| Making MEL Procedures:
This tutorial covers the basics of making your own MEL procedures, MEL
procedures allow you to define your own language in MEL, creating your
own commands instead of using the built in commands like 'move', 'rotate'
and 'polyCube'. The power of being able to make your own procedures is
the ablity to create a simple interface to a vast array of functionality
and decision making. MEL procedures do this by allowing you to take a
series of complicated commands, group them together and give them a name.
In this simple tutorial we are going to create a new MEL procedures called
'stair', this procedure will perform all of the calculations necessary
to create a set of stairs based on height, number of steps and starting
location. Once you have made this function, you can save it to a file
and source it whenever you start Maya. If you do that, you can use it
over and over again, wherever you need a staircase.
Step 1
Making stairs with a procedure |
The first step in the tutorial is just to make a basic looping script
that will create a set of stairs. After you have made this, you can encapsulate
it in a MEL procedure that gives it a name. The script uses a 'while'
loop, to reptetively call the 'polyCube' command and the 'move' command,
creating 10 steps and moving them into a stair configuration. If you cut-and-paste
the following code into your MEL scripting window you should get something
resembling the image on the right.
$i = 0;
//loop through while $i is less that ten and create some cubes
while($i < 10){
polyCube;
scale 10 .1 1;
move 0 $i $i;
$i++;
}
Step 2
The second step in this step is to take the loop from step 1 and wrap
it inside of a procedure. To create a procedure, just surround the loop
with a procedure declaration. Place the statement 'proc stair(){' at the
beginning and '}' at the end. This defines it as a procedure named 'stair()'
(the parthesis will be explained later in the tutorial). When you copy-and-paste
this script into the MEL scripting window, nothing will happen on the
screen. However, once you have cut-and-paste the script, you will have
a new function called 'stair()' that you can execute. Once you copy-and-paste,
type 'stair();' into the MEL scripting window and it will create a stair.
proc stair(){
//create a function called 'stair()' that will perform the loop
//loop through while $i is less that ten and create some cubes
$i = 0;
while($i < 10){
polyCube;
scale 10 .1 1;
move 0 $i $i;
$i++;
}
}
If you add the word 'global' before your procedure declaration, then if
you save it to a file you can use the files as a function library. Add
a 'global' declararion before the 'proc' statement and save your script
as a text-only file called 'stair.mel'. To load the stair function at
any time, choose 'Source Script' from the 'File' menu in the MEL Scripting
window and select you file.
Step 3
Now that you have defined your 'stair' procedure, you can refine its definition
by providing for 'arguments'. 'Arguments' allow you to feed
information or varaibles into your function so that it can have different
behaviors. These arguments are the variables that come between the parenthesis
when you call a procedure.
In this step you will redefine your function so that the number of stairs
is variable. To do this change the function declaration to be 'global
proc stair(float $numberofsteps)', this tells the function that is will
receive a variable (which will be a floating point decimal) and that number
will define how many steps should be in the stairs. Use the '$numberofsteps"
variable inside of the function to limit the iterations of the loop.
global proc stair(float $numberofsteps){
//create a function called 'stair()' that will perform the loop
//this function will take the argument 'numberofsteps'
//loop through while $i is less that $numberofsteps and create some cubes
$i = 0;
//change the < to be less that $numberofsteps
while($i < $numberofsteps){
polyCube;
scale 10 .1 1;
move 0 $i $i;
$i++;
}
}
Arguments have to be defined by naming the variable, and defining its
type. In the example above we define the variable as being '$numberofsteps'
and we can use that variable inside of the procedure by referring to its
name. The variable name is preceded by its type definition, there are
many different type definitions in MEL, but the 3 most common are:
float - Floating point number. This is a decimal number, like 2.3457
or 0.0000045.
int - Integer. This is a whole number, like 2 or 345839.
If you define a definition as an 'int' and pass the procedure decimal
number, it will automatically be rounded down to the closest whole number.
For example. If you have a function defined as 'proc box(int $size)' and
you call it with the following syntax 'proc box(4.56342)' the $size will
be rounded down to 4 inside of the procedure.
string - Text string. This is a word or series of words, like "Hello"
or "My name is ....".
Once you have cut-and-pasted the code into the MEL scripting window, you
will have to call the stair command with a number as an argument, try
'stair(20);' and it will make 20 steps, 'stair(40);' will make 40 steps.
Step 4
The stair procedure can be further refined by adding additional arguments.
In this step you will add arguments of '$locationx', '$locationy' and
'$locationz'. These additional arguments will be used to position the
staircase anywhere in space (instead of always being at 0,0,0), making
the 'stair' procedure much more self-contained and usable in more situations.
global proc stair(float $numberofsteps,float $locationx,float $locationy,float
$locationz){
//make function called 'stair' that takes arguments of 'numberofsteps',
plus x,y,z coordinates of a starting point.
//loop through while $i is less than the number of steps.
$i = 0;
while($i < $numberofsteps){
polyCube;
scale 10 .1 1;
//use the arguments of locationx, locationy and locationz to position
the steps.
$x = $locationx; // the x position
$y = $locationy + $i; // the y position is the starting y position, plus
and offset for each step
$z = $locationz + $i; // the z position is the starting z position, plus
and offset for each step
//move the step to x,y,z
move $x $y $z;
$i++;
}
}
When you call the stair command now in the MEL scripting window you will
have to give it 4 arguments, such as 'stair(20,10,10,10)', which would
make a staircase with 20 steps at location 10,10,10.
Step 6
The last step is to add some more intelligence to your stair function.
Aadd the argument of '$height' to the function and use the height and
the number of steps to determine the spacing between each individual step.
Once you have done this you can make stairs anywhere you need and you
only have to know the number of steps, height and location.
global proc stair(float $numberofsteps,float $height, float $locationx,
float $locationy, float $locationz){
//add and argument of 'height' to the stair function.
//use the 'height' variable to calculate the step riser height. The riser
height is equal to
//the overall height divided by the number of steps.
float $step = $height / $numberofsteps;
$i = 0;
while($i < $numberofsteps){
polyCube;
scale 10 .1 1;
$x = $locationx;
//use the 'step variable as a multiplier so that each step is based on
the riser height
$y = $locationy + ($i * $step);
$z = $locationz + $i;
move $x $y $z;
$i++;
}
}
One of the real values of procedures is to provide a simple interface
ot complex functionality and calculations like this stair. As a modeler,
you do not want to have to calculate the stair spacing and other things
to create a stair, all you know is how big you want the stairs and where
they should be - the procedure should handle the rest. You can further
refine your procedure to calculate for proper landings, railings and ballustrades.
Remember, save your stair procedure to a file and you can load it by selecting
'Source Script' each time you start Maya. If you quit Maya and restart,
your custom function will not be available until you source the file again.
|
