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