latticeNoiseNode.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: latticeNoiseNode
//
//  Description:
//      A "latticeNoise" node adds random noise to lattice geometry over time.
//      This makes the geometry being deformed by the lattice look like 
//      wobbly jello.
//
//
//  Node:       latticeNoise
//
//  Attributes: input     - input lattice 
//              amplitude - amplitude of the noise
//              frequency - frequency of the noise
//              time      - the current time
//              output    - the modified lattice
//  
#include "latticeNoise.h"

#include <string.h>
#include <maya/MIOStream.h>
#include <stdio.h>
#include <math.h>

#include <maya/MFnUnitAttribute.h>  
#include <maya/MFnNumericAttribute.h>
#include <maya/MFnTypedAttribute.h>  
#include <maya/MFnLattice.h>
#include <maya/MFnLatticeData.h>

#include <maya/MString.h> 
#include <maya/MTypeId.h> 
#include <maya/MPlug.h> 
#include <maya/MDataBlock.h>
#include <maya/MDataHandle.h> 
#include <maya/MTime.h>

// CONSTANTS
//
#define DEF_AMPLITUDE 0.2
#define DEF_FREQ      4.0 

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


//             latticeNoiseNode Methods                 //

MTypeId     latticeNoiseNode::id( 0x80010 );
MObject     latticeNoiseNode::input;  
MObject     latticeNoiseNode::amplitude;  
MObject     latticeNoiseNode::frequency;  
MObject     latticeNoiseNode::time;      
MObject     latticeNoiseNode::output;       

MStatus latticeNoiseNode::compute( const MPlug& plug, MDataBlock& data )
{ 
        MStatus returnStatus;

        float noiseAmplitude;
        float noiseFreq;
 
        if( plug == output )
        {
                // Get the lattice data from the input attribute.  First get the 
                // data object, and then use the lattice data function set to extract
                // the actual lattice.
                //

                // Get the data handle
                //
                MDataHandle inputData = data.inputValue( input, &returnStatus );
                McheckErr( returnStatus, "ERROR getting lattice data handle\n" ); 
                // Get the data object
                //
                MObject latticeData = inputData.data(); 
                MFnLatticeData dataFn( latticeData );
                // Get the actual geometry
                // 
                MObject lattice = dataFn.lattice();
                MFnLattice lattFn( lattice, &returnStatus );
                McheckErr( returnStatus, "ERROR getting lattice geometry\n" );  


                // Do the same for the output lattice
                //
                MDataHandle outputData = data.outputValue( output, &returnStatus ); 
                McheckErr( returnStatus, "ERROR getting lattice data handle\n" );
                // Get the data object
                //
                latticeData = outputData.data(); 
                if ( latticeData.isNull() ) { 
                        // The data object for this attribute has not been created yet, so
                        // we'll create it
                        //
                        latticeData = dataFn.create();
                } else {
                        // Use the data object that is already there
                        // 
                        dataFn.setObject( latticeData );
                }
                // Get the actual geometry
                // 
                MObject outLattice = dataFn.lattice();
                MFnLattice outLattFn( outLattice, &returnStatus );
                McheckErr( returnStatus, "ERROR getting lattice geometry\n" );  

                // Get the amplitude and frequency
                //
                MDataHandle ampData = data.inputValue( amplitude, &returnStatus );
                McheckErr( returnStatus, "ERROR getting amplitude\n" );
                noiseAmplitude = ampData.asFloat(); 

                MDataHandle freqData = data.inputValue( frequency, &returnStatus );
                McheckErr( returnStatus, "ERROR getting frequency\n" );
                noiseFreq = freqData.asFloat(); 

                // Get the time.  
                //
                MDataHandle timeData = data.inputValue( time, &returnStatus ); 
                McheckErr( returnStatus, "ERROR getting time data handle\n" );
                MTime time = timeData.asTime();
                float seconds = (float)time.as( MTime::kSeconds );

                // Easiest way to modify frequency is by modifying the time
                //
                seconds = seconds * noiseFreq;

                // We have the information we need now.  We'll apply noise to the
                // points upon the lattice
                //
                unsigned s, t, u;
                lattFn.getDivisions( s, t, u );
                // match up the divisions in the lattices
                //
                outLattFn.setDivisions( s, t, u );   

                for ( unsigned i = 0; i < s; i++ ) {
                        for ( unsigned j = 0; j < t; j++ ) {
                                for ( unsigned k = 0; k < u; k++ ) {
                                        MPoint & point = lattFn.point( i, j, k );
                                        MPoint & outPoint = outLattFn.point( i, j, k );
                                        pnt noisePnt = noise::atPointAndTime( (float)point.x, (float)point.y, 
                                                                                                                  (float)point.z, seconds );
                                        // Make noise between -1 and 1 instead of 0 and 1
                                        //
                                        noisePnt.x =  ( noisePnt.x * 2.0F ) - 1.0F;
                                        noisePnt.y =  ( noisePnt.y * 2.0F ) - 1.0F;
                                        noisePnt.z =  ( noisePnt.z * 2.0F ) - 1.0F;

                                        outPoint.x = point.x + ( noisePnt.x * noiseAmplitude );
                                        outPoint.y = point.y + ( noisePnt.y * noiseAmplitude );
                                        outPoint.z = point.z + ( noisePnt.z * noiseAmplitude );  
                                }
                        }
                } 
                outputData.set( latticeData );
                data.setClean(plug); 
        } else {
                return MS::kUnknownParameter;
        }

        return MS::kSuccess;
}

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

