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

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

#include <torusField.h>

#include <maya/MTime.h>
#include <maya/MVectorArray.h>
#include <maya/MDoubleArray.h>
#include <maya/MMatrix.h>

#include <maya/MFnDependencyNode.h>
#include <maya/MFnTypedAttribute.h>
#include <maya/MFnNumericAttribute.h>
#include <maya/MFnCompoundAttribute.h>
#include <maya/MFnUnitAttribute.h>
#include <maya/MFnVectorArrayData.h>
#include <maya/MFnDoubleArrayData.h>
#include <maya/MFnMatrixData.h>


MObject torusField::aMinDistance;
MObject torusField::aAttractDistance;
MObject torusField::aRepelDistance;
MObject torusField::aDrag;
MObject torusField::aSwarmAmplitude;
MObject torusField::aSwarmFrequency;
MObject torusField::aSwarmPhase;

MTypeId torusField::id( 0x80018 );


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

MStatus torusField::initialize()
//
//      Descriptions:
//              Initialize the node, attributes.
//
{
        MStatus status;

        MFnNumericAttribute numAttr;

        // create the field basic attributes.
        //
        aMinDistance = numAttr.create("minDistance","mnd",MFnNumericData::kDouble);
        numAttr.setDefault( 0.0 );
        numAttr.setKeyable( true );
        status = addAttribute( aMinDistance );
        McheckErr(status, "ERROR adding aMinDistance attribute.\n");

        aAttractDistance = numAttr.create("attractDistance","ad",
                                                                                MFnNumericData::kDouble);
        numAttr.setDefault( 20.0 );
        numAttr.setKeyable( true );
        status = addAttribute( aAttractDistance );
        McheckErr(status, "ERROR adding aAttractDistance attribute.\n");

        aRepelDistance = numAttr.create("repelDistance","rd",
                                                                                MFnNumericData::kDouble);
        numAttr.setDefault( 10.0 );
        numAttr.setKeyable( true );
        status = addAttribute( aRepelDistance );
        McheckErr(status, "ERROR adding aRepelDistance attribute.\n");

        aDrag = numAttr.create("drag", "d", MFnNumericData::kDouble);
        numAttr.setDefault( 0.0 );
        numAttr.setKeyable( true );
        status = addAttribute( aDrag );
        McheckErr(status, "ERROR adding aDrag attribute.\n");

        aSwarmAmplitude = numAttr.create("swarmAmplitude", "samp",
                                                                                MFnNumericData::kDouble);
        numAttr.setDefault( 0.0 );
        numAttr.setKeyable( true );
        status = addAttribute( aSwarmAmplitude );
        McheckErr(status, "ERROR adding aSwarmAmplitude attribute.\n");

        aSwarmFrequency = numAttr.create("swarmFrequency", "sfrq",
                                                                                MFnNumericData::kDouble);
        numAttr.setDefault( 1.0 );
        numAttr.setKeyable( true );
        status = addAttribute( aSwarmFrequency );
        McheckErr(status, "ERROR adding aSwarmFrequency attribute.\n");

        aSwarmPhase = numAttr.create("swarmPhase", "sa", MFnNumericData::kDouble);
        numAttr.setDefault( 0.0 );
        numAttr.setKeyable( true );
        status = addAttribute( aSwarmPhase );
        McheckErr(status, "ERROR adding aSwarmPhase attribute.\n");

        // the new attribute will affect output force.
        //
        //status = attributeAffects( aMinDistance, outputForce );
        //McheckErr(status, "ERROR in attributeAffects(aMinDistance,outputForce).\n");
        //status = attributeAffects( aAttractDistance, outputForce );
        //McheckErr(status, "ERROR in attributeAffects(aAttractDistance,outputForce).\n");
        //status = attributeAffects( aRepelDistance, outputForce );
        //McheckErr(status, "ERROR in attributeAffects(aRepelDistance,outputForce).\n");
        //status = attributeAffects( aDrag, outputForce );
        //McheckErr(status, "ERROR in attributeAffects(aDrag,outputForce).\n");

        return( MS::kSuccess );
}


