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 getBindConnectObjectDcmp(jnt):
sgBFunction_attribute.addAttr(jnt,
ln='bindConnectObject',
at='message')
cons = cmds.listConnections(jnt + '.bindConnectObject', d=1, s=0)
if not cons:
bindConnectObject = cmds.createNode('transform',
n='BindCObj_' + jnt)
sgBFunction_attribute.addAttr(bindConnectObject,
ln='bindConnectObject_target',
at='message')
cmds.connectAttr(jnt + '.bindConnectObject',
bindConnectObject + '.bindConnectObject_target')
cmds.parent(bindConnectObject, jnt)
else:
bindConnectObject = cons[0]
cons = cmds.listConnections(bindConnectObject + '.wm',
type='decomposeMatrix')
if not cons:
dcmp = cmds.createNode('decomposeMatrix')
cmds.connectAttr(bindConnectObject + '.wm', dcmp + '.imat')
else:
dcmp = cons[0]
cmds.xform(bindConnectObject,
ws=1,
matrix=sgBModel_data.getDefaultMatrix())
return dcmp
def setEyeRotation(topJoint, closeValue=40):
import sgBFunction_attribute
childJnts = cmds.listRelatives(topJoint, c=1, f=1)
leftChild = ''
rightChild = ''
for child in childJnts:
if cmds.xform(child, q=1, os=1, t=1)[0] > 0:
leftChild = child
else:
rightChild = child
lfAnim = cmds.createNode('animCurveUA')
rfAnim = cmds.createNode('animCurveUA')
sgBFunction_attribute.addAttr(topJoint, ln='closeL', min=0, max=1, k=1)
sgBFunction_attribute.addAttr(topJoint, ln='closeR', min=0, max=1, k=1)
cmds.connectAttr(topJoint + '.closeL', lfAnim + '.input')
cmds.connectAttr(topJoint + '.closeR', rfAnim + '.input')
cmds.setKeyframe(lfAnim, f=0, v=0)
cmds.setKeyframe(lfAnim, f=1, v=closeValue)
cmds.setKeyframe(rfAnim, f=0, v=0)
cmds.setKeyframe(rfAnim, f=1, v=closeValue)
cmds.connectAttr(lfAnim + '.output', leftChild + '.rotateX')
cmds.connectAttr(rfAnim + '.output', rightChild + '.rotateX')
def setEyeRotation( topJoint, closeValue = 40 ):
import sgBFunction_attribute
childJnts = cmds.listRelatives( topJoint, c=1, f=1 )
leftChild = ''
rightChild = ''
for child in childJnts:
if cmds.xform( child, q=1, os=1, t=1 )[0] > 0:
leftChild = child
else:
rightChild = child
lfAnim = cmds.createNode( 'animCurveUA' )
rfAnim = cmds.createNode( 'animCurveUA' )
sgBFunction_attribute.addAttr( topJoint, ln='closeL', min=0, max=1, k=1 )
sgBFunction_attribute.addAttr( topJoint, ln='closeR', min=0, max=1, k=1 )
cmds.connectAttr( topJoint+'.closeL', lfAnim+'.input' )
cmds.connectAttr( topJoint+'.closeR', rfAnim+'.input' )
cmds.setKeyframe( lfAnim, f=0, v=0 )
cmds.setKeyframe( lfAnim, f=1, v=closeValue )
cmds.setKeyframe( rfAnim, f=0, v=0 )
cmds.setKeyframe( rfAnim, f=1, v=closeValue )
cmds.connectAttr( lfAnim+'.output', leftChild +'.rotateX' )
cmds.connectAttr( rfAnim+'.output', rightChild+'.rotateX' )
def createWorldBlendTwoMatrixObject( first, second, target = None ):
import sgBFunction_attribute
blMtx = cmds.createNode( 'blendTwoMatrix' )
mmdc = cmds.createNode( 'multMatrixDecompose' )
cmds.connectAttr( first+'.wm', blMtx+'.inMatrix1' )
cmds.connectAttr( second+'.wm', blMtx+'.inMatrix2' )
cmds.connectAttr( blMtx+'.outMatrix', mmdc+'.i[0]' )
if not target: target = cmds.createNode( 'transform' )
cmds.connectAttr( target+'.pim', mmdc+'.i[1]' )
sgBFunction_attribute.addAttr( target, ln='blend', min=0, max=1, dv=0.5, k=1 )
cmds.connectAttr( target+'.blend', blMtx+'.attributeBlender' )
if not cmds.isConnected( mmdc+'.ot', target+'.t' ):
cmds.connectAttr( mmdc+'.ot', target+'.t', f=1 )
if not cmds.isConnected( mmdc+'.or', target+'.r' ):
cmds.connectAttr( mmdc+'.or', target+'.r', f=1 )
if not cmds.isConnected( mmdc+'.os', target+'.s' ):
cmds.connectAttr( mmdc+'.os', target+'.s', f=1 )
if not cmds.isConnected( mmdc+'.osh', target+'.sh' ):
cmds.connectAttr( mmdc+'.osh', target+'.sh', f=1 )
cmds.select( blMtx, target )
return blMtx, target
def followMatrixConnection( ctl, others ):
import sgBFunction_attribute
ctlP = cmds.listRelatives( ctl, p=1 )[0]
followMatrix = cmds.createNode( 'followMatrix' )
mmdc = cmds.createNode( 'multMatrixDecompose' )
cmds.connectAttr( others[0]+'.wm', followMatrix+'.originalMatrix' )
sgBFunction_attribute.addAttr( ctl, ln='_______', at='enum', en='Parent:', cb=1 )
for other in others[1:]:
i = others.index( other ) - 1
cmds.connectAttr( other+'.wm', followMatrix+'.inputMatrix[%d]' % i )
attrName = 'parent' + other.split( '_' )[-1]
print other, attrName
sgBFunction_attribute.addAttr( ctl, ln= attrName, min=0, max=10, k=1 )
cmds.connectAttr( ctl+'.'+attrName, followMatrix+'.inputWeight[%d]' % i )
cmds.connectAttr( followMatrix+'.outputMatrix', mmdc+'.i[0]' )
cmds.connectAttr( ctlP+'.pim', mmdc+'.i[1]' )
cmds.connectAttr( mmdc+'.ot', ctlP+'.t' )
cmds.connectAttr( mmdc+'.or', ctlP+'.r' )
def removeUiSeparateView( cam ):
import sgBFunction_attribute
import sgBFunction_dag
uiPrefix = 'separatedViewCam_'
uis = cmds.lsUI( wnd=1 )
for ui in uis:
if not len( ui ) > len( uiPrefix ): continue
if ui[ : len( uiPrefix ) ] != uiPrefix: continue
cmds.deleteUI( ui, wnd=1 )
if not cmds.objExists( cam ): return None
for cam in cmds.ls( type='camera' ):
if not cmds.objExists( cam ): continue
cam = sgBFunction_dag.getTransform( cam )
sgBFunction_attribute.addAttr( cam, ln='filmTranslateCams', at='message' )
sgBFunction_attribute.addAttr( cam, ln='aniamtionCam', at='message' )
cons1 = cmds.listConnections( cam+'.filmTranslateCams', d=1, s=0 )
cons2 = cmds.listConnections( cam+'.aniamtionCam', d=1, s=0 )
if cons1: cmds.delete( cons1 )
if cons2: cmds.delete( cons2 )
def createLocalBlendTwoMatrixObject( first, second, target = None ):
import sgBFunction_attribute
blMtx = cmds.createNode( 'blendTwoMatrixDecompose' )
cmds.connectAttr( first+'.m', blMtx+'.inMatrix1' )
cmds.connectAttr( second+'.m', blMtx+'.inMatrix2' )
if not target: target = cmds.createNode( 'transform' )
sgBFunction_attribute.addAttr( target, ln='blend', min=0, max=1, dv=0.5, k=1 )
cmds.connectAttr( target+'.blend', blMtx+'.attributeBlender' )
if cmds.nodeType( target ) == 'joint':
try:cmds.setAttr( target+'.jo', 0,0,0 )
except:pass
if not cmds.isConnected( blMtx+'.ot', target+'.t' ):
cmds.connectAttr( blMtx+'.ot', target+'.t', f=1 )
if not cmds.isConnected( blMtx+'.or', target+'.r' ):
cmds.connectAttr( blMtx+'.or', target+'.r', f=1 )
if not cmds.isConnected( blMtx+'.os', target+'.s' ):
cmds.connectAttr( blMtx+'.os', target+'.s', f=1 )
if not cmds.isConnected( blMtx+'.osh', target+'.sh' ):
cmds.connectAttr( blMtx+'.osh', target+'.sh', f=1 )
cmds.select( blMtx, target )
return blMtx, target
def removeUiSeparateView(cam):
import sgBFunction_attribute
import sgBFunction_dag
uiPrefix = 'separatedViewCam_'
uis = cmds.lsUI(wnd=1)
for ui in uis:
if not len(ui) > len(uiPrefix): continue
if ui[:len(uiPrefix)] != uiPrefix: continue
cmds.deleteUI(ui, wnd=1)
if not cmds.objExists(cam): return None
for cam in cmds.ls(type='camera'):
if not cmds.objExists(cam): continue
cam = sgBFunction_dag.getTransform(cam)
sgBFunction_attribute.addAttr(cam,
ln='filmTranslateCams',
at='message')
sgBFunction_attribute.addAttr(cam, ln='aniamtionCam', at='message')
cons1 = cmds.listConnections(cam + '.filmTranslateCams', d=1, s=0)
cons2 = cmds.listConnections(cam + '.aniamtionCam', d=1, s=0)
if cons1: cmds.delete(cons1)
if cons2: cmds.delete(cons2)
def makeCloneObject2( target, replaceName=['SOURCENAME_', 'TARGETNAME_'], **options ):
import sgBModel_dag
import sgBFunction_attribute
import sgBFunction_value
import sgBFunction_connection
op_cloneAttrName = None
op_shapeOn = None
op_connectionOn = None
op_cloneAttrName = sgBFunction_value.getValueFromDict( options, 'cloneAttrName' )
op_shapeOn = sgBFunction_value.getValueFromDict( options, 'shapeOn' )
op_connectionOn = sgBFunction_value.getValueFromDict( options, 'connectionOn' )
if op_cloneAttrName:
attrName = op_cloneAttrName
else:
attrName = sgBModel_dag.cloneTargetAttrName
targets = getParents( target )
targets.append( target )
targetCloneParent = None
for cuTarget in targets:
sgBFunction_attribute.addAttr( cuTarget, ln=attrName, at='message' )
cloneConnection = cmds.listConnections( cuTarget+'.'+attrName, s=1, d=0 )
if not cloneConnection:
print "replaceName : ", cuTarget.split( '|' )[-1].replace( replaceName[0], replaceName[1] )
targetClone = cmds.createNode( 'transform', n= cuTarget.split( '|' )[-1].replace( replaceName[0], replaceName[1] ) )
cmds.connectAttr( targetClone+'.message', cuTarget+'.'+attrName )
if op_shapeOn:
cuTargetShape = getShape( cuTarget )
if cuTargetShape:
duObj = cmds.duplicate( cuTarget, n=targetClone+'_du' )[0]
duShape = cmds.listRelatives( duObj, s=1, f=1 )[0]
duShape = cmds.parent( duShape, targetClone, add=1, shape=1 )[0]
cmds.delete( duObj )
cmds.rename( duShape, targetClone+'Shape' )
if op_connectionOn:
sgBFunction_connection.getSourceConnection( cuTarget, targetClone )
cuTargetShape = getShape( cuTarget )
targetCloneShape = getShape( targetClone )
if cuTargetShape and targetCloneShape:
sgBFunction_connection.getSourceConnection( cuTargetShape, targetCloneShape )
else:
targetClone = cloneConnection[0]
targetCloneParentExpected = getParent( targetClone )
if cmds.ls( targetCloneParentExpected ) != cmds.ls( targetCloneParent ) and targetCloneParent:
targetClone = cmds.parent( targetClone, targetCloneParent )[0]
cuTargetPos = cmds.getAttr( cuTarget+'.m' )
cmds.xform( targetClone, os=1, matrix=cuTargetPos )
targetCloneParent = targetClone
return targetCloneParent
def setKeyCurveMatrixObjects( curves, mtxObj ):
import sgBFunction_attribute
sgBFunction_attribute.addAttr( mtxObj, ln='keyCurveTarget', at='message' )
for curve in curves:
sgBFunction_attribute.addAttr( curve, ln='mtxObj_forKeyCurve', at='message' )
if cmds.isConnected( mtxObj + '.keyCurveTarget', curve + '.mtxObj_forKeyCurve' ): continue
cmds.connectAttr( mtxObj + '.keyCurveTarget', curve + '.mtxObj_forKeyCurve', f=1 )
def getGlobalAttr(self):
import sgBFunction_attribute
globalValueAttrs = cmds.ls( '*.' + WinA_Global.globalValueAttr )
if not globalValueAttrs:
cmds.undoInfo( swf=1 )
node = cmds.createNode( 'addDoubleLinear' )
sgBFunction_attribute.addAttr( node, ln= WinA_Global.globalValueAttr )
globalValueAttrs = [node + '.' + WinA_Global.globalValueAttr]
return globalValueAttrs[0]
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 addMultDoubleLinearConnection( sel, attr ):
import sgBFunction_attribute
newAttrName = 'mult_' + attr
sgBFunction_attribute.addAttr( sel, ln=newAttrName, cb=1, dv=1 )
multDouble = cmds.createNode( 'multDoubleLinear' )
separateParentConnection( sel, attr )
cons = cmds.listConnections( sel + '.' + attr, s=1, d=0, p=1, c=1 )
cmds.connectAttr( cons[1], multDouble+'.input1' )
cmds.connectAttr( sel+'.'+newAttrName, multDouble + '.input2' )
cmds.connectAttr( multDouble + '.output', sel+'.'+attr, f=1 )
def addMultDoubleLinearConnection(sel, attr):
import sgBFunction_attribute
newAttrName = 'mult_' + attr
sgBFunction_attribute.addAttr(sel, ln=newAttrName, cb=1, dv=1)
multDouble = cmds.createNode('multDoubleLinear')
separateParentConnection(sel, attr)
cons = cmds.listConnections(sel + '.' + attr, s=1, d=0, p=1, c=1)
cmds.connectAttr(cons[1], multDouble + '.input1')
cmds.connectAttr(sel + '.' + newAttrName, multDouble + '.input2')
cmds.connectAttr(multDouble + '.output', sel + '.' + attr, f=1)
def createSquashObject( distTarget, distBase, scaleTarget ):
import sgBFunction_attribute
import sgBFunction_base
import math
scaleTargetMtx = cmds.getAttr( scaleTarget+'.wm' )
xVector = om.MVector( *scaleTargetMtx[0:3] )
yVector = om.MVector( *scaleTargetMtx[4:4+3] )
zVector = om.MVector( *scaleTargetMtx[8:8+3] )
targetPos = cmds.xform( distTarget, q=1, ws=1, t=1 )
basePos = cmds.xform( distBase, q=1, ws=1, t=1 )
aimVector = om.MVector( targetPos[0] - basePos[0], targetPos[1] - basePos[1], targetPos[2] - basePos[2] )
vectors = [ xVector, yVector, zVector ]
maxDotValue = 0
aimIndex = 0
for i in range( 3 ):
dotValue = math.fabs( aimVector * vectors[i] )
if dotValue > maxDotValue:
maxDotValue = dotValue
aimIndex = i
print "max dot value : ", maxDotValue
otherIndex1 = ( aimIndex + 1 ) % 3
otherIndex2 = ( aimIndex + 2 ) % 3
sgBFunction_base.autoLoadPlugin( 'sgLocusChRig' )
mmdc = cmds.createNode( 'multMatrixDecompose' )
cmds.connectAttr( distTarget+'.wm', mmdc+'.i[0]' )
cmds.connectAttr( distBase+'.wim', mmdc+'.i[1]' )
sgBFunction_attribute.addAttr( scaleTarget, ln='distanceDefault', k=1 )
sgBFunction_attribute.addAttr( scaleTarget, ln='distanceCurrent', cb=1 )
sgBFunction_attribute.addAttr( scaleTarget, ln='squashRate', k=1 )
sgBFunction_attribute.addAttr( scaleTarget, ln='forceScale', k=1 )
cmds.connectAttr( mmdc+'.outputDistance', scaleTarget+'.distanceCurrent', f=1 )
cmds.setAttr( scaleTarget+'.distanceDefault', cmds.getAttr( mmdc+'.outputDistance' ) )
squashNode = cmds.createNode( 'squash' )
divNode = cmds.createNode( 'multiplyDivide' )
cmds.setAttr( divNode+'.operation', 2 )
cmds.connectAttr( scaleTarget+'.distanceDefault', squashNode+'.lengthOriginal' )
cmds.connectAttr( scaleTarget+'.distanceCurrent', squashNode+'.lengthModify' )
cmds.connectAttr( scaleTarget+'.distanceDefault', divNode+'.input2X' )
cmds.connectAttr( scaleTarget+'.distanceCurrent', divNode+'.input1X' )
axisChar = ['X', 'Y', 'Z' ]
cmds.connectAttr( squashNode+'.output', scaleTarget+'.scale%s' % axisChar[ otherIndex1 ] )
cmds.connectAttr( squashNode+'.output', scaleTarget+'.scale%s' % axisChar[ otherIndex2 ] )
cmds.connectAttr( divNode+'.outputX', scaleTarget+'.scale%s' % axisChar[ aimIndex ] )
cmds.connectAttr( scaleTarget+'.squashRate', squashNode+'.squashRate' )
cmds.connectAttr( scaleTarget+'.forceScale', squashNode+'.forceValue' )
def setKeyCurveMatrixObjects(curves, mtxObj):
import sgBFunction_attribute
sgBFunction_attribute.addAttr(mtxObj, ln='keyCurveTarget', at='message')
for curve in curves:
sgBFunction_attribute.addAttr(curve,
ln='mtxObj_forKeyCurve',
at='message')
if cmds.isConnected(mtxObj + '.keyCurveTarget',
curve + '.mtxObj_forKeyCurve'):
continue
cmds.connectAttr(mtxObj + '.keyCurveTarget',
curve + '.mtxObj_forKeyCurve',
f=1)
def ctlVisConnection( ctl, targets, attrName = 'ctlVis' ):
import sgBFunction_attribute
sgBFunction_attribute.addAttr( ctl, ln=attrName, min=0, max=1, at='long', k=1 )
for target in targets:
targetP = cmds.listRelatives( target, p=1, f=1 )[0]
if not cmds.isConnected( ctl+'.'+attrName, target+'.v' ):
try:
cmds.connectAttr( ctl+'.'+attrName, target+'.v' )
except:
if not cmds.isConnected( ctl+'.'+attrName, targetP+'.v' ):
try:cmds.connectAttr( ctl+'.'+attrName, targetP+'.v' )
except:pass
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 createWristAngle( rotBase, target ):
import sgBFunction_attribute
targetP = cmds.listRelatives( target, p=1, f=1 )[0]
mm = cmds.createNode( 'multMatrix' )
wa = cmds.createNode( 'wristAngle' )
cmds.connectAttr( rotBase+'.wm', mm+'.i[0]' )
cmds.connectAttr( targetP+'.wim', mm+'.i[1]' )
cmds.connectAttr( mm+'.matrixSum', wa+'.inputMatrix' )
cmds.connectAttr( wa+'.outAngle', target+'.rx' )
sgBFunction_attribute.addAttr( target, ln='wristAngle_Rate', cb=1, dv=1 )
sgBFunction_attribute.addAttr( target, ln='wristAngle_Axis', cb=1, at='enum', el=':X:Y:Z' )
cmds.connectAttr( target+'.wristAngle_Rate', wa+'.angleRate' )
cmds.connectAttr( target+'.wristAngle_Axis', wa+'.axis' )
def translateBlend_toAimTarget( target, aimTarget ):
targetP = cmds.listRelatives( target, p=1, f=1 )[0]
blendNode = cmds.createNode( 'blendTwoAttr' )
mmdc = cmds.createNode( 'multMatrixDecompose' )
cmds.connectAttr( aimTarget+'.wm', mmdc+'.i[0]' )
cmds.connectAttr( targetP+'.pim', mmdc+'.i[1]' )
sgBFunction_attribute.addAttr( target, ln='origTx', k=1, dv= cmds.getAttr( mmdc+'.otx' ) )
sgBFunction_attribute.addAttr( targetP, ln='blend', min=0, max=1, dv=0.5, k=1 )
cmds.connectAttr( target+'.origTx', blendNode+'.input[0]' )
cmds.connectAttr( mmdc+'.otx', blendNode+'.input[1]' )
cmds.connectAttr( targetP+'.blend', blendNode+'.attributesBlender' )
cmds.connectAttr( blendNode+'.output', target+'.tx' )
def getConstrainedObject( target, constLabel = '_coned' ):
import sgBModel_dag
import sgBFunction_attribute
import sgBFunction_connection
attrName = sgBModel_dag.constrainedTargetAttrName
sgBFunction_attribute.addAttr( target, ln= attrName, at='message' )
connections = cmds.listConnections( target+'.'+attrName, s=1, d=0 )
if not connections:
constTarget = cmds.createNode( 'transform', n= target.split( '|' )[-1].replace( ':', '_' ) + constLabel )
cmds.connectAttr( constTarget+'.message', target+'.'+attrName )
sgBFunction_connection.constraintAll( target, constTarget )
else:
constTarget = connections[0]
return constTarget
def getConstrainedObject(target, constLabel='_coned'):
import sgBModel_dag
import sgBFunction_attribute
import sgBFunction_connection
attrName = sgBModel_dag.constrainedTargetAttrName
sgBFunction_attribute.addAttr(target, ln=attrName, at='message')
connections = cmds.listConnections(target + '.' + attrName, s=1, d=0)
if not connections:
constTarget = cmds.createNode(
'transform',
n=target.split('|')[-1].replace(':', '_') + constLabel)
cmds.connectAttr(constTarget + '.message', target + '.' + attrName)
sgBFunction_connection.constraintAll(target, constTarget)
else:
constTarget = connections[0]
return constTarget
def getBindConnectObjectDcmp( jnt ):
sgBFunction_attribute.addAttr( jnt, ln='bindConnectObject', at='message' )
cons = cmds.listConnections( jnt+'.bindConnectObject', d=1, s=0 )
if not cons:
bindConnectObject = cmds.createNode( 'transform', n= 'BindCObj_' + jnt )
sgBFunction_attribute.addAttr( bindConnectObject, ln='bindConnectObject_target', at='message' )
cmds.connectAttr( jnt+'.bindConnectObject', bindConnectObject+'.bindConnectObject_target' )
cmds.parent( bindConnectObject, jnt )
else:
bindConnectObject = cons[0]
cons = cmds.listConnections( bindConnectObject+'.wm', type='decomposeMatrix' )
if not cons:
dcmp = cmds.createNode( 'decomposeMatrix' )
cmds.connectAttr( bindConnectObject+'.wm', dcmp+'.imat' )
else:
dcmp = cons[0]
cmds.xform( bindConnectObject, ws=1, matrix=sgBModel_data.getDefaultMatrix() )
return dcmp
def addModification( meshObjs ):
import sgBFunction_attribute
import sgBFunction_dag
meshObjs = sgBFunction_dag.getChildrenMeshExists( meshObjs )
softMod = cmds.deformer( meshObjs, type='softMod' )[0]
ctlGrp = cmds.createNode( 'transform' )
cmds.setAttr( ctlGrp+'.dh', 1 )
dcmp = cmds.createNode( 'decomposeMatrix' )
ctl = cmds.sphere()[0]
ctl = cmds.parent( ctl, ctlGrp )[0]
sgBFunction_attribute.addAttr( ctl, ln='__________', at='enum', enumName = ':Modify Attr', cb=1 )
sgBFunction_attribute.addAttr( ctl, ln='falloffRadius', min=0, dv=1, k=1 )
sgBFunction_attribute.addAttr( ctl, ln='envelope', min=0, max=1, dv=1, k=1 )
cmds.connectAttr( ctlGrp+'.wim', softMod+'.bindPreMatrix' )
cmds.connectAttr( ctlGrp+'.wm', softMod+'.preMatrix' )
cmds.connectAttr( ctl+'.wm', softMod+'.matrix' )
cmds.connectAttr( ctl+'.m', softMod+'.weightedMatrix' )
cmds.connectAttr( ctlGrp+'.wm', dcmp+'.imat' )
cmds.connectAttr( dcmp+'.ot', softMod+'.falloffCenter' )
for i in range( len( meshObjs ) ):
cmds.connectAttr( meshObjs[i]+'.wm', softMod+'.geomMatrix[%d]' % i )
cmds.connectAttr( ctl+'.envelope', softMod+'.envelope' )
cmds.connectAttr( ctl+'.falloffRadius', softMod+'.falloffRadius' )
cmds.xform( ctlGrp, ws=1, t=cmds.getAttr( meshObjs[0]+'.wm' )[-4:-1] )
cmds.select( ctlGrp )
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 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 createFollowMatrixObject( base, targets, attrName='followWeight' ):
import sgBFunction_attribute
followMatrix = cmds.createNode( 'followMatrix' )
mmdc = cmds.createNode( 'multMatrixDecompose' )
cmds.connectAttr( base+'.wm', followMatrix+'.originalMatrix' )
for other in targets:
i = targets.index( other )
cmds.connectAttr( other+'.wm', followMatrix+'.inputMatrix[%d]' % i )
addAttrName = attrName + '_' + other.split( '_' )[-1]
sgBFunction_attribute.addAttr( base, ln= addAttrName, min=0, max=10, k=1 )
cmds.connectAttr( base+'.'+addAttrName, followMatrix+'.inputWeight[%d]' % i )
followTarget = cmds.createNode( 'transform' )
cmds.connectAttr( followMatrix+'.outputMatrix', mmdc+'.i[0]' )
cmds.connectAttr( followTarget+'.pim', mmdc+'.i[1]' )
cmds.connectAttr( mmdc+'.ot', followTarget+'.t' )
cmds.connectAttr( mmdc+'.or', followTarget+'.r' )
def ctlVisConnection(ctl, targets, attrName='ctlVis'):
import sgBFunction_attribute
sgBFunction_attribute.addAttr(ctl,
ln=attrName,
min=0,
max=1,
at='long',
k=1)
for target in targets:
targetP = cmds.listRelatives(target, p=1, f=1)[0]
if not cmds.isConnected(ctl + '.' + attrName, target + '.v'):
try:
cmds.connectAttr(ctl + '.' + attrName, target + '.v')
except:
if not cmds.isConnected(ctl + '.' + attrName, targetP + '.v'):
try:
cmds.connectAttr(ctl + '.' + attrName, targetP + '.v')
except:
pass
def getDistanceAttribute( first, second ):
import sgBFunction_attribute
sgBFunction_attribute.addAttr( second, ln='dist_orig', cb=1 )
sgBFunction_attribute.addAttr( second, ln='dist_current', cb=1 )
sgBFunction_attribute.addAttr( second, ln='dist_stretchValue', cb=1 )
mmdc = cmds.createNode( 'multMatrixDecompose' )
mult = cmds.createNode( 'multiplyDivide' )
cmds.setAttr( mult+'.op', 2 )
cmds.connectAttr( first+'.wm', mmdc+'.i[0]' )
cmds.connectAttr( second+'.wim', mmdc+'.i[1]' )
cmds.connectAttr( mmdc+'.outputDistance', mult+'.input1X' )
cmds.setAttr( mult+'.input2X', cmds.getAttr( mmdc+'.outputDistance' ) )
cmds.connectAttr( mult+'.outputX', second+'.dist_stretchValue' )
cmds.setAttr( second+'.dist_orig', cmds.getAttr( mmdc+'.outputDistance' ) )
cmds.connectAttr( mmdc+'.outputDistance', second+'.dist_current' )
def addPositionBasedController(controller, relative=True):
import sgBFunction_connection
import sgBFunction_attribute
import sgCFnc_connection
controllerName = controller.split('|')[-1]
controllerP = cmds.listRelatives(controller, p=1, f=1)[0]
replaceObj = cmds.createNode('transform', n=controllerName + '_replace')
replaceObj = cmds.parent(replaceObj, controllerP)[0]
cmds.xform(replaceObj, ws=1, matrix=cmds.getAttr(controller + '.wm'))
sgBFunction_connection.getSourceConnection(controller, replaceObj)
outputCons, inputCons = sgCFnc_connection.getSourceConnection(controller)
for i in range(len(outputCons)):
cmds.disconnectAttr(outputCons[i], inputCons[i])
locC = cmds.createNode('transform', n='locC')
locCR = cmds.createNode('transform', n='locCR')
locCS = cmds.createNode('transform', n='locCS')
loc = cmds.spaceLocator()[0]
locP = cmds.group(loc)
pivCtl = cmds.createNode('transform')
cmds.setAttr(pivCtl + '.dh', 1)
locBase = cmds.group(locP, pivCtl)
locC, locCR, locCS = cmds.parent(locC, locCR, locCS, loc)
cmds.connectAttr(pivCtl + '.t', locP + '.t')
cmds.connectAttr(pivCtl + '.r', locP + '.r')
cmds.connectAttr(pivCtl + '.s', locP + '.s')
cmds.connectAttr(pivCtl + '.sh', locP + '.sh')
mmdcLocCR = cmds.createNode('multMatrixDecompose')
cmds.connectAttr(locBase + '.wm', mmdcLocCR + '.i[0]')
cmds.connectAttr(pivCtl + '.wim', mmdcLocCR + '.i[1]')
cmds.connectAttr(mmdcLocCR + '.ot', locCR + '.t')
cmds.connectAttr(mmdcLocCR + '.or', locCR + '.r')
cmds.connectAttr(mmdcLocCR + '.os', locCR + '.s')
cmds.connectAttr(mmdcLocCR + '.osh', locCR + '.sh')
mmdcLocCS = cmds.createNode('multMatrixDecompose')
cmds.connectAttr(replaceObj + '.wm', mmdcLocCS + '.i[0]')
cmds.connectAttr(loc + '.wim', mmdcLocCS + '.i[1]')
cmds.connectAttr(mmdcLocCS + '.ot', locCS + '.t')
cmds.connectAttr(mmdcLocCS + '.or', locCS + '.r')
cmds.connectAttr(mmdcLocCS + '.os', locCS + '.s')
cmds.connectAttr(mmdcLocCS + '.osh', locCS + '.sh')
blendMtx = cmds.createNode('blendTwoMatrixDecompose')
blendCS = cmds.createNode('blendColors')
blendCSH = cmds.createNode('blendColors')
mmdcOutput = cmds.createNode('multMatrixDecompose')
cmds.connectAttr(locCR + '.s', blendCS + '.color1')
cmds.connectAttr(locCS + '.s', blendCS + '.color2')
cmds.connectAttr(locCR + '.sh', blendCSH + '.color1')
cmds.connectAttr(locCS + '.sh', blendCSH + '.color2')
cmds.connectAttr(locCS + '.m', blendMtx + '.inMatrix1')
cmds.connectAttr(locCR + '.m', blendMtx + '.inMatrix2')
cmds.connectAttr(blendMtx + '.ot', locC + '.t')
cmds.connectAttr(blendMtx + '.or', locC + '.r')
cmds.connectAttr(blendCS + '.output', locC + '.s')
cmds.connectAttr(blendCSH + '.output', locC + '.sh')
cmds.connectAttr(locC + '.wm', mmdcOutput + '.i[0]')
cmds.connectAttr(controller + '.pim', mmdcOutput + '.i[1]')
cmds.connectAttr(mmdcOutput + '.ot', controller + '.t')
cmds.connectAttr(mmdcOutput + '.or', controller + '.r')
cmds.connectAttr(mmdcOutput + '.os', controller + '.s')
cmds.connectAttr(mmdcOutput + '.osh', controller + '.sh')
sgBFunction_attribute.addAttr(loc, ln='blend', min=0, max=1, dv=1, k=1)
cmds.connectAttr(loc + '.blend', blendMtx + '.attributeBlender')
cmds.connectAttr(loc + '.blend', blendCS + '.blender')
cmds.connectAttr(loc + '.blend', blendCSH + '.blender')
if relative: sgBFunction_connection.constraintAll(replaceObj, locBase)
else: cmds.xform(locBase, ws=1, matrix=cmds.getAttr(replaceObj + '.wm'))
def addAngleDriverAttribute( sel ):
import sgBFunction_attribute
sgBFunction_attribute.addAttr( sel, ln='angleRate0', cb=1 )
sgBFunction_attribute.addAttr( sel, ln='angleRate1', cb=1 )
sgBFunction_attribute.addAttr( sel, ln='angleRate2', cb=1 )
if cmds.listConnections( sel, s=1, d=0, type='angleDriver' ): return None
selP = cmds.listRelatives( sel, p=1, f=1 )[0]
selName = sel.split( '|' )[-1]
targetDriver = cmds.createNode( 'angleDriver', n= 'angleDriver_' + selName )
mm = cmds.createNode( 'multMatrix', n='mm_' + selName )
base = cmds.createNode( 'transform', n= 'angleBase_' + selName )
base = cmds.parent( base, selP )[0]
cmds.xform( base, ws=1, matrix= cmds.getAttr( sel+'.wm' ) )
cmds.connectAttr( sel+'.wm', mm+'.i[0]' )
cmds.connectAttr( base+'.wim', mm+'.i[1]' )
cmds.connectAttr( mm+'.matrixSum', targetDriver+'.angleMatrix' )
sgBFunction_attribute.addAttr( sel, ln='angleRate0', cb=1 )
sgBFunction_attribute.addAttr( sel, ln='angleRate1', cb=1 )
sgBFunction_attribute.addAttr( sel, ln='angleRate2', cb=1 )
if not cmds.isConnected( targetDriver+'.outDriver0', sel+'.angleRate0' ):
cmds.connectAttr( targetDriver+'.outDriver0', sel+'.angleRate0' )
if not cmds.isConnected( targetDriver+'.outDriver1', sel+'.angleRate1' ):
cmds.connectAttr( targetDriver+'.outDriver1', sel+'.angleRate1' )
if not cmds.isConnected( targetDriver+'.outDriver2', sel+'.angleRate2' ):
cmds.connectAttr( targetDriver+'.outDriver2', sel+'.angleRate2' )
def makeCloneObject2(target,
replaceName=['SOURCENAME_', 'TARGETNAME_'],
**options):
import sgBModel_dag
import sgBFunction_attribute
import sgBFunction_value
import sgBFunction_connection
op_cloneAttrName = None
op_shapeOn = None
op_connectionOn = None
op_cloneAttrName = sgBFunction_value.getValueFromDict(
options, 'cloneAttrName')
op_shapeOn = sgBFunction_value.getValueFromDict(options, 'shapeOn')
op_connectionOn = sgBFunction_value.getValueFromDict(
options, 'connectionOn')
if op_cloneAttrName:
attrName = op_cloneAttrName
else:
attrName = sgBModel_dag.cloneTargetAttrName
targets = getParents(target)
targets.append(target)
targetCloneParent = None
for cuTarget in targets:
sgBFunction_attribute.addAttr(cuTarget, ln=attrName, at='message')
cloneConnection = cmds.listConnections(cuTarget + '.' + attrName,
s=1,
d=0)
if not cloneConnection:
print "replaceName : ", cuTarget.split('|')[-1].replace(
replaceName[0], replaceName[1])
targetClone = cmds.createNode('transform',
n=cuTarget.split('|')[-1].replace(
replaceName[0], replaceName[1]))
cmds.connectAttr(targetClone + '.message',
cuTarget + '.' + attrName)
if op_shapeOn:
cuTargetShape = getShape(cuTarget)
if cuTargetShape:
duObj = cmds.duplicate(cuTarget, n=targetClone + '_du')[0]
duShape = cmds.listRelatives(duObj, s=1, f=1)[0]
duShape = cmds.parent(duShape, targetClone, add=1,
shape=1)[0]
cmds.delete(duObj)
cmds.rename(duShape, targetClone + 'Shape')
if op_connectionOn:
sgBFunction_connection.getSourceConnection(
cuTarget, targetClone)
cuTargetShape = getShape(cuTarget)
targetCloneShape = getShape(targetClone)
if cuTargetShape and targetCloneShape:
sgBFunction_connection.getSourceConnection(
cuTargetShape, targetCloneShape)
else:
targetClone = cloneConnection[0]
targetCloneParentExpected = getParent(targetClone)
if cmds.ls(targetCloneParentExpected) != cmds.ls(
targetCloneParent) and targetCloneParent:
targetClone = cmds.parent(targetClone, targetCloneParent)[0]
cuTargetPos = cmds.getAttr(cuTarget + '.m')
cmds.xform(targetClone, os=1, matrix=cuTargetPos)
targetCloneParent = targetClone
return targetCloneParent
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
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 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 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 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 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
def addPositionBasedController( controller, relative=True ):
import sgBFunction_connection
import sgBFunction_attribute
import sgCFnc_connection
controllerName = controller.split( '|' )[-1]
controllerP = cmds.listRelatives( controller, p=1, f=1 )[0]
replaceObj = cmds.createNode( 'transform', n=controllerName + '_replace' )
replaceObj = cmds.parent( replaceObj, controllerP )[0]
cmds.xform( replaceObj, ws=1, matrix= cmds.getAttr( controller+'.wm' ) )
sgBFunction_connection.getSourceConnection( controller, replaceObj )
outputCons, inputCons = sgCFnc_connection.getSourceConnection( controller )
for i in range( len( outputCons ) ):
cmds.disconnectAttr( outputCons[i], inputCons[i] )
locC = cmds.createNode( 'transform', n='locC' )
locCR = cmds.createNode( 'transform', n='locCR' )
locCS = cmds.createNode( 'transform', n='locCS' )
loc = cmds.spaceLocator()[0]
locP = cmds.group( loc )
pivCtl = cmds.createNode( 'transform' );cmds.setAttr( pivCtl + '.dh', 1 )
locBase = cmds.group( locP, pivCtl )
locC, locCR, locCS = cmds.parent( locC, locCR, locCS, loc )
cmds.connectAttr( pivCtl + '.t', locP + '.t' )
cmds.connectAttr( pivCtl + '.r', locP + '.r' )
cmds.connectAttr( pivCtl + '.s', locP + '.s' )
cmds.connectAttr( pivCtl + '.sh', locP + '.sh' )
mmdcLocCR = cmds.createNode( 'multMatrixDecompose' )
cmds.connectAttr( locBase + '.wm', mmdcLocCR + '.i[0]' )
cmds.connectAttr( pivCtl + '.wim', mmdcLocCR + '.i[1]' )
cmds.connectAttr( mmdcLocCR + '.ot', locCR + '.t' )
cmds.connectAttr( mmdcLocCR + '.or', locCR + '.r' )
cmds.connectAttr( mmdcLocCR + '.os', locCR + '.s' )
cmds.connectAttr( mmdcLocCR + '.osh', locCR + '.sh' )
mmdcLocCS = cmds.createNode( 'multMatrixDecompose' )
cmds.connectAttr( replaceObj + '.wm', mmdcLocCS + '.i[0]' )
cmds.connectAttr( loc + '.wim', mmdcLocCS + '.i[1]' )
cmds.connectAttr( mmdcLocCS + '.ot', locCS + '.t' )
cmds.connectAttr( mmdcLocCS + '.or', locCS + '.r' )
cmds.connectAttr( mmdcLocCS + '.os', locCS + '.s' )
cmds.connectAttr( mmdcLocCS + '.osh', locCS + '.sh' )
blendMtx = cmds.createNode( 'blendTwoMatrixDecompose' )
blendCS = cmds.createNode( 'blendColors' )
blendCSH = cmds.createNode( 'blendColors' )
mmdcOutput = cmds.createNode( 'multMatrixDecompose' )
cmds.connectAttr( locCR + '.s', blendCS + '.color1' )
cmds.connectAttr( locCS + '.s', blendCS + '.color2' )
cmds.connectAttr( locCR + '.sh', blendCSH + '.color1' )
cmds.connectAttr( locCS + '.sh', blendCSH + '.color2' )
cmds.connectAttr( locCS + '.m', blendMtx + '.inMatrix1' )
cmds.connectAttr( locCR + '.m', blendMtx + '.inMatrix2' )
cmds.connectAttr( blendMtx + '.ot', locC + '.t' )
cmds.connectAttr( blendMtx + '.or', locC + '.r' )
cmds.connectAttr( blendCS + '.output', locC + '.s' )
cmds.connectAttr( blendCSH + '.output', locC + '.sh' )
cmds.connectAttr( locC + '.wm', mmdcOutput + '.i[0]' )
cmds.connectAttr( controller+'.pim', mmdcOutput + '.i[1]' )
cmds.connectAttr( mmdcOutput + '.ot', controller+'.t' )
cmds.connectAttr( mmdcOutput + '.or', controller+'.r' )
cmds.connectAttr( mmdcOutput + '.os', controller+'.s' )
cmds.connectAttr( mmdcOutput + '.osh', controller+'.sh' )
sgBFunction_attribute.addAttr( loc, ln='blend', min=0, max=1, dv=1, k=1 )
cmds.connectAttr( loc + '.blend', blendMtx + '.attributeBlender' )
cmds.connectAttr( loc + '.blend', blendCS + '.blender' )
cmds.connectAttr( loc + '.blend', blendCSH + '.blender' )
if relative: sgBFunction_connection.constraintAll( replaceObj, locBase )
else: cmds.xform( locBase, ws=1, matrix= cmds.getAttr( replaceObj + '.wm' ) )
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)
