jitterNode.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.
// ==========================================================================
//+

// Jitter
// 
// Description:
// 
//      This is a dependency graph node which takes a
//      floating point value as input, adds a random value,
//      and passes the result on as output.  A time input
//      is used to ensure the output result is repeatable
//      when played back.  A scale input is used to scale 
//      the value beyond 1.0.
// 
// Attributes ( < input, > output ):
// 
//      < input: the input float value
//      < scale: the scalar for the random value (0 - 1.0)
//      < time: the frame number
// 
//      > output: the randomized float value
// 
// Usage:
// 
//      Use jitterNode.mel to insert this DG node between
//      a float value connection in your DG.  See that MEL
//  script for usage information.

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

#include <maya/MPxNode.h>

#include <maya/MString.h> 
#include <maya/MTypeId.h> 
#include <maya/MPlug.h>

#include <maya/MFnNumericAttribute.h>
#include <maya/MVector.h>

#include <maya/MFnPlugin.h>
#include <maya/MDataBlock.h>
#include <maya/MDataHandle.h>

static unsigned int xRand, yRand, zRand;     /* seed */

float randomd()
{
    float result;
    unsigned int a = xRand/177, b = xRand%177;
    unsigned int c = yRand/176, d = yRand%176;
    unsigned int e = zRand/178, f = zRand%178;

    xRand = (171 * b - 2 * a) % 30269;
    yRand = (172 * d - 35 * c) % 30307;
    zRand = (170 * f - 63 * e) % 30323;

    result = (float) xRand/30269.0f + yRand/30307.0f + zRand/30323.0f;
    return result - ((int) result);
}

void seedd(unsigned char nx, unsigned char ny, unsigned char nz)
{
    xRand = nx;
    yRand = ny;
    zRand = nz;
    randomd();
    randomd();
    randomd();
    randomd();
}

class jitter : public MPxNode
{
public:
        jitter();
        virtual ~jitter(); 

        virtual MStatus         compute( const MPlug& plug, MDataBlock& data );

        static  void*           creator();
        static  MStatus         initialize();
 
        static  MObject         time;           // The time value.
        static  MObject         scale;          // Scale of jitter.

        static  MObject         input;          // The input value.
        static  MObject         output;         // The jittered-output value.

        static  MTypeId         id;
};

MTypeId     jitter::id( 0x80009 );
MObject         jitter::time;
MObject         jitter::scale;
MObject     jitter::input;
MObject     jitter::output; 

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

MStatus jitter::initialize()
{
        MFnNumericAttribute nAttr;
        MStatus                         stat;

        time = nAttr.create( "time", "tm", MFnNumericData::kFloat, 0.0 );
        nAttr.setStorable(true);

        scale = nAttr.create( "scale", "sc", MFnNumericData::kFloat, 1.0 );
        nAttr.setStorable(true);

        input = nAttr.create( "input", "in", MFnNumericData::kFloat, 0.0 );
        nAttr.setStorable(true);

        output = nAttr.create( "output", "out", MFnNumericData::kFloat, 0.0 );
        nAttr.setWritable(false);
        nAttr.setStorable(false);

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

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

        return MS::kSuccess;
} 

jitter::jitter() {}

jitter::~jitter() {}

// Compute the offset and add it to input
// as the output from this node.
MStatus jitter::compute( const MPlug& plug, MDataBlock& data )
{
        MStatus returnStatus;
 
        if( plug == output )
        {
                MDataHandle timeData = data.inputValue( time, &returnStatus );
                MDataHandle scaleData = data.inputValue( scale, &returnStatus );
                MDataHandle inputData = data.inputValue( input, &returnStatus );

                if( returnStatus != MS::kSuccess )
                        cerr << "ERROR getting data\n";
                else
                {
                        float currentFrame = timeData.asFloat();
                        float scaleFactor  = scaleData.asFloat();
                        float inValue = inputData.asFloat();

                        // This is where we jitter the value

                        unsigned char seed = (unsigned char)currentFrame;
                        seedd( seed, seed * 17, seed * 23 );

                        float tmp = randomd();
                        float result = ( tmp - 0.5f ) * scaleFactor + inValue;

                        MDataHandle outHandle = data.outputValue( jitter::output );

                        outHandle.set( result );

                        data.setClean(plug);
                }
        }
        else {
                return MS::kUnknownParameter;
        }

        return MS::kSuccess;
}

MStatus initializePlugin( MObject obj )
{ 
        MStatus   status;
        MFnPlugin plugin( obj, PLUGIN_COMPANY, "3.0", "Any");

        status = plugin.registerNode( "jitter", jitter::id, 
                                                 jitter::creator, jitter::initialize  );
        if (!status) {
                status.perror("registerNode");
                return status;
        }

        return status;
}

MStatus uninitializePlugin( MObject obj)
{
        MStatus   status;
        MFnPlugin plugin( obj );

        status = plugin.deregisterNode( jitter::id );
        if (!status) {
                status.perror("deregisterNode");
                return status;
        }

        return status;
}