MStatus torusField::compute(const MPlug& plug, MDataBlock& block)
//
//      Descriptions:
//              compute output force.
//
{
        MStatus status;

        if( !(plug == mOutputForce) )
        return( MS::kUnknownParameter );

        // get the logical index of the element this plug refers to.
        //
        int multiIndex = plug.logicalIndex( &status );
        McheckErr(status, "ERROR in plug.logicalIndex.\n");

        // Get input data handle, use outputArrayValue since we do not
        // want to evaluate both inputs, only the one related to the
        // requested multiIndex. Evaluating both inputs at once would cause
        // a dependency graph loop.
        //
        MArrayDataHandle hInputArray = block.outputArrayValue( mInputData, &status );
        McheckErr(status,"ERROR in hInputArray = block.outputArrayValue().\n");

        status = hInputArray.jumpToElement( multiIndex );
        McheckErr(status, "ERROR: hInputArray.jumpToElement failed.\n");

        // get children of aInputData.
        //
        MDataHandle hCompond = hInputArray.inputValue( &status );
        McheckErr(status, "ERROR in hCompond=hInputArray.inputValue\n");

        MDataHandle hPosition = hCompond.child( mInputPositions );
        MObject dPosition = hPosition.data();
        MFnVectorArrayData fnPosition( dPosition );
        MVectorArray points = fnPosition.array( &status );
        McheckErr(status, "ERROR in fnPosition.array(), not find points.\n");

        MDataHandle hVelocity = hCompond.child( mInputVelocities );
        MObject dVelocity = hVelocity.data();
        MFnVectorArrayData fnVelocity( dVelocity );
        MVectorArray velocities = fnVelocity.array( &status );
        McheckErr(status, "ERROR in fnVelocity.array(), not find velocities.\n");

        MDataHandle hMass = hCompond.child( mInputMass );
        MObject dMass = hMass.data();
        MFnDoubleArrayData fnMass( dMass );
        MDoubleArray masses = fnMass.array( &status );
        McheckErr(status, "ERROR in fnMass.array(), not find masses.\n");

        // Compute the output force.
        //

        MVectorArray forceArray;
        bool useMaxDistSet = useMaxDistanceValue( block );
        if( useMaxDistSet )
        {
                applyMaxDist( block, points, velocities, masses, forceArray );
        }
        else
        {
                applyNoMaxDist( block, points, velocities, masses, forceArray );
        }

        // get output data handle
        //
        MArrayDataHandle hOutArray = block.outputArrayValue( mOutputForce, &status);
        McheckErr(status, "ERROR in hOutArray = block.outputArrayValue.\n");
        MArrayDataBuilder bOutArray = hOutArray.builder( &status );
        McheckErr(status, "ERROR in bOutArray = hOutArray.builder.\n");

        // get output force array from block.
        //
        MDataHandle hOut = bOutArray.addElement(multiIndex, &status);
        McheckErr(status, "ERROR in hOut = bOutArray.addElement.\n");

        MFnVectorArrayData fnOutputForce;
        MObject dOutputForce = fnOutputForce.create( forceArray, &status );
        McheckErr(status, "ERROR in dOutputForce = fnOutputForce.create\n");

        // update data block with new output force data.
        //
        hOut.set( dOutputForce );
        block.setClean( plug );

        return( MS::kSuccess );
}


void torusField::applyNoMaxDist
        (
                MDataBlock &block,                              // get field param from this block
                const MVectorArray &points,             // current position of Object
                const MVectorArray &velocities, // current velocity of Object
                const MDoubleArray &/*masses*/,         // mass of Object
                MVectorArray &outputForce               // output force
        )
