korydondzila/gist:d7627149c196d267f872

## gistfile1.tcl
//////////////////////////////////////////////////////////////////////////
///                                                                    ///
/// SCRIPT:           kdGrassV0.1.mel - MEL Script                     ///
///                                                                    ///
/// AUTHOR:           Kory Dondzila - kory@korydondzila.com            ///
///                   www.korydondzila.com                             ///
///                                                                    ///
/// DESCRIPTION:           Populates a mesh named ground with grass.   ///
///                   Each grass mesh is attached to a vertex and has  ///
///                   has a joint chain and an expression.  When the   ///
///                   When the vertices on the mesh are changed the    ///
///                   grass adjusts which way it faces and adjusts its ///
///                   bend/curl.                                       ///
///                                                                    ///
/// USAGE:            Source script then run: grass( 1, 1 );           ///
///                                                                    ///
/// EDITS TO DO:          Add a conditional to limit the bends, even   ///
///                   more, when the y normal is close to 1 or -1.     ///
///                       Fix a few of the loops to make them more     ///
///                   intuitive.                                       ///
///                       Edit White space.                            ///
///                                                                    ///
/// THINGS TO ADD:        Menu, option for using NURBS, option for     ///
///                   only using selected vertices, option to use a    ///
///                   selected mesh as the grass, option to not use    ///
///                   joints and only populate.                        ///
///                       A system for using curves and not joints.    ///
///                                                                    ///
/// VERSIONS:         0.1 - Oct 12, 2011 - Initial Prototype           ///
///                                                                    ///
//////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////
////////////////// Global Procedure: grass /////////////////
////////////////////////////////////////////////////////////
//                                                        //
// Main call procedure, source the script then run this.  //
// Include two float values for the maximum bend in the   //
// grass and the minimum, this acts as a range for the    //
// bend.                                                  //
//                                                        //
// Default: grass( 1, 1 );                                //
// Zero ( 0 ), cannot be used for the bend minimum.       //
//                                                        //
// NOTE:     The UVs of the ground mesh need to be layed  //
//       out, before running the script, this doesn't     //
//       need to be done for the primitive meshes.        //
//       Transforms need to be frozen to update the       //
//       positions of the vertices, do this before        //
//       applying any animation to the mesh.              //
//       Animation, lighting and anything else should be  //
//       before running this script, as it can be         //
//       PROCESSOR HEAVY.  Depending on the number of     //
//       vertices in the mesh.                            //

global proc grass(float $bendMax, float $bendMin)
{
    // Sets some initial strings to be used in the
    // procedures.
    string $ground = "ground";
    string $grass = "grass";
    string $grassTexture;
    string $grassS = "grassShader";
    string $grassSG = ($grassS+"SG");
    string $joints[];
    string $grassGrps = "grass_grps";

    // Checks if bendMin is 0.
    if ($bendMin == 0)
    {
        error "Minimum bend cannot equal zero, cannot divide by zero.\n";
    }

    // Runs procedures, some return values to be used later.
    groundCheck($ground);
    $grassTexture = grassTexturePath();
    createGrass($grass, $grassS, $grassSG, $grassTexture);
    $joints = createJoints($grass);
    populateGrass($ground, $grass, $joints, $grassGrps, $bendMax, $bendMin);

    // After everything else is done, groups the grass and
    // ground under world and turns off inherits transform
    // on the grass grp.
    group -n "world" $ground $grassGrps;
    setAttr ($grassGrps+".inheritsTransform") 0;
}

////////////////////////////////////////////////////////////
////////////////// Procedure: groundCheck //////////////////
////////////////////////////////////////////////////////////
//                                                        //
//     This procedure checks to see if a mesh named       //
// ground exists.  If it does it freezes the              //
// transformations, this is to update the uv.  If not     //
// then the script errors out and asks for a mesh named   //
// ground.                                                //

proc groundCheck(string $ground)
{
    if (`objExists $ground`)
    {
        print "Ground exists.\n";
    }else{
        error "No ground exists.  Create a mesh named ground and try again.\n";
    }
}

////////////////////////////////////////////////////////////
//////////////// Procedure: grassTexturePath ///////////////
////////////////////////////////////////////////////////////
//                                                        //
//     This procedures allows the user to set a texture   //
// to be applied to the grass.                            //

proc string grassTexturePath()
{
    print "Select a texture for the grass.\n";

    // This string is for the file filters.
    string $filters = "All Files (*.*);;JPEG (*.jpg);;Targa (*.tga);;Tiff (*.tiff);;IFF (*.iff);;GIF (*.gif);;Bitmap (*.bmp)";

    // Queries the current set workspace/project directory path.
    string $dir = `workspace -q -dir`;

    // Opens the file dialog box, if nothing is selected or
    // the selection is canceled then the user is asked if
    // he/she wants to continue without a texture, if not
    // then the script errors out to be reran.
    string $grassTexture[] = `fileDialog2 -ds 2 -cap "Open Texture" -dir $dir -ff $filters -sff "All Files" -fm 1`;

    string $confirm;
    if ($grassTexture[0] == "")
    {
        $confirm = `confirmDialog -t "No Texture" -m "No texture was selected.  Are you sure you want to\n continue without a texture?" -ma "center" -b "Yes" -b "No" -db "Yes" -cb "No" -ds "No" -icn "question"`;
    }

    if ($confirm == "No")
    {
        error "Restart the script and choose a texture.\n";
    }

    // Returns the file path for the texture.
    return $grassTexture[0];
}

