def importCache( targets, cacheFolderPath ):
import sgFunctionCache
import random
for target in targets:
target = sgModelDag.getTransform( target )
attrNum = cmds.getAttr( target+'.cacheAttr' )
xmlFileName = 'riceType_%02dShape.xml' % ( attrNum )
xmlFilePath = cacheFolderPath + '/' + xmlFileName
animCurve = sgModelDg.getRoofLinearCurve( 1, 32, 1, 32 )
addNode = cmds.createNode( 'addDoubleLinear' )
sgFunctionCache.importCache( target, xmlFilePath )
time1 = sgModelDag.getNodeFromHistory( target, 'time' )[0]
cacheFile = sgModelDag.getNodeFromHistory( target, 'cacheFile' )[0]
sgRigAttribute.addAttr( target, ln='cacheOffset', k=1, dv=random.uniform( 1, 32 ) )
cmds.connectAttr( time1+'.outTime', addNode+'.input1' )
cmds.connectAttr( target+'.cacheOffset', addNode+'.input2' )
cmds.connectAttr( addNode+'.output', animCurve+'.input' )
cmds.connectAttr( animCurve+'.output', cacheFile+'.time', f=1 )
def getInfluenceAndWeightList(mesh, vertices=[]):
skinClusters = sgModelDag.getNodeFromHistory(mesh, 'skinCluster')
if not skinClusters: return None
skinCluster = skinClusters[0]
fnSkinCluster = sgModelDg.getDependNode(skinCluster)
plugWeightList = fnSkinCluster.findPlug('weightList')
if not vertices:
vertices = [i for i in range(plugWeightList.numElements())]
influenceAndWeightList = [[] for i in range(len(vertices))]
phygicalMap = [0 for i in range(plugWeightList.numElements())]
for i in range(len(vertices)):
logicalIndex = vertices[i]
plugWeights = plugWeightList[logicalIndex].child(0)
influenceNums = []
values = []
for j in range(plugWeights.numElements()):
influenceNum = plugWeights[j].logicalIndex()
value = plugWeights[j].asFloat()
influenceNums.append(influenceNum)
values.append(value)
influenceAndWeightList[i] = [influenceNums, values]
phygicalMap[logicalIndex] = i
return influenceAndWeightList, phygicalMap
def connectHairControl(ctl, hairSystem):
hairSystem = sgModelDag.getNodeFromHistory(hairSystem, 'hairSystem')[0]
try:
sgRigAttribute.addAttr(ctl, ln='________', en='Hair:', at='enum', cb=1)
except:
pass
sgRigAttribute.addAttr(ctl, ln='dynamicOn', min=0, max=1, at='long', cb=1)
sgRigAttribute.addAttr(ctl, ln='startFrame', dv=1, at='long', cb=1)
sgRigAttribute.addAttr(ctl, ln='attraction', min=0, max=1, dv=1, k=1)
sgRigAttribute.addAttr(ctl, ln='attractionDamp', min=0, dv=0.5, k=1)
sgRigAttribute.addAttr(ctl, ln='stiffness', min=0, max=1, dv=0.15, k=1)
sgRigAttribute.addAttr(ctl, ln='mass', min=0.1, dv=1, k=1)
sgRigAttribute.addAttr(ctl, ln='drag', min=0, dv=0.05, k=1)
condition = cmds.createNode('condition')
cmds.setAttr(condition + '.secondTerm', 0)
cmds.setAttr(condition + '.colorIfTrueR', 1)
cmds.setAttr(condition + '.colorIfFalseR', 3)
connectAttrCommon(ctl + '.dynamicOn', condition + '.firstTerm')
connectAttrCommon(ctl + '.startFrame', hairSystem + '.startFrame')
connectAttrCommon(condition + '.outColorR',
hairSystem + '.simulationMethod')
connectAttrCommon(ctl + '.attraction', hairSystem + '.startCurveAttract')
connectAttrCommon(ctl + '.stiffness', hairSystem + '.stiffness')
connectAttrCommon(ctl + '.attractionDamp', hairSystem + '.attractionDamp')
connectAttrCommon(ctl + '.mass', hairSystem + '.mass')
connectAttrCommon(ctl + '.drag', hairSystem + '.drag')
def connectHairControl( ctl, hairSystem ):
hairSystem = sgModelDag.getNodeFromHistory( hairSystem, 'hairSystem' )[0]
try:sgRigAttribute.addAttr( ctl, ln='________', en='Hair:', at='enum', cb=1 )
except:pass
sgRigAttribute.addAttr( ctl, ln='dynamicOn', min=0, max=1, at='long', cb=1 )
sgRigAttribute.addAttr( ctl, ln='startFrame', dv=1, at='long', cb=1 )
sgRigAttribute.addAttr( ctl, ln='attraction', min=0, max=1, dv=1, k=1 )
sgRigAttribute.addAttr( ctl, ln='attractionDamp', min=0, dv=0.5, k=1 )
sgRigAttribute.addAttr( ctl, ln='stiffness', min=0, max=1, dv=0.15, k=1 )
sgRigAttribute.addAttr( ctl, ln='mass', min=0.1, dv=1, k=1 )
sgRigAttribute.addAttr( ctl, ln='drag', min=0, dv=0.05, k=1 )
condition = cmds.createNode( 'condition' )
cmds.setAttr( condition+'.secondTerm', 0 )
cmds.setAttr( condition+'.colorIfTrueR', 1 )
cmds.setAttr( condition+'.colorIfFalseR', 3 )
connectAttrCommon( ctl+'.dynamicOn', condition+'.firstTerm' )
connectAttrCommon( ctl+'.startFrame', hairSystem+'.startFrame' )
connectAttrCommon( condition+'.outColorR', hairSystem+'.simulationMethod' )
connectAttrCommon( ctl+'.attraction', hairSystem+'.startCurveAttract' )
connectAttrCommon( ctl+'.stiffness', hairSystem+'.stiffness' )
connectAttrCommon( ctl+'.attractionDamp', hairSystem+'.attractionDamp' )
connectAttrCommon( ctl+'.mass', hairSystem+'.mass' )
connectAttrCommon( ctl+'.drag', hairSystem+'.drag' )
def removePositiveNormalInfluence(selectedObjs):
mesh, vtxIndices = sgModelMesh.getMeshAndIndicesPoints(selectedObjs)
skinClusterNode = sgModelDag.getNodeFromHistory(mesh, 'skinCluster')
if not skinClusterNode: return None
skinClusterNode = skinClusterNode[0]
influenceAndWeightList = sgModelSkinCluster.getInfluenceAndWeightList(mesh)
fnMesh = sgModelMesh.getFnMesh(mesh)
meshInvMatrix = sgModelDag.getDagPath(mesh).inclusiveMatrixInverse()
meshPoints = sgModelMesh.getLocalPoints(mesh)
plugMatrix = sgModelSkinCluster.getPlugMatrix(mesh)
#normal = om.MVector()
percentRate = 100.0 / len(vtxIndices)
currentRate = 0.0
for i in vtxIndices:
influenceList, childInfluenceList, weights = influenceAndWeightList[i]
for j in range(len(influenceList)):
jointMatrix = sgModelDg.getMatrixFromPlug(
plugMatrix.elementByLogicalIndex(influenceList[j]))
jointPointOnLocalMesh = om.MPoint(jointMatrix(
3, 0), jointMatrix(3, 1), jointMatrix(3, 2)) * meshInvMatrix
vMeshPoint = om.MVector(meshPoints[i] - jointPointOnLocalMesh)
interPoints = om.MPointArray()
fnMesh.intersect(om.MPoint(jointPointOnLocalMesh), vMeshPoint,
interPoints)
lengthMeshPoint = vMeshPoint.length() * 0.99999
if not interPoints.length(): continue
if om.MVector(interPoints[0] -
jointPointOnLocalMesh).length() < lengthMeshPoint:
weights[j] = 0
allWeights = 0.0
for weight in weights:
allWeights += weight
if allWeights == 0:
continue
for j in range(len(weights)):
logicalIndex = influenceList[j]
cmds.setAttr(
skinClusterNode + '.weightList[%d].weights[%d]' %
(i, logicalIndex), weights[j] / allWeights)
currentRate += percentRate
print "%6.2f" % currentRate + "% caculated"
def removePositiveNormalInfluence( selectedObjs ):
mesh, vtxIndices = sgModelMesh.getMeshAndIndicesPoints( selectedObjs )
skinClusterNode = sgModelDag.getNodeFromHistory( mesh, 'skinCluster' )
if not skinClusterNode: return None
skinClusterNode = skinClusterNode[0]
influenceAndWeightList = sgModelSkinCluster.getInfluenceAndWeightList( mesh )
fnMesh = sgModelMesh.getFnMesh( mesh )
meshInvMatrix = sgModelDag.getDagPath( mesh ).inclusiveMatrixInverse()
meshPoints = sgModelMesh.getLocalPoints( mesh )
plugMatrix = sgModelSkinCluster.getPlugMatrix( mesh )
#normal = om.MVector()
percentRate = 100.0/len( vtxIndices )
currentRate = 0.0
for i in vtxIndices:
influenceList, childInfluenceList, weights = influenceAndWeightList[i]
for j in range( len( influenceList ) ):
jointMatrix = sgModelDg.getMatrixFromPlug( plugMatrix.elementByLogicalIndex( influenceList[j] ) )
jointPointOnLocalMesh = om.MPoint( jointMatrix(3,0), jointMatrix(3,1), jointMatrix(3,2) )*meshInvMatrix
vMeshPoint = om.MVector( meshPoints[i]-jointPointOnLocalMesh )
interPoints = om.MPointArray()
fnMesh.intersect( om.MPoint( jointPointOnLocalMesh ), vMeshPoint, interPoints )
lengthMeshPoint = vMeshPoint.length()*0.99999
if not interPoints.length(): continue
if om.MVector( interPoints[0] - jointPointOnLocalMesh ).length() < lengthMeshPoint:
weights[j] = 0
allWeights = 0.0
for weight in weights:
allWeights += weight
if allWeights == 0:
continue
for j in range( len( weights ) ):
logicalIndex = influenceList[j]
cmds.setAttr( skinClusterNode+'.weightList[%d].weights[%d]' %( i, logicalIndex ), weights[j]/allWeights )
currentRate += percentRate
print "%6.2f" %currentRate + "% caculated"
def setInverseSkinCluster( skinedObject, shapedObject, target ):
skinCluster = sgModelDag.getNodeFromHistory( skinedObject, 'skinCluster' )
if not skinCluster: return None
skinCluster = skinCluster[0]
targetShape = sgModelDag.getShape( target )
shapedShape = sgModelDag.getShape( shapedObject )
origShape = sgModelDag.getOrigShape( skinedObject )
cmds.connectAttr( origShape+'.outMesh', targetShape+'.inMesh', f=1 )
invSkinCluster = cmds.deformer( target, type='inverseSkinCluster' )[0]
cmds.connectAttr( skinCluster+'.message', invSkinCluster+'.targetSkinCluster' )
cmds.connectAttr( skinedObject+'.wm', invSkinCluster+'.geomMatrix' )
cmds.connectAttr( shapedShape+'.outMesh', invSkinCluster+'.inMesh' )
def setInverseSkinCluster(skinedObject, shapedObject, target):
skinCluster = sgModelDag.getNodeFromHistory(skinedObject, 'skinCluster')
if not skinCluster: return None
skinCluster = skinCluster[0]
targetShape = sgModelDag.getShape(target)
shapedShape = sgModelDag.getShape(shapedObject)
origShape = sgModelDag.getOrigShape(skinedObject)
cmds.connectAttr(origShape + '.outMesh', targetShape + '.inMesh', f=1)
invSkinCluster = cmds.deformer(target, type='inverseSkinCluster')[0]
cmds.connectAttr(skinCluster + '.message',
invSkinCluster + '.targetSkinCluster')
cmds.connectAttr(skinedObject + '.wm', invSkinCluster + '.geomMatrix')
cmds.connectAttr(shapedShape + '.outMesh', invSkinCluster + '.inMesh')
def addScaleControlObjectToSkined(ctl, target):
import sgModelDag
def getMultMtx(ctl, outputAttr):
ctlP = cmds.listRelatives(ctl, p=1)[0]
jntMms = cmds.listConnections(outputAttr, type='multMatrix')
ctlPMms = cmds.listConnections(ctlP + '.wim', type='multMatrix')
ctlMms = cmds.listConnections(ctl + '.wm', type='multMatrix')
if not jntMms: jntMms = []
if not ctlPMms: ctlPMms = []
if not ctlMms: ctlMms = []
targetMms = []
for jntMm in jntMms:
if jntMm in ctlMms and jntMm in ctlPMms:
targetMms.append(jntMm)
if targetMms: return targetMms[0]
mm = cmds.createNode('multMatrix')
cmds.connectAttr(outputAttr, mm + '.i[0]')
cmds.connectAttr(ctlP + '.wim', mm + '.i[1]')
cmds.connectAttr(ctl + '.wm', mm + '.i[2]')
return mm
skinClusters = sgModelDag.getNodeFromHistory(target, 'skinCluster')
if not skinClusters: return None
targetSkinCluster = skinClusters[0]
cons = cmds.listConnections(targetSkinCluster + '.matrix',
s=1,
d=0,
p=1,
c=1)
for i in range(0, len(cons), 2):
outputAttr = cons[i + 1]
mmNode = getMultMtx(ctl, outputAttr)
if not cmds.isConnected(mmNode + '.matrixSum', cons[i]):
cmds.connectAttr(mmNode + '.matrixSum', cons[i], f=1)
def setInfluenceParentAsBindFre( mesh ):
skinCluster = sgModelDag.getNodeFromHistory( mesh, 'skinCluster' )[0]
cons = cmds.listConnections( skinCluster+'.matrix', type='joint', p=1, c=1, s=1, d=0 )
outputs = cons[1::2]
inputs = cons[::2]
for i in range( len( outputs ) ):
jnt = outputs[i].split( '.' )[0]
jntP = cmds.listRelatives( jnt, p=1, f=1 )[0]
output = jntP+'.wim'
input_ = inputs[i].replace( 'matrix', 'bindPreMatrix' )
print output, input_
if cmds.isConnected( output, input_ ): continue
cmds.connectAttr( output, input_, f=1 )
def addScaleControlObjectToSkined( ctl, target ):
import sgModelDag
def getMultMtx( ctl, outputAttr ):
ctlP = cmds.listRelatives( ctl, p=1 )[0]
jntMms = cmds.listConnections( outputAttr, type='multMatrix' )
ctlPMms = cmds.listConnections( ctlP+'.wim', type='multMatrix' )
ctlMms = cmds.listConnections( ctl+'.wm', type='multMatrix' )
if not jntMms: jntMms = []
if not ctlPMms: ctlPMms = []
if not ctlMms: ctlMms = []
targetMms = []
for jntMm in jntMms:
if jntMm in ctlMms and jntMm in ctlPMms:
targetMms.append( jntMm )
if targetMms: return targetMms[0]
mm = cmds.createNode( 'multMatrix' )
cmds.connectAttr( outputAttr, mm+'.i[0]' )
cmds.connectAttr( ctlP+'.wim', mm+'.i[1]' )
cmds.connectAttr( ctl+'.wm', mm+'.i[2]' )
return mm
skinClusters = sgModelDag.getNodeFromHistory( target, 'skinCluster' )
if not skinClusters: return None
targetSkinCluster = skinClusters[0]
cons = cmds.listConnections( targetSkinCluster+'.matrix', s=1, d=0, p=1, c=1 )
for i in range( 0, len( cons ), 2 ):
outputAttr = cons[i+1]
mmNode = getMultMtx( ctl, outputAttr )
if not cmds.isConnected( mmNode+'.matrixSum', cons[i] ):
cmds.connectAttr( mmNode+'.matrixSum', cons[i], f=1 )
def setInfluenceParentAsBindFre(mesh):
skinCluster = sgModelDag.getNodeFromHistory(mesh, 'skinCluster')[0]
cons = cmds.listConnections(skinCluster + '.matrix',
type='joint',
p=1,
c=1,
s=1,
d=0)
outputs = cons[1::2]
inputs = cons[::2]
for i in range(len(outputs)):
jnt = outputs[i].split('.')[0]
jntP = cmds.listRelatives(jnt, p=1, f=1)[0]
output = jntP + '.wim'
input_ = inputs[i].replace('matrix', 'bindPreMatrix')
print output, input_
if cmds.isConnected(output, input_): continue
cmds.connectAttr(output, input_, f=1)
def createRivetBasedOnSkinWeights(selectedObjs):
import sgModelMesh
import sgModelDag
import sgModelSkinCluster
import sgModelConvert
def getJointMultMatrix(jnt, mtxBindPre):
cons = cmds.listConnections(jnt + '.wm', type='multMatrix')
if cons:
for con in cons:
if cmds.attributeQuery('skinWeightInfluenceMatrix',
node=con,
ex=1):
if mtxBindPre == cmds.getAttr(con + '.i[0]'):
return con
mmtxNode = cmds.createNode('multMatrix')
cmds.setAttr(mmtxNode + '.i[0]', mtxBindPre, type='matrix')
cmds.connectAttr(jnt + '.wm', mmtxNode + '.i[1]')
cmds.addAttr(mmtxNode, ln='skinWeightInfluenceMatrix', at='message')
return mmtxNode
mesh, vtxIndices = sgModelMesh.getMeshAndIndicesPoints(selectedObjs)
skinClusterNode = sgModelDag.getNodeFromHistory(mesh, 'skinCluster')
if not skinClusterNode: return None
skinClusterNode = skinClusterNode[0]
influenceAndWeightList, phygicalMap = sgModelSkinCluster.getInfluenceAndWeightList(
mesh, vtxIndices)
meshMatrix = sgModelDag.getDagPath(mesh).inclusiveMatrix()
meshPoints = sgModelMesh.getLocalPoints(mesh)
plugMatrix = sgModelSkinCluster.getPlugMatrix(mesh)
plugBindPre = sgModelSkinCluster.getPlugBindPre(mesh)
BB = om.MBoundingBox()
wtAddMtx = cmds.createNode('wtAddMatrix')
mtxPlugIndidcesAndWeights = {}
allWeights = 0.0
for i in vtxIndices:
influenceList, weights = influenceAndWeightList[phygicalMap[i]]
for j in range(len(influenceList)):
mtxPlugIndex = influenceList[j]
if mtxPlugIndex in mtxPlugIndidcesAndWeights.keys():
mtxPlugIndidcesAndWeights[mtxPlugIndex] += weights[j]
else:
mtxPlugIndidcesAndWeights.update({mtxPlugIndex: weights[j]})
allWeights += weights[j]
BB.expand(meshPoints[i])
worldPoint = BB.center() * meshMatrix
items = mtxPlugIndidcesAndWeights.items()
for i in range(len(items)):
influence, weight = items[i]
plugMatrixElement = plugMatrix.elementByLogicalIndex(influence)
plugBindPreElement = plugBindPre.elementByLogicalIndex(influence)
jnt = cmds.listConnections(plugMatrixElement.name(),
s=1,
d=0,
type='joint')[0]
mtxBindPre = cmds.getAttr(plugBindPreElement.name())
mmtxNode = getJointMultMatrix(jnt, mtxBindPre)
cmds.connectAttr(mmtxNode + '.o', wtAddMtx + '.i[%d].m' % i)
cmds.setAttr(wtAddMtx + '.i[%d].w' % i, weight / allWeights)
origObj = cmds.createNode('transform', n='OrigObject')
destObj = cmds.createNode('transform', n='destObject')
cmds.setAttr(destObj + '.dh', 1)
cmds.setAttr(destObj + '.dla', 1)
mmNode = cmds.createNode('multMatrix')
dcmp = cmds.createNode('decomposeMatrix')
mtxWtAdd = cmds.getAttr(wtAddMtx + '.o')
cmds.connectAttr(origObj + '.wm', mmNode + '.i[0]')
cmds.connectAttr(wtAddMtx + '.o', mmNode + '.i[1]')
cmds.connectAttr(destObj + '.pim', mmNode + '.i[2]')
cmds.connectAttr(mmNode + '.o', dcmp + '.imat')
cmds.connectAttr(dcmp + '.ot', destObj + '.t')
cmds.connectAttr(dcmp + '.or', destObj + '.r')
mmtxWtAdd = sgModelConvert.convertMatrixToMMatrix(mtxWtAdd)
worldPoint *= mmtxWtAdd.inverse()
cmds.setAttr(origObj + '.t', worldPoint.x, worldPoint.y, worldPoint.z)
def setRotateRoofPointer( pointer, upObject, worldUpIndex, upIndex = 1 ):
''' aim index is 0 '''
curveInfos = sgModelDag.getNodeFromHistory( pointer, 'pointOnCurveInfo' )
curveInfo = curveInfos[0]
cons = cmds.listConnections( curveInfo+'.inputCurve', s=1, d=0, c=1, p=1 )
inputAttr = cons[1]
inputCurve = inputAttr.split( '.' )[0]
inputCurveIsLocal = False
if inputAttr.split( '.' )[1] == 'local':
inputCurveIsLocal = True
'''------------------- create nodes ---------------------------'''
mtxToThree = cmds.createNode( 'matrixToThreeByThree' )
vp = cmds.createNode( 'vectorProduct' )
fbfm = cmds.createNode( 'fourByFourMatrix' )
mmdc = cmds.createNode( 'multMatrixDecompose' )
'''-----------------------------------------------------------'''
'''-------------------matrix connect --------------------------'''
crossIndex = 3-upIndex
cmds.setAttr( vp+'.operation', 2 ) # cross product
cmds.connectAttr( curveInfo + '.tangentX', fbfm+'.i00' )
cmds.connectAttr( curveInfo + '.tangentY', fbfm+'.i01' )
cmds.connectAttr( curveInfo + '.tangentZ', fbfm+'.i02' )
if inputCurveIsLocal:
mm = cmds.createNode( 'multMatrix' )
cmds.connectAttr( upObject+'.wm', mm+'.i[0]' )
cmds.connectAttr( inputCurve+'.pim', mm+'.i[1]' )
cmds.connectAttr( mm+'.o', mtxToThree+'.inMatrix' )
else:
cmds.connectAttr( upObject+'.wm', mtxToThree+'.inMatrix' )
cmds.connectAttr( mtxToThree+'.o%d0' % worldUpIndex, fbfm+'.i%d0' % upIndex )
cmds.connectAttr( mtxToThree+'.o%d1' % worldUpIndex, fbfm+'.i%d1' % upIndex )
cmds.connectAttr( mtxToThree+'.o%d2' % worldUpIndex, fbfm+'.i%d2' % upIndex )
cmds.connectAttr( mtxToThree+'.o%d0' % worldUpIndex, vp+'.input%dX' % crossIndex )
cmds.connectAttr( mtxToThree+'.o%d1' % worldUpIndex, vp+'.input%dY' % crossIndex )
cmds.connectAttr( mtxToThree+'.o%d2' % worldUpIndex, vp+'.input%dZ' % crossIndex )
cmds.connectAttr( curveInfo+'.tangent', vp+'.input%d' % upIndex )
cmds.connectAttr( vp+'.outputX', fbfm+'.i%d0' % crossIndex )
cmds.connectAttr( vp+'.outputY', fbfm+'.i%d1' % crossIndex )
cmds.connectAttr( vp+'.outputZ', fbfm+'.i%d2' % crossIndex )
cmds.connectAttr( fbfm+'.output', mmdc+'.i[0]' )
if inputCurveIsLocal:
cmds.connectAttr( inputCurve+'.wm', mmdc+'.i[1]' )
cmds.connectAttr( pointer+'.pim', mmdc+'.i[2]' )
else:
cmds.connectAttr( pointer+'.pim', mmdc+'.i[1]' )
'''-----------------------------------------------------------'''
'''---------- result ---------------- '''
cmds.connectAttr( mmdc+'.or', pointer+'.r' )
'''---------------------------------- '''
def createRivetBasedOnSkinWeights( selectedObjs ):
import sgModelMesh
import sgModelDag
import sgModelSkinCluster
import sgModelConvert
def getJointMultMatrix( jnt, mtxBindPre ):
cons = cmds.listConnections( jnt+'.wm', type='multMatrix' )
if cons:
for con in cons:
if cmds.attributeQuery( 'skinWeightInfluenceMatrix', node=con, ex=1 ):
if mtxBindPre == cmds.getAttr( con+'.i[0]' ):
return con
mmtxNode = cmds.createNode( 'multMatrix' )
cmds.setAttr( mmtxNode+'.i[0]', mtxBindPre, type='matrix' )
cmds.connectAttr( jnt+'.wm', mmtxNode+'.i[1]' )
cmds.addAttr( mmtxNode, ln='skinWeightInfluenceMatrix', at='message' )
return mmtxNode
mesh, vtxIndices = sgModelMesh.getMeshAndIndicesPoints( selectedObjs )
skinClusterNode = sgModelDag.getNodeFromHistory( mesh, 'skinCluster' )
if not skinClusterNode: return None
skinClusterNode = skinClusterNode[0]
influenceAndWeightList, phygicalMap = sgModelSkinCluster.getInfluenceAndWeightList( mesh, vtxIndices )
meshMatrix = sgModelDag.getDagPath( mesh ).inclusiveMatrix()
meshPoints = sgModelMesh.getLocalPoints( mesh )
plugMatrix = sgModelSkinCluster.getPlugMatrix( mesh )
plugBindPre = sgModelSkinCluster.getPlugBindPre( mesh )
BB = om.MBoundingBox()
wtAddMtx = cmds.createNode( 'wtAddMatrix' )
mtxPlugIndidcesAndWeights = {}
allWeights = 0.0
for i in vtxIndices:
influenceList, weights = influenceAndWeightList[ phygicalMap[i] ]
for j in range( len( influenceList ) ):
mtxPlugIndex = influenceList[j]
if mtxPlugIndex in mtxPlugIndidcesAndWeights.keys():
mtxPlugIndidcesAndWeights[mtxPlugIndex] += weights[j]
else:
mtxPlugIndidcesAndWeights.update( {mtxPlugIndex:weights[j]} )
allWeights += weights[j]
BB.expand( meshPoints[i] )
worldPoint = BB.center()*meshMatrix
items = mtxPlugIndidcesAndWeights.items()
for i in range( len( items ) ):
influence, weight = items[i]
plugMatrixElement = plugMatrix.elementByLogicalIndex( influence )
plugBindPreElement = plugBindPre.elementByLogicalIndex( influence )
jnt = cmds.listConnections( plugMatrixElement.name(), s=1, d=0, type='joint' )[0]
mtxBindPre = cmds.getAttr( plugBindPreElement.name() )
mmtxNode = getJointMultMatrix( jnt, mtxBindPre )
cmds.connectAttr( mmtxNode+'.o', wtAddMtx+'.i[%d].m' % i )
cmds.setAttr( wtAddMtx+'.i[%d].w' % i, weight/allWeights )
origObj = cmds.createNode( 'transform', n='OrigObject' )
destObj = cmds.createNode( 'transform', n='destObject' )
cmds.setAttr( destObj+'.dh' , 1 )
cmds.setAttr( destObj+'.dla', 1 )
mmNode = cmds.createNode( 'multMatrix' )
dcmp = cmds.createNode( 'decomposeMatrix' )
mtxWtAdd = cmds.getAttr( wtAddMtx+'.o' )
cmds.connectAttr( origObj+'.wm', mmNode+'.i[0]' )
cmds.connectAttr( wtAddMtx+'.o', mmNode+'.i[1]' )
cmds.connectAttr( destObj+'.pim', mmNode+'.i[2]' )
cmds.connectAttr( mmNode+'.o', dcmp+'.imat' )
cmds.connectAttr( dcmp+'.ot', destObj+'.t' )
cmds.connectAttr( dcmp+'.or', destObj+'.r' )
mmtxWtAdd = sgModelConvert.convertMatrixToMMatrix( mtxWtAdd )
worldPoint *= mmtxWtAdd.inverse()
cmds.setAttr( origObj+'.t', worldPoint.x, worldPoint.y, worldPoint.z )
def getSkinClusterFromMesh(mesh):
return sgModelDag.getNodeFromHistory(mesh, 'skinCluster')
def setRotateRoofPointer(pointer, upObject, worldUpIndex, upIndex=1):
''' aim index is 0 '''
curveInfos = sgModelDag.getNodeFromHistory(pointer, 'pointOnCurveInfo')
curveInfo = curveInfos[0]
cons = cmds.listConnections(curveInfo + '.inputCurve', s=1, d=0, c=1, p=1)
inputAttr = cons[1]
inputCurve = inputAttr.split('.')[0]
inputCurveIsLocal = False
if inputAttr.split('.')[1] == 'local':
inputCurveIsLocal = True
'''------------------- create nodes ---------------------------'''
mtxToThree = cmds.createNode('matrixToThreeByThree')
vp = cmds.createNode('vectorProduct')
fbfm = cmds.createNode('fourByFourMatrix')
mmdc = cmds.createNode('multMatrixDecompose')
'''-----------------------------------------------------------'''
'''-------------------matrix connect --------------------------'''
crossIndex = 3 - upIndex
cmds.setAttr(vp + '.operation', 2) # cross product
cmds.connectAttr(curveInfo + '.tangentX', fbfm + '.i00')
cmds.connectAttr(curveInfo + '.tangentY', fbfm + '.i01')
cmds.connectAttr(curveInfo + '.tangentZ', fbfm + '.i02')
if inputCurveIsLocal:
mm = cmds.createNode('multMatrix')
cmds.connectAttr(upObject + '.wm', mm + '.i[0]')
cmds.connectAttr(inputCurve + '.pim', mm + '.i[1]')
cmds.connectAttr(mm + '.o', mtxToThree + '.inMatrix')
else:
cmds.connectAttr(upObject + '.wm', mtxToThree + '.inMatrix')
cmds.connectAttr(mtxToThree + '.o%d0' % worldUpIndex,
fbfm + '.i%d0' % upIndex)
cmds.connectAttr(mtxToThree + '.o%d1' % worldUpIndex,
fbfm + '.i%d1' % upIndex)
cmds.connectAttr(mtxToThree + '.o%d2' % worldUpIndex,
fbfm + '.i%d2' % upIndex)
cmds.connectAttr(mtxToThree + '.o%d0' % worldUpIndex,
vp + '.input%dX' % crossIndex)
cmds.connectAttr(mtxToThree + '.o%d1' % worldUpIndex,
vp + '.input%dY' % crossIndex)
cmds.connectAttr(mtxToThree + '.o%d2' % worldUpIndex,
vp + '.input%dZ' % crossIndex)
cmds.connectAttr(curveInfo + '.tangent', vp + '.input%d' % upIndex)
cmds.connectAttr(vp + '.outputX', fbfm + '.i%d0' % crossIndex)
cmds.connectAttr(vp + '.outputY', fbfm + '.i%d1' % crossIndex)
cmds.connectAttr(vp + '.outputZ', fbfm + '.i%d2' % crossIndex)
cmds.connectAttr(fbfm + '.output', mmdc + '.i[0]')
if inputCurveIsLocal:
cmds.connectAttr(inputCurve + '.wm', mmdc + '.i[1]')
cmds.connectAttr(pointer + '.pim', mmdc + '.i[2]')
else:
cmds.connectAttr(pointer + '.pim', mmdc + '.i[1]')
'''-----------------------------------------------------------'''
'''---------- result ---------------- '''
cmds.connectAttr(mmdc + '.or', pointer + '.r')
'''---------------------------------- '''
def createSgWobbleAttribute( crv, wobbleCurve=None ):
crv = sgModelDag.getTransform( crv )
if not wobbleCurve:
sgWobbleCurve = sgModelDag.getNodeFromHistory( crv , 'sgWobbleCurve2' )
if not sgWobbleCurve: return None
sgWobbleCurve = sgWobbleCurve[0]
else:
sgWobbleCurve = wobbleCurve
addAttr( crv, ln='globalEnvelope', k=1, dv=1 )
addAttr( crv, ln='globalWave1', k=1, dv=1 )
addAttr( crv, ln='globalTimeMult1', k=1, dv=-.3 )
addAttr( crv, ln='globalOffset1', k=1, dv=0.0 )
addAttr( crv, ln='globalLength1', k=1, dv=0.0 )
addAttr( crv, ln='globalWave2', k=1, dv=1 )
addAttr( crv, ln='globalTimeMult2', k=1, dv=-.3 )
addAttr( crv, ln='globalOffset2', k=1, dv=0.0 )
addAttr( crv, ln='globalLength2', k=1, dv=0.0 )
addAttr( crv, ln='envelope', k=1, dv=1 )
addAttr( crv, ln='wave1', k=1, dv=30 )
addAttr( crv, ln='timeMult1', k=1, dv=1 )
addAttr( crv, ln='offset1', k=1, dv=0 )
addAttr( crv, ln='waveLength1', k=1, dv=0.25 )
addAttr( crv, ln='wave2', k=1, dv=30 )
addAttr( crv, ln='timeMult2', k=1, dv=1 )
addAttr( crv, ln='offset2', k=1, dv=0 )
addAttr( crv, ln='waveLength2', k=1, dv=0.25 )
envelopeMd = cmds.createNode( 'multDoubleLinear' )
waveMd1 = cmds.createNode( 'multDoubleLinear' )
timeMultMd1 = cmds.createNode( 'multDoubleLinear' )
offsetAd1 = cmds.createNode( 'addDoubleLinear' )
lengthAdd1 = cmds.createNode( 'addDoubleLinear' )
waveMd2 = cmds.createNode( 'multDoubleLinear' )
timeMultMd2 = cmds.createNode( 'multDoubleLinear' )
offsetAd2 = cmds.createNode( 'addDoubleLinear' )
lengthAdd2 = cmds.createNode( 'addDoubleLinear' )
cmds.connectAttr( crv+'.globalEnvelope', envelopeMd+'.input1' )
cmds.connectAttr( crv+'.envelope', envelopeMd+'.input2' )
cmds.connectAttr( crv+'.globalWave1', waveMd1+'.input1' )
cmds.connectAttr( crv+'.wave1', waveMd1+'.input2' )
cmds.connectAttr( crv+'.globalTimeMult1', timeMultMd1+'.input1' )
cmds.connectAttr( crv+'.timeMult1', timeMultMd1+'.input2' )
cmds.connectAttr( crv+'.globalOffset1', offsetAd1+'.input1' )
cmds.connectAttr( crv+'.offset1', offsetAd1+'.input2' )
cmds.connectAttr( crv+'.globalLength1', lengthAdd1+'.input1' )
cmds.connectAttr( crv+'.waveLength1', lengthAdd1+'.input2' )
cmds.connectAttr( crv+'.globalWave2', waveMd2+'.input1' )
cmds.connectAttr( crv+'.wave2', waveMd2+'.input2' )
cmds.connectAttr( crv+'.globalTimeMult2', timeMultMd2+'.input1' )
cmds.connectAttr( crv+'.timeMult2', timeMultMd2+'.input2' )
cmds.connectAttr( crv+'.globalOffset2', offsetAd2+'.input1' )
cmds.connectAttr( crv+'.offset2', offsetAd2+'.input2' )
cmds.connectAttr( crv+'.globalLength2', lengthAdd2+'.input1' )
cmds.connectAttr( crv+'.waveLength2', lengthAdd2+'.input2' )
cmds.connectAttr( envelopeMd+'.output', sgWobbleCurve+'.envelope' )
cmds.connectAttr( waveMd1+'.output', sgWobbleCurve+'.wave1' )
cmds.connectAttr( timeMultMd1+'.output', sgWobbleCurve+'.timeMult1' )
cmds.connectAttr( offsetAd1+'.output', sgWobbleCurve+'.offset1' )
cmds.connectAttr( lengthAdd1+'.output', sgWobbleCurve+'.waveLength1' )
cmds.connectAttr( waveMd2+'.output', sgWobbleCurve+'.wave2' )
cmds.connectAttr( timeMultMd2+'.output', sgWobbleCurve+'.timeMult2' )
cmds.connectAttr( offsetAd2+'.output', sgWobbleCurve+'.offset2' )
cmds.connectAttr( lengthAdd2+'.output', sgWobbleCurve+'.waveLength2' )