- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Examples

# latticeNoiseCmd.cpp

    //-
    // ==========================================================================
    // Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
    //
    // Use of this software is subject to the terms of the Autodesk
    // license agreement provided at the time of installation or download,
    // or which otherwise accompanies this software in either electronic
    // or hard copy form.
    // ==========================================================================
    //+

    //
    //  Class: latticeNoiseCmd
    //
    //  Description:
    //      The latticeNoise command creates a new lattice (ffd) deformer.  A
    //      latticeNoise node is placed between the deformed lattice shape and the
    //      actual deformer node.  This causes the deformed object to wobble over time
    //      as random continuous noise is applied to the pointes of the lattice.
    //
    //      Once the deformer is created, the regular 'lattice' command can be
    //      used on it to modify the standard lattice parameters.
    //
    //      One thing to note is that the lattice geometry displayed on the
    //      screen will not show the added noise.  This is done this way
    //      so that the lattice can be modified with the usual tools without
    //      the noise node overriding all changes made to the lattice.
    //
    //      Also note that the noise function is reasonably computationally
    //      expensive, so dense lattices will be slow to update.
    //
    //  eg
    //     This causes the currently selected object to be deformed
    //
    //       latticeNoise;
    //
    //     This causes the specified geometry to be deformed
    //
    //       latticeNoise sphereShape1;
    //

    #include <maya/MIOStream.h>
    #include "latticeNoise.h"
    #include <maya/MObject.h>
    #include <maya/MFnLatticeDeformer.h>
    #include <maya/MSelectionList.h>
    #include <maya/MString.h>
    #include <maya/MArgList.h>
    #include <maya/MGlobal.h>
    #include <maya/MItSelectionList.h>
    #include <maya/MFnDependencyNode.h>
    #include <maya/MFnLattice.h>
    #include <maya/MDGModifier.h>

    #define McheckErr(stat,msg)         \
        if ( MS::kSuccess != stat ) {   \
            cerr << msg << endl;        \
            return MS::kFailure;        \
        }

    void* latticeNoiseCmd::creator()
    {
        return new latticeNoiseCmd();
    }

    MStatus latticeNoiseCmd::doIt( const MArgList& args )
    {
        MStatus res = MS::kSuccess;

        MSelectionList list;

        if ( args.length() > 0 ) {
            MString argStr;

            unsigned last = args.length();
            for ( unsigned i = 0; i < last; i++ ) {
                // Get the arg as a string.
                //
                res = args.get( i, argStr );
                McheckErr( res, "Invalid argument type" );

                // Attempt to find all of the objects matched
                // by the string and add them to the list
                //
                res = list.add( argStr );
                McheckErr( res, "Invalid object" );
            }
        } else {
            // Get the geometry list from what is currently selected in the
            // model
            //
            MGlobal::getActiveSelectionList( list );
        }

        // Create the deformer
        //
        MFnLatticeDeformer defFn;
        MObject deformNode = defFn.create( 2, 5, 2, &res );
        McheckErr( res, "Deformer creation failed" );
        MObject geomObj;

        for ( MItSelectionList iter( list, MFn::kGeometric );
              !iter.isDone(); iter.next() ) {
            // Get the object and add it to the deformation.  Note: we just
            // ignore objects that we don't understand.  This is standard maya
            // command behavior
            //
            iter.getDependNode( geomObj );
            defFn.addGeometry( geomObj );
        }

        // Reset the lattice to bound it's geometry
        //
        defFn.resetLattice( true );

        // Insert the latticeNoise node between the deformed lattice and the
        // actual lattice deformer node
        //
        MFnDependencyNode depNodeFn;
        MDGModifier modifier;
        MString attrName;

        // Make the noise node and get the attributes that we are going to
        // connect up
        //
        MString nodeType("latticeNoise" );
        MObject noiseNode = depNodeFn.create( nodeType, &res );
        McheckErr( res, "Lattice noise node creation failed" );
        attrName.set( "input" );
        MObject inputAttr = depNodeFn.attribute( attrName );
        attrName.set( "output" );
        MObject outputAttr = depNodeFn.attribute( attrName );
        attrName.set( "time" );
        MObject timeAttr = depNodeFn.attribute( attrName );

        // Get the lattice input attribute from the deformer node
        //
        attrName.set( "deformedLatticePoints" );
        MObject destLattAttr = defFn.attribute( attrName );

        // Get the lattice shape node so that we can find the output
        // attribute
        //
        MObject deformedLattice = defFn.deformLattice( &res );
        McheckErr( res, "Could not get the deformed lattice node" );
        MFnLattice latticeShapeFn( deformedLattice, &res );
        attrName.set( "latticeOutput" );
        MObject sourceLattAttr = latticeShapeFn.attribute( attrName );

        // Disconnect lattice from deformer
        //
        res = modifier.disconnect( deformedLattice, sourceLattAttr,
                                   deformNode, destLattAttr );
        McheckErr( res, "Could not disconnect nodes" );

        // Insert new noise node
        //
        modifier.connect( deformedLattice, sourceLattAttr,
                          noiseNode, inputAttr );
        modifier.connect( noiseNode, outputAttr,
                          deformNode, destLattAttr );

        // Find the time node and connect to it
        //
        list.clear();
        list.add( "time1" );
        MObject timeNode;
        list.getDependNode( 0, timeNode );
        MFnDependencyNode timeFn( timeNode, &res );
        McheckErr( res, "Could not get the time node" );
        attrName.set( "outTime" );
        MObject timeOutAttr = timeFn.attribute( attrName );

        // Connect to time node
        //
        modifier.connect( timeNode, timeOutAttr,
                          noiseNode, timeAttr );

        // Perform all of the operations cued up in the modifier
        //
        res = modifier.doIt();
        McheckErr( res, "Error changing deformer graph connections" );

        // Lastly, make the new lattice that we have created active
        // This is standard Mel command behaviour.
        //
        MString name = latticeShapeFn.name();
        MGlobal::selectByName( name, MGlobal::kReplaceList );

        return res;
    }