//
//      Descriptions:
//              Compute output force in the case that the useMaxDistance is not set.
//
{
        // points and velocities should have the same length. If not return.
        //
        if( points.length() != velocities.length() )
                return;

        // clear the output force array.
        //
        outputForce.clear();

        // get field parameters.
        //
        double magValue = magnitudeValue( block );
        // double attenValue = attenuationValue( block );
        double minDist = minDistanceValue( block );
        double attractDist = attractDistanceValue( block );
        double repelDist = repelDistanceValue( block );
        double dragMag = dragValue( block );
        double swarmAmp = swarmAmplitudeValue( block );

        // get owner's data. posArray may have only one point which is the centroid
        // (if this has owner) or field position(if without owner). Or it may have
        // a list of points if with owner and applyPerVertex.
        //
        MVectorArray posArray;
        posArray.clear();
        ownerPosition( block, posArray );

        int fieldPosCount = posArray.length();
        int receptorSize = points.length();

        // With this model,if max distance isn't set then we
        // also don't attenuate, because 1 - dist/maxDist isn't
        // meaningful. No max distance and no attenuation.
        //
        if (dragMag <= 0)
        {
                if (swarmAmp <= 0)
                {
                        // No max dist, no attenuation, no drag, no swarm
                        //
                        for (int ptIndex = 0; ptIndex < receptorSize; ptIndex ++ )
                        {
                                MVector forceV(0.0,0.0,0.0);
                                const MVector &receptorPoint = points[ptIndex];

                                // Apply from every field position to every receptor position.
                                //
                                for(int i = fieldPosCount; --i>=0; )
                                {
                                        MVector difference = (receptorPoint-posArray[i]);

                                        double distance = difference.length();
                                        if (distance < minDist) continue;

                                        if (distance <= repelDist)
                                                forceV += difference * magValue;
                                        else if (distance >= attractDist)
                                                forceV += -difference * magValue;
                                }
                                outputForce.append( forceV );
                        }
                }
                else
                {
                        // No max dist, no attenuation, no drag, yes swarm
                        //
                        for (int ptIndex = 0; ptIndex < receptorSize; ptIndex ++ )
                        {
                                MVector forceV(0.0,0.0,0.0);
                                const MVector &receptorPoint = points[ptIndex];

                                // Apply from every field position to every receptor position.
                                //
                                double distance = 0.0;
                                int i;
                                for(i = fieldPosCount; --i>=0; )
                                {
                                        MVector difference = (receptorPoint-posArray[i]);
                                        distance = difference.length();
                                        if (distance < minDist) continue;

                                        if (distance <= repelDist)
                                                forceV += difference * magValue;
                                        else if (distance >= attractDist)
                                                forceV += -difference * magValue;
                                }

                                // Apply swarm only if the object is inside the zone
                                // the repulsion-attraction is pushing the object to.
                                //
                                if ( distance >= repelDist && distance <= attractDist)
                                {
                                        double frequency = swarmFrequencyValue( block );
                                        MVector phase( 0.0, 0.0, swarmPhaseValue(block) );

                                        // Add swarm in here
                                        //
                                        for(i = fieldPosCount; --i >= 0;)
                                        {
                                                MVector difference = receptorPoint - posArray[i];
                                                difference = (difference + phase) * frequency;

                                                double *noiseEffect = &difference.x;
                                                if( (noiseEffect[0] < -2147483647.0) ||
                                                        (noiseEffect[0] >  2147483647.0) ||
                                                        (noiseEffect[1] < -2147483647.0) ||
                                                        (noiseEffect[1] >  2147483647.0) ||
                                                        (noiseEffect[2] < -2147483647.0) ||
                                                        (noiseEffect[2] >  2147483647.0) )
                                                        continue;

                                                double noiseOut[4];
                                                noiseFunction( noiseEffect, noiseOut );
                                                MVector swarmForce( noiseOut[0] * swarmAmp,
                                                                                        noiseOut[1] * swarmAmp,
                                                                                        noiseOut[2] * swarmAmp );
                                                forceV += swarmForce;
                                        }
                                }
                                outputForce.append( forceV );
                        }
                }
        }
        else
        {
                if (swarmAmp <= 0)
                {
                        // Yes drag, no swarm
                        //
                        for (int ptIndex = 0; ptIndex < receptorSize; ptIndex ++ )
                        {
                                const MVector& receptorPoint = points[ptIndex];

                                // Apply from every field position to every receptor position.
                                //
                                MVector forceV(0,0,0);
                                double distance = 0.0;
                                for(int i = fieldPosCount; --i>=0; )
                                {
                                        MVector difference = (receptorPoint-posArray[i]);
                                        distance = difference.length();
                                        if (distance < minDist) continue;

                                        if (distance <= repelDist)
                                                forceV += difference * magValue;
                                        else if (distance >= attractDist)
                                                forceV += -difference * magValue;
                                }

                                // Apply drag only if the object is inside the zone
                                // the repulsion-attraction is pushing the object to.
                                //
                                if ( distance >= repelDist && distance <= attractDist)
                                {
                                        if (fieldPosCount > 0)
                                        {
                                                MVector dragForceV;
                                                dragForceV = velocities[ptIndex] *
                                                                                                (-dragMag) * fieldPosCount;
                                                forceV += dragForceV;
                                        }
                                }

                                outputForce.append( forceV );
                        }
                }
                else
                {
                        // Yes drag, yes swarm
                        //
                        for (int ptIndex = 0; ptIndex < receptorSize; ptIndex ++ )
                        {
                                const MVector &receptorPoint = points[ptIndex];

                                // Apply from every field position to every receptor position.
                                //
                                MVector forceV(0,0,0);
                                double distance = 0.0;
                                int i;
                                for(i = fieldPosCount; --i>=0; )
                                {
                                        MVector difference = (receptorPoint-posArray[i]);
                                        distance = difference.length();
                                        if (distance < minDist) continue;

                                        if (distance <= repelDist)
                                                forceV += difference * magValue;
                                        else if (distance >= attractDist)
                                                forceV += -difference * magValue;
                                }

                                // Apply drag and swarm only if the object is inside
                                // the zone the repulsion-attraction is pushing the object to.
                                //
                                if ( distance >= repelDist && distance <= attractDist)
                                {
                                        if (fieldPosCount > 0)
                                        {
                                                MVector dragForceV;
                                                dragForceV = velocities[ptIndex] *
                                                                                                (-dragMag) * fieldPosCount;
                                                forceV += dragForceV;
                                        }

                                        // Add swarm in here
                                        //
                                        double frequency = swarmFrequencyValue( block );
                                        MVector phase( 0.0, 0.0, swarmPhaseValue(block) );

                                        for(i = fieldPosCount; --i>=0; )
                                        {
                                                MVector difference = receptorPoint - posArray[i];
                                                difference = (difference + phase) * frequency;

                                                double *noiseEffect = &difference.x;
                                                if( (noiseEffect[0] < -2147483647.0) ||
                                                        (noiseEffect[0] >  2147483647.0) ||
                                                        (noiseEffect[1] < -2147483647.0) ||
                                                        (noiseEffect[1] >  2147483647.0) ||
                                                        (noiseEffect[2] < -2147483647.0) ||
                                                        (noiseEffect[2] >  2147483647.0) )
                                                        continue;

                                                double noiseOut[4];
                                                noiseFunction( noiseEffect, noiseOut );
                                                MVector swarmForce( noiseOut[0] * swarmAmp,
                                                                                        noiseOut[1] * swarmAmp,
                                                                                        noiseOut[2] * swarmAmp );
                                                forceV += swarmForce;
                                        }
                                }
                                outputForce.append( forceV );
                        }
                }
        }
}


