torusField.py

#-
# ==========================================================================
# Copyright (C) 1995 - 2006 Autodesk, Inc. and/or its licensors.  All 
# rights reserved.
#
# The coded instructions, statements, computer programs, and/or related 
# material (collectively the "Data") in these files contain unpublished 
# information proprietary to Autodesk, Inc. ("Autodesk") and/or its 
# licensors, which is protected by U.S. and Canadian federal copyright 
# law and by international treaties.
#
# The Data is provided for use exclusively by You. You have the right 
# to use, modify, and incorporate this Data into other products for 
# purposes authorized by the Autodesk software license agreement, 
# without fee.
#
# The copyright notices in the Software and this entire statement, 
# including the above license grant, this restriction and the 
# following disclaimer, must be included in all copies of the 
# Software, in whole or in part, and all derivative works of 
# the Software, unless such copies or derivative works are solely 
# in the form of machine-executable object code generated by a 
# source language processor.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND. 
# AUTODESK DOES NOT MAKE AND HEREBY DISCLAIMS ANY EXPRESS OR IMPLIED 
# WARRANTIES INCLUDING, BUT NOT LIMITED TO, THE WARRANTIES OF 
# NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR 
# PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE, OR 
# TRADE PRACTICE. IN NO EVENT WILL AUTODESK AND/OR ITS LICENSORS 
# BE LIABLE FOR ANY LOST REVENUES, DATA, OR PROFITS, OR SPECIAL, 
# DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES, EVEN IF AUTODESK 
# AND/OR ITS LICENSORS HAS BEEN ADVISED OF THE POSSIBILITY 
# OR PROBABILITY OF SUCH DAMAGES.
#
# ==========================================================================
#+

#
# Creation Date:   3 October 2006
#
# Example Plugin: torusField.py
#
#  Description
#       The torusField node implements an attraction-and-repel field.
#
#       The field repels all objects between itself and repelDistance attribute
#       and attracts objects greater than attractDistance attribute from itself.  
#       This will eventually result in the objects clustering
#       in a torus shape around the field.
#
#       See torusFieldTest.py for usage
#

import math, sys
import maya.OpenMaya as OpenMaya
import maya.OpenMayaUI as OpenMayaUI
import maya.OpenMayaMPx as OpenMayaMPx
import maya.OpenMayaRender as OpenMayaRender

kPluginName = "spTorusField"
kPluginNodeId = OpenMaya.MTypeId(0x87008)

glRenderer = OpenMayaRender.MHardwareRenderer.theRenderer()
glFT = glRenderer.glFunctionTable()

def statusError(msg):
        sys.stderr.write("%s\n" % message)
        raise   # called from exception handlers only, reraise exception


