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

// Example Plugin: circleNode.cpp
//
// This plug-in is an example of a user-defined dependency graph node.
// It takes a number as input (such as time) and generates two output
// numbers one which describes a sine curve as the input varies and
// one that generates a cosine curve. If these two are hooked up to
// the x and z translation attributes of an object the object will describe
// move through a circle in the xz plane as time is changed.
//
// Executing the command "source circleNode" will run the MEL script which will
// create a new "Circle" menu with a single item. Selecting this will build
// a simple model (a sphere which follows a circular path) which can be played back,
// by clicking on the "play" icon on the time slider.  Note: the circleNode
// plugin needs to be loaded before the "Circle" menu item can be executed
// properly.
//
// The node has two additional attributes which can be changed to affect
// the animation, "scale" which defines the size of the circular path, and
// "frames" which defines the number of frames required for a complete circuit
// of the path. Either of these can be hooked up to other nodes, or can
// be simply set via the MEL command "setAttr" operating on the circle node
// "circleNode1" created by the MEL script. For example, "setAttr circleNode1.scale #"
// will change the size of the circle and "setAttr circleNode1.frames #"
// will cause objects to complete a circle in indicated number of frames.


#include <string.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>

#include <math.h>

// The circle class defines the attributes
// and methods necessary for the circleNode plugin
//
class circle : public MPxNode
{
public:
                        circle();
    virtual             ~circle(); 

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

    static  void*       creator();
    static  MStatus     initialize();
 
public:
    static  MObject     input;      // The input value.
    static  MObject     sOutput;    // The sinusoidal output value.
    static  MObject     cOutput;    // The cosinusoidal output value.
    static  MObject     frames;     // Number of frames for one circle.
    static  MObject     scale;      // Size of circle.
    static  MTypeId     id;
};

MTypeId     circle::id( 0x80005 );
MObject     circle::input;        
MObject     circle::sOutput;       
MObject     circle::cOutput;       
MObject     circle::frames;
MObject     circle::scale;

// The creator method creates an instance of the circleNode class
// and is the first method called by Maya
// when a circleNode needs to be created.
//
void* circle::creator()
{
    return new circle();
}

// The initialize routine is called after the node has been created.
// It sets up the input and output attributes and adds them to the node.
// Finally the dependencies are arranged so that when the inputs
// change Maya knowns to call compute to recalculate the output values.
// The inputs are: input, scale, frames
// The outputs are: sineOutput, cosineOutput
//
MStatus circle::initialize()
{
    MFnNumericAttribute nAttr;
    MStatus             stat;

    // Setup the input attributes
    //
    input = nAttr.create( "input", "in", MFnNumericData::kFloat, 0.0,
            &stat );
    CHECK_MSTATUS( stat );
    CHECK_MSTATUS( nAttr.setStorable( true ) );

    scale = nAttr.create( "scale", "sc", MFnNumericData::kFloat, 10.0,
            &stat );
    CHECK_MSTATUS( stat );
    CHECK_MSTATUS( nAttr.setStorable( true ) );

    frames = nAttr.create( "frames", "fr", MFnNumericData::kFloat, 48.0,
            &stat );
    CHECK_MSTATUS( stat );
    CHECK_MSTATUS( nAttr.setStorable( true ) );

    // Setup the output attributes
    //
    sOutput = nAttr.create( "sineOutput", "so", MFnNumericData::kFloat,
            0.0, &stat );
    CHECK_MSTATUS( stat );
    CHECK_MSTATUS( nAttr.setWritable( false ) );
    CHECK_MSTATUS( nAttr.setStorable( false ) );

    cOutput = nAttr.create( "cosineOutput", "co", MFnNumericData::kFloat,
            0.0, &stat );
    CHECK_MSTATUS( stat );
    CHECK_MSTATUS( nAttr.setWritable( false ) );
    CHECK_MSTATUS( nAttr.setStorable( false ) );

    // Add the attributes to the node
    //
    CHECK_MSTATUS( addAttribute( input ) );
    CHECK_MSTATUS( addAttribute( scale ) );
    CHECK_MSTATUS( addAttribute( frames ) );
    CHECK_MSTATUS( addAttribute( sOutput ) );
    CHECK_MSTATUS( addAttribute( cOutput ) );

    // Set the attribute dependencies
    //
    CHECK_MSTATUS( attributeAffects( input, sOutput ) );
    CHECK_MSTATUS( attributeAffects( input, cOutput ) );
    CHECK_MSTATUS( attributeAffects( scale, sOutput ) );
    CHECK_MSTATUS( attributeAffects( scale, cOutput ) );
    CHECK_MSTATUS( attributeAffects( frames, sOutput ) );
    CHECK_MSTATUS( attributeAffects( frames, cOutput ) );

    return MS::kSuccess;
} 

// The constructor does nothing
//
circle::circle() {}

// The destructor does nothing
//
circle::~circle() {}

// The compute method is called by Maya when the input values
// change and the output values need to be recomputed.
// The input values are read then using sinf() and cosf()
// the output values are stored on the output plugs.
//
MStatus circle::compute (const MPlug& plug, MDataBlock& data)
{
    
    MStatus returnStatus;
 
    // Check that the requested recompute is one of the output values
    //
    if (plug == sOutput || plug == cOutput) {
        // Read the input values
        //
        MDataHandle inputData = data.inputValue (input, &returnStatus);
        CHECK_MSTATUS( returnStatus );
        MDataHandle scaleData = data.inputValue (scale, &returnStatus);
        CHECK_MSTATUS( returnStatus );
        MDataHandle framesData = data.inputValue (frames, &returnStatus);
        CHECK_MSTATUS( returnStatus );

        // Compute the output values
        //
        float currentFrame = inputData.asFloat();
        float scaleFactor  = scaleData.asFloat();
        float framesPerCircle = framesData.asFloat();
        float angle = 6.2831853f * (currentFrame/framesPerCircle);
        float sinResult = sinf (angle) * scaleFactor;
        float cosResult = cosf (angle) * scaleFactor;

        // Store them on the output plugs
        //
        MDataHandle sinHandle = data.outputValue( circle::sOutput,
                &returnStatus );
        CHECK_MSTATUS( returnStatus );
        MDataHandle cosHandle = data.outputValue( circle::cOutput,
                &returnStatus );
        CHECK_MSTATUS( returnStatus );
        sinHandle.set( sinResult );
        cosHandle.set( cosResult );
        CHECK_MSTATUS( data.setClean( plug ) );
    } else {
        return MS::kUnknownParameter;
    }

    return MS::kSuccess;
}

// The initializePlugin method is called by Maya when the circleNode
// plugin is loaded.  It registers the circleNode which provides
// Maya with the creator and initialize methods to be called when
// a circleNode is created.
//
MStatus initializePlugin ( MObject obj )
{ 
    MStatus   status;
    MFnPlugin plugin( obj, PLUGIN_COMPANY, "4.5", "Any");

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

    return status;
}

// The unitializePlugin is called when Maya needs to unload the plugin.
// It basically does the opposite of initialize by calling
// the deregisterCommand to remove it.
//
MStatus uninitializePlugin( MObject obj)
{
    MStatus   status;
    MFnPlugin plugin( obj );

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

    return status;
}