void torusField::applyMaxDist
        (
                MDataBlock& block,                              // get field param from this block
                const MVectorArray &points,             // current position of Object
                const MVectorArray &velocities, // current velocity of Object
                const MDoubleArray &/*masses*/,         // mass of Object
                MVectorArray &outputForce               // output force
        )
//
//      Descriptions:
//              Compute output force in the case that the useMaxDistance is set.
//
{
        // points and velocities should have the same length. If not return.
        //
        if( points.length() != velocities.length() )
                return;

        // clear the output force array.
        //
        outputForce.clear();

        // get field parameters.
        //
        double magValue = magnitudeValue( block );
        double attenValue = attenuationValue( block );
        double maxDist = maxDistanceValue( block );
        double minDist = minDistanceValue( block );
        double attractDist = attractDistanceValue( block );
        double repelDist = repelDistanceValue( block );
        double dragMag = dragValue( block );
        double swarmAmp = swarmAmplitudeValue( block );

        // get owner's data. posArray may have only one point which is the centroid
        // (if this has owner) or field position(if without owner). Or it may have
        // a list of points if with owner and applyPerVertex.
        //
        MVectorArray posArray;
        posArray.clear();
        ownerPosition( block, posArray );

        int fieldPosCount = posArray.length();
        int receptorSize = points.length();

        if (attenValue > 0.0)
        {
                // Max distance applies and so does attenuation.
                //
                for (int ptIndex = 0; ptIndex < receptorSize; ptIndex ++ )
                {
                        const MVector &receptorPoint = points[ptIndex];

                        // Apply from every field position to every receptor position.
                        //
                        MVector forceV(0,0,0);
                        MVector sumForceV(0,0,0);
                        for(int i = fieldPosCount; --i>=0; )
                        {
                                MVector difference = receptorPoint-posArray[i];
                                double distance  = difference.length();
                                if (distance <= maxDist && distance >= minDist )
                                {
                                        double force = magValue *
                                                                        (pow((1.0-(distance/maxDist)),attenValue));
                                        forceV = difference * force;

                                        // Apply drag and swarm if the object is inside
                                        // the zone the repulsion-attraction is pushing the
                                        // object to, and if they are set.
                                        //
                                        if ( distance >= repelDist && distance <= attractDist)
                                        {
                                                if (fieldPosCount > 0 && dragMag > 0)
                                                {
                                                        MVector dragForceV;
                                                        dragForceV = velocities[ptIndex] *
                                                                                        (-dragMag) * fieldPosCount;
                                                        forceV += dragForceV;
                                                }

                                                // Add swarm if swarm aplitude is set.
                                                //
                                                if (swarmAmp > 0)
                                                {
                                                        double frequency = swarmFrequencyValue( block );
                                                        MVector phase( 0.0, 0.0, swarmPhaseValue(block) );

                                                        difference = receptorPoint - posArray[i];
                                                        difference = (difference + phase) * frequency;
                                                        double *noiseEffect = &difference.x;
                                                        if( (noiseEffect[0] < -2147483647.0) ||
                                                                (noiseEffect[0] >  2147483647.0) ||
                                                                (noiseEffect[1] < -2147483647.0) ||
                                                                (noiseEffect[1] >  2147483647.0) ||
                                                                (noiseEffect[2] < -2147483647.0) ||
                                                                (noiseEffect[2] >  2147483647.0) )
                                                                continue;

                                                        double noiseOut[4];
                                                        noiseFunction( noiseEffect, noiseOut );
                                                        MVector swarmForce( noiseOut[0] * swarmAmp,
                                                                                                noiseOut[1] * swarmAmp,
                                                                                                noiseOut[2] * swarmAmp );
                                                        forceV += swarmForce;
                                                }
                                        }
                                }
                                if (maxDist > 0.0) forceV *= falloffCurve(distance/maxDist);
                                sumForceV += forceV;                                    
                        }
                        outputForce.append( sumForceV );
                }
        }
        else
        {
                // Max dist applies, but not attenuation.
                //
                for (int ptIndex = 0; ptIndex < receptorSize; ptIndex ++ )
                {
                        const MVector & receptorPoint = points[ptIndex];

                        // Apply from every field position to every receptor position.
                        //
                        MVector forceV(0,0,0);
                        MVector sumForceV(0,0,0);
                        int i;
                        for(i = fieldPosCount; --i>=0; )
                        {
                                MVector difference = (receptorPoint-posArray[i]);
                                double distance = difference.length();
                                if (distance < minDist || distance > maxDist) continue;

                                if (distance <= repelDist)
                                        forceV = difference * magValue;
                                else if (distance >= attractDist)
                                        forceV = -difference * magValue;

                                // Apply drag and swarm if the object is inside
                                // the zone the repulsion-attraction is pushing the
                                // object to, and if they are set.
                                //
                                if ( distance >= repelDist && distance <= attractDist)
                                {
                                        if (fieldPosCount > 0 && dragMag > 0)
                                        {
                                                MVector dragForceV;
                                                dragForceV = velocities[ptIndex] *
                                                                                        (-dragMag) * fieldPosCount;
                                                forceV += dragForceV;
                                        }

                                        // Add swarm if swarm aplitude is set.
                                        //
                                        if (swarmAmp > 0)
                                        {
                                                double frequency = swarmFrequencyValue( block );
                                                MVector phase( 0.0, 0.0, swarmPhaseValue(block) );

                                                for(i = fieldPosCount; --i >= 0;)
                                                {
                                                        difference = receptorPoint - posArray[i];
                                                        difference = (difference + phase) * frequency;
                                                        double *noiseEffect = &difference.x;
                                                        if( (noiseEffect[0] < -2147483647.0) ||
                                                                (noiseEffect[0] >  2147483647.0) ||
                                                                (noiseEffect[1] < -2147483647.0) ||
                                                                (noiseEffect[1] >  2147483647.0) ||
                                                                (noiseEffect[2] < -2147483647.0) ||
                                                                (noiseEffect[2] >  2147483647.0) )
                                                                continue;

                                                        double noiseOut[4];
                                                        noiseFunction( noiseEffect, noiseOut );
                                                        MVector swarmForce( noiseOut[0] * swarmAmp,
                                                                                                noiseOut[1] * swarmAmp,
                                                                                                noiseOut[2] * swarmAmp );

                                                        forceV += swarmForce;
                                                }
                                        }
                                }
                                if (maxDist > 0.0) forceV *= falloffCurve(distance/maxDist);
                                sumForceV += forceV;
                        }
                        outputForce.append( sumForceV );
                }
        }
}


