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