# Node definition
class TorusField(OpenMayaMPx.MPxFieldNode):
        # Attributes
        # minimum distance from field at which repel is applied
        #
        aMinDistance = OpenMaya.MObject()

        # min distance from field at which the force attracts
        #
        aAttractDistance = OpenMaya.MObject()

        # max distance from field at which the force repels.
        #
        aRepelDistance = OpenMaya.MObject()

        # drag exerted on the attractRepel force.
        #
        aDrag = OpenMaya.MObject()

        # amplitude/magnitude of the swarm force.
        #
        aSwarmAmplitude = OpenMaya.MObject()

        # frequency of the swarm force.
        #
        aSwarmFrequency = OpenMaya.MObject()

        # phase of the swarm force.
        #
        aSwarmPhase = OpenMaya.MObject()


        def __init__(self):
                OpenMayaMPx.MPxFieldNode.__init__(self)


        def compute(self, plug, block):
                """
                Compute output force.
                """
                outputForce = OpenMayaMPx.cvar.MPxFieldNode_mOutputForce
                if not (plug == outputForce):
                        return

                # get the logical index of the element this plug refers to.
                #
                try:
                        multiIndex = plug.logicalIndex()
                except:
                        statusError("ERROR in plug.logicalIndex.")

                # 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.
                #
                inputData = OpenMayaMPx.cvar.MPxFieldNode_mInputData
                try:
                        hInputArray = block.outputArrayValue(inputData)
                except:
                        statusError("ERROR in hInputArray = block.outputArrayValue().")

                try:
                        hInputArray.jumpToElement(multiIndex)
                except:
                        statusError("ERROR: hInputArray.jumpToElement failed.")

                # get children of aInputData.
                #
                try:
                        hCompond = hInputArray.inputValue()
                except:
                        statusError("ERROR in hCompond=hInputArray.inputValue")

                inputPositions = OpenMayaMPx.cvar.MPxFieldNode_mInputPositions
                hPosition = hCompond.child(inputPositions)
                dPosition = hPosition.data()
                fnPosition = OpenMaya.MFnVectorArrayData(dPosition)
                try:
                        points = fnPosition.array()
                except:
                        statusError("ERROR in fnPosition.array(), not find points.")

                inputVelocities = OpenMayaMPx.cvar.MPxFieldNode_mInputVelocities
                hVelocity = hCompond.child(inputVelocities)
                dVelocity = hVelocity.data()
                fnVelocity = OpenMaya.MFnVectorArrayData(dVelocity)
                try:
                        velocities = fnVelocity.array()
                except:
                        statusError("ERROR in fnVelocity.array(), not find velocities.")

                inputMass = OpenMayaMPx.cvar.MPxFieldNode_mInputMass
                hMass = hCompond.child(inputMass)
                dMass = hMass.data()
                fnMass = OpenMaya.MFnDoubleArrayData(dMass)
                try:
                        masses = fnMass.array()
                except:
                        statusError("ERROR in fnMass.array(), not find masses.")

                # Compute the output force.
                #
                forceArray = OpenMaya.MVectorArray()
                useMaxDistSet = self.__useMaxDistanceValue(block)
                if useMaxDistSet:
                        self.__applyMaxDist(block, points, velocities, masses, forceArray)
                else:
                        self.__applyNoMaxDist(block, points, velocities, masses, forceArray)

                # get output data handle
                #
                try:
                        hOutArray = block.outputArrayValue(outputForce)
                except:
                        statusError("ERROR in hOutArray = block.outputArrayValue.")
                try:
                        bOutArray = hOutArray.builder()
                except:
                        statusError("ERROR in bOutArray = hOutArray.builder.")

                # get output force array from block.
                #
                try:
                        hOut = bOutArray.addElement(multiIndex)
                except:
                        statusError("ERROR in hOut = bOutArray.addElement.")

                fnOutputForce = OpenMaya.MFnVectorArrayData()
                try:
                        dOutputForce = fnOutputForce.create(forceArray)
                except:
                        statusError("ERROR in dOutputForce = fnOutputForce.create")

                # update data block with new output force data.
                #
                hOut.setMObject(dOutputForce)
                block.setClean(plug)


        def draw (self, view, path, style, status):
                """
                Draw a set of rings to symbolie the field. This does not override default icon, you can do that by implementing the iconBitmap() function
                """
                TORUS_PI = 3.14159265
                TORUS_2PI = 2.0 * TORUS_PI
                EDGES = 30
                SEGMENTS = 20

                view.beginGL()
                for j in range(SEGMENTS):
                        glFT.glPushMatrix()
                        glFT.glRotatef(360.0 * j / SEGMENTS, 0.0, 1.0, 0.0)
                        glFT.glTranslatef(1.5, 0.0, 0.0)
                        for i in range(EDGES):
                                glFT.glBegin(OpenMayaRender.MGL_LINE_STRIP)
                                p0 = TORUS_2PI * i / EDGES
                                p1 = TORUS_2PI * (i+1) / EDGES
                                glFT.glVertex2f(math.cos(p0), math.sin(p0))
                                glFT.glVertex2f(math.cos(p1), math.sin(p1))
                                glFT.glEnd()
                        glFT.glPopMatrix()
                view.endGL()


        def getForceAtPoint(self, points, velocities, masses, forceArray, deltaTime):
                """
                This method is not required to be overridden, it is only necessary
                for compatibility with the MFnField function set.
                """
                block = forceCache()
                useMaxDistSet = self.__useMaxDistanceValue(block)
                if useMaxDistSet:
                        self.__applyMaxDist(block, points, velocities, masses, forceArray)
                else:
                        self.__applyNoMaxDist(block, points, velocities, masses, forceArray)


        def iconSizeAndOrigin(self, width, height, xbo, ybo):
                OpenMaya.MScriptUtil.setUint( width, 32 )
                OpenMaya.MScriptUtil.setUint( height, 32 )
                OpenMaya.MScriptUtil.setUint( xbo, 4 )
                OpenMaya.MScriptUtil.setUint( ybo, 4 )


        def iconBitmap(self, bitmap):
                OpenMaya.MScriptUtil.setUcharArray( bitmap, 0, 0x18 )
                OpenMaya.MScriptUtil.setUcharArray( bitmap, 4, 0x66 )
                OpenMaya.MScriptUtil.setUcharArray( bitmap, 8, 0xC3 )
                OpenMaya.MScriptUtil.setUcharArray( bitmap, 12, 0x81 )
                OpenMaya.MScriptUtil.setUcharArray( bitmap, 16, 0x81 )
                OpenMaya.MScriptUtil.setUcharArray( bitmap, 20, 0xC3 )
                OpenMaya.MScriptUtil.setUcharArray( bitmap, 24, 0x66 )
                OpenMaya.MScriptUtil.setUcharArray( bitmap, 28, 0x18 )


        # methods to compute output force.
        #
        def __applyNoMaxDist(self, block, points, velocities, masses, outputForce):
                """
                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.
                #
                magValue = self.__magnitudeValue(block)
                minDist = self.__minDistanceValue(block)
                attractDist = self.__attractDistanceValue(block)
                repelDist = self.__repelDistanceValue(block)
                dragMag = self.__dragValue(block)
                swarmAmp = self.__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.
                #
                posArray = self.__ownerPosition(block)

                fieldPosCount = posArray.length()
                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.
                #
                for ptIndex in range(receptorSize):
                        forceV = OpenMaya.MVector(0.0,0.0,0.0)
                        receptorPoint = points[ptIndex]

                        # Apply from every field position to every receptor position.
                        #
                        distance = 0.0
                        for i in range(fieldPosCount-1, -1, -1):
                                difference = receptorPoint - posArray[i]
                                distance = difference.length()

                                if distance < minDist:
                                        continue

                                if distance <= repelDist:
                                        forceV += difference * magValue
                                elif distance >= attractDist:
                                        forceV += -difference * magValue

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

                                if swarmAmp > 0:
                                        frequency = self.__swarmFrequencyValue(block)
                                        phase = OpenMaya.MVector(0.0, 0.0, frequency)

                                        # Add swarm in here
                                        #
                                        for i in range(fieldPosCount-1, -1, -1):
                                                difference = receptorPoint - posArray[i]
                                                difference = (difference + phase) * frequency

                                                noiseEffect = [ difference[i] for i in range(3) ]
                                                if( (noiseEffect[0] < -2147483647.0) or
                                                        (noiseEffect[0] >  2147483647.0) or
                                                        (noiseEffect[1] < -2147483647.0) or
                                                        (noiseEffect[1] >  2147483647.0) or
                                                        (noiseEffect[2] < -2147483647.0) or
                                                        (noiseEffect[2] >  2147483647.0) ):
                                                        continue

                                                noiseOut = self.__noiseFunction(noiseEffect)
                                                swarmForce = OpenMaya.MVector(noiseOut[0] * swarmAmp,
                                                                                                                noiseOut[1] * swarmAmp,
                                                                                                                noiseOut[2] * swarmAmp)
                                                forceV += swarmForce

                        outputForce.append(forceV)


        def __applyMaxDist(self, block, points, velocities, masses, outputForce):
                """
                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.
                #
                magValue = self.__magnitudeValue(block)
                attenValue = self.__attenuationValue(block)
                maxDist = self.__maxDistanceValue(block)
                minDist = self.__minDistanceValue(block)
                attractDist = self.__attractDistanceValue(block)
                repelDist = self.__repelDistanceValue(block)
                dragMag = self.__dragValue(block)
                swarmAmp = self.__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.
                #
                posArray = self.__ownerPosition(block)

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

                for ptIndex in range(receptorSize):
                        receptorPoint = points[ptIndex]

                        # Apply from every field position to every receptor position.
                        #
                        forceV = OpenMaya.MVector(0,0,0)
                        sumForceV = OpenMaya.MVector(0,0,0)
                        for i in range(fieldPosCount-1, -1, -1):
                                difference = receptorPoint-posArray[i]
                                distance  = difference.length()

                                if (distance < minDist or distance > maxDist):
                                        continue

                                if attenValue > 0.0:
                                        force = magValue * (math.pow((1.0-(distance/maxDist)),attenValue))
                                        forceV = difference * force
                                elif (distance <= repelDist):
                                        forceV = difference * magValue
                                elif (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 and distance <= attractDist:
                                        if dragMag > 0:
                                                if fieldPosCount > 0:
                                                        dragForceV = velocities[ptIndex] * (-dragMag) * fieldPosCount
                                                        forceV += dragForceV

                                        if swarmAmp > 0:
                                                frequency = self.__swarmFrequencyValue(block)
                                                phase = OpenMaya.MVector(0.0, 0.0, frequency)

                                                # Add swarm in here
                                                #
                                                for i in range(fieldPosCount-1, -1, -1):
                                                        difference = receptorPoint - posArray[i]
                                                        difference = (difference + phase) * frequency

                                                        noiseEffect = [ difference[i] for i in range(3) ]
                                                        if( (noiseEffect[0] < -2147483647.0) or
                                                                (noiseEffect[0] >  2147483647.0) or
                                                                (noiseEffect[1] < -2147483647.0) or
                                                                (noiseEffect[1] >  2147483647.0) or
                                                                (noiseEffect[2] < -2147483647.0) or
                                                                (noiseEffect[2] >  2147483647.0) ):
                                                                continue

                                                        noiseOut = self.__noiseFunction(noiseEffect)
                                                        swarmForce = OpenMaya.MVector(noiseOut[0] * swarmAmp,
                                                                                                                        noiseOut[1] * swarmAmp,
                                                                                                                        noiseOut[2] * swarmAmp)
                                                        forceV += swarmForce

                                if (maxDist > 0.0):
                                        forceV *= self.falloffCurve(distance/maxDist)
                                sumForceV += forceV

                        outputForce.append(sumForceV)


        def __ownerPosition(self, block):
                """
                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.
                """
                ownerPosArray = OpenMaya.MVectorArray()
                if self.__applyPerVertexValue(block):
                        ownerPos = OpenMayaMPx.cvar.MPxFieldNode_mOwnerPosData
                        try:
                                hOwnerPos = block.inputValue(ownerPos)
                        except:
                                # get the field position in the world space
                                # and add it into ownerPosArray.
                                #
                                worldPos = self.__getWorldPosition()
                                ownerPosArray.append(worldPos)
                        else:
                                dOwnerPos = hOwnerPos.data()
                                fnOwnerPos = OpenMaya.MFnVectorArrayData(dOwnerPos)
                                try:
                                        posArray = fnOwnerPos.array()
                                except:
                                        worldPos = self.__getWorldPosition()
                                        ownerPosArray.append(worldPos)
                                else:
                                        # assign vectors from block to ownerPosArray.
                                        #
                                        for i in range(posArray.length()):
                                                ownerPosArray.append(posArray[i])
                else:
                        try:
                                centroidV = self.__ownerCentroidValue(block)
                        except:
                                # get the field position in the world space.
                                #
                                worldPos = self.__getWorldPosition()
                                ownerPosArray.append(worldPos)
                        else:
                                ownerPosArray.append(centroidV) 

                return ownerPosArray


        def __getWorldPosition(self):
                thisNode = self.thisMObject()
                fnThisNode = OpenMaya.MFnDependencyNode(thisNode)

                # get worldMatrix attribute.
                #
                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).
                #
                matrixPlug = OpenMaya.MPlug(thisNode, worldMatrixAttr)
                matrixPlug = matrixPlug.elementByLogicalIndex(0)

                # Get the value of the 'worldMatrix' attribute
                #
                try:
                        matrixObject = matrixPlug.asMObject(matrixObject)
                except:
                        statusError("TorusField.__getWorldPosition: get matrixObject")

                try:
                        worldMatrixData = OpenMaya.MFnMatrixData(matrixObject)
                except:
                        statusError("TorusField.__getWorldPosition: get worldMatrixData")

                try:
                        worldMatrix = worldMatrixData.matrix()
                except:
                        statusError("TorusField.__getWorldPosition: get worldMatrix")

                # assign the translate to the given vector.
                #
                return OpenMaya.MVector(worldMatrix(3, 0), worldMatrix(3, 1), worldMatrix(3, 2))


        def __noiseFunction(self, inNoise):
                """
                A noise function
                """
                # Shared data for noise computation
                #
                xlim = [ [0,0], [0,0], [0,0] ] # integer bound for point
                xarg = [0.0, 0.0, 0.0 ] # fractional part

                # Helper functions to compute noise
                #
                rand3a = lambda x,y,z: frand(67*(x)+59*(y)+71*(z))
                rand3b = lambda x,y,z: frand(73*(x)+79*(y)+83*(z))
                rand3c = lambda x,y,z: frand(89*(x)+97*(y)+101*(z))
                rand3d = lambda x,y,z: frand(103*(x)+107*(y)+109*(z))

                def frand(s):
                        seed = s << 13^s
                        return (1.0 - ((s*(s*s*15731+789221)+1376312589) & 0x7fffffff)/1073741824.0)

                def hermite(p0, p1, r0, r1, t):
                        t2 = t * t
                        t3 = t2 * t
                        _3t2 = 3.0 * t2
                        _2t3 = 2.0 * t3 

                        return (p0*(_2t3-_3t2+1) + p1*(-_2t3+_3t2) + r0*(t3-2.0*t2+t) + r1*(t3-t2))

                def interpolate(i, n):
                        f = [ 0.0, 0.0, 0.0, 0.0 ]
                        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] )
                        else:
                                n -= 1
                                f0 = interpolate(i, n) # compute first half
                                f1 = interpolate(i | 1<<n, n) # compute second half

                                # use linear interpolation for slopes
                                f[0] = (1.0 - xarg[n]) * f0[0] + xarg[n] * f1[0]
                                f[1] = (1.0 - xarg[n]) * f0[1] + xarg[n] * f1[1]
                                f[2] = (1.0 - 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])

                        return f

                xlim[0][0] = int(math.floor(inNoise[0]))
                xlim[0][1] = xlim[0][0] + 1
                xlim[1][0] = int(math.floor(inNoise[1]))
                xlim[1][1] = xlim[1][0] + 1
                xlim[2][0] = int(math.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]

                return interpolate(0, 3)


        # methods to get attribute value.
        #
        def __magnitudeValue(self, block):
                magnitude = OpenMayaMPx.cvar.MPxFieldNode_mMagnitude
                hValue = block.inputValue(magnitude)
                return hValue.asDouble()


        def __attenuationValue(self, block):
                attenuation = OpenMayaMPx.cvar.MPxFieldNode_mAttenuation
                hValue = block.inputValue(attenuation)
                return hValue.asDouble()


        def __maxDistanceValue(self, block):
                maxDistance = OpenMayaMPx.cvar.MPxFieldNode_mMaxDistance
                hValue = block.inputValue(maxDistance)
                return hValue.asDouble()


        def __useMaxDistanceValue(self, block):
                useMaxDistance = OpenMayaMPx.cvar.MPxFieldNode_mUseMaxDistance
                hValue = block.inputValue(useMaxDistance)
                return hValue.asBool()


        def __applyPerVertexValue(self, block):
                applyPerVertex = OpenMayaMPx.cvar.MPxFieldNode_mApplyPerVertex
                hValue = block.inputValue(applyPerVertex)
                return hValue.asBool()


        # methods to get attribute value of local attributes.
        #
        def __minDistanceValue(self, block):
                hValue = block.inputValue(TorusField.aMinDistance)
                return hValue.asDouble()


        def __attractDistanceValue(self, block):
                hValue = block.inputValue(TorusField.aAttractDistance)
                return hValue.asDouble()


        def __repelDistanceValue(self, block):
                hValue = block.inputValue(TorusField.aRepelDistance)
                return hValue.asDouble()


        def __dragValue(self, block):
                hValue = block.inputValue(TorusField.aDrag)
                return hValue.asDouble()


        def __swarmAmplitudeValue(self, block):
                hValue = block.inputValue(TorusField.aSwarmAmplitude)
                return hValue.asDouble()


        def __swarmFrequencyValue(self, block):
                hValue = block.inputValue(TorusField.aSwarmFrequency)
                return hValue.asDouble()


        def __swarmPhaseValue(self, block):
                hValue = block.inputValue(TorusField.aSwarmPhase)
                return hValue.asDouble()


        def __ownerCentroidValue(self, block):
                ownerCentroidX = OpenMayaMPx.cvar.MPxFieldNode_mOwnerCentroidX
                ownerCentroidY = OpenMayaMPx.cvar.MPxFieldNode_mOwnerCentroidY
                ownerCentroidZ = OpenMayaMPx.cvar.MPxFieldNode_mOwnerCentroidZ
                hValueX = block.inputValue(ownerCentroidX)
                hValueY = block.inputValue(ownerCentroidY)
                hValueZ = block.inputValue(ownerCentroidZ)
                return OpenMaya.MVector(hValueX.asDouble(),
                                                                        hValueY.asDouble(),
                                                                        hValueZ.asDouble())