void torusField::ownerPosition
        (
                MDataBlock& block,
                MVectorArray &ownerPosArray
        )
//
//      Descriptions:
//              If this field has an owner, get the owner's position array or
//              centroid, then assign it to the ownerPosArray.
//              If it does not have owner, get the field position in the world
//              space, and assign it to the given array, ownerPosArray.
//
{
        MStatus status;

        if( applyPerVertexValue(block) )
        {
                MDataHandle hOwnerPos = block.inputValue( mOwnerPosData, &status );
                if( status == MS::kSuccess )
                {
                        MObject dOwnerPos = hOwnerPos.data();
                        MFnVectorArrayData fnOwnerPos( dOwnerPos );
                        MVectorArray posArray = fnOwnerPos.array( &status );
                        if( status == MS::kSuccess )
                        {
                                // assign vectors from block to ownerPosArray.
                                //
                                for( unsigned int i = 0; i < posArray.length(); i ++ )
                                        ownerPosArray.append( posArray[i] );
                        }
                        else
                        {
                                MVector worldPos(0.0, 0.0, 0.0);
                                //status = getWorldPosition( block, worldPos );
                                status = getWorldPosition( worldPos );
                                ownerPosArray.append( worldPos );
                        }
                }
                else
                {
                        // get the field position in the world space
                        // and add it into ownerPosArray.
                        //
                        MVector worldPos(0.0, 0.0, 0.0);
                        //status = getWorldPosition( block, worldPos );
                        status = getWorldPosition( worldPos );
                        ownerPosArray.append( worldPos );
                }
        }
        else
        {
                MVector centroidV(0.0, 0.0, 0.0);
                status = ownerCentroidValue( block, centroidV );
                if( status == MS::kSuccess )
                {
                        // assign centroid vector to ownerPosArray.
                        //
                        ownerPosArray.append( centroidV );
                }
                else
                {
                        // get the field position in the world space.
                        //
                        MVector worldPos(0.0, 0.0, 0.0);
                        //status = getWorldPosition( block, worldPos );
                        status = getWorldPosition( worldPos );
                        ownerPosArray.append( worldPos );
                }
        }
}


