jigglePoint

 

#-*- coding: cp949 -*-
import maya.OpenMayaMPx as omMPx
import maya.OpenMaya as om
import math

 

 

 

class JigglePoint( omMPx.MPxNode ):

    #____ 어트리뷰트들을 선언

    kPluginNodeId= om.MTypeId(0x00001234)

    aOutput = om.MObject()
    aGoal = om.MObject()
    aDamping = om.MObject()
    aStiffness = om.MObject()
    aParentInverse = om.MObject() 
    aJiggleAmount = om.MObject()  
    aTime = om.MObject()

 

 

    def __init__( self ):

        #____ 계산에 필요한 변수들을 선언
        omMPx.MPxNode.__init__( self )

        self._initialized = False
        self._currentPosition = om.MPoint()
        self._previousPosition = om.MPoint()
        self._previousTime = om.MTime()

 

    def compute( self, plug, data ):
        if plug != JigglePoint.aOutput:
            return om.kUnknownParameter

 

        damping = data.inputValue( self.aDamping ).asFloat()
        stiffness = data.inputValue( self.aStiffness ).asFloat()
        goal = om.MPoint( data.inputValue(self.aGoal).asFloatVector() )
        currentTime = data.inputValue( self.aTime ).asTime()
        parentInverse = data.inputValue( self.aParentInverse ).asMatrix()
        jiggleAmount = data.inputValue( self.aJiggleAmount ).asFloat()

 

        if not self._initialized:
            self._previousTime = currentTime
            self._currentPosition = goal
            self._previousPosition = goal
            self._initialized = True
           
        timeDifference = currentTime.value() - self._previousTime.value()
        if timeDifference > 1.0 or timeDifference < 0.0:
            self._initialized = False
            self._previousTime = currentTime
            return

        velocity = ( self._currentPosition - self._previousPosition ) * ( 1.0 - damping )
        newPosition = self._currentPosition + velocity
        goalForce = ( goal - newPosition ) * stiffness
        newPosition += goalForce

        self._previousPosition = om.MPoint( self._currentPosition )
        self._currentPosition = om.MPoint( newPosition )
        self._previousTime = om.MTime( currentTime )

        newPosition = goal + ( ( newPosition - goal) * jiggleAmount )

        newPosition *= parentInverse

        hOutput = data.outputValue( JigglePoint.aOutput )
        outVector = om.MFloatVector( newPosition.x, newPosition.y, newPosition.z )
        hOutput.setMFloatVector( outVector )
        hOutput.setClean()
        data.setClean( plug )

 

 

def creator():
    return omMPx.asMPxPtr( JigglePoint() )

def initialize():
    nAttr = om.MFnNumericAttribute()
    uAttr = om.MFnUnitAttribute()
    mAttr = om.MFnMatrixAttribute()

    JigglePoint.aOutput = nAttr.createPoint( 'output', 'out' )
    nAttr.setWritable( False )
    nAttr.setStorable( False )
    JigglePoint.addAttribute( JigglePoint.aOutput )

    JigglePoint.aJiggleAmount = nAttr.create( 'jiggle', 'jiggle', om.MFnNumericData.kFloat, 0.0 )
    nAttr.setKeyable( True )
    nAttr.setMin( 0.0 )
    nAttr.setMax( 1.0 )
    JigglePoint.addAttribute( JigglePoint.aJiggleAmount )
    JigglePoint.attributeAffects( JigglePoint.aJiggleAmount, JigglePoint.aOutput )

    JigglePoint.aGoal = nAttr.createPoint( 'goal', 'goal' )
    JigglePoint.addAttribute( JigglePoint.aGoal )
    JigglePoint.attributeAffects( JigglePoint.aGoal, JigglePoint.aOutput )

    JigglePoint.aTime = uAttr.create( 'time', 'time', om.MFnUnitAttribute.kTime, 0.0 )
    JigglePoint.addAttribute( JigglePoint.aTime )
    JigglePoint.attributeAffects( JigglePoint.aTime, JigglePoint.aOutput )

    JigglePoint.aStiffness = nAttr.create( 'stiffness', 'stiffness', om.MFnNumericData.kFloat, 1.0 )
    nAttr.setKeyable( True )
    nAttr.setMin( 0.0 )
    nAttr.setMax( 1.0 )
    JigglePoint.addAttribute( JigglePoint.aStiffness )
    JigglePoint.attributeAffects( JigglePoint.aStiffness, JigglePoint.aOutput )

    JigglePoint.aDamping = nAttr.create( 'damping', 'damping', om.MFnNumericData.kFloat, 1.0 )
    nAttr.setKeyable( True )
    nAttr.setMin( 0.0 )
    nAttr.setMax( 1.0 )
    JigglePoint.addAttribute( JigglePoint.aDamping )
    JigglePoint.attributeAffects( JigglePoint.aDamping, JigglePoint.aOutput )   

    JigglePoint.aParentInverse = mAttr.create( 'parentInverse', 'parentInverse' )
    JigglePoint.addAttribute( JigglePoint.aParentInverse )

def initializePlugin( obj ):
    fnPlugin = omMPx.MFnPlugin( obj, 'chad Vernon', '1.0', 'Any' )
    fnPlugin.registerNode( 'jigglePoint', JigglePoint.kPluginNodeId, creator, initialize )

def uninitializePlugin( obj ):
    fnPlugin = omMPx.MFnPlugin( obj )
    fnPlugin.deregisterNode( JigglePoint.kPluginNodeId )