############################################################################


# creator
def nodeCreator():
        return OpenMayaMPx.asMPxPtr(TorusField())


# initializer
def nodeInitializer():
        numAttr = OpenMaya.MFnNumericAttribute()

        # create the field basic attributes.
        #
        TorusField.aMinDistance = numAttr.create("minDistance", "mnd", OpenMaya.MFnNumericData.kDouble, 0.0)
        numAttr.setKeyable(True)
        try:
                TorusField.addAttribute(TorusField.aMinDistance)
        except:
                statusError("ERROR adding aMinDistance attribute.")

        TorusField.aAttractDistance = numAttr.create("attractDistance", "ad", OpenMaya.MFnNumericData.kDouble, 20.0)
        numAttr.setKeyable(True)
        try:
                TorusField.addAttribute(TorusField.aAttractDistance)
        except:
                statusError("ERROR adding aAttractDistance attribute.")

        TorusField.aRepelDistance = numAttr.create("repelDistance", "rd", OpenMaya.MFnNumericData.kDouble, 10.0)
        numAttr.setKeyable(True)
        try:
                TorusField.addAttribute(TorusField.aRepelDistance)
        except:
                statusError("ERROR adding aRepelDistance attribute.")

        TorusField.aDrag = numAttr.create("drag", "d", OpenMaya.MFnNumericData.kDouble, 0.0)
        numAttr.setKeyable(True)
        try:
                TorusField.addAttribute(TorusField.aDrag)
        except:
                statusError("ERROR adding aDrag attribute.")

        TorusField.aSwarmAmplitude = numAttr.create("swarmAmplitude", "samp", OpenMaya.MFnNumericData.kDouble, 0.0)
        numAttr.setKeyable(True)
        try:
                TorusField.addAttribute(TorusField.aSwarmAmplitude)
        except:
                statusError("ERROR adding aSwarmAmplitude attribute.")

        TorusField.aSwarmFrequency = numAttr.create("swarmFrequency", "sfrq", OpenMaya.MFnNumericData.kDouble, 1.0)
        numAttr.setKeyable(True)
        try:
                TorusField.addAttribute(TorusField.aSwarmFrequency)
        except:
                statusError("ERROR adding aSwarmFrequency attribute.")

        TorusField.aSwarmPhase = numAttr.create("swarmPhase", "sa", OpenMaya.MFnNumericData.kDouble, 0.0)
        numAttr.setKeyable(True)
        try:
                TorusField.addAttribute(TorusField.aSwarmPhase)
        except:
                statusError("ERROR adding aSwarmPhase attribute.")


# initialize the script plug-in
def initializePlugin(mobject):
        mplugin = OpenMayaMPx.MFnPlugin(mobject, "Autodesk", "1.0", "Any")
        try:
                mplugin.registerNode(kPluginName, kPluginNodeId, nodeCreator, nodeInitializer, OpenMayaMPx.MPxNode.kFieldNode)
        except:
                statusError("Failed to register node: %s" % kPluginName)


# uninitialize the script plug-in
def uninitializePlugin(mobject):
        mplugin = OpenMayaMPx.MFnPlugin(mobject)
        try:
                mplugin.deregisterNode(kPluginNodeId)
        except:
                statusError("Failed to deregister node: %s" % kPluginName)