MStatus torusField::getWorldPosition( MVector &vector )
//
//      Descriptions:
//              get the field position in the world space.
//              The position value is from inherited attribute, aWorldMatrix.
//
{
        MStatus status;

        MObject thisNode = thisMObject();
        MFnDependencyNode fnThisNode( thisNode );

        // get worldMatrix attribute.
        //
        MObject worldMatrixAttr = fnThisNode.attribute( "worldMatrix" );

        // build worldMatrix plug, and specify which element the plug refers to.
        // We use the first element(the first dagPath of this field).
        //
        MPlug matrixPlug( thisNode, worldMatrixAttr );
        matrixPlug = matrixPlug.elementByLogicalIndex( 0 );

        // Get the value of the 'worldMatrix' attribute
        //
        MObject matrixObject;
        status = matrixPlug.getValue( matrixObject );
        if( !status )
        {
                status.perror("torusField::getWorldPosition: get matrixObject");
                return( status );
        }

        MFnMatrixData worldMatrixData( matrixObject, &status );
        if( !status )
        {
                status.perror("torusField::getWorldPosition: get worldMatrixData");
                return( status );
        }

        MMatrix worldMatrix = worldMatrixData.matrix( &status );
        if( !status )
        {
                status.perror("torusField::getWorldPosition: get worldMatrix");
                return( status );
        }

        // assign the translate to the given vector.
        //
        vector[0] = worldMatrix( 3, 0 );
        vector[1] = worldMatrix( 3, 1 );
        vector[2] = worldMatrix( 3, 2 );

    return( status );
}