////////////////////////////////////////////////////////////
////////////////// Procedure: createGrass //////////////////
////////////////////////////////////////////////////////////
//                                                        //
//     This procedure creates the master grass geometry   //
// that the attached grass are copied from.  The UVs are  //
// adjusted, a new blinn shading network is created and   //
// it attaches the chosen texture to the grass.           //

proc createGrass(string $grass, string $grassS, string $grassSG, string $grassTexture)
{
    // Creates the master grass mesh.
    polyPlane -w 1 -h 8 -sx 1 -sy 8 -ax 0 0 1 -cuv 2 -ch 1 -n $grass;
    xform -pivots 0 -4 0;
    move -rpr 0 0 0;
    select -r grass.e[3] grass.e[6] grass.e[9] grass.e[12] grass.e[15] grass.e[18] grass.e[21] grass.e[24] ;
    scale -x 0.95404;
    select -d grass.e[3] ;
    scale -x 0.935408;
    select -d grass.e[6] ;
    scale -x 0.95808;
    select -d grass.e[9] ;
    scale -x 0.891177;
    select -d grass.e[12] ;
    scale -x 0.902911;
    select -d grass.e[15] ;
    scale -x 0.824543;
    select -d grass.e[18] ;
    scale -x 0.780672;
    scale -x 0.949012;
    select -d grass.e[21] ;
    scale -x 0.456029;
    polyCollapseEdge -ch 1 grass.e[24];
    select -r grass.e[21] ;
    scale -x 0.778965;
    select -r grass.e[18] ;
    scale -x 0.908768;
    select -r grass.e[15] ;
    scale -x 0.926951;
    select -r grass.e[12] ;
    scale -x 0.944705;
    select -r grass.e[9] ;
    scale -x 0.94611;
    select -r grass.e[6] ;
    scale -x 0.9656;
    select -r grass.e[6] ;
    scale -x 1.033333;
    select -r grass.e[12] ;
    scale -x 1;
    select -cl;

    // Projects the UVs and adjusts them.
    polyAutoProjection -lm 0 -pb 0 -ibd 1 -cm 0 -l 2 -sc 1 -o 1 -p 6 -ps 0.2 -ws 0 grass.f[0:7];
    select -r grass.map[0:16] ;
    setAttr "grassShape.uvPivot" -type double2 .5 0.5 ;
    select -r grass.map[0:16] ;
    setAttr "grassShape.uvPivot" -type double2 0.498274 0.5 ;
    polyEditUV -u 0.435774 -v 0 ;
    polyEditUV -pu 0.498274 -pv 0.5 -su 0.551282 -sv 1 ;
    select -r grass.map[16] ;
    setAttr "grassShape.uvPivot" -type double2 0.498274 0.922395 ;
    polyEditUV -u 0 -v -0.075613 ;
    select -r grassShape.map[14:15] ;
    polyEditUV -pu 0.498274 -pv 0.873506 -su 0.75641 -sv 1 ;

    // Deletes 4 edges to drop the poly count to 4.
    polyDelEdge -cv true -ch 1 grass.e[3] grass.e[9] grass.e[15] grass.e[21];

    // Creates a new blinn shader and network.
    shadingNode -asShader blinn -n $grassS;
    sets -renderable true -noSurfaceShader true -empty -name $grassSG;
    connectAttr -f grassShader.outColor grassShaderSG.surfaceShader;
    select -r $grass;
    hyperShade -a grassShader;

    // Sets attributes for the new shader.
    setAttr "grassShader.diffuse" 0.642;
    setAttr "grassShader.eccentricity" 0.163;
    setAttr "grassShader.specularRollOff" 0.276;
    setAttr "grassShader.specularColor" -type double3 1 0.997 0.863 ;

    // Creates a file node and place2dTexture node and
    // connects their attributes.
    shadingNode -asTexture file -n grassFile;
    shadingNode -asUtility place2dTexture -n grassPlace2dTexture;
    connectAttr -f ("grassPlace2dTexture.coverage") ("grassFile.coverage");
    connectAttr -f ("grassPlace2dTexture.translateFrame") ("grassFile.translateFrame");
    connectAttr -f ("grassPlace2dTexture.rotateFrame") ("grassFile.rotateFrame");
    connectAttr -f ("grassPlace2dTexture.mirrorU") ("grassFile.mirrorU");
    connectAttr -f ("grassPlace2dTexture.mirrorV") ("grassFile.mirrorV");
    connectAttr -f ("grassPlace2dTexture.stagger") ("grassFile.stagger");
    connectAttr -f ("grassPlace2dTexture.wrapU") ("grassFile.wrapU");
    connectAttr -f ("grassPlace2dTexture.wrapV") ("grassFile.wrapV");
    connectAttr -f ("grassPlace2dTexture.repeatUV") ("grassFile.repeatUV");
    connectAttr -f ("grassPlace2dTexture.offset") ("grassFile.offset");
    connectAttr -f ("grassPlace2dTexture.rotateUV") ("grassFile.rotateUV");
    connectAttr -f ("grassPlace2dTexture.noiseUV") ("grassFile.noiseUV");
    connectAttr -f ("grassPlace2dTexture.vertexUvOne") ("grassFile.vertexUvOne");
    connectAttr -f ("grassPlace2dTexture.vertexUvTwo") ("grassFile.vertexUvTwo");
    connectAttr -f ("grassPlace2dTexture.vertexUvThree") ("grassFile.vertexUvThree");
    connectAttr -f ("grassPlace2dTexture.vertexCameraOne") ("grassFile.vertexCameraOne");
    connectAttr ("grassPlace2dTexture.outUV") ("grassFile.uv");
    connectAttr ("grassPlace2dTexture.outUvFilterSize") ("grassFile.uvFilterSize");
    defaultNavigation -force true -connectToExisting -source ("grassFile") -destination grassShader.color;

    // Sets the file texture to the selected image/texture.
    setAttr grassFile.fileTextureName -typ "string" $grassTexture;

    // Freezes the transforms and deletes the history on
    // the master grass.
    makeIdentity -apply true -t 1 -r 1 -s 1 -n 0 $grass;
    delete -ch grass;
}

