- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Examples

# yTwistNode.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.
    // ==========================================================================
    //+
    //
    //  File: yTwist.cpp
    //
    //  Description:
    //      Example implementation of a deformer. This node
    //      twists the deformed vertices around the y-axis.
    //

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

    #include <maya/MPxDeformerNode.h>
    #include <maya/MItGeometry.h>

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

    #include <maya/MFnNumericAttribute.h>
    #include <maya/MFnPlugin.h>
    #include <maya/MFnDependencyNode.h>

    #include <maya/MPoint.h>
    #include <maya/MMatrix.h>

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

    class yTwist : public MPxDeformerNode
    {
    public:
                            yTwist();
        virtual             ~yTwist();

        static  void*       creator();
        static  MStatus     initialize();

        // deformation function
        //
        virtual MStatus     deform(MDataBlock&      block,
                                   MItGeometry&     iter,
                                   const MMatrix&   mat,
                                   unsigned int     multiIndex);

    public:
        // yTwist attributes
        //
        static  MObject     angle;          // angle to twist

        static  MTypeId     id;

    private:

    };

    MTypeId     yTwist::id( 0x8000e );

    // yTwist attributes  //

    MObject     yTwist::angle;

    yTwist::yTwist()
    //
    //  Description:
    //      constructor
    //
    {
    }

    yTwist::~yTwist()
    //
    //  Description:
    //      destructor
    //
    {}

    void* yTwist::creator()
    //
    //  Description:
    //      create the yTwist
    //
    {
        return new yTwist();
    }

    MStatus yTwist::initialize()
    //
    //  Description:
    //      initialize the attributes
    //
    {
        // local attribute initialization
        //
        MFnNumericAttribute nAttr;
        angle=nAttr.create( "angle", "fa", MFnNumericData::kDouble );
            nAttr.setDefault(0.0);
            nAttr.setKeyable(true);
        addAttribute( angle);

        // affects
        //
        attributeAffects( yTwist::angle, yTwist::outputGeom );

        return MS::kSuccess;
    }

    MStatus
    yTwist::deform( MDataBlock& block,
                    MItGeometry& iter,
                    const MMatrix& /*m*/,
                    unsigned int /*multiIndex*/)
    //
    // Method: deform
    //
    // Description:   Deform the point with a yTwist algorithm
    //
    // Arguments:
    //   block      : the datablock of the node
    //   iter       : an iterator for the geometry to be deformed
    //   m          : matrix to transform the point into world space
    //   multiIndex : the index of the geometry that we are deforming
    //
    //
    {
        MStatus status = MS::kSuccess;

        // determine the angle of the yTwist
        //
        MDataHandle angleData = block.inputValue(angle,&status);
        McheckErr(status, "Error getting angle data handle\n");
        double magnitude = angleData.asDouble();

        // determine the envelope (this is a global scale factor)
        //
        MDataHandle envData = block.inputValue(envelope,&status);
        McheckErr(status, "Error getting envelope data handle\n");
        float env = envData.asFloat();

        // iterate through each point in the geometry
        //
        for ( ; !iter.isDone(); iter.next()) {

            MPoint pt = iter.position();

            // do the twist
            //
            double ff = magnitude*pt.y*env;
            if (ff != 0.0) {
                double cct= cos(ff);
                double cst= sin(ff);
                double tt= pt.x*cct-pt.z*cst;
                pt.z= pt.x*cst + pt.z*cct;
                pt.x=tt;;
            }

            iter.setPosition(pt);
        }
        return status;
    }

    // standard initialization procedures
    //

    MStatus initializePlugin( MObject obj )
    {
        MStatus result;
        MFnPlugin plugin( obj, PLUGIN_COMPANY, "3.0", "Any");
        result = plugin.registerNode( "yTwist", yTwist::id, yTwist::creator,
                                      yTwist::initialize, MPxNode::kDeformerNode );
        return result;
    }

    MStatus uninitializePlugin( MObject obj)
    {
        MStatus result;
        MFnPlugin plugin( obj );
        result = plugin.deregisterNode( yTwist::id );
        return result;
    }