MStatus torusField::getWorldPosition( MDataBlock& block, MVector &vector )
//
//      Descriptions:
//              Find the field position in the world space.
//
{
    MStatus status;

        MObject thisNode = thisMObject();
        MFnDependencyNode fnThisNode( thisNode );

        // get worldMatrix attribute.
        //
        MObject worldMatrixAttr = fnThisNode.attribute( "worldMatrix" );

        // build worldMatrix plug, and specify which element the plug refers to.
        // We use the first element(the first dagPath of this field).
        //
        MPlug matrixPlug( thisNode, worldMatrixAttr );
        matrixPlug = matrixPlug.elementByLogicalIndex( 0 );

    //MDataHandle hWMatrix = block.inputValue( worldMatrix, &status );
    MDataHandle hWMatrix = block.inputValue( matrixPlug, &status );

        McheckErr(status, "ERROR getting hWMatrix from dataBlock.\n");

    if( status == MS::kSuccess )
    {
        MMatrix wMatrix = hWMatrix.asMatrix();
        vector[0] = wMatrix(3, 0);
        vector[1] = wMatrix(3, 1);
        vector[2] = wMatrix(3, 2);
    }
    return( status );
}

MStatus torusField::getForceAtPoint(const MVectorArray& points,
                                  const MVectorArray&   velocities,
                                  const MDoubleArray&   masses,
                                  MVectorArray& forceArray,
                                  double        /*deltaTime*/)
//
//    This method is not required to be overridden, it is only necessary
//    for compatibility with the MFnField function set.
//
{
        MDataBlock block = forceCache();

        bool useMaxDistSet = useMaxDistanceValue( block );
        if( useMaxDistSet )
        {
                applyMaxDist( block, points, velocities, masses, forceArray );
        }
        else
        {
                applyNoMaxDist( block, points, velocities, masses, forceArray );
        }

    return MS::kSuccess;
}

MStatus torusField::iconSizeAndOrigin(  GLuint& width,
                                        GLuint& height,
                                        GLuint& xbo,
                                        GLuint& ybo   )
//
//      This method is not required to be overridden.  It should be overridden
//      if the plug-in has custom icon.
//
//      The width and height have to be a multiple of 32 on Windows and 16 on 
//      other platform.
//
//      Define an 8x8 icon at the lower left corner of the 32x32 grid. 
//      (xbo, ybo) of (4,4) makes sure the icon is center at origin.
//
{
        width = 32;
        height = 32;
        xbo = 4;
        ybo = 4;
        return MS::kSuccess;
}

MStatus torusField::iconBitmap(GLubyte* bitmap)
//
//      This method is not required to be overridden.  It should be overridden
//      if the plug-in has custom icon.
//
//      Define an 8x8 icon at the lower left corner of the 32x32 grid. 
//      (xbo, ybo) of (4,4) makes sure the icon is center at origin.
{
        bitmap[0] = 0x18;
        bitmap[4] = 0x66;
        bitmap[8] = 0xC3;
        bitmap[12] = 0x81;
        bitmap[16] = 0x81;
        bitmap[20] = 0xC3;
        bitmap[24] = 0x66;
        bitmap[28] = 0x18;

        return MS::kSuccess;
}