MStatus latticeNoiseNode::initialize()
{ 
        MFnUnitAttribute    unitAttr;
        MFnTypedAttribute   typedAttr;
        MFnNumericAttribute numAttr;

        MStatus stat;

        input = typedAttr.create( "input", "in", MFnData::kLattice, &stat );
        if ( !stat ) {
                stat.perror("ERROR creating latticeNoiseNode input lattice attribute");
                return stat;
        }

        amplitude = numAttr.create( "amplitude", "amp", 
                                                                                           MFnNumericData::kFloat,
                                                                                           DEF_AMPLITUDE,
                                                                                           &stat );
        if ( !stat ) {
                stat.perror("ERROR creating latticeNoiseNode amplitude attribute");
                return stat;
        }

        frequency = numAttr.create( "frequency", "fq", 
                                                                                           MFnNumericData::kFloat,
                                                                                           DEF_FREQ,
                                                                                           &stat );
        if ( !stat ) {
                stat.perror("ERROR creating latticeNoiseNode frequency attribute");
                return stat;
        }

        time = unitAttr.create( "time", "tm", MFnUnitAttribute::kTime,
                                                                                        0.0, &stat );
        if ( !stat ) {
                stat.perror("ERROR creating latticeNoiseNode time attribute");
                return stat;
        }

        output = typedAttr.create( "output", "out", MFnData::kLattice, &stat ); 
        if ( !stat ) {
                stat.perror("ERROR creating latticeNoiseNode output attribute");
                return stat;
        }
        typedAttr.setWritable(false);

        stat = addAttribute( input );
                if (!stat) { stat.perror("addAttribute"); return stat;}
        stat = addAttribute( amplitude );
                if (!stat) { stat.perror("addAttribute"); return stat;}
        stat = addAttribute( frequency );
                if (!stat) { stat.perror("addAttribute"); return stat;}
        stat = addAttribute( time );
                if (!stat) { stat.perror("addAttribute"); return stat;}
        stat = addAttribute( output );
                if (!stat) { stat.perror("addAttribute"); return stat;}

        stat = attributeAffects( input, output );
                if (!stat) { stat.perror("attributeAffects"); return stat;}
        stat = attributeAffects( amplitude, output );
                if (!stat) { stat.perror("attributeAffects"); return stat;}
        stat = attributeAffects( frequency, output );
                if (!stat) { stat.perror("attributeAffects"); return stat;}
        stat = attributeAffects( time, output );
                if (!stat) { stat.perror("attributeAffects"); return stat;}


        return MS::kSuccess;
}