def duplicateOnlyCurve( curves ):
import sgBFunction_dag
curves = sgBFunction_dag.getChildrenCurveExists( curves )
newCurves = []
for curve in curves:
curveP = sgBFunction_dag.getParent( curve )
if curveP:
newCurveParent = sgBFunction_dag.makeCloneObject( curveP )
else:
newCurveParent = None
newCurveShape = cmds.createNode( 'nurbsCurve' )
curveShape = sgBFunction_dag.getShape( curve )
cmds.connectAttr( curveShape+'.local', newCurveShape+'.create' )
newCurve = sgBFunction_dag.getTransform( newCurveShape )
newCurve = cmds.rename( newCurve, 'du_' + curve.split( '|' )[-1] )
if newCurveParent:
newCurve = cmds.parent( newCurve, newCurveParent )[0]
newCurves.append( newCurve )
cmds.refresh()
for i in range( len( newCurves ) ):
curveShape = sgBFunction_dag.getShape( curves[i] )
newCurveShape = sgBFunction_dag.getShape( newCurves[i] )
if cmds.isConnected( curveShape+'.local', newCurveShape+'.create' ):
cmds.disconnectAttr( curveShape+'.local', newCurveShape+'.create' )
return newCurves
def displayModCombine( sels ):
import sgBFunction_dag
targetMeshObjs = []
sels = cmds.listRelatives( sels, s=1, f=1 )
for sel in sels:
if cmds.getAttr( sel+'.io' ): continue
selP = cmds.listRelatives( sel, p=1, f=1 )[0]
if selP.find( 'display_' ) == -1: continue
targetMeshObjs.append( selP )
targetMeshObjs = list( set( targetMeshObjs ) )
cmds.select( targetMeshObjs )
for targetMesh in targetMeshObjs:
displayMod = cmds.ls( targetMesh )[0]
realMod = displayMod.replace( 'display_', '' )
if not cmds.objExists( realMod ): continue
displayModShape = sgBFunction_dag.getShape( displayMod )
realModShape = sgBFunction_dag.getShape( realMod )
displayOrig = sgBFunction_dag.getOrigShape( displayModShape )
if not cmds.isConnected( realModShape+'.outMesh', displayOrig+'.inMesh' ):
cmds.connectAttr( realModShape+'.outMesh', displayOrig+'.inMesh', f=1 )
def getTubeIntersectionPointAndNormal( tubeMesh, baseMesh ):
import math
import sgBFunction_dag
hairMesh = tubeMesh
headMesh = baseMesh
headMeshShape = sgBFunction_dag.getShape( headMesh )
dagPathHead = sgBFunction_dag.getMDagPath( headMeshShape )
intersector = om.MMeshIntersector()
intersector.create( dagPathHead.node() )
hairMeshShape = sgBFunction_dag.getShape( hairMesh )
dagPathHairMesh = sgBFunction_dag.getMDagPath( hairMeshShape )
fnMesh = om.MFnMesh( dagPathHairMesh )
points = om.MPointArray()
fnMesh.getPoints( points )
pointOnMesh = om.MPointOnMesh()
minDist = 100000.0
minDistIndex = 0
minDistNormal = om.MVector()
for i in range( points.length() ):
intersector.getClosestPoint( points[i], pointOnMesh )
closePoint = om.MPoint( pointOnMesh.getPoint() )
dist = closePoint.distanceTo( points[i] )
if dist < minDist:
normal = om.MVector()
itNormal = om.MVector( pointOnMesh.getNormal() )
fnMesh.getVertexNormal( i, True, normal )
if math.fabs( itNormal.normal() * normal.normal() ) < 0.4:
minDist = dist
minDistIndex = i
minDistNormal = itNormal
pointMinDist = points[ minDistIndex ]
normalMinDist = om.MVector()
fnMesh.getVertexNormal( minDistIndex, True, normalMinDist )
srcPoint = om.MPoint( pointMinDist + normalMinDist )
ray = -normalMinDist
intersectPoints = om.MPointArray()
fnMesh.intersect( srcPoint, ray, intersectPoints )
if intersectPoints.length() == 1:
return intersectPoints[0], minDistNormal
else:
bb = om.MBoundingBox()
for k in range( intersectPoints.length() ):
bb.expand( intersectPoints[k] )
return bb.center(), minDistNormal
def duplicateShaderToOther( first, second ):
import maya.mel as mel
import sgBFunction_dag
if not cmds.objExists( first ): return None
if not cmds.objExists( second ): return None
first = sgBFunction_dag.getTransform( first )
second = sgBFunction_dag.getTransform( second )
firstShape = sgBFunction_dag.getShape( first )
secondShape = sgBFunction_dag.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 )
engine = cmds.duplicate( engine, n= 'du_'+engine )[0]
if shaders:
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]
cmds.connectAttr( shader+'.outColor', engine+'.surfaceShader' )
aiShaders = cmds.listConnections( engine+'.aiSurfaceShader', s=1, d=0 )
if aiShaders:
aiShader = aiShaders[0]
cmds.hyperShade( objects = aiShader )
selObjs = cmds.ls( sl=1, l=1 )
cmds.select( aiShader )
mel.eval( 'hyperShadePanelMenuCommand("hyperShadePanel1", "duplicateShadingNetwork")' )
aiShader = cmds.ls( sl=1 )[0]
cmds.connectAttr( aiShader+'.outColor', engine+'.aiSurfaceShader' )
for targetObj in targetObjs:
cmds.sets( targetObj, e=1, forceElement=engine )
def cmdCreatePattern( arg=0 ):
import sgBFunction_dag
import sgBFunction_attribute
PatternSize = cmds.floatField( WinA_Global.ff_patternSize, q=1, v=1 )
OffsetMult = cmds.floatField( WinA_Global.ff_offsetMult, q=1, v=1 )
sels = cmds.ls( sl=1 )
curve = sels[0]
surf = sels[1]
curveShape = sgBFunction_dag.getShape( curve )
surfShape = sgBFunction_dag.getShape( surf )
numSpansU = cmds.getAttr( surfShape + '.spansU' )
numSpansV = cmds.getAttr( surfShape + '.spansV' )
rebuildSurf = cmds.createNode( 'rebuildSurface' )
cmds.setAttr( rebuildSurf + '.keepCorners', 0 )
cmds.setAttr( rebuildSurf + '.spansU', numSpansU )
cmds.setAttr( rebuildSurf + '.spansV', numSpansV )
trGeo = cmds.createNode( 'transformGeometry' )
node = cmds.createNode( 'sgPatternCurveOnSurface' )
sgBFunction_attribute.addAttr( curve, ln='patternSize', min=0.1, dv=PatternSize, k=1 )
sgBFunction_attribute.addAttr( curve, ln='offsetMult', min=0.25, dv=OffsetMult, k=1 )
cmds.connectAttr( curve + '.patternSize', node + '.patternSize' )
cmds.connectAttr( curve + '.offsetMult' , node + '.offsetMult' )
newSurface = cmds.createNode( 'nurbsSurface' )
cmds.setAttr( newSurface + '.io', 1 )
cmds.connectAttr( surfShape + '.local', rebuildSurf + '.inputSurface' )
cmds.connectAttr( rebuildSurf + '.outputSurface', trGeo + '.inputGeometry' )
cmds.connectAttr( surf + '.wm', trGeo + '.transform' )
cmds.connectAttr( trGeo + '.outputGeometry', newSurface+'.create' )
cmds.connectAttr( newSurface + '.local', node + '.surface' )
cmds.connectAttr( curveShape + '.local', node + '.curve' )
surfShape = cmds.listRelatives( curve, s=1, f=1 )[0]
nodes = cmds.listConnections( surfShape, s=0, d=1, type='sgPatternCurveOnSurface' )
outputNum = cmds.getAttr( nodes[0] + '.numOutput' )
for i in range( outputNum ):
cons = cmds.listConnections( nodes[0] +'.outputCurves[%d]' % i )
if not cons:
outputCurve = cmds.createNode( 'nurbsCurve' )
cmds.connectAttr( nodes[0] + '.outputCurves[%d]' % i, outputCurve + '.create' )
def copyFollicleAttribute( *args ):
sels = cmds.ls( sl=1 )
others = sels[:-1]
first = sels[-1]
import sgBModel_attribute
import sgBFunction_dag
import sgBFunction_attribute
first = sgBFunction_dag.getShape( first )
if cmds.nodeType( first ) == 'nurbsCurve':
first = sgBFunction_dag.getFollicleFromCurve( first )
for i in range( len( others ) ):
other = sgBFunction_dag.getShape( others[i] )
if cmds.nodeType( other ) == 'nurbsCurve':
other = sgBFunction_dag.getFollicleFromCurve( other )
others[i] = other
follicleRampAttrList = sgBModel_attribute.follicleRampAttrList
follicleNormalAttrList = sgBModel_attribute.follicleNormalAttrList
fnNode = om.MFnDependencyNode( sgBFunction_dag.getMObject( first ) )
rampAttrNames = []
rampValues = []
for rampAttr in follicleRampAttrList:
print "node name : ", fnNode.name()
plugAttr = fnNode.findPlug( rampAttr )
print rampAttr
for other in others:
sgBFunction_attribute.removeMultiInstances( other, rampAttr )
for j in range( plugAttr.numElements() ):
rampAttrNames.append( plugAttr[j].name().split( '.' )[-1] )
rampValues.append( cmds.getAttr( plugAttr[j].name() )[0] )
for other in others:
for i in range( len( rampAttrNames ) ):
cmds.setAttr( other+'.'+rampAttrNames[i], *rampValues[i] )
for normalAttr in follicleNormalAttrList:
attrValue = cmds.getAttr( first+'.'+normalAttr )
for other in others:
try:cmds.setAttr( other+'.'+normalAttr, attrValue )
except:pass
def createFollicleFromSurfacePoint( surfacePoint ):
import sgBFunction_dag
surfaceNode, noneArrangeStr = surfacePoint.split( '.uv[' )
uvStrs = noneArrangeStr.replace( ']', '' ).split( '[' )
uv = [ float( uvStrs[0] ), float( uvStrs[1] ) ]
surfaceNode = sgBFunction_dag.getShape( surfaceNode )
minMaxRangeU = cmds.getAttr( surfaceNode+'.minMaxRangeU' )[0]
minMaxRangeV = cmds.getAttr( surfaceNode+'.minMaxRangeV' )[0]
divRateU = minMaxRangeU[1] - minMaxRangeU[0]
divRateV = minMaxRangeV[1] - minMaxRangeV[0]
follicleNode = cmds.createNode( 'follicle' )
cmds.setAttr( follicleNode+'.parameterU', uv[0]/divRateU )
cmds.setAttr( follicleNode+'.parameterV', uv[1]/divRateV )
cmds.connectAttr( surfaceNode+'.local', follicleNode+'.inputSurface' )
cmds.connectAttr( surfaceNode+'.wm', follicleNode+'.inputWorldMatrix' )
follicleObj = sgBFunction_dag.getTransform( follicleNode )
cmds.setAttr( follicleObj+'.inheritsTransform', 0 )
cmds.connectAttr( follicleNode+'.outTranslate', follicleObj+'.t' )
cmds.connectAttr( follicleNode+'.outRotate', follicleObj+'.r' )
return follicleObj
def createFollicleOnVertices( vertices ):
import sgBFunction_dag
import sgBFunction_mesh
vertices = cmds.ls( vertices, fl=1 )
for vertex in vertices:
vtxPos = cmds.xform( vertex, q=1, ws=1, t=1 )
mesh = vertex.split( '.' )[0]
meshShape = sgBFunction_dag.getShape( mesh )
u, v = sgBFunction_mesh.getUVAtPoint( vtxPos, mesh )
follicleNode = cmds.createNode( 'follicle' )
follicle = cmds.listRelatives( follicleNode, p=1, f=1 )[0]
cmds.connectAttr( meshShape+'.outMesh', follicleNode+'.inputMesh' )
cmds.connectAttr( meshShape+'.wm', follicleNode+'.inputWorldMatrix' )
cmds.setAttr( follicleNode+'.parameterU', u )
cmds.setAttr( follicleNode+'.parameterV', v )
cmds.connectAttr( follicleNode+'.outTranslate', follicle+'.t' )
cmds.connectAttr( follicleNode+'.outRotate', follicle+'.r' )
def createRivetOnSurfacePoint( surfacePoint, firstDirection='u' ):
import sgBFunction_dag
import sgBFunction_attribute
if firstDirection.lower() == 'u':
fString = 'U'
sString = 'V'
else:
fString = 'V'
sString = 'U'
surfaceName, uv = surfacePoint.split( '.uv' )
surfaceName = sgBFunction_dag.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 surfaceColorAtPoint( surfaceNode, position ):
import sgBFunction_dag
def getCloseNode( surfaceNode ):
closeNode = cmds.listConnections( surfaceNode+'.worldSpace', type='closestPointOnSurface' )
if closeNode: return closeNode[0]
closeNode = cmds.createNode( 'closestPointOnSurface' )
cmds.connectAttr( surfaceNode+'.worldSpace', closeNode+'.inputSurface' )
return closeNode
surfaceNode = sgBFunction_dag.getShape( surfaceNode )
closeNode = getCloseNode( surfaceNode )
cmds.setAttr( closeNode+'.inPosition', *position )
shadingEngines = sgBFunction_dag.getShadingEngines( surfaceNode )
if not shadingEngines: return None
shader = cmds.listConnections( shadingEngines[0]+'.surfaceShader', s=1, d=0 )
texture = cmds.listConnections( shader[0]+'.color', s=1, d=0 )
if not texture: return None
uValue = cmds.getAttr( closeNode+'.parameterU' )
vValue = cmds.getAttr( closeNode+'.parameterV' )
return cmds.colorAtPoint( texture[0], u=uValue, v=vValue )
def displayModConnect( displayMods ):
import sgBFunction_dag
import sgBFunction_convert
import sgBFunction_connection
displayMods = sgBFunction_convert.singleToList( displayMods )
for displayMod in displayMods:
origMod = displayMod.replace( 'display_', '' )
sgBFunction_connection.constraintAll( origMod, displayMod )
displayModShape = sgBFunction_dag.getShape( displayMod )
origModShape = sgBFunction_dag.getShape( origMod )
cmds.connectAttr( origModShape+'.outMesh', displayModShape+'.inMesh' )
def createControllerOnTarget( target, pivotCtlOn=True ):
import sgBFunction_connection
import sgBFunction_dag
import sgBModel_data
targetPos = cmds.getAttr( target+'.wm' )
targetP = cmds.listRelatives( target, p=1, f=1 )[0]
targetName = target.split( '|' )[-1]
ctl = cmds.circle( n='CTL_' + targetName )[0]
ctlChild = cmds.createNode( 'transform', n='CTLChild_'+targetName );ctlChild = cmds.parent( ctlChild, ctl )[0]
pivCtl = cmds.createNode( 'transform', n='PivCTL_'+targetName ); cmds.setAttr( pivCtl+'.dh', 1 )
cmds.setAttr( pivCtl+'.overrideEnabled', 1 )
cmds.setAttr( pivCtl+'.overrideColor', 18 )
ctlP = cmds.group( ctl, n='P'+ctl )
ctlPPiv = cmds.group( ctlP, pivCtl, n='Piv' + ctlP )
cmds.xform( ctlPPiv, ws=1, matrix=targetPos )
cloneObject = sgBFunction_dag.getConstrainedObject( targetP )
ctlPPiv = cmds.parent( ctlPPiv, cloneObject )[0]
cmds.xform( pivCtl, os=1, matrix= sgBModel_data.getDefaultMatrix() )
ctl = cmds.listRelatives( ctlP, c=1, f=1 )[0]
sgBFunction_connection.getSourceConnection( target, ctlPPiv )
for attr in [ 't', 'tx', 'ty', 'tz', 'r', 'rx', 'ry', 'rz', 's', 'sx', 'sy', 'sz', 'sh' ]:
cons = cmds.listConnections( target+'.'+attr, s=1, d=0, p=1, c=1 )
if not cons: continue
for i in range( 0, len( cons ), 2 ):
cmds.disconnectAttr( cons[i+1], cons[i] )
sgBFunction_connection.constraintAll( ctlChild, target )
cmds.connectAttr( pivCtl+'.t', ctlP+'.t' )
cmds.connectAttr( pivCtl+'.r', ctlP+'.r' )
cmds.connectAttr( pivCtl+'.s', ctlP+'.s' )
cmds.connectAttr( pivCtl+'.sh', ctlP+'.sh' )
mmdcCtlChild = cmds.createNode( 'multMatrixDecompose' )
cmds.connectAttr( ctlPPiv+'.wm', mmdcCtlChild+'.i[0]' )
cmds.connectAttr( pivCtl+'.wim', mmdcCtlChild+'.i[1]' )
cmds.connectAttr( mmdcCtlChild+'.ot', ctlChild+'.t' )
cmds.connectAttr( mmdcCtlChild+'.or', ctlChild+'.r' )
cmds.connectAttr( mmdcCtlChild+'.os', ctlChild+'.s' )
cmds.connectAttr( mmdcCtlChild+'.osh', ctlChild+'.sh' )
ctlShape = sgBFunction_dag.getShape( ctl )
circleNode = cmds.listConnections( ctlShape+'.create', s=1, d=0 )[0]
mm = cmds.createNode( 'multMatrix' )
trGeo = cmds.createNode( 'transformGeometry' )
cmds.connectAttr( ctlPPiv+'.wm', mm+'.i[0]' )
cmds.connectAttr( pivCtl+'.wim', mm+'.i[1]' )
cmds.connectAttr( circleNode+'.outputCurve', trGeo+'.inputGeometry' )
cmds.connectAttr( mm+'.matrixSum', trGeo+'.transform' )
cmds.connectAttr( trGeo+'.outputGeometry', ctlShape+'.create', f=1 )
return ctl
def getCurveLength(target ):
import sgBFunction_dag
targetShape = sgBFunction_dag.getShape( target )
fnCurve = om.MFnNurbsCurve( sgBFunction_dag.getMDagPath( targetShape ) )
return fnCurve.length()
def export( *args ):
import sgBFunction_fileAndPath
import sgBFunction_dag
exportPath = cmds.textField( WinA_Global.txf_export, q=1, tx=1 )
minFrame = cmds.intField( WinA_Global.fld_startFrame, q=1, v=1 )
maxFrame = cmds.intField( WinA_Global.fld_endFrame, q=1, v=1 )
exportPath = exportPath.replace( '\\', '/' )
folderPath = '/'.join( exportPath.split( '/' )[-1:] )
sgBFunction_fileAndPath.makeFolder( folderPath )
sels = cmds.ls( sl=1 )
cams = []
for sel in sels:
selShape = sgBFunction_dag.getShape( sel )
if cmds.nodeType( selShape ) == 'camera':
cams.append( sel )
import sgBFunction_scene
sgBFunction_scene.doBake( exportPath, minFrame, maxFrame )
WinA_Cmd.write_windowInfo()
def getMeshAndIndices( vertices ):
meshName = sgBFunction_dag.getShape( vertices[0].split( '.' )[0] )
indices = []
for vtx in vertices:
vtxName = vtx.split( '.' )[1]
index = int( vtxName.split( '[' )[-1].replace( ']', '' ) )
indices.append( index )
return meshName, indices
def __init__(self, centerCurves, mesh ):
import sgBFunction_dag
self.centerCurves = centerCurves
meshShape = sgBFunction_dag.getShape( mesh )
dagPath = sgBFunction_dag.getMDagPath( meshShape )
self.fnMesh = om.MFnMesh( dagPath )
self.mtxMesh = dagPath.inclusiveMatrix()
def copyShapeAttr( source, target, ud=False ):
import sgBFunction_dag
sourceShape = sgBFunction_dag.getShape( source )
targetShape = sgBFunction_dag.getShape( target )
udAttrs = cmds.listAttr( sourceShape, ud=1 )
fpAttrs = cmds.listAttr( sourceShape, fp=1 )
attrs = []
if udAttrs:
attrs += udAttrs
if fpAttrs:
attrs += fpAttrs
for attr in attrs:
if attr.find( '.' ) != -1: continue
if not cmds.attributeQuery( attr, node = sourceShape, writable=1 ): continue
copyAttribute( sourceShape+'.'+attr, targetShape )
def setKeyCurve( keyCurve, targetCurve, objBaseMatrix = None ):
import sgBFunction_dag
import sgBFunction_base
sgBFunction_base.autoLoadPlugin( 'sgHair' )
nodes = sgBFunction_dag.getNodeFromHistory( targetCurve, 'sgHair_keyCurve' )
if not nodes:
node = cmds.deformer( targetCurve, type= 'sgHair_keyCurve' )[0]
cmds.connectAttr( 'time1.outTime', node+'.time' )
if objBaseMatrix:
mm = cmds.createNode( 'multMatrix' )
cmds.connectAttr( objBaseMatrix+'.wm', mm+'.i[0]' )
cmds.connectAttr( targetCurve+'.wim', mm+'.i[1]' )
cmds.connectAttr( mm+'.o', node+'.baseLocalMatrix' )
else:
node = nodes[0]
fnNode = om.MFnDependencyNode( sgBFunction_dag.getMObject( node ) )
cuTime = cmds.currentTime( q=1 )
plugKeys = fnNode.findPlug( 'keys' )
targetIndex = 0
for i in range( plugKeys.numElements() ):
plugKey = plugKeys[i]
plugFrame = plugKey.child( 0 )
timeValue = plugFrame.asMTime().value()
if cuTime == timeValue:
targetIndex = plugKey.logicalIndex()
break
if plugKey.logicalIndex() >= targetIndex:
targetIndex = plugKey.logicalIndex() + 1
if objBaseMatrix:
import sgBFunction_convert
mtxObj = cmds.getAttr( objBaseMatrix+'.wm' )
mtxInvCurve = cmds.getAttr( keyCurve+'.wim' )
mMtxObj = sgBFunction_convert.convertMatrixToMMatrix( mtxObj )
mMtxInvCurve = sgBFunction_convert.convertMatrixToMMatrix( mtxInvCurve )
mMtxLocal = mMtxObj * mMtxInvCurve
mtxLocal = sgBFunction_convert.convertMMatrixToMatrix( mMtxLocal )
cmds.setAttr( node+'.keys[%d].baseMatrix' % targetIndex, mtxLocal, type='matrix' )
cmds.setAttr( node+'.keys[%d].keyframe' % targetIndex, cuTime )
keyCurveShape = sgBFunction_dag.getShape( keyCurve )
if not cmds.isConnected( keyCurveShape+'.local', node+'.keys[%d].inputCurve' % targetIndex ):
cmds.connectAttr( keyCurveShape+'.local', node+'.keys[%d].inputCurve' % targetIndex, f=1 )
'''
def getMatricesFromCurve( curve, aimIndex = 0, vUpVector=None ):
import sgBFunction_dag
curveShape = sgBFunction_dag.getShape( curve )
curvePath = sgBFunction_dag.getMDagPath( curveShape )
mtxCurve = curvePath.inclusiveMatrix()
fnCurve = om.MFnNurbsCurve( curvePath )
minParam = fnCurve.findParamFromLength( 0 )
maxParam = fnCurve.findParamFromLength( fnCurve.length() )
numSpans = fnCurve.numSpans()
lengthParam = maxParam - minParam
eachParam = lengthParam / ( numSpans - 1 )
if not vUpVector:
vUp = om.MVector( 0, 1, 0 )
else:
vUp = vUpVector
mtxArr = []
for i in range( numSpans ):
point = om.MPoint()
fnCurve.getPointAtParam( eachParam * i, point )
vTangent = fnCurve.tangent( eachParam * i ) * mtxCurve
vCross = vTangent ^ vUp
vUp = vCross ^ vTangent
vTangent.normalize()
vUp.normalize()
vCross.normalize()
mtx = [ float(i%5 == 0) for i in range( 16 ) ]
indexAim = (3+aimIndex)%3
indexUp = (3+aimIndex+1)%3
indexCross = (3+aimIndex+2)%3
mtx[ indexAim*4+0 ] = vTangent.x
mtx[ indexAim*4+1 ] = vTangent.y
mtx[ indexAim*4+2 ] = vTangent.z
mtx[ indexUp*4+0 ] = vUp.x
mtx[ indexUp*4+1 ] = vUp.y
mtx[ indexUp*4+2 ] = vUp.z
mtx[ indexCross*4+0 ] = vCross.x
mtx[ indexCross*4+1 ] = vCross.y
mtx[ indexCross*4+2 ] = vCross.z
mtx[ 3*4+0 ] = point.x
mtx[ 3*4+1 ] = point.y
mtx[ 3*4+2 ] = point.z
mtxArr.append( mtx )
return mtxArr
def makeDisplayMod_deformed( baseModel ):
import sgBFunction_dag
targetShape = cmds.createNode( 'mesh' )
baseShape = sgBFunction_dag.getShape( baseModel )
cmds.connectAttr( baseShape+'.outMesh', targetShape+'.inMesh' )
target = cmds.listRelatives( targetShape, p=1, f=1 )[0]
cmds.select( target )
cmds.sets( e=1, forceElement='initialShadingGroup' )
cmds.xform( target, ws=1, matrix= cmds.getAttr( baseModel+'.wm' ) )
return cmds.rename( target, 'display_' + baseModel.split( '|' )[-1] )
def getKnots( target ):
import sgBFunction_dag
target = sgBFunction_dag.getShape( target )
fnCurve = om.MFnNurbsCurve( sgBFunction_dag.getMObject( target ) )
dArr = om.MDoubleArray()
fnCurve.getKnots( dArr )
return dArr
def setRandomColor( targets, each=True ):
import sgBModel_data
import sgBFunction_dag
if each:
for target in targets:
shape = sgBFunction_dag.getShape( target )
cmds.setAttr( shape+'.overrideEnabled', True )
cmds.setAttr( shape+'.overrideColor', sgBModel_data.setAniColorNum )
sgBModel_data.setAniColorNum = ( sgBModel_data.setAniColorNum + 1 ) % 32
if sgBModel_data.setAniColorNum in [ 16, 19, 20, 1 ]:
sgBModel_data.setAniColorNum +=1
else:
for target in targets:
shape = sgBFunction_dag.getShape( target )
cmds.setAttr( shape+'.overrideEnabled', True )
cmds.setAttr( shape+'.overrideColor', sgBModel_data.setAniColorNum )
def makeSparateShader( targetObject ):
import random
import maya.OpenMaya as om
import sgBFunction_dag
import sgBFunction_base
import copy
sgBFunction_base.autoLoadPlugin( 'sgMesh' )
cmds.sgGetMeshElementInfo( targetObject, set=1 )
targetShape = sgBFunction_dag.getShape( targetObject )
dagPathShape = sgBFunction_dag.getMDagPath( targetShape )
numElement = cmds.sgGetMeshElementInfo( ne=1 )
numFaces = cmds.sgGetMeshElementInfo( np=1 )
faceIndices = cmds.sgGetMeshElementInfo( fi=1 )
for i in range( numElement ):
startFaceIndex = 0
lastFaceIndex = 0
for j in range( i ):
startFaceIndex += int( numFaces[j] )
for j in range( i+1 ):
lastFaceIndex += int( numFaces[j] )
compArray = om.MIntArray()
compArray.setLength( int( numFaces[i] ) )
for j in range( startFaceIndex, lastFaceIndex ):
compArray.set( faceIndices[j], j-startFaceIndex )
blinnShader = cmds.shadingNode( 'blinn', asShader=1 )
blinnSet = cmds.sets( renderable=1, noSurfaceShader=1, empty=1, name='blinnSG' )
cmds.connectAttr( blinnShader+'.outColor', blinnSet+'.surfaceShader', f=1 )
colorR = random.uniform( 0, 1 )
colorG = random.uniform( 0, 1 )
colorB = random.uniform( 0, 1 )
cmds.setAttr( blinnShader+'.color', colorR, colorG, colorB, type='double3' )
singleComp = om.MFnSingleIndexedComponent()
singleCompObj = singleComp.create( om.MFn.kMeshPolygonComponent )
singleComp.addElements( compArray )
selList = om.MSelectionList()
selList.add( dagPathShape, singleCompObj )
om.MGlobal.selectCommand( selList )
cmds.sets( e=1, forceElement=blinnSet )
def separateMeshBySkinWeight2( meshObj ):
import sgBFunction_connection
skinClusters = sgBFunction_dag.getNodeFromHistory( meshObj, 'skinCluster' )
meshShape = sgBFunction_dag.getShape( meshObj )
if not skinClusters: return []
skinCluster = skinClusters[0]
fnMesh = om.MFnMesh( sgBFunction_dag.getMDagPath( meshShape ) )
jntsPerVertices = JointsPerVertices( skinCluster )
polygonsPerJointArray = [ PolygonsPerJoint2( meshShape ) for i in range( len( jntsPerVertices.existConnectJoints ) ) ]
vtxCountsPerPolygon = om.MIntArray()
vtxIndices = om.MIntArray()
fnMesh.getVertices( vtxCountsPerPolygon, vtxIndices )
for i in range( fnMesh.numVertices() ):
jointLogicalIndex = jntsPerVertices.getJointIndex( i )
physicalIndex = jntsPerVertices.jointLogicalIndexMap[ jointLogicalIndex ]
polygonsPerJointArray[ physicalIndex ].check( i )
meshs = []
for i in range( len( polygonsPerJointArray ) ):
targetJoint = om.MFnDagNode( jntsPerVertices.existConnectJoints[i] ).fullPathName()
mesh = polygonsPerJointArray[i].buildMesh2()
meshShape = sgBFunction_dag.getShape( mesh )
fnMesh = om.MFnMesh( sgBFunction_dag.getMDagPath( meshShape ) )
print fnMesh.numPolygons(), targetJoint
mesh = cmds.rename( mesh, targetJoint.split( '|' )[-1] + '_mesh' )
cmds.sets( mesh, e=1, forceElement='initialShadingGroup' )
meshs.append( mesh )
sgBFunction_connection.bindConnect( mesh, targetJoint )
return meshs
def getCurveInfo_localSpace( curve ):
import sgBFunction_dag
curveShape = sgBFunction_dag.getShape( curve )
cons = cmds.listConnections( curveShape+'.local', d=1, s=0 )
if not cons:
info = cmds.createNode( 'curveInfo' )
cmds.connectAttr( curveShape+'.local', info+'.inputCurve' )
return info
else:
return cons[0]
def getNodeFromMesh( mesh, isFirst=True ):
if cmds.objectType( mesh ) == 'transform':
mesh = sgBFunction_dag.getShape( mesh )
cons = cmds.listConnections( mesh+'.wm', type='sgMatrixFromVertices' )
if cons: return cons[0]
node = cmds.createNode( 'sgMatrixFromVertices' )
cmds.connectAttr( mesh+'.outMesh', node+'.inputMesh' )
cmds.connectAttr( mesh+'.wm', node+'.inputMeshMatrix' )
return node
def addSquashFromCurve( target, curve ):
import sgBFunction_curve
import sgBFunction_dag
import sgBFunction_mscriptUtil
import math
sgBFunction_curve.addDistanceAttribute( curve )
squashNode = cmds.createNode( 'squash' )
cmds.connectAttr( curve + '.initCurveLength', squashNode+'.lengthOriginal' )
cmds.connectAttr( curve + '.curveLength', squashNode+'.lengthModify' )
divNode = cmds.createNode( 'multiplyDivide' )
cmds.setAttr( divNode+'.operation', 2 )
cmds.connectAttr( curve+'.curveLength', divNode+'.input1X' )
cmds.connectAttr( curve+'.initCurveLength', divNode+'.input2X' )
curveShape = sgBFunction_dag.getShape( curve )
mtxTarget = sgBFunction_dag.getMDagPath( target ).inclusiveMatrix()
fnCurve = om.MFnNurbsCurve( sgBFunction_dag.getMDagPath( curveShape ) )
mtxCurve = sgBFunction_dag.getMDagPath( curveShape ).inclusiveMatrix()
pointTarget = om.MPoint( mtxTarget( 3, 0 ), mtxTarget( 3, 1 ), mtxTarget( 3, 2 ) ) * mtxCurve.inverse()
ptrParam, utilParam = sgBFunction_mscriptUtil.getDoublePtr()
fnCurve.getParamAtPoint( pointTarget, ptrParam )
param = utilParam.getDouble( ptrParam )
tangent = fnCurve.tangent( param )
vX = om.MVector( mtxTarget( 0, 0 ), mtxTarget( 0, 1 ), mtxTarget( 0, 2 ) )
vY = om.MVector( mtxTarget( 1, 0 ), mtxTarget( 1, 1 ), mtxTarget( 1, 2 ) )
vZ = om.MVector( mtxTarget( 2, 0 ), mtxTarget( 2, 1 ), mtxTarget( 2, 2 ) )
dotX = math.fabs( tangent * vX )
dotY = math.fabs( tangent * vY )
dotZ = math.fabs( tangent * vZ )
if dotX > dotY and dotX > dotZ:
cmds.connectAttr( divNode+'.outputX', target+'.scaleX', f=1 )
cmds.connectAttr( squashNode+'.output', target+'.scaleY', f=1 )
cmds.connectAttr( squashNode+'.output', target+'.scaleZ', f=1 )
elif dotY > dotZ and dotY > dotX:
cmds.connectAttr( squashNode+'.output', target+'.scaleX', f=1 )
cmds.connectAttr( divNode+'.outputX', target+'.scaleY', f=1 )
cmds.connectAttr( squashNode+'.output', target+'.scaleZ', f=1 )
elif dotZ > dotX and dotZ > dotY:
cmds.connectAttr( squashNode+'.output', target+'.scaleX', f=1 )
cmds.connectAttr( squashNode+'.output', target+'.scaleY', f=1 )
cmds.connectAttr( divNode+'.outputX', target+'.scaleZ', f=1 )
def setAniColor( targets ):
import sgBModel_data
import sgBFunction_dag
for target in targets:
shape = sgBFunction_dag.getShape( target )
cmds.setAttr( shape+'.overrideEnabled', True )
cmds.setAttr( shape+'.overrideColor', sgBModel_data.setAniColorNum )
sgBModel_data.setAniColorNum = ( sgBModel_data.setAniColorNum + 1 ) % 32
if sgBModel_data.setAniColorNum in [ 16, 19 ]:
sgBModel_data.setAniColorNum +=1
def rebuildByMinMaxSpans(curves, minSpans, maxSpans):
import sgBFunction_dag
sels = sgBFunction_dag.getChildrenShapeExists(curves)
lengthList = []
minLength = 10000000.0
maxLength = 0.0
targetCurves = []
for sel in sels:
selShape = sgBFunction_dag.getShape(sel)
if not selShape: continue
if not cmds.nodeType(selShape) == 'nurbsCurve': continue
fnCurve = om.MFnNurbsCurve(sgBFunction_dag.getMDagPath(selShape))
curveLength = fnCurve.length()
if curveLength < minLength:
minLength = curveLength
if curveLength > maxLength:
maxLength = curveLength
targetCurves.append(sel)
lengthList.append(fnCurve.length())
diffSpans = maxSpans - minSpans
diffLength = maxLength - minLength
for i in range(len(targetCurves)):
lengthRate = (lengthList[i] - minLength) / diffLength
spansRate = lengthRate * diffSpans
spans = spansRate + minSpans
cmds.rebuildCurve(targetCurves[i],
rpo=1,
rt=0,
end=1,
kr=2,
kcp=0,
kep=1,
kt=1,
s=spans,
d=3,
tol=0.01)
def getDeformedObjectsFromGroup(targets):
import sgBFunction_dag
targets = sgBFunction_dag.getChildrenShapeExists(targets)
if not targets: return []
returnTransforms = []
for target in targets:
targetShape = sgBFunction_dag.getShape(target)
nodeType = cmds.nodeType(targetShape)
if nodeType == 'mesh': inputAttr = 'inMesh'
elif nodeType in ['nurbsCurve', 'nurbsSurface']: inputAttr = 'create'
cons = cmds.listConnections(targetShape + '.' + inputAttr, s=1, d=0)
if not cons: continue
returnTransforms.append(target)
return list(set(returnTransforms))
def importCache( mesh, xmlFilePath ):
import sgBFunction_dag
import maya.cmds as cmds
mesh = sgBFunction_dag.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 = getStartAndEndFrameFromXmlFile( xmlFilePath )
cmds.setAttr( cacheNode+'.startFrame', -10000 )
cmds.setAttr( cacheNode+'.sourceStart', -10000 )
cmds.setAttr( cacheNode+'.sourceEnd', 10000 )
cmds.setAttr( cacheNode+'.originalStart', startFrame )
cmds.setAttr( cacheNode+'.originalEnd', endFrame )
cmds.select( mesh )
cmds.DeleteHistory()
meshP = cmds.listRelatives( mesh, p=1, f=1 )[0]
for shape in cmds.listRelatives( meshP, s=1, f=1 ):
if cmds.getAttr( shape+'.io' ): cmds.delete( shape )
print cmds.listRelatives( meshP, s=1 )
origMesh = sgBFunction_dag.addIOShape( mesh )
if cmds.nodeType( mesh ) == 'mesh':
cmds.connectAttr( origMesh+'.worldMesh', deformer+'.undeformedGeometry[0]' )
cmds.connectAttr( deformer+'.outputGeometry[0]', mesh+'.inMesh', f=1 )
elif cmds.nodeType( mesh ) in [ 'nurbsCurve', 'nurbsSurface' ]:
cmds.connectAttr( origMesh+'.worldSpace', deformer+'.undeformedGeometry[0]' )
cmds.connectAttr( deformer+'.outputGeometry[0]', mesh+'.create', f=1 )
def getDeformedObjectsFromGroup( targets ):
import sgBFunction_dag
targets = sgBFunction_dag.getChildrenShapeExists( targets )
if not targets: return []
returnTransforms = []
for target in targets:
targetShape = sgBFunction_dag.getShape( target )
nodeType = cmds.nodeType( targetShape )
if nodeType == 'mesh': inputAttr = 'inMesh'
elif nodeType in ['nurbsCurve', 'nurbsSurface']: inputAttr = 'create'
cons = cmds.listConnections( targetShape+'.'+inputAttr, s=1, d=0 )
if not cons: continue
returnTransforms.append( target )
return list( set( returnTransforms ) )
def createClosestPointObjectOnCurve( target, curve, attach=False ):
import sgBFunction_dag
import sgBFunction_curve
import sgBFunction_attribute
crvShape = sgBFunction_dag.getShape( curve )
crvMin, crvMax = cmds.getAttr( crvShape + '.minMaxValue' )[0]
tr = cmds.createNode( 'transform' )
cmds.setAttr( tr + '.dh', 1 )
sgBFunction_attribute.addAttr( tr, ln='param', min=crvMin, max=crvMax, k=1 )
if attach:
nearInfo = cmds.createNode( 'nearestPointOnCurve' )
dcmp = cmds.createNode( 'decomposeMatrix' )
cmds.connectAttr( crvShape + '.worldSpace', nearInfo + '.inputCurve' )
cmds.connectAttr( target + '.wm', dcmp + '.imat' )
cmds.connectAttr( dcmp + '.ot', nearInfo + '.inPosition' )
vectorProduct = cmds.createNode( 'vectorProduct' )
cmds.setAttr( vectorProduct + '.operation', 4 )
cmds.connectAttr( nearInfo+'.position', vectorProduct+'.input1' )
cmds.connectAttr( tr+'.pim', vectorProduct + '.matrix' )
cmds.connectAttr( vectorProduct + '.output', tr+'.t' )
else:
pointOnCurve = cmds.createNode( 'pointOnCurveInfo' )
cmds.connectAttr( crvShape + '.worldSpace', pointOnCurve + '.inputCurve' )
vectorProduct = cmds.createNode( 'vectorProduct' )
cmds.setAttr( vectorProduct + '.operation', 4 )
cmds.connectAttr( pointOnCurve+'.position', vectorProduct+'.input1' )
cmds.connectAttr( tr+'.pim', vectorProduct + '.matrix' )
cmds.connectAttr( vectorProduct + '.output', tr+'.t' )
parameter = sgBFunction_curve.getClosestParameter( target, curve )
cmds.setAttr( tr + '.param', parameter )
cmds.connectAttr( tr + '.param', pointOnCurve + '.parameter' )
return tr
def createClosestPointObjectOnCurve(target, curve, attach=False):
import sgBFunction_dag
import sgBFunction_curve
import sgBFunction_attribute
crvShape = sgBFunction_dag.getShape(curve)
crvMin, crvMax = cmds.getAttr(crvShape + '.minMaxValue')[0]
tr = cmds.createNode('transform')
cmds.setAttr(tr + '.dh', 1)
sgBFunction_attribute.addAttr(tr, ln='param', min=crvMin, max=crvMax, k=1)
if attach:
nearInfo = cmds.createNode('nearestPointOnCurve')
dcmp = cmds.createNode('decomposeMatrix')
cmds.connectAttr(crvShape + '.worldSpace', nearInfo + '.inputCurve')
cmds.connectAttr(target + '.wm', dcmp + '.imat')
cmds.connectAttr(dcmp + '.ot', nearInfo + '.inPosition')
vectorProduct = cmds.createNode('vectorProduct')
cmds.setAttr(vectorProduct + '.operation', 4)
cmds.connectAttr(nearInfo + '.position', vectorProduct + '.input1')
cmds.connectAttr(tr + '.pim', vectorProduct + '.matrix')
cmds.connectAttr(vectorProduct + '.output', tr + '.t')
else:
pointOnCurve = cmds.createNode('pointOnCurveInfo')
cmds.connectAttr(crvShape + '.worldSpace',
pointOnCurve + '.inputCurve')
vectorProduct = cmds.createNode('vectorProduct')
cmds.setAttr(vectorProduct + '.operation', 4)
cmds.connectAttr(pointOnCurve + '.position', vectorProduct + '.input1')
cmds.connectAttr(tr + '.pim', vectorProduct + '.matrix')
cmds.connectAttr(vectorProduct + '.output', tr + '.t')
parameter = sgBFunction_curve.getClosestParameter(target, curve)
cmds.setAttr(tr + '.param', parameter)
cmds.connectAttr(tr + '.param', pointOnCurve + '.parameter')
return tr
def addWobbleCurve(targetCurves):
import sgBFunction_convert
import sgBFunction_dag
targetCurves = sgBFunction_convert.singleToList(targetCurves)
targetCurves = sgBFunction_dag.getChildrenShapeExists(targetCurves)
for targetCurve in targetCurves:
targetShape = sgBFunction_dag.getShape(targetCurve)
cons = cmds.listConnections(targetShape + '.create',
p=1,
c=1,
s=1,
d=0)
sourceAttr = ''
if not cons:
origShape = cmds.createNode('nurbsCurve')
cmds.connectAttr(targetShape + '.local', origShape + '.create')
cmds.refresh()
cmds.disconnectAttr(targetShape + '.local', origShape + '.create')
origObject = cmds.listRelatives(origShape, p=1)[0]
origShape = cmds.parent(origShape, targetCurve)
cmds.setAttr(origShape + '.io', 1)
cmds.delete(origObject)
sourceAttr = origShape + '.local'
else:
sourceAttr = cons[1]
sgWobbleCurve = cmds.createNode('sgWobbleCurve2')
cmds.connectAttr(sourceAttr, sgWobbleCurve + '.inputCurve')
cmds.connectAttr(sgWobbleCurve + '.outputCurve',
targetShape + '.create',
f=1)
cmds.connectAttr('time1.outTime', sgWobbleCurve + '.time')
cmds.setAttr(sgWobbleCurve + '.fallOff1[0].fallOff1_Position', 0.2)
cmds.setAttr(sgWobbleCurve + '.fallOff1[0].fallOff1_FloatValue', 0.0)
cmds.setAttr(sgWobbleCurve + '.fallOff1[1].fallOff1_Position', 1)
cmds.setAttr(sgWobbleCurve + '.fallOff1[1].fallOff1_FloatValue', 1)
cmds.setAttr(sgWobbleCurve + '.timeMult1', 2)
def createClosestFollicle(trObj, meshObj):
import sgBFunction_mesh
import sgBFunction_dag
trObjPos = cmds.xform(trObj, q=1, ws=1, t=1)
u, v = sgBFunction_mesh.getUVAtPoint(trObjPos, meshObj)
follicle = cmds.createNode('follicle')
follicleObj = sgBFunction_dag.getTransform(follicle)
cmds.connectAttr(follicle + '.ot', follicleObj + '.t')
cmds.connectAttr(follicle + '.or', follicleObj + '.r')
meshShape = sgBFunction_dag.getShape(meshObj)
cmds.connectAttr(meshShape + '.outMesh', follicle + '.inputMesh')
cmds.setAttr(follicle + '.parameterU', u)
cmds.setAttr(follicle + '.parameterV', v)
return follicleObj
def makeControledCurveFromJoints(sels):
import sgBFunction_dag
for sel in sels:
children = cmds.listRelatives(sel, c=1, ad=1, f=1)
children.append(sel)
children.reverse()
points = [[0, 0, 0] for i in range(len(children))]
crv = cmds.curve(p=points, d=3)
crvShape = sgBFunction_dag.getShape(crv)
for i in range(len(children)):
mmdc = cmds.createNode('multMatrixDecompose')
cmds.connectAttr(children[i] + '.wm', mmdc + '.i[0]')
cmds.connectAttr(sel + '.pim', mmdc + '.i[1]')
cmds.connectAttr(mmdc + '.ot', crvShape + '.controlPoints[%d]' % i)
def makeExportObjects(exportTargets):
import sgBFunction_dag
import sgBFunction_connection
exportMeshs = sgBFunction_dag.getChildrenMeshExists(exportTargets)
for exportMesh in exportMeshs:
exportMeshP = cmds.listRelatives(exportMesh, p=1, f=1)[0]
cloneP = sgBFunction_dag.makeCloneObject2(exportMeshP, [':', '_'],
connectionOn=True)
exportMeshName = exportMesh.split('|')[-1]
exportMeshOrigShape = sgBFunction_dag.getOrigShape(exportMesh, True)
meshShape = cmds.createNode('mesh')
cmds.connectAttr(exportMeshOrigShape + '.outMesh',
meshShape + '.inMesh')
meshObj = cmds.listRelatives(meshShape, p=1)[0]
meshObj = cmds.rename(meshObj, exportMeshName.replace(':', '_'))
meshShape = sgBFunction_dag.getShape(meshObj)
meshShape = cmds.rename(meshShape,
exportMeshName.replace(':', '_') + 'Shape')
pivotScale = cmds.getAttr(exportMesh + '.scalePivot')[0]
pivotRotate = cmds.getAttr(exportMesh + '.rotatePivot')[0]
pivotScaleTr = cmds.getAttr(exportMesh + '.scalePivotTranslate')[0]
pivotRotateTr = cmds.getAttr(exportMesh + '.rotatePivotTranslate')[0]
cmds.setAttr(meshObj + '.scalePivot', *pivotScale)
cmds.setAttr(meshObj + '.rotatePivot', *pivotRotate)
cmds.setAttr(meshObj + '.scalePivotTranslate', *pivotScaleTr)
cmds.setAttr(meshObj + '.rotatePivotTranslate', *pivotRotateTr)
cmds.parent(meshObj, cloneP)
blendShape = cmds.blendShape(exportMesh, meshObj)[0]
cmds.setAttr(blendShape + '.origin', 0)
cmds.setAttr(blendShape + '.w[0]', 1)
cmds.sets(meshObj, e=1, forceElement='initialShadingGroup')
def setNearestPointOnCurveInfo( targetCrvs, createTransform = False ):
import sgBFunction_convert
import sgBFunction_dag
targetCrvs = sgBFunction_convert.singleToList( targetCrvs )
infos = []
for crv in targetCrvs:
crv = sgBFunction_dag.getShape( crv )
npc = cmds.createNode( 'nearestPointOnCurve' )
info = cmds.createNode( 'pointOnCurveInfo' )
cmds.connectAttr( crv+'.worldSpace[0]', npc+'.inputCurve' )
cmds.connectAttr( crv+'.worldSpace[0]', info+'.inputCurve' )
cmds.connectAttr( npc+'.parameter', info+'.parameter' )
infos.append( npc )
if createTransform:
transforms = []
for info in infos:
trNode = cmds.createNode( 'transform' )
fbf = cmds.createNode( 'fourByFourMatrix' )
mmdc= cmds.createNode( 'multMatrixDecompose' )
cmds.connectAttr( info+'.positionX', fbf+'.i30' )
cmds.connectAttr( info+'.positionY', fbf+'.i31' )
cmds.connectAttr( info+'.positionZ', fbf+'.i32' )
cmds.setAttr( trNode+'.dh', 1 )
cmds.connectAttr( fbf+'.output', mmdc+'.i[0]' )
cmds.connectAttr( trNode+'.pim', mmdc+'.i[1]' )
cmds.connectAttr( mmdc+'.ot', trNode+'.t' )
transforms.append( trNode )
cmds.select( transforms )
return infos
def getMeshAndIndices(targetCurve):
curveShape = sgBFunction_dag.getShape(targetCurve)
inputNode = curveShape
crvToPointNode = None
mtxFromVtxNode = None
num = 0
while True:
num += 1
if num >= 100: break
cons = cmds.listConnections(inputNode, s=1, d=0, p=1, c=1)
if not cons: return None
outputCon = cons[1]
node = outputCon.split('.')[0]
targetNodeType = cmds.nodeType(node)
if targetNodeType == 'sgCurveFromPoints':
crvToPointNode = node
inputNode = node
continue
if targetNodeType == 'sgMatrixFromVertices':
mtxFromVtxNode = node
break
inputNode = node
mesh = cmds.listConnections(mtxFromVtxNode + '.inputMesh', s=1, d=0)[0]
print "crvToPointNode : ", crvToPointNode
fnNode = om.MFnDependencyNode(
sgBFunction_dag.getMObject(crvToPointNode))
plugInputs = fnNode.findPlug('input')
indices = []
for i in range(plugInputs.numElements()):
connections = om.MPlugArray()
plugInputPoint = plugInputs[i].child(1)
plugInputPoint.connectedTo(connections, True, False)
indices.append(connections[0].logicalIndex())
return mesh, indices
def addDistanceAttribute(curve):
import sgBFunction_attribute
import sgBFunction_dag
curveLength = getCurveLength(curve)
sgBFunction_attribute.addAttr(curve, ln='initCurveLength', k=1)
sgBFunction_attribute.addAttr(curve, ln='curveLength', k=1)
cmds.setAttr(curve + '.initCurveLength', e=1, lock=0)
cmds.setAttr(curve + '.curveLength', e=1, lock=0)
cmds.setAttr(curve + '.initCurveLength', curveLength)
if not cmds.listConnections(
curve + '.curveLength', s=1, d=0, type='curveInfo'):
curveShape = sgBFunction_dag.getShape(curve)
curveInfo = cmds.createNode('curveInfo')
cmds.connectAttr(curveShape + '.local', curveInfo + '.inputCurve')
cmds.connectAttr(curveInfo + '.arcLength', curve + '.curveLength')
cmds.setAttr(curve + '.initCurveLength', e=1, lock=1)
cmds.setAttr(curve + '.curveLength', e=1, lock=1)
def getClosestParameter(targetObj, curve):
import sgBFunction_dag
crvShape = sgBFunction_dag.getShape(curve)
dagPathTarget = sgBFunction_dag.getMDagPath(targetObj)
mtxTarget = dagPathTarget.inclusiveMatrix()
dagPathCurve = sgBFunction_dag.getMDagPath(crvShape)
mtxCurve = dagPathCurve.inclusiveMatrix()
pointTarget = om.MPoint(mtxTarget[3])
pointTarget *= mtxCurve.inverse()
fnCurve = om.MFnNurbsCurve(sgBFunction_dag.getMDagPath(crvShape))
util = om.MScriptUtil()
util.createFromDouble(0.0)
ptrDouble = util.asDoublePtr()
fnCurve.closestPoint(pointTarget, 0, ptrDouble)
paramValue = om.MScriptUtil().getDouble(ptrDouble)
return paramValue
def createRivetFromCurves(curves):
import sgBFunction_dag
loft = cmds.createNode('loft')
info = cmds.createNode('pointOnSurfaceInfo')
fbfm = cmds.createNode('fourByFourMatrix')
mmdc = cmds.createNode('multMatrixDecompose')
null = cmds.createNode('transform')
vp = cmds.createNode('vectorProduct')
surfShape = cmds.createNode('nurbsSurface')
surfObj = sgBFunction_dag.getTransform(surfShape)
for i in range(len(curves)):
curve = curves[i]
shape = sgBFunction_dag.getShape(curve)
srcCons = cmds.listConnections(shape + '.create', p=1, c=1)
if not srcCons:
cmds.connectAttr(shape + '.local', loft + '.inputCurve[%d]' % i)
else:
cmds.connectAttr(srcCons[1], loft + '.inputCurve[%d]' % i)
cmds.setAttr(vp + '.operation', 2)
cmds.setAttr(info + '.top', 1)
cmds.setAttr(info + '.u', 0.5)
cmds.setAttr(info + '.v', 0.5)
cmds.connectAttr(loft + '.outputSurface', info + '.inputSurface')
cmds.connectAttr(loft + '.outputSurface', surfShape + '.create')
cmds.connectAttr(info + '.nnx', fbfm + '.i00')
cmds.connectAttr(info + '.nny', fbfm + '.i01')
cmds.connectAttr(info + '.nnz', fbfm + '.i02')
cmds.connectAttr(info + '.nvx', fbfm + '.i10')
cmds.connectAttr(info + '.nvy', fbfm + '.i11')
cmds.connectAttr(info + '.nvz', fbfm + '.i12')
cmds.connectAttr(info + '.nnx', vp + '.input1X')
cmds.connectAttr(info + '.nny', vp + '.input1Y')
cmds.connectAttr(info + '.nnz', vp + '.input1Z')
cmds.connectAttr(info + '.nvx', vp + '.input2X')
cmds.connectAttr(info + '.nvy', vp + '.input2Y')
cmds.connectAttr(info + '.nvz', vp + '.input2Z')
cmds.connectAttr(vp + '.outputX', fbfm + '.i20')
cmds.connectAttr(vp + '.outputY', fbfm + '.i21')
cmds.connectAttr(vp + '.outputZ', fbfm + '.i22')
cmds.connectAttr(info + '.px', fbfm + '.i30')
cmds.connectAttr(info + '.py', fbfm + '.i31')
cmds.connectAttr(info + '.pz', fbfm + '.i32')
cmds.connectAttr(fbfm + '.output', mmdc + '.i[0]')
cmds.connectAttr(null + '.pim', mmdc + '.i[1]')
cmds.connectAttr(mmdc + '.ot', null + '.t')
cmds.connectAttr(mmdc + '.or', null + '.r')
cmds.addAttr(null, ln='parameterU', min=0, max=1, dv=0.5)
cmds.setAttr(null + '.parameterU', e=1, k=1)
cmds.addAttr(null, ln='parameterV', min=0, max=1, dv=0.5)
cmds.setAttr(null + '.parameterV', e=1, k=1)
cmds.connectAttr(null + '.parameterU', info + '.u')
cmds.connectAttr(null + '.parameterV', info + '.v')
cmds.setAttr(null + '.dh', 1)
cmds.select(null)
return null, surfObj
def combineSkinCluster(skinedObjs):
import sgBFunction_dag
numVertices = None
for skinedObj in skinedObjs:
objShape = sgBFunction_dag.getShape(skinedObj)
fnMesh = om.MFnMesh(sgBFunction_dag.getMDagPath(objShape))
if not numVertices:
numVertices = fnMesh.numVertices()
else:
if numVertices != fnMesh.numVertices():
cmds.error("Selected meshs not same objects")
skinJoints = []
weightList = [[] for i in range(numVertices)]
for skinedObj in skinedObjs:
skinCluster = sgBFunction_dag.getNodeFromHistory(
skinedObj, 'skinCluster')
if not skinCluster: continue
skinCluster = skinCluster[0]
fnNode = om.MFnDependencyNode(sgBFunction_dag.getMObject(skinCluster))
plugMatrix = fnNode.findPlug('matrix')
plugMatrixMaxLogicalIndex = 0
for i in range(plugMatrix.numElements()):
logicalIndex = plugMatrix[i].logicalIndex()
if logicalIndex > plugMatrixMaxLogicalIndex:
plugMatrixMaxLogicalIndex = logicalIndex
connections = om.MPlugArray()
skinedJointIndices = []
origSkinedJointIndicesMap = [
-1 for i in range(plugMatrixMaxLogicalIndex + 1)
]
for i in range(plugMatrix.numElements()):
plugMatrix[i].connectedTo(connections, True, False)
if not connections.length():
continue
skinJointName = om.MFnDagNode(connections[0].node()).fullPathName()
if not skinJointName in skinJoints:
skinJoints.append(skinJointName)
jntIndex = skinJoints.index(skinJointName)
origSkinedJointIndicesMap[plugMatrix[i].logicalIndex()] = jntIndex
skinedJointIndices.append(jntIndex)
plugWeightList = fnNode.findPlug('weightList')
for i in range(plugWeightList.numElements()):
plugWeights = plugWeightList[i].child(0)
for j in range(plugWeights.numElements()):
logicalIndex = plugWeights[j].logicalIndex()
weightValue = plugWeights[j].asFloat()
jntIndex = origSkinedJointIndicesMap[logicalIndex]
weightList[i].append([jntIndex, weightValue])
newMesh = cmds.createNode('mesh')
srcShape = sgBFunction_dag.getShape(skinedObjs[0])
newMeshObj = sgBFunction_dag.getParent(newMesh)
cmds.connectAttr(srcShape + '.outMesh', newMesh + '.inMesh')
cmds.refresh()
cmds.disconnectAttr(srcShape + '.outMesh', newMesh + '.inMesh')
node = cmds.deformer(newMeshObj, type='skinCluster')[0]
for i in range(len(skinJoints)):
cmds.connectAttr(skinJoints[i] + '.wm', node + '.matrix[%d]' % i)
bindPreMatrix = cmds.getAttr(skinJoints[i] + '.wim')
cmds.setAttr(node + '.bindPreMatrix[%d]' % i,
bindPreMatrix,
type='matrix')
for i in range(len(weightList)):
for logicalIndex, value in weightList[i]:
cmds.setAttr(
node + '.weightList[%d].weights[%d]' % (i, logicalIndex),
value)
cmds.skinPercent(node, normalize=True)
def createControllerOnTarget(target, pivotCtlOn=True):
import sgBFunction_connection
import sgBFunction_dag
import sgBModel_data
targetPos = cmds.getAttr(target + '.wm')
targetP = cmds.listRelatives(target, p=1, f=1)[0]
targetName = target.split('|')[-1]
ctl = cmds.circle(n='CTL_' + targetName)[0]
ctlChild = cmds.createNode('transform', n='CTLChild_' + targetName)
ctlChild = cmds.parent(ctlChild, ctl)[0]
pivCtl = cmds.createNode('transform', n='PivCTL_' + targetName)
cmds.setAttr(pivCtl + '.dh', 1)
cmds.setAttr(pivCtl + '.overrideEnabled', 1)
cmds.setAttr(pivCtl + '.overrideColor', 18)
ctlP = cmds.group(ctl, n='P' + ctl)
ctlPPiv = cmds.group(ctlP, pivCtl, n='Piv' + ctlP)
cmds.xform(ctlPPiv, ws=1, matrix=targetPos)
cloneObject = sgBFunction_dag.getConstrainedObject(targetP)
ctlPPiv = cmds.parent(ctlPPiv, cloneObject)[0]
cmds.xform(pivCtl, os=1, matrix=sgBModel_data.getDefaultMatrix())
ctl = cmds.listRelatives(ctlP, c=1, f=1)[0]
sgBFunction_connection.getSourceConnection(target, ctlPPiv)
for attr in [
't', 'tx', 'ty', 'tz', 'r', 'rx', 'ry', 'rz', 's', 'sx', 'sy',
'sz', 'sh'
]:
cons = cmds.listConnections(target + '.' + attr, s=1, d=0, p=1, c=1)
if not cons: continue
for i in range(0, len(cons), 2):
cmds.disconnectAttr(cons[i + 1], cons[i])
sgBFunction_connection.constraintAll(ctlChild, target)
cmds.connectAttr(pivCtl + '.t', ctlP + '.t')
cmds.connectAttr(pivCtl + '.r', ctlP + '.r')
cmds.connectAttr(pivCtl + '.s', ctlP + '.s')
cmds.connectAttr(pivCtl + '.sh', ctlP + '.sh')
mmdcCtlChild = cmds.createNode('multMatrixDecompose')
cmds.connectAttr(ctlPPiv + '.wm', mmdcCtlChild + '.i[0]')
cmds.connectAttr(pivCtl + '.wim', mmdcCtlChild + '.i[1]')
cmds.connectAttr(mmdcCtlChild + '.ot', ctlChild + '.t')
cmds.connectAttr(mmdcCtlChild + '.or', ctlChild + '.r')
cmds.connectAttr(mmdcCtlChild + '.os', ctlChild + '.s')
cmds.connectAttr(mmdcCtlChild + '.osh', ctlChild + '.sh')
ctlShape = sgBFunction_dag.getShape(ctl)
circleNode = cmds.listConnections(ctlShape + '.create', s=1, d=0)[0]
mm = cmds.createNode('multMatrix')
trGeo = cmds.createNode('transformGeometry')
cmds.connectAttr(ctlPPiv + '.wm', mm + '.i[0]')
cmds.connectAttr(pivCtl + '.wim', mm + '.i[1]')
cmds.connectAttr(circleNode + '.outputCurve', trGeo + '.inputGeometry')
cmds.connectAttr(mm + '.matrixSum', trGeo + '.transform')
cmds.connectAttr(trGeo + '.outputGeometry', ctlShape + '.create', f=1)
return ctl
def create(*args):
import sgBFunction_dag
reload(sgBFunction_mesh)
sels = cmds.ls(sl=1)
baseMesh = cmds.textField(Window_Global.fld_baseMesh, q=1, tx=1)
detail = cmds.intField(Window_Global.fld_detail, q=1, v=1)
base = sgBFunction_dag.getShape(baseMesh)
dagPathBase = sgBFunction_dag.getMDagPath(baseMesh)
oBase = sgBFunction_dag.getMObject(base)
baseMtx = dagPathBase.inclusiveMatrix()
fnBase = om.MFnMesh()
fnBase.setObject(dagPathBase)
origPointsBase = om.MPointArray()
multedPointsBase = om.MPointArray()
fnBase.getPoints(origPointsBase)
multedPointsBase.setLength(origPointsBase.length())
for i in range(multedPointsBase.length()):
multedPointsBase.set(origPointsBase[i] * baseMtx, i)
fnBase.setPoints(multedPointsBase)
intersector = om.MMeshIntersector()
intersector.create(oBase)
topJnts = []
for sel in sels:
target = sgBFunction_dag.getShape(sel)
dagPathMesh = sgBFunction_dag.getMDagPath(target)
fnMeshTarget = om.MFnMesh(dagPathMesh)
origPointsTarget = om.MPointArray()
multedPointsTarget = om.MPointArray()
fnMeshTarget.getPoints(origPointsTarget)
targetMtx = dagPathMesh.inclusiveMatrix()
multedPointsTarget.setLength(origPointsTarget.length())
for i in range(multedPointsTarget.length()):
multedPointsTarget.set(origPointsTarget[i] * targetMtx, i)
minDistIndex = 0
minDist = 100000.0
pointOnMesh = om.MPointOnMesh()
for i in range(multedPointsTarget.length()):
intersector.getClosestPoint(multedPointsTarget[i], pointOnMesh)
pointClose = om.MPoint(pointOnMesh.getPoint())
dist = multedPointsTarget[i].distanceTo(pointClose)
if dist < minDist:
minDist = dist
minDistIndex = i
maxDistIndex = 0
maxDist = 0.0
for i in range(multedPointsTarget.length()):
dist = multedPointsTarget[minDistIndex].distanceTo(
multedPointsTarget[i])
if maxDist < dist:
maxDist = dist
maxDistIndex = i
startCenter = om.MPoint(
*cmds.xform(target +
'.vtx[%d]' % minDistIndex, q=1, ws=1, t=1))
endCenter = om.MPoint(
*cmds.xform(target +
'.vtx[%d]' % maxDistIndex, q=1, ws=1, t=1))
jnts = sgBFunction_mesh.createJointLineFromMeshApi(
dagPathMesh, startCenter, endCenter, detail)
topJnts.append(jnts[0])
fnBase.setPoints(origPointsBase)
cmds.select(topJnts)
def setWeightInnerPointsToTargetJoint(baseMesh, baseJoint, targetMeshs):
import sgBFunction_dag
baseMeshShape = sgBFunction_dag.getShape(baseMesh)
dagPathBaseMesh = sgBFunction_dag.getMDagPath(baseMeshShape)
mtxBaseMesh = dagPathBaseMesh.inclusiveMatrix()
headIntersector = om.MMeshIntersector()
headIntersector.create(dagPathBaseMesh.node())
targetMeshs = cmds.ls(sl=1)
for targetMesh in targetMeshs:
skinNodes = sgBFunction_dag.getNodeFromHistory(targetMesh,
'skinCluster')
if not skinNodes: continue
skinNode = skinNodes[0]
fnSkinNode = om.MFnDependencyNode(sgBFunction_dag.getMObject(skinNode))
joints = cmds.listConnections(skinNode + '.matrix', s=1, d=0)
if not baseJoint in joints: continue
indexInfluence = joints.index(baseJoint)
plugWeightList = fnSkinNode.findPlug('weightList')
targetMeshShape = sgBFunction_dag.getShape(targetMesh)
dagPathTargetMesh = sgBFunction_dag.getMDagPath(targetMeshShape)
fnTargetMesh = om.MFnMesh(dagPathTargetMesh)
mtxTarget = dagPathTargetMesh.inclusiveMatrix()
mtxToBase = mtxTarget * mtxBaseMesh.inverse()
numVertices = fnTargetMesh.numVertices()
pointsTarget = om.MPointArray()
fnTargetMesh.getPoints(pointsTarget)
pointOnMesh = om.MPointOnMesh()
targetVertices = []
for i in range(numVertices):
pointLocal = pointsTarget[i] * mtxToBase
headIntersector.getClosestPoint(pointLocal, pointOnMesh)
point = pointOnMesh.getPoint()
normal = om.MVector(pointOnMesh.getNormal())
vDir = om.MVector(pointLocal) - om.MVector(point)
if vDir * normal > 0: continue
plugWeights = plugWeightList[i].child(0)
for j in range(plugWeights.numElements()):
cmds.setAttr(plugWeights.name() + "[%d]" % j, 0)
cmds.setAttr(plugWeights.name() + "[%d]" % indexInfluence, 1)
targetVertices.append(targetMesh + '.vtx[%d]' % i)
cmds.select(targetVertices)
def getCamControllerAndCamControled( targetCam ):
import sgBFunction_dag
import sgBFunction_connection
import sgBFunction_attribute
cloneObject = sgBFunction_dag.getConstrainedObject( targetCam )
sgBFunction_attribute.addAttr( targetCam, ln='transController', at='message' )
sgBFunction_attribute.addAttr( targetCam, ln='transControllerP', at='message' )
sgBFunction_attribute.addAttr( targetCam, ln='camControled', at='message' )
transController = cmds.listConnections( targetCam+'.transController' )
transControllerP = cmds.listConnections( targetCam+'.transControllerP' )
camControled = cmds.listConnections( targetCam+'.camControled' )
for target in [ transController, transControllerP, camControled ]:
if not target: continue
cmds.delete( target )
transControllerP = cmds.createNode( 'transform' )
transController = cmds.polyPlane( width=.192, height=.108, subdivisionsHeight=1, subdivisionsWidth=1 )[0]
camControled = cmds.duplicate( targetCam )[0]
transController = cmds.parent( transController, transControllerP )[0]
cmds.setAttr( transController+'.rx', -90 )
cmds.setAttr( transController+'.s', .725, .725, .725 )
cmds.makeIdentity( transController, apply=1, t=1, r=1, s=1, n=0 )
cmds.setAttr( transController+'.overrideEnabled', 1 )
cmds.setAttr( transController+'.overrideLevelOfDetail', 1 )
cmds.setAttr( transController+'.overrideDisplayType', 2 )
cmds.setAttr( transControllerP+'.tz', -2.779 )
for attr in [ 'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz' ]:
cmds.setAttr( transControllerP+'.'+attr, e=1, lock=1 )
for attr in [ 'tz', 'rx', 'ry', 'rz' ]:
cmds.setAttr( transController+'.'+attr, e=1, lock=1, k=0 )
cmds.parent( transControllerP, cloneObject )
camControledShape = sgBFunction_dag.getShape( camControled )
cmds.setAttr( camControledShape+'.displayResolution', 0 )
cmds.setAttr( camControledShape+'.displayGateMask', 0 )
cmds.connectAttr( transController+'.tx', camControledShape+'.filmTranslateH' )
cmds.connectAttr( transController+'.ty', camControledShape+'.filmTranslateV' )
multNode = cmds.createNode( 'multiplyDivide' )
luminance = cmds.createNode( 'luminance' )
multDouble = cmds.createNode( 'multDoubleLinear' )
cmds.setAttr( multNode+'.input1', 1,1,1 )
cmds.setAttr( multNode+'.op', 2 )
cmds.connectAttr( transController+'.sx', multNode+'.input2X' )
cmds.connectAttr( transController+'.sy', multNode+'.input2Y' )
cmds.connectAttr( transController+'.sz', multNode+'.input2Z' )
cmds.connectAttr( multNode+'.output', luminance+'.value' )
cmds.connectAttr( luminance+'.outValue', multDouble+'.input1' )
cmds.setAttr( multDouble+'.input2', 14 )
cmds.connectAttr( multDouble+'.output', camControledShape+'.postScale' )
sgBFunction_connection.constraintAll( targetCam, camControled )
cmds.connectAttr( transController +'.message', targetCam+'.transController' )
cmds.connectAttr( transControllerP+'.message', targetCam+'.transControllerP' )
cmds.connectAttr( camControled+'.message', targetCam+'.camControled' )
def cmdUpdatePattern(arg=0):
sels = cmds.ls(sl=1)
surfShape = cmds.listRelatives(sels[0], s=1, f=1)[0]
nodes = cmds.listConnections(surfShape,
s=0,
d=1,
type='sgPatternCurveOnSurface')
node = nodes[0]
hists = cmds.listHistory(node)
delTarget = ''
targetSurface = ''
for hist in hists:
if cmds.nodeType(hist) != 'nurbsSurface': continue
if cmds.getAttr(hist + '.io'):
delTarget = cmds.listRelatives(hist, p=1, f=1)[0]
else:
targetSurface = cmds.listRelatives(hist, p=1, f=1)[0]
curves = cmds.listConnections(node + '.outputCurves')
cmds.delete(curves, delTarget)
import sgBFunction_dag
import sgBFunction_attribute
curve = sels[0]
surf = targetSurface
curveShape = sgBFunction_dag.getShape(curve)
surfShape = sgBFunction_dag.getShape(surf)
numSpansU = cmds.getAttr(surfShape + '.spansU')
numSpansV = cmds.getAttr(surfShape + '.spansV')
rebuildSurf = cmds.createNode('rebuildSurface')
cmds.setAttr(rebuildSurf + '.keepCorners', 0)
cmds.setAttr(rebuildSurf + '.spansU', numSpansU)
cmds.setAttr(rebuildSurf + '.spansV', numSpansV)
trGeo = cmds.createNode('transformGeometry')
node = cmds.createNode('sgPatternCurveOnSurface')
cmds.connectAttr(curve + '.patternSize', node + '.patternSize')
cmds.connectAttr(curve + '.offsetMult', node + '.offsetMult')
newSurface = cmds.createNode('nurbsSurface')
cmds.setAttr(newSurface + '.io', 1)
cmds.connectAttr(surfShape + '.local', rebuildSurf + '.inputSurface')
cmds.connectAttr(rebuildSurf + '.outputSurface',
trGeo + '.inputGeometry')
cmds.connectAttr(surf + '.wm', trGeo + '.transform')
cmds.connectAttr(trGeo + '.outputGeometry', newSurface + '.create')
cmds.connectAttr(newSurface + '.local', node + '.surface')
cmds.connectAttr(curveShape + '.local', node + '.curve')
surfShape = cmds.listRelatives(curve, s=1, f=1)[0]
nodes = cmds.listConnections(surfShape,
s=0,
d=1,
type='sgPatternCurveOnSurface')
outputNum = cmds.getAttr(nodes[0] + '.numOutput')
for i in range(outputNum):
cons = cmds.listConnections(nodes[0] + '.outputCurves[%d]' % i)
if not cons:
outputCurve = cmds.createNode('nurbsCurve')
cmds.connectAttr(nodes[0] + '.outputCurves[%d]' % i,
outputCurve + '.create')
def createRivetOnSurfacePoint(surfacePoint, firstDirection='u'):
import sgBFunction_dag
import sgBFunction_attribute
if firstDirection.lower() == 'u':
fString = 'U'
sString = 'V'
else:
fString = 'V'
sString = 'U'
surfaceName, uv = surfacePoint.split('.uv')
surfaceName = sgBFunction_dag.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 getCenterCurve(curves=None):
import sgBFunction_dag
posList = []
bbox = om.MBoundingBox()
if not curves: curves = cmds.ls(sl=1)
numSpans = 0
for curve in curves:
curveShape = sgBFunction_dag.getShape(curve)
fnCurve = om.MFnNurbsCurve(sgBFunction_dag.getMDagPath(curveShape))
numSpans += fnCurve.numSpans()
numSpans /= len(curves)
posList = [[] for i in range(numSpans)]
for curve in curves:
curveShape = sgBFunction_dag.getShape(curve)
curvePath = sgBFunction_dag.getMDagPath(curveShape)
curveWorldMatrix = curvePath.inclusiveMatrix()
fnCurve = om.MFnNurbsCurve(curvePath)
minParam = fnCurve.findParamFromLength(0)
maxParam = fnCurve.findParamFromLength(fnCurve.length())
eachParam = (float(maxParam) - float(minParam)) / numSpans
bbox = om.MBoundingBox()
for i in range(numSpans):
eachPoint = om.MPoint()
fnCurve.getPointAtParam(eachParam * i + minParam, eachPoint)
posList[i].append(eachPoint * curveWorldMatrix)
bbCenterList = []
for i in range(numSpans):
bbox = om.MBoundingBox()
for j in range(len(curves)):
bbox.expand(posList[i][j])
bbCenterList.append(bbox.center())
minIndexList = []
for i in range(numSpans):
minDist = 1000000.0
minIndex = 0
for j in range(len(curves)):
dist = posList[i][j].distanceTo(bbCenterList[i])
if dist < minDist:
minDist = dist
minIndex = j
minIndexList.append(minIndex)
minIndexRateList = [0 for i in range(len(curves))]
for i in range(numSpans):
minIndexRateList[minIndexList[i]] += 1
targetCurveIndex = 0
maxIndexRate = 0
for i in range(len(minIndexRateList)):
if minIndexRateList[i] > maxIndexRate:
maxIndexRate = minIndexRateList[i]
targetCurveIndex = i
cmds.select(curves[targetCurveIndex])
return curves[minIndex]
def createUiSeparatedView(cam,
width,
height,
indexW,
indexH,
sgw,
sgh,
sw,
sh,
scale,
camNum,
createWindow=False):
uiPrefix = 'separatedViewCam_%d_' % camNum
sepWidthValue = 1.0 / sgw / sw
filmTransWidthValue = gWidthValues[indexW] - 1.0 / sgw - sepWidthValue
filmTransWidthValues = []
for i in range(sw):
filmTransWidthValue += sepWidthValue * 2
filmTransWidthValues.append(filmTransWidthValue)
sepHeightValue = 1.0 / sgh / sh
filmTransHeightValue = gHeightValues[
indexH] - 1.0 / sgh - sepHeightValue
filmTransHeightValues = []
for i in range(sh):
filmTransHeightValue += sepHeightValue * 2
filmTransHeightValues.append(filmTransHeightValue * aspectRatio)
targetCams = []
tlcList = []
scaleValue = sw * sgw
offsetWidth = width / sgw * indexW
offsetHeight = height / sgh * indexH
animationCam = cmds.duplicate(cam,
n=cam + '_animation_%d_%d' %
(indexW, indexH))[0]
aniCamShape = sgBFunction_dag.getShape(animationCam)
cmds.setAttr(aniCamShape + '.displayResolution', 0)
cmds.setAttr(aniCamShape + '.displayGateMask', 0)
cmds.setAttr(aniCamShape + '.postScale', scaleValue)
cmds.setAttr(aniCamShape + '.filmFit', 1)
sgBFunction_attribute.addAttr(animationCam, ln='mainCam', at='message')
cmds.connectAttr(cam + '.aniamtionCam', animationCam + '.mainCam')
cmds.setAttr(aniCamShape + '.overscan', 1)
for i in range(len(filmTransHeightValues)):
for j in range(len(filmTransWidthValues)):
duCam = cmds.duplicate(cam,
n=cam + '_translate_G_%d_%d_%02d_%02d' %
(indexW, indexH, i + 1, j + 1))[0]
sgBFunction_attribute.addAttr(duCam,
ln='mainCam',
at='message')
cmds.connectAttr(cam + '.filmTranslateCams',
duCam + '.mainCam')
duCamShape = sgBFunction_dag.getShape(duCam)
cmds.setAttr(duCamShape + '.overscan', 1)
cmds.setAttr(duCamShape + '.displayResolution', 0)
cmds.setAttr(duCamShape + '.displayGateMask', 0)
cmds.setAttr(duCamShape + '.postScale', scaleValue)
cmds.setAttr(duCamShape + '.filmFit', 1)
cmds.setAttr(duCamShape + '.filmTranslateH',
filmTransWidthValues[j])
cmds.setAttr(duCamShape + '.filmTranslateV',
-filmTransHeightValues[i])
cuFrame = i * len(filmTransWidthValues) + j + 1
#print "frame : %02d, %5.2f, %5.2f" %( cuFrame, filmTransWidthValues[j], -filmTransHeightValues[i] )
cmds.setKeyframe(animationCam + '.filmTranslateH',
t=cuFrame,
v=filmTransWidthValues[j])
cmds.setKeyframe(animationCam + '.filmTranslateV',
t=cuFrame,
v=-filmTransHeightValues[i])
targetCams.append(duCam)
tlcValue = [
int((
(filmTransHeightValues[i] - filmTransHeightValues[0]) *
width / 2) * scale) + 23,
int(((filmTransWidthValues[j] - filmTransWidthValues[0]) *
width / 2) * scale) + 1
]
tlcList.append(tlcValue)
if createWindow:
for i in range(len(targetCams)):
winName = uiPrefix + targetCams[i]
tlc = tlcList[i]
tlc[0] += top + offsetHeight * scale
tlc[1] += left + offsetWidth * scale
inst = sgBModel_ui.ModelEditorWindow(winName,
eachResolutionWidth,
eachResolutionHeight,
tlc,
False,
camera=targetCams[i],
hud=0,
cameras=0,
dynamics=0,
ikHandles=0,
nurbsCurves=0,
textures=False,
grid=False,
da='smoothShaded')
inst.create()
tlc = tlcList[0]
tlc[0] -= 23
inst = sgBModel_ui.ModelEditorWindow(uiPrefix + animationCam,
eachResolutionWidth,
eachResolutionHeight,
tlc,
True,
False,
camera=animationCam,
hud=0,
cameras=0,
dynamics=0,
ikHandles=0,
nurbsCurves=0,
textures=False,
grid=False,
da='smoothShaded')
inst.create()
cmds.window(inst.winName,
e=1,
title='WCA_%d_%d' % (indexW, indexH))
minFrame = 1
maxFrame = len(filmTransHeightValues) * len(filmTransWidthValues)
cmds.playbackOptions(min=minFrame)
cmds.playbackOptions(max=maxFrame)
cmds.currentTime(minFrame)
def duplicateShaderToOther(first, second):
import maya.mel as mel
import sgBFunction_dag
if not cmds.objExists(first): return None
if not cmds.objExists(second): return None
first = sgBFunction_dag.getTransform(first)
second = sgBFunction_dag.getTransform(second)
firstShape = sgBFunction_dag.getShape(first)
secondShape = sgBFunction_dag.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)
engine = cmds.duplicate(engine, n='du_' + engine)[0]
if shaders:
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]
cmds.connectAttr(shader + '.outColor', engine + '.surfaceShader')
aiShaders = cmds.listConnections(engine + '.aiSurfaceShader', s=1, d=0)
if aiShaders:
aiShader = aiShaders[0]
cmds.hyperShade(objects=aiShader)
selObjs = cmds.ls(sl=1, l=1)
cmds.select(aiShader)
mel.eval(
'hyperShadePanelMenuCommand("hyperShadePanel1", "duplicateShadingNetwork")'
)
aiShader = cmds.ls(sl=1)[0]
cmds.connectAttr(aiShader + '.outColor',
engine + '.aiSurfaceShader')
for targetObj in targetObjs:
cmds.sets(targetObj, e=1, forceElement=engine)
def createVolume_byCurvesLine(self, level=6 ):
import sgBFunction_dag
avSpans = 0
eachMinParams = []
eachMaxParams = []
for i in range( len( self.centerCurves ) ):
curve = self.centerCurves[i]
curveShape = sgBFunction_dag.getShape( curve )
fnCurve = om.MFnNurbsCurve( sgBFunction_dag.getMDagPath( curveShape ) )
avSpans += fnCurve.numSpans()
eachMinParam = fnCurve.findParamFromLength( 0 )
eachMaxParam = fnCurve.findParamFromLength( fnCurve.length() )
eachMinParams.append( eachMinParam )
eachMaxParams.append( eachMaxParam )
avSpans = int( avSpans / len( self.centerCurves ) )
eachParamRates = []
for i in range( len( self.centerCurves ) ):
paramRate = float( eachMaxParams[i] - eachMinParams[i] )
paramRate /= (avSpans-1)
eachParamRates.append( paramRate )
curvePointsList = [ [] for j in range( (level/2)*2 ) ]
for i in range( avSpans ):
epPoints = om.MPointArray()
epPoints.setLength( len( self.centerCurves ) )
avTangent = om.MVector( 0,0,0 )
for j in range( len( self.centerCurves ) ):
curveShape = sgBFunction_dag.getShape( self.centerCurves[j] )
fnCurve = om.MFnNurbsCurve( sgBFunction_dag.getMDagPath( curveShape ) )
point = om.MPoint()
fnCurve.getPointAtParam( eachParamRates[j] * i + eachMinParams[j], point )
epPoints.set( point, j )
avTangent += fnCurve.tangent( eachParamRates[j] * i + eachMinParams[j] )
dataCurve = om.MFnNurbsCurveData()
oCurve = dataCurve.create()
fnCurveCreate = om.MFnNurbsCurve()
fnCurveCreate.createWithEditPoints( epPoints, 3, 1, False, False, False, oCurve )
fnCurveCreate.setObject( oCurve )
maxParam = fnCurveCreate.findParamFromLength( fnCurveCreate.length() )
eachParam = maxParam / ( level/2 + 2 )
for j in range( level/2 ):
param = eachParam * ( j+1 )
point = om.MPoint()
fnCurveCreate.getPointAtParam( param, point )
vAim = fnCurveCreate.tangent( param )
vUp = avTangent
vCross = vAim ^ vUp
vInvCross = -vCross
pointsIntersects = om.MPointArray()
pointsIntersectsInv = om.MPointArray()
self.fnMesh.intersect( point, vCross, pointsIntersects )
self.fnMesh.intersect( point, vInvCross, pointsIntersectsInv )
if pointsIntersects.length():
targetPoint = ( pointsIntersects[0] - om.MVector( point ) ) * 0.7 + om.MVector( point )
curvePointsList[j].append( [ targetPoint.x, targetPoint.y, targetPoint.z ] )
else:
curvePointsList[j].append( [ point.x, point.y, point.z ] )
if pointsIntersectsInv.length():
targetPointInv = ( pointsIntersectsInv[0] - om.MVector( point ) ) * 0.7 + om.MVector( point )
curvePointsList[j+( level/2 )].append( [ targetPointInv.x, targetPointInv.y, targetPointInv.z ] )
else:
curvePointsList[j+( level/2 )].append( [ point.x, point.y, point.z ] )
createCurves = []
for curvePoints in curvePointsList:
createCurves.append( cmds.curve( ep=curvePoints ) )
return createCurves
def cmdCreatePattern(arg=0):
import sgBFunction_dag
import sgBFunction_attribute
PatternSize = cmds.floatField(WinA_Global.ff_patternSize, q=1, v=1)
OffsetMult = cmds.floatField(WinA_Global.ff_offsetMult, q=1, v=1)
sels = cmds.ls(sl=1)
curve = sels[0]
surf = sels[1]
curveShape = sgBFunction_dag.getShape(curve)
surfShape = sgBFunction_dag.getShape(surf)
numSpansU = cmds.getAttr(surfShape + '.spansU')
numSpansV = cmds.getAttr(surfShape + '.spansV')
rebuildSurf = cmds.createNode('rebuildSurface')
cmds.setAttr(rebuildSurf + '.keepCorners', 0)
cmds.setAttr(rebuildSurf + '.spansU', numSpansU)
cmds.setAttr(rebuildSurf + '.spansV', numSpansV)
trGeo = cmds.createNode('transformGeometry')
node = cmds.createNode('sgPatternCurveOnSurface')
sgBFunction_attribute.addAttr(curve,
ln='patternSize',
min=0.1,
dv=PatternSize,
k=1)
sgBFunction_attribute.addAttr(curve,
ln='offsetMult',
min=0.25,
dv=OffsetMult,
k=1)
cmds.connectAttr(curve + '.patternSize', node + '.patternSize')
cmds.connectAttr(curve + '.offsetMult', node + '.offsetMult')
newSurface = cmds.createNode('nurbsSurface')
cmds.setAttr(newSurface + '.io', 1)
cmds.connectAttr(surfShape + '.local', rebuildSurf + '.inputSurface')
cmds.connectAttr(rebuildSurf + '.outputSurface',
trGeo + '.inputGeometry')
cmds.connectAttr(surf + '.wm', trGeo + '.transform')
cmds.connectAttr(trGeo + '.outputGeometry', newSurface + '.create')
cmds.connectAttr(newSurface + '.local', node + '.surface')
cmds.connectAttr(curveShape + '.local', node + '.curve')
surfShape = cmds.listRelatives(curve, s=1, f=1)[0]
nodes = cmds.listConnections(surfShape,
s=0,
d=1,
type='sgPatternCurveOnSurface')
outputNum = cmds.getAttr(nodes[0] + '.numOutput')
for i in range(outputNum):
cons = cmds.listConnections(nodes[0] + '.outputCurves[%d]' % i)
if not cons:
outputCurve = cmds.createNode('nurbsCurve')
cmds.connectAttr(nodes[0] + '.outputCurves[%d]' % i,
outputCurve + '.create')
def createInCurve(surface,
numCurve,
paramRand=0.3,
offsetRand=0.15,
centerOffset=0.5):
import random
import sgBFunction_dag
import sgBFunction_base
sgBFunction_base.autoLoadPlugin("HSBVC.mll")
node = cmds.createNode('volumeCurvesOnSurface')
cmds.connectAttr(surface + '.wm', node + '.inputMatrix')
surfaceShape = sgBFunction_dag.getShape(surface)
cmds.connectAttr(surfaceShape + '.local', node + '.inputSurface')
minValue, maxValue = cmds.getAttr(surfaceShape + '.minMaxRangeV')[0]
if numCurve in [1, 2, 3]:
paramRate = (maxValue - minValue) / numCurve
else:
paramRate = (maxValue - minValue) / (numCurve - 1)
outputCurves = cmds.listConnections(node + '.outputCurve')
if outputCurves:
lenOutputCurves = len(outputCurves)
if lenOutputCurves > numCurve:
cmds.delete(outputCurves[numCurve - lenOutputCurves:])
if not numCurve:
return None
curves = []
for i in range(numCurve):
addOffsetParam = random.uniform(-paramRate / 2 * paramRand,
paramRate / 2 * paramRand)
addOffsetCenter = random.uniform(-offsetRand, offsetRand)
outputCurveCon = cmds.listConnections(node + '.outputCurve[%d]' % i)
if not outputCurveCon:
crvNode = cmds.createNode('nurbsCurve')
crvObj = cmds.listRelatives(crvNode, p=1)[0]
cmds.connectAttr(node + '.outputCurve[%d]' % i,
crvNode + '.create')
cmds.addAttr(crvObj,
ln='paramRate',
dv=paramRate * i + addOffsetParam + paramRate * 0.5)
cmds.setAttr(crvObj + '.paramRate', e=1, k=1)
cmds.addAttr(crvObj,
ln='centerRate',
dv=centerOffset + addOffsetCenter)
cmds.setAttr(crvObj + '.centerRate', e=1, k=1)
cmds.connectAttr(crvObj + '.paramRate',
node + '.curveInfo[%d].paramRate' % i)
cmds.connectAttr(crvObj + '.centerRate',
node + '.curveInfo[%d].centerRate' % i)
else:
crvObj = outputCurveCon[0]
cmds.setAttr(crvObj + '.paramRate',
paramRate * i + addOffsetParam + paramRate * 0.5)
cmds.setAttr(crvObj + '.centerRate',
centerOffset + addOffsetCenter)
crvObj = cmds.rename(crvObj, surface + '_curve_%d' % i)
curves.append(crvObj)
if i == numCurve - 1:
if not numCurve in [2, 3]:
cmds.setAttr(crvObj + '.centerRate', 0)
outputLen = numCurve
for i in range(outputLen):
outputCons = cmds.listConnections(node + '.outputCurve[%d]' % i)
if not outputCons:
cmds.removeMultiInstance('%s[%d]' % (node + '.outputCurve', i))
cmds.removeMultiInstance('%s[%d]' % (node + '.curveInfo', i))
return curves
def doBake( cameraPath, minFrame, maxFrame, maya=True, mb = True, fbx=True ):
import os, time, socket
import sgBFunction_dag
import sgBFunction_base
sgBFunction_base.autoLoadPlugin( 'fbxmaya' )
removeUnknown()
cameraPath = cameraPath.replace( '\\', '/' )
##_ex_Atts = ["renderable"]
_attrs = ["horizontalFilmAperture", "verticalFilmAperture", "focalLength", "lensSqueezeRatio", "fStop", "focusDistance", "shutterAngle", "centerOfInterest", "nearClipPlane", "farClipPlane",
"filmFit", "filmFitOffset", "horizontalFilmOffset", "verticalFilmOffset", "shakeEnabled", "horizontalShake", "verticalShake", "shakeOverscanEnabled", "shakeOverscan", "preScale",
"filmTranslateH", "filmTranslateV", "horizontalRollPivot", "verticalRollPivot", "filmRollValue", "filmRollOrder", "postScale", "depthOfField", "focusRegionScale"]
if not (maya or fbx):
print "AAA"
return
if not cmds.ls(sl=1):
print "BBB"
return
sels = cmds.ls(sl=1)
src = None
src_sh = None
for sel in sels:
selShape = sgBFunction_dag.getShape( sel )
if cmds.nodeType( selShape ) == 'camera':
src = sel
src_sh = selShape
if not src_sh:
cmds.error( "No Camera Selected")
if not (cmds.nodeType(src_sh) == "camera"):
return
trg = cmds.camera()[0]
unit = cmds.currentUnit( q=1, time=1 )
unitDict = { 'game':15, 'film':24, 'pal':25, 'ntsc':30, 'show':48, 'palf':50, 'ntscf':60 }
camName = cameraPath.split( '/' )[-1]
camName += '_%d_%d_%df_bake' %( minFrame, maxFrame, unitDict[ unit ] )
trg = cmds.rename( trg, camName )
trg_sh = cmds.listRelatives(trg, s=True, f=True)[0]
##for at in cmds.listAttr(src_sh):
for at in _attrs:
##if at in _ex_Atts: continue
try:
##cmds.setAttr("%s.%s" % (src_sh, at), k=1)
cmds.setAttr("%s.%s" % (trg_sh, at), k=1)
cmds.setAttr("%s.%s" % (trg_sh, at), cmds.getAttr("%s.%s" % (src_sh, at)))
cmds.connectAttr("%s.%s" % (src_sh, at), "%s.%s" % (trg_sh, at), f=1)
except:
pass
cmds.pointConstraint(src, trg, offset=[0,0,0], weight=1)
cmds.orientConstraint(src, trg, offset=[0,0,0], weight=1)
cmds.setAttr(trg + ".rotateAxisX", cmds.getAttr(src + ".rotateAxisX"))
cmds.setAttr(trg + ".rotateAxisY", cmds.getAttr(src + ".rotateAxisY"))
cmds.setAttr(trg + ".rotateAxisZ", cmds.getAttr(src + ".rotateAxisZ"))
cmds.refresh(suspend=True)
try:
cmds.bakeResults(trg, sm=True, t=(minFrame, maxFrame), sb=1, dic=True, pok=True, sac=False, removeBakedAttributeFromLayer=False, bakeOnOverrideLayer=False, cp=False, s=True)
finally:
cmds.refresh(suspend=False)
cmds.refresh()
cmds.delete(trg, constraints=1)
try:
a = cmds.listConnections(src_sh, s=0, d=1, c=1, p=1, scn=1, sh=1)[::2]
b = cmds.listConnections(src_sh, s=0, d=1, c=1, p=1, scn=1, sh=1)[1::2]
for i in range(len(a)):
cmds.disconnectAttr(a[i], b[i])
except:
pass
outFN = cameraPath
rntN = cmds.fileDialog2(fm=0, dir=outFN)
if not rntN:
return
rntFN = os.path.splitext(rntN[0])[0]
if maya:
cmds.file(rntFN, force=1, options="v=0;", typ="mayaAscii", pr=1, es=1)
if mb:
cmds.file(rntFN, force=1, options="v=0;", typ="mayaBinary", pr=1, es=1)
if fbx:
cmds.file(rntFN, force=1, options="v=0;", typ="FBX export", pr=1, es=1)
#print rnt
##setClipboardData(rnt)
def showExportCamera():
if cmds.window("exportCamera", ex=1):
cmds.deleteUI("exportCamera")
cmds.window("exportCamera")
cmds.columnLayout( adjustableColumn=True )
cmds.rowColumnLayout(numberOfColumns=2, columnWidth=[(1, 100), (2, 100)] )
mayaCB = cmds.checkBox(l="Maya", v=True)
fbxCB = cmds.checkBox(l="FBX", v=True)
cmds.setParent("..")
#cmds.button(l="Tear off", c=lambda x:tearOffPanel())
cmds.button(l="Export", c=lambda x:doBake(cmds.checkBox(mayaCB, q=1, v=1), cmds.checkBox(fbxCB, q=1, v=1)))
cmds.showWindow()
showExportCamera()
def createCurveFromSelVertices_mirror(targetCurve):
import sgBFunction_dag
def getMeshAndIndices(targetCurve):
curveShape = sgBFunction_dag.getShape(targetCurve)
inputNode = curveShape
crvToPointNode = None
mtxFromVtxNode = None
num = 0
while True:
num += 1
if num >= 100: break
cons = cmds.listConnections(inputNode, s=1, d=0, p=1, c=1)
if not cons: return None
outputCon = cons[1]
node = outputCon.split('.')[0]
targetNodeType = cmds.nodeType(node)
if targetNodeType == 'sgCurveFromPoints':
crvToPointNode = node
inputNode = node
continue
if targetNodeType == 'sgMatrixFromVertices':
mtxFromVtxNode = node
break
inputNode = node
mesh = cmds.listConnections(mtxFromVtxNode + '.inputMesh', s=1, d=0)[0]
print "crvToPointNode : ", crvToPointNode
fnNode = om.MFnDependencyNode(
sgBFunction_dag.getMObject(crvToPointNode))
plugInputs = fnNode.findPlug('input')
indices = []
for i in range(plugInputs.numElements()):
connections = om.MPlugArray()
plugInputPoint = plugInputs[i].child(1)
plugInputPoint.connectedTo(connections, True, False)
indices.append(connections[0].logicalIndex())
return mesh, indices
def createCurve(mesh, indices):
vtsToCrv = cmds.createNode('sgMatrixFromVertices')
pointToCrv = cmds.createNode('sgCurveFromPoints')
crv = cmds.createNode('nurbsCurve')
cmds.connectAttr(pointToCrv + '.outputCurve', crv + '.create')
cmds.connectAttr(mesh + '.outMesh', vtsToCrv + '.inputMesh')
cmds.connectAttr(mesh + '.wm', vtsToCrv + '.inputMeshMatrix')
for i in range(len(indices)):
cmds.setAttr(vtsToCrv + '.verticeId[%d]' % indices[i], indices[i])
cmds.connectAttr(vtsToCrv + '.outputTranslate[%d]' % indices[i],
pointToCrv + '.input[%d].inputPoint' % i)
return crv, pointToCrv
mesh, indices = getMeshAndIndices(targetCurve)
mesh = sgBFunction_dag.getShape(mesh)
dagPathMesh = sgBFunction_dag.getMDagPath(mesh)
intersector = om.MMeshIntersector()
intersector.create(dagPathMesh.node())
meshMtx = dagPathMesh.inclusiveMatrix()
meshMtxInv = dagPathMesh.inclusiveMatrixInverse()
fnMesh = om.MFnMesh(dagPathMesh)
pArr = om.MPointArray()
fnMesh.getPoints(pArr)
targetIndices = []
pointOnMesh = om.MPointOnMesh()
for index in indices:
worldPoint = pArr[index] * meshMtx
mirrorPoint = om.MPoint(-worldPoint.x, worldPoint.y,
worldPoint.z) * meshMtxInv
intersector.getClosestPoint(mirrorPoint, pointOnMesh)
fIndex = pointOnMesh.faceIndex()
vtxIndices = om.MIntArray()
fnMesh.getPolygonVertices(fIndex, vtxIndices)
closeDist = 1000000.0
closeIndex = vtxIndices[0]
for vtxIndex in vtxIndices:
point = pArr[vtxIndex]
dist = point.distanceTo(mirrorPoint)
if dist < closeDist:
closeDist = dist
closeIndex = vtxIndex
targetIndices.append(closeIndex)
node = sgBFunction_dag.getNodeFromHistory(targetCurve,
'sgCurveFromPoints')[0]
createType = cmds.getAttr(node + '.createType')
degrees = cmds.getAttr(node + '.degrees')
createdCrv, createdNode = createCurve(mesh, targetIndices)
cmds.setAttr(createdNode + '.createType', createType)
cmds.setAttr(createdNode + '.degrees', degrees)
def setKeyCurves(curves):
import sgBFunction_dag
import sgBFunction_attribute
import math
curves = sgBFunction_dag.getChildrenCurveExists(curves)
currentFrame = str('%.2f' % cmds.currentTime(q=1)).replace('.',
'_').replace(
'-', 'm')
frameGroup = 'keyCurveGroup_%s' % currentFrame
if not cmds.objExists(frameGroup):
cmds.group(em=1, n=frameGroup)
sgBFunction_attribute.addAttr(frameGroup, ln='frameValue', dt='string')
cmds.setAttr(frameGroup + '.frameValue', currentFrame, type='string')
cmds.setAttr(frameGroup + '.overrideEnabled', 1)
cmds.setAttr(frameGroup + '.overrideColor',
int(math.fabs(cmds.currentTime(q=1))) % 32)
keyCurves = []
for curve in curves:
sgBFunction_attribute.addAttr(curve, ln='keyCurveBase', at='message')
cons = cmds.listConnections(curve + '.keyCurveBase', d=1, s=0)
if cons:
targetCurve = None
for con in cons:
conP = cmds.listRelatives(con, p=1, f=1)[0]
if cmds.getAttr(conP + '.frameValue') == currentFrame:
targetCurve = con
if targetCurve:
keyCurves.append(targetCurve)
continue
keyCurveShape = cmds.createNode('nurbsCurve')
curveShape = sgBFunction_dag.getShape(curve)
cmds.connectAttr(curveShape + '.local', keyCurveShape + '.create')
keyCurve = sgBFunction_dag.getTransform(keyCurveShape)
curveName = curve.split('|')[-1]
keyCurve = cmds.rename(keyCurve, curveName + '_' + currentFrame)
keyCurves.append(keyCurve)
sgBFunction_attribute.addAttr(keyCurve, ln='keyCurve', at='message')
cmds.connectAttr(curve + '.keyCurveBase', keyCurve + '.keyCurve')
cmds.refresh()
for i in range(len(curves)):
baseCurve = sgBFunction_dag.getShape(curves[i])
keyCurve = sgBFunction_dag.getShape(keyCurves[i])
if cmds.isConnected(baseCurve + '.local', keyCurve + '.create'):
cmds.disconnectAttr(baseCurve + '.local', keyCurve + '.create')
try:
keyCurves[i] = cmds.parent(keyCurves[i], frameGroup)[0]
except:
continue
targetKeyCurves = []
for i in range(len(curves)):
baseCurve = curves[i]
keyCurve = keyCurves[i]
if not cmds.attributeQuery('mtxObj_forKeyCurve', node=baseCurve, ex=1):
cmds.delete(keyCurve)
continue
mtxObj = cmds.listConnections(baseCurve + '.mtxObj_forKeyCurve',
s=1,
d=0)
if not mtxObj:
cmds.delete(keyCurve)
continue
targetKeyCurves.append(keyCurve)
setKeyCurve(keyCurve, baseCurve, mtxObj[0])
return targetKeyCurves
