/*
The following makes a procedure that creates a 'tree', or at least a trunk and a few branches.
This is done using techniques that should be familiar to you, and using the 'turtle' commands
to draw
*/
 The primitive tree
/*
You can create a procedure with the same arguments as the one above, but using recursion.
By using a recursive procedure you can create branches, but each of the branches can also have branches, and
each of the branches' branches can have branches....etc. Recursive procedures are procedures that are
self-referential, meaning the procedure calls itself.
*/
 A simple recursive tree
//You can now begin to refine your procedure so you have more control over the output of the tree.
//In this step we will add another variable to the procedure definition so that the angle between branch
//and trunk will be variable. We will call this angle the 'spread'.
//add another argument, $spread, to the end of the procedure definition
global proc tree(float $length,float $x,float $y,float $z,float $angle,float $spread){
//create a turtle to use to draw a trunk
$tree = aa_turtle_newturtle("LINE");
//set its starting position
aa_turtle_setPosition($tree,<<$x,$y,$z>>);
//set its initial orientation
aa_turtle_turn($tree,$angle,0);
//move to draw a line
aa_turtle_move($tree,$length);
//get the position
$position = aa_turtle_getPosition($tree);
if($length > 1){
//use the same call to the tree procedure as before, but adjust the 'angle' by adding the 'spread'.
//also, don't forget to include the 'spread itself as the 6th argument.
tree(($length/2),$position[0],$position[1],$position[2],($angle-$spread),$spread);
tree(($length/2),$position[0],$position[1],$position[2],($angle+$spread),$spread);
tree(($length/2),$position[0],$position[1],$position[2],$angle,$spread);
}
}
//test it out
tree(10,0,0,0,0,11);
tree(20,0,0,0,0,20);
tree(20,0,0,0,0,120);
/*
To give a little more control over the morphology of your tree, you can add another variable, we'll call it
$drift. We will use this to have the angle of the branch change over each step of the growth. Each time the
tree branches we will add $drift to the $angle so the $angle at which the branches are oriented will slowly
'bend'. This is just oneexample of how you can start to have the algorithm for growth change for each step
of the growth/recursion.
*/
 A tree with 'drift'
/*
So far we have been doing all of our 'trees' in the xz plane, to have it draw in three dimensions is easy, we
just need to have the 'turtle' command turn in the altitude as well as the azimuth. We can use the same angle
for altitude as we do for azimuth
*/
 Starting into 3 dimensions
/*
We can improve our 3d tree growth by making the 'altitude' angle different than the $angle we are already using.
Also, we can have the tree branch in 4 directions off of each trunk (one for each of the possible combinations of
postive and negative altitude and azimuth). To have more branching we just need to add more calls to the 'tree'
procedure within itself
*/
 A fully 3D tree
/*
To add 'leaves' on the ends of all our branches we can add an 'else' clause to the procedure. Until now, if the $length
is greater than 1 the tree procedure would call itself, if it is less than one, it stopped. Now, add an 'else' clause so
that when $lenght is less than one (which is the end of a branch) the procedure will create a polyCube
*/
 A tree with 'leaves'
/*
Recursive procedures are no different than any other procedures, they can all other procedures from within them. Instead
of making a 'polyCube' you can make a procedure called 'leaf' (that makes a cube) and put a call to the 'leaf' procedure
inside of the 'tree'.
*/
global proc leaf(float $x,float $y, float $z, float $scale){
polyCube;
scale $scale $scale $scale;
move $x $y $z;
}
global proc tree(float $length,float $x,float $y,float $z,float $angle,float $altitude,float $spread,float $drift){
$tree = aa_turtle_newturtle("LINE");
aa_turtle_setPosition($tree,<<$x,$y,$z>>);
aa_turtle_turn($tree,$angle,$altitude);
aa_turtle_move($tree,$length);
$position = aa_turtle_getPosition($tree);
$angle = $angle + $drift;
if($length > 1){
tree(($length/2),$position[0],$position[1],$position[2],($angle-$spread),($altitude-$spread),$spread,$drift);
tree(($length/2),$position[0],$position[1],$position[2],($angle+$spread),($altitude+$spread),$spread,$drift);
tree(($length/2),$position[0],$position[1],$position[2],($angle-$spread),($altitude-$spread * -1),$spread,$drift);
tree(($length/2),$position[0],$position[1],$position[2],($angle+$spread),($altitude+$spread * -1),$spread,$drift);
tree(($length/2),$position[0],$position[1],$position[2],$angle,$altitude,$spread,$drift);
}else{
//make a leaf
leaf($position[0],$position[1],$position[2],.3);
}
}
//give it a try
tree(20,0,0,0,0,78,60,19);
/*
As the tree 'grows' you can track its recursions, and use that to create and shape objects as it grows. To do this add an
argument called '$iteration' to your procedure. This is a value that will start at 0 and be incremented with each
step of the growth.
You can use the iteration to shape/scale objects as you place them. In this example I took the 'leaf' call and moved it so
that a leaf will be created at the end of each trunk as well as each branch. I made the scale of the leaf be the inverse
(1 divide by) of the iteration. What will happen is each iteration will have progressively smaller 'leaf' or block at
the end of it.
*/
 Using the 'iterations'  Using global variables
//try redefining the leaf so that the color is darker with each iteration.
global proc leaf(float $x,float $y, float $z, float $scale){
$leaf = `polyCube`;
scale $scale $scale $scale;
move $x $y $z;
aa_setColor($leaf[0],"lambert",0,$scale,0,.5);
}
tree(10,0,0,0,0,78,60,19,0);
/*
You can also keep track of each branch that is created so you have a overall count of branches. To do this you need
to use a new variable definition in MEL, a 'global' variable. So far all of the variables we have been using in MEL
procedures have been isolated to the scope of the procedure. This means, if you have the variable '$length' being
used inside of a procedure, it only has value inside of the procedure, if you refer to $length outside of the
procedure it will not be equal to anything. To keep a running count of how many branches we have we need to use
a variable that will transcend the boundaries of the procedure, this is called a 'global' variable. Global
variables have the same value inside and outside of a procedure. In our case we will make a variable called
'$counter' and define it as 'global'. This variable will be shared by every call to the 'tree' procedure and
can be incremented to keep track of our count of branches.
/*
//create a variable counter, outside of the procedure 'tree'
int $counter = 0;
global proc tree(float $length,float $x,float $y,float $z,float $angle,float $altitude,float $spread,float $drift){
//import the variable $counter as a global variable.
global int $counter;
//increment the counter
$counter++;
//print its value (plus a carriage return)
print($counter + "\\n");
$tree = aa_turtle_newturtle("LINE");
aa_turtle_setPosition($tree,<<$x,$y,$z>>);
aa_turtle_turn($tree,$angle,$altitude);
aa_turtle_move($tree,$length);
$position = aa_turtle_getPosition($tree);
$angle = $angle + $drift;
leaf($position[0],$position[1],$position[2],.1);
if($length > 1){
tree(($length/2),$position[0],$position[1],$position[2],($angle-$spread),($altitude-$spread),$spread,$drift);
tree(($length/2),$position[0],$position[1],$position[2],($angle+$spread),($altitude+$spread),$spread,$drift);
tree(($length/2),$position[0],$position[1],$position[2],($angle-$spread),($altitude-$spread * -1),$spread,$drift);
tree(($length/2),$position[0],$position[1],$position[2],($angle+$spread),($altitude+$spread * -1),$spread,$drift);
tree(($length/2),$position[0],$position[1],$position[2],$angle,$altitude,$spread,$drift);
}
}
/*
If we want, we can also redefine the 'leaf' procedure to make a text label that puts the $counter lable on each branch
instead of a cube. This can be done with the 'textCurves' command.
*/
//redefine a leaf
global proc leaf(float $x,float $y, float $z, float $scale){
global int $counter;
textCurves -ch 0 -f "Arial|h-08|w400|c0" -t $counter;
scale $scale $scale $scale;
rotate 90 0 0;
move $x $y $z;
}
//try it out
tree(10,0,0,0,0,78,60,19);
|
class_06
|
