latticeNoise/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;
}