def connectHairSystemAttr(first, second):
import sgModelAttribute
first = sgModelDag.getShape(first)
second = sgModelDag.getShape(second)
connectAttrList = [
'startFrame', 'active', 'simulationMethod', 'iterations', 'lengthFlex',
'startCurveAttract', 'attractionDamp', 'attractionScale', 'stiffness',
'stiffnessScale', 'mass', 'drag', 'tangentialDrag', 'motionDrag',
'damp', 'gravity', 'dynamicsWeight', 'turbulenceStrength',
'turbulenceFrequency', 'turbulenceSpeed'
]
for attr in connectAttrList:
print attr, first
if cmds.attributeQuery(attr, node=first, usesMultiBuilder=1):
sgRigAttribute.removeMultiInstances(second, attr)
indices = sgModelAttribute.getMultiAttrIndices(first, attr)
for index in indices:
connectAttrCommon(first + '.' + attr + '[%d]' % index,
second + '.' + attr + '[%d]' % index)
else:
connectAttrCommon(first + '.' + attr, second + '.' + attr)
def clearCurve( crv ):
crvShape = sgModelDag.getShape( crv )
crv = cmds.listRelatives( crvShape, p=1 )[0]
nCrv = sgFunctionDag.copyShape( crv )
nCrvShape = sgModelDag.getShape( nCrv )
cmds.refresh()
cmds.delete( crvShape )
cmds.parent( nCrvShape, crv, add=1, shape=1 )
cmds.delete( nCrv )
def clearCurve(crv):
crvShape = sgModelDag.getShape(crv)
crv = cmds.listRelatives(crvShape, p=1)[0]
nCrv = sgFunctionDag.copyShape(crv)
nCrvShape = sgModelDag.getShape(nCrv)
cmds.refresh()
cmds.delete(crvShape)
cmds.parent(nCrvShape, crv, add=1, shape=1)
cmds.delete(nCrv)
def __init__(self, baseMesh, outMesh):
baseMesh = sgModelDag.getShape(baseMesh)
outMesh = sgModelDag.getShape(outMesh)
self.baseIntersector = om.MMeshIntersector()
self.baseIntersector.create(getMObject(baseMesh))
self.outMeshInfo = MeshInfo(outMesh)
self.meshPoints = om.MPointArray()
self.outMeshInfo.fnMesh.getPoints(self.meshPoints)
self.outMeshName = outMesh
self.copyVtxWeightAndPast = skinF.CopyVtxAndPast(outMesh)
def __init__(self, baseMesh, outMesh ):
baseMesh = sgModelDag.getShape( baseMesh )
outMesh = sgModelDag.getShape( outMesh )
self.baseIntersector = om.MMeshIntersector()
self.baseIntersector.create( getMObject( baseMesh ) )
self.outMeshInfo = MeshInfo( outMesh )
self.meshPoints = om.MPointArray()
self.outMeshInfo.fnMesh.getPoints( self.meshPoints )
self.outMeshName = outMesh
self.copyVtxWeightAndPast = skinF.CopyVtxAndPast( outMesh )
def addCurveInfo( crv ):
shape = sgModelDag.getShape( crv )
info = cmds.createNode( 'curveInfo' )
cmds.connectAttr( shape+'.local', info+'.inputCurve' )
return info
def createMeshInstersectPointObject(sourcePointObject, destPointObject, mesh):
meshShape = sgModelDag.getShape(mesh)
dcmpSrc = cmds.createNode('decomposeMatrix')
dcmpDst = cmds.createNode('decomposeMatrix')
intersectNode = cmds.createNode('sgMeshIntersect')
cmds.connectAttr(sourcePointObject + '.wm', dcmpSrc + '.imat')
cmds.connectAttr(destPointObject + '.wm', dcmpDst + '.imat')
cmds.connectAttr(mesh + '.wm', intersectNode + '.inputMeshMatrix')
cmds.connectAttr(meshShape + '.outMesh', intersectNode + '.inputMesh')
cmds.connectAttr(dcmpSrc + '.ot', intersectNode + '.pointSource')
cmds.connectAttr(dcmpDst + '.ot', intersectNode + '.pointDest')
trObj = cmds.createNode('transform')
cmds.setAttr(trObj + '.dh', 1)
crv = cmds.curve(p=[[0, 0, 0], [0, 0, 0]], d=1)
cmds.setAttr(crv + '.template', 1)
crvShape = cmds.listRelatives(crv, s=1)[0]
mmdcSource = cmds.createNode('sgMultMatrixDecompose')
mmdcDest = cmds.createNode('sgMultMatrixDecompose')
cmds.connectAttr(sourcePointObject + '.wm', mmdcSource + '.i[0]')
cmds.connectAttr(destPointObject + '.wm', mmdcDest + '.i[0]')
cmds.connectAttr(crv + '.wim', mmdcSource + '.i[1]')
cmds.connectAttr(crv + '.wim', mmdcDest + '.i[1]')
cmds.connectAttr(mmdcSource + '.ot', crvShape + '.controlPoints[0]')
cmds.connectAttr(mmdcDest + '.ot', crvShape + '.controlPoints[1]')
cmds.connectAttr(trObj + '.pim', intersectNode + '.pim')
cmds.connectAttr(intersectNode + '.outPoint', trObj + '.t')
return trObj, crv
def createMeshInstersectPointObject( sourcePointObject, destPointObject, mesh ):
meshShape = sgModelDag.getShape( mesh )
dcmpSrc = cmds.createNode( 'decomposeMatrix' )
dcmpDst = cmds.createNode( 'decomposeMatrix' )
intersectNode = cmds.createNode( 'sgMeshIntersect' )
cmds.connectAttr( sourcePointObject+'.wm', dcmpSrc+'.imat' )
cmds.connectAttr( destPointObject +'.wm', dcmpDst+'.imat' )
cmds.connectAttr( mesh+'.wm', intersectNode+'.inputMeshMatrix' )
cmds.connectAttr( meshShape+'.outMesh', intersectNode+'.inputMesh' )
cmds.connectAttr( dcmpSrc+'.ot', intersectNode+'.pointSource' )
cmds.connectAttr( dcmpDst+'.ot', intersectNode+'.pointDest' )
trObj = cmds.createNode( 'transform' )
cmds.setAttr( trObj+'.dh', 1 )
crv = cmds.curve( p=[[0,0,0],[0,0,0]], d=1 )
cmds.setAttr( crv+'.template', 1 )
crvShape = cmds.listRelatives( crv, s=1 )[0]
mmdcSource = cmds.createNode( 'sgMultMatrixDecompose' )
mmdcDest = cmds.createNode( 'sgMultMatrixDecompose' )
cmds.connectAttr( sourcePointObject+'.wm', mmdcSource+'.i[0]' )
cmds.connectAttr( destPointObject+'.wm', mmdcDest+'.i[0]' )
cmds.connectAttr( crv+'.wim', mmdcSource+'.i[1]' )
cmds.connectAttr( crv+'.wim', mmdcDest+'.i[1]' )
cmds.connectAttr( mmdcSource+'.ot', crvShape+'.controlPoints[0]' )
cmds.connectAttr( mmdcDest+'.ot', crvShape+'.controlPoints[1]' )
cmds.connectAttr( trObj+'.pim', intersectNode+'.pim' )
cmds.connectAttr( intersectNode+'.outPoint', trObj+'.t' )
return trObj, crv
def importCache( mesh, xmlFilePath ):
mesh = sgModelDag.getShape( mesh )
xmlFileSplits = xmlFilePath.split( '/' )
cachePath = '/'.join( xmlFileSplits[:-1] )
cacheName = xmlFileSplits[-1].split( '.' )[0]
deformer = cmds.createNode( 'historySwitch' )
cacheNode = cmds.createNode( 'cacheFile' )
cmds.connectAttr( cacheNode+'.outCacheData[0]', deformer+'.inPositions[0]')
cmds.connectAttr( cacheNode+'.inRange', deformer+'.playFromCache' )
cmds.connectAttr( 'time1.outTime', cacheNode+'.time' )
cmds.setAttr( cacheNode+'.cachePath', cachePath, type='string' )
cmds.setAttr( cacheNode+'.cacheName', cacheName, type='string' )
#print "xml filePath : ", xmlFilePath
startFrame, endFrame = sgModelData.getStartAndEndFrameFromXmlFile( xmlFilePath )
cmds.playbackOptions( animationStartTime = startFrame, animationEndTime= endFrame,
minTime = startFrame+5, maxTime= endFrame-5 )
cmds.setAttr( cacheNode+'.startFrame', startFrame )
cmds.setAttr( cacheNode+'.sourceStart', startFrame )
cmds.setAttr( cacheNode+'.sourceEnd', endFrame )
cmds.setAttr( cacheNode+'.originalStart', startFrame )
cmds.setAttr( cacheNode+'.originalEnd', endFrame )
origMesh = sgModelDag.getOrigShape( mesh )
if not origMesh: return None
cmds.connectAttr( origMesh+'.worldMesh', deformer+'.undeformedGeometry[0]' )
cmds.connectAttr( deformer+'.outputGeometry[0]', mesh+'.inMesh', f=1 )
def addCurveInfo(crv):
shape = sgModelDag.getShape(crv)
info = cmds.createNode('curveInfo')
cmds.connectAttr(shape + '.local', info + '.inputCurve')
return info
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 createRivetOnSurfacePoint( surfacePoint, firstDirection='u' ):
import sgBFunction_attribute
if firstDirection.lower() == 'u':
fString = 'U'
sString = 'V'
else:
fString = 'V'
sString = 'U'
surfaceName, uv = surfacePoint.split( '.uv' )
surfaceName = sgModelDag.getShape( surfaceName )
uvSplits = uv.split( '][' )
uValue = float( uvSplits[0].replace( '[', '' ) )
vValue = float( uvSplits[1].replace( ']', '' ) )
pointOnSurf = cmds.createNode( 'pointOnSurfaceInfo' )
vectorNode = cmds.createNode( 'vectorProduct' )
fbfNode = cmds.createNode( 'fourByFourMatrix' )
mmdcNode = cmds.createNode( 'multMatrixDecompose' )
rivetNode = cmds.createNode( 'transform' )
cmds.setAttr( pointOnSurf+'.u', uValue )
cmds.setAttr( pointOnSurf+'.v', vValue )
cmds.setAttr( vectorNode+'.operation', 2 )
cmds.setAttr( rivetNode+'.dla',1 )
cmds.setAttr( rivetNode+'.dh', 1 )
cmds.connectAttr( surfaceName +'.worldSpace[0]', pointOnSurf+'.inputSurface' )
cmds.connectAttr( pointOnSurf+'.tangent%s' % fString, vectorNode+'.input1' )
cmds.connectAttr( pointOnSurf+'.tangent%s' % sString, vectorNode+'.input2' )
cmds.connectAttr( pointOnSurf+'.tangent%sx' % fString, fbfNode+'.i00' )
cmds.connectAttr( pointOnSurf+'.tangent%sy' % fString, fbfNode+'.i01' )
cmds.connectAttr( pointOnSurf+'.tangent%sz' % fString, fbfNode+'.i02' )
cmds.connectAttr( pointOnSurf+'.tangent%sx' % sString, fbfNode+'.i10' )
cmds.connectAttr( pointOnSurf+'.tangent%sy' % sString, fbfNode+'.i11' )
cmds.connectAttr( pointOnSurf+'.tangent%sz' % sString, fbfNode+'.i12' )
cmds.connectAttr( vectorNode+'.outputX', fbfNode+'.i20' )
cmds.connectAttr( vectorNode+'.outputY', fbfNode+'.i21' )
cmds.connectAttr( vectorNode+'.outputZ', fbfNode+'.i22' )
cmds.connectAttr( pointOnSurf+'.positionX', fbfNode+'.i30' )
cmds.connectAttr( pointOnSurf+'.positionY', fbfNode+'.i31' )
cmds.connectAttr( pointOnSurf+'.positionZ', fbfNode+'.i32' )
cmds.connectAttr( fbfNode+'.output', mmdcNode+'.i[0]' )
cmds.connectAttr( rivetNode+'.pim', mmdcNode+'.i[1]' )
cmds.connectAttr( mmdcNode+'.ot', rivetNode+'.t' )
cmds.connectAttr( mmdcNode+'.or', rivetNode+'.r' )
sgBFunction_attribute.addAttr( rivetNode, ln='paramU', min=0, dv=uValue, k=1 )
sgBFunction_attribute.addAttr( rivetNode, ln='paramV', min=0, dv=vValue, k=1 )
cmds.connectAttr( rivetNode+'.paramU', pointOnSurf+'.u' )
cmds.connectAttr( rivetNode+'.paramV', pointOnSurf+'.v' )
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 makeCenterCurveFromCurves(crvs, rebuildSpanRate=1.0):
crvShapes = []
for crv in crvs:
crvShape = sgModelDag.getShape(crv)
if not crvShape: continue
crvShapes.append(crvShape)
lengthAll = 0.0
crvInfo = cmds.createNode('curveInfo')
for crvShape in crvShapes:
if not cmds.isConnected(crvShape + '.local', crvInfo + '.inputCurve'):
cmds.connectAttr(crvShape + '.local', crvInfo + '.inputCurve', f=1)
length = cmds.getAttr(crvInfo + '.arcLength')
lengthAll += length
cmds.delete(crvInfo)
lengthAverage = lengthAll / len(crvShapes)
rebuildSpans = int(lengthAverage * rebuildSpanRate)
for crvShape in crvShapes:
cmds.rebuildCurve(crvShape,
constructionHistory=0,
replaceOriginal=1,
rebuildType=0,
endKnots=1,
keepRange=0,
keepControlPoints=0,
keepEndPoints=1,
keepTangents=0,
s=rebuildSpans,
d=3,
tol=0.01)
fnNurbsCurve = om.MFnNurbsCurve(sgModelDag.getDagPath(crvShapes[0]))
numCVs = fnNurbsCurve.numCVs()
points = []
for i in range(numCVs):
points.append([0, 0, 0])
curve = cmds.curve(p=points, d=3)
for i in range(numCVs):
sumPoints = om.MVector(0, 0, 0)
for crvShape in crvShapes:
sumPoints += om.MVector(*cmds.xform(
crvShape + '.controlPoints[%d]' % i, q=1, ws=1, t=1))
averagePoints = sumPoints / len(crvShapes)
cmds.move(averagePoints.x,
averagePoints.y,
averagePoints.z,
curve + '.controlPoints[%d]' % i,
os=1)
return curve
def duplicateShaderToOther(first, second):
import maya.mel as mel
if not cmds.objExists(first): return None
if not cmds.objExists(second): return None
first = sgModelDag.getTransform(first)
second = sgModelDag.getTransform(second)
firstShape = sgModelDag.getShape(first)
secondShape = sgModelDag.getShape(second)
engines = cmds.listConnections(firstShape, type='shadingEngine')
if not engines: return None
engines = list(set(engines))
for engine in engines:
shaders = cmds.listConnections(engine + '.surfaceShader', s=1, d=0)
if not shaders: continue
shader = shaders[0]
cmds.hyperShade(objects=shader)
selObjs = cmds.ls(sl=1, l=1)
targetObjs = []
for selObj in selObjs:
if selObj.find('.') != -1:
trNode, components = selObj.split('.')
if trNode == first:
targetObjs.append(second + '.' + components)
elif selObj == firstShape:
targetObjs.append(secondShape)
cmds.select(shader)
mel.eval(
'hyperShadePanelMenuCommand("hyperShadePanel1", "duplicateShadingNetwork")'
)
shader = cmds.ls(sl=1)[0]
engine = cmds.duplicate(engine, n=shader + '_engine')[0]
cmds.connectAttr(shader + '.outColor', engine + '.surfaceShader')
for targetObj in targetObjs:
cmds.sets(targetObj, e=1, forceElement=engine)
def duplicateShaderToOther( first, second ):
import maya.mel as mel
if not cmds.objExists( first ): return None
if not cmds.objExists( second ): return None
first = sgModelDag.getTransform( first )
second = sgModelDag.getTransform( second )
firstShape = sgModelDag.getShape( first )
secondShape = sgModelDag.getShape( second )
engines = cmds.listConnections( firstShape, type='shadingEngine' )
if not engines: return None
engines = list( set( engines ) )
for engine in engines:
shaders = cmds.listConnections( engine+'.surfaceShader', s=1, d=0 )
if not shaders: continue
shader = shaders[0]
cmds.hyperShade( objects = shader )
selObjs = cmds.ls( sl=1, l=1 )
targetObjs = []
for selObj in selObjs:
if selObj.find( '.' ) != -1:
trNode, components = selObj.split( '.' )
if trNode == first:
targetObjs.append( second+'.'+components )
elif selObj == firstShape:
targetObjs.append( secondShape )
cmds.select( shader )
mel.eval( 'hyperShadePanelMenuCommand("hyperShadePanel1", "duplicateShadingNetwork")' )
shader = cmds.ls( sl=1 )[0]
engine = cmds.duplicate( engine, n=shader+'_engine' )[0]
cmds.connectAttr( shader+'.outColor', engine+'.surfaceShader' )
for targetObj in targetObjs:
cmds.sets( targetObj, e=1, forceElement=engine )
def moveObjectToClosestPoint( targets, base ):
if not type( targets ) in [ type([]), type(()) ]:
targets = [targets]
dagPathBase = sgModelDag.getDagPath( sgModelDag.getShape( base ) )
baseMatrix = dagPathBase.inclusiveMatrix()
baseInvMatrix = dagPathBase.inclusiveMatrixInverse()
intersector = om.MMeshIntersector()
intersector.create( sgModelDag.getMObject( sgModelDag.getShape( base ) ) )
pointOnMesh = om.MPointOnMesh()
for target in targets:
pivPoint = om.MPoint( *cmds.xform( target, q=1, ws=1, piv=1 )[:3] )*baseInvMatrix
intersector.getClosestPoint( pivPoint, pointOnMesh )
point = pointOnMesh.getPoint()
pointDiff = (om.MVector( point ) - om.MVector( pivPoint ))*baseMatrix
cmds.move( pointDiff.x, pointDiff.y, pointDiff.z, target, ws=1, r=1 )
def moveObjectToClosestPoint(targets, base):
if not type(targets) in [type([]), type(())]:
targets = [targets]
dagPathBase = sgModelDag.getDagPath(sgModelDag.getShape(base))
baseMatrix = dagPathBase.inclusiveMatrix()
baseInvMatrix = dagPathBase.inclusiveMatrixInverse()
intersector = om.MMeshIntersector()
intersector.create(sgModelDag.getMObject(sgModelDag.getShape(base)))
pointOnMesh = om.MPointOnMesh()
for target in targets:
pivPoint = om.MPoint(
*cmds.xform(target, q=1, ws=1, piv=1)[:3]) * baseInvMatrix
intersector.getClosestPoint(pivPoint, pointOnMesh)
point = pointOnMesh.getPoint()
pointDiff = (om.MVector(point) - om.MVector(pivPoint)) * baseMatrix
cmds.move(pointDiff.x, pointDiff.y, pointDiff.z, target, ws=1, r=1)
def copyShader(first, second):
if not cmds.objExists(first): return None
if not cmds.objExists(second): return None
first = sgModelDag.getTransform(first)
second = sgModelDag.getTransform(second)
firstShape = sgModelDag.getShape(first)
secondShape = sgModelDag.getShape(second)
print firstShape
engines = cmds.listConnections(firstShape, type='shadingEngine')
print engines
if not engines: return None
engines = list(set(engines))
for engine in engines:
shaders = cmds.listConnections(engine + '.surfaceShader', s=1, d=0)
if not shaders: continue
shader = shaders[0]
cmds.hyperShade(objects=shader)
selObjs = cmds.ls(sl=1, l=1)
targetObjs = []
for selObj in selObjs:
if selObj.find('.') != -1:
trNode, components = selObj.split('.')
if trNode == first:
targetObjs.append(second + '.' + components)
elif selObj == firstShape:
targetObjs.append(secondShape)
if not targetObjs: continue
for targetObj in targetObjs:
cmds.sets(targetObj, e=1, forceElement=engine)
def copyShader( first, second ):
if not cmds.objExists( first ): return None
if not cmds.objExists( second ): return None
first = sgModelDag.getTransform( first )
second = sgModelDag.getTransform( second )
firstShape = sgModelDag.getShape( first )
secondShape = sgModelDag.getShape( second )
print firstShape
engines = cmds.listConnections( firstShape, type='shadingEngine' )
print engines
if not engines: return None
engines = list( set( engines ) )
for engine in engines:
shaders = cmds.listConnections( engine+'.surfaceShader', s=1, d=0 )
if not shaders: continue
shader = shaders[0]
cmds.hyperShade( objects = shader )
selObjs = cmds.ls( sl=1, l=1 )
targetObjs = []
for selObj in selObjs:
if selObj.find( '.' ) != -1:
trNode, components = selObj.split( '.' )
if trNode == first:
targetObjs.append( second+'.'+components )
elif selObj == firstShape:
targetObjs.append( secondShape )
if not targetObjs: continue
for targetObj in targetObjs:
cmds.sets( targetObj, e=1, forceElement=engine )
def makeCenterCurveFromCurves( crvs, rebuildSpanRate= 1.0 ):
crvShapes = []
for crv in crvs:
crvShape = sgModelDag.getShape( crv )
if not crvShape: continue
crvShapes.append( crvShape )
lengthAll = 0.0
crvInfo = cmds.createNode( 'curveInfo' )
for crvShape in crvShapes:
if not cmds.isConnected( crvShape+'.local', crvInfo+'.inputCurve' ):
cmds.connectAttr( crvShape+'.local', crvInfo+'.inputCurve', f=1 )
length = cmds.getAttr( crvInfo+'.arcLength' )
lengthAll += length
cmds.delete( crvInfo )
lengthAverage = lengthAll / len( crvShapes )
rebuildSpans = int( lengthAverage * rebuildSpanRate )
for crvShape in crvShapes:
cmds.rebuildCurve( crvShape, constructionHistory=0,
replaceOriginal=1,
rebuildType=0,
endKnots=1,
keepRange=0,
keepControlPoints=0,
keepEndPoints=1,
keepTangents=0,
s=rebuildSpans, d=3, tol=0.01 )
fnNurbsCurve = om.MFnNurbsCurve( sgModelDag.getDagPath( crvShapes[0] ) )
numCVs = fnNurbsCurve.numCVs()
points = []
for i in range( numCVs ):
points.append( [0,0,0] )
curve = cmds.curve( p=points, d=3 )
for i in range( numCVs ):
sumPoints = om.MVector(0,0,0)
for crvShape in crvShapes:
sumPoints += om.MVector( *cmds.xform( crvShape+'.controlPoints[%d]' % i, q=1, ws=1, t=1 ) )
averagePoints = sumPoints / len( crvShapes )
cmds.move( averagePoints.x, averagePoints.y, averagePoints.z, curve+'.controlPoints[%d]' % i, os=1 )
return curve
def connectHairSystemAttr( first, second ):
import sgModelAttribute
first = sgModelDag.getShape( first )
second = sgModelDag.getShape( second )
connectAttrList = ['startFrame', 'active', 'simulationMethod',
'iterations', 'lengthFlex',
'startCurveAttract', 'attractionDamp', 'attractionScale',
'stiffness', 'stiffnessScale',
'mass', 'drag', 'tangentialDrag', 'motionDrag', 'damp', 'gravity', 'dynamicsWeight',
'turbulenceStrength', 'turbulenceFrequency', 'turbulenceSpeed' ]
for attr in connectAttrList:
print attr, first
if cmds.attributeQuery( attr, node=first, usesMultiBuilder=1 ):
sgRigAttribute.removeMultiInstances( second, attr )
indices = sgModelAttribute.getMultiAttrIndices(first, attr)
for index in indices:
connectAttrCommon( first+'.'+attr+'[%d]' % index, second+'.'+attr+'[%d]' % index )
else:
connectAttrCommon( first+'.'+attr, second+'.'+attr )
def setPivotToLowerPoint( target ):
dagPath = sgModelDag.getDagPath( sgModelDag.getShape( target ) )
fnMesh = om.MFnMesh( dagPath )
points = om.MPointArray()
fnMesh.getPoints( points )
lowerHeight = 1000000.0
lowerIndex = 0
for i in range( points.length() ):
if lowerHeight > points[i].y:
lowerHeight = points[i].y
lowerIndex = i
lowerPoint = points[ lowerIndex ]*dagPath.inclusiveMatrix()
cmds.move( lowerPoint.x, lowerPoint.y, lowerPoint.z, target+'.rotatePivot', target+'.scalePivot' )
def getExportBakeData( targetRefNode, selTargets ):
selTargets = sgModelConvert.convertFullPathNames( selTargets )
childTargets = cmds.listRelatives( selTargets, c=1, ad=1, type='transform', f=1 )
if not childTargets: childTargets = []
selTargets += childTargets
exportTargets = []
for selTarget in selTargets:
if not cmds.referenceQuery( selTarget, inr=1 ): continue
selTargetRefNode = cmds.referenceQuery( selTarget, rfn=1 )
if selTargetRefNode != targetRefNode: continue
exportTargets.append( selTarget )
exportTargets = list( set( exportTargets ) )
exportTargets.sort()
bakeTargetList = []
shapes = []
for i in range( len( exportTargets ) ):
target = exportTargets[i]
targetMtx = cmds.getAttr( target+'.m' )
targetPiv = cmds.xform( target, q=1, os=1, piv=1 )[:3]
listAttrs = cmds.listAttr( target, k=1 )
attrInfoList = []
for attr in listAttrs:
if cmds.getAttr( target+'.'+ attr, lock=1 ) and not cmds.listConnections( target+'.'+attr, s=1, d=0 ): continue
attrValue = cmds.getAttr( target+'.'+ attr )
if not type( attrValue ) in [ type( 123 ), type( 123.4 ), type( True ) ]: continue
attrInfoList.append( [attr, sgModelDg.AnimCurveForBake( target+'.'+ attr )] )
bakeTargetList.append( [ target, targetMtx, targetPiv, attrInfoList ] )
shape = sgModelDag.getShape( target )
if shape: shapes.append( shape )
deformedShapes = sgModelDag.getDeformedObjects( shapes )
namespace = cmds.referenceQuery( targetRefNode, ns=1 )[1:].replace( ':', '_' )
fileName = cmds.referenceQuery( targetRefNode, filename=1 )
return namespace, fileName, bakeTargetList, deformedShapes
def setPivotToLowerPoint(target):
dagPath = sgModelDag.getDagPath(sgModelDag.getShape(target))
fnMesh = om.MFnMesh(dagPath)
points = om.MPointArray()
fnMesh.getPoints(points)
lowerHeight = 1000000.0
lowerIndex = 0
for i in range(points.length()):
if lowerHeight > points[i].y:
lowerHeight = points[i].y
lowerIndex = i
lowerPoint = points[lowerIndex] * dagPath.inclusiveMatrix()
cmds.move(lowerPoint.x, lowerPoint.y, lowerPoint.z,
target + '.rotatePivot', target + '.scalePivot')
def createSgWobbleCurve(crv, editMatrix=1, createNewCurve=True, addName='_'):
import sgBFunction_base
sgBFunction_base.autoLoadPlugin('sgWobble')
crvShape = sgModelDag.getShape(crv)
if createNewCurve:
srcAttr = crvShape + '.local'
targetCrvShape = cmds.createNode('nurbsCurve')
targetCrv = cmds.listRelatives(targetCrvShape, p=1, f=1)[0]
targetAttr = targetCrvShape + '.create'
cmds.xform(targetCrv, ws=1, matrix=cmds.getAttr(crv + '.wm'))
else:
targetCrv = crv
srcAttr = sgModelDag.getSourceCurveAttr(crvShape)
targetAttr = crvShape + '.create'
sgWobbleCurve = cmds.createNode('sgWobbleCurve2', n='sgWobbleCurve')
mmNode = cmds.createNode('multMatrix')
cmds.connectAttr(srcAttr, sgWobbleCurve + '.inputCurve')
cmds.connectAttr(sgWobbleCurve + '.outputCurve', targetAttr, f=1)
cmds.setAttr(sgWobbleCurve + '.fallOff1[1].fallOff1_Position', 1)
cmds.setAttr(sgWobbleCurve + '.fallOff1[1].fallOff1_FloatValue', 1)
cmds.setAttr(sgWobbleCurve + '.fallOff2[1].fallOff2_Position', 1)
cmds.setAttr(sgWobbleCurve + '.fallOff2[1].fallOff2_FloatValue', 1)
aimMatrix = cmds.createNode('transform', n='aimMatrix')
cmds.connectAttr(aimMatrix + '.wm', mmNode + '.i[0]')
cmds.connectAttr(crv + '.wim', mmNode + '.i[1]')
cmds.connectAttr(mmNode + '.matrixSum', sgWobbleCurve + '.aimMatrix')
cmds.connectAttr('time1.outTime', sgWobbleCurve + '.time')
cmds.setAttr(aimMatrix + '.dh', 1)
cmds.setAttr(aimMatrix + '.dla', 1)
mtx = sgModelCurve.getStartCurveMatrix(targetCrv)
cmds.xform(aimMatrix, ws=1, matrix=mtx)
sgRigAttribute.createSgWobbleAttribute(targetCrv)
try:
targetCrv = cmds.rename(targetCrv, crv.split('|')[-1] + addName)
except:
pass
return targetCrv, aimMatrix
def setBaseMesh(self, meshName):
meshName = sgModelDag.getShape(meshName)
oMesh = sgModelDg.getMObject(meshName)
intersector = om.MMeshIntersector()
fnMesh = om.MFnMesh()
intersector.create(oMesh)
fnMesh.setObject(oMesh)
pointsMesh = om.MPointArray()
fnMesh.getPoints(pointsMesh)
self.mirrorIndices = om.MIntArray()
self.mirrorIndices.setLength(pointsMesh.length())
for i in range(self.mirrorIndices.length()):
self.mirrorIndices[i] = -1
pointOnMesh = om.MPointOnMesh()
indicesVertices = om.MIntArray()
for i in range(pointsMesh.length()):
if self.mirrorIndices[i] != -1: continue
mirrorPoint = om.MPoint(-pointsMesh[i].x, pointsMesh[i].y,
pointsMesh[i].z)
intersector.getClosestPoint(mirrorPoint, pointOnMesh)
faceIndex = pointOnMesh.faceIndex()
fnMesh.getPolygonVertices(faceIndex, indicesVertices)
minDist = 10000000.0
minDistIndex = 0
for j in range(indicesVertices.length()):
dist = mirrorPoint.distanceTo(pointsMesh[indicesVertices[j]])
if dist < minDist:
minDist = dist
minDistIndex = indicesVertices[j]
self.mirrorIndices[i] = minDistIndex
self.mirrorIndices[i] = minDistIndex
self.mirrorIndices[minDistIndex] = i
self.points = pointsMesh
self.meshName = meshName
def getTangentAtParam( curve, paramValue, **options ):
curveShape = sgModelDag.getShape( curve )
objectSpace = sgModelData.getValueFromDict( options, 'os' )
fnCurve= om.MFnNurbsCurve( sgModelDag.getDagPath( curveShape ) )
tangentValue = om.MVector()
if objectSpace:
tangentValue = fnCurve.tangent( paramValue )
else:
worldMatrix = cmds.getAttr( curve+'.wm')
worldMMatrix = sgModelConvert.convertMatrixToMMatrix( worldMatrix )
tangentValue = fnCurve.tangent( paramValue ) * worldMMatrix
return tangentValue
def createSgWobbleCurve( crv, editMatrix=1, createNewCurve=True, addName = '_' ):
import sgBFunction_base
sgBFunction_base.autoLoadPlugin( 'sgWobble' )
crvShape = sgModelDag.getShape( crv )
if createNewCurve:
srcAttr = crvShape+'.local'
targetCrvShape = cmds.createNode( 'nurbsCurve' )
targetCrv = cmds.listRelatives( targetCrvShape, p=1, f=1 )[0]
targetAttr = targetCrvShape+'.create'
cmds.xform( targetCrv, ws=1, matrix= cmds.getAttr( crv+'.wm' ) )
else:
targetCrv = crv
srcAttr = sgModelDag.getSourceCurveAttr( crvShape )
targetAttr = crvShape+'.create'
sgWobbleCurve = cmds.createNode( 'sgWobbleCurve2', n='sgWobbleCurve' )
mmNode = cmds.createNode( 'multMatrix' )
cmds.connectAttr( srcAttr, sgWobbleCurve+'.inputCurve' )
cmds.connectAttr( sgWobbleCurve+'.outputCurve', targetAttr, f=1 )
cmds.setAttr( sgWobbleCurve+'.fallOff1[1].fallOff1_Position', 1 )
cmds.setAttr( sgWobbleCurve+'.fallOff1[1].fallOff1_FloatValue', 1 )
cmds.setAttr( sgWobbleCurve+'.fallOff2[1].fallOff2_Position', 1 )
cmds.setAttr( sgWobbleCurve+'.fallOff2[1].fallOff2_FloatValue', 1 )
aimMatrix = cmds.createNode( 'transform', n='aimMatrix' )
cmds.connectAttr( aimMatrix+'.wm', mmNode+'.i[0]' )
cmds.connectAttr( crv+'.wim', mmNode+'.i[1]' )
cmds.connectAttr( mmNode+'.matrixSum', sgWobbleCurve+'.aimMatrix' )
cmds.connectAttr( 'time1.outTime', sgWobbleCurve+'.time')
cmds.setAttr( aimMatrix+'.dh',1 )
cmds.setAttr( aimMatrix+'.dla', 1 )
mtx = sgModelCurve.getStartCurveMatrix( targetCrv )
cmds.xform( aimMatrix, ws=1, matrix=mtx )
sgRigAttribute.createSgWobbleAttribute( targetCrv )
try:targetCrv = cmds.rename( targetCrv, crv.split( '|' )[-1]+addName)
except: pass
return targetCrv, aimMatrix
def getPointAtParam( curve, paramValue, **options ):
curveShape = sgModelDag.getShape( curve )
objectSpace = sgModelData.getValueFromDict( options, 'os' )
fnCurve= om.MFnNurbsCurve( sgModelDag.getDagPath( curveShape ) )
pointValue = om.MPoint()
if objectSpace:
fnCurve.getPointAtParam( paramValue, pointValue )
else:
worldMatrix = cmds.getAttr( curve+'.wm')
worldMMatrix = sgModelConvert.convertMatrixToMMatrix( worldMatrix )
fnCurve.getPointAtParam( paramValue, pointValue )
pointValue *= worldMMatrix
return pointValue
def closePointBlendToTargetMesh(jnts, mesh):
def rivetBlend(first, second):
firstP = cmds.listRelatives(first, p=1)[0]
blendTwoMatrix = cmds.createNode('blendTwoMatrix')
mmdc = cmds.createNode('multMatrixDecompose')
cmds.connectAttr(firstP + '.wm', blendTwoMatrix + '.inMatrix1')
cmds.connectAttr(second + '.wm', blendTwoMatrix + '.inMatrix2')
cmds.connectAttr(blendTwoMatrix + '.outMatrix', mmdc + '.i[0]')
cmds.connectAttr(firstP + '.wim', mmdc + '.i[1]')
cmds.connectAttr(mmdc + '.ot', first + '.t')
sgRigAttribute.addAttr(first, ln='blend', min=0, max=1, k=1, dv=0.9)
cmds.connectAttr(first + '.blend', blendTwoMatrix + '.ab')
sels = jnts
dcmp = cmds.createNode('decomposeMatrix')
closestPointOnMesh = cmds.createNode('closestPointOnMesh')
mesh = sgModelDag.getShape(mesh)
cmds.connectAttr(mesh + '.outMesh', closestPointOnMesh + '.inMesh')
cmds.connectAttr(mesh + '.wm', closestPointOnMesh + '.inputMatrix')
cmds.connectAttr(dcmp + '.ot', closestPointOnMesh + '.inPosition', f=1)
for sel in sels:
cmds.connectAttr(sel + '.wm', dcmp + '.imat', f=1)
vtxIndex = cmds.getAttr(closestPointOnMesh + '.closestVertexIndex')
rivetObject = rigObject.meshRivetConnect.cmdModel.createRivet(
mesh, [vtxIndex], [vtxIndex], [vtxIndex], [vtxIndex], [vtxIndex],
0, 1)
rivetBlend(sel, rivetObject)
cmds.setAttr(sel + '.blend', 0.5)
cmds.delete(dcmp, closestPointOnMesh)
def addWobbleDeform( mainCtl, targets ):
import math
if not type( targets ) in [ type(()), type([]) ]:
targets = [targets]
failedTargets = []
for target in targets:
vtxList = cmds.ls( target+'.vtx[*]', fl=1 )
topVtxPos = [0,0,0]
bottomVtxPos = [0,10000,0]
for vtx in vtxList:
pos = cmds.xform( vtx, q=1, ws=1, t=1 )
if math.fabs( pos[1] ) > math.fabs( topVtxPos[1] ):
topVtxPos = pos
if math.fabs( pos[1] ) < math.fabs( bottomVtxPos[1] ):
bottomVtxPos = pos
if( (topVtxPos[0]-bottomVtxPos[0])**2 + (topVtxPos[1]-bottomVtxPos[1])**2 + (topVtxPos[2]-bottomVtxPos[2])**2 ) < 0.001:
failedTargets.append( target )
continue
crv = cmds.curve( p=[bottomVtxPos,topVtxPos], d=1 )
cmds.rebuildCurve( crv, ch=0, d=3, s=10 )
sgRigCurve.createSgWobbleCurve( crv, False )
copyAttrs = [ 'globalEnvelope', 'globalTimeMult', 'globalOffset' ]
for copyAttr in copyAttrs:
sgRigAttribute.copyAttribute( crv+'.'+copyAttr, mainCtl )
cmds.connectAttr( mainCtl+'.'+copyAttr, crv+'.'+copyAttr )
wire = cmds.deformer( target, type='wire' )[0]
crvOrig = sgModelDag.getOrigShape( crv )
crvShape= sgModelDag.getShape( crv )
cmds.connectAttr( crvOrig+'.local', wire+'.baseWire[0]' )
cmds.connectAttr( crvShape+'.local', wire+'.deformedWire[0]' )
cmds.setAttr( wire+'.rotation', 0.2 )
cmds.setAttr( wire+'.dropoffDistance[0]', 10 )
return failedTargets
def createRoofPointers(crv, numPointer, roofLength=None):
if not roofLength: roofLength = numPointer
crv = sgModelDag.getTransform(crv)
crvShape = sgModelDag.getShape(crv)
sgRigAttribute.addAttr(crv, ln='roofValue', k=1)
minValue = cmds.getAttr(crvShape + '.minValue')
maxValue = cmds.getAttr(crvShape + '.maxValue')
eachInputOffset = float(roofLength) / numPointer
pointers = []
for i in range(numPointer):
curveInfo = cmds.createNode('pointOnCurveInfo')
pointer = cmds.createNode('transform', n=crv + '_pointer_%d' % i)
sgRigAttribute.addAttr(pointer, ln='roofPointerNum', dv=i)
sgRigAttribute.addAttr(pointer,
ln='parameter',
dv=i * eachInputOffset,
k=1)
cmds.setAttr(pointer + '.dh', 1)
cmds.connectAttr(crvShape + '.local', curveInfo + '.inputCurve')
addNode = cmds.createNode('plusMinusAverage')
animCurve = sgModelDg.getRoofLinearCurve(0, float(roofLength),
minValue, maxValue)
cmds.connectAttr(crv + '.roofValue', addNode + '.input1D[0]')
cmds.connectAttr(pointer + '.parameter', addNode + '.input1D[1]')
cmds.connectAttr(addNode + '.output1D', animCurve + '.input')
cmds.connectAttr(animCurve + '.output', curveInfo + '.parameter')
cmds.connectAttr(curveInfo + '.position', pointer + '.t')
pointer = cmds.parent(pointer, crv)[0]
pointers.append(pointer)
return pointers
def MeshSetClosestPoint(baseName, targetName):
baseName = sgModelDag.getShape(baseName)
oBase = sgModelDg.getMObject(baseName)
intersector = om.MMeshIntersector()
fnMeshBase = om.MFnMesh(oBase)
intersector.create(oBase)
pointsBase = om.MPointArray()
fnMeshBase.getPoints(pointsBase)
dagPathTarget = sgModelDag.getDagPath(targetName)
fnMeshTarget = om.MFnMesh(dagPathTarget)
pointsTarget = om.MPointArray()
fnMeshTarget.getPoints(pointsTarget)
pointOnMesh = om.MPointOnMesh()
indicesVtx = om.MIntArray()
for i in range(pointsTarget.length()):
intersector.getClosestPoint(pointsTarget[i], pointOnMesh)
faceIndex = pointOnMesh.faceIndex()
fnMeshBase.getPolygonVertices(faceIndex, indicesVtx)
closeDist = 1000000.0
closeIndex = 0
for j in range(indicesVtx.length()):
dist = pointsTarget[i].distanceTo(pointsBase[indicesVtx[j]])
if dist < closeDist:
closeDist = dist
closeIndex = indicesVtx[j]
pointBase = pointsBase[closeIndex]
cmds.move(pointBase.x,
pointBase.y,
pointBase.z,
targetName + '.vtx[%d]' % i,
os=1)
def getParamAtPoint( curve, MPointValue, **options ):
curveShape = sgModelDag.getShape( curve )
objectSpace = sgModelData.getValueFromDict( options, 'os' )
nearPointOnCurve = cmds.createNode( 'nearestPointOnCurve')
cmds.connectAttr( curveShape+'.local', nearPointOnCurve+'.inputCurve' )
paramValue = 0.0
if objectSpace:
cmds.setAttr( nearPointOnCurve+'.inPosition', MPointValue.x, MPointValue.y, MPointValue.z )
paramValue = cmds.getAttr( nearPointOnCurve+'.parameter' )
else:
worldMatrix = cmds.getAttr( curve+'.wm')
worldMMatrix = sgModelConvert.convertMatrixToMMatrix( worldMatrix )
localMPoint = MPointValue * worldMMatrix.inverse()
cmds.setAttr( nearPointOnCurve+'.inPosition', localMPoint.x, localMPoint.y, localMPoint.z )
paramValue = cmds.getAttr( nearPointOnCurve+'.parameter' )
cmds.delete( nearPointOnCurve )
return paramValue
def createRoofPointers( crv, numPointer, roofLength=None ):
if not roofLength: roofLength = numPointer
crv = sgModelDag.getTransform( crv )
crvShape= sgModelDag.getShape( crv )
sgRigAttribute.addAttr( crv, ln='roofValue', k=1 )
minValue = cmds.getAttr( crvShape+'.minValue' )
maxValue = cmds.getAttr( crvShape+'.maxValue' )
eachInputOffset = float( roofLength ) / numPointer
pointers = []
for i in range( numPointer ):
curveInfo = cmds.createNode( 'pointOnCurveInfo' )
pointer = cmds.createNode( 'transform', n= crv+'_pointer_%d' % i )
sgRigAttribute.addAttr( pointer, ln='roofPointerNum', dv=i )
sgRigAttribute.addAttr( pointer, ln='parameter', dv=i*eachInputOffset, k=1 )
cmds.setAttr( pointer+'.dh', 1 )
cmds.connectAttr( crvShape+'.local', curveInfo+'.inputCurve' )
addNode = cmds.createNode( 'plusMinusAverage' )
animCurve = sgModelDg.getRoofLinearCurve( 0, float( roofLength ), minValue, maxValue )
cmds.connectAttr( crv+'.roofValue', addNode+'.input1D[0]' )
cmds.connectAttr( pointer+'.parameter', addNode+'.input1D[1]' )
cmds.connectAttr( addNode+'.output1D', animCurve+'.input' )
cmds.connectAttr( animCurve+'.output', curveInfo+'.parameter' )
cmds.connectAttr( curveInfo+'.position', pointer+'.t' )
pointer = cmds.parent( pointer, crv )[0]
pointers.append( pointer )
return pointers
def importBakeData( cachePath ):
sceneInfoPath = cachePath + '/sceneInfo.sceneInfo'
f = open( sceneInfoPath, 'r' )
sceneInfo = cPickle.load( f )
f.close()
timeUnit, minTime, maxTime = sceneInfo
cmds.currentUnit( time=timeUnit )
cmds.playbackOptions( minTime=minTime, maxTime=maxTime )
cmds.currentTime( 1 )
namespaces = []
bakeInfoFiles = []
assetInfoFiles = []
animCurvesFiles = []
for root, dirs, names in os.walk( cachePath ):
for name in names:
splits = name.split( '.' )
assetInfoPath = root + '/' + name.replace( 'bakeInfo', 'assetInfo' )
animCurvesPath = root + '/' + name.replace( 'bakeInfo', 'ma' )
if splits[-1] == 'bakeInfo' and sgModelFileAndPath.isFile( assetInfoPath ) and sgModelFileAndPath.isFile( animCurvesPath ):
namespaces.append( '.'.join( name.split('.')[:-1] ) )
bakeInfoFiles.append( root + '/' + name )
assetInfoFiles.append( assetInfoPath )
animCurvesFiles.append( animCurvesPath )
cacheBodyPathList = []
for i in range( len( bakeInfoFiles ) ):
bakeInfoFile = bakeInfoFiles[i]
assetInfoFile = assetInfoFiles[i]
animCurvesFile = animCurvesFiles[i]
f = open( assetInfoFile, 'r' )
assetPath = f.read()
f.close()
splits = assetPath.split( '.' )
cacheBodyPath = '.'.join( splits[:-1] ) + '_cachebody.mb'
if not sgModelFileAndPath.isFile( cacheBodyPath ): continue
cmds.file( cacheBodyPath, i=True, type="mayaBinary", mergeNamespacesOnClash=False, ra=True, namespace = ':', rdn=1,
options= "v=0;", pr=1, loadReferenceDepth="all" )
cmds.file( animCurvesFile, r=True, type='mayaAscii', mergeNamespacesOnClash=False, namespace = '%s_anim' % namespaces[i],
options= "v=0;" )
cacheBodyPathList.append( cacheBodyPath )
f = open( bakeInfoFile, 'r' )
bakeTargetList = cPickle.load( f )
for j in range( len( bakeTargetList ) ):
bakeObjectInfo = bakeTargetList[j]
bakeObjectOrigName, matrix, piv, attrList = bakeObjectInfo
localName = bakeObjectOrigName.split( '|' )[-1]
localNameRemoveNamespace = localName.split( ':' )[-1]
if not cmds.objExists( localNameRemoveNamespace ): continue
shapeName = sgModelDag.getShape( localNameRemoveNamespace )
if not shapeName: continue
bakeObjectOrigName = bakeObjectOrigName.replace( ':', '_' )
sgFunctionDag.makeTransform( bakeObjectOrigName )
#print shapeName, '->', bakeObjectOrigName
shapeName = cmds.parent( shapeName, bakeObjectOrigName, shape=1, r=1 )
shapeLocalName = cmds.rename( shapeName, bakeObjectOrigName.split( '|' )[-1]+'Shape' )
shapeCachePath = cachePath + '/' + shapeLocalName + '.xml'
if sgModelFileAndPath.isFile( shapeCachePath ):
importCache( shapeLocalName, shapeCachePath )
cmds.xform( bakeObjectOrigName, matrix=matrix )
cmds.xform( bakeObjectOrigName, piv = piv )
cmds.delete( localNameRemoveNamespace )
try:cmds.delete( 'MOD' )
except:pass
for animCurve in cmds.ls( type='animCurve' ):
if not cmds.attributeQuery( 'bakeTargetAttrName', node=animCurve, ex=1 ): continue
targetAttr = cmds.getAttr( animCurve+'.bakeTargetAttrName' )
if not cmds.ls( targetAttr.replace( ':', '_' ) ): continue
if cmds.isConnected( animCurve+'.output', targetAttr.replace( ':', '_' ) ): continue
cmds.connectAttr( animCurve+'.output', targetAttr.replace( ':', '_' ) )
sameIndicesList = []
for i in range( len( cacheBodyPathList )-1 ):
for j in range( i+1, len( cacheBodyPathList ) ):
if cacheBodyPathList[i] == cacheBodyPathList[j]:
sameIndicesList.append( [i,j] )
for i, j in sameIndicesList:
first = namespaces[i]+'_MOD'
second = namespaces[j]+'_MOD'
setMultiObjectShaderCombine( [ first, second ] )
setMultiObjectOrigShapeCombine( [ first, second ] )
def addSurfaceLineObject( targetCurve, multValue = 1, range = 1 ):
crvShape = sgModelDag.getShape( targetCurve )
rebuildCurveNode = cmds.createNode( 'rebuildCurve' )
detachCurveNode = cmds.createNode( 'detachCurve' )
circleNode = cmds.createNode( 'makeNurbCircle' )
extrudeNode = cmds.createNode( 'extrude' )
surfaceNode = cmds.createNode( 'nurbsSurface' )
curveInfo = cmds.createNode( 'curveInfo' )
cmds.connectAttr( crvShape+'.worldSpace', curveInfo+'.inputCurve' )
multValue = cmds.getAttr( curveInfo+'.arcLength' ) * multValue
cmds.setAttr( rebuildCurveNode+'.spans', multValue )
cmds.setAttr( rebuildCurveNode+'.keepRange', 0 )
cmds.setAttr( detachCurveNode+'.parameter[0]', 0.25 )
cmds.setAttr( detachCurveNode+'.parameter[1]', 0.75 )
cmds.setAttr( extrudeNode+'.fixedPath', 1 )
cmds.setAttr( extrudeNode+'.useProfileNormal', 1 )
cmds.setAttr( extrudeNode+'.useComponentPivot', 1 )
cmds.connectAttr( crvShape+'.local', rebuildCurveNode+'.inputCurve' )
cmds.connectAttr( rebuildCurveNode+'.outputCurve', detachCurveNode+'.inputCurve' )
cmds.connectAttr( circleNode+'.outputCurve', extrudeNode+'.profile' )
cmds.connectAttr( detachCurveNode+'.outputCurve[1]', extrudeNode+'.path' )
cmds.connectAttr( extrudeNode+'.outputSurface', surfaceNode+'.create' )
surfNodeParent = cmds.listRelatives( surfaceNode, p=1 )[0]
sgRigAttribute.addAttr( surfNodeParent, ln='radius', min=0, dv=1, k=1 )
sgRigAttribute.addAttr( surfNodeParent, ln='parameter', min= 0, max=range, k=1 )
sgRigAttribute.addAttr( surfNodeParent, ln='length', min=0, max=range, dv=range*0.5, k=1 )
cmds.connectAttr( surfNodeParent+'.radius', circleNode+'.radius' )
rangeNode = cmds.createNode( 'setRange' )
minusMultNode = cmds.createNode( 'multDoubleLinear' )
plusMultNode = cmds.createNode( 'multDoubleLinear' )
minusAddNode = cmds.createNode( 'addDoubleLinear' )
plusAddNode = cmds.createNode( 'addDoubleLinear' )
cmds.connectAttr( surfNodeParent+'.parameter', rangeNode+'.valueX' )
cmds.connectAttr( surfNodeParent+'.length', minusMultNode+'.input1' )
cmds.connectAttr( surfNodeParent+'.length', plusMultNode+'.input1' )
cmds.setAttr( minusMultNode+'.input2', -0.5 )
cmds.setAttr( plusMultNode+'.input2', 0.5 )
cmds.connectAttr( minusMultNode+'.output', minusAddNode+'.input1' )
cmds.connectAttr( plusMultNode+'.output', plusAddNode+'.input1' )
cmds.setAttr( minusAddNode+'.input2', 0 )
cmds.setAttr( plusAddNode +'.input2', range )
cmds.connectAttr( minusAddNode+'.output', rangeNode+'.minX' )
cmds.connectAttr( plusAddNode+'.output', rangeNode+'.maxX' )
cmds.setAttr( rangeNode+'.oldMinX', 0 )
cmds.setAttr( rangeNode+'.oldMaxX', range )
addMinNode = cmds.createNode( 'addDoubleLinear' )
addMaxNode = cmds.createNode( 'addDoubleLinear' )
cmds.connectAttr( rangeNode+'.outValueX', addMinNode+'.input1' )
cmds.connectAttr( rangeNode+'.outValueX', addMaxNode+'.input1' )
cmds.connectAttr( minusMultNode+'.output', addMinNode+'.input2' )
cmds.connectAttr( plusMultNode+'.output', addMaxNode+'.input2' )
minConditionFirst = cmds.createNode( 'condition' )
minConditionSecond = cmds.createNode( 'condition' )
maxConditionFirst = cmds.createNode( 'condition' )
maxConditionSecond = cmds.createNode( 'condition' )
cmds.connectAttr( addMinNode+'.output', minConditionFirst+'.firstTerm' )
cmds.connectAttr( addMinNode+'.output', minConditionFirst+'.colorIfFalseR' )
cmds.setAttr( minConditionFirst+'.secondTerm', range-0.0001 )
cmds.setAttr( minConditionFirst+'.colorIfTrueR', range-0.0001 )
cmds.setAttr( minConditionFirst+'.op', 2 )
cmds.connectAttr( minConditionFirst+'.outColorR', minConditionSecond+'.firstTerm' )
cmds.connectAttr( minConditionFirst+'.outColorR', minConditionSecond+'.colorIfFalseR' )
cmds.setAttr( minConditionSecond+'.secondTerm', 0 )
cmds.setAttr( minConditionSecond+'.colorIfTrueR', 0 )
cmds.setAttr( minConditionSecond+'.op', 4 )
cmds.connectAttr( addMaxNode+'.output', maxConditionFirst+'.firstTerm' )
cmds.connectAttr( addMaxNode+'.output', maxConditionFirst+'.colorIfFalseR' )
cmds.setAttr( maxConditionFirst+'.secondTerm', range )
cmds.setAttr( maxConditionFirst+'.colorIfTrueR', range )
cmds.setAttr( maxConditionFirst+'.op', 2 )
cmds.connectAttr( maxConditionFirst+'.outColorR', maxConditionSecond+'.firstTerm' )
cmds.connectAttr( maxConditionFirst+'.outColorR', maxConditionSecond+'.colorIfFalseR' )
cmds.setAttr( maxConditionSecond+'.secondTerm', 0.0001 )
cmds.setAttr( maxConditionSecond+'.colorIfTrueR', 0.0001 )
cmds.setAttr( maxConditionSecond+'.op', 4 )
minMult = cmds.createNode( 'multDoubleLinear' )
maxMult = cmds.createNode( 'multDoubleLinear' )
cmds.connectAttr( minConditionSecond+'.outColorR', minMult+'.input1' )
cmds.connectAttr( maxConditionSecond+'.outColorR', maxMult+'.input1' )
cmds.setAttr( minMult+'.input2', 1.0/range )
cmds.setAttr( maxMult+'.input2', 1.0/range )
cmds.connectAttr( minMult+'.output', detachCurveNode+'.parameter[0]' )
cmds.connectAttr( maxMult+'.output', detachCurveNode+'.parameter[1]' )
cmds.select( surfNodeParent )
def addSurfaceLineObject(targetCurve, multValue=1, range=1):
crvShape = sgModelDag.getShape(targetCurve)
rebuildCurveNode = cmds.createNode('rebuildCurve')
detachCurveNode = cmds.createNode('detachCurve')
circleNode = cmds.createNode('makeNurbCircle')
extrudeNode = cmds.createNode('extrude')
surfaceNode = cmds.createNode('nurbsSurface')
curveInfo = cmds.createNode('curveInfo')
cmds.connectAttr(crvShape + '.worldSpace', curveInfo + '.inputCurve')
multValue = cmds.getAttr(curveInfo + '.arcLength') * multValue
cmds.setAttr(rebuildCurveNode + '.spans', multValue)
cmds.setAttr(rebuildCurveNode + '.keepRange', 0)
cmds.setAttr(detachCurveNode + '.parameter[0]', 0.25)
cmds.setAttr(detachCurveNode + '.parameter[1]', 0.75)
cmds.setAttr(extrudeNode + '.fixedPath', 1)
cmds.setAttr(extrudeNode + '.useProfileNormal', 1)
cmds.setAttr(extrudeNode + '.useComponentPivot', 1)
cmds.connectAttr(crvShape + '.local', rebuildCurveNode + '.inputCurve')
cmds.connectAttr(rebuildCurveNode + '.outputCurve',
detachCurveNode + '.inputCurve')
cmds.connectAttr(circleNode + '.outputCurve', extrudeNode + '.profile')
cmds.connectAttr(detachCurveNode + '.outputCurve[1]',
extrudeNode + '.path')
cmds.connectAttr(extrudeNode + '.outputSurface', surfaceNode + '.create')
surfNodeParent = cmds.listRelatives(surfaceNode, p=1)[0]
sgRigAttribute.addAttr(surfNodeParent, ln='radius', min=0, dv=1, k=1)
sgRigAttribute.addAttr(surfNodeParent,
ln='parameter',
min=0,
max=range,
k=1)
sgRigAttribute.addAttr(surfNodeParent,
ln='length',
min=0,
max=range,
dv=range * 0.5,
k=1)
cmds.connectAttr(surfNodeParent + '.radius', circleNode + '.radius')
rangeNode = cmds.createNode('setRange')
minusMultNode = cmds.createNode('multDoubleLinear')
plusMultNode = cmds.createNode('multDoubleLinear')
minusAddNode = cmds.createNode('addDoubleLinear')
plusAddNode = cmds.createNode('addDoubleLinear')
cmds.connectAttr(surfNodeParent + '.parameter', rangeNode + '.valueX')
cmds.connectAttr(surfNodeParent + '.length', minusMultNode + '.input1')
cmds.connectAttr(surfNodeParent + '.length', plusMultNode + '.input1')
cmds.setAttr(minusMultNode + '.input2', -0.5)
cmds.setAttr(plusMultNode + '.input2', 0.5)
cmds.connectAttr(minusMultNode + '.output', minusAddNode + '.input1')
cmds.connectAttr(plusMultNode + '.output', plusAddNode + '.input1')
cmds.setAttr(minusAddNode + '.input2', 0)
cmds.setAttr(plusAddNode + '.input2', range)
cmds.connectAttr(minusAddNode + '.output', rangeNode + '.minX')
cmds.connectAttr(plusAddNode + '.output', rangeNode + '.maxX')
cmds.setAttr(rangeNode + '.oldMinX', 0)
cmds.setAttr(rangeNode + '.oldMaxX', range)
addMinNode = cmds.createNode('addDoubleLinear')
addMaxNode = cmds.createNode('addDoubleLinear')
cmds.connectAttr(rangeNode + '.outValueX', addMinNode + '.input1')
cmds.connectAttr(rangeNode + '.outValueX', addMaxNode + '.input1')
cmds.connectAttr(minusMultNode + '.output', addMinNode + '.input2')
cmds.connectAttr(plusMultNode + '.output', addMaxNode + '.input2')
minConditionFirst = cmds.createNode('condition')
minConditionSecond = cmds.createNode('condition')
maxConditionFirst = cmds.createNode('condition')
maxConditionSecond = cmds.createNode('condition')
cmds.connectAttr(addMinNode + '.output', minConditionFirst + '.firstTerm')
cmds.connectAttr(addMinNode + '.output',
minConditionFirst + '.colorIfFalseR')
cmds.setAttr(minConditionFirst + '.secondTerm', range - 0.0001)
cmds.setAttr(minConditionFirst + '.colorIfTrueR', range - 0.0001)
cmds.setAttr(minConditionFirst + '.op', 2)
cmds.connectAttr(minConditionFirst + '.outColorR',
minConditionSecond + '.firstTerm')
cmds.connectAttr(minConditionFirst + '.outColorR',
minConditionSecond + '.colorIfFalseR')
cmds.setAttr(minConditionSecond + '.secondTerm', 0)
cmds.setAttr(minConditionSecond + '.colorIfTrueR', 0)
cmds.setAttr(minConditionSecond + '.op', 4)
cmds.connectAttr(addMaxNode + '.output', maxConditionFirst + '.firstTerm')
cmds.connectAttr(addMaxNode + '.output',
maxConditionFirst + '.colorIfFalseR')
cmds.setAttr(maxConditionFirst + '.secondTerm', range)
cmds.setAttr(maxConditionFirst + '.colorIfTrueR', range)
cmds.setAttr(maxConditionFirst + '.op', 2)
cmds.connectAttr(maxConditionFirst + '.outColorR',
maxConditionSecond + '.firstTerm')
cmds.connectAttr(maxConditionFirst + '.outColorR',
maxConditionSecond + '.colorIfFalseR')
cmds.setAttr(maxConditionSecond + '.secondTerm', 0.0001)
cmds.setAttr(maxConditionSecond + '.colorIfTrueR', 0.0001)
cmds.setAttr(maxConditionSecond + '.op', 4)
minMult = cmds.createNode('multDoubleLinear')
maxMult = cmds.createNode('multDoubleLinear')
cmds.connectAttr(minConditionSecond + '.outColorR', minMult + '.input1')
cmds.connectAttr(maxConditionSecond + '.outColorR', maxMult + '.input1')
cmds.setAttr(minMult + '.input2', 1.0 / range)
cmds.setAttr(maxMult + '.input2', 1.0 / range)
cmds.connectAttr(minMult + '.output', detachCurveNode + '.parameter[0]')
cmds.connectAttr(maxMult + '.output', detachCurveNode + '.parameter[1]')
cmds.select(surfNodeParent)
def createRivetOnSurfacePoint(surfacePoint, firstDirection='u'):
import sgBFunction_attribute
if firstDirection.lower() == 'u':
fString = 'U'
sString = 'V'
else:
fString = 'V'
sString = 'U'
surfaceName, uv = surfacePoint.split('.uv')
surfaceName = sgModelDag.getShape(surfaceName)
uvSplits = uv.split('][')
uValue = float(uvSplits[0].replace('[', ''))
vValue = float(uvSplits[1].replace(']', ''))
pointOnSurf = cmds.createNode('pointOnSurfaceInfo')
vectorNode = cmds.createNode('vectorProduct')
fbfNode = cmds.createNode('fourByFourMatrix')
mmdcNode = cmds.createNode('multMatrixDecompose')
rivetNode = cmds.createNode('transform')
cmds.setAttr(pointOnSurf + '.u', uValue)
cmds.setAttr(pointOnSurf + '.v', vValue)
cmds.setAttr(vectorNode + '.operation', 2)
cmds.setAttr(rivetNode + '.dla', 1)
cmds.setAttr(rivetNode + '.dh', 1)
cmds.connectAttr(surfaceName + '.worldSpace[0]',
pointOnSurf + '.inputSurface')
cmds.connectAttr(pointOnSurf + '.tangent%s' % fString,
vectorNode + '.input1')
cmds.connectAttr(pointOnSurf + '.tangent%s' % sString,
vectorNode + '.input2')
cmds.connectAttr(pointOnSurf + '.tangent%sx' % fString, fbfNode + '.i00')
cmds.connectAttr(pointOnSurf + '.tangent%sy' % fString, fbfNode + '.i01')
cmds.connectAttr(pointOnSurf + '.tangent%sz' % fString, fbfNode + '.i02')
cmds.connectAttr(pointOnSurf + '.tangent%sx' % sString, fbfNode + '.i10')
cmds.connectAttr(pointOnSurf + '.tangent%sy' % sString, fbfNode + '.i11')
cmds.connectAttr(pointOnSurf + '.tangent%sz' % sString, fbfNode + '.i12')
cmds.connectAttr(vectorNode + '.outputX', fbfNode + '.i20')
cmds.connectAttr(vectorNode + '.outputY', fbfNode + '.i21')
cmds.connectAttr(vectorNode + '.outputZ', fbfNode + '.i22')
cmds.connectAttr(pointOnSurf + '.positionX', fbfNode + '.i30')
cmds.connectAttr(pointOnSurf + '.positionY', fbfNode + '.i31')
cmds.connectAttr(pointOnSurf + '.positionZ', fbfNode + '.i32')
cmds.connectAttr(fbfNode + '.output', mmdcNode + '.i[0]')
cmds.connectAttr(rivetNode + '.pim', mmdcNode + '.i[1]')
cmds.connectAttr(mmdcNode + '.ot', rivetNode + '.t')
cmds.connectAttr(mmdcNode + '.or', rivetNode + '.r')
sgBFunction_attribute.addAttr(rivetNode,
ln='paramU',
min=0,
dv=uValue,
k=1)
sgBFunction_attribute.addAttr(rivetNode,
ln='paramV',
min=0,
dv=vValue,
k=1)
cmds.connectAttr(rivetNode + '.paramU', pointOnSurf + '.u')
cmds.connectAttr(rivetNode + '.paramV', pointOnSurf + '.v')
def createConveyerBeltSet( meshName, firstEdgeIndex, secondEdgeIndex ):
firstEdges = cmds.polySelectSp( meshName+'.e[%d]' % firstEdgeIndex, loop=1 )
secondEdges = cmds.polySelectSp( meshName+'.e[%d]' % secondEdgeIndex, loop=1 )
cmds.select( firstEdges )
firstCurve = cmds.polyToCurve( form=2, degree=3, n=meshName+'_loopCurve_First' )[0]
cmds.select( secondEdges )
secondCurve = cmds.polyToCurve( form=2, degree=3, n=meshName+'_loopCurve_Second' )[0]
firstCurveShape = sgModelDag.getShape( firstCurve )
secondCurveShape = sgModelDag.getShape( secondCurve )
firstSpans = cmds.getAttr( firstCurveShape +'.spans' )
secondSpans = cmds.getAttr( secondCurveShape+'.spans' )
firstTangent = sgModelCurve.getTangentAtParam( firstCurveShape, 0.0 )
firstParamPoint = sgModelCurve.getPointAtParam( firstCurveShape, 0.0 )
secondParam = sgModelCurve.getParamAtPoint( secondCurveShape, firstParamPoint )
secondTangent = sgModelCurve.getTangentAtParam( secondCurveShape, secondParam )
if firstTangent * secondTangent < 0:
cmds.reverseCurve( secondCurve, ch = 1, rpo = 1 )
firstPointers = sgRigCurve.createRoofPointers( firstCurve, firstSpans )
secondPointers = sgRigCurve.createRoofPointers( secondCurve, secondSpans )
fPos = cmds.xform( firstPointers[0], q=1, ws=1, t=1 )
minDistPointer = secondPointers[0]
minDist = 1000000000.0
for secondPointer in secondPointers:
sPos = cmds.xform( secondPointer, q=1, ws=1, t=1 )
dist = (fPos[0]-sPos[0])**2+(fPos[1]-sPos[1])**2+(fPos[2]-sPos[2])**2
if dist < minDist:
minDistPointer = secondPointer
minDist = dist
offset = int( minDistPointer.split( '_' )[-1] )
crvs = []
for i in range( len( firstPointers ) ):
firstPointer = firstPointers[i]
secondPointer = '_'.join( secondPointers[i].split( '_' )[:-1] ) + '_%d' %( (i + offset)%firstSpans )
crv = sgRigCurve.createCurveOnTargetPoints( [firstPointer, secondPointer] )
crv = cmds.rename( crv, meshName+'_line_%d' % i )
crvs.append( crv )
cmds.select( crvs )
loftSurf = cmds.loft( n=meshName+'_loft' )[0]
resultObject = cmds.nurbsToPoly( loftSurf ,mnd=1 ,ch=1,f=3,pt=0,pc=200,chr=0.9,ft=0.01,mel=0.001, d=0.1,
ut=1, un=3, vt=1, vn=3, uch=0, ucr=0, cht=0.2, es=0,ntr=0,mrt=0, uss=1, n=meshName+'_conveyorBelt' )
crvGrp = cmds.group( crvs, n=meshName+'_lines' )
conveyorRig = cmds.group( firstCurve, secondCurve, crvGrp, loftSurf, resultObject, meshName, n=meshName+'_conveyorRig' )
import sgRigAttribute
sgRigAttribute.addAttr( conveyorRig, ln='offset', k=1 )
cmds.connectAttr( conveyorRig+'.offset', firstCurve+'.roofValue' )
cmds.connectAttr( conveyorRig+'.offset', secondCurve+'.roofValue' )
cmds.setAttr( conveyorRig+'.v', 0 )
def createConveyerBeltSet(meshName, firstEdgeIndex, secondEdgeIndex):
firstEdges = cmds.polySelectSp(meshName + '.e[%d]' % firstEdgeIndex,
loop=1)
secondEdges = cmds.polySelectSp(meshName + '.e[%d]' % secondEdgeIndex,
loop=1)
cmds.select(firstEdges)
firstCurve = cmds.polyToCurve(form=2,
degree=3,
n=meshName + '_loopCurve_First')[0]
cmds.select(secondEdges)
secondCurve = cmds.polyToCurve(form=2,
degree=3,
n=meshName + '_loopCurve_Second')[0]
firstCurveShape = sgModelDag.getShape(firstCurve)
secondCurveShape = sgModelDag.getShape(secondCurve)
firstSpans = cmds.getAttr(firstCurveShape + '.spans')
secondSpans = cmds.getAttr(secondCurveShape + '.spans')
firstTangent = sgModelCurve.getTangentAtParam(firstCurveShape, 0.0)
firstParamPoint = sgModelCurve.getPointAtParam(firstCurveShape, 0.0)
secondParam = sgModelCurve.getParamAtPoint(secondCurveShape,
firstParamPoint)
secondTangent = sgModelCurve.getTangentAtParam(secondCurveShape,
secondParam)
if firstTangent * secondTangent < 0:
cmds.reverseCurve(secondCurve, ch=1, rpo=1)
firstPointers = sgRigCurve.createRoofPointers(firstCurve, firstSpans)
secondPointers = sgRigCurve.createRoofPointers(secondCurve, secondSpans)
fPos = cmds.xform(firstPointers[0], q=1, ws=1, t=1)
minDistPointer = secondPointers[0]
minDist = 1000000000.0
for secondPointer in secondPointers:
sPos = cmds.xform(secondPointer, q=1, ws=1, t=1)
dist = (fPos[0] - sPos[0])**2 + (fPos[1] - sPos[1])**2 + (fPos[2] -
sPos[2])**2
if dist < minDist:
minDistPointer = secondPointer
minDist = dist
offset = int(minDistPointer.split('_')[-1])
crvs = []
for i in range(len(firstPointers)):
firstPointer = firstPointers[i]
secondPointer = '_'.join(secondPointers[i].split('_')[:-1]) + '_%d' % (
(i + offset) % firstSpans)
crv = sgRigCurve.createCurveOnTargetPoints(
[firstPointer, secondPointer])
crv = cmds.rename(crv, meshName + '_line_%d' % i)
crvs.append(crv)
cmds.select(crvs)
loftSurf = cmds.loft(n=meshName + '_loft')[0]
resultObject = cmds.nurbsToPoly(loftSurf,
mnd=1,
ch=1,
f=3,
pt=0,
pc=200,
chr=0.9,
ft=0.01,
mel=0.001,
d=0.1,
ut=1,
un=3,
vt=1,
vn=3,
uch=0,
ucr=0,
cht=0.2,
es=0,
ntr=0,
mrt=0,
uss=1,
n=meshName + '_conveyorBelt')
crvGrp = cmds.group(crvs, n=meshName + '_lines')
conveyorRig = cmds.group(firstCurve,
secondCurve,
crvGrp,
loftSurf,
resultObject,
meshName,
n=meshName + '_conveyorRig')
import sgRigAttribute
sgRigAttribute.addAttr(conveyorRig, ln='offset', k=1)
cmds.connectAttr(conveyorRig + '.offset', firstCurve + '.roofValue')
cmds.connectAttr(conveyorRig + '.offset', secondCurve + '.roofValue')
cmds.setAttr(conveyorRig + '.v', 0)
def getFnMesh(mesh):
mesh = sgModelDag.getShape(mesh)
return om.MFnMesh(sgModelDag.getDagPath(mesh))
def getFnMesh( mesh ):
mesh = sgModelDag.getShape( mesh )
return om.MFnMesh( sgModelDag.getDagPath( mesh ) )
def exportBakeData( targets, startFrame, endFrame, cachePath = '' ):
transformBakePath = cachePath + '/transformBake.cPickle'
targets = sgModelConvert.convertFullPathNames( targets )
trObjs = cmds.listRelatives( targets, c=1, ad=1, type='transform', f=1 )
if not trObjs: trObjs = []
trObjs += targets
trParents = []
for trObj in trObjs:
parents = sgModelDag.getParents( trObj )
trParents += parents
trs = list( set( trObjs + trParents ) )
trs.sort()
namespaces = []
filePaths = []
cacheBodyPaths = []
namespaceIndices = []
for tr in trs:
if not cmds.reference( tr, q=1, inr=1 ):
namespaceIndices.append( None )
continue
namespace = cmds.referenceQuery( tr, ns=1 )
filePath = cmds.reference( tr, q=1, filename =1 ).split( '{' )[0]
cacheBodyPath = '.'.join( filePath.split( '.' )[:-1] ) + '_cachebody.' + filePath.split( '.' )[-1]
if not os.path.exists( cacheBodyPath ):
cacheBodyPath = ''
if not namespace in namespaces:
print "appended namespace :", namespace
namespaces.append( namespace )
filePaths.append( filePath )
cacheBodyPaths.append( cacheBodyPath )
namespaceIndex = namespaces.index( namespace )
namespaceIndices.append( namespaceIndex )
parentList = []
objectList = []
shapes = []
for i in range( len( trs ) ):
tr = trs[i]
trParent = cmds.listRelatives( tr, p=1, f=1 )
trMtx = cmds.getAttr( tr+'.m' )
trPiv = cmds.xform( tr, q=1, os=1, piv=1 )[:3]
listAttrs = cmds.listAttr( tr, k=1 )
attrInfoList = []
for attr in listAttrs:
if not cmds.attributeQuery( attr, node=tr, ex=1 ): continue
if cmds.listConnections( tr+'.'+ attr, s=1, d=0 ):
animCurves = cmds.listConnections( tr+'.'+ attr, s=1, d=0, type='animCurve' )
if animCurves:
attrInfoList.append( [attr, sgModelDg.AnimCurveData( animCurves[0] )] )
else:
attrInfoList.append( [attr, []] )
else:
parentAttrs = cmds.attributeQuery( attr, node=tr, listParent = 1 )
if parentAttrs:
if cmds.listConnections( tr+'.'+parentAttrs[0], s=1, d=0 ):
attrInfoList.append( [attr, []] )
if trParent: trParent = trParent[0]
if trParent in parentList:
parentIndex= parentList.index( trParent )
else:
parentIndex = -1
objectList.append( [ namespaceIndices[i], parentIndex, tr, trMtx, trPiv, attrInfoList ] )
parentList.append( tr )
shape = sgModelDag.getShape( tr )
if shape: shapes.append( shape )
timeUnit = cmds.currentUnit( q=1, time=1 )
dataForExport = [ namespaces, filePaths, cacheBodyPaths, objectList, timeUnit ]
deformedShapes = sgModelDag.getDeformedObjects( shapes )
if deformedShapes:
def setKeyframeBakeTargets( *args ):
cuTime = cmds.currentTime( q=1 )
for i in range( len(objectList) ):
for j in range( len( objectList[i][5] ) ):
attr = objectList[i][5][j][0]
info = objectList[i][5][j][1]
if type( info ) != type( [] ): continue
tr = objectList[i][2]
value = cmds.getAttr( tr+'.' + attr )
objectList[i][5][j][1].append( [ cuTime, value ] )
callbackId = om.MEventMessage().addEventCallback( 'timeChanged', setKeyframeBakeTargets )
cmds.select( deformedShapes )
sgFunctionFileAndPath.makeFolder( cachePath )
mel.eval( 'doCreateGeometryCache 6 { "3", "%s", "%s", "OneFile", "1", "%s","1","","0", "export", "0", "1", "1","0","0","mcc","0" };' %( startFrame, endFrame, cachePath ) )
om.MMessage().removeCallback( callbackId )
transformBakePath = sgFunctionFileAndPath.makeFile( transformBakePath, False )
f = open( transformBakePath, 'w' )
cPickle.dump( dataForExport, f )
f.close()
return transformBakePath
def importBakeData( cachePath ):
transformBakePath = cachePath+'/transformBake.cPickle'
f = open( transformBakePath, 'r' )
importedData = cPickle.load( f )
namespaces, filePaths, cacheBodyPaths, objectList, timeUnit = importedData
cmds.currentUnit( time=timeUnit )
for k in range( len( namespaces ) ):
cacheBodyPath = cacheBodyPaths[k]
#print "cachebody path : ", cacheBodyPath
if not os.path.exists( cacheBodyPath ): continue
cmds.file( cacheBodyPath, i=True, type="mayaBinary", mergeNamespacesOnClash=False, ra=True, namespace = 'cachebody%d' % k,
options= "v=0;", pr=1, loadReferenceDepth="all" )
for i in range( len( objectList ) ):
namespaceIndex, parentIndex, tr, trMtx, trPiv, attrInfoList = objectList[i]
if namespaceIndex != None:
origName = tr.split( '|' )[-1].replace( namespaces[ namespaceIndex ][1:]+':', '' )
targetCacheBody = 'cachebody%d:%s' %( namespaceIndex , origName )
else:
origName = tr.split( '|' )[-1]
targetCacheBody = origName
if not cmds.objExists( targetCacheBody ):
targetCacheBody = cmds.createNode( 'transform', n=targetCacheBody )
if parentIndex != -1:
try:targetCacheBody = cmds.parent( targetCacheBody, objectList[ parentIndex ][2] )[0]
except:pass
try:
cmds.xform( targetCacheBody, os=1, matrix=trMtx )
cmds.xform( targetCacheBody, os=1, piv=trPiv )
objectList[i][2] = cmds.ls( targetCacheBody, l=1 )[0]
except: continue
for attrInfo in attrInfoList:
attr, animCurveInfos = attrInfo
if type( animCurveInfos ) == type( [] ):
animCurve = cmds.createNode( 'animCurveTU', n=origName+'_'+attr )
fnAnimCurve = omAnim.MFnAnimCurve( sgModelDg.getMObject( animCurve ) )
time = om.MTime()
for animCurveInfo in animCurveInfos:
timeValue, value = animCurveInfo
time.setValue( timeValue )
fnAnimCurve.addKey( time, value )
#print animCurve, targetCacheBody, attr
try:cmds.connectAttr( animCurve+'.output', targetCacheBody+'.'+attr, f=1 )
except:pass
else:
try:
animCurve = animCurveInfo.createAnimCurve()
cmds.connectAttr( animCurve+'.output', targetCacheBody + '.' + attr, f=1 )
except:pass
targetMesh = sgModelDag.getShape( targetCacheBody )
if not targetMesh: continue
if namespaceIndex == None: continue
xmlFileName = namespaces[ namespaceIndex ][1:] + '_' + origName.replace( ':', '_' )+'Shape.xml'
xmlFilePath = cachePath + '/' + xmlFileName
if os.path.exists( xmlFilePath ):
print 'xml file path : ', xmlFilePath
importCache( targetMesh, xmlFilePath )
def createRoofPointers(surface, numPointer, aimDirection='v', roofLength=10):
surface = sgModelDag.getTransform(surface)
surfaceShape = sgModelDag.getShape(surface)
dStr = aimDirection.upper()
if dStr == 'V':
upStr = 'U'
else:
upStr = 'V'
sgRigAttribute.addAttr(surface, ln='roofValue', k=1)
minValue, maxValue = cmds.getAttr(surfaceShape + '.minMaxRange%s' %
(dStr))[0]
eachInputOffset = float(roofLength) / (numPointer - 1)
for i in range(numPointer):
surfaceInfo = cmds.createNode('pointOnSurfaceInfo')
pointer = cmds.createNode('transform', n=surface + '_pointer%d' % i)
cmds.setAttr(pointer + '.dh', 1)
cmds.setAttr(pointer + '.dla', 1)
cmds.connectAttr(surfaceShape + '.local',
surfaceInfo + '.inputSurface')
addNode = cmds.createNode('addDoubleLinear')
cmds.setAttr(addNode + '.input2', eachInputOffset * i)
animCurve = sgModelDg.getRoofLinearCurve(0, float(roofLength),
minValue, maxValue)
cmds.connectAttr(surface + '.roofValue', addNode + '.input1')
cmds.connectAttr(addNode + '.output', animCurve + '.input')
cmds.connectAttr(animCurve + '.output',
surfaceInfo + '.parameter%s' % (dStr))
fbfMtx = cmds.createNode('fourByFourMatrix')
vProduct = cmds.createNode('vectorProduct')
mmdc = cmds.createNode('multMatrixDecompose')
cmds.setAttr(vProduct + '.op', 2)
cmds.connectAttr(surfaceInfo + '.tangent%sx' % (dStr), fbfMtx + '.i00')
cmds.connectAttr(surfaceInfo + '.tangent%sy' % (dStr), fbfMtx + '.i01')
cmds.connectAttr(surfaceInfo + '.tangent%sz' % (dStr), fbfMtx + '.i02')
cmds.connectAttr(surfaceInfo + '.tangent%sx' % (upStr),
fbfMtx + '.i10')
cmds.connectAttr(surfaceInfo + '.tangent%sy' % (upStr),
fbfMtx + '.i11')
cmds.connectAttr(surfaceInfo + '.tangent%sz' % (upStr),
fbfMtx + '.i12')
cmds.connectAttr(surfaceInfo + '.positionX', fbfMtx + '.i30')
cmds.connectAttr(surfaceInfo + '.positionY', fbfMtx + '.i31')
cmds.connectAttr(surfaceInfo + '.positionZ', fbfMtx + '.i32')
cmds.connectAttr(surfaceInfo + '.tangent%s' % (dStr),
vProduct + '.input1')
cmds.connectAttr(surfaceInfo + '.tangent%s' % (upStr),
vProduct + '.input2')
cmds.connectAttr(vProduct + '.outputX', fbfMtx + '.i20')
cmds.connectAttr(vProduct + '.outputY', fbfMtx + '.i21')
cmds.connectAttr(vProduct + '.outputZ', fbfMtx + '.i22')
cmds.connectAttr(fbfMtx + '.output', mmdc + '.i[0]')
cmds.connectAttr(pointer + '.pim', mmdc + '.i[1]')
cmds.connectAttr(mmdc + '.ot', pointer + '.t')
cmds.connectAttr(mmdc + '.or', pointer + '.r')
cmds.parent(pointer, surface)
def createRoofPointers( surface, numPointer, aimDirection = 'v', roofLength = 10 ):
surface = sgModelDag.getTransform( surface )
surfaceShape = sgModelDag.getShape( surface )
dStr = aimDirection.upper()
if dStr == 'V':
upStr = 'U'
else:
upStr = 'V'
sgRigAttribute.addAttr( surface, ln='roofValue', k=1 )
minValue, maxValue = cmds.getAttr( surfaceShape+'.minMaxRange%s' % ( dStr ) )[0]
eachInputOffset = float( roofLength ) / ( numPointer-1 )
for i in range( numPointer ):
surfaceInfo = cmds.createNode( 'pointOnSurfaceInfo' )
pointer = cmds.createNode( 'transform', n= surface+'_pointer%d' % i )
cmds.setAttr( pointer+'.dh', 1 )
cmds.setAttr( pointer+'.dla', 1 )
cmds.connectAttr( surfaceShape+'.local', surfaceInfo+'.inputSurface' )
addNode = cmds.createNode( 'addDoubleLinear' )
cmds.setAttr( addNode+'.input2', eachInputOffset * i )
animCurve = sgModelDg.getRoofLinearCurve( 0, float( roofLength ), minValue, maxValue )
cmds.connectAttr( surface+'.roofValue', addNode+'.input1' )
cmds.connectAttr( addNode+'.output', animCurve+'.input' )
cmds.connectAttr( animCurve+'.output', surfaceInfo+'.parameter%s' %( dStr ) )
fbfMtx = cmds.createNode( 'fourByFourMatrix' )
vProduct = cmds.createNode( 'vectorProduct' )
mmdc = cmds.createNode( 'multMatrixDecompose' )
cmds.setAttr( vProduct+'.op', 2 )
cmds.connectAttr( surfaceInfo + '.tangent%sx' % ( dStr ), fbfMtx+'.i00' )
cmds.connectAttr( surfaceInfo + '.tangent%sy' % ( dStr ), fbfMtx+'.i01' )
cmds.connectAttr( surfaceInfo + '.tangent%sz' % ( dStr ), fbfMtx+'.i02' )
cmds.connectAttr( surfaceInfo + '.tangent%sx' % ( upStr ), fbfMtx+'.i10' )
cmds.connectAttr( surfaceInfo + '.tangent%sy' % ( upStr ), fbfMtx+'.i11' )
cmds.connectAttr( surfaceInfo + '.tangent%sz' % ( upStr ), fbfMtx+'.i12' )
cmds.connectAttr( surfaceInfo + '.positionX', fbfMtx+'.i30' )
cmds.connectAttr( surfaceInfo + '.positionY', fbfMtx+'.i31' )
cmds.connectAttr( surfaceInfo + '.positionZ', fbfMtx+'.i32' )
cmds.connectAttr( surfaceInfo+'.tangent%s' % ( dStr ), vProduct+'.input1' )
cmds.connectAttr( surfaceInfo+'.tangent%s' % ( upStr ), vProduct+'.input2' )
cmds.connectAttr( vProduct+'.outputX', fbfMtx+'.i20' )
cmds.connectAttr( vProduct+'.outputY', fbfMtx+'.i21' )
cmds.connectAttr( vProduct+'.outputZ', fbfMtx+'.i22' )
cmds.connectAttr( fbfMtx+'.output', mmdc+'.i[0]' )
cmds.connectAttr( pointer+'.pim', mmdc+'.i[1]' )
cmds.connectAttr( mmdc+'.ot', pointer+'.t' )
cmds.connectAttr( mmdc+'.or', pointer+'.r' )
cmds.parent( pointer, surface )
