def markingMenuSet( rigInstance ):
ctls = cmds.ls( '*_CTL' )
rObj = cmds.createNode( 'multDoubleLinear', n='RightClickObj_Rigs' )
attrEdit = rigbase.AttrEdit( rObj )
attrEdit.addAttr( ln='originalName', dt='string' )
cmds.setAttr( rObj+'.originalName', rObj, type='string' )
attrEdit = rigbase.AttrEdit( rObj )
for ctl in ctls:
attrEdit.addAttr( ln=ctl, at='message' )
cmds.connectAttr( ctl+'.message', rObj+'.'+ctl )
rigbase.AttrEdit( 'World_CTL' ).addAttr( ln=rObj, at='message' )
cmds.connectAttr( rObj+'.message', 'World_CTL.'+rObj )
bjts = cmds.ls( '*_BJT' )
bjts.append( 'BJT_World' )
rObj = cmds.createNode( 'multDoubleLinear', n='RightClickObj_Bjts' )
attrEdit = rigbase.AttrEdit( rObj )
attrEdit.addAttr( ln='originalName', dt='string' )
cmds.setAttr( rObj+'.originalName', rObj, type='string' )
attrEdit = rigbase.AttrEdit( rObj )
for bjt in bjts:
attrEdit.addAttr( ln=bjt, at='message' )
cmds.connectAttr( bjt+'.message', rObj+'.'+bjt )
rigbase.AttrEdit( 'BJT_World' ).addAttr( ln=rObj, at='message' )
cmds.connectAttr( rObj+'.message', 'BJT_World.'+rObj )
def switch(node,attr,value=0,inputNames=list(),inputValues=list()):
'''
:param node:
:param attr:
:param value:
:param inputName:
:param inputValues:
:return:
'''
attrName = "{0}.{1}".format(node,attr)
choiceName = "{0}_{1}_switch".format(node,attr)
cmds.createNode("choice",name=choiceName)
cmds.addAttr(node,ln=attr,at="enum",en=":".join(inputNames),dv=value,keyable=True)
for i in range(len(inputValues)):
choiceAttr = "output{0}".format(i)
cmds.addAttr(choiceName,ln=choiceAttr,at="double3")
cmds.addAttr(choiceName,ln="{0}x".format(choiceAttr),at="double",p=choiceAttr,dv=inputValues[i][0])
cmds.addAttr(choiceName,ln="{0}y".format(choiceAttr),at="double",p=choiceAttr,dv=inputValues[i][1])
cmds.addAttr(choiceName,ln="{0}z".format(choiceAttr),at="double",p=choiceAttr,dv=inputValues[i][2])
cmds.connectAttr("{0}.{1}".format(choiceName,choiceAttr),"{0}.input[{1}]".format(choiceName,i))
cmds.connectAttr(attrName,"{0}.selector".format(choiceName),f=True)
return "{0}.output".format(choiceName)
def add_target(self, name):
cmds.select(self.main_jnt)
jnt = cmds.joint(name=self.name + "_" + name + "_target_jnt")
cmds.setAttr(jnt + ".t" + self.axis, 1.0)
cmds.addAttr(jnt, ln="cone_angle", at="double", keyable=1, maxValue=360, minValue=0)
cmds.addAttr(jnt, ln="pose_weight", at="double")
norm_vp = cmds.createNode("vectorProduct", name=self.name + "_" + name + "normalize_vp")
cmds.connectAttr(jnt + ".t", norm_vp + ".input1")
cmds.setAttr(norm_vp + ".normalizeOutput", 1)
cmds.setAttr(norm_vp + ".operation", 0)
dot_vp = cmds.createNode("vectorProduct", name=self.name + "_" + name + "dot_vp")
cmds.connectAttr(norm_vp + ".output", dot_vp + ".input1")
cmds.connectAttr(self.reader_jnt + ".t", dot_vp + ".input2")
cmds.setAttr(dot_vp + ".normalizeOutput", 1)
angle_rv = cmds.createNode("remapValue", name=self.name + "_" + name + "_angle_rv")
cmds.connectAttr(jnt + ".cone_angle", angle_rv + ".inputValue")
cmds.setAttr(angle_rv + ".value[0].value_FloatValue", 1)
cmds.setAttr(angle_rv + ".value[1].value_FloatValue", -1)
cmds.setAttr(angle_rv + ".inputMax", 360.0)
rv = cmds.createNode("remapValue", name=self.name + "_" + name + "_rv")
# cmds.connectAttr(jnt + '.cone_angle', rv + '.value[0].value_Position')
cmds.connectAttr(angle_rv + ".outValue", rv + ".value[0].value_Position")
cmds.connectAttr(dot_vp + ".outputX", rv + ".inputValue")
cmds.connectAttr(rv + ".outValue", jnt + ".pose_weight")
def aimObjectConnect( targets ):
for i in range( len( targets ) -1 ):
first = targets[i]
second = targets[i+1]
grp = cmds.createNode( 'transform', n=second+'_aimObj_GRP' )
trg = cmds.createNode( 'transform', n=second+'_aimObj' )
cmds.parent( trg, grp )
constraint( first, grp )
localMtx = cmds.createNode( 'multMatrixDecompose', n=second+'_localMtx' )
fbfMtx = cmds.createNode( 'fourByFourMatrix', n=second+'_fbfMtx' )
shdOrt = cmds.createNode( 'shoulderOrient', n=second+'_shdOrt' )
cmds.connectAttr( second+'.wm', localMtx+'.i[0]' )
cmds.connectAttr( first+'.wim', localMtx+'.i[1]' )
cmds.connectAttr( localMtx+'.otx', fbfMtx+'.i00' )
cmds.connectAttr( localMtx+'.oty', fbfMtx+'.i01' )
cmds.connectAttr( localMtx+'.otz', fbfMtx+'.i02' )
cmds.connectAttr( fbfMtx+'.output', shdOrt+'.inputMatrix' )
cmds.connectAttr( shdOrt+'.outAngleX', trg+'.rx' )
cmds.connectAttr( shdOrt+'.outAngleY', trg+'.ry' )
cmds.connectAttr( shdOrt+'.outAngleZ', trg+'.rz' )
def create_line_from_2_obj(self, obja, objb, crv_name='_curve_CRV'):
'''
Desc:
Make a line between 2 objects
Parameter:
crv_name = name of curve
pta = first object
ptb = second object
Return: Curve name
'''
# Define generic curve
curve=cmds.curve(d=1, p=[(0,0,0),(0,0,0)], k=[0,1], n=crv_name)
cmds.setAttr(curve+'.overrideEnabled',1)
cmds.setAttr(curve+'.overrideColor', 13)
# Making connection in worldSpace using decomposeMatrix
dMa=cmds.createNode('decomposeMatrix', n='_DMAT')
dMb=cmds.createNode('decomposeMatrix', n='_DMAT')
# Connect control worldMatrix to decomposeMatrix.inputMatrix
KstMaya.node_op(obja+'.worldMatrix','>>', dMa+'.inputMatrix')
KstMaya.node_op(dMa+'.outputTranslate','>>',curve+'.controlPoints[0]')
KstMaya.node_op(objb+'.worldMatrix','>>', dMb+'.inputMatrix')
KstMaya.node_op(dMb+'.outputTranslate','>>',curve+'.controlPoints[1]')
return curve
def blendAttrs(targ1=None, targ2=None, driven=None, blendAttr=None, translate=1, rotate=1):
'''
sets up blending of translation / rotation values from targs 1 & 2 on the driven node.
If a blendAttr is supplied, this is connected to the blender value
'''
if not targ1 and not targ2 and not driven:
if len(cmds.ls(sl=1)) == 3:
targ1 = cmds.ls(sl=1)[0]
targ2 = cmds.ls(sl=1)[1]
driven = cmds.ls(sl=1)[2]
else:
return showDialog( 'Argument Error', 'Please supply or select targ1, targ2 and driven nodes' )
if translate:
t_bc = cmds.createNode('blendColors', name='%s_translate_bc' % driven)
cmds.connectAttr('%s.t' % targ2, '%s.color1' % t_bc)
cmds.connectAttr('%s.t' % targ1, '%s.color2' % t_bc)
if blendAttr:
cmds.connectAttr(blendAttr, '%s.blender' % t_bc)
cmds.connectAttr('%s.output' % t_bc, '%s.t' % driven)
if rotate:
r_bc = cmds.createNode('blendColors', name='%s_rotate_bc' % driven)
cmds.connectAttr('%s.rotate' % targ2, '%s.color1' % r_bc)
cmds.connectAttr('%s.rotate' % targ1, '%s.color2' % r_bc)
if blendAttr:
cmds.connectAttr(blendAttr, '%s.blender' % r_bc)
cmds.connectAttr('%s.output' % r_bc, '%s.rotate' % driven)
def createSplineCurveInfo( curve, number, **options ):
crvShape = cmds.listRelatives( curve, s=1 )
if not crvShape: return None
crvShape = crvShape[0]
splineNode = cmds.createNode( 'splineCurveInfo', n=curve+'_spline' )
cmds.connectAttr( crvShape+'.local', splineNode+'.inputCurve' )
if number <= 1:
return None
elif number > 1:
eachRate = 1.0/(number-1)
for i in range( number ):
cmds.setAttr( splineNode+'.parameter[%d]' % i, eachRate*i+0.001 )
for i in range( number-1 ):
trNode = cmds.createNode( 'transform' )
cmds.connectAttr( splineNode+'.output[%d].position' % i, trNode+'.t' )
cmds.connectAttr( splineNode+'.output[%d].rotate' % i, trNode+'.r' )
cmds.parent( trNode, curve )
cmds.setAttr( trNode+'.dh', 1 )
cmds.setAttr( trNode+'.dla', 1 )
return splineNode
def reverseObj(self , name , one , another):
#--------------------------------------------------------------------------------------#
#note : this two object's axial must be consistent and matched for world !
#--------------------------------------------------------------------------------------#
if name=='':
pass
else:
name = name+'_'
#--------------------------------------------------------------------------------------#
tranNode = mc.createNode( 'multiplyDivide' , n = name+one+'to'+another+'_reverseTran_md')
rotaNode = mc.createNode( 'multiplyDivide' , n = name+one+'to'+another+'_reverseRota_md')
unlock=[ '.tx' , '.ty' , '.tz' , '.rx' , '.ry' , '.rz' ]
for x in unlock:
mc.setAttr(another+x , lock=False)
#reverse tanslate value.
mc.setAttr( '%s.input2X'%(tranNode) , -1 )
mc.connectAttr( '%s.tx'%(one) , '%s.input1X'%(tranNode) )
mc.connectAttr( '%s.ty'%(one) , '%s.input1Y'%(tranNode) )
mc.connectAttr( '%s.tz'%(one) , '%s.input1Z'%(tranNode) )
mc.connectAttr( '%s.outputX'%(tranNode) , '%s.tx'%(another) )
mc.connectAttr( '%s.outputY'%(tranNode) , '%s.ty'%(another) )
mc.connectAttr( '%s.outputZ'%(tranNode) , '%s.tz'%(another) )
#reverse rotate value.
mc.setAttr( '%s.input2Y'%(rotaNode) , -1 )
mc.setAttr( '%s.input2Z'%(rotaNode) , -1 )
mc.connectAttr( '%s.rx'%(one) , '%s.input1X'%(rotaNode) )
mc.connectAttr( '%s.ry'%(one) , '%s.input1Y'%(rotaNode) )
mc.connectAttr( '%s.rz'%(one) , '%s.input1Z'%(rotaNode) )
mc.connectAttr( '%s.outputX'%(rotaNode) , '%s.rx'%(another) )
mc.connectAttr( '%s.outputY'%(rotaNode) , '%s.ry'%(another) )
mc.connectAttr( '%s.outputZ'%(rotaNode) , '%s.rz'%(another) )
def perform(**kwargs):
sel = cmds.ls(sl=True)
sel3=[]
for s in sel:
sel3+=cmds.xform(s,q=True, ws=True, t=True)
pointset=[]
for i in xrange(len(sel3)/3):
pointset+=[Vector(sel3[i*3],sel3[i*3+1],sel3[i*3+2])]
bbox = BBox()
bbox.obbFromPointSet(pointset)
t = Transform(bbox.axis[0],bbox.axis[1],bbox.axis[2])
t = t.transpose()
z = t.getEuler()
cube = cmds.createNode("polyCube")
cubeShape = cmds.createNode("mesh")
cubeTrans = cmds.listRelatives(cubeShape,p=True)[0]
cmds.connectAttr(cube+".output",cubeShape+".inMesh")
cmds.setAttr(cubeTrans+".tx",bbox.center[0])
cmds.setAttr(cubeTrans+".ty",bbox.center[1])
cmds.setAttr(cubeTrans+".tz",bbox.center[2])
cmds.setAttr(cubeTrans+".rz",degrees(z[2]))
cmds.setAttr(cubeTrans+".ry",degrees(z[1]))
cmds.setAttr(cubeTrans+".rx",degrees(z[0]))
cmds.setAttr(cube+".width",bbox.max[0]-bbox.min[0])
cmds.setAttr(cube+".height",bbox.max[1]-bbox.min[1])
cmds.setAttr(cube+".depth",bbox.max[2]-bbox.min[2])
cmds.sets(e=True,forceElement="initialShadingGroup")
cmds.select(sel)
def connectInit(self, inits ):
rigbase.connectSameAttr( inits[0], self.neckCtl.transformGrp ).doIt( 't', 'r' )
neckMiddleMtxDcmp = self.getMtxDcmpInNeckSet()
cmds.connectAttr( neckMiddleMtxDcmp+'.ot', self.neckMiddleCtl.transformGrp+'.t' )
cmds.connectAttr( neckMiddleMtxDcmp+'.or', self.neckMiddleCtl.transformGrp+'.r' )
headPosMtxDcmp = rigbase.getChildMtxDcmp( inits[2], inits[0] )
cmds.connectAttr( headPosMtxDcmp+'.ot', self.headCtl.transformGrp+'.t' )
cmds.connectAttr( headPosMtxDcmp+'.or', self.headCtl.transformGrp+'.r' )
eyeCenterMtx = cmds.createNode( 'blendTwoMatrixDecompose', n='EyeCenterMtx' )
eyeLMtxDcmp = cmds.createNode( 'multMatrixDecompose', n='Eye_L_MtxDcmp' )
eyeRMtxDcmp = cmds.createNode( 'multMatrixDecompose', n='Eye_R_MtxDcmp' )
eyeCenterObj = rigbase.Transform( n='EyeCenterObj' )
eyeCenterObj.setParent( self.headCtl )
eyeLInitTarget = rigbase.Transform( n='Eye_L_InitTarget' )
eyeRInitTarget = rigbase.Transform( n='Eye_R_InitTarget' )
eyeLInitTarget.setParent( self.headCtl )
eyeRInitTarget.setParent( self.headCtl )
rigbase.connectSameAttr( inits[3], eyeLInitTarget.name ).doIt( 't', 'r' )
rigbase.connectSameAttr( inits[4], eyeRInitTarget.name ).doIt( 't', 'r' )
cmds.connectAttr( eyeLInitTarget+'.m', eyeCenterMtx+'.inMatrix1' )
cmds.connectAttr( eyeRInitTarget+'.m', eyeCenterMtx+'.inMatrix2' )
cmds.connectAttr( eyeCenterMtx+'.ot', eyeCenterObj+'.t' )
cmds.connectAttr( eyeLInitTarget+'.wm', eyeLMtxDcmp+'.i[0]' )
cmds.connectAttr( eyeRInitTarget+'.wm', eyeRMtxDcmp+'.i[0]' )
cmds.connectAttr( eyeCenterObj+'.wim', eyeLMtxDcmp+'.i[1]' )
cmds.connectAttr( eyeCenterObj+'.wim', eyeRMtxDcmp+'.i[1]' )
cmds.connectAttr( eyeLMtxDcmp+'.ot', self.eyeLCtl.transformGrp+'.t' )
cmds.connectAttr( eyeRMtxDcmp+'.ot', self.eyeRCtl.transformGrp+'.t' )
cmds.connectAttr( inits[-1]+'.t', self.eyeCtl.transformGrp+'.t' )
def neckMiddleCtlSet(self):
self.neckMiddleCtl = rigbase.Controler( n='NeckMiddle_CTL' )
self.neckMiddleCtl.setShape( normal=[0,1,0], radius = .5 )
self.neckMiddleCtl.setColor( 29 )
self.middlePoint1 = rigbase.Transform( n='NeckMiddle_spline_Point1' )
self.middlePoint2 = rigbase.Transform( n='NeckMiddle_spline_Point2' )
self.middlePoint1.setParent( self.neckMiddleCtl )
self.middlePoint2.setParent( self.neckMiddleCtl )
rigbase.transformDefault( self.middlePoint1, self.middlePoint2 )
midPnt1Dist= cmds.createNode( 'distanceBetween', n='NeckMiddle_spPnt1_dist' )
midPnt2Dist = cmds.createNode( 'distanceBetween', n='NeckMiddle_spPnt2_dist' )
midMult1Dist = cmds.createNode( 'multDoubleLinear', n='NeckMiddle_md1' )
midMult2Dist = cmds.createNode( 'multDoubleLinear', n='NeckMiddle_md2' )
cmds.setAttr( midMult1Dist+'.input2', -.4 )
cmds.setAttr( midMult2Dist+'.input2', .4 )
cmds.connectAttr( self.neckMiddleInit+'.m', midPnt1Dist+'.inMatrix1' )
cmds.connectAttr( self.headInit+'.m', midPnt2Dist+'.inMatrix2' )
cmds.connectAttr( midPnt1Dist+'.distance', midMult1Dist+'.input1' )
cmds.connectAttr( midPnt2Dist+'.distance', midMult2Dist+'.input1' )
cmds.connectAttr( midMult1Dist+'.output', self.middlePoint1+'.ty' )
cmds.connectAttr( midMult2Dist+'.output', self.middlePoint2+'.ty' )
attrEdit = rigbase.AttrEdit( self.neckMiddleCtl.name )
attrEdit.lockAndHideAttrs( 'sx','sy','sz','v' )
self.rigInstance.neckMiddleCtl = self.neckMiddleCtl.name
def connection(vks, jt, jgroup):
"""
Establishes a connection between the vks control and one of the joints in the chain
"""
ucn_p = setup.onetenthNode(vks, 'position')
linstepA = cmds.createNode('setRange', n='setRangeA_%s' % jt)
cmds.setAttr('%s.minX' % linstepA, 1)
cmds.connectAttr('%s.parameter' % jt, '%s.valueX' % linstepA)
cmds.connectAttr('%s.maxPos' % vks, '%s.oldMaxX' % linstepA)
cmds.connectAttr('%s.output' % ucn_p, '%s.oldMinX' % linstepA)
linstepB = cmds.createNode('setRange', n='setRangeB_%s' % jt)
cmds.setAttr('%s.maxX' % linstepB, 1)
cmds.connectAttr('%s.parameter' % jt, '%s.valueX' % linstepB)
cmds.connectAttr('%s.minPos' % vks, '%s.oldMinX' % linstepB)
cmds.connectAttr('%s.output' % ucn_p, '%s.oldMaxX' % linstepB)
cond = cmds.createNode('condition', n='condition_%s' % jt)
cmds.setAttr('%s.operation' % cond, 2)
cmds.connectAttr('%s.parameter' % jt, '%s.firstTerm' % cond)
cmds.connectAttr('%s.output' % ucn_p, '%s.secondTerm' % cond)
cmds.connectAttr('%s.outValueX' % linstepA, '%s.colorIfTrueR' % cond)
cmds.connectAttr('%s.outValueX' % linstepB, '%s.colorIfFalseR' % cond)
mtp_r = cmds.createNode('multiplyDivide', n='multiplyRotate_%s' % jt)
cmds.connectAttr('%s.rotate' % vks, '%s.input1' % mtp_r)
cmds.connectAttr('%s.outColorR' % cond, '%s.input2X' % mtp_r)
cmds.connectAttr('%s.outColorR' % cond, '%s.input2Y' % mtp_r)
cmds.connectAttr('%s.outColorR' % cond, '%s.input2Z' % mtp_r)
cmds.connectAttr('%s.output' % mtp_r, '%s.rotate' % jgroup)
def ik_stretch(ikhnd):
'''
'''
jts = cmds.ikHandle(ikhnd, q=True, jl=True)
cu_s = cmds.ikHandle(ikhnd, q=True, c=True)
cu = cmds.listRelatives(cu_s, p=1)[0]
cmds.addAttr(ikhnd, longName='ik_stretch', k=1, defaultValue=1.0, minValue=0.0, maxValue=1.)
dcu = cmds.duplicate(cu, n=cu + '_base_scale')[0]
dcu_s = cmds.listRelatives(dcu, c=1)[0]
cf = cmds.createNode('curveInfo')
dcf = cmds.createNode('curveInfo')
bl = cmds.createNode('blendTwoAttr')
md = cmds.createNode('multiplyDivide')
cmds.connectAttr(cu_s + '.worldSpace', cf + '.inputCurve')
cmds.connectAttr(dcu_s + '.worldSpace', dcf + '.inputCurve')
cmds.connectAttr(dcf + '.arcLength', bl + '.input[0]')
cmds.connectAttr(cf + '.arcLength', bl + '.input[1]')
cmds.connectAttr(ikhnd + '.ik_stretch', bl + '.attributesBlender')
cmds.connectAttr(bl + '.output', md + '.input1X')
cmds.setAttr(md + '.input2X', cmds.getAttr(cf + '.arcLength'), l=1)
cmds.setAttr(md + '.operation', 2)
cmds.setAttr(dcu + '.v', 0)
for j in jts:
cmds.connectAttr(md + '.outputX', j + '.sx')
return dcu
def __init__(self):
TopInfo.__init__(self)
node = self.getRetargetNode_for( self._target )
self.originRate = node+'.originalRate'
self.source = node+'.sourceMatrix'
self.sourceOrig = node+'.sourceOrigMatrix'
self.sourceParent = node+'.sourceParentMatrix'
self.targetOrig = node+'.targetOrigMatrix'
self.targetParent = node+'.targetParentMatrix'
self.distRate = node+'.distanceRate'
self.localData = [ node+'.localData[0].localMatrix', node+'.localData[0].localOffset' ]
if self._transDirect:
transDirect = cmds.createNode( "multMatrixDecompose", n= self._target+'_transDirect' )
invNode = cmds.createNode( 'inverseMatrix', n= self._target+'_transDirect_origInv' )
multNode = cmds.createNode( 'multiplyDivide', n=self._target+'_transDirect_mult' )
cmds.connectAttr( self.source, transDirect+'.i[0]' )
cmds.connectAttr( self.sourceOrig, invNode+'.inputMatrix' )
cmds.connectAttr( invNode+'.outputMatrix', transDirect+'.i[1]' )
cmds.connectAttr( transDirect+'.ot', multNode+'.input1' )
cmds.connectAttr( self.distRate, multNode+'.input2X' )
cmds.connectAttr( self.distRate, multNode+'.input2Y' )
cmds.connectAttr( self.distRate, multNode+'.input2Z' )
cmds.connectAttr( multNode+'.outputX', self._target+'.tx', f=1 )
cmds.connectAttr( multNode+'.outputY', self._target+'.ty', f=1 )
cmds.connectAttr( multNode+'.outputZ', self._target+'.tz', f=1 )
def getRetargetNode_for( self, target ):
retargetBlenderCons = cmds.listConnections( target, s=1, d=0, type='retargetBlender' )
if not retargetBlenderCons:
retargetBlender = cmds.createNode( 'retargetBlender', n= target+'_retargetBlender' )
sourceName = target.replace( self._targetNS, self._sourceNS )
retargetNode = cmds.createNode( 'retargetTransNode', n= sourceName+'_RTTrans' )
self.blenderToControl( retargetBlender, target )
if cmds.nodeType( target ) == 'joint':
fnc.tryConnect( target+'.jo', retargetBlender+'.orient' )
cmds.connectAttr( retargetNode+'.transMatrix', retargetBlender+'.input[0].transMatrix' )
else:
retargetBlender = retargetBlenderCons[0]
fnc.clearArrayElement( retargetBlender+'.input' )
cuIndex = fnc.getLastIndex( retargetBlender+'.input' )
if cuIndex == -1: cuIndex = 0
retargetTransCons = cmds.listConnections( retargetBlender+'.input[%d].transMatrix ' % cuIndex )
if retargetTransCons: cuIndex += 1
sourceName = target.replace( self._targetNS, self._sourceNS )
retargetNode = cmds.createNode( 'retargetTransNode', n= sourceName+'_RTTrans' )
cmds.connectAttr( retargetNode+'.transMatrix', retargetBlender+'.input[%d].transMatrix' % cuIndex )
return retargetNode
def importCache( mesh, xmlFilePath ):
mesh = sgModelDag.getShape( mesh )
xmlFileSplits = xmlFilePath.split( '/' )
cachePath = '/'.join( xmlFileSplits[:-1] )
cacheName = xmlFileSplits[-1].split( '.' )[0]
deformer = cmds.createNode( 'historySwitch' )
cacheNode = cmds.createNode( 'cacheFile' )
cmds.connectAttr( cacheNode+'.outCacheData[0]', deformer+'.inPositions[0]')
cmds.connectAttr( cacheNode+'.inRange', deformer+'.playFromCache' )
cmds.connectAttr( 'time1.outTime', cacheNode+'.time' )
cmds.setAttr( cacheNode+'.cachePath', cachePath, type='string' )
cmds.setAttr( cacheNode+'.cacheName', cacheName, type='string' )
#print "xml filePath : ", xmlFilePath
startFrame, endFrame = sgModelData.getStartAndEndFrameFromXmlFile( xmlFilePath )
cmds.playbackOptions( animationStartTime = startFrame, animationEndTime= endFrame,
minTime = startFrame+5, maxTime= endFrame-5 )
cmds.setAttr( cacheNode+'.startFrame', startFrame )
cmds.setAttr( cacheNode+'.sourceStart', startFrame )
cmds.setAttr( cacheNode+'.sourceEnd', endFrame )
cmds.setAttr( cacheNode+'.originalStart', startFrame )
cmds.setAttr( cacheNode+'.originalEnd', endFrame )
origMesh = sgModelDag.getOrigShape( mesh )
if not origMesh: return None
cmds.connectAttr( origMesh+'.worldMesh', deformer+'.undeformedGeometry[0]' )
cmds.connectAttr( deformer+'.outputGeometry[0]', mesh+'.inMesh', f=1 )
def pfxHairScaleConnect( ctl, hairSystemGrp ):
hairSystems = cmds.listRelatives( hairSystemGrp, c=1, ad=1, type='hairSystem' )
def getMultDoubleLinear( attr ):
multNodes = cmds.listConnections( attr, type='multDoubleLinear', s=1, d=0 )
if not multNodes:
multNode = cmds.createNode( 'multDoubleLinear' )
sgRigAttribute.addAttr( multNode, ln='clumpWidthMult', at='message' )
attrValue = cmds.getAttr( attr )
cmds.setAttr( multNode+'.input1', attrValue )
cmds.connectAttr( multNode+'.output', attr )
return multNode
else:
if not cmds.attributeQuery( 'clumpWidthMult', node=multNodes[0], ex=1 ):
multNode = cmds.createNode( 'multDoubleLinear' )
sgRigAttribute.addAttr( multNode, ln='clumpWidthMult', at='message' )
attrValue = cmds.getAttr( attr )
cmds.setAttr( multNode+'.input1', attrValue )
cmds.connectAttr( multNode+'.output', attr )
return multNode
else:
return multNodes[0]
for hairSystem in hairSystems:
dcmp = cmds.createNode( 'decomposeMatrix' )
multNode = cmds.createNode( 'multDoubleLinear' )
cmds.connectAttr( ctl+'.wm', dcmp+'.imat' )
cmds.connectAttr( dcmp+'.osx', multNode+'.input1' )
cmds.setAttr( multNode+'.input2', cmds.getAttr( hairSystem+'.clumpWidth' ) )
cmds.connectAttr( multNode+'.output', hairSystem+'.clumpWidth' )
def closestPointOnModel(self , modelShape , obj):
closest_Point = []
modelShapeType = self.getObjType(modelShape)
temp = mc.createNode('transform',name=obj+'_point_temp')
mc.parentConstraint(obj,temp,mo = False)
#model type data
if modelShapeType == 'kNurbsSurface':
closest_Point = ['closestPointOnSurface' , temp+'_cpos' , 'local' , 'inputSurface']
elif modelShapeType == 'kMesh':
closest_Point = ['closestPointOnMesh' , temp+'_cpom' , 'outMesh' , 'inMesh']
#create getUV Node
closest_PointNode = mc.createNode( closest_Point[0] , name = closest_Point[1] )
mc.connectAttr( temp+'.translate' , closest_PointNode+'.inPosition' )
mc.connectAttr( modelShape + '.' + closest_Point[2] , closest_PointNode +'.' + closest_Point[3] )
#get UV
U = mc.getAttr(closest_PointNode + '.result.parameterU')
V = mc.getAttr(closest_PointNode + '.result.parameterV')
mc.delete(closest_PointNode,temp)
return {'u':U , 'v':V}
def create(baseCrv,curveList,inMeshList,prefix):
'''
Create standard copyMeshToCurve setup based on the input arguments
@param baseCrv: Base curve
@type baseCrv: str
@param curveList: List of curves to copy mesh to
@type curveList: list
@param inMeshList: List of meshes to copy to curves
@type inMeshList: list
@param prefix: Naming prefix
@type prefix: str
'''
# Create copyMeshToCurve node
copyMeshToCurve = mc.createNode('copyMeshToCurve',n=prefix+'_copyMeshToCurve')
# Connect base curve
mc.connectAttr(baseCrv+'.worldSpace[0]',copyMeshToCurve+'.baseCurve',f=True)
# Connect input curves
connectInputCurves(copyMeshToCurve,curveList)
# Connect input mesh
connectInputMesh(copyMeshToCurve,inMeshList)
# Create output mesh
outMeshShape = mc.createNode('mesh',n=prefix+'_outMeshShape')
outMesh = mc.listRelatives(outMeshShape,p=True)[0]
mc.rename(outMesh,prefix+'_outMesh')
# Connect out mesh
mc.connectAttr(copyMeshToCurve+'.outputMesh',outMeshShape+'.inMesh',f=True)
# Return Reult
return copyMeshToCurve
def postProcessControl ( _control, _function, _controlled ): # <<< string, string, list
lockHideAttributes ( _control )
if (cmds.objExists('anim_control_set') == False): cmds.createNode('objectSet',name='anim_control_set',skipSelect=True)
cmds.sets ( _control, addElement = 'anim_control_set' )
cmds.toggle ( localAxis = 1 )
if len ( _controlled ) == 0:
_control = cmds.rename ( '_' + _function + '_control' )
_control = cmds.group ( world = 1, name = '_' + _function + '_control_offSet' )
cmds.move ( 0, 0, 0, _control + '.rotatePivot', _control + '.scalePivot' )
lockHideAttributes ( _control )
else:
_k = _controlled[0].rfind ( '|' )
_control = _controlled[0][_k+1:]
cmds.rename ( _control + '_' + _function + '_control' )
_control = cmds.group ( world = 1, name = _control + '_' + _function + '_control_offSet' )
cmds.move ( 0, 0, 0, _control + '.rotatePivot', _control + '.scalePivot' )
lockHideAttributes ( _control )
cmds.select ( _controlled[0], toggle = True )
cmds.parent ()
cmds.xform ( translation = ( 0, 0, 0 ), rotation = ( 0, 0, 0 ) )
cmds.parent ( world = 1 )
cmds.pickWalk ( direction = "down" )
def setupStrechy ():
# >>> get IK from selection, get start/end joints & IK curve, determine strechy joints
_IK = cmds.ls (selection = True)[0]
_IKcurve = cmds.listConnections (_IK + '.inCurve', destination = True)[0]
_startJoint = cmds.listConnections (_IK + '.startJoint', destination = True)[0]
_endEffector = cmds.listConnections (_IK + '.endEffector', destination = True)[0]
_endJoint = cmds.listConnections (_endEffector + '.translateX', destination = True)[0]
cmds.select (_endJoint, hierarchy = True)
_jointsTrash = cmds.ls (selection = True)
cmds.select (_startJoint, hierarchy = True)
_strachyJoints_ = cmds.ls (selection = True)
_strachyJoints_ = _strachyJoints_[:len (_strachyJoints_) - len (_jointsTrash)-1]
# >>> setup utility nodes
_curveInfo = cmds.arclen (_IKcurve, constructionHistory = True)
_condtition = cmds.createNode ('condition')
_startLength = cmds.getAttr (_curveInfo + '.arcLength')
_currentLength = cmds.createNode ('multiplyDivide')
cmds.setAttr (_currentLength + '.operation', 2)
cmds.setAttr (_currentLength + '.input2X', _startLength)
cmds.setAttr (_condtition + '.firstTerm', _startLength)
cmds.setAttr (_condtition + '.operation', 4)
cmds.connectAttr (_curveInfo + '.arcLength', _currentLength + '.input1X', force = True)
cmds.connectAttr (_curveInfo + '.arcLength', _condtition + '.secondTerm', force = True)
cmds.connectAttr (_currentLength + '.outputX', _condtition + '.colorIfTrueR', force = True)
# >>> connect calculated scale to joints
for _j in _strachyJoints_:
cmds.connectAttr (_condtition + '.outColorR', _j + '.scaleX', force = True)
def createWristAngleJoints( orientObject ):
import sgBFunction_dag
orientObjP = sgBFunction_dag.getParent( orientObject )
orientObjectName = orientObject.split( '|' )[-1]
if cmds.nodeType( orientObject ) == 'joint':
baseJointRad = cmds.getAttr( orientObject+'.radius' )
else:
baseJointRad = 1
cmds.select( orientObjP )
zJoint = cmds.joint( n = orientObjectName+'_waZ', radius = baseJointRad * 1.5 )
yJoint = cmds.joint( n = orientObjectName+'_waY', radius = baseJointRad * 2.0 )
xJoint = cmds.joint( n = orientObjectName+'_waX', radius = baseJointRad * 2.5 )
waz = cmds.createNode( 'wristAngle', n='WA_Z_' + orientObjectName )
way = cmds.createNode( 'wristAngle', n='WA_Y_' + orientObjectName )
wax = cmds.createNode( 'wristAngle', n='WA_X_' + orientObjectName )
cmds.connectAttr( orientObject+'.m', waz+'.inputMatrix' )
cmds.setAttr( waz+'.axis', 2 )
cmds.connectAttr( waz+'.outAngle', zJoint+'.rotateZ' )
mm = getMultMatrixAsParenting( orientObject, zJoint )
cmds.connectAttr( mm+'.o', way+'.inputMatrix' )
cmds.setAttr( way+'.axis', 1 )
cmds.connectAttr( way+'.outAngle', yJoint+'.rotateY' )
mm = getMultMatrixAsParenting( orientObject, yJoint )
cmds.connectAttr( mm+'.o', wax+'.inputMatrix' )
cmds.setAttr( wax+'.axis', 0 )
cmds.connectAttr( wax+'.outAngle', xJoint+'.rotateX' )
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 createAimObjectCmd( first, second, third, worldPosition=False ):
aimObjectMatrix = cmds.createNode( 'aimObjectMatrix' )
cmds.connectAttr( first+'.wm', aimObjectMatrix+'.targetMatrix' )
cmds.connectAttr( second+'.wm', aimObjectMatrix+'.baseMatrix' )
if third:
aimObject = third
else:
aimObject = cmds.createNode( 'transform' )
if cmds.nodeType( aimObject ) == 'joint':
try: cmds.setAttr( aimObject+'.jo', 0,0,0 )
except:pass
cmds.connectAttr( aimObjectMatrix+'.outRotate', aimObject+'.r' )
if not third: cmds.parent( aimObject, second )
cmds.setAttr( aimObject+'.t', 0,0,0 )
if worldPosition:
cmds.setAttr( aimObjectMatrix+'.worldSpaceOutput', 1 )
cmds.connectAttr( aimObject+'.pim', aimObjectMatrix+'.parentInverseMatrix' )
cmds.connectAttr( aimObjectMatrix+'.outTranslate', aimObject+'.t' )
cmds.parent( aimObject, w=1 )
return aimObject, aimObjectMatrix
def getWristAngleNode( target, targetBase=None ):
wristAngleCons = cmds.listConnections( target+'.m', s=0, d=1, type='wristAngle' )
wristAngleNode = ''
if not wristAngleCons:
mmCons = cmds.listConnections( target+'.wm', s=0, d=1, type='multMatrix' )
if mmCons:
wristAngleCons = cmds.listConnections( mmCons[0]+'.o', s=0, d=1, type='wristAngle' )
if wristAngleCons: wristAngleNode = wristAngleCons[0]
else:
wristAngleNode = wristAngleCons[0]
if wristAngleNode: return wristAngleNode
wa = cmds.createNode( 'wristAngle' )
if not targetBase:
targetBase = cmds.listRelatives( target, p=1, f=1 )[0]
cmds.connectAttr( target+'.m', wa+'.inputMatrix' )
else:
mm = cmds.createNode( 'multMatrix' )
cmds.connectAttr( target+'.wm', mm+'.i[0]' )
cmds.connectAttr( targetBase+'.wim', mm+'.i[1]' )
cmds.connectAttr( mm+'.o', wa+'.inputMatrix' )
cmds.select( wa )
return wa
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 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 chimaAddWingBsh() : # Add wing blend shapes to bird character cmd = 'file -import -type "mayaAscii" -rpr "geo_1" -options "v=0" -pr -loadReferenceDepth "all" "Y:/USERS/Peck/projs/chimaWingFold/geo_1.ma";' mm.eval( cmd ) mc.select( 'wingFoldLFT_bsh' , r=True ) mc.select( 'wingFoldLFT_bsh' , add=True ) cmd = 'blendShape -e -t Eggbert_wings_geo 2 wingFoldLFT_bsh 1 -t Eggbert_wings_geo 3 wingFoldRGT_bsh 1 wings_bls;' mm.eval( cmd ) rootCtrl = 'Pelvis_Ctrl' mc.addAttr( rootCtrl , ln='L_wingFoldB' , k=True , min=0 , max=10 ) mc.addAttr( rootCtrl , ln='R_wingFoldB' , k=True , min=0 , max=10 ) lMdv = mc.createNode( 'multDoubleLinear' , n='wingFoldBBshLFT_mdv' ) mc.connectAttr( '%s.L_wingFoldB' % rootCtrl , '%s.i1' % lMdv ) mc.setAttr( '%s.i2' % lMdv , 0.1 ) mc.connectAttr( '%s.o' % lMdv , 'wings_bls.wingFoldLFT_bsh' ) rMdv = mc.createNode( 'multDoubleLinear' , n='wingFoldBBshRGT_mdv' ) mc.connectAttr( '%s.R_wingFoldB' % rootCtrl , '%s.i1' % rMdv ) mc.setAttr( '%s.i2' % rMdv , 0.1 ) mc.connectAttr( '%s.o' % rMdv , 'wings_bls.wingFoldRGT_bsh' ) mc.delete( 'wingFold_bsh' ) mc.delete( 'wingOrig_bsh' ) mc.delete( 'wingFoldLFT_bsh' ) mc.delete( 'wingFoldRGT_bsh' )
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 patch():
facialDrv = 'facialDrivers'
eyeMaskOrig = 'eyeMask_ctrl_orig'
JawClenchLOrig = 'Jaw_Clench_l_ctrl_orig'
JawClenchROrig = 'Jaw_Clench_r_ctrl_orig'
UpHeadGuide = 'UpHead_ctrl_GUIDE_01'
UpHeadOrig = 'UpHead_ctrl_01_orig'
UpHeadCtrl = 'UpHead_ctrl_01'
LowerHeadGuide = 'LowerHead_ctrl_GUIDE_01'
LowerHeadOrig = 'LowerHead_ctrl_01_orig'
LowerHeadCtrl = 'LowerHead_ctrl_01'
mouthSquashOrig = 'mouthSquash_jnt_orig'
foreheadGrp = 'forehead_grp'
headSKN = 'head_SKN'
jawctrl = 'jaw_ctrl'
noseGrp = 'nose_grp'
noseUp = 'nose_up_ctrl'
sneerTip = 'sneer_tip_ctrl'
CUpperLip = 'C_upper_lip_ctrl'
CUpperLipSideDkey = 'C_lipFlap_ctrl_01_dKeyAll_side'
sides = ['L', 'R', 'C']
lipFlapOrig = 'lipFlap_ctrl_01_orig'
lipflapAll = 'lipFlap_all_ctrl'
lipflapTip = 'lipFlap_tip_ctrl'
lipflapCup = 'lipFlap_cup_ctrl'
lipFlapList = [lipflapAll, lipflapTip, lipflapCup]
allFlapsWeigts = [
'lipFlap_all_inOut', 'lipFlap_all_UpDn', 'lipFlap_all_bwFw',
'lipFlap_all_rotX', 'lipFlap_all_rotY', 'lipFlap_all_rotZ'
]
tipFlapsWeigts = [
'lipFlap_tip_inOut', 'lipFlap_tip_UpDn', 'lipFlap_tip_bwFw',
'lipFlap_tip_rotX', 'lipFlap_tip_rotY', 'lipFlap_tip_rotZ'
]
flapWeightsList = [allFlapsWeigts, tipFlapsWeigts]
transformListBcs = [
'translateX', 'translateY', 'translateZ', 'outValueX', 'outValueY',
'outValueZ'
]
bcsNode = mc.ls('*_bcs', type='DPK_bcs')[0]
#reparent cups inside flaps All
for side in sides:
mc.parent('%s_%s_orig' % (side, lipflapCup),
'%s_%s' % (side, lipflapAll))
# create drivenKeys on all dKeys nodes
dKeyTrVals = [-2, 0, 2]
dKeyRoVals = [-180, 0, 180]
dKeyValsList = [dKeyTrVals, dKeyRoVals]
axisList = ['X', 'Y', 'Z']
transformList = ['translate', 'rotate']
if mc.objExists('tempSaveGrp'):
dKeyAllNodesList = eval(mc.getAttr('tempSaveGrp.dKeyAllNodesList'))
dKeyTipNodesList = eval(mc.getAttr('tempSaveGrp.dKeyTipNodesList'))
## create dKeys on dKeyAll nodes
for s, side in enumerate(sides):
slaveNum = len(dKeyAllNodesList[s])
ctrlName = '%s_%s' % (side, lipflapAll)
targetList = dKeyAllNodesList[s]
for t, transform in enumerate(transformList):
for a, axis in enumerate(axisList):
for r, target in enumerate(targetList):
valuesDivider = len(targetList)
if transform == 'rotate':
mc.setAttr('%s.%s%s' % (ctrlName, transform, axis),
0)
for value in dKeyValsList[t]:
mc.setAttr(
'%s.%s%s' % (ctrlName, transform, axis),
value)
mc.setAttr(
'%s.%s%s' % (target, transform, axis),
value / (valuesDivider / 2))
mc.setDrivenKeyframe(
target,
at='%s%s' % (transform, axis),
cd='%s.%s%s' % (ctrlName, transform, axis))
mc.setAttr('%s.%s' % (ctrlName, transform), 0, 0,
0)
elif transform == 'translate':
trFactor = mc.getAttr('%s_orig.scale' %
ctrlName)[0]
if not axis == 'Y':
if r > 0:
pass
else:
mc.setAttr(
'%s.%s%s' %
(ctrlName, transform, axis), 0)
for value in dKeyValsList[t]:
mc.setAttr(
'%s.%s%s' %
(ctrlName, transform, axis), value)
mc.setAttr(
'%s.%s%s' %
(target, transform, axis),
value * abs(trFactor[a]))
mc.setDrivenKeyframe(
target,
at='%s%s' % (transform, axis),
cd='%s.%s%s' %
(ctrlName, transform, axis))
mc.setAttr('%s.%s' % (ctrlName, transform),
0, 0, 0)
else:
mc.setAttr(
'%s.%s%s' % (ctrlName, transform, axis), 0)
for value in dKeyValsList[t]:
mc.setAttr(
'%s.%s%s' %
(ctrlName, transform, axis), value)
mc.setAttr(
'%s.%s%s' % (target, transform, axis),
value * abs(trFactor[a]))
mc.setDrivenKeyframe(
target,
at='%s%s' % (transform, axis),
cd='%s.%s%s' %
(ctrlName, transform, axis))
mc.setAttr('%s.%s' % (ctrlName, transform), 0,
0, 0)
mc.keyTangent(target, itt='linear', ott='linear')
## create dKeys on dKeytip nodes
for s, side in enumerate(sides):
slaveNum = len(dKeyAllNodesList[s])
ctrlName = '%s_%s' % (side, lipflapTip)
targetList = dKeyTipNodesList[s]
for t, transform in enumerate(transformList):
for a, axis in enumerate(axisList):
for r, target in enumerate(targetList):
valuesDivider = len(targetList)
if transform == 'rotate':
mc.setAttr('%s.%s%s' % (ctrlName, transform, axis),
0)
for value in dKeyValsList[t]:
mc.setAttr(
'%s.%s%s' % (ctrlName, transform, axis),
value)
mc.setAttr(
'%s.%s%s' % (target, transform, axis),
value / (valuesDivider / 2))
mc.setDrivenKeyframe(
target,
at='%s%s' % (transform, axis),
cd='%s.%s%s' % (ctrlName, transform, axis))
mc.setAttr('%s.%s' % (ctrlName, transform), 0, 0,
0)
elif transform == 'translate':
trFactor = mc.getAttr('%s_orig.scale' %
ctrlName)[0]
if not axis == 'Y':
if r > 0:
pass
else:
mc.setAttr(
'%s.%s%s' %
(ctrlName, transform, axis), 0)
for value in dKeyValsList[t]:
mc.setAttr(
'%s.%s%s' %
(ctrlName, transform, axis), value)
mc.setAttr(
'%s.%s%s' %
(target, transform, axis),
value * abs(trFactor[a]))
mc.setDrivenKeyframe(
target,
at='%s%s' % (transform, axis),
cd='%s.%s%s' %
(ctrlName, transform, axis))
mc.setAttr('%s.%s' % (ctrlName, transform),
0, 0, 0)
else:
mc.setAttr(
'%s.%s%s' % (ctrlName, transform, axis), 0)
for value in dKeyValsList[t]:
mc.setAttr(
'%s.%s%s' %
(ctrlName, transform, axis), value)
mc.setAttr(
'%s.%s%s' % (target, transform, axis),
value * abs(trFactor[a]))
mc.setDrivenKeyframe(
target,
at='%s%s' % (transform, axis),
cd='%s.%s%s' %
(ctrlName, transform, axis))
mc.setAttr('%s.%s' % (ctrlName, transform), 0,
0, 0)
mc.keyTangent(target, itt='linear', ott='linear')
## create additionnal Dkeys
### create nose up dKeyAllNodesList
noseDkeyVals = [-2, 0, 2]
mc.setAttr('{}_dKey.rotateY'.format(noseUp), 0)
mc.setAttr('{}.translateX'.format(sneerTip), 0)
for val in noseDkeyVals:
mc.setAttr('{}.translateX'.format(sneerTip), val)
mc.setAttr('{}_dKey.rotateY'.format(noseUp), val * 1.5)
mc.setDrivenKeyframe('{}_dKey'.format(noseUp),
at='rotateY',
cd='{}.translateX'.format(sneerTip))
mc.setAttr('{}.translateX'.format(sneerTip), 0)
### create C_upperLip_side_dkey
lipDkeyVals = [-1.5, 0, 1.5]
axisList = ['X', 'Z']
for axis in axisList:
mc.setAttr('{}.translate{}'.format(CUpperLip, axis), 0)
mc.setAttr('{}.translate{}'.format(CUpperLipSideDkey, axis), 0)
for val in lipDkeyVals:
mc.setAttr('{}.translate{}'.format(CUpperLip, axis), val)
mc.setAttr('{}.translate{}'.format(CUpperLipSideDkey, axis),
val * 0.1)
mc.setDrivenKeyframe(CUpperLipSideDkey,
at='translate{}'.format(axis),
cd='{}.translate{}'.format(
CUpperLip, axis))
mc.setAttr('{}.translate{}'.format(CUpperLip, axis), 0)
mc.delete('tempSaveGrp')
# add locks and translate limits to controls
for side in sides:
for lipFlap in (lipFlapList[0], lipFlapList[1]):
patchLib.locksSwitch('%s_%s' % (side, lipFlap),
T=False,
R=False,
S=True,
V=False,
lockdo='lock',
keydo=False)
mc.transformLimits('%s_%s' % (side, lipFlap),
tx=(-1, 1),
ty=(-1, 1),
tz=(-1, 1))
mc.transformLimits('%s_%s' % (side, lipFlap),
rx=(-180, 180),
ry=(-180, 180),
rz=(-180, 180))
mc.transformLimits('%s_%s' % (side, lipFlap),
etx=(True, True),
ety=(True, True),
etz=(True, True))
mc.transformLimits('%s_%s' % (side, lipFlap),
erx=(True, True),
ery=(True, True),
erz=(True, True))
createOvershootAttrLimit(['%s_%s' % (side, lipFlap)],
['tx', 'ty', 'tz'])
#connect flaps controls to bcs weights
if bcsNode:
for side in sides:
for f, flap in enumerate(lipFlapList[0:2]):
flapCtrl = '%s_%s' % (side, flap)
flapSR = mc.createNode('setRange', n='%s_sr' % flapCtrl)
mc.connectAttr('%s.rotate' % flapCtrl, '%s.value' % flapSR)
mc.setAttr('%s.min' % flapSR, -2, -2, -2)
mc.setAttr('%s.max' % flapSR, 2, 2, 2)
mc.setAttr('%s.oldMin' % flapSR, -180, -180, -180)
mc.setAttr('%s.oldMax' % flapSR, 180, 180, 180)
for w, weight in enumerate(flapWeightsList[f]):
if w < 3:
mc.connectAttr(
'%s.%s' % (flapCtrl, transformListBcs[w]),
'%s.%s_%s' % (bcsNode, weight, side))
else:
mc.connectAttr(
'%s.%s' % (flapSR, transformListBcs[w]),
'%s.%s_%s' % (bcsNode, weight, side))
else:
print 'saveGrp missing, do jawGen dog befor creating dKeys'
def test_childPathAtIndex(self):
nodeParent = nodes.asMObject(cmds.group(self.node))
child1 = nodes.asMObject(cmds.createNode("transform"))
nodes.setParent(child1, nodeParent)
dagPath = om.MFnDagNode(nodeParent).getPath()
self.assertEquals(nodes.childPathAtIndex(dagPath, 0).partialPathName(), self.node)
def test_setParent(self):
obj = nodes.asMObject(self.node)
self.assertFalse(nodes.hasParent(obj))
transform = nodes.asMObject(cmds.createNode("transform"))
nodes.setParent(transform, obj)
self.assertTrue(nodes.hasParent(transform))
def test_toApiObjectReturnsDependNode(self):
node = cmds.createNode("multiplyDivide")
self.assertIsInstance(nodes.toApiMFnSet(node), om.MFnDependencyNode)
def setUp(self):
self.node = cmds.createNode("transform")
cmds.parentConstraint(sel, targetA)
cmds.delete(targetA + '_parentConstraint1')
cmds.parent(sel, targetA)
up = cmds.listRelatives(sel, p=True)
cmds.parentConstraint(sel, targetB)
cmds.delete(targetB + '_parentConstraint1')
cmds.parent(targetA, targetB)
cmds.select(cl=1)
return targetB
name_ = 'ankle_ribbon'
sel = orderls()
num_ = len(sel)
posList_, crvShape_ = pointCrv(sel, name_)
crv_ = crv(sel, name_, posList_)
for i in range(num_):
padding = '2'
pad = ("%%0%si" % padding) % int(i)
#cmds.getAttr('{}.{}[{}]'.format(shape_, 'controlPoints', i))
poci_ = cmds.createNode('pointOnCurveInfo',
n='{}_{}_{}'.format(name_, pad, 'POCI'))
ctl_, ctl_os = ctl('{}_{}'.format(name_, pad), 'sphere', 2)
jnt_ = jnt(ctl_, '{}_{}'.format(name_, pad))
jnt_os = OSCS(jnt_)
cmds.parent(jnt_os, ctl_)
cmds.setAttr('{}.{}'.format(poci_, 'parameter'), i)
cmds.connectAttr('{}.{}'.format(crv_, 'ws'), '{}.{}'.format(poci_, 'ic'))
cmds.connectAttr('{}.{}'.format(poci_, 'p'), '{}.{}'.format(ctl_os, 't'))
def createSpace(self):
if cmds.objExists(
self.firstSpace.replace(
self.firstSpace.split('_')[-1], 'space_SPC')):
self.firstSpaceNul = self.firstSpace.replace(
self.firstSpace.split('_')[-1], 'space_SPC')
fLocatorName = self.target.replace(
self.firstSpace.split('_')[-1], 'LOC')
self.firstSpaceLOC = cmds.spaceLocator(n=fLocatorName.replace(
fLocatorName.split('_')[-2], '%sIn%s' %
(self.target.split('_')[-2],
self.firstSpace.split('_')[-2].capitalize())))
POsnap(self.firstSpaceLOC, self.target)
cmds.parent(self.firstSpaceLOC, self.firstSpaceNul)
else:
self.firstSpaceNul = cmds.createNode(
'transform',
n=self.firstSpace.replace(
self.firstSpace.split('_')[-1], 'space_SPC'))
POsnap(self.firstSpaceNul, self.firstSpace)
fLocatorName = self.target.replace(
self.firstSpace.split('_')[-1], 'LOC')
self.firstSpaceLOC = cmds.spaceLocator(n=fLocatorName.replace(
fLocatorName.split('_')[-2], '%sIn%s' %
(self.target.split('_')[-2],
self.firstSpace.split('_')[-2].capitalize())))
POsnap(self.firstSpaceLOC, self.target)
cmds.parent(self.firstSpaceLOC, self.firstSpaceNul)
if cmds.objExists(
self.secondSpace.replace(
self.secondSpace.split('_')[-1], 'space_SPC')):
self.secondSpaceNul = self.secondSpace.replace(
self.secondSpace.split('_')[-1], 'space_SPC')
sLocatorName = self.target.replace(
self.secondSpace.split('_')[-1], 'LOC')
self.secondSpaceLOC = cmds.spaceLocator(n=sLocatorName.replace(
sLocatorName.split('_')[-2], '%sIn%s' %
(self.target.split('_')[-2],
self.secondSpace.split('_')[-2].capitalize())))
POsnap(self.secondSpaceLOC[0], self.target)
cmds.parent(self.secondSpaceLOC, self.secondSpaceNul)
else:
self.secondSpaceNul = cmds.createNode(
'transform',
n=self.secondSpace.replace(
self.secondSpace.split('_')[-1], 'space_SPC'))
POsnap(self.secondSpaceNul, self.secondSpace)
sLocatorName = self.target.replace(
self.secondSpace.split('_')[-1], 'LOC')
self.secondSpaceLOC = cmds.spaceLocator(n=sLocatorName.replace(
sLocatorName.split('_')[-2], '%sIn%s' %
(self.target.split('_')[-2],
self.secondSpace.split('_')[-2].capitalize())))
POsnap(self.secondSpaceLOC[0], self.target)
cmds.parent(self.secondSpaceLOC, self.secondSpaceNul)
return [self.firstSpaceNul, self.secondSpaceNul]
"""
def meshAlphaMapCreateNew(node, attr):
logger.debug("Alpha Map create new: %s.%s" % (node, attr))
alphaMap = mc.createNode("appleseedAlphaMap")
mc.connectAttr(alphaMap + ".shape", node + '.' + attr)
def remapValue(inputAttr,
targetAttr='',
inputMin=0,
inputMax=1,
outputMin=0,
outputMax=1,
interpType='linear',
rampValues=[],
prefix=''):
'''
Create a remapValue node based on the incoming arguments
@param inputAttr: Input attribute plug to connect to the remapValue node input.
@type inputAttr: str
@param targetAttr: Optional target attribute to receive the output value of the remapValue node.
@type targetAttr: str
@param inputMin: Input minimum value for the remapValue node.
@type inputMin: float
@param inputMax: Input maximum value for the remapValue node.
@type inputMax: float
@param outputMin: Output minimum value for the remapValue node.
@type outputMin: float
@param outputMax: Output maximum value for the remapValue node.
@type outputMax: float
@param interpType: Ramp interpolation method.
@type interpType: str
@param rampValues: List of ramp position and value pairs. [(pos1,val1),(pos2,val2),(pos3,val3)]
@type rampValues: list
@param prefix: Naming prefix string for remapValue node
@type prefix: str
'''
# ==========
# - Checks -
# ==========
# Input Attributes
if not mc.objExists(inputAttr):
raise Exception('Input attribute "' + inputAttr + '" does not exist!')
try:
mc.getAttr(inputAttr, l=True)
except:
raise Exception('Input attribute argument "' + inputAttr +
'" is not a valid attribute!')
# Target
if targetAttr:
if not mc.objExists(targetAttr):
raise Exception('Target attribute "' + targetAttr +
'" does not exist!')
try:
mc.getAttr(targetAttr, l=True)
except:
raise Exception('Target attribute argument "' + targetAttr +
'" is not a valid attribute!')
# Interp Type
interpTypeList = ['none', 'linear', 'smooth', 'spline']
if not interpTypeList.count(interpType):
raise Exception('Invalid interpolation type specified! ("' +
interpType + '")')
# Prefix
if not prefix: prefix = inputAttr.replace('.', '_')
# ==========================
# - Create RemapValue Node -
# ==========================
remapValueNode = mc.createNode('remapValue', n=prefix + '_remapValue')
# Connect Input
mc.connectAttr(inputAttr, remapValueNode + '.inputValue', f=True)
# Set Input/Output Min/Max
mc.setAttr(remapValueNode + '.inputMin', inputMin)
mc.setAttr(remapValueNode + '.inputMax', inputMax)
mc.setAttr(remapValueNode + '.outputMin', outputMin)
mc.setAttr(remapValueNode + '.outputMax', outputMax)
# Interp Type
interpTypeInd = interpTypeList.index(interpType)
mc.setAttr(remapValueNode + '.value[0].value_Interp', interpTypeInd)
mc.setAttr(remapValueNode + '.value[1].value_Interp', interpTypeInd)
# ====================
# - Plot Ramp Values -
# ====================
for i in range(len(rampValues)):
mc.setAttr(remapValueNode + '.value[' + str(i) + '].value_Position',
rampValues[i][0])
mc.setAttr(remapValueNode + '.value[' + str(i) + '].value_FloatValue',
rampValues[i][1])
mc.setAttr(remapValueNode + '.value[' + str(i) + '].value_Interp',
interpTypeInd)
# ===============================
# - Connect to Target Attribute -
# ===============================
if targetAttr:
mc.connectAttr(remapValueNode + '.outValue', targetAttr, f=True)
# =================
# - Return Result -
# =================
return remapValueNode
def fromType(nodeType):
n = cmds.createNode(nodeType)
return Node(n)
def create(path,
objectType,
num=0,
parent=False,
useDist=False,
min=0.0,
max=1.0,
prefix=''):
"""
Create objects along a curve
# INPUTS:
@input path: Input nurbs curve path
@inputType path: str
@input objectType: Type of objects to create and place along path
@inputType objectType: str
@input num: Number of objects to create along path. If num=0, number of edit points will be used.
@inputType num: int
@input parent: Parent each new object to the previously created object. eg. Joint chain
@inputType parent: bool
@input useDist: Use distance along curve instead of parametric length for sample distribution
@inputType useDist: bool
@input min: Percent along the path to start placing objects
@inputType min: float
@input max: Percent along the path to stop placing objects
@inputType max: float
@input prefix: Name prefix for builder created nodes. If left at default ("") prefix will be derived from path name.
@inputType prefix: str
# OUTPUTS:
@output outObjectList: List of objects placed along path
@outputType outObjectList: list
"""
# Check Path
if not glTools.utils.curve.isCurve(path):
raise Exception('Path object ' + path + ' is not a valid nurbs curve!')
# Check prefix
if not prefix: prefix = glTools.utils.stringUtils.stripSuffix(path)
# Check object count
if not num: num = cmds.getAttr(path + '.spans') + 1
# Get curve sample points
paramList = glTools.utils.curve.sampleParam(path, num, useDist, min, max)
# Create object along path
objList = []
for i in range(num):
# Get string index
ind = glTools.utils.stringUtils.stringIndex(i + 1)
# Create object
obj = cmds.createNode(objectType, n=prefix + ind + '_' + objectType)
if not glTools.utils.base.isTransform(obj):
obj = cmds.listRelatives(obj, p=True, pa=True)[0]
# Position
pos = cmds.pointOnCurve(path, pr=paramList[i])
cmds.xform(obj, t=pos, ws=True)
# Parent
if parent and i: obj = cmds.parent(obj, objList[-1])[0]
# Orient Joint
if objectType == 'joint' and i:
cmds.joint(objList[-1], e=True, zso=True, oj='xyz', sao='yup')
# Append result
objList.append(str(obj))
# Return result
return objList
def build(
self,
spineJoints = [],
rootJoint = '',
rigScale = 1.0,
createFKSystem = True,
createCircleFkControl = True,
createCircleIkControl = False,
surroundingMeshes = []
):
# Create upper body control.
upperBodyCtrl = SERigControl.RigArrowCrossControl(
rigSide = SERigEnum.eRigSide.RS_Center,
rigType = SERigEnum.eRigType.RT_SpineUpperBody,
prefix = self.Prefix + 'UpperBody',
translateTo = spineJoints[0],
scale = rigScale*20,
scaleX = 5,
scaleZ = 5,
parent = self.ControlsGrp,
fitToSurroundingMeshes = True,
surroundingMeshes = surroundingMeshes,
postFitScale = 1.75,
overrideFitRayDirection = True,
fitRayDirection = (-1, 0, 0)
)
SERigObjectTypeHelper.linkRigObjects(self.TopGrp, upperBodyCtrl.ControlGroup, 'UpperBodyCtrl', 'ControlOwner')
self.UpperBodyCtrl = upperBodyCtrl
# Create pelvis and chest proxy joints.
pelvisProxyJoint = cmds.duplicate(spineJoints[0], n = spineJoints[0] + SERigNaming.s_Proxy, parentOnly = True)[0]
chestBeginProxyJoint = cmds.duplicate(spineJoints[-1], n = spineJoints[-1] + SERigNaming.s_Proxy, parentOnly = True)[0]
cmds.hide(pelvisProxyJoint, chestBeginProxyJoint)
# Create IK controls.
chestBeginCtrl = None
if createCircleIkControl:
chestBeginCtrl = SERigControl.RigCircleControl(
rigSide = SERigEnum.eRigSide.RS_Center,
rigType = SERigEnum.eRigType.RT_SpineChest,
prefix = self.Prefix + 'Chest',
translateTo = chestBeginProxyJoint,
rotateTo = chestBeginProxyJoint,
scale = rigScale*22,
parent = upperBodyCtrl.ControlObject,
fitToSurroundingMeshes = True,
surroundingMeshes = surroundingMeshes,
postFitScale = 1.6
)
else:
chestBeginCtrl = SERigControl.RigCubeControl(
rigSide = SERigEnum.eRigSide.RS_Center,
rigType = SERigEnum.eRigType.RT_SpineChest,
prefix = self.Prefix + 'Chest',
translateTo = chestBeginProxyJoint,
rotateTo = chestBeginProxyJoint,
scale = rigScale*22,
parent = upperBodyCtrl.ControlObject,
cubeScaleX = 4.0,
cubeScaleY = 35.0,
cubeScaleZ = 35.0,
transparency = 0.75,
fitToSurroundingMeshes = True,
surroundingMeshes = surroundingMeshes,
postFitScale = 1.25
)
SERigObjectTypeHelper.linkRigObjects(self.TopGrp, chestBeginCtrl.ControlGroup, 'ChestBeginCtrl', 'ControlOwner')
self.ChestBeginCtrl = chestBeginCtrl
pelvisCtrl = None
if createCircleIkControl:
pelvisCtrl = SERigControl.RigCircleControl(
rigSide = SERigEnum.eRigSide.RS_Center,
rigType = SERigEnum.eRigType.RT_SpinePelvis,
prefix = self.Prefix + 'Pelvis',
translateTo = pelvisProxyJoint,
rotateTo = pelvisProxyJoint,
scale = rigScale*26,
parent = upperBodyCtrl.ControlObject,
fitToSurroundingMeshes = True,
surroundingMeshes = surroundingMeshes,
postFitScale = 1.3
)
else:
pelvisCtrl = SERigControl.RigCubeControl(
rigSide = SERigEnum.eRigSide.RS_Center,
rigType = SERigEnum.eRigType.RT_SpinePelvis,
prefix = self.Prefix + 'Pelvis',
translateTo = pelvisProxyJoint,
rotateTo = pelvisProxyJoint,
scale = rigScale*26,
parent = upperBodyCtrl.ControlObject,
cubeScaleX = 4.0,
cubeScaleY = 35.0,
cubeScaleZ = 35.0,
transparency = 0.75,
fitToSurroundingMeshes = True,
surroundingMeshes = surroundingMeshes,
postFitScale = 1.2
)
SERigObjectTypeHelper.linkRigObjects(self.TopGrp, pelvisCtrl.ControlGroup, 'PelvisCtrl', 'ControlOwner')
self.PelvisCtrl = pelvisCtrl
pelvisLocalCtrl = SERigControl.RigCircleControl(
rigSide = SERigEnum.eRigSide.RS_Center,
rigType = SERigEnum.eRigType.RT_SpinePelvisLocal,
prefix = self.Prefix + 'PelvisLocal',
translateTo = pelvisProxyJoint,
rotateTo = pelvisProxyJoint,
scale = rigScale*22,
parent = upperBodyCtrl.ControlObject,
lockChannels = ['s', 't', 'v'],
fitToSurroundingMeshes = True,
surroundingMeshes = surroundingMeshes,
postFitScale = 1.35
)
SERigObjectTypeHelper.linkRigObjects(self.TopGrp, pelvisLocalCtrl.ControlGroup, 'PelvisLocalCtrl', 'ControlOwner')
self.PelvisLocalCtrl = pelvisLocalCtrl
chestBeginLocalCtrl = SERigControl.RigCircleControl(
rigSide = SERigEnum.eRigSide.RS_Center,
rigType = SERigEnum.eRigType.RT_SpineChestLocal,
prefix = self.Prefix + 'ChestLocal',
translateTo = chestBeginProxyJoint,
rotateTo = chestBeginProxyJoint,
scale = rigScale*22,
parent = upperBodyCtrl.ControlObject,
lockChannels = ['s', 't', 'v'],
fitToSurroundingMeshes = True,
surroundingMeshes = surroundingMeshes,
postFitScale = 1.35
)
SERigObjectTypeHelper.linkRigObjects(self.TopGrp, chestBeginLocalCtrl.ControlGroup, 'ChestBeginLocalCtrl', 'ControlOwner')
self.ChestBeginLocalCtrl = chestBeginLocalCtrl
cmds.parent(pelvisProxyJoint, chestBeginProxyJoint, self.JointsGrp)
cmds.parentConstraint(chestBeginCtrl.ControlObject, chestBeginProxyJoint)
cmds.parentConstraint(chestBeginCtrl.ControlObject, chestBeginLocalCtrl.ControlGroup)
cmds.parentConstraint(pelvisCtrl.ControlObject, pelvisProxyJoint)
cmds.parentConstraint(pelvisCtrl.ControlObject, pelvisLocalCtrl.ControlGroup)
# Insert two new parents for the spine end joints.
chestBeginNewParent = SEJointHelper.createNewParentJoint(spineJoints[-1])
spine0NewParent = SEJointHelper.createNewParentJoint(spineJoints[1], True)
# Get spine joints on which IK joints shall be created.
cmds.parent(spineJoints[-1], w = 1)
newSpineJoints = SEJointHelper.listHierarchy(spine0NewParent)
cmds.parent(spineJoints[-1], chestBeginNewParent)
# Create IK spine joints.
ikSpineJoints = []
preParent = None
for joint in newSpineJoints:
ikSpineJoint = cmds.createNode('joint', n = SERigNaming.sIKPrefix + joint)
cmds.delete(cmds.parentConstraint(joint, ikSpineJoint))
if preParent:
cmds.parent(ikSpineJoint, preParent)
preParent = ikSpineJoint
ikSpineJoints.append(ikSpineJoint)
# Move IK spine joints to component's joint group.
cmds.parent(ikSpineJoints[0], self.JointsGrp)
cmds.makeIdentity(ikSpineJoints[0], apply = True, t = 1, r = 1, s = 1, n = 0, pn = 1)
cmds.hide(ikSpineJoints[0])
# Create IK handle on IK spine joints.
resList = cmds.ikHandle(n = self.Prefix + SERigNaming.s_SplineIKHandle,
sol = 'ikSplineSolver', sj = ikSpineJoints[0], ee = ikSpineJoints[-1], ccv = 1, parentCurve = 0, numSpans = 4)
spineIK = resList[0]
spineCurve = resList[2]
spineCurveNewName = self.Prefix + SERigNaming.s_Curve
cmds.rename(spineCurve, spineCurveNewName)
cmds.hide(spineIK)
cmds.hide(spineCurveNewName)
cmds.parent(spineIK, spineCurveNewName, self.RigPartsFixedGrp)
cmds.select(pelvisProxyJoint, chestBeginProxyJoint, spineCurveNewName)
cmds.skinCluster(toSelectedBones = 1, bindMethod = 0, nw = 1, wd = 0, mi = 5, omi = True, dr = 4, rui = True)
# Make spine twistable.
cmds.setAttr(spineIK + '.dTwistControlEnable', 1)
cmds.setAttr(spineIK + '.dWorldUpType', 4)
cmds.connectAttr(pelvisCtrl.ControlObject + '.worldMatrix[0]', spineIK + '.dWorldUpMatrix')
cmds.connectAttr(chestBeginCtrl.ControlObject + '.worldMatrix[0]', spineIK + '.dWorldUpMatrixEnd')
# Control original spine in-between joints via IK spine joints.
for ikSpineJoint, spineJoint in zip(ikSpineJoints, newSpineJoints):
cmds.orientConstraint(ikSpineJoint, spineJoint, mo = 1)
cmds.pointConstraint(ikSpineJoint, spineJoint, mo = 1)
# Control original chest begin joint via chest begin local control.
cmds.orientConstraint(chestBeginLocalCtrl.ControlObject, spineJoints[-1], mo = 1)
cmds.pointConstraint(chestBeginLocalCtrl.ControlObject, spineJoints[-1], mo = 1)
# Control original pelvis joint via pelvis local control.
cmds.orientConstraint(pelvisLocalCtrl.ControlObject, spineJoints[0], mo = 1)
cmds.pointConstraint(pelvisLocalCtrl.ControlObject, spineJoints[0], mo = 1)
# Create stretching spine.
curveInfoNode = cmds.arclen(spineCurveNewName, ch = 1)
curveLen = cmds.getAttr(curveInfoNode + '.arcLength')
globalScaleAttr = None
if self.BaseRig:
globalScaleAttr = self.BaseRig.getGlobalScaleAttrName()
mulNode = cmds.createNode('multiplyDivide')
cmds.setAttr(mulNode + '.operation', 1)
cmds.setAttr(mulNode + '.input1X', curveLen)
cmds.setAttr(mulNode + '.i1', l = 1)
if globalScaleAttr:
cmds.connectAttr(globalScaleAttr, mulNode + '.input2X', f = 1)
divNode = cmds.createNode('multiplyDivide')
cmds.setAttr(divNode + '.operation', 2)
cmds.connectAttr(curveInfoNode + '.arcLength', divNode + '.input1X', f = 1)
cmds.connectAttr(mulNode + '.outputX', divNode + '.input2X', f = 1)
blender = cmds.createNode('blendColors')
cmds.connectAttr(divNode + '.outputX', blender + '.color1R', f = 1)
cmds.setAttr(blender + '.color2R', 1.0)
if self.BaseRig:
stretchSpineAttr = self.BaseRig.addStretchSpineAttr()
mainControlObj = self.BaseRig.getMainControlObject()
if mainControlObj and stretchSpineAttr:
cmds.connectAttr(mainControlObj + '.' + stretchSpineAttr, blender + '.blender')
for i in range(len(ikSpineJoints) - 1):
curIKSpineJoint = ikSpineJoints[i + 1]
curDefaultTransX = cmds.getAttr(curIKSpineJoint + '.translateX')
curMulNode = cmds.createNode('multiplyDivide')
cmds.setAttr(curMulNode + '.input2X', curDefaultTransX)
cmds.setAttr(curMulNode + '.i2', l = 1)
cmds.connectAttr(blender + '.outputR', curMulNode + '.input1X', f = 1)
cmds.connectAttr(curMulNode + '.outputX', curIKSpineJoint + '.translateX', f = 1)
else:
cmds.warning('Failed creating stretching spine attribute for the main control.')
if createFKSystem:
# Create FK joints.
resCurve = cmds.rebuildCurve(spineCurveNewName, ch = 0, rpo = 0, rt = 0, end = 1, kr = 0, kcp = 0, kep = 1, kt = 0, s = 3, d = 1, tol = 0.00393701)[0]
cmds.select(cl=1)
jnt0 = cmds.joint(n = SERigNaming.sFKPrefix + spineJoints[0])
cmds.delete(cmds.pointConstraint(spineJoints[0], jnt0))
cmds.select(cl=1)
jnt1 = cmds.joint(n = SERigNaming.sFKPrefix + 'C_Spine_0')
cmds.select(resCurve + '.cv[1]')
res = cmds.pointPosition()
cmds.move(res[0], res[1], res[2], jnt1, rpr = 1)
cmds.select(cl=1)
jnt2 = cmds.joint(n = SERigNaming.sFKPrefix + 'C_Spine_1')
cmds.select(resCurve + '.cv[2]')
res = cmds.pointPosition()
cmds.move(res[0], res[1], res[2], jnt2, rpr = 1)
cmds.select(cl=1)
jnt3 = cmds.joint(n = SERigNaming.sFKPrefix + spineJoints[-1])
cmds.delete(cmds.pointConstraint(spineJoints[-1], jnt3))
RefJnt = cmds.duplicate(jnt2, n = 'Ref_jnt', parentOnly = True)[0]
cmds.move(0, 0, -10, RefJnt, r = 1, os = 1)
cmds.delete(cmds.aimConstraint(jnt1, jnt0, offset = [0, 0, 0], w = 1, aim = [1, 0, 0], u = [0, 1, 0], worldUpType = 'object', worldUpObject = RefJnt))
cmds.delete(cmds.aimConstraint(jnt2, jnt1, offset = [0, 0, 0], w = 1, aim = [1, 0, 0], u = [0, 1, 0], worldUpType = 'object', worldUpObject = RefJnt))
cmds.delete(cmds.aimConstraint(jnt3, jnt2, offset = [0, 0, 0], w = 1, aim = [1, 0, 0], u = [0, 1, 0], worldUpType = 'object', worldUpObject = RefJnt))
cmds.delete(cmds.orientConstraint(spineJoints[-1], jnt3))
cmds.parent(jnt3, jnt2)
cmds.parent(jnt2, jnt1)
cmds.parent(jnt1, jnt0)
cmds.parent(jnt0, self.JointsGrp)
cmds.makeIdentity(jnt0, apply = True, t = 1, r = 1, s = 1, n = 0, pn = 1)
cmds.delete(RefJnt)
cmds.delete(resCurve)
# Attach FK root joint to upper body control.
cmds.parentConstraint(upperBodyCtrl.ControlObject, jnt0, mo = 1)
# Create FK spine_0 control.
FKSpine0Ctrl = None
if createCircleFkControl:
FKSpine0Ctrl = SERigControl.RigCircleControl(
rigSide = SERigEnum.eRigSide.RS_Center,
rigType = SERigEnum.eRigType.RT_SpineFK,
rigControlIndex = 0,
prefix = SERigNaming.sFKPrefix + self.Prefix + '_0',
translateTo = jnt1,
rotateTo = jnt1,
scale = rigScale*20,
parent = upperBodyCtrl.ControlObject,
lockChannels = ['t', 's', 'v'],
overrideControlColor = True,
controlColor = (0.4, 0.9, 0.9),
fitToSurroundingMeshes = True,
surroundingMeshes = surroundingMeshes,
postFitScale = 1.45
)
else:
FKSpine0Ctrl = SERigControl.RigCubeControl(
rigSide = SERigEnum.eRigSide.RS_Center,
rigType = SERigEnum.eRigType.RT_SpineFK,
rigControlIndex = 0,
prefix = SERigNaming.sFKPrefix + self.Prefix + '_0',
translateTo = jnt1,
rotateTo = jnt1,
scale = rigScale*20,
parent = upperBodyCtrl.ControlObject,
lockChannels = ['t', 's', 'v'],
cubeScaleX = 4.0,
cubeScaleY = 35.0,
cubeScaleZ = 35.0,
transparency = 0.75,
overrideControlColor = True,
controlColor = (0.4, 0.9, 0.9),
fitToSurroundingMeshes = True,
surroundingMeshes = surroundingMeshes,
postFitScale = 1.1
)
SERigObjectTypeHelper.linkRigObjects(self.TopGrp, FKSpine0Ctrl.ControlGroup, 'FKSpine0Ctrl', 'ControlOwner')
self.FKSpine0Ctrl = FKSpine0Ctrl
cmds.orientConstraint(FKSpine0Ctrl.ControlObject, jnt1)
# Create FK spine_1 control.
FKSpine1Ctrl = None
if createCircleFkControl:
FKSpine1Ctrl = SERigControl.RigCircleControl(
rigSide = SERigEnum.eRigSide.RS_Center,
rigType = SERigEnum.eRigType.RT_SpineFK,
rigControlIndex = 1,
prefix = SERigNaming.sFKPrefix + self.Prefix + '_1',
translateTo = jnt2,
rotateTo = jnt2,
scale = rigScale*20,
parent = FKSpine0Ctrl.ControlObject,
lockChannels = ['t', 's', 'v'],
overrideControlColor = True,
controlColor = (0.4, 0.9, 0.9),
fitToSurroundingMeshes = True,
surroundingMeshes = surroundingMeshes,
postFitScale = 1.45
)
else:
FKSpine1Ctrl = SERigControl.RigCubeControl(
rigSide = SERigEnum.eRigSide.RS_Center,
rigType = SERigEnum.eRigType.RT_SpineFK,
rigControlIndex = 1,
prefix = SERigNaming.sFKPrefix + self.Prefix + '_1',
translateTo = jnt2,
rotateTo = jnt2,
scale = rigScale*20,
parent = FKSpine0Ctrl.ControlObject,
lockChannels = ['t', 's', 'v'],
cubeScaleX = 4.0,
cubeScaleY = 30.0,
cubeScaleZ = 30.0,
transparency = 0.75,
overrideControlColor = True,
controlColor = (0.4, 0.9, 0.9),
fitToSurroundingMeshes = True,
surroundingMeshes = surroundingMeshes,
postFitScale = 1.1
)
SERigObjectTypeHelper.linkRigObjects(self.TopGrp, FKSpine1Ctrl.ControlGroup, 'FKSpine1Ctrl', 'ControlOwner')
self.FKSpine1Ctrl = FKSpine1Ctrl
cmds.orientConstraint(FKSpine1Ctrl.ControlObject, jnt2)
# Attach ChestBegin controls to FK spine_1 control.
cmds.parent(chestBeginCtrl.ControlGroup, FKSpine1Ctrl.ControlObject)
cmds.parent(chestBeginLocalCtrl.ControlGroup, FKSpine1Ctrl.ControlObject)
cmds.hide(jnt0)
# Create controls visibility expression.
mainControl = SERigNaming.sMainControlPrefix + SERigNaming.sControl
controlsVisEN = SERigNaming.sExpressionPrefix + self.Prefix + 'ControlsVis'
controlsVisES = ''
tempExpressionTail = mainControl + '.' + SERigNaming.sBodyControlsVisibilityAttr + ';'
if self.UpperBodyCtrl:
controlsVisES += self.UpperBodyCtrl.ControlGroup + '.visibility = ' + tempExpressionTail
if self.ChestBeginCtrl:
controlsVisES += '\n'
controlsVisES += self.ChestBeginCtrl.ControlGroup + '.visibility = ' + tempExpressionTail
if self.PelvisCtrl:
controlsVisES += '\n'
controlsVisES += self.PelvisCtrl.ControlGroup + '.visibility = ' + tempExpressionTail
if self.PelvisLocalCtrl:
controlsVisES += '\n'
controlsVisES += self.PelvisLocalCtrl.ControlGroup + '.visibility = ' + tempExpressionTail
if self.FKSpine0Ctrl:
controlsVisES += '\n'
controlsVisES += self.FKSpine0Ctrl.ControlGroup + '.visibility = ' + tempExpressionTail
if self.FKSpine1Ctrl:
controlsVisES += '\n'
controlsVisES += self.FKSpine1Ctrl.ControlGroup + '.visibility = ' + tempExpressionTail
cmds.expression(n = controlsVisEN, s = controlsVisES, ae = 1)
def runSetup(self):
if not self.ployName:
rig.confirmDialog(t = u'警告',\
m = u'没有载入ploygon物体',\
ma = 'left',\
button = ('OK'),\
defaultButton = 'OK',\
cancelButton = 'OK',\
dismissString = 'OK')
else:
#=======================================================================
# 生成毛囊
#=======================================================================
Mesh = self.ployName
MeshShape = rig.listRelatives(Mesh,s = True,ni = True)[0]
FOLS = []
if not rig.objExists(Mesh+'_CLM'): #增加closestPointOnMesh节点
CLM = rig.createNode('closestPointOnMesh',n = Mesh+'_CLM',ss = True)
rig.connectAttr(MeshShape+'.outMesh',CLM+'.inMesh')
else:
CLM = Mesh+'_CLM'
if not rig.objExists(Mesh+'_ScaleSM_GRP'): #增加毛囊缩放组节点
self.FolScale = rig.group(empty = True,n = Mesh+'_ScaleSM_GRP')
rig.addAttr(self.FolScale,at = 'float',ln = 'vis',dv = 0)#增加控制器隐藏属性
else:
self.FolScale = Mesh+'_ScaleSM_GRP'
self.allCons = rig.listConnections(self.locatorModel+'.sign',s = False,d = True) #列出所有定位控制器
if self.allCons:
for con in self.allCons:
if rig.objExists(con+'_FOL'):
warning(u'毛囊:'+con+u'_FOL已经存在')
continue
pos = rig.xform(con,q = True,t = True,ws = True)
rig.setAttr(CLM+'.inPositionX',pos[0])
rig.setAttr(CLM+'.inPositionY',pos[1])
rig.setAttr(CLM+'.inPositionZ',pos[2])
U = rig.getAttr(CLM+'.result.parameterU')
V = rig.getAttr(CLM+'.result.parameterV')
FOLShape = rig.createNode('follicle',n = con.replace('_P','_'+self.key)+'_FOLShape',ss = True)
rig.hide(FOLShape)
rig.connectAttr(MeshShape+'.worldMesh[0]',FOLShape+'.inputMesh')
FOL = rig.listRelatives(FOLShape,p = True)[0]
rig.connectAttr(self.FolScale+'.scale',FOL+'.scale')
rig.connectAttr(MeshShape+'.worldMatrix[0]',FOL+'.inputWorldMatrix')
newFol = rig.rename(FOL,con.replace('_P','_'+self.key)+'_FOL')
rig.connectAttr(FOLShape+'.outTranslate',newFol+'.translate')
rig.connectAttr(FOLShape+'.outRotate',newFol+'.rotate')
rig.setAttr(FOLShape+'.parameterU',U)
rig.setAttr(FOLShape+'.parameterV',V)
rig.setAttr(FOLShape+'.simulationMethod',0)
FOLS.append(newFol)
self.origenCurve = rig.group(self.allCons,n = self.ployName+'_origen_ALL_Curves')
else:
warning(u'没有找定位控制器')
#=======================================================================
# 生成控制器和骨骼
#=======================================================================
if FOLS:
jnts = []
for fol in FOLS:
matFol = rig.getAttr(fol+'.worldMatrix')
rig.select(cl = True)
JNT = rig.joint(n = fol.replace('_'+self.key+'_FOL','_JNT'+self.key))
rig.hide(JNT)
grpJnt = rig.group(JNT,n = JNT+'_GRP')
con = rig.duplicate(fol.replace('_'+self.key+'_FOL','_P'),n = fol.replace('_'+self.key+'_FOL','_'+self.key))[0]
rig.xform(con,t = (0,0,0),wd = True)
grpA = rig.group(con,n = con+'_GRP_A')
grpB = rig.group(grpA,n = con+'_GRP_B')
grpC = rig.group(grpB,n = con+'_GRP_C')
rig.parent(grpJnt,con)
rig.xform(grpC,matrix = matFol)
rig.parent(grpC,fol)
jnts.append(JNT)
rig.connectAttr(self.FolScale+'.vis',grpA+'.visibility')
#复制出新的模型对其蒙皮
if not rig.objExists(self.ployName+'_SKIN'):
self.skinMesh = rig.duplicate(self.ployName,n = self.ployName+'_SKIN')[0]
skin = rig.skinCluster(jnts,self.skinMesh)[0]
#连接矩阵
infs = rig.skinCluster(skin,q = True,inf = True)
for i,inf in enumerate(infs):
linkGrp = inf.replace('_JNT'+self.key,'_'+self.key+'_GRP_C')
rig.connectAttr(linkGrp+'.worldInverseMatrix[0]',skin+'.bindPreMatrix['+str(i)+']')
else:
warning(u'蒙皮物体已经存在')
self.FOLGRP = rig.group(FOLS,n = self.ployName+'_ALL_FOL_GRP')
rig.blendShape(self.ployName,self.skinMesh,n = self.ployName+'_BS',foc = True,w = (0,1))#创建blendShape
def unitConversion(plug,
conversionFactor=1.0,
conversionFactorSourcePlug='',
plugIsSource=True,
prefix=''):
'''
Create a unit conversion node for the given destination attribute
@param plug: Plug to be connected to the unitConversion node
@type plug: str
@param conversionFactor: Conversion factor value
@type conversionFactor: float
@param conversionFactorSourcePlug: Plug to supply incoming connection for conversion factor
@type conversionFactorSourcePlug: str
@param plugIsSource: Specifies the plug as either the source or destination of the unitConversion
@type plugIsSource: bool
@param prefix: Name prefix for newly created nodes
@type prefix: str
'''
# Check plug
if not mc.objExists(plug):
raise Exception('Plug ' + plug + ' does not exist!!')
if not plug.count('.'):
raise Exception('Object ' + plug +
' is not a valid plug (node.attr)!!')
# Check conversionFactorSourcePlug
if conversionFactorSourcePlug:
if not mc.objExists(conversionFactorSourcePlug):
raise Exception('Conversion factor source plug ' +
conversionFactorSourcePlug + ' does not exist!')
# Check prefix
if not prefix:
prefix = glTools.utils.stringUtils.stripSuffix(control.split('.')[0])
# Get existing plug connections
conns = mc.listConnections(plug,
s=not plugIsSource,
d=plugIsSource,
p=True)
# Create unitConversion node
unitConversion = mc.createNode('unitConversion',
n=prefix + '_unitConversion')
mc.setAttr(unitConversion + '.conversionFactor', conversionFactor)
# Connect conversion factor
if conversionFactorSourcePlug:
mc.connectAttr(conversionFactorSourcePlug,
unitConversion + '.conversionFactor',
f=True)
# Connect plug
if plugIsSource:
mc.connectAttr(plug, unitConversion + '.input', f=True)
else:
if conns: mc.connectAttr(conns[0], unitConversion + '.input', f=True)
# Connect to destination plugs
if plugIsSource:
if conns:
for conn in conns:
mc.connectAttr(unitConversion + '.output', conn, f=True)
else:
mc.connectAttr(unitConversion + '.output', plug, f=True)
# Return result
return unitConversion
def setUp(self):
cmds.file(new=True, force=True)
node_name = cmds.createNode("transform")
self.meta_node = MetaNode(node_name)
def cachedObjToTransform(*args):
'''{'ath':'Animation/Transform/cachedObjToTransform( )',
'ath':'Dynamics/RBD',
'icon':':/transform.svg',
'usage':"""
#将缓存物体bake成关键帧物体。
$fun( )""",
}
'''
if len(args):
cachedObj = qm.checkArg(args[0], nodeType='mesh', tryToShape=True)
else:
cachedObj = qm.checkArg(nodeType='mesh', tryToShape=True)
cmds.constructionHistory(toggle=False)
#cachedObj = cmds.ls(sl=True,l=True)[0]
#sepratate cachedObj
minTime = int(cmds.playbackOptions(q=True, min=True))
cmds.currentTime(minTime)
temp = cmds.polySeparate(cachedObj, ch=True)[0]
rbdGrp = cmds.listRelatives(temp, p=True, f=True)[0]
childGrp = cmds.duplicate(rbdGrp, rr=True)[0]
parentList = cmds.listRelatives(rbdGrp, type='transform', f=True)
childList = cmds.listRelatives(childGrp, type='transform', f=True)
cmds.delete(cmds.listRelatives(childGrp, f=True), ch=True)
forRemove = []
for obj in parentList:
meshNode = cmds.listRelatives(obj, type='mesh', f=True)
if meshNode == [] or cmds.getAttr(meshNode[0] +
'.intermediateObject') == 1:
forRemove.append(obj)
if obj in forRemove:
parentList.remove(obj)
forRemove = []
for obj in childList:
meshNode = cmds.listRelatives(obj, type='mesh', f=True)
if meshNode == [] or cmds.getAttr(meshNode[0] +
'.intermediateObject') == 1:
forRemove.append(obj)
if obj in forRemove:
childList.remove(obj)
cmds.delete(forRemove)
unfreeze(childList)
folGrp = cmds.group(em=True, n=rbdGrp + '_FoGrp')
for papa in parentList:
index = parentList.index(papa)
child = childList[index]
meshShape = cmds.listRelatives(papa, type='mesh', f=True)[0]
faceCount = cmds.polyEvaluate(papa, f=True) - 1
if faceCount > 10:
faceCount = 10
newFace = '%s.f[0:%s]' % (papa, faceCount)
cmds.select(newFace)
mel.eval('polySplitTextureUV')
mel.eval('PolySelectConvert 4')
map = cmds.ls(sl=True)
cmds.polyNormalizeUV(map, normalizeType=0, preserveAspectRatio=False)
cmds.polyEditUV(map, pu=.5, pv=.5, su=2, sv=2)
#create follicle and set attribute
folShape = cmds.createNode("follicle")
folTransform = cmds.listRelatives(folShape, p=True, f=True)[0]
cmds.setAttr(folTransform + '.intermediateObject', 1)
cmds.setAttr(folShape + '.parameterU', .5, l=True)
cmds.setAttr(folShape + '.parameterV', .5, l=True)
cmds.setAttr(folShape + ".simulationMethod", 0)
cmds.setAttr(folShape + ".collide", 0)
cmds.setAttr(folShape + ".degree", 1)
cmds.setAttr(folShape + ".sampleDensity", 0)
#connection follicles
cmds.connectAttr(meshShape + '.worldMatrix[0]',
folShape + '.inputWorldMatrix',
f=True)
cmds.connectAttr(meshShape + '.outMesh',
folShape + '.inputMesh',
f=True)
cmds.connectAttr(folShape + '.outRotate',
folTransform + '.rotate',
f=True)
cmds.connectAttr(folShape + '.outTranslate',
folTransform + '.translate',
f=True)
parentConNode = cmds.parentConstraint(folTransform, child, mo=True)[0]
cmds.parent(folTransform, folGrp)
minTime = int(cmds.playbackOptions(q=True, min=True))
maxTime = int(cmds.playbackOptions(q=True, max=True))
cmds.bakeResults(childList,simulation=True, t=(minTime,maxTime),sampleBy=1,\
disableImplicitControl=True, preserveOutsideKeys=True, sparseAnimCurveBake=False, removeBakedAttributeFromLayer=False, \
bakeOnOverrideLayer=False,at=['tx','ty','tz','rx','ry','rz'])
cmds.delete([folGrp, rbdGrp])
cmds.delete(cmds.listRelatives(childGrp, f=True), ch=True)
cmds.constructionHistory(toggle=True)
def rigModule(self, *args):
Base.StartClass.rigModule(self)
# verify if the guide exists:
if cmds.objExists(self.moduleGrp):
try:
hideJoints = cmds.checkBox('hideJointsCB',
query=True,
value=True)
except:
hideJoints = 1
# declare lists to store names and attributes:
self.mainCtrlList, self.wheelCtrlList, self.steeringGrpList, self.ctrlHookGrpList = [], [], [], []
# start as no having mirror:
sideList = [""]
# analisys the mirror module:
self.mirrorAxis = cmds.getAttr(self.moduleGrp + ".mirrorAxis")
if self.mirrorAxis != 'off':
# get rigs names:
self.mirrorNames = cmds.getAttr(self.moduleGrp + ".mirrorName")
# get first and last letters to use as side initials (prefix):
sideList = [
self.mirrorNames[0] + '_',
self.mirrorNames[len(self.mirrorNames) - 1] + '_'
]
for s, side in enumerate(sideList):
duplicated = cmds.duplicate(
self.moduleGrp,
name=side + self.userGuideName + '_Guide_Base')[0]
allGuideList = cmds.listRelatives(duplicated,
allDescendents=True)
for item in allGuideList:
cmds.rename(item,
side + self.userGuideName + "_" + item)
self.mirrorGrp = cmds.group(name="Guide_Base_Grp",
empty=True)
cmds.parent(side + self.userGuideName + '_Guide_Base',
self.mirrorGrp,
absolute=True)
# re-rename grp:
cmds.rename(
self.mirrorGrp,
side + self.userGuideName + '_' + self.mirrorGrp)
# do a group mirror with negative scaling:
if s == 1:
if cmds.getAttr(self.moduleGrp + ".flip") == 0:
for axis in self.mirrorAxis:
gotValue = cmds.getAttr(
side + self.userGuideName +
"_Guide_Base.translate" + axis)
flipedValue = gotValue * (-2)
cmds.setAttr(
side + self.userGuideName + '_' +
self.mirrorGrp + '.translate' + axis,
flipedValue)
else:
for axis in self.mirrorAxis:
cmds.setAttr(
side + self.userGuideName + '_' +
self.mirrorGrp + '.scale' + axis, -1)
# joint labelling:
jointLabelAdd = 1
else: # if not mirror:
duplicated = cmds.duplicate(self.moduleGrp,
name=self.userGuideName +
'_Guide_Base')[0]
allGuideList = cmds.listRelatives(duplicated,
allDescendents=True)
for item in allGuideList:
cmds.rename(item, self.userGuideName + "_" + item)
self.mirrorGrp = cmds.group(self.userGuideName + '_Guide_Base',
name="Guide_Base_Grp",
relative=True)
#for Maya2012: self.userGuideName+'_'+self.moduleGrp+"_Grp"
# re-rename grp:
cmds.rename(self.mirrorGrp,
self.userGuideName + '_' + self.mirrorGrp)
# joint labelling:
jointLabelAdd = 0
# store the number of this guide by module type
dpAR_count = utils.findModuleLastNumber(CLASS_NAME,
"dpAR_type") + 1
# run for all sides
for s, side in enumerate(sideList):
# declare guides:
self.base = side + self.userGuideName + '_Guide_Base'
self.cvCenterLoc = side + self.userGuideName + "_Guide_CenterLoc"
self.cvFrontLoc = side + self.userGuideName + "_Guide_FrontLoc"
self.cvInsideLoc = side + self.userGuideName + "_Guide_InsideLoc"
self.cvOutsideLoc = side + self.userGuideName + "_Guide_OutsideLoc"
# create a joint:
cmds.select(clear=True)
# center joint:
self.centerJoint = cmds.joint(
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['m156_wheel'] + "_Jnt",
scaleCompensate=False)
cmds.addAttr(self.centerJoint,
longName='dpAR_joint',
attributeType='float',
keyable=False)
# joint labelling:
utils.setJointLabel(
self.centerJoint, s + jointLabelAdd, 18,
self.userGuideName + "_" +
self.langDic[self.langName]['m156_wheel'])
# create end joint:
self.endJoint = cmds.joint(
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['m156_wheel'] + "_JEnd")
# main joint:
cmds.select(clear=True)
self.mainJoint = cmds.joint(
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['c058_main'] + "_Jnt",
scaleCompensate=False)
cmds.addAttr(self.mainJoint,
longName='dpAR_joint',
attributeType='float',
keyable=False)
# joint labelling:
utils.setJointLabel(
self.mainJoint, s + jointLabelAdd, 18, self.userGuideName +
"_" + self.langDic[self.langName]['c058_main'])
# create end joint:
self.mainEndJoint = cmds.joint(
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['c058_main'] + "_JEnd")
# create controls:
self.wheelCtrl = self.ctrls.cvControl(
"id_060_WheelCenter",
side + self.userGuideName + "_" +
self.langDic[self.langName]['m156_wheel'] + "_Ctrl",
r=self.ctrlRadius,
d=self.curveDegree)
self.mainCtrl = self.ctrls.cvControl(
"id_061_WheelMain",
side + self.userGuideName + "_" +
self.langDic[self.langName]['c058_main'] + "_Ctrl",
r=self.ctrlRadius * 0.4,
d=self.curveDegree)
self.insideCtrl = self.ctrls.cvControl(
"id_062_WheelPivot",
side + self.userGuideName + "_" +
self.langDic[self.langName]['c011_RevFoot_B'].capitalize()
+ "_Ctrl",
r=self.ctrlRadius * 0.2,
d=self.curveDegree,
rot=(0, 90, 0))
self.outsideCtrl = self.ctrls.cvControl(
"id_062_WheelPivot",
side + self.userGuideName + "_" +
self.langDic[self.langName]['c010_RevFoot_A'].capitalize()
+ "_Ctrl",
r=self.ctrlRadius * 0.2,
d=self.curveDegree,
rot=(0, 90, 0))
self.mainCtrlList.append(self.mainCtrl)
self.wheelCtrlList.append(self.wheelCtrl)
# origined from attributes:
utils.originedFrom(objName=self.mainCtrl,
attrString=self.base + ";" +
self.cvCenterLoc + ";" + self.cvFrontLoc +
";" + self.cvInsideLoc + ";" +
self.cvOutsideLoc)
#utils.originedFrom(objName=self.wheelCtrl, attrString=self.cvCenterLoc)
# prepare group to receive steering wheel connection:
self.toSteeringGrp = cmds.group(
self.insideCtrl,
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['c070_steering'].capitalize() +
"_Grp")
cmds.addAttr(
self.toSteeringGrp,
longName=self.langDic[self.langName]['c070_steering'],
attributeType='bool',
keyable=True)
cmds.addAttr(
self.toSteeringGrp,
longName=self.langDic[self.langName]['c070_steering'] +
self.langDic[self.langName]['m151_invert'],
attributeType='bool',
keyable=True)
cmds.setAttr(
self.toSteeringGrp + "." +
self.langDic[self.langName]['c070_steering'], 1)
self.steeringGrpList.append(self.toSteeringGrp)
# position and orientation of joint and control:
cmds.delete(
cmds.parentConstraint(self.cvCenterLoc,
self.centerJoint,
maintainOffset=False))
cmds.delete(
cmds.parentConstraint(self.cvFrontLoc,
self.endJoint,
maintainOffset=False))
cmds.delete(
cmds.parentConstraint(self.cvCenterLoc,
self.wheelCtrl,
maintainOffset=False))
cmds.delete(
cmds.parentConstraint(self.cvCenterLoc,
self.mainCtrl,
maintainOffset=False))
cmds.parentConstraint(self.mainCtrl,
self.mainJoint,
maintainOffset=False)
cmds.delete(
cmds.parentConstraint(self.cvFrontLoc,
self.mainEndJoint,
maintainOffset=False))
if s == 1 and cmds.getAttr(self.moduleGrp + ".flip") == 1:
cmds.move(self.ctrlRadius,
self.mainCtrl,
moveY=True,
relative=True,
objectSpace=True,
worldSpaceDistance=True)
else:
cmds.move(-self.ctrlRadius,
self.mainCtrl,
moveY=True,
relative=True,
objectSpace=True,
worldSpaceDistance=True)
cmds.delete(
cmds.parentConstraint(self.cvInsideLoc,
self.toSteeringGrp,
maintainOffset=False))
cmds.delete(
cmds.parentConstraint(self.cvOutsideLoc,
self.outsideCtrl,
maintainOffset=False))
# zeroOut controls:
zeroGrpList = utils.zeroOut([
self.mainCtrl, self.wheelCtrl, self.toSteeringGrp,
self.outsideCtrl
])
wheelAutoGrp = utils.zeroOut([self.wheelCtrl])
wheelAutoGrp = cmds.rename(
wheelAutoGrp, side + self.userGuideName + "_" +
self.langDic[self.langName]['m156_wheel'] + "_Auto_Grp")
# fixing flip mirror:
if s == 1:
if cmds.getAttr(self.moduleGrp + ".flip") == 1:
for zeroOutGrp in zeroGrpList:
cmds.setAttr(zeroOutGrp + ".scaleX", -1)
cmds.setAttr(zeroOutGrp + ".scaleY", -1)
cmds.setAttr(zeroOutGrp + ".scaleZ", -1)
cmds.addAttr(self.wheelCtrl,
longName='scaleCompensate',
attributeType="bool",
keyable=False)
cmds.setAttr(self.wheelCtrl + ".scaleCompensate",
1,
channelBox=True)
cmds.connectAttr(self.wheelCtrl + ".scaleCompensate",
self.centerJoint + ".segmentScaleCompensate",
force=True)
cmds.addAttr(self.mainCtrl,
longName='scaleCompensate',
attributeType="bool",
keyable=False)
cmds.setAttr(self.mainCtrl + ".scaleCompensate",
1,
channelBox=True)
cmds.connectAttr(self.mainCtrl + ".scaleCompensate",
self.mainJoint + ".segmentScaleCompensate",
force=True)
# hide visibility attributes:
self.ctrls.setLockHide(
[self.mainCtrl, self.insideCtrl, self.outsideCtrl], ['v'])
self.ctrls.setLockHide(
[self.wheelCtrl],
['tx', 'ty', 'tz', 'rx', 'ry', 'sx', 'sy', 'sz', 'v'])
# grouping:
cmds.parentConstraint(self.wheelCtrl,
self.centerJoint,
maintainOffset=False,
name=self.centerJoint +
"_ParentConstraint")
cmds.scaleConstraint(self.wheelCtrl,
self.centerJoint,
maintainOffset=True,
name=self.centerJoint +
"_ScaleConstraint")
cmds.parent(zeroGrpList[1], self.mainCtrl, absolute=True)
cmds.parent(zeroGrpList[0], self.outsideCtrl, absolute=True)
cmds.parent(zeroGrpList[3], self.insideCtrl, absolute=True)
# add attributes:
cmds.addAttr(
self.wheelCtrl,
longName=self.langDic[self.langName]['c047_autoRotate'],
attributeType="bool",
defaultValue=1,
keyable=True)
cmds.addAttr(
self.wheelCtrl,
longName=self.langDic[self.langName]['c068_startFrame'],
attributeType="long",
defaultValue=1,
keyable=False)
cmds.addAttr(
self.wheelCtrl,
longName=self.langDic[self.langName]['c067_radius'],
attributeType="float",
min=0.01,
defaultValue=self.ctrlRadius,
keyable=True)
cmds.addAttr(
self.wheelCtrl,
longName=self.langDic[self.langName]['c069_radiusScale'],
attributeType="float",
defaultValue=1,
keyable=False)
cmds.addAttr(
self.wheelCtrl,
longName=self.langDic[self.langName]['c021_showControls'],
attributeType="long",
min=0,
max=1,
defaultValue=0,
keyable=True)
cmds.addAttr(
self.wheelCtrl,
longName=self.langDic[self.langName]['c070_steering'],
attributeType="bool",
defaultValue=0,
keyable=True)
cmds.addAttr(
self.wheelCtrl,
longName=self.langDic[self.langName]['i037_to'] +
self.langDic[self.langName]['c070_steering'].capitalize(),
attributeType="float",
defaultValue=0,
keyable=False)
cmds.addAttr(
self.wheelCtrl,
longName=self.langDic[self.langName]['c070_steering'] +
self.langDic[self.langName]['c053_invert'].capitalize(),
attributeType="long",
min=0,
max=1,
defaultValue=1,
keyable=False)
cmds.addAttr(
self.wheelCtrl,
longName=self.langDic[self.langName]['c093_tryKeepUndo'],
attributeType="long",
min=0,
max=1,
defaultValue=1,
keyable=False)
# get stored values by user:
startFrameValue = cmds.getAttr(self.moduleGrp + ".startFrame")
steeringValue = cmds.getAttr(self.moduleGrp + ".steering")
showControlsValue = cmds.getAttr(self.moduleGrp +
".showControls")
cmds.setAttr(self.wheelCtrl + "." +
self.langDic[self.langName]['c068_startFrame'],
startFrameValue,
channelBox=True)
cmds.setAttr(self.wheelCtrl + "." +
self.langDic[self.langName]['c070_steering'],
steeringValue,
channelBox=True)
cmds.setAttr(self.wheelCtrl + "." +
self.langDic[self.langName]['c021_showControls'],
showControlsValue,
channelBox=True)
cmds.setAttr(
self.wheelCtrl + "." +
self.langDic[self.langName]['c070_steering'] +
self.langDic[self.langName]['c053_invert'].capitalize(),
1,
channelBox=True)
cmds.setAttr(self.wheelCtrl + "." +
self.langDic[self.langName]['c093_tryKeepUndo'],
1,
channelBox=True)
if s == 1:
if cmds.getAttr(self.moduleGrp + ".flip") == 1:
cmds.setAttr(
self.wheelCtrl + "." +
self.langDic[self.langName]['c070_steering'] +
self.langDic[
self.langName]['c053_invert'].capitalize(), 0)
# automatic rotation wheel setup:
receptSteeringMD = cmds.createNode(
'multiplyDivide',
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['c070_steering'] + "_MD")
inverseSteeringMD = cmds.createNode(
'multiplyDivide',
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['c070_steering'] + "_Inv_MD")
steeringInvCnd = cmds.createNode(
'condition',
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['c070_steering'] + "_Inv_Cnd")
cmds.setAttr(steeringInvCnd + ".colorIfTrueR", 1)
cmds.setAttr(steeringInvCnd + ".colorIfFalseR", -1)
cmds.connectAttr(
self.wheelCtrl + "." +
self.langDic[self.langName]['i037_to'] +
self.langDic[self.langName]['c070_steering'].capitalize(),
receptSteeringMD + ".input1X",
force=True)
cmds.connectAttr(self.wheelCtrl + "." +
self.langDic[self.langName]['c070_steering'],
receptSteeringMD + ".input2X",
force=True)
cmds.connectAttr(receptSteeringMD + ".outputX",
inverseSteeringMD + ".input1X",
force=True)
cmds.connectAttr(steeringInvCnd + ".outColorR",
inverseSteeringMD + ".input2X",
force=True)
cmds.connectAttr(
self.wheelCtrl + "." +
self.langDic[self.langName]['c070_steering'] +
self.langDic[self.langName]['c053_invert'].capitalize(),
steeringInvCnd + ".firstTerm",
force=True)
cmds.connectAttr(inverseSteeringMD + ".outputX",
self.toSteeringGrp + ".rotateY",
force=True)
# create locators (frontLoc to get direction and oldLoc to store wheel old position):
self.frontLoc = cmds.spaceLocator(
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['m156_wheel'] +
"_Front_Loc")[0]
self.oldLoc = cmds.spaceLocator(
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['m156_wheel'] + "_Old_Loc")[0]
cmds.delete(
cmds.parentConstraint(self.cvFrontLoc,
self.frontLoc,
maintainOffset=False))
cmds.parent(self.frontLoc, self.mainCtrl)
cmds.delete(
cmds.parentConstraint(self.cvCenterLoc,
self.oldLoc,
maintainOffset=False))
cmds.setAttr(self.frontLoc + ".visibility", 0, lock=True)
cmds.setAttr(self.oldLoc + ".visibility", 0, lock=True)
# this wheel auto group locator could be replaced by a decomposeMatrix to get the translation in world space of the Wheel_Auto_Ctrl_Grp instead:
self.wheelAutoGrpLoc = cmds.spaceLocator(
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['m156_wheel'] + "_Auto_Loc")[0]
cmds.pointConstraint(wheelAutoGrp,
self.wheelAutoGrpLoc,
maintainOffset=False,
name=self.wheelAutoGrpLoc +
"_PointConstraint")
cmds.setAttr(self.wheelAutoGrpLoc + ".visibility",
0,
lock=True)
expString = "if ("+self.wheelCtrl+"."+self.langDic[self.langName]['c047_autoRotate']+" == 1) {"+\
"\nif ("+self.wheelCtrl+"."+self.langDic[self.langName]['c093_tryKeepUndo']+" == 1) { undoInfo -stateWithoutFlush 0; };"+\
"\nfloat $radius = "+self.wheelCtrl+"."+self.langDic[self.langName]['c067_radius']+" * "+self.wheelCtrl+"."+self.langDic[self.langName]['c069_radiusScale']+\
";\nvector $moveVectorOld = `xform -q -ws -t \""+self.oldLoc+\
"\"`;\nvector $moveVector = << "+self.wheelAutoGrpLoc+".translateX, "+self.wheelAutoGrpLoc+".translateY, "+self.wheelAutoGrpLoc+".translateZ >>;"+\
"\nvector $dirVector = `xform -q -ws -t \""+self.frontLoc+\
"\"`;\nvector $wheelVector = ($dirVector - $moveVector);"+\
"\nvector $motionVector = ($moveVector - $moveVectorOld);"+\
"\nfloat $distance = mag($motionVector);"+\
"\n$dot = dotProduct($motionVector, $wheelVector, 1);\n"+\
wheelAutoGrp+".rotateZ = "+wheelAutoGrp+".rotateZ - 360 / (6.283*$radius) * ($dot*$distance);"+\
"\nxform -t ($moveVector.x) ($moveVector.y) ($moveVector.z) "+self.oldLoc+\
";\nif (frame == "+self.wheelCtrl+"."+self.langDic[self.langName]['c068_startFrame']+") { "+wheelAutoGrp+".rotateZ = 0; };"+\
"\nif ("+self.wheelCtrl+"."+self.langDic[self.langName]['c093_tryKeepUndo']+" == 1) { undoInfo -stateWithoutFlush 1; };};"
# expression:
cmds.expression(name=side + self.userGuideName + "_" +
self.langDic[self.langName]['m156_wheel'] +
"_Exp",
object=self.frontLoc,
string=expString)
self.ctrls.setLockHide([self.frontLoc, self.wheelAutoGrpLoc], [
'tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'
])
# deformers:
self.loadedGeo = cmds.getAttr(self.moduleGrp + ".geo")
# geometry holder:
self.geoHolder = cmds.polyCube(
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['c046_holder'] + "_Geo",
constructionHistory=False)[0]
cmds.delete(
cmds.parentConstraint(self.cvCenterLoc,
self.geoHolder,
maintainOffset=False))
cmds.setAttr(self.geoHolder + ".visibility", 0, lock=True)
# skinning:
cmds.skinCluster(self.centerJoint,
self.geoHolder,
toSelectedBones=True,
dropoffRate=4.0,
maximumInfluences=3,
skinMethod=0,
normalizeWeights=1,
removeUnusedInfluence=False,
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['c046_holder'] +
"_SC")
if self.loadedGeo:
if cmds.objExists(self.loadedGeo):
baseName = utils.extractSuffix(self.loadedGeo)
skinClusterName = baseName + "_SC"
if "|" in skinClusterName:
skinClusterName = skinClusterName[skinClusterName.
rfind("|") + 1:]
try:
cmds.skinCluster(self.centerJoint,
self.loadedGeo,
toSelectedBones=True,
dropoffRate=4.0,
maximumInfluences=3,
skinMethod=0,
normalizeWeights=1,
removeUnusedInfluence=False,
name=skinClusterName)
except:
childList = cmds.listRelatives(self.loadedGeo,
children=True,
allDescendents=True)
if childList:
for item in childList:
itemType = cmds.objectType(item)
if itemType == "mesh" or itemType == "nurbsSurface":
try:
skinClusterName = utils.extractSuffix(
item) + "_SC"
cmds.skinCluster(
self.centerJoint,
item,
toSelectedBones=True,
dropoffRate=4.0,
maximumInfluences=3,
skinMethod=0,
normalizeWeights=1,
removeUnusedInfluence=False,
name=skinClusterName)
except:
pass
# lattice:
latticeList = cmds.lattice(self.geoHolder,
divisions=(6, 6, 6),
outsideLattice=2,
outsideFalloffDistance=1,
position=(0, 0, 0),
scale=(self.ctrlRadius * 2,
self.ctrlRadius * 2,
self.ctrlRadius * 2),
name=side + self.userGuideName +
"_FFD") #[deformer, lattice, base]
cmds.scale(self.ctrlRadius * 2, self.ctrlRadius * 2,
self.ctrlRadius * 2, latticeList[2])
# clusters:
upperClusterList = cmds.cluster(
latticeList[1] + ".pt[0:5][4:5][0:5]",
relative=True,
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['c044_upper'] +
"_Cls") #[deform, handle]
middleClusterList = cmds.cluster(
latticeList[1] + ".pt[0:5][2:3][0:5]",
relative=True,
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['m033_middle'] +
"_Cls") #[deform, handle]
lowerClusterList = cmds.cluster(
latticeList[1] + ".pt[0:5][0:1][0:5]",
relative=True,
name=side + self.userGuideName + "_" +
self.langDic[self.langName]['c045_lower'] +
"_Cls") #[deform, handle]
clusterGrpList = utils.zeroOut([
upperClusterList[1], middleClusterList[1],
lowerClusterList[1]
])
clustersGrp = cmds.group(clusterGrpList,
name=side + self.userGuideName +
"_Clusters_Grp")
# deform controls:
upperDefCtrl = self.ctrls.cvControl(
"id_063_WheelDeform",
side + self.userGuideName + "_" +
self.langDic[self.langName]['c044_upper'] + "_Ctrl",
r=self.ctrlRadius * 0.5,
d=self.curveDegree)
middleDefCtrl = self.ctrls.cvControl(
"id_064_WheelMiddle",
side + self.userGuideName + "_" +
self.langDic[self.langName]['m033_middle'] + "_Ctrl",
r=self.ctrlRadius * 0.5,
d=self.curveDegree)
lowerDefCtrl = self.ctrls.cvControl(
"id_063_WheelDeform",
side + self.userGuideName + "_" +
self.langDic[self.langName]['c045_lower'] + "_Ctrl",
r=self.ctrlRadius * 0.5,
d=self.curveDegree,
rot=(0, 0, 180))
defCtrlGrpList = utils.zeroOut(
[upperDefCtrl, middleDefCtrl, lowerDefCtrl])
defCtrlGrp = cmds.group(defCtrlGrpList,
name=side + self.userGuideName +
"_Ctrl_Grp")
# positions:
cmds.delete(
cmds.parentConstraint(upperClusterList[1],
defCtrlGrpList[0],
maintainOffset=False))
cmds.delete(
cmds.parentConstraint(middleClusterList[1],
defCtrlGrpList[1],
maintainOffset=False))
cmds.delete(
cmds.parentConstraint(lowerClusterList[1],
defCtrlGrpList[2],
maintainOffset=False))
cmds.delete(
cmds.parentConstraint(self.cvCenterLoc,
latticeList[1],
maintainOffset=False))
cmds.delete(
cmds.parentConstraint(self.cvCenterLoc,
latticeList[2],
maintainOffset=False))
cmds.delete(
cmds.parentConstraint(self.cvCenterLoc,
clustersGrp,
maintainOffset=False))
cmds.delete(
cmds.parentConstraint(self.cvCenterLoc,
defCtrlGrp,
maintainOffset=False))
outsideDist = cmds.getAttr(self.cvOutsideLoc + ".tz")
if s == 1:
if cmds.getAttr(self.moduleGrp + ".flip") == 1:
outsideDist = -outsideDist
cmds.move(outsideDist,
defCtrlGrp,
moveZ=True,
relative=True,
objectSpace=True,
worldSpaceDistance=True)
self.ctrls.directConnect(upperDefCtrl, upperClusterList[1])
self.ctrls.directConnect(middleDefCtrl, middleClusterList[1])
self.ctrls.directConnect(lowerDefCtrl, lowerClusterList[1])
# grouping deformers:
if self.loadedGeo:
if cmds.objExists(self.loadedGeo):
cmds.lattice(latticeList[0],
edit=True,
geometry=self.loadedGeo)
defGrp = cmds.group(latticeList[1],
latticeList[2],
clustersGrp,
name=side + self.userGuideName +
"_Deform_Grp")
cmds.parentConstraint(self.mainCtrl,
defGrp,
maintainOffset=True,
name=defGrp + "_ParentConstraint")
cmds.scaleConstraint(self.mainCtrl,
defGrp,
maintainOffset=True,
name=defGrp + "_ScaleConstraint")
cmds.parent(defCtrlGrp, self.mainCtrl)
cmds.connectAttr(
self.wheelCtrl + "." +
self.langDic[self.langName]['c021_showControls'],
defCtrlGrp + ".visibility",
force=True)
# create a masterModuleGrp to be checked if this rig exists:
self.toCtrlHookGrp = cmds.group(
zeroGrpList[2],
name=side + self.userGuideName + "_Control_Grp")
self.toScalableHookGrp = cmds.group(
self.centerJoint,
self.mainJoint,
defGrp,
name=side + self.userGuideName + "_Joint_Grp")
self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp,
self.toScalableHookGrp,
self.oldLoc,
self.wheelAutoGrpLoc,
self.geoHolder,
name=side +
self.userGuideName + "_Grp")
# add hook attributes to be read when rigging integrated modules:
utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook')
utils.addHook(objName=self.toScalableHookGrp,
hookType='scalableHook')
utils.addHook(objName=self.toStaticHookGrp,
hookType='staticHook')
cmds.addAttr(self.toStaticHookGrp,
longName="dpAR_name",
dataType="string")
cmds.addAttr(self.toStaticHookGrp,
longName="dpAR_type",
dataType="string")
cmds.setAttr(self.toStaticHookGrp + ".dpAR_name",
self.userGuideName,
type="string")
cmds.setAttr(self.toStaticHookGrp + ".dpAR_type",
CLASS_NAME,
type="string")
# add module type counter value
cmds.addAttr(self.toStaticHookGrp,
longName='dpAR_count',
attributeType='long',
keyable=False)
cmds.setAttr(self.toStaticHookGrp + '.dpAR_count', dpAR_count)
self.ctrlHookGrpList.append(self.toCtrlHookGrp)
if hideJoints:
cmds.setAttr(self.toScalableHookGrp + ".visibility", 0)
# delete duplicated group for side (mirror):
cmds.delete(side + self.userGuideName + '_' + self.mirrorGrp)
# finalize this rig:
self.integratingInfo()
cmds.select(clear=True)
# delete UI (moduleLayout), GUIDE and moduleInstance namespace:
self.deleteModule()
if (mc.objExists("pCube1")):
clean([pathNode, pathNodeCppDraw], [nodeType, nodeTypeDraw])
mc.error("****CLEAN FOR RECOMPILING NODE*****")
print('BUILD TEST __________________________ PREPARE SCENE')
mc.file(pathBuildTest, i=True)
mc.playbackOptions(min=0, max=400)
inputObj = 'pCube1'
outputObj = 'pCone1'
print('BUILD TEST __________________________ LOAD NODE')
mc.loadPlugin(pathNode)
print('BUILD TEST __________________________ CREATE NODE')
newNode = mc.createNode(nodeType)
print('BUILD TEST __________________________ CONNECT IN')
mc.connectAttr(inputObj + '.translateX', newNode + '.inValue')
mc.connectAttr('time1.outTime', newNode + '.currentFrame')
mc.connectAttr(inputObj + '.worldMatrix[0]', newNode + '.drawMatrix')
print('BUILD TEST __________________________ CONNECT OUT')
mc.connectAttr(newNode + '.outValue', outputObj + '.translateY')
print('BUILD TEST __________________________ SET ATTR')
print('BUILD TEST __________________________ DONE')
mc.select(newNode)
#LOAD DRAW
def setUp(self):
self.a = noca.Node(cmds.createNode("transform", name=TEST_NODES[0]))
self.b = noca.Node(cmds.createNode("transform", name=TEST_NODES[1]))
self.c = noca.Node(cmds.createNode("transform", name=TEST_NODES[2]))
self.m = noca.Node(cmds.createNode("holdMatrix", name=TEST_NODES[3]))
def createGuide(self, *args):
Base.StartClass.createGuide(self)
# Custom GUIDE:
cmds.addAttr(self.moduleGrp, longName="flip", attributeType='bool')
cmds.addAttr(self.moduleGrp, longName="geo", dataType='string')
cmds.addAttr(self.moduleGrp,
longName="startFrame",
attributeType='long',
defaultValue=1)
cmds.addAttr(self.moduleGrp,
longName="showControls",
attributeType='bool')
cmds.addAttr(self.moduleGrp, longName="steering", attributeType='bool')
cmds.setAttr(self.moduleGrp + ".flip", 0)
cmds.setAttr(self.moduleGrp + ".showControls", 1)
cmds.setAttr(self.moduleGrp + ".steering", 0)
cmds.setAttr(self.moduleGrp + ".moduleNamespace",
self.moduleGrp[:self.moduleGrp.rfind(":")],
type='string')
self.cvCenterLoc, shapeSizeCH = self.ctrls.cvJointLoc(
ctrlName=self.guideName + "_CenterLoc",
r=0.6,
d=1,
rot=(90, 0, 90),
guide=True)
self.connectShapeSize(shapeSizeCH)
self.jGuideCenter = cmds.joint(name=self.guideName + "_JGuideCenter",
radius=0.001)
cmds.setAttr(self.jGuideCenter + ".template", 1)
cmds.parent(self.jGuideCenter, self.moduleGrp, relative=True)
self.cvFrontLoc = self.ctrls.cvControl("id_059_AimLoc",
ctrlName=self.guideName +
"_FrontLoc",
r=0.3,
d=1,
rot=(0, 0, 90))
self.ctrls.colorShape([self.cvFrontLoc], "blue")
shapeSizeCH = self.ctrls.shapeSizeSetup(self.cvFrontLoc)
self.connectShapeSize(shapeSizeCH)
cmds.parent(self.cvFrontLoc, self.cvCenterLoc)
cmds.setAttr(self.cvFrontLoc + ".tx", 1.3)
self.jGuideFront = cmds.joint(name=self.guideName + "_JGuideFront",
radius=0.001)
cmds.setAttr(self.jGuideFront + ".template", 1)
cmds.transformLimits(self.cvFrontLoc,
translationX=(1, 1),
enableTranslationX=(True, False))
radiusCtrl = self.moduleGrp + "_RadiusCtrl"
cvFrontLocPosNode = cmds.createNode("plusMinusAverage",
name=self.cvFrontLoc + "_Pos_PMA")
cmds.setAttr(cvFrontLocPosNode + ".input1D[0]", -0.5)
cmds.connectAttr(radiusCtrl + ".translateX",
cvFrontLocPosNode + ".input1D[1]")
cmds.connectAttr(cvFrontLocPosNode + ".output1D",
self.cvFrontLoc + ".tx")
self.ctrls.setLockHide(
[self.cvCenterLoc, self.cvFrontLoc],
['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'])
self.cvInsideLoc, shapeSizeCH = self.ctrls.cvLocator(
ctrlName=self.guideName + "_InsideLoc", r=0.2, d=1, guide=True)
self.connectShapeSize(shapeSizeCH)
cmds.parent(self.cvInsideLoc, self.cvCenterLoc)
cmds.setAttr(self.cvInsideLoc + ".tz", 0.3)
self.jGuideInside = cmds.joint(name=self.guideName + "_JGuideInside",
radius=0.001)
cmds.setAttr(self.jGuideInside + ".template", 1)
cmds.transformLimits(self.cvInsideLoc, tz=(0.01, 1), etz=(True, False))
inverseRadius = cmds.createNode("multiplyDivide",
name=self.moduleGrp + "_Radius_Inv_MD")
cmds.setAttr(inverseRadius + ".input2X", -1)
cmds.connectAttr(radiusCtrl + ".translateX",
inverseRadius + ".input1X")
cmds.connectAttr(inverseRadius + ".outputX",
self.cvInsideLoc + ".translateY")
self.ctrls.setLockHide(
[self.cvInsideLoc],
['tx', 'ty', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'])
self.cvOutsideLoc, shapeSizeCH = self.ctrls.cvLocator(
ctrlName=self.guideName + "_OutsideLoc", r=0.2, d=1, guide=True)
self.connectShapeSize(shapeSizeCH)
cmds.parent(self.cvOutsideLoc, self.cvCenterLoc)
cmds.setAttr(self.cvOutsideLoc + ".tz", -0.3)
self.jGuideOutside = cmds.joint(name=self.guideName + "_JGuideOutside",
radius=0.001)
cmds.setAttr(self.jGuideOutside + ".template", 1)
cmds.transformLimits(self.cvOutsideLoc,
tz=(-1, 0.01),
etz=(False, True))
cmds.connectAttr(inverseRadius + ".outputX",
self.cvOutsideLoc + ".translateY")
self.ctrls.setLockHide(
[self.cvOutsideLoc],
['tx', 'ty', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz'])
cmds.parent(self.cvCenterLoc, self.moduleGrp)
cmds.parent(self.jGuideFront, self.jGuideInside, self.jGuideOutside,
self.jGuideCenter)
cmds.parentConstraint(self.cvCenterLoc,
self.jGuideCenter,
maintainOffset=False,
name=self.jGuideCenter + "_ParentConstraint")
cmds.parentConstraint(self.cvFrontLoc,
self.jGuideFront,
maintainOffset=False,
name=self.jGuideFront + "_ParentConstraint")
cmds.parentConstraint(self.cvInsideLoc,
self.jGuideInside,
maintainOffset=False,
name=self.cvInsideLoc + "_ParentConstraint")
cmds.parentConstraint(self.cvOutsideLoc,
self.jGuideOutside,
maintainOffset=False,
name=self.cvOutsideLoc + "_ParentConstraint")
def main(name="assembly", position=(0,0,0), radius=1, fbx=False,
cog=True, body=True, pelvis=True):
if type(position) == str or type(position) == unicode:
position = mc.xform(position, q=True, rp=True, ws=True)
grp = mc.createNode("transform", n=name)
mc.addAttr(grp, ln="joints", at="bool", dv=True, k=True)
mc.addAttr(grp, ln="editJoints", at="bool", k=True)
if fbx:
mc.setAttr(grp+".joints", False)
mc.addAttr(grp, ln="fbxJoints", at="bool", dv=True, k=True)
mc.addAttr(grp, ln="editFbxJoints", at="bool", k=True)
mc.addAttr(grp, ln="controls", at="bool", dv=True, k=True)
mc.addAttr(grp, ln="_geometry", at="bool", dv=True, k=True)
mc.addAttr(grp, ln="editGeometry", at="bool", k=True)
#
# controls
#
ctrl = []
ctrl.append(common.control(name="world", parent=grp, radius=radius*5, color=13,
lockAttr=["v"], hideAttr=["v"])[1])
if cog:
ctrl.append(common.control(name="cog", parent=ctrl[0], position=position,
color=13, radius=radius*4, lockAttr=["s","v"],
hideAttr=["sx","sy","sz","v"])[1])
if body:
ctrl.append(common.control(name="body", parent=ctrl[1], position=ctrl[1],
color=13, radius=radius*3, lockAttr=["s","v"],
hideAttr=["sx","sy","sz","v"])[1])
if pelvis:
ctrl.append(common.control(name="pelvis", parent=ctrl[2], position=ctrl[2],
radius=radius*2, lockAttr=["s","v"],
hideAttr=["sx","sy","sz","v"])[1])
grps = [None]*2
rev = mc.createNode("reverse")
if fbx:
grps[0] = mc.createNode("transform", n="skeleton_fbx")
grps[1] = mc.createNode("transform", n="geometry_fbx")
mc.connectAttr(grp+".fbxJoints", grps[0]+".v")
mc.setAttr(grps[0]+".overrideDisplayType", 2)
mc.connectAttr(grp+".editFbxJoints", rev+".inputX")
mc.connectAttr(rev+".outputX", grps[0]+".overrideEnabled")
mc.createNode("transform", n="constraints_fbx", p=grp)
else:
grps[1] = mc.createNode("transform", n="geometry", p=grp)
mc.connectAttr(grp+"._geometry", grps[1]+".v")
mc.connectAttr(grp+".editGeometry", rev+".inputY")
mc.connectAttr(rev+".outputY", grps[1]+".overrideEnabled")
mc.setAttr(grps[1]+".overrideDisplayType", 2)
for n in grps:
for a in ["tx","ty","tz","rx","ry","rz","sx","sy","sz","v"]:
try: mc.setAttr(n+"."+a, l=True, k=False, cb=False)
except: pass
#
# selection sets
#
n1 = mc.sets(n="ik_controls_set", em=True)
n2 = mc.sets(n="fk_controls_set", em=True)
for n in ctrl: mc.connectAttr(n+".message", n2+".dnSetMembers", na=True)
n3 = mc.sets(n="joints_set", em=True)
n4 = mc.sets(n=name+"_set", em=True)
mc.sets(n1, n2, n3, add=n4)
mc.select(grp)
mc.dgdirty(a=True)
return grp
def getOrigShape(shape):
nodeType = cmds.nodeType(shape)
outputAttr = ''
inputAttr = ''
if nodeType in ['nurbsSurface', 'nurbsCurve']:
outputAttr = 'local'
inputAttr = 'create'
elif nodeType == 'mesh':
outputAttr = 'outMesh'
inputAttr = 'inMesh'
cons = cmds.listConnections(shape, s=1, d=0, c=1, p=1)
origShapeNode = None
if cons:
outputCons = cons[1::2]
inputCons = cons[::2]
outputNode = ''
for i in range(len(inputCons)):
if inputCons[i].split('.')[1] == inputAttr:
outputNode = outputCons[i].split('.')[0]
checkList = []
if outputNode:
def getOrigShapeNode(node):
if node in checkList: return None
checkList.append(node)
if not cmds.nodeType(node): return None
if cmds.nodeType(node) == nodeType:
if cmds.getAttr(node + '.io'):
return node
cons = cmds.listConnections(node, s=1, d=0, p=1, c=1)
nodes = []
if cons:
for con in cons[1::2]:
nodes.append(getOrigShapeNode(con.split('.')[0]))
for node in nodes:
if node:
return node
return None
origShapeNode = getOrigShapeNode(outputNode)
if origShapeNode:
return origShapeNode
else:
cons = 1
while (cons):
cons = cmds.listConnections(shape + '.' + inputAttr, p=1, c=1)
if cons:
for con in cons[1::2]:
cmds.delete(con.split('.')[0])
origNode = cmds.createNode(nodeType, n='temp_origNodeShape')
origP = cmds.listRelatives(origNode, p=1)[0]
cmds.connectAttr(shape + '.' + outputAttr, origNode + '.' + inputAttr)
duOrigP = cmds.duplicate(origP)[0]
duOrig = cmds.listRelatives(duOrigP, s=1)[0]
cmds.connectAttr(duOrig + '.' + outputAttr, shape + '.' + inputAttr)
shapeP = cmds.listRelatives(shape, p=1)[0]
cmds.parent(duOrig, shapeP, add=1, shape=1)
cmds.delete(origP, duOrigP)
cmds.setAttr(duOrig + '.io', 1)
origShapeNode = cmds.rename(duOrig, shape + 'Orig')
return origShapeNode
def rigModule(self, *args):
Base.StartClass.rigModule(self)
# verify if the guide exists:
if cmds.objExists(self.moduleGrp):
try:
hideJoints = cmds.checkBox('hideJointsCB', query=True, value=True)
except:
hideJoints = 1
# declaring lists to send information for integration:
self.scalableGrpList, self.ikCtrlZeroList = [], []
# start as no having mirror:
sideList = [""]
# analisys the mirror module:
self.mirrorAxis = cmds.getAttr(self.moduleGrp + ".mirrorAxis")
if self.mirrorAxis != 'off':
# get rigs names:
self.mirrorNames = cmds.getAttr(self.moduleGrp + ".mirrorName")
# get first and last letters to use as side initials (prefix):
sideList = [self.mirrorNames[0] + '_', self.mirrorNames[len(self.mirrorNames) - 1] + '_']
for s, side in enumerate(sideList):
duplicated = cmds.duplicate(self.moduleGrp, name=side + self.userGuideName + '_Guide_Base')[0]
allGuideList = cmds.listRelatives(duplicated, allDescendents=True)
for item in allGuideList:
cmds.rename(item, side + self.userGuideName + "_" + item)
self.mirrorGrp = cmds.group(name="Guide_Base_Grp", empty=True)
cmds.parent(side + self.userGuideName + '_Guide_Base', self.mirrorGrp, absolute=True)
# re-rename grp:
cmds.rename(self.mirrorGrp, side + self.userGuideName + '_' + self.mirrorGrp)
# do a group mirror with negative scaling:
if s == 1:
for axis in self.mirrorAxis:
cmds.setAttr(side + self.userGuideName + '_' + self.mirrorGrp + '.scale' + axis, -1)
else: # if not mirror:
duplicated = cmds.duplicate(self.moduleGrp, name=self.userGuideName + '_Guide_Base')[0]
allGuideList = cmds.listRelatives(duplicated, allDescendents=True)
for item in allGuideList:
cmds.rename(item, self.userGuideName + "_" + item)
self.mirrorGrp = cmds.group(self.userGuideName + '_Guide_Base', name="Guide_Base_Grp", relative=True)
# re-rename grp:
cmds.rename(self.mirrorGrp, self.userGuideName + '_' + self.mirrorGrp)
# store the number of this guide by module type
dpAR_count = utils.findModuleLastNumber(CLASS_NAME, "dpAR_type") + 1
# run for all sides
for s, side in enumerate(sideList):
self.skinJointList = []
self.base = side + self.userGuideName + '_Guide_Base'
# get the number of joints to be created:
self.nJoints = cmds.getAttr(self.base + ".nJoints")
for n in range(0, self.nJoints + 1):
cmds.select(clear=True)
# declare guide:
self.guide = side + self.userGuideName + "_Guide_JointLoc" + str(n)
# create a joint:
self.jnt = cmds.joint(name=side + self.userGuideName + "_" + str(n) + "_Jnt", scaleCompensate=False)
self.skinJointList.append(self.jnt)
cmds.addAttr(self.jnt, longName='dpAR_joint', attributeType='float', keyable=False)
# create a control:
if n == 1:
self.ctrl = ctrls.cvFinger(ctrlName=side + self.userGuideName + "_" + str(n) + "_Ctrl", r=self.ctrlRadius)
cmds.setAttr(self.ctrl + ".rotateOrder", 1)
utils.originedFrom(objName=self.ctrl, attrString=self.base + ";" + self.guide)
# edit the mirror shape to a good direction of controls:
if s == 1:
if self.mirrorAxis == 'X':
cmds.setAttr(self.ctrl + '.rotateZ', 180)
elif self.mirrorAxis == 'Y':
cmds.setAttr(self.ctrl + '.rotateY', 180)
elif self.mirrorAxis == 'Z':
cmds.setAttr(self.ctrl + '.rotateZ', 180)
elif self.mirrorAxis == 'XY':
cmds.setAttr(self.ctrl + '.rotateX', 180)
elif self.mirrorAxis == 'XYZ':
cmds.setAttr(self.ctrl + '.rotateZ', 180)
cmds.makeIdentity(self.ctrl, apply=True, translate=False, rotate=True, scale=False)
else:
self.ctrl = cmds.circle(name=side + self.userGuideName + "_" + str(n) + "_Ctrl", degree=1, normal=(0, 0, 1), r=self.ctrlRadius, s=6, ch=False)[0]
cmds.setAttr(self.ctrl + ".rotateOrder", 1)
utils.originedFrom(objName=self.ctrl, attrString=self.guide)
if n == 0:
if self.nJoints == 2:
# problably we are creating the first control to a thumb
cmds.scale(2, 2, 2, self.ctrl, relative=True)
cmds.makeIdentity(self.ctrl, apply=True)
else:
# problably we are creating other base controls
cmds.scale(2, 0.5, 1, self.ctrl, relative=True)
cmds.makeIdentity(self.ctrl, apply=True)
# scaleCompensate attribute:
#Not needed in Maya 2016 since we need to deactivate scale compensate on all finger bone
if (int(cmds.about(version=True)[:4]) < 2016):
if n > 0 or self.nJoints == 2:
cmds.addAttr(self.ctrl, longName="scaleCompensate", attributeType='bool', keyable=True)
scaleCompensateCond = cmds.createNode("condition", name=side + self.userGuideName + "_" + str(n) + "_ScaleCompensate_Cnd")
cmds.setAttr(scaleCompensateCond + ".secondTerm", 1)
cmds.connectAttr(self.ctrl + ".scaleCompensate", scaleCompensateCond + ".colorIfTrueR", force=True)
cmds.connectAttr(scaleCompensateCond + ".outColorR", self.jnt + ".segmentScaleCompensate", force=True)
# hide visibility attribute:
cmds.setAttr(self.ctrl + '.visibility', keyable=False)
# put another group over the control in order to use this to connect values from mainFingerCtrl:
self.sdkGrp = cmds.group(self.ctrl, name=side + self.userGuideName + "_" + str(n) + "_SDKGrp")
if n == 1:
# change pivot of this group to control pivot:
pivotPos = cmds.xform(self.ctrl, query=True, worldSpace=True, rotatePivot=True)
cmds.setAttr(self.sdkGrp + '.rotatePivotX', pivotPos[0])
cmds.setAttr(self.sdkGrp + '.rotatePivotY', pivotPos[1])
cmds.setAttr(self.sdkGrp + '.rotatePivotZ', pivotPos[2])
# position and orientation of joint and control:
tempDel = cmds.parentConstraint(self.guide, self.jnt, maintainOffset=False)
cmds.delete(tempDel)
tempDel = cmds.parentConstraint(self.guide, self.sdkGrp, maintainOffset=False)
cmds.delete(tempDel)
# zeroOut controls:
utils.zeroOut([self.sdkGrp])
# create end joint:
self.cvEndJoint = side + self.userGuideName + "_Guide_JointEnd"
self.endJoint = cmds.joint(name=side + self.userGuideName + "_JEnd", scaleCompensate=False)
tempDel = cmds.parentConstraint(self.cvEndJoint, self.endJoint, maintainOffset=False)
cmds.delete(tempDel)
cmds.parent(self.endJoint, side + self.userGuideName + "_" + str(self.nJoints) + "_Jnt", absolute=True)
# grouping:
for n in range(0, self.nJoints + 1):
self.jnt = side + self.userGuideName + "_" + str(n) + "_Jnt"
self.ctrl = side + self.userGuideName + "_" + str(n) + "_Ctrl"
self.zeroCtrl = side + self.userGuideName + "_" + str(n) + "_SDKGrp_Zero"
if n > 0:
if n == 1:
if not cmds.objExists(self.ctrl + '.ikFkBlend'):
cmds.addAttr(self.ctrl, longName="ikFkBlend", attributeType='float', keyable=True, minValue=0.0, maxValue=1.0, defaultValue=1.0)
self.ikFkRevNode = cmds.createNode("reverse", name=side + self.userGuideName + "_ikFk_Rev")
cmds.connectAttr(self.ctrl + ".ikFkBlend", self.ikFkRevNode + ".inputX", force=True)
if not cmds.objExists(self.ctrl + '.' + self.langDic[self.langName]['c_showControls']):
cmds.addAttr(self.ctrl, longName=self.langDic[self.langName]['c_showControls'], attributeType='float', keyable=True, minValue=0.0, maxValue=1.0, defaultValue=1.0)
self.ctrlShape0 = cmds.listRelatives(side + self.userGuideName + "_0_Ctrl", children=True, type='nurbsCurve')[0]
cmds.connectAttr(self.ctrl + "." + self.langDic[self.langName]['c_showControls'], self.ctrlShape0 + ".visibility", force=True)
cmds.setAttr(self.ctrl + '.' + self.langDic[self.langName]['c_showControls'], keyable=False, channelBox=True)
for j in range(1, self.nJoints + 1):
cmds.addAttr(self.ctrl, longName=self.langDic[self.langName]['c_falange'] + str(j), attributeType='float', keyable=True)
# parent joints as a simple chain (line)
self.fatherJnt = side + self.userGuideName + "_" + str(n - 1) + "_Jnt"
cmds.parent(self.jnt, self.fatherJnt, absolute=True)
# parent zeroCtrl Group to the before ctrl:
self.fatherCtrl = side + self.userGuideName + "_" + str(n - 1) + "_Ctrl"
cmds.parent(self.zeroCtrl, self.fatherCtrl, absolute=True)
# freeze joints rotation
cmds.makeIdentity(self.jnt, apply=True)
# create parent and scale constraints from ctrl to jnt:
cmds.delete(cmds.parentConstraint(self.ctrl, self.jnt, maintainOffset=False, name=self.jnt + "_ParentConstraint"))
# make first falange be leads from base finger control:
cmds.parentConstraint(side + self.userGuideName + "_0_Ctrl", side + self.userGuideName + "_1_SDKGrp_Zero", maintainOffset=True, name=side + self.userGuideName + "_1_SDKGrp_Zero" + "_ParentConstraint")
cmds.scaleConstraint(side + self.userGuideName + "_0_Ctrl", side + self.userGuideName + "_1_SDKGrp_Zero", maintainOffset=True, name=side + self.userGuideName + "_1_SDKGrp_Zero" + "_ScaleConstraint")
if self.nJoints != 2:
cmds.parentConstraint(side + self.userGuideName + "_0_Ctrl", side + self.userGuideName + "_0_Jnt", maintainOffset=True, name=side + self.userGuideName + "_ParentConstraint")
cmds.scaleConstraint(side + self.userGuideName + "_0_Ctrl", side + self.userGuideName + "_0_Jnt", maintainOffset=True, name=side + self.userGuideName + "_ScaleConstraint")
# connecting the attributes from control 1 to falanges rotate:
for n in range(1, self.nJoints + 1):
self.ctrl = side + self.userGuideName + "_1_Ctrl"
self.sdkGrp = side + self.userGuideName + "_" + str(n) + "_SDKGrp"
cmds.connectAttr(self.ctrl + "." + self.langDic[self.langName]['c_falange'] + str(n), self.sdkGrp + ".rotateY", force=True)
if n > 1:
self.ctrlShape = cmds.listRelatives(side + self.userGuideName + "_" + str(n) + "_Ctrl", children=True, type='nurbsCurve')[0]
cmds.connectAttr(self.ctrl + "." + self.langDic[self.langName]['c_showControls'], self.ctrlShape + ".visibility", force=True)
# ik and Fk setup
if self.nJoints == 2:
dupIk = cmds.duplicate(self.skinJointList[0])[0]
dupFk = cmds.duplicate(self.skinJointList[0])[0]
else:
dupIk = cmds.duplicate(self.skinJointList[1])[0]
dupFk = cmds.duplicate(self.skinJointList[1])[0]
# hide ik and fk joints in order to be rigger friendly whe skinning
cmds.setAttr(dupIk+".visibility", 0)
cmds.setAttr(dupFk+".visibility", 0)
# ik setup
childrenIkList = cmds.listRelatives(dupIk, children=True, allDescendents=True, fullPath=True)
if childrenIkList:
for child in childrenIkList:
if not cmds.objectType(child) == "joint":
cmds.delete(child)
jointIkList = cmds.listRelatives(dupIk, children=True, allDescendents=True, fullPath=True)
for jointNode in jointIkList:
if "_Jnt" in jointNode[jointNode.rfind("|"):]:
cmds.rename(jointNode, jointNode[jointNode.rfind("|") + 1:].replace("_Jnt", "_Ik_Jxt"))
elif "_JEnd" in jointNode[jointNode.rfind("|"):]:
cmds.rename(jointNode, jointNode[jointNode.rfind("|") + 1:].replace("_JEnd", "_Ik_JEnd"))
ikBaseJoint = cmds.rename(dupIk, dupIk.replace("_Jnt1", "_Ik_Jxt"))
ikJointList = cmds.listRelatives(ikBaseJoint, children=True, allDescendents=True)
ikJointList.append(ikBaseJoint)
# Fk setup
childrenFkList = cmds.listRelatives(dupFk, children=True, allDescendents=True, fullPath=True)
if childrenFkList:
for child in childrenFkList:
if not cmds.objectType(child) == "joint":
cmds.delete(child)
jointFkList = cmds.listRelatives(dupFk, children=True, allDescendents=True, fullPath=True)
for jointNode in jointFkList:
if "_Jnt" in jointNode[jointNode.rfind("|"):]:
cmds.rename(jointNode, jointNode[jointNode.rfind("|") + 1:].replace("_Jnt", "_Fk_Jxt"))
elif "_JEnd" in jointNode[jointNode.rfind("|"):]:
cmds.rename(jointNode, jointNode[jointNode.rfind("|") + 1:].replace("_JEnd", "_Fk_JEnd"))
fkBaseJoint = cmds.rename(dupFk, dupFk.replace("_Jnt2", "_Fk_Jxt"))
fkJointList = cmds.listRelatives(fkBaseJoint, children=True, allDescendents=True)
fkJointList.append(fkBaseJoint)
# ik fk blend connnections
for i, ikJoint in enumerate(ikJointList):
if not "_JEnd" in ikJoint:
if cmds.objExists(ikJoint + ".dpAR_joint"):
cmds.deleteAttr(ikJoint + ".dpAR_joint")
fkJoint = ikJoint.replace("_Ik_Jxt", "_Fk_Jxt")
skinJoint = ikJoint.replace("_Ik_Jxt", "_Jnt")
self.ctrl = side + self.userGuideName + "_1_Ctrl"
scaleCompensateCond = ikJoint.replace("_Ik_Jxt", "_ScaleCompensate_Cnd")
ikFkParentConst = cmds.parentConstraint(ikJoint, fkJoint, skinJoint, maintainOffset=True, name=skinJoint + "_ParentConstraint")[0]
ikFkScaleConst = cmds.scaleConstraint(ikJoint, fkJoint, skinJoint, maintainOffset=True, name=skinJoint + "_ScaleConstraint")[0]
cmds.connectAttr(self.ctrl + ".ikFkBlend", ikFkParentConst + "." + fkJoint + "W1", force=True)
cmds.connectAttr(self.ikFkRevNode + ".outputX", ikFkParentConst + "." + ikJoint + "W0", force=True)
cmds.connectAttr(self.ctrl + ".ikFkBlend", ikFkScaleConst + "." + fkJoint + "W1", force=True)
cmds.connectAttr(self.ikFkRevNode + ".outputX", ikFkScaleConst + "." + ikJoint + "W0", force=True)
cmds.setAttr(ikJoint + ".segmentScaleCompensate", 1)
#Condition for scale compensate will not exist in maya 2016 since we need to have the compensate
#off for almost every joint
if (int(cmds.about(version=True)[:4]) < 2016):
cmds.connectAttr(self.ctrl + ".ikFkBlend", scaleCompensateCond + ".firstTerm", force=True)
# fk control drives fk joints
for i, fkJoint in enumerate(fkJointList):
if not "_JEnd" in fkJoint:
if cmds.objExists(fkJoint + ".dpAR_joint"):
cmds.deleteAttr(fkJoint + ".dpAR_joint")
fkCtrl = fkJoint.replace("_Fk_Jxt", "_Ctrl")
scaleCompensateCond = fkCtrl.replace("_Ctrl", "_ScaleCompensate_Cnd")
cmds.parentConstraint(fkCtrl, fkJoint, maintainOffset=True, name=fkJoint + "_ParentConstraint")
cmds.scaleConstraint(fkCtrl, fkJoint, maintainOffset=True, name=fkJoint + "_ScaleConstraint")
#Not needed in Maya 2016 since we need to deactivate scale compensate on all finger bone
if (int(cmds.about(version=True)[:4]) < 2016):
cmds.connectAttr(fkCtrl + ".scaleCompensate", fkJoint + ".segmentScaleCompensate", force=True)
else:
cmds.setAttr(fkJoint + ".segmentScaleCompensate", 0)
cmds.setAttr(fkCtrl + ".rotateOrder", 1)
#Force Scale compensate to prevent scale problem in Maya 2016
for nJnt in self.skinJointList:
if (int(cmds.about(version=True)[:4]) >= 2016):
cmds.setAttr(nJnt + ".segmentScaleCompensate", 0)
# ik handle
if self.nJoints >= 2:
if self.nJoints == 2:
ikHandleList = cmds.ikHandle(startJoint=side + self.userGuideName + "_0_Ik_Jxt", endEffector=side + self.userGuideName + "_" + str(self.nJoints) + "_Ik_Jxt", solver="ikRPsolver", name=side + self.userGuideName + "_IkHandle")
else:
ikHandleList = cmds.ikHandle(startJoint=side + self.userGuideName + "_1_Ik_Jxt", endEffector=side + self.userGuideName + "_" + str(self.nJoints) + "_Ik_Jxt", solver="ikRPsolver", name=side + self.userGuideName + "_IkHandle")
cmds.rename(ikHandleList[1], side + self.userGuideName + "_Effector")
endIkHandleList = cmds.ikHandle(startJoint=side + self.userGuideName + "_" + str(self.nJoints) + "_Ik_Jxt", endEffector=side + self.userGuideName + "_Ik_JEnd", solver="ikSCsolver", name=side + self.userGuideName + "_EndIkHandle")
cmds.rename(endIkHandleList[1], side + self.userGuideName + "_EndEffector")
self.ikCtrl = ctrls.cvBox(ctrlName=side + self.userGuideName + "_Ik_Ctrl", r=self.ctrlRadius*0.3)
cmds.addAttr(self.ikCtrl, longName='twist', attributeType='float', keyable=True)
cmds.connectAttr(self.ikCtrl + ".twist", ikHandleList[0] + ".twist", force=True)
cmds.delete(cmds.parentConstraint(side + self.userGuideName + "_Ik_JEnd", self.ikCtrl))
cmds.setAttr(self.ikCtrl + ".rotateOrder", 1)
self.ikCtrlZero = utils.zeroOut([self.ikCtrl])[0]
self.ikCtrlZeroList.append(self.ikCtrlZero)
cmds.connectAttr(self.ikFkRevNode + ".outputX", self.ikCtrlZero + ".visibility", force=True)
for q in range(2, self.nJoints):
cmds.connectAttr(side + self.userGuideName + "_1_Ctrl.ikFkBlend", side + self.userGuideName + "_" + str(q) + "_Ctrl.visibility", force=True)
cmds.parentConstraint(self.ikCtrl, ikHandleList[0], name=side + self.userGuideName + "_IkHandle_ParentConstraint", maintainOffset=True)
cmds.parentConstraint(self.ikCtrl, endIkHandleList[0], name=side + self.userGuideName + "_EndIkHandle_ParentConstraint", maintainOffset=True)
ikHandleGrp = cmds.group(ikHandleList[0], endIkHandleList[0], name=side + self.userGuideName + "_IkHandle_Grp")
cmds.setAttr(ikHandleGrp+".visibility", 0)
ctrls.setLockHide([self.ikCtrl], ['sx', 'sy', 'sz', 'v'])
if self.nJoints == 2:
cmds.parentConstraint(side + self.userGuideName + "_0_Ctrl", side + self.userGuideName + "_0_Ik_Jxt", maintainOffset=True, name=side + self.userGuideName + "_0_Ik_Jxt_ParentConstraint")
cmds.scaleConstraint(side + self.userGuideName + "_0_Ctrl", side + self.userGuideName + "_0_Ik_Jxt", maintainOffset=True, name=side + self.userGuideName + "_0_Ik_Jxt_ScaleConstraint")
# stretch
cmds.addAttr(self.ikCtrl, longName='stretchable', attributeType='float', minValue=0, maxValue=1, defaultValue=0, keyable=True)
stretchNormMD = cmds.createNode("multiplyDivide", name=side + self.userGuideName + "_StretchNormalize_MD")
cmds.setAttr(stretchNormMD + ".operation", 2)
distBetweenList = ctrls.distanceBet(side + self.userGuideName + "_0_Ctrl", self.ikCtrl, name=side + self.userGuideName + "_DistBet", keep=True)
cmds.connectAttr(self.ikFkRevNode + ".outputX", distBetweenList[5] + "." + self.ikCtrl + "W0", force=True)
cmds.connectAttr(self.ctrl + ".ikFkBlend", distBetweenList[5] + "." + distBetweenList[4] + "W1", force=True)
cmds.connectAttr(distBetweenList[1] + ".distance", stretchNormMD + ".input1X", force=True)
cmds.setAttr(stretchNormMD + ".input2X", distBetweenList[0])
stretchScaleMD = cmds.createNode("multiplyDivide", name=side + self.userGuideName + "_StretchScale_MD")
cmds.connectAttr(stretchNormMD + ".outputX", stretchScaleMD + ".input1X", force=True)
cmds.connectAttr(self.ikCtrl + ".stretchable", stretchScaleMD + ".input2X", force=True)
stretchCond = cmds.createNode("condition", name=side + self.userGuideName + "_Stretch_Cnd")
cmds.connectAttr(stretchScaleMD + ".outputX", stretchCond + ".firstTerm", force=True)
cmds.setAttr(stretchCond + ".secondTerm", 1)
cmds.setAttr(stretchCond + ".operation", 2)
cmds.connectAttr(stretchScaleMD + ".outputX", stretchCond + ".colorIfTrueR", force=True)
for i, ikJoint in enumerate(ikJointList):
if not "_JEnd" in ikJoint:
if self.nJoints == 2 and i == 0:
pass
else:
cmds.connectAttr(stretchCond + ".outColorR", ikJoint + ".scaleZ", force=True)
# create a masterModuleGrp to be checked if this rig exists:
self.toCtrlHookGrp = cmds.group(self.ikCtrlZero, side + self.userGuideName + "_0_SDKGrp_Zero", side + self.userGuideName + "_1_SDKGrp_Zero", name=side + self.userGuideName + "_Control_Grp")
if self.nJoints == 2:
self.toScalableHookGrp = cmds.group(side + self.userGuideName + "_0_Jnt", ikBaseJoint, fkBaseJoint, ikHandleGrp, distBetweenList[2], distBetweenList[3], distBetweenList[4], name=side + self.userGuideName + "_Joint_Grp")
else:
self.toScalableHookGrp = cmds.group(side + self.userGuideName + "_0_Jnt", ikHandleGrp, distBetweenList[2], distBetweenList[3], distBetweenList[4], name=side + self.userGuideName + "_Joint_Grp")
else:
self.toCtrlHookGrp = cmds.group(side + self.userGuideName + "_0_SDKGrp_Zero", side + self.userGuideName + "_1_SDKGrp_Zero", name=side + self.userGuideName + "_Control_Grp")
self.toScalableHookGrp = cmds.group(side + self.userGuideName + "_0_Jnt", name=side + self.userGuideName + "_Joint_Grp")
self.scalableGrpList.append(self.toScalableHookGrp)
self.toStaticHookGrp = cmds.group(self.toCtrlHookGrp, self.toScalableHookGrp, name=side + self.userGuideName + "_Grp")
# add hook attributes to be read when rigging integrated modules:
utils.addHook(objName=self.toCtrlHookGrp, hookType='ctrlHook')
utils.addHook(objName=self.toScalableHookGrp, hookType='scalableHook')
utils.addHook(objName=self.toStaticHookGrp, hookType='staticHook')
cmds.addAttr(self.toStaticHookGrp, longName="dpAR_name", dataType="string")
cmds.addAttr(self.toStaticHookGrp, longName="dpAR_type", dataType="string")
cmds.setAttr(self.toStaticHookGrp + ".dpAR_name", self.userGuideName, type="string")
cmds.setAttr(self.toStaticHookGrp + ".dpAR_type", CLASS_NAME, type="string")
# add module type counter value
cmds.addAttr(self.toStaticHookGrp, longName='dpAR_count', attributeType='long', keyable=False)
cmds.setAttr(self.toStaticHookGrp + '.dpAR_count', dpAR_count)
# create a locator in order to avoid delete static group
loc = cmds.spaceLocator(name=side + self.userGuideName + "_DO_NOT_DELETE")[0]
cmds.parent(loc, self.toStaticHookGrp, absolute=True)
cmds.setAttr(loc + ".visibility", 0)
ctrls.setLockHide([loc], ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'])
if hideJoints:
cmds.setAttr(self.toScalableHookGrp + ".visibility", 0)
# delete duplicated group for side (mirror):
cmds.delete(side + self.userGuideName + '_' + self.mirrorGrp)
# finalize this rig:
self.integratingInfo()
cmds.select(clear=True)
# delete UI (moduleLayout), GUIDE and moduleInstance namespace:
self.deleteModule()
def test_integration_1(manager):
"""
1) Create a compound
2) Register the compound
3) Modify the compound
4) Register a new version of the compound
5) Rollback to the previous version
6) Update to latest
"""
def _test_compound_v1():
"""
Validate the namespace actually contain v1 of our test compound.
:param str namespace: The compound namespace
"""
# Validate internal connections
for src, dst in (
("foo:inputs.input1X", "foo:multiplyDivide1"),
("foo:multiplyDivide1.outputX", "foo:outputs.outputX"),
):
cmds.isConnected(src, dst)
# Validate external connections
for src, dst in (
("testInn.translateX", "foo:inputs.input1X"),
("foo:outputs.outputX", "testOut.translateX"),
):
cmds.isConnected(src, dst)
# Validate scene content
for dagpath in (
"foo:inputs",
"foo:inputs.input1X",
"foo:multiplyDivide1",
"foo:outputs",
"foo:outputs.outputX",
):
assert cmds.objExists(dagpath)
for dagpath in ("foo:outputs.outputY",):
assert not cmds.objExists(dagpath)
def _test_compound_v2():
for dagpath in (
"foo:inputs",
"foo:inputs.input1X",
"foo:multiplyDivide1",
"foo:outputs",
"foo:outputs.outputX",
"foo:outputs.outputY",
):
assert cmds.objExists(dagpath)
# 1) Create a simple network
mult1 = pymel.createNode("multiplyDivide")
# Create a compound from the network
compound = create_from_nodes([mult1], namespace="foo")
a = mult1.input1X
compound.expose_input_attr(a)
compound.expose_output_attr(mult1.outputX)
# Create connections from outside the compound
cmds.createNode("transform", name="testInn")
cmds.createNode("transform", name="testOut")
cmds.connectAttr("testInn.translateX", "foo:inputs.input1X")
cmds.connectAttr("foo:outputs.outputX", "testOut.translateX")
_test_compound_v1()
# Register the compound?
compound_def_1 = CompoundDefinition(
name="compound_name", version="1.0.0", uid="compound_uid"
)
compound.set_metadata(dict(compound_def_1))
manager.publish_compound(compound)
# Modify the scene content
compound.expose_output_attr(mult1.outputY)
_test_compound_v2()
# TODO: Error if the file does not end with .ma?
compound_def_2 = CompoundDefinition(
name="compound_name", version="1.0.1", uid="compound_uid"
)
compound.set_metadata(dict(compound_def_2))
manager.publish_compound(compound)
cmds.connectAttr("foo:outputs.outputY", "testOut.translateY")
# Downgrade our compound
manager.update_compound(compound, "1.0.0")
_test_compound_v1()
# Upgrade our compound
manager.update_compound(compound)
_test_compound_v2()
# Verify that we can restore our in-memory registry
new_registry = Registry()
new_registry.parse_directory(manager.preferences.compound_location)
assert manager.registry == new_registry
def dupToCurveFlow():
allSel = mc.ls(sl=True)
count = len(allSel)
if count < 2:
om.MGlobal.displayError(
'Please select some will follow Curve Objects and Curve...')
return
curveSel = mc.ls(sl=True, tail=1)
if mc.nodeType(curveSel[0]) == 'transform':
curveShape = mc.listRelatives(curveSel, shapes=True)
if mc.nodeType(curveShape[0]) == 'nurbsCurve':
shape = curveShape[0]
elif mc.nodeType(curveSel[0]) == 'nurbsCurve':
shape = curveSel[0]
else:
om.MGlobal.displayError('Please select lastest Curve...')
return
_min = mc.getAttr(shape + '.minValue')
_max = mc.getAttr(shape + '.maxValue')
objSel = allSel[:count - 1]
for eachObj in objSel:
if mc.attributeQuery('translate', node=eachObj, ex=True) == False:
om.MGlobal.displayWarning(
'%s Object have not "Transform" attribute,ingore it...' %
eachObj)
objSel.remove(eachObj)
elif mc.attributeQuery('rotate', node=eachObj, ex=True) == False:
om.MGlobal.displayWarning(
'%s Object have not "Rotate" attribute,ingore it...' % eachObj)
objSel.remove(eachObj)
_length = _max - _min
segment = _length / (len(objSel) - 1)
if not mc.pluginInfo('dupToCurveFlowPlugin.py', q=True, l=True):
mc.loadPlugin(
r'\\octvision.com\cg\TD\Maya\2012\Plugins\dupToCurveFlowPlugin.py')
icNode = mc.createNode('ic_dupToCurveFlow')
mc.connectAttr(shape + '.local', icNode + '.inCurve', f=True)
for i in range(0, len(objSel)):
mc.getAttr(icNode + '.outTranslate[%i]' % i)
mc.getAttr(icNode + '.outRotate[%i]' % i)
if not mc.attributeQuery('param', node=objSel[i], ex=True):
mc.addAttr(objSel[i], ln='param', at='double')
mc.setAttr(objSel[i] + '.param', e=True, keyable=True)
mc.connectAttr(objSel[i] + '.param',
icNode + '.inParam[%i]' % i,
f=True)
mc.connectAttr(icNode + '.outTranslate[%i].outTranslateX' % i,
objSel[i] + '.translateX',
f=True)
mc.connectAttr(icNode + '.outTranslate[%i].outTranslateY' % i,
objSel[i] + '.translateY',
f=True)
mc.connectAttr(icNode + '.outTranslate[%i].outTranslateZ' % i,
objSel[i] + '.translateZ',
f=True)
mc.connectAttr(icNode + '.outRotate[%i].outRotateX' % i,
objSel[i] + '.rotateX',
f=True)
mc.connectAttr(icNode + '.outRotate[%i].outRotateY' % i,
objSel[i] + '.rotateY',
f=True)
mc.connectAttr(icNode + '.outRotate[%i].outRotateZ' % i,
objSel[i] + '.rotateZ',
f=True)
mc.setAttr(objSel[i] + '.param', segment * i)
def create(self):
sGrp = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sRig' %(self._sPart, self._sName), iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sConnectInJnt)
sGrpCtrl = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sCtrl' %(self._sPart, self._sName), iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = self._sConnectInCtrl)
sParent_jnt = sGrp
lJnts = []
for i, sBpJnt in enumerate(self._lBpJnts):
oJntName = naming.oName(sBpJnt)
oJntName.sType = 'jnt'
sJnt = joints.createJntOnExistingNode(sBpJnt, sBpJnt, oJntName.sName, sParent = sParent_jnt)
lJnts.append(sJnt)
sParent_jnt = sJnt
## rig each limb
iJnts_min = len(lJnts)
dRigLimbs = {}
lCtrls = []
for sMode in self._dRigLimbs.keys():
dRigLimbs_each = {sMode: {
'iIndex': 0,
'class': None,
'lJnts': None,
}}
oLimb = self._dRigLimbs[sMode]['class'](sSide = self._sSide, iIndex = self._iIndex)
oLimb._lBpJnts = self._lBpJnts
oLimb._sConnectInJnt = sGrp
oLimb._sConnectInCtrl = sGrpCtrl
oLimb.create()
if self._dRigLimbs[sMode].has_key('iIndex'):
dRigLimbs_each[sMode]['iIndex'] = self._dRigLimbs[sMode]['iIndex']
else:
dRigLimbs_each[sMode]['iIndex'] = namingDict.spaceDict[sMode]
dRigLimbs_each[sMode]['class'] = oLimb
if hasattr(oLimb, 'lJntsOutput'):
dRigLimbs_each[sMode]['lJnts'] = oLimb.lJntsOutput
if len(oLimb.lJntsOutput) < iJnts_min:
iJnts_min = len(oLimb.lJntsOutput)
else:
dRigLimbs_each[sMode]['lJnts'] = oLimb.lJnts
if len(oLimb.lJnts) < iJnts_min:
iJnts_min = len(oLimb.lJnts)
lCtrls += oLimb.lCtrls
dRigLimbs.update(dRigLimbs_each)
## add shape node
sCtrlShape = naming.oName(sType = 'ctrl', sSide = self._sSide, sPart = self._sPart, iIndex = self._iIndex).sName
controls.addCtrlShape(lCtrls, sCtrlShape, bVis = False)
## blend constraint joints
for i in range(0, iJnts_min):
lDrivers = []
#dDrivers = {'cog': {'iIndex': 0, 'sOutput': 'ctrl_m_cog'}}
dDrivers = {}
for sMode in dRigLimbs.keys():
dDriver_each = {sMode: {'iIndex': dRigLimbs[sMode]['iIndex'], 'sOutput': dRigLimbs[sMode]['lJnts'][i]}}
dDrivers.update(dDriver_each)
constraints.spaceConstraint(dDrivers, lJnts[i], sType = self._sConstraintType, sCtrl = sCtrlShape, bMaintainOffset = False, sName = self._sName, lDefaultVal = None)
## vis switch
sCondition = naming.oName(sType = 'condition', sSide = self._sSide, sPart = '%s%s%sSelector' %(self._sPart, self._sName[0].upper(), self._sName[1:]), iIndex = self._iIndex).sName
cmds.createNode('condition', name = sCondition)
cmds.connectAttr('%s.%sModeA' %(sCtrlShape, self._sName), '%s.colorIfTrueR' %sCondition)
cmds.connectAttr('%s.%sModeB' %(sCtrlShape, self._sName), '%s.colorIfFalseR' %sCondition)
cmds.connectAttr('%s.%sModeBlend' %(sCtrlShape, self._sName), '%s.firstTerm' %sCondition)
cmds.setAttr('%s.secondTerm' %sCondition, 0.5)
cmds.setAttr('%s.operation' %sCondition, 4)
lAttrs = []
lEnumIndex = []
for sMode in dRigLimbs.keys():
lAttrs.append('%s.v' %dRigLimbs[sMode]['class'].sGrpCtrl)
lEnumIndex.append(dRigLimbs[sMode]['iIndex'])
attributes.enumToMultiAttrs('outColorR', lAttrs, iEnumRange = len(lEnumIndex), lEnumIndex = lEnumIndex, sEnumObj = sCondition)
#enumToMultiAttrs(sEnumAttr, lAttrs, iEnumRange = 2, lEnumIndex = None, lValRange = [[0,1]], sEnumObj = None)
#### control connect out node
sConnectOutCtrl = transforms.createTransformNode(naming.oName(sType = 'grp', sSide = self._sSide, sPart = '%s%sConnectOutCtrl' %(self._sPart, self._sName), iIndex = self._iIndex).sName, lLockHideAttrs = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v'], sParent = sGrpCtrl, bVis = True)
constraints.constraint([lJnts[-1], sConnectOutCtrl], sType = 'parent', bForce = True, bMaintainOffset = True)
lCtrls = sCtrlShape
## write rig info
sModuleNodes = ''
sModuleIndex = ''
for sMode in dRigLimbs.keys():
sModuleNodes += '%s,' %dRigLimbs[sMode]['class'].sModuleNode
sModuleIndex += '%d,' %dRigLimbs[sMode]['iIndex']
sString_lJnts = self._convertListToString(lJnts)
sString_lCtrls = self._convertListToString(lCtrls)
lRigInfo = ['blendModeRig', sGrp, self._sConnectInJnt, self._sConnectInCtrl, lJnts[-1], sConnectOutCtrl, sString_lJnts, sString_lCtrls, sGrpCtrl, sModuleNodes[:-1], sModuleIndex[:-1]]
lAttrs = ['sModuleType', 'sModuleNode', 'sConnectInJnt', 'sConnectInCtrl', 'sConnectOutJnt', 'sConnectOutCtrl', 'lJnts', 'lCtrls', 'sGrpCtrl', 'lModuleNodes', 'lModuleIndex']
self._writeRigInfo(sGrp, lRigInfo, lAttrs)
self._getRigInfo(sGrp)
def testAnimNurbsPlaneWrite(self, wfg=False):
ret = MayaCmds.nurbsPlane(p=(0, 0, 0), ax=(0, 1, 0), w=1, lr=1, d=3,
u=5, v=5, ch=0)
name = ret[0]
MayaCmds.lattice(name, dv=(4, 5, 4), oc=True)
MayaCmds.select('ffd1Lattice.pt[1:2][0:4][1:2]', r=True)
MayaCmds.currentTime(1, update=True)
MayaCmds.setKeyframe()
MayaCmds.currentTime(24, update=True)
MayaCmds.setKeyframe()
MayaCmds.currentTime(12, update=True)
MayaCmds.move( 0, 0.18, 0, r=True)
MayaCmds.scale( 2.5, 1.0, 2.5, r=True)
MayaCmds.setKeyframe()
MayaCmds.curveOnSurface(name,
uv=((0.597523,0), (0.600359,0.271782), (0.538598,0.564218),
(0.496932,0.779936), (0.672153,1)),
k=(0,0,0,0.263463,0.530094,0.530094,0.530094))
curvename = MayaCmds.curveOnSurface(name,
uv=((0.170718,0.565967), (0.0685088,0.393034), (0.141997,0.206296),
(0.95,0.230359), (0.36264,0.441381), (0.251243,0.569889)),
k=(0,0,0,0.200545,0.404853,0.598957,0.598957,0.598957))
MayaCmds.closeCurve(curvename, ch=1, ps=1, rpo=1, bb=0.5, bki=0, p=0.1,
cos=1)
MayaCmds.trim(name, lu=0.23, lv=0.39)
degreeU = MayaCmds.getAttr(name+'.degreeU')
degreeV = MayaCmds.getAttr(name+'.degreeV')
spansU = MayaCmds.getAttr(name+'.spansU')
spansV = MayaCmds.getAttr(name+'.spansV')
formU = MayaCmds.getAttr(name+'.formU')
formV = MayaCmds.getAttr(name+'.formV')
minU = MayaCmds.getAttr(name+'.minValueU')
maxU = MayaCmds.getAttr(name+'.maxValueU')
minV = MayaCmds.getAttr(name+'.minValueV')
maxV = MayaCmds.getAttr(name+'.maxValueV')
MayaCmds.createNode('surfaceInfo')
MayaCmds.connectAttr(name+'.worldSpace', 'surfaceInfo1.inputSurface',
force=True)
MayaCmds.currentTime(1, update=True)
controlPoints = MayaCmds.getAttr('surfaceInfo1.controlPoints[*]')
knotsU = MayaCmds.getAttr('surfaceInfo1.knotsU[*]')
knotsV = MayaCmds.getAttr('surfaceInfo1.knotsV[*]')
MayaCmds.currentTime(12, update=True)
controlPoints2 = MayaCmds.getAttr('surfaceInfo1.controlPoints[*]')
knotsU2 = MayaCmds.getAttr('surfaceInfo1.knotsU[*]')
knotsV2 = MayaCmds.getAttr('surfaceInfo1.knotsV[*]')
if wfg:
self.__files.append(util.expandFileName('testAnimNurbsPlane.abc'))
MayaCmds.AbcExport(j='-fr 1 24 -frs -0.25 -frs 0.0 -frs 0.25 -wfg -root %s -file %s' % (name, self.__files[-1]))
# reading test
MayaCmds.AbcImport(self.__files[-1], mode='open')
else:
self.__files.append(util.expandFileName('testAnimNurbsPlane.abc'))
self.__files.append(util.expandFileName('testAnimNurbsPlane01_14.abc'))
self.__files.append(util.expandFileName('testAnimNurbsPlane15_24.abc'))
MayaCmds.AbcExport(j='-fr 1 14 -root %s -file %s' % (name, self.__files[-2]))
MayaCmds.AbcExport(j='-fr 15 24 -root %s -file %s' % (name, self.__files[-1]))
# use AbcStitcher to combine two files into one
subprocess.call(self.__abcStitcher + self.__files[-3:])
# reading test
MayaCmds.AbcImport(self.__files[-3], mode='open')
self.failUnlessEqual(degreeU, MayaCmds.getAttr(name+'.degreeU'))
self.failUnlessEqual(degreeV, MayaCmds.getAttr(name+'.degreeV'))
self.failUnlessEqual(spansU, MayaCmds.getAttr(name+'.spansU'))
self.failUnlessEqual(spansV, MayaCmds.getAttr(name+'.spansV'))
self.failUnlessEqual(formU, MayaCmds.getAttr(name+'.formU'))
self.failUnlessEqual(formV, MayaCmds.getAttr(name+'.formV'))
self.failUnlessEqual(minU, MayaCmds.getAttr(name+'.minValueU'))
self.failUnlessEqual(maxU, MayaCmds.getAttr(name+'.maxValueU'))
self.failUnlessEqual(minV, MayaCmds.getAttr(name+'.minValueV'))
self.failUnlessEqual(maxV, MayaCmds.getAttr(name+'.maxValueV'))
MayaCmds.createNode('surfaceInfo')
MayaCmds.connectAttr(name+'.worldSpace', 'surfaceInfo1.inputSurface',
force=True)
MayaCmds.currentTime(1, update=True)
errmsg = "At frame #1, Nurbs Plane's control point #%d.%s not equal"
for i in range(0, len(controlPoints)):
cp1 = controlPoints[i]
cp2 = MayaCmds.getAttr('surfaceInfo1.controlPoints[%d]' % (i))
self.failUnlessAlmostEqual(cp1[0], cp2[0][0], 3, errmsg % (i, 'x'))
self.failUnlessAlmostEqual(cp1[1], cp2[0][1], 3, errmsg % (i, 'y'))
self.failUnlessAlmostEqual(cp1[2], cp2[0][2], 3, errmsg % (i, 'z'))
errmsg = "At frame #1, Nurbs Plane's control knotsU #%d not equal"
for i in range(0, len(knotsU)):
ku1 = knotsU[i]
ku2 = MayaCmds.getAttr('surfaceInfo1.knotsU[%d]' % (i))
self.failUnlessAlmostEqual(ku1, ku2, 3, errmsg % (i))
errmsg = "At frame #1, Nurbs Plane's control knotsV #%d not equal"
for i in range(0, len(knotsV)):
kv1 = knotsV[i]
kv2 = MayaCmds.getAttr('surfaceInfo1.knotsV[%d]' % (i))
self.failUnlessAlmostEqual(kv1, kv2, 3, errmsg % (i))
MayaCmds.currentTime(12, update=True)
errmsg = "At frame #12, Nurbs Plane's control point #%d.%s not equal"
for i in range(0, len(controlPoints2)):
cp1 = controlPoints2[i]
cp2 = MayaCmds.getAttr('surfaceInfo1.controlPoints[%d]' % (i))
self.failUnlessAlmostEqual(cp1[0], cp2[0][0], 3, errmsg % (i, 'x'))
self.failUnlessAlmostEqual(cp1[1], cp2[0][1], 3, errmsg % (i, 'y'))
self.failUnlessAlmostEqual(cp1[2], cp2[0][2], 3, errmsg % (i, 'z'))
errmsg = "At frame #12, Nurbs Plane's control knotsU #%d not equal"
for i in range(0, len(knotsU2)):
ku1 = knotsU2[i]
ku2 = MayaCmds.getAttr('surfaceInfo1.knotsU[%d]' % (i))
self.failUnlessAlmostEqual(ku1, ku2, 3, errmsg % (i))
errmsg = "At frame #12, Nurbs Plane's control knotsV #%d not equal"
for i in range(0, len(knotsV2)):
kv1 = knotsV2[i]
kv2 = MayaCmds.getAttr('surfaceInfo1.knotsV[%d]' % (i))
self.failUnlessAlmostEqual(kv1, kv2, 3, errmsg % (i))
MayaCmds.currentTime(24, update=True)
errmsg = "At frame #24, Nurbs Plane's control point #%d.%s not equal"
for i in range(0, len(controlPoints)):
cp1 = controlPoints[i]
cp2 = MayaCmds.getAttr('surfaceInfo1.controlPoints[%d]' % (i))
self.failUnlessAlmostEqual(cp1[0], cp2[0][0], 3, errmsg % (i, 'x'))
self.failUnlessAlmostEqual(cp1[1], cp2[0][1], 3, errmsg % (i, 'y'))
self.failUnlessAlmostEqual(cp1[2], cp2[0][2], 3, errmsg % (i, 'z'))
errmsg = "At frame #24, Nurbs Plane's control knotsU #%d not equal"
for i in range(0, len(knotsU)):
ku1 = knotsU[i]
ku2 = MayaCmds.getAttr('surfaceInfo1.knotsU[%d]' % (i))
self.failUnlessAlmostEqual(ku1, ku2, 3, errmsg % (i))
errmsg = "At frame #24, Nurbs Plane's control knotsV #%d not equal"
for i in range(0, len(knotsV)):
kv1 = knotsV[i]
kv2 = MayaCmds.getAttr('surfaceInfo1.knotsV[%d]' % (i))
self.failUnlessAlmostEqual(kv1, kv2, 3, errmsg % (i))
mc.unloadPlugin("dsRaycast")
# mc.unloadPlugin('drawVector')
# mc.loadPlugin(os.path.join(MAYA_APP_DIR, 'scripts\dsRaycast\dsDrawVector\plugins\dsDrawVector.py'))
mc.loadPlugin(
os.path.join(MAYA_APP_DIR, 'scripts/dsRaycast/plugins/dsRaycast.py'))
###### Test #########
# Basic test
mesh = mc.polyPlane()[0]
mc.move(0, 4, 0, mesh)
mc.scale(50, 50, 50, mesh)
source = mc.spaceLocator(n='source')[0]
mc.move(0, 10, 0, source)
aim = mc.spaceLocator(n='aim')[0]
dsRaycast = mc.createNode('dsRaycast')
mc.connectAttr(mesh + '.worldMesh', dsRaycast + '.tm')
mc.connectAttr(source + '.worldMatrix', dsRaycast + '.srs')
mc.connectAttr(aim + '.t', dsRaycast + '.aim')
testObj = mc.polyCube(n='testBoi00')
mc.connectAttr(dsRaycast + ".hitPoint", testObj[0] + ".t")
'''
#Wheel test
mesh = mc.polyPlane()
srsLocs =[]
wheelGeo =[]
meshShape = mc.listRelatives(mesh, type='shape')[0]
mc.move(0, 2, 0, mesh[0])
def build(startJoint,
endJoint,
ikSwitchCtrl='',
ikSwitchAttr='spineIk',
ctrlScale=1.0,
prefix='cn_spine'):
'''
Build spine rig base.
@param startJoint: Start joint of the FK spine
@type startJoint: str
@param endJoint: End joint of the FK spine
@type endJoint: str
@param ikSwitchCtrl: Control to store the IK switch attribute
@type ikSwitchCtrl: str
@param ikSwitchAttr: IK switch attribute
@type ikSwitchAttr: str
@param prefix: Name prefix for new nodes
@type prefix: str
'''
# ==========
# - Checks -
# ==========
if not mc.objExists(startJoint):
raise Exception('Start joint "' + startJoint + '" does not exist!')
if not mc.objExists(endJoint):
raise Exception('End joint "' + endJoint + '" does not exist!')
if ikSwitchCtrl and not mc.objExists(ikSwitchCtrl):
raise Exception('IK switch control "' + ikSwitchCtrl +
'" does not exist!')
# ===================
# - Configure Spine -
# ===================
# Control Scale
fkCtrlScale = 1.5 * ctrlScale
spineCtrlScale = 1 * ctrlScale
# ==========================
# - Build Module Structure -
# ==========================
# Create control group
ctrl_grp = mc.group(em=True, n=prefix + '_ctrl_grp', w=True)
# Create rig group
rig_grp = mc.group(em=True, n=prefix + '_rig_grp', w=True)
# Create skel group
skel_grp = mc.group(em=True, n=prefix + '_skel_grp', w=True)
# Create module group
module = mc.group(em=True, n=prefix + '_module')
mc.parent([ctrl_grp, rig_grp, skel_grp], module)
# - Uniform Scale -
mc.addAttr(module, ln='uniformScale', min=0.001, dv=1.0)
mc.connectAttr(module + '.uniformScale', ctrl_grp + '.scaleX')
mc.connectAttr(module + '.uniformScale', ctrl_grp + '.scaleY')
mc.connectAttr(module + '.uniformScale', ctrl_grp + '.scaleZ')
mc.connectAttr(module + '.uniformScale', skel_grp + '.scaleX')
mc.connectAttr(module + '.uniformScale', skel_grp + '.scaleY')
mc.connectAttr(module + '.uniformScale', skel_grp + '.scaleZ')
# =========================
# - Determine Joint Scale -
# =========================
# Get joint list
spineJnts = glTools.utils.joint.getJointList(startJoint, endJoint)
jntLen = 0.0
for jnt in spineJnts:
cJntLen = glTools.utils.joint.length(jnt)
if cJntLen > jntLen: jntLen = cJntLen
# =====================
# - Create FK Joints -
# =====================
# Create Joints
fkJnts = glTools.utils.joint.duplicateChain(startJoint,
endJoint,
prefix=prefix + '_fk')
# Create Control Shapes
fkJntGrps = []
fkJntShapes = []
for i in range(len(fkJnts) - 1):
# Add control shape
jntShape = glTools.tools.controlBuilder.controlShape(fkJnts[i],
'circle',
rotate=[0, 90, 0],
scale=jntLen *
fkCtrlScale)
# Add joint buffer
jntGrp = glTools.utils.joint.group(fkJnts[i])
# Tag controls
glTools.rig.utils.tagCtrl(fkJnts[i], 'primary')
# Append arrays
fkJntGrps.append(jntGrp)
fkJntShapes.extend(jntShape)
# =======================
# - Create Spine Joints -
# =======================
# For each joint
spineJntGrps = []
spineJntShapes = []
for i in range(len(spineJnts)):
# Add control curves
jntShape = glTools.tools.controlBuilder.controlShape(spineJnts[i],
'square',
rotate=[0, 90, 0],
scale=jntLen *
spineCtrlScale)
# Add joint buffer
jntGrp = glTools.utils.joint.group(spineJnts[i])
# Tag controls
glTools.rig.utils.tagCtrl(spineJnts[i], 'primary')
# Append arrays
spineJntGrps.append(jntGrp)
spineJntShapes.extend(jntShape)
# =======================
# - Parent Spine Joints -
# =======================
for i in range(len(spineJnts)):
mc.parent(spineJntGrps[i], fkJnts[i])
# =======================
# - Create Attach Joint -
# =======================
mc.select(cl=True)
# Create attach
attachJoint = mc.joint(n=prefix + '_attachA_jnt')
attachJointGrp = glTools.utils.joint.group(attachJoint)
mc.delete(mc.parentConstraint(spineJnts[0], attachJointGrp))
# Attach joint display
mc.setAttr(attachJoint + '.overrideEnabled', 1)
mc.setAttr(attachJoint + '.overrideLevelOfDetail', 1)
# Parent attach joint
mc.parent(fkJntGrps[0], attachJoint)
mc.parent(attachJointGrp, skel_grp)
# ========================
# - Setup IK Mode Switch -
# ========================
if ikSwitchCtrl:
# Check switch attribute
if not ikSwitchAttr: ikSwitchAttr = 'spineIk'
if not mc.objExists(ikSwitchCtrl + '.' + ikSwitchAttr):
mc.addAttr(ikSwitchCtrl,
ln=ikSwitchAttr,
at='long',
min=0,
max=1,
dv=0,
k=True)
# Create Parent Constraints
ikConstraint1 = mc.parentConstraint([spineJnts[0], spineJnts[-1]],
spineJntGrps[1],
mo=True)[0]
ikConstraint2 = mc.parentConstraint([spineJnts[0], spineJnts[-1]],
spineJntGrps[2],
mo=True)[0]
# Connect to switch
ikWeightMult1 = mc.createNode('multDoubleLinear',
n=prefix + '_ikWeight1_multDoubleLinear')
ikWeightMult2 = mc.createNode('multDoubleLinear',
n=prefix + '_ikWeight1_multDoubleLinear')
mc.connectAttr(ikSwitchCtrl + '.' + ikSwitchAttr,
ikWeightMult1 + '.input1')
mc.connectAttr(ikSwitchCtrl + '.' + ikSwitchAttr,
ikWeightMult2 + '.input1')
mc.setAttr(ikWeightMult1 + '.input2', 0.666)
mc.setAttr(ikWeightMult2 + '.input2', 0.333)
# Connect to constraint
ikWeightAlias1 = mc.parentConstraint(ikConstraint1, q=True, wal=True)
ikWeightAlias2 = mc.parentConstraint(ikConstraint2, q=True, wal=True)
mc.connectAttr(ikWeightMult1 + '.output',
ikConstraint1 + '.' + ikWeightAlias1[0],
f=True)
mc.connectAttr(ikWeightMult2 + '.output',
ikConstraint1 + '.' + ikWeightAlias1[1],
f=True)
mc.connectAttr(ikWeightMult1 + '.output',
ikConstraint2 + '.' + ikWeightAlias1[1],
f=True)
mc.connectAttr(ikWeightMult2 + '.output',
ikConstraint2 + '.' + ikWeightAlias1[0],
f=True)
# ======================
# - Set Channel States -
# ======================
chStateUtil = glTools.utils.channelState.ChannelState()
chStateUtil.setFlags([0, 0, 0, 0, 0, 0, 0, 0, 0, 1], objectList=spineJnts)
chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1],
objectList=spineJntGrps)
chStateUtil.setFlags([0, 0, 0, 0, 0, 0, 0, 0, 0, 1], objectList=fkJnts)
chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1], objectList=fkJntGrps)
chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1],
objectList=[attachJointGrp])
chStateUtil.setFlags([1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
objectList=[attachJoint])
chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 1],
objectList=[module, ctrl_grp, rig_grp, skel_grp])
# =================
# - Return Result -
# =================
return [module, attachJoint]
srcJnt = selLs[0]
trgGeos = selLs[1:]
for geo in trgGeos:
#geoRpInWs = cmds.xform(geo, q = True, rp = True, ws = True)
geoJnt = cmds.duplicate(srcJnt, n = geo + '_jnt')
#cmds.xform(geoJnt, t = geoRpInWs, ws = True)
cmds.skinCluster(geoJnt, geo, mi = 4, dr = 4, tsb = True, omi = False, nw = 1)
autoGrps = cmds.ls(sl = True)
for i in xrange(len(autoGrps)):
if i == 0:
continue
pmaNode = cmds.createNode('plusMinusAverage', n = selLs[i] + '_offset_pma')
cmds.connectAttr(autoGrps[i-1] + '.rotateY', pmaNode + '.input1D[0]')
cmds.connectAttr('flip_ctrl' + '.offset', pmaNode + '.input1D[2]')
cmds.connectAttr(pmaNode + '.output1D', autoGrps[i] + '.rotateY')
cmds.setAttr(pmaNode + '.operation', 2)
geos = cmds.ls(sl = True)
for geo in geos:
bendGeo = cmds.duplicate(geo, n = geo + '_bend_geo')[0]
cmds.parent(bendGeo, w = True)
bsNode = cmds.blendShape(bendGeo, geo, frontOfChain = True)[0]
cmds.setAttr(bsNode + '.' + bendGeo, 1)
cmds.setAttr(bendGeo + '.visibility', False)
bendHndl = cmds.nonLinear(bendGeo, type = 'bend', lowBound = 0, highBound = 1, curvature = 0)[1]