#define rand3a(x,y,z)   frand(67*(x)+59*(y)+71*(z))
#define rand3b(x,y,z)   frand(73*(x)+79*(y)+83*(z))
#define rand3c(x,y,z)   frand(89*(x)+97*(y)+101*(z))
#define rand3d(x,y,z)   frand(103*(x)+107*(y)+109*(z))

int             xlim[3][2];             // integer bound for point
double  xarg[3];                // fractional part

double frand( register int s )   // get random number from seed
{
        s = s << 13^s;
        return(1. - ((s*(s*s*15731+789221)+1376312589)&0x7fffffff)/1073741824.);
}

double hermite( double p0, double p1, double r0, double r1, double t )
{
        register double t2, t3, _3t2, _2t3 ;
        t2 = t * t;
        t3 = t2 * t;
        _3t2 = 3. * t2;
        _2t3 = 2. * t3 ;

        return(p0*(_2t3-_3t2+1) + p1*(-_2t3+_3t2) + r0*(t3-2.*t2+t) + r1*(t3-t2));
}

void interpolate( double f[4], register int i, register int n )
//
//      f[] returned tangent and value *
//      i   location ?
//      n   order
//
{
        double f0[4], f1[4] ;  //results for first and second halves

        if( n == 0 )    // at 0, return lattice value
        {
                f[0] = rand3a( xlim[0][i&1], xlim[1][i>>1&1], xlim[2][i>>2] );
                f[1] = rand3b( xlim[0][i&1], xlim[1][i>>1&1], xlim[2][i>>2] );
                f[2] = rand3c( xlim[0][i&1], xlim[1][i>>1&1], xlim[2][i>>2] );
                f[3] = rand3d( xlim[0][i&1], xlim[1][i>>1&1], xlim[2][i>>2] );
                return;
        }

        n--;
        interpolate( f0, i, n );                // compute first half
        interpolate( f1, i| 1<<n, n );  // compute second half

        // use linear interpolation for slopes
        //
        f[0] = (1. - xarg[n]) * f0[0] + xarg[n] * f1[0];
        f[1] = (1. - xarg[n]) * f0[1] + xarg[n] * f1[1];
        f[2] = (1. - xarg[n]) * f0[2] + xarg[n] * f1[2];

        // use hermite interpolation for values
        //
        f[3] = hermite( f0[3], f1[3], f0[n], f1[n], xarg[n] );
}

void torusField::noiseFunction( double *inNoise, double *out )
//
//      Descriptions:
//              A noise function.
//
{
        xlim[0][0] = (int)floor( inNoise[0] );
        xlim[0][1] = xlim[0][0] + 1;
        xlim[1][0] = (int)floor( inNoise[1] );
        xlim[1][1] = xlim[1][0] + 1;
        xlim[2][0] = (int)floor( inNoise[2] );
        xlim[2][1] = xlim[2][0] + 1;

        xarg[0] = inNoise[0] - xlim[0][0];
        xarg[1] = inNoise[1] - xlim[1][0];
        xarg[2] = inNoise[2] - xlim[2][0];

        interpolate( out, 0, 3 ) ;
}

#define TORUS_PI 3.14159265
#define TORUS_2PI 2*TORUS_PI
#define EDGES 30
#define SEGMENTS 20

//
//      Descriptions:
//              Draw a set of rings to symbolie the field. This does not override default icon, you can do that by implementing the iconBitmap() function
//
void torusField::draw( M3dView& view, const MDagPath& path, M3dView::DisplayStyle style, M3dView:: DisplayStatus )
{
         view.beginGL();
         for (int j = 0; j < SEGMENTS; j++ )
         {
                glPushMatrix();
                glRotatef( GLfloat(360 * j / SEGMENTS), 0.0, 1.0, 0.0 );
                glTranslatef( 1.5, 0.0, 0.0 );

                 for (int i = 0; i < EDGES; i++ )
                 {
                        glBegin(GL_LINE_STRIP);
                        float p0 = float( TORUS_2PI * i / EDGES );
                        float p1 = float( TORUS_2PI * (i+1) / EDGES );
                        glVertex2f( cos(p0), sin(p0) );
                        glVertex2f( cos(p1), sin(p1) );
                        glEnd();
                 }
                glPopMatrix();
         }
         view.endGL ();
}


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

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

        return status;
}

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

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

        return status;
}