////////////////////////////////////////////////////////////
////////////////// Procedure: createJoints /////////////////
////////////////////////////////////////////////////////////
//                                                        //
//     This procedure creates the master joints that the  //
// master grass is then bound to.                         //

proc string[] createJoints(string $grass)
{
    // Gets the bounding box of the master grass and
    // positions the first joint to the minimumY and the
    // end joint to the maximumY.
    float $grassBox[] = `exactWorldBoundingBox $grass`;
    string $selJnt[];
    $selJnt[0] = `joint -p 0 $grassBox[1] 0 -n grass_1_jnt -rad 0.5`;
    $selJnt[1] = `joint -p 0 $grassBox[4] 0 -n grass_end_jnt -rad 0.5`;

    // Gets the absolute positions of the new joints.
    vector $sjPos = (`joint -q -p $selJnt[0]`);
    vector $ejPos = (`joint -q -p $selJnt[1]`);
    string $crJnt[];

    // Clears the selection and sets $seg to 4.
    select -cl;
    int $seg=4;

    // For loop creates joints in the proper position
    // and assigns them to an array and parents the first
    // created joint to the start joint and parents the
    // end joint to the last created joint.
    for ($i=$seg; $i>1; $i--)
    {
        // This gets the value to use in the $crJnt array.
        // Then creates a new joint based on the positions
        // of the start and end joint and which segment joint
        // is being created.
        int $x = abs ($i-$seg);
        $crJnt[$x] = `joint -p ((((($sjPos.x)-($ejPos.x))/$seg)*($i-1))+($ejPos.x)) ((((($sjPos.y)-($ejPos.y))/$seg)*($i-1))+($ejPos.y)) ((((($sjPos.z)-($ejPos.z))/$seg)*($i-1))+($ejPos.z)) -n ("grass_"+($x+2)+"_jnt") -rad 0.5`;

        // Conditional checks if first segment joint is
        // being created and if true it is parented to
        // the start joint.  Then checks if the last
        // segment joint is being created and if true
        // the end joint gets parented to the last segment
        // joint.
        if ($x==0)
        {
            parent $crJnt[$x] $selJnt[0];
        }else if (($x+1)==($seg-1)) {
            parent $selJnt[1] $crJnt[$x];
        }
    }

    // Orients the joints to XYZ with the secondary axis
    // pointing in -z.
    joint -e -oj xyz -secondaryAxisOrient zdown -ch -zso $selJnt[0];

    // Binds the master grass mesh to the master joints.
    bindSkin -tsb $selJnt[0] $crJnt[0] $crJnt[1] $crJnt[2] $grass;

    // Puts the master start joint and the first 3 segment
    // joints into an array then returns the array.
    string $joints[] = {$selJnt[0], $crJnt[0], $crJnt[1], $crJnt[2]};
    return $joints;
}

////////////////////////////////////////////////////////////
///////////////// Procedure: populateGrass /////////////////
////////////////////////////////////////////////////////////
//                                                        //
//     This procedure moves the master grass to a vertex  //
// on the ground mesh and bends it based on the inputed   //
// bendMax, bendMin and the y normal of the vertex.       //
// the master grass, mesh and joints, are duplicated      //
// and the duplicated mesh is bound to the duplicated     //
// joints.  The new start joint is then normalConstrained //
// to the ground mesh.  A transform node is created and   //
// pointOnPolyConstrained to the ground mesh, the new     //
// joint chain is then parented to the transform node.    //
// The transform node and the grass mesh are then grouped //
// together and that group is parented to a main group    //
// for all grass groups.  An expression is then created   //
// for the grass joints so that their bend is updated     //
// when the normal of the ground vertex is changed.       //
// This is done for all vertices on the ground mesh.      //

proc populateGrass(string $ground, string $grass, string $joints[], string $grassGrps, float $bendMax, float $bendMin)
{
    // Bend min is inversed so that a smaller given number
    // brings the minimum bend closer to zero.
    $bendMin = 1/$bendMin;

    // Creates a closestPointOnMesh node and the outMesh
    // attr from the ground is connected to the inMesh
    // and the translate of the master start joint is
    // connected to the inPosition.
    string $cpom = `createNode closestPointOnMesh -ss`;
    connectAttr ($ground+"Shape.outMesh") ($cpom+".inMesh");
    connectAttr ($joints[0]+".translate") ($cpom+".inPosition");

    // Selects all vertices of the ground mesh and puts
    // them into an array, then gets teh size of that array.
    // The selection is cleared.
    select -r "ground.vtx[*]";
    string $groundVtx[] = `ls -sl -fl`;
    float $groundSize = size($groundVtx);
    select -cl;

    // A group is created, this is for all the grass groups.
    group -n $grassGrps -em;

    string $grassJnt[];

    // This Loops does what is specified in the procedure
    // description.  It loops for all vertices in the
    // ground mesh.
    for ($s=0; $s<$groundSize; $s++)
    {
        // Queries the normals of the current vertex.
        float $vtxNorm[] = `polyNormalPerVertex -q -xyz $groundVtx[$s]`;

        // If the vertex is between -0.5 and 0.5 it sets
        // is to -.5 or 0.5 respectively.  This prevents
        // the grass from bending in on itself, but that
        // can be changed if the bendMax is changed.
        if (($vtxNorm[1]<0.5)&&($vtxNorm[1]>(-0.5)))
        {
            if ($vtxNorm[1]<0)
            {
            $vtxNorm[1] = -0.5;
            }else{
            $vtxNorm[1] = 0.5;
            }
        }

        // This sets the randMin and randMax that the
        // master joints use to randomize their rotations.
        float $randMin = (-10*$bendMax)*(pow((1/$vtxNorm[1]),2));
        float $randMax = $randMin/(3*$bendMin);

        // This randomly rotates the three master segment
        // joints.  To also rotate the start joint change
        // $i=1 to $i=0.
        for ($i=1; $i<4; $i++)
        {
            setAttr ($joints[$i]+".rz") (rand($randMin,$randMax));
        }

        // This queries the absolute translation of the
        // current vertex and moves the master grass to
        // that point.
        float $posVtx[] = `xform -q -t $groundVtx[$s]`;
        setAttr ($joints[0]+".translate") $posVtx[0] $posVtx[1] $posVtx[2];

        // The master grass mesh and joints are duplicated
        // and the dupicate segment joints are put into an
        // array.  This array is used in the creation of
        // the expression.
        string $newGrass[] = `duplicate -rc $grass $joints[0]`;
        for ($i=0; $i<3; $i++)
        {
            $grassJnt[(($s*3)+$i)] = $newGrass[(2+$i)];
        }

        // The new mesh is bound to the new joints, the new
        // start joint is normalConstrained to the ground
        // mesh and its pivot is set.
        bindSkin -tsb $newGrass[1] $newGrass[2] $newGrass[3] $newGrass[4] $newGrass[0];
        string $normConst[] = `normalConstraint $ground $newGrass[1]`;
        xform -piv $posVtx[0] $posVtx[1] $posVtx[2] $newGrass[1];

        // An empty node is created and moved to the current
        // vertex, its transforms are then frozen.
        string $null = `group -em -n ($newGrass[1]+"_grp")`;
        setAttr ($null+".translate") $posVtx[0] $posVtx[1] $posVtx[2];
        makeIdentity -a 1 -t 1 -r 1 -s 1 $null;

        // The empty node is pointOnPolyConstrained to the ground
        // mesh and the constraint's U and V parameter are set
        // to the current vertex, this information is received from
        // the closestPointOnMesh node.  The new grass start joint
        // is parented to the empty node.
        string $popc[] = `pointOnPolyConstraint $ground $null`;
        float $pU = `getAttr ($cpom+".parameterU")`;
        float $pV = `getAttr ($cpom+".parameterV")`;
        setAttr ($popc[0]+".groundU0") $pU;
        setAttr ($popc[0]+".groundV0") $pV;
        parent $newGrass[1] $null;

        // Groups the new grass mesh and transform node, with
        // the joints, together, then parents this group node
        // to the grass groups node.  This it to organize the
        // outliner.
        string $grassGroup = `group -n ($newGrass[0]+"_grp") $newGrass[0] $null`;
        parent $grassGroup $grassGrps;

        // Expression is created to control the bend in the grass
        // when the y normal of the vertex, the new grass is on,
        // is changed.  This expression is almost the same that
        // was used earlier in the script to set the initial
        // bends.
        expression -n ("grass"+($s+1)+"_expr") -s
            (
            "float $vtxNorm[] = `polyNormalPerVertex -q -xyz "+$groundVtx[$s]+"`;\n"+
            "float $vtxNormPast;\n"+
            "float $yNorm;\n\n"+

            "if ($vtxNorm[1] != $vtxNormPast)\n"+
            "{\n"+
            "$yNorm = $vtxNorm[1];\n"+
            "    if (($yNorm<0.5)&&($yNorm>(-0.5)))\n"+
            "    {\n"+
            "        if ($yNorm<0)\n"+
            "        {\n"+
            "            $yNorm = -0.5;\n"+
            "        }else{\n"+
            "            $yNorm = 0.5;\n"+
            "        }\n"+
            "    }\n"+
            "    float $randMin = (-10*"+$bendMax+")*(pow((1/$yNorm),2));\n"+
            "    float $randMax = $randMin/(3*"+$bendMin+");\n\n"+

            "    "+$grassJnt[($s*3)]+".rz = (rand($randMin,$randMax));\n"+
            "    "+$grassJnt[(($s*3)+1)]+".rz = (rand($randMin,$randMax));\n"+
            "    "+$grassJnt[(($s*3)+2)]+".rz = (rand($randMin,$randMax));\n"+
            "}\n\n"+

            "$vtxNormPast = $vtxNorm[1];");
    }

    // After all new grass is created the master grass, joints and
    // closestPointOnMesh node are deleted.
    delete $grass $joints[0] $cpom;
}
	//////////////////////////////////////////////////////////////////////////
	/// ///
	/// SCRIPT: kdGrassV0.1.mel - MEL Script ///
	/// ///
	/// AUTHOR: Kory Dondzila - kory@korydondzila.com ///
	/// www.korydondzila.com ///
	/// ///
	/// DESCRIPTION: Populates a mesh named ground with grass. ///
	/// Each grass mesh is attached to a vertex and has ///
	/// has a joint chain and an expression. When the ///
	/// When the vertices on the mesh are changed the ///
	/// grass adjusts which way it faces and adjusts its ///
	/// bend/curl. ///
	/// ///
	/// USAGE: Source script then run: grass( 1, 1 ); ///
	/// ///
	/// EDITS TO DO: Add a conditional to limit the bends, even ///
	/// more, when the y normal is close to 1 or -1. ///
	/// Fix a few of the loops to make them more ///
	/// intuitive. ///
	/// Edit White space. ///
	/// ///
	/// THINGS TO ADD: Menu, option for using NURBS, option for ///
	/// only using selected vertices, option to use a ///
	/// selected mesh as the grass, option to not use ///
	/// joints and only populate. ///
	/// A system for using curves and not joints. ///
	/// ///
	/// VERSIONS: 0.1 - Oct 12, 2011 - Initial Prototype ///
	/// ///
	//////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////////////////////////
	////////////////// Global Procedure: grass /////////////////
	////////////////////////////////////////////////////////////
	// //
	// Main call procedure, source the script then run this. //
	// Include two float values for the maximum bend in the //
	// grass and the minimum, this acts as a range for the //
	// bend. //
	// //
	// Default: grass( 1, 1 ); //
	// Zero ( 0 ), cannot be used for the bend minimum. //
	// //
	// NOTE: The UVs of the ground mesh need to be layed //
	// out, before running the script, this doesn't //
	// need to be done for the primitive meshes. //
	// Transforms need to be frozen to update the //
	// positions of the vertices, do this before //
	// applying any animation to the mesh. //
	// Animation, lighting and anything else should be //
	// before running this script, as it can be //
	// PROCESSOR HEAVY. Depending on the number of //
	// vertices in the mesh. //

	global proc grass(float $bendMax, float $bendMin)
	{
	// Sets some initial strings to be used in the
	// procedures.
	string $ground = "ground";
	string $grass = "grass";
	string $grassTexture;
	string $grassS = "grassShader";
	string $grassSG = ($grassS+"SG");
	string $joints[];
	string $grassGrps = "grass_grps";

	// Checks if bendMin is 0.
	if ($bendMin == 0)
	{
	error "Minimum bend cannot equal zero, cannot divide by zero.\n";
	}

	// Runs procedures, some return values to be used later.
	groundCheck($ground);
	$grassTexture = grassTexturePath();
	createGrass($grass, $grassS, $grassSG, $grassTexture);
	$joints = createJoints($grass);
	populateGrass($ground, $grass, $joints, $grassGrps, $bendMax, $bendMin);

	// After everything else is done, groups the grass and
	// ground under world and turns off inherits transform
	// on the grass grp.
	group -n "world" $ground $grassGrps;
	setAttr ($grassGrps+".inheritsTransform") 0;
	}

	////////////////////////////////////////////////////////////
	////////////////// Procedure: groundCheck //////////////////
	////////////////////////////////////////////////////////////
	// //
	// This procedure checks to see if a mesh named //
	// ground exists. If it does it freezes the //
	// transformations, this is to update the uv. If not //
	// then the script errors out and asks for a mesh named //
	// ground. //

	proc groundCheck(string $ground)
	{
	if (`objExists $ground`)
	{
	print "Ground exists.\n";
	}else{
	error "No ground exists. Create a mesh named ground and try again.\n";
	}
	}

	////////////////////////////////////////////////////////////
	//////////////// Procedure: grassTexturePath ///////////////
	////////////////////////////////////////////////////////////
	// //
	// This procedures allows the user to set a texture //
	// to be applied to the grass. //

	proc string grassTexturePath()
	{
	print "Select a texture for the grass.\n";

	// This string is for the file filters.
	string $filters = "All Files (.);;JPEG (.jpg);;Targa (.tga);;Tiff (.tiff);;IFF (.iff);;GIF (.gif);;Bitmap (.bmp)";

	// Queries the current set workspace/project directory path.
	string $dir = `workspace -q -dir`;

	// Opens the file dialog box, if nothing is selected or
	// the selection is canceled then the user is asked if
	// he/she wants to continue without a texture, if not
	// then the script errors out to be reran.
	string $grassTexture[] = `fileDialog2 -ds 2 -cap "Open Texture" -dir $dir -ff $filters -sff "All Files" -fm 1`;

	string $confirm;
	if ($grassTexture[0] == "")
	{
	$confirm = `confirmDialog -t "No Texture" -m "No texture was selected. Are you sure you want to\n continue without a texture?" -ma "center" -b "Yes" -b "No" -db "Yes" -cb "No" -ds "No" -icn "question"`;
	}

	if ($confirm == "No")
	{
	error "Restart the script and choose a texture.\n";
	}

	// Returns the file path for the texture.
	return $grassTexture[0];
	}

	////////////////////////////////////////////////////////////
	////////////////// Procedure: createGrass //////////////////
	////////////////////////////////////////////////////////////
	// //
	// This procedure creates the master grass geometry //
	// that the attached grass are copied from. The UVs are //
	// adjusted, a new blinn shading network is created and //
	// it attaches the chosen texture to the grass. //

	proc createGrass(string $grass, string $grassS, string $grassSG, string $grassTexture)
	{
	// Creates the master grass mesh.
	polyPlane -w 1 -h 8 -sx 1 -sy 8 -ax 0 0 1 -cuv 2 -ch 1 -n $grass;
	xform -pivots 0 -4 0;
	move -rpr 0 0 0;
	select -r grass.e[3] grass.e[6] grass.e[9] grass.e[12] grass.e[15] grass.e[18] grass.e[21] grass.e[24] ;
	scale -x 0.95404;
	select -d grass.e[3] ;
	scale -x 0.935408;
	select -d grass.e[6] ;
	scale -x 0.95808;
	select -d grass.e[9] ;
	scale -x 0.891177;
	select -d grass.e[12] ;
	scale -x 0.902911;
	select -d grass.e[15] ;
	scale -x 0.824543;
	select -d grass.e[18] ;
	scale -x 0.780672;
	scale -x 0.949012;
	select -d grass.e[21] ;
	scale -x 0.456029;
	polyCollapseEdge -ch 1 grass.e[24];
	select -r grass.e[21] ;
	scale -x 0.778965;
	select -r grass.e[18] ;
	scale -x 0.908768;
	select -r grass.e[15] ;
	scale -x 0.926951;
	select -r grass.e[12] ;
	scale -x 0.944705;
	select -r grass.e[9] ;
	scale -x 0.94611;
	select -r grass.e[6] ;
	scale -x 0.9656;
	select -r grass.e[6] ;
	scale -x 1.033333;
	select -r grass.e[12] ;
	scale -x 1;
	select -cl;

	// Projects the UVs and adjusts them.
	polyAutoProjection -lm 0 -pb 0 -ibd 1 -cm 0 -l 2 -sc 1 -o 1 -p 6 -ps 0.2 -ws 0 grass.f[0:7];
	select -r grass.map[0:16] ;
	setAttr "grassShape.uvPivot" -type double2 .5 0.5 ;
	select -r grass.map[0:16] ;
	setAttr "grassShape.uvPivot" -type double2 0.498274 0.5 ;
	polyEditUV -u 0.435774 -v 0 ;
	polyEditUV -pu 0.498274 -pv 0.5 -su 0.551282 -sv 1 ;
	select -r grass.map[16] ;
	setAttr "grassShape.uvPivot" -type double2 0.498274 0.922395 ;
	polyEditUV -u 0 -v -0.075613 ;
	select -r grassShape.map[14:15] ;
	polyEditUV -pu 0.498274 -pv 0.873506 -su 0.75641 -sv 1 ;

	// Deletes 4 edges to drop the poly count to 4.
	polyDelEdge -cv true -ch 1 grass.e[3] grass.e[9] grass.e[15] grass.e[21];

	// Creates a new blinn shader and network.
	shadingNode -asShader blinn -n $grassS;
	sets -renderable true -noSurfaceShader true -empty -name $grassSG;
	connectAttr -f grassShader.outColor grassShaderSG.surfaceShader;
	select -r $grass;
	hyperShade -a grassShader;

	// Sets attributes for the new shader.
	setAttr "grassShader.diffuse" 0.642;
	setAttr "grassShader.eccentricity" 0.163;
	setAttr "grassShader.specularRollOff" 0.276;
	setAttr "grassShader.specularColor" -type double3 1 0.997 0.863 ;

	// Creates a file node and place2dTexture node and
	// connects their attributes.
	shadingNode -asTexture file -n grassFile;
	shadingNode -asUtility place2dTexture -n grassPlace2dTexture;
	connectAttr -f ("grassPlace2dTexture.coverage") ("grassFile.coverage");
	connectAttr -f ("grassPlace2dTexture.translateFrame") ("grassFile.translateFrame");
	connectAttr -f ("grassPlace2dTexture.rotateFrame") ("grassFile.rotateFrame");
	connectAttr -f ("grassPlace2dTexture.mirrorU") ("grassFile.mirrorU");
	connectAttr -f ("grassPlace2dTexture.mirrorV") ("grassFile.mirrorV");
	connectAttr -f ("grassPlace2dTexture.stagger") ("grassFile.stagger");
	connectAttr -f ("grassPlace2dTexture.wrapU") ("grassFile.wrapU");
	connectAttr -f ("grassPlace2dTexture.wrapV") ("grassFile.wrapV");
	connectAttr -f ("grassPlace2dTexture.repeatUV") ("grassFile.repeatUV");
	connectAttr -f ("grassPlace2dTexture.offset") ("grassFile.offset");
	connectAttr -f ("grassPlace2dTexture.rotateUV") ("grassFile.rotateUV");
	connectAttr -f ("grassPlace2dTexture.noiseUV") ("grassFile.noiseUV");
	connectAttr -f ("grassPlace2dTexture.vertexUvOne") ("grassFile.vertexUvOne");
	connectAttr -f ("grassPlace2dTexture.vertexUvTwo") ("grassFile.vertexUvTwo");
	connectAttr -f ("grassPlace2dTexture.vertexUvThree") ("grassFile.vertexUvThree");
	connectAttr -f ("grassPlace2dTexture.vertexCameraOne") ("grassFile.vertexCameraOne");
	connectAttr ("grassPlace2dTexture.outUV") ("grassFile.uv");
	connectAttr ("grassPlace2dTexture.outUvFilterSize") ("grassFile.uvFilterSize");
	defaultNavigation -force true -connectToExisting -source ("grassFile") -destination grassShader.color;

	// Sets the file texture to the selected image/texture.
	setAttr grassFile.fileTextureName -typ "string" $grassTexture;

	// Freezes the transforms and deletes the history on
	// the master grass.
	makeIdentity -apply true -t 1 -r 1 -s 1 -n 0 $grass;
	delete -ch grass;
	}

	////////////////////////////////////////////////////////////
	////////////////// Procedure: createJoints /////////////////
	////////////////////////////////////////////////////////////
	// //
	// This procedure creates the master joints that the //
	// master grass is then bound to. //

	proc string[] createJoints(string $grass)
	{
	// Gets the bounding box of the master grass and
	// positions the first joint to the minimumY and the
	// end joint to the maximumY.
	float $grassBox[] = `exactWorldBoundingBox $grass`;
	string $selJnt[];
	$selJnt[0] = `joint -p 0 $grassBox[1] 0 -n grass_1_jnt -rad 0.5`;
	$selJnt[1] = `joint -p 0 $grassBox[4] 0 -n grass_end_jnt -rad 0.5`;

	// Gets the absolute positions of the new joints.
	vector $sjPos = (`joint -q -p $selJnt[0]`);
	vector $ejPos = (`joint -q -p $selJnt[1]`);
	string $crJnt[];

	// Clears the selection and sets $seg to 4.
	select -cl;
	int $seg=4;

	// For loop creates joints in the proper position
	// and assigns them to an array and parents the first
	// created joint to the start joint and parents the
	// end joint to the last created joint.
	for ($i=$seg; $i>1; $i--)
	{
	// This gets the value to use in the $crJnt array.
	// Then creates a new joint based on the positions
	// of the start and end joint and which segment joint
	// is being created.
	int $x = abs ($i-$seg);
	$crJnt[$x] = `joint -p ((((($sjPos.x)-($ejPos.x))/$seg)($i-1))+($ejPos.x)) ((((($sjPos.y)-($ejPos.y))/$seg)($i-1))+($ejPos.y)) ((((($sjPos.z)-($ejPos.z))/$seg)*($i-1))+($ejPos.z)) -n ("grass_"+($x+2)+"_jnt") -rad 0.5`;

	// Conditional checks if first segment joint is
	// being created and if true it is parented to
	// the start joint. Then checks if the last
	// segment joint is being created and if true
	// the end joint gets parented to the last segment
	// joint.
	if ($x==0)
	{
	parent $crJnt[$x] $selJnt[0];
	}else if (($x+1)==($seg-1)) {
	parent $selJnt[1] $crJnt[$x];
	}
	}

	// Orients the joints to XYZ with the secondary axis
	// pointing in -z.
	joint -e -oj xyz -secondaryAxisOrient zdown -ch -zso $selJnt[0];

	// Binds the master grass mesh to the master joints.
	bindSkin -tsb $selJnt[0] $crJnt[0] $crJnt[1] $crJnt[2] $grass;

	// Puts the master start joint and the first 3 segment
	// joints into an array then returns the array.
	string $joints[] = {$selJnt[0], $crJnt[0], $crJnt[1], $crJnt[2]};
	return $joints;
	}

	////////////////////////////////////////////////////////////
	///////////////// Procedure: populateGrass /////////////////
	////////////////////////////////////////////////////////////
	// //
	// This procedure moves the master grass to a vertex //
	// on the ground mesh and bends it based on the inputed //
	// bendMax, bendMin and the y normal of the vertex. //
	// the master grass, mesh and joints, are duplicated //
	// and the duplicated mesh is bound to the duplicated //
	// joints. The new start joint is then normalConstrained //
	// to the ground mesh. A transform node is created and //
	// pointOnPolyConstrained to the ground mesh, the new //
	// joint chain is then parented to the transform node. //
	// The transform node and the grass mesh are then grouped //
	// together and that group is parented to a main group //
	// for all grass groups. An expression is then created //
	// for the grass joints so that their bend is updated //
	// when the normal of the ground vertex is changed. //
	// This is done for all vertices on the ground mesh. //

	proc populateGrass(string $ground, string $grass, string $joints[], string $grassGrps, float $bendMax, float $bendMin)
	{
	// Bend min is inversed so that a smaller given number
	// brings the minimum bend closer to zero.
	$bendMin = 1/$bendMin;

	// Creates a closestPointOnMesh node and the outMesh
	// attr from the ground is connected to the inMesh
	// and the translate of the master start joint is
	// connected to the inPosition.
	string $cpom = `createNode closestPointOnMesh -ss`;
	connectAttr ($ground+"Shape.outMesh") ($cpom+".inMesh");
	connectAttr ($joints[0]+".translate") ($cpom+".inPosition");

	// Selects all vertices of the ground mesh and puts
	// them into an array, then gets teh size of that array.
	// The selection is cleared.
	select -r "ground.vtx[*]";
	string $groundVtx[] = `ls -sl -fl`;
	float $groundSize = size($groundVtx);
	select -cl;

	// A group is created, this is for all the grass groups.
	group -n $grassGrps -em;

	string $grassJnt[];

	// This Loops does what is specified in the procedure
	// description. It loops for all vertices in the
	// ground mesh.
	for ($s=0; $s<$groundSize; $s++)
	{
	// Queries the normals of the current vertex.
	float $vtxNorm[] = `polyNormalPerVertex -q -xyz $groundVtx[$s]`;

	// If the vertex is between -0.5 and 0.5 it sets
	// is to -.5 or 0.5 respectively. This prevents
	// the grass from bending in on itself, but that
	// can be changed if the bendMax is changed.
	if (($vtxNorm[1]<0.5)&&($vtxNorm[1]>(-0.5)))
	{
	if ($vtxNorm[1]<0)
	{
	$vtxNorm[1] = -0.5;
	}else{
	$vtxNorm[1] = 0.5;
	}
	}

	// This sets the randMin and randMax that the
	// master joints use to randomize their rotations.
	float $randMin = (-10$bendMax)(pow((1/$vtxNorm[1]),2));
	float $randMax = $randMin/(3*$bendMin);

	// This randomly rotates the three master segment
	// joints. To also rotate the start joint change
	// $i=1 to $i=0.
	for ($i=1; $i<4; $i++)
	{
	setAttr ($joints[$i]+".rz") (rand($randMin,$randMax));
	}

	// This queries the absolute translation of the
	// current vertex and moves the master grass to
	// that point.
	float $posVtx[] = `xform -q -t $groundVtx[$s]`;
	setAttr ($joints[0]+".translate") $posVtx[0] $posVtx[1] $posVtx[2];

	// The master grass mesh and joints are duplicated
	// and the dupicate segment joints are put into an
	// array. This array is used in the creation of
	// the expression.
	string $newGrass[] = `duplicate -rc $grass $joints[0]`;
	for ($i=0; $i<3; $i++)
	{
	$grassJnt[(($s*3)+$i)] = $newGrass[(2+$i)];
	}

	// The new mesh is bound to the new joints, the new
	// start joint is normalConstrained to the ground
	// mesh and its pivot is set.
	bindSkin -tsb $newGrass[1] $newGrass[2] $newGrass[3] $newGrass[4] $newGrass[0];
	string $normConst[] = `normalConstraint $ground $newGrass[1]`;
	xform -piv $posVtx[0] $posVtx[1] $posVtx[2] $newGrass[1];

	// An empty node is created and moved to the current
	// vertex, its transforms are then frozen.
	string $null = `group -em -n ($newGrass[1]+"_grp")`;
	setAttr ($null+".translate") $posVtx[0] $posVtx[1] $posVtx[2];
	makeIdentity -a 1 -t 1 -r 1 -s 1 $null;

	// The empty node is pointOnPolyConstrained to the ground
	// mesh and the constraint's U and V parameter are set
	// to the current vertex, this information is received from
	// the closestPointOnMesh node. The new grass start joint
	// is parented to the empty node.
	string $popc[] = `pointOnPolyConstraint $ground $null`;
	float $pU = `getAttr ($cpom+".parameterU")`;
	float $pV = `getAttr ($cpom+".parameterV")`;
	setAttr ($popc[0]+".groundU0") $pU;
	setAttr ($popc[0]+".groundV0") $pV;
	parent $newGrass[1] $null;

	// Groups the new grass mesh and transform node, with
	// the joints, together, then parents this group node
	// to the grass groups node. This it to organize the
	// outliner.
	string $grassGroup = `group -n ($newGrass[0]+"_grp") $newGrass[0] $null`;
	parent $grassGroup $grassGrps;

	// Expression is created to control the bend in the grass
	// when the y normal of the vertex, the new grass is on,
	// is changed. This expression is almost the same that
	// was used earlier in the script to set the initial
	// bends.
	expression -n ("grass"+($s+1)+"_expr") -s
	(
	"float $vtxNorm[] = `polyNormalPerVertex -q -xyz "+$groundVtx[$s]+"`;\n"+
	"float $vtxNormPast;\n"+
	"float $yNorm;\n\n"+

	"if ($vtxNorm[1] != $vtxNormPast)\n"+
	"{\n"+
	"$yNorm = $vtxNorm[1];\n"+
	" if (($yNorm<0.5)&&($yNorm>(-0.5)))\n"+
	" {\n"+
	" if ($yNorm<0)\n"+
	" {\n"+
	" $yNorm = -0.5;\n"+
	" }else{\n"+
	" $yNorm = 0.5;\n"+
	" }\n"+
	" }\n"+
	" float $randMin = (-10"+$bendMax+")(pow((1/$yNorm),2));\n"+
	" float $randMax = $randMin/(3*"+$bendMin+");\n\n"+

	" "+$grassJnt[($s*3)]+".rz = (rand($randMin,$randMax));\n"+
	" "+$grassJnt[(($s*3)+1)]+".rz = (rand($randMin,$randMax));\n"+
	" "+$grassJnt[(($s*3)+2)]+".rz = (rand($randMin,$randMax));\n"+
	"}\n\n"+

	"$vtxNormPast = $vtxNorm[1];");
	}

	// After all new grass is created the master grass, joints and
	// closestPointOnMesh node are deleted.
	delete $grass $joints[0] $cpom;
	}