def __mirrorBlendShape(self,*args):
pm.select(self.baseShape)
baseShape = pm.ls(sl = 1)[0]
pm.select(self.sculptedShape)
sculptedShape = pm.ls(sl = 1)[0]
baseWarp = pm.duplicate(baseShape,n = nameUtils.setUniqueName(baseShape + 'Warp','geo'))
baseScaleNeg = pm.duplicate(baseShape,n = nameUtils.setUniqueName(baseShape + 'ScaleNeg','geo'))
#flip scale
pm.setAttr(baseScaleNeg[0] + '.scaleX', -1)
tempBlend = pm.blendShape(sculptedShape,baseScaleNeg[0],n = nameUtils.setUniqueName(sculptedShape + 'TempBlend','geo'))
#create warp between warp and neg
pm.select(cl=True)
pm.select(baseWarp)
pm.select(baseScaleNeg,add = 1)
pm.runtime.CreateWrap()
pm.setAttr(tempBlend[0] + '.' + sculptedShape, 1)
#Duplicate Wrapped shape for final result
pm.duplicate(baseWarp)
#Clean up setup
pm.delete(baseWarp,baseScaleNeg)
def rig_ctrlDuplicate(ctrl, name):
"""Creates a hub set
Args:
ctrl (pm.PyNode): maya objects to rename
name (str): new name
Returns:
list: [offset_grp, ctrl, con_grp]
"""
orig_name = ctrl.split('_')[0]
grp_offset,grp_con = None,None
if str(ctrl.getParent()) == orig_name+'Offset_GRP':
grp_offset = pm.PyNode(orig_name + 'Offset_GRP')
if orig_name+'Con_GRP' in ctrl.getChildren():
grp_con = pm.PyNode(orig_name+'Con_GRP')
if grp_offset:
grp_offsetDup = pm.duplicate(grp_offset,n=name+'Offset_GRP',po=True)
ctrl_dup = pm.duplicate(ctrl,n=ctrl.replace(orig_name, name))
ctrl_dup[0].setParent(grp_offsetDup)
for child in ctrl_dup[0].getChildren():
if child.type() != 'nurbsCurve':
pm.delete(child)
if grp_con:
grp_conDup = pm.duplicate(grp_con,n=name+'Con_GRP',po=True)
grp_conDup[0].setParent(ctrl_dup)
if grp_offset:
return [grp_offsetDup[0],ctrl_dup[0],grp_conDup[0]]
else:
return [None,ctrl_dup[0],grp_conDup[0]]
def copy_correctiveToBlend(base, corrective):
'''Bakes a static mesh that can be used as a corrective to what you've posed
Args:
base (pm.PyNode): base object with bad shape from skinCluster or blendShapes
corrective (pm.PyNode): sculpted fixed shape
Returns:
[pm.PyNode]: new corrected shape
Usage:
copy_correctiveToBlend(pm.ls(sl=True)[0], pm.ls(sl=True)[1])
'''
#Duplicate your deformed mesh twice, calling one positive and one negative. Move them a little away from your model
positive = corrective
negative = pm.duplicate(base, n=corrective.name()+"_negative")[0]
inputs = pm.listConnections(base.getShape(), type=['skinCluster','blendShape'])
for input in inputs:
input.attr('envelope').set(0)
corrected = pm.duplicate(base, n=corrective.name()+"_corrective")[0]
#Make a new blend-shape node on your character containing the two duplicate meshes. This blend shape must use the parallel blending mode.
blend = pm.blendShape(corrected, n='corrector_BS')[0]
pm.blendShape(blend, e=True, t=(corrected, 0, positive, 1.0))
pm.blendShape(blend, e=True, t=(corrected, 1, negative, 1.0))
set=1
for alias in blend.listAliases():
alias[1].set(set)
set=-1
#Move your character back to bind-pose and in the parallel blend-node, set the positive mesh to 1 and the negative to -1. This should blend your mesh so that you only have the deformations you made to the positive mesh, but now in a neutral pose.
#bindPose
#Duplicate this new mesh and call it something with the letters BS is the name because this is infinitely funny. This mesh can now be used as a corrective blend-shape
#Delete the parallel blend-node and repeat these steps for all your shapes. Yes, really.
#pm.delete(p_bs)
#pm.delete(base)
for input in inputs:
input.attr('envelope').set(1)
return corrected
def create_deltaMush(bindGeo, iterations = [5, 10, 20, 30, 40]):
smoothGeo = pm.duplicate( bindGeo, rr=True, ic=True, name=bindGeo.name() + "_smooth") [0]
smoothGeo.addAttr("envelope", at='long', min=0, max=1, dv=1, k=True)
smoothGeo.addAttr("partitions", at='message')
deltaGeo = pm.duplicate( bindGeo, rr=True, ic=False, name="BS_" + bindGeo.name() + "_delta") [0]
pm.select(deltaGeo, smoothGeo)
pm.mel.eval("CreateWrap")
smoothNodes = []
smoothNodeSets = []
for i in range(0, len(iterations)):
smoothNode = pm.deformer([smoothGeo], type='smooth')[0]
smoothNode.iterations.set(iterations[i])
smoothGeo.envelope >> smoothNode.envelope
smoothNodes.append(smoothNode)
smoothNodeSet = smoothNode.message.listConnections()[0]
smoothNodeSet.clear()
smoothNodeSets.append(smoothNodeSet)
for smoothNodeSet in smoothNodeSets:
smoothNodeSet.clear()
partition = pm.partition(smoothNodeSets)
partition.message >> smoothGeo.partitions
skinCls = bindGeo.getShape().listConnections(type='skinCluster')[0]
joints = skinCls.getInfluence()
assign_iteration_set(joints, bindGeo, skinCls, deltaGeo)
def gimbal(**kwargs):
final = pm.nt.Transform(name = 'Gimbal')
circle1 = pm.modeling.circle(
constructionHistory = False,
normal = kwargs['normal'] if 'normal' in kwargs else [0, 1, 0],
radius = kwargs['radius'] if 'radius' in kwargs else 1
)[0]
circle2 = pm.duplicate(circle1, returnRootsOnly = True)[0]
circle2.rotateBy((90, 0, 0))
circle3 = pm.duplicate(circle1, returnRootsOnly = True)[0]
circle3.rotateBy((0, 0, 90))
for circle in [circle1, circle2, circle3]:
pm.makeIdentity(circle, apply = True)
shape = circle.getShape()
pm.parent(shape, final, shape = True, relative = True)
shape.rename('{0}Circle1Shape'.format(final.nodeName()))
pm.delete(circle)
return final
def makeFkIk(*args):
bindRoot = pm.ls(selection = True)[0]
bindChain = pm.ls(bindRoot, dag = True)
fkChain = pm.duplicate(bindRoot)
replaceSuffix(fkChain, 'fk')
makeFk(False, fkChain)
ikChain = pm.duplicate(bindRoot)
replaceSuffix(ikChain, 'ik')
makeIk(False, ikChain)
fkChainList = pm.ls(fkChain, dag = True)
ikChainList = pm.ls(ikChain, dag = True)
createPad(bindRoot)
suffixIndex = bindChain[0].rfind('_')
hanldeName = bindChain[0][:suffixIndex] + '_switch'
handle = createHandle(hanldeName)
pm.rename(handle, hanldeName)
pm.parentConstraint(bindChain[-1], handle)
constraintList = []
for i, item in enumerate(bindChain):
newConstraint = pm.orientConstraint(fkChainList[i], ikChainList[i], bindChain[i], mo = False)
fkCon = pm.orientConstraint(newConstraint, q = True, wal = True)[1]
ikCon = pm.orientConstraint(newConstraint, q = True, wal = True)[0]
pm.setDrivenKeyframe(fkCon, cd = handle + '.switch', v = 1, dv = 10)
pm.setDrivenKeyframe(fkCon, cd = handle + '.switch', v = 0, dv = 0)
pm.setDrivenKeyframe(ikCon, cd = handle + '.switch', v = 0, dv = 10)
pm.setDrivenKeyframe(ikCon, cd = handle + '.switch', v = 1, dv = 0)
def bdSwitchFKIK(self):
if 'arm' in self.limb:
print self.side + ' arm FK->IK switch '
for loc in self.ikArmCons:
shadowLoc = pm.ls(self.namespace + self.side + loc + 'LOC')[0]
tempLoc = pm.duplicate(shadowLoc)
pm.parent(tempLoc,w=True)
ikCon = pm.ls(self.namespace + self.side + loc + 'CON',type='transform')[0]
if ikCon.name().find('armIK') > 0:
tempCnstr = pm.parentConstraint(tempLoc,ikCon)
else:
tempCnstr = pm.pointConstraint(tempLoc,ikCon)
pm.delete([tempCnstr,tempLoc])
self.armSwitchCon.attr('ikFkBlend').set(0)
elif 'leg' in self.limb:
print self.side + ' leg FK->IK switch '
for loc in self.ikLegCons:
shadowLoc = pm.ls(self.namespace + self.side + loc + 'LOC')[0]
tempLoc = pm.duplicate(shadowLoc)
pm.parent(tempLoc,w=True)
ikCon = pm.ls(self.namespace + self.side + loc + 'CON',type='transform')[0]
if ikCon.name().find('legIK') > 0:
tempCnstr = pm.parentConstraint(tempLoc,ikCon)
else:
tempCnstr = pm.pointConstraint(tempLoc,ikCon)
pm.delete([tempCnstr,tempLoc])
self.legSwitchCon.attr('ikFkBlend').set(0)
def duplicateArray(objA=None, noCopies=9, direction="+x", adj=0):
""" Duplicate Array of Objects """
if objA == None:
objA = getSelection()
else:
objA = pm.PyNode(objA)
if isinstance(objA, pm.nodetypes.Transform):
result = [objA]
width = getWidth(objA)
dup = pm.duplicate(objA)[0]
result.append(dup)
if "+x" in direction or "+X" in direction:
pos = dup.t.get()
pm.move(pos.x + width[0] + adj, pos.y, pos.z)
elif "-x" in direction or "-X" in direction:
pos = dup.t.get()
pm.move(pos.x - width[0] + adj, pos.y, pos.z)
if "+y" in direction or "+Y" in direction:
pos = dup.t.get()
pm.move(pos.x, pos.y + width[1] + adj, pos.z)
elif "-y" in direction or "-Y" in direction:
pos = dup.t.get()
pm.move(pos.x, pos.y - width[1] + adj, pos.z)
if "+z" in direction or "+Z" in direction:
pos = dup.t.get()
pm.move(pos.x, pos.y, pos.z + width[2] + adj)
elif "-z" in direction or "-Z" in direction:
pos = dup.t.get()
pm.move(pos.x, pos.y, pos.z - width[2] + adj)
for i in xrange(noCopies - 1):
dup = pm.duplicate(st=True)[0]
result.append(dup)
return result
def buildChains(self, *args):
"""
Build joint chains based on locator positions.
"""
self.jointChain = []
self.ikChain = []
self.fkChain = []
loc1Pos = pm.xform(self.loc1, q=True, ws=True, t=True)
loc2Pos = pm.xform(self.loc2, q=True, ws=True, t=True)
loc3Pos = pm.xform(self.loc3, q=True, ws=True, t=True)
jnt1='%s_shldrJnt'%self.prefix
jnt2='%s_elbow1Jnt'%self.prefix
jnt3='%s_wristJnt'%self.prefix
self.jointChain.append(pm.PyNode(pm.joint(p=loc1Pos, n=jnt1)))
self.jointChain.append(pm.PyNode(pm.joint(p=loc2Pos, n=jnt2)))
self.jointChain.append(pm.PyNode(pm.joint(p=loc3Pos, n=jnt3)))
#--- Orient the chain
self.orientChain()
#--- Creating duplicate ik/fk joint chains
for each in pm.duplicate(self.jointChain, rc=True):
# Slice off number maya adds during duplication
each.rename('%s_ik' % each[:-1])
self.ikChain.append(pm.PyNode(each))
for each in pm.duplicate(self.jointChain, rc=True):
each.rename('%s_fk' % each[:-1])
self.fkChain.append(pm.PyNode(each))
def createIKSpline( jntList ):
pymelLogger.debug('Starting: createIKSpline()...')
# Make IK Spline
ikHandleTorso = pm.ikHandle( startJoint=jntList[0], endEffector=jntList[-1], solver = 'ikSplineSolver', numSpans = 4, name = jntList[-1]+'_'+Names.suffixes['ikhandle'])
# we should probably rename the object created to know names ......
# CAREFULL // inherits Transform OFF, to avoid double transformation when grouped later on
pm.setAttr(ikHandleTorso[2] + '.inheritsTransform', 0)
# Duplicate last and first joint to use as Drivers of the spine Ik curve
print jntList
drvStart = pm.duplicate(jntList[0], parentOnly=True, name = Names.prefixes['driver']+'_'+ jntList[0] +'_'+Names.suffixes['start'])
drvEnd = pm.duplicate(jntList[-1], parentOnly=True, name = Names.prefixes['driver']+'_'+ jntList[-1] +'_'+Names.suffixes['end'])
pm.parent(drvEnd, w=1)
# Make radius bigger
pm.joint(drvStart, edit = True, radius = 1)
pm.joint(drvEnd, edit = True, radius = 1)
# Skin hip/shldr jnt's to back curve
pm.skinCluster(drvStart,drvEnd,ikHandleTorso[2],dr=4)
# return nedded elements
rList = [ikHandleTorso, drvStart, drvEnd ]
pymelLogger.debug('End: createIKSpline()...')
return rList
def instance(self, source_transform_node):
"""instances the given nodes hierarchy
"""
# duplicate the given node
# then replace the instanceable nodes with instances
# find instanceable nodes in the node and dupNode
source_hierarchy = self.walk_hierarchy(source_transform_node)
# if there is no node in the sourceHierarchy just return
# the instance of the given node
if len(source_hierarchy) < 1:
dup_node = pm.duplicate(source_transform_node, ilf=1, rc=True)[0]
pm.select(dup_node)
return
dup_node = pm.duplicate(source_transform_node, rc=True)[0]
dup_hierarchy = self.walk_hierarchy(dup_node)
for i, node in enumerate(dup_hierarchy):
shape = node.getShape()
if shape is not None and isinstance(shape,
tuple(self._instanceables)):
# instance the corresponding sourceNode
source_node = source_hierarchy[i]
new_instance_node = pm.duplicate(source_node, ilf=True)[0]
pm.parent(new_instance_node, node.getParent(), r=False)
pm.delete(node)
pm.select(dup_node)
return dup_node
def bdSwitchIKFK(self):
if 'arm' in self.limb:
print self.side + ' arm IK -> FK switch'
for loc in self.fkArmCons:
shadowLoc = pm.ls(self.namespace + self.side + loc + 'LOC')[0]
tempLoc = pm.duplicate(shadowLoc)
pm.parent(tempLoc,w=True)
fkCon = pm.ls(self.namespace + self.side + loc + 'CON',type='transform')[0]
tempCnstr = pm.orientConstraint(tempLoc,fkCon)
pm.delete([tempCnstr,tempLoc])
self.armSwitchCon.attr('ikFkBlend').set(1)
elif 'leg' in self.limb:
print self.side + ' leg IK->FK switch '
for loc in self.fkLegCons:
shadowLoc = pm.ls(self.namespace + self.side + loc + 'LOC')[0]
tempLoc = pm.duplicate(shadowLoc)
pm.parent(tempLoc,w=True)
fkCon = pm.ls(self.namespace + self.side + loc + 'CON',type='transform')[0]
tempCnstr = pm.orientConstraint(tempLoc,fkCon)
pm.delete([tempCnstr,tempLoc])
self.legSwitchCon.attr('ikFkBlend').set(1)
def createJnts( LegJnts, side ):
pymelLogger.debug('Starting: createJnts()...')
# duplicate joints
listJnts = []
print LegJnts
for jnt in LegJnts:
pm.select(clear=1)
newJnt = pm.duplicate(jnt,rr=True,po=True, name=jnt+'_'+Names.suffixes['ik'])[0]
try:
newJnt.setParent(world=1)
except: pass
listJnts.append(newJnt)
print listJnts
# parent joints
listJnts.reverse()
index = 0
for jnt in listJnts:
if index+1 == len(listJnts): break
jnt.setParent(listJnts[index+1])
index = index + 1
listJnts.reverse()
# joints for inverse foot
ankleFloorJnt = '%s%s' %(side,'AnkleFloor_if')
# duplicate only joints ww for inverse foot
pm.select(clear=1)
toeBaseWW = listJnts[-3]
invfootname = str(toeBaseWW).replace('_'+Names.suffixes['ik'], '_inversefoot')
invfootjnt = pm.duplicate( toeBaseWW, name=invfootname )[0]
invfootjnt.setParent(w=1)
index = 1
invjntlist = invfootjnt.listRelatives(ad=1)
invjntlist.reverse()
for jnt in invjntlist:
jnt.rename(invfootname+str(index))
jnt.setParent(w=1)
index += 1
invjntlist.reverse()
invjntlist.append(invfootjnt)
invjntlist.reverse()
index = 0
for jnt in invjntlist:
if index+1 == len(invjntlist): break
jnt.setParent(invjntlist[index+1])
index = index + 1
# make them child of the Ankle floor jnt
invjntlist[-1].setParent(ankleFloorJnt)
pm.select(clear=1)
pymelLogger.debug('End: createJnts()...')
print listJnts
return listJnts
def duplicateJointChain( *joints ):
'''
update : 2015-04-04
'''
if joints:
pm.select(joints)
joints = pm.selected(type='joint')
# 입력된게 없으면 에러
if not joints:
raise
# 선택된게 하나이면?
if len(joints)==1 :
dupJnt = pm.duplicate( joints[0], po=True )[0]
dupJnt.setParent( w=True )
pm.select(dupJnt)
return [dupJnt]
else:
startJoint = joints[0]
endJoint = joints[-1]
# endJoint가 startJoint의 parent가 아니면 에러
if endJoint not in startJoint.getChildren( allDescendents=True ):
raise
# 복사할 조인트 리스트 만듦
jointList = [ endJoint ]
p = endJoint.getParent()
while p!=startJoint:
jointList.append( p )
p = p.getParent()
jointList.append( startJoint )
# 새로운 조인트 복사
newJoint = []
for jnt in jointList:
jnt = pm.duplicate(jnt, returnRootsOnly=True, renameChildren=True, parentOnly=True)[0]
newJoint.append(jnt)
# parent
for i in range( len(newJoint[:-1]) ):
newJoint[i].setParent( newJoint[i+1])
# 루트로 옮김
newJoint[-1].setParent(w=True)
#
newJoint.reverse()
return newJoint
def bdBuildSplineSolverScale():
selection = pm.ls(sl=1,type='transform')
startJoint = ''
if selection:
startJoint = selection[0]
else:
return
print startJoint
ikSpline = pm.listConnections(startJoint,type='ikHandle')[0]
print ikSpline
solver = ikSpline.ikSolver.inputs()[0]
if 'ikSplineSolver' in solver.name():
sclChain = pm.duplicate(startJoint,name = startJoint.name() + '_SCL')[0]
sclChainAll = sclChain.listRelatives(f=True, ad=True,type='joint')
print sclChainAll
for sclJnt in sclChainAll:
pm.rename(sclJnt,sclJnt+'_SCL')
splineCurve = pm.listConnections(ikSpline, type = 'nurbsCurve')[0]
effector = pm.listConnections(ikSpline ,source=True, type='ikEffector')[0]
endJoint = pm.listConnections(effector,source=True, type='joint')[0]
jointChain = startJoint.listRelatives(f=True, ad=True,type='joint')
jointChain = jointChain + [startJoint]
jointChain.reverse()
print jointChain
splineCurveScl = pm.duplicate(splineCurve,name = splineCurve.name().replace('crv','crv_scl'))
strArclenSCL = pm.arclen(splineCurveScl,ch=True)
strArclenCRV = pm.arclen(splineCurve,ch=True)
arclenSCL = pm.ls( strArclenSCL ) [0]
arclenCRV = pm.ls( strArclenCRV ) [0]
arclenSCL.rename(splineCurveScl[0].name() + '_length')
arclenCRV.rename(splineCurve.name() + '_length')
mdScaleFactor = pm.createNode('multiplyDivide', name = splineCurve.name().replace('crv','crv_scaleFactor_md'))
arclenCRV.arcLength.connect(mdScaleFactor.input1X)
arclenSCL.arcLength.connect(mdScaleFactor.input2X)
mdScaleFactor.operation.set(2)
for jnt in jointChain[1:]:
mdJntTr = pm.createNode('multiplyDivide', name = jnt + '_trX_MD')
#mdJntTr.operation.set(2)
sclJnt = pm.ls(jnt + '_SCL')[0]
mdScaleFactor.outputX.connect(mdJntTr.input2X)
sclJnt.translateX.connect(mdJntTr.input1X)
mdJntTr.outputX.connect(jnt.translateX)
def build_tweek_ctrls(self, follicles):
"""
Args:
None
Returns (None)
"""
base_name = '%s_flexiPlane' % self.flexiPlaneNameField.getText()
follicle_prefix = '%s_flexiPlane_' % self.flexiPlaneNameField.getText()
mainCTRLGRP = self.flexiPlaneNameField.getText() + '_flexiPlane_main_CTRLCon_GRP'
main_crv_name = '%s_main_CTRL' % base_name
tweekCTRLGRP = pm.group( em = True, name = self.flexiPlaneNameField.getText() + '_flexiPlane_tweakCTRL_GRP' )
tweekCTRLGRP.setAttr( 'inheritsTransform', 0 )
pm.parent( tweekCTRLGRP, mainCTRLGRP )
for index,follicle in enumerate(follicles):
tweek_crv_name = self.format_string.format(PREFIX = self.flexiPlaneNameField.getText(),
INDEX = 'flexiPlane_tweak%03d' % (index+1),
SUFFIX = 'CTRL')
pm.circle( c = (0, 0, 0 ), nr = ( 0, 1, 0 ), sw = 360, r = 1, d = 3, ut = 0, tol = 0.000129167, s = 8, n = tweek_crv_name, ch = 0 )
pm.setAttr( tweek_crv_name + '.scaleX', .5 )
pm.setAttr( tweek_crv_name + '.scaleY', .5 )
pm.setAttr( tweek_crv_name + '.scaleZ', .5 )
pm.setAttr( tweek_crv_name + '.overrideEnabled', 1 )
pm.setAttr( tweek_crv_name + '.overrideColor', 17 )
pm.makeIdentity( tweek_crv_name, apply=True, translate=True, rotate=True, scale=True )
pm.setAttr( tweek_crv_name + '.overrideEnabled', 1 )
pm.setAttr( tweek_crv_name + '.overrideColor', 17 )
pm.duplicate( tweek_crv_name, n= tweek_crv_name + 'A' )
pm.setAttr( tweek_crv_name + 'A.rotateZ', -90 )
pm.makeIdentity( tweek_crv_name + 'A', apply=True, translate=True, rotate=True, scale=True )
pm.duplicate( tweek_crv_name, n= tweek_crv_name + 'B' )
pm.setAttr( tweek_crv_name + 'B.rotateZ', -90 )
pm.setAttr( tweek_crv_name + 'B.rotateX', -90 )
pm.makeIdentity( tweek_crv_name + 'B', apply=True, translate=True, rotate=True, scale=True )
pm.parent( tweek_crv_name + 'AShape', tweek_crv_name + 'BShape', tweek_crv_name, add = True, shape = True )
pm.delete( tweek_crv_name + 'A', tweek_crv_name + 'B')
pm.select(tweek_crv_name, r=True)
offSetGRP.add_offset_grps()
conGRP.add_con_grps()
pm.select(clear = True)
pm.connectAttr( follicle + '.translate', tweek_crv_name + 'Offset_GRP.translate' )
pm.connectAttr( follicle + '.rotate', tweek_crv_name + 'Offset_GRP.rotate' )
pm.parent( tweek_crv_name + 'Offset_GRP', tweekCTRLGRP )
pm.scaleConstraint( main_crv_name, tweek_crv_name + 'Offset_GRP' )
pm.select( clear = True)
def bdMirrorCon(self):
print 'Mirror Controller'
mirrorType = self.mirrorRadioBtn.checkedId()
selection = pm.ls(sl=True)
if selection.count > 0:
for sel in selection:
if ('L_' in sel.name()) or ('R_' in sel.name()):
conGrp = sel.getParent()
conGrpPos = conGrp.getTranslation(space='world')
conGrpRot = conGrp.getRotation(space='world')
exp = ['L_','R_']
if 'R_' in conGrp.name():
exp.reverse()
mirrorConGrp = ''
if mirrorType == -2:
mirrorConGrp = pm.duplicate(conGrp,name = conGrp.name().replace(exp[0],exp[1]))[0]
scaleGrp = pm.group(mirrorConGrp)
scaleGrp.setPivots([0,0,0])
scaleGrp.scaleX.set(-1)
pm.parent(mirrorConGrp,world=True)
pm.makeIdentity(mirrorConGrp,apply=True,t=0,r=0,s=1)
pm.delete(scaleGrp)
mirrorConGrpRot = mirrorConGrp.getRotation(space='world')
print mirrorConGrpRot
mirrorConGrp.setRotation([mirrorConGrpRot[0],-1 * mirrorConGrpRot[1],180 - abs(mirrorConGrpRot[2])])
elif mirrorType == -3:
mirrorConGrp = pm.duplicate(conGrp,name = conGrp.name().replace(exp[0],exp[1]))[0]
mirrorConChildren = mirrorConGrp.getChildren(ad=True,type='transform')
for child in mirrorConChildren :
child.rename(child.name().replace(exp[0],exp[1]))
if mirrorType == -3:
mirrorConGrp.setTranslation([conGrpPos[0]*-1,conGrpPos[1],conGrpPos[2]])
for child in mirrorConChildren :
for shape in child.getChildren(type='shape'):
shape.overrideEnabled.set(1)
shape.overrideColor.set(self.conColors[exp[1]])
targetShape = pm.ls(child.name().replace(exp[1],exp[0]) + '*',type='shape')[0]
if mirrorType == -3:
self.bdMirrorShape(shape,targetShape)
else:
pm.warning( 'Central controller, no need (sic) to mirror it!')
def bdBuildJointStructure(self,target,ctrlName,ikName):
startDrv = pm.duplicate(target,po=True,name=target.replace('jnt','side_drv_jnt'))
drvChain = pm.duplicate(target,name=target.replace('jnt','drv_jnt'))
drvChainChildren = pm.listRelatives(drvChain[0], c=True,type='joint',f=True)
for child in drvChainChildren:
if '02' in child.name():
child.rename(child.name().replace('bnd_jnt','drv_jnt'))
pm.parentConstraint(child,ctrlName.replace('anim','anim_CON'),mo=True,w=1)
pm.parent(drvChain[0],startDrv[0])
if 'upper' in startDrv[0].name():
pm.parent(startDrv[0],startDrv[0].split('_')[0] + '_eyelid_upper_blink_jnt')
elif 'lower' in startDrv[0].name():
pm.parent(startDrv[0],startDrv[0].split('_')[0] + '_eyelid_lower_blink_jnt')
def create_deltaMush(bindGeo, iterations=10):
smoothGeo = pm.duplicate( bindGeo, rr=True, ic=True, name=bindGeo.name() + "_smooth") [0]
deltaGeo = pm.duplicate( bindGeo, rr=True, ic=False, name=bindGeo.name() + "_delta") [0]
pm.select(deltaGeo, smoothGeo)
pm.mel.eval("CreateWrap")
smoothNode = pm.deformer([smoothGeo], type='smoothSimple')[0]
smoothNode.iterations.set(iterations)
newBaseGeo = pm.duplicate( smoothGeo, rr=True, ic=False, name=bindGeo.name() + "_smoothBase") [0]
wrapNode = deltaGeo.inMesh.listConnections()[0]
swap_wrap_deformer_base(wrapNode, newBaseGeo)
def bdRigEye(self):
#create IK handles for the bind joints, for now getting the joints based on the name
parts = []
if self.templateSide == 'both':
parts = ['left','right']
else:
parts = [self.templateSide]
for side in parts:
eyeLidsJnt = pm.ls(side + '*eyelid_*_01_jnt')
eyeJoint = pm.ls(side + "*eye*jnt")[0]
eyeCorners = pm.ls(side + "*eye*corner*01_jnt")
eyeAnim = pm.ls(side + '_eye_anim')
pm.select(cl=True)
eyeAnimGrp = pm.group(n=side + '_eyelids_anim_GRP')
pm.select(cl=True)
pm.aimConstraint(eyeAnim[0],eyeJoint,offset = [0, 0, 0] ,weight=1 , aimVector =[0 ,0 ,1] ,upVector=[0, 1, 0] ,worldUpType="vector" ,worldUpVector= [0,1,0])
blinkUpJnt = pm.duplicate(eyeJoint,name = side + '_eyelid_upper_blink_jnt',po=True)
blinkLowJnt = pm.duplicate(eyeJoint,name = side + '_eyelid_lower_blink_jnt',po=True)
baseLidsJnt = pm.ls(side + '*lids*base')
pm.parent([blinkUpJnt[0],blinkLowJnt[0]],baseLidsJnt[0])
for joint in (eyeLidsJnt + eyeCorners):
endJoint = pm.listRelatives(joint,c=True,type='joint')
ikName = endJoint[0].name().replace('02_bnd_jnt','ikHandle')
ctrlName = endJoint[0].name().replace('02_bnd_jnt','anim')
bdRigUtils.bdAddIk(joint.name(),endJoint[0].name(),'ikSCsolver',ikName)
eyelidAnim,eyelidAnimGrp = bdRigUtils.bdBuildSquareController(endJoint[0].name(),ctrlName,0.2)
pm.parent(eyelidAnimGrp , eyeAnimGrp)
#bdRigUtils.bdBuildBoxController(endJoint[0].name(),ctrlName,0.2)
if 'corner' not in ctrlName:
bdRigUtils.bdAddAttributeMinMax(ctrlName,['BlinkPosition'],'double',-5,5,1)
pm.parent(ikName,ctrlName)
self.bdBuildJointStructure(joint,ctrlName,ikName)
'''
allAnimsGrps = pm.ls(self.templateSide + '*eye*CON_??',type='transform')
globalAnimGrp = pm.ls('controllers')
pm.parent(allAnimsGrps,globalAnimGrp[0])
'''
self.bdAddEyeAttr(eyeAnim[0])
self.bdCreateVerticalFollow(side)
self.bdCreateSideFollow(side)
self.bdCreateBlink(side)
self.bdCleanupGuides(side)
def rig_makeBlockGeo(meshes, constrain=False, *args):
'''
Args:
meshes (list(pm.nt.Transform)): meshes to cut up
constrain (boolean): whether to constrain them or not
Returns:
list (pm.nt.Transform): list of block geometries created
Usage:
rig_makeBlockGeo(pm.ls(sl=True), constrain=True)
'''
blockgeos=[]
joints=[]
for mesh in meshes:
skinCluster = rig_getConnectedSkinCluster(mesh)
if skinCluster:
joints+= skinCluster.getWeightedInfluence()
if len(joints)==1:
dup=pm.duplicate(mesh, n=mesh.name().replace('GEO','BLOCKGEO'))[0]
blockgeos.append(dup)
rig_unlockTransform(dup)
pm.parentConstraint(joints[0], dup, mo=True)
else:
for joint in joints:
blockgeo = rig_makeBlockGeoFromJoint([mesh], joint)
if blockgeo:
if pm.objExists(blockgeo):
blockgeos+=blockgeo
pm.delete(blockgeo, ch=True)
if constrain:
for geo in blockgeo:
rig_unlockTransform(geo)
pm.parentConstraint(joint, geo, mo=True)
else:
pm.warning('No skinCluster detected on mesh %s' % mesh)
return blockgeos
def rig_makeJointsAlongCurve(module, curve, numJoints):
'''Create joints along a curve in the same direction as the curve
Args:
module (string): what the name of the joint module should be
curve (pm.PyNode): the curve transform to be used
numJoints (int): the number of joints to be created
Returns:
[pm.nt.Joint]: list of joints
Usage:
rig_makeJointsAlongCurve("petalA", pm.ls(sl=True)[0], 15)
rig_makeJointsAlongCurve("seatbeltDrive", pm.ls(sl=True)[0], 160)
'''
#Creating a curve between them
#pm.curve (d=1, n= 'curve_body', p=[(startPos[0],startPos[1],startPos[2]),(endPos[0],endPos[1],endPos[2])])
curve = pm.duplicate(curve)[0]
pm.rebuildCurve(curve, ch=0, rpo=1, rt=0, end=1, kr=1, kcp=0, kep=1, kt=0, s=numJoints, d=1, tol=0.01)
#Evenly spacing joints according to the curve
joints=[]
for k in range(0,numJoints+1):
cvPos = pm.pointPosition( '%s.cv[%s]'%(curve,str(k)), w = 1)
joints.append( pm.joint( n = '%s_0%s_JNT'%(module, str(k+1)), p = cvPos) )
#Set the rotation order
for joint in joints[:-1]:
joint.secondaryAxisOrient('yup', oj='xyz')
pm.delete(curve)
return joints
def bdMirrorCon(self):
print 'Mirror Controller'
selection = pm.ls(sl=True)
if selection.count > 0:
for sel in selection:
if ('L_' in sel.name()) or ('R_' in sel.name()):
print sel.name()
conGrp = sel.getParent()
conGrpPos = conGrp.getTranslation(space='world')
conGrpRot = conGrp.getRotation(space='world')
exp = ['L_','R_']
if 'R_' in conGrp.name():
exp.reverse()
print exp
mirrorConGrp = pm.duplicate(conGrp,name = conGrp.name().replace(exp[0],exp[1]))[0]
mirroCon = mirrorConGrp.getChildren()[0]
mirroCon.rename(sel.name().replace(exp[0],exp[1]))
mirroCon.getShape().overrideColor.set(self.conColors[exp[1]])
mirrorConGrp.setTranslation([conGrpPos[0]*-1,conGrpPos[1],conGrpPos[2]])
mirrorConGrp.setRotation([conGrpRot[0],conGrpRot[1],conGrpRot[2]*-1])
else:
pm.warning( 'Central controller, no need (sic) to mirror it!')
def symCtrl(s, root):
parent = pm.listRelatives(s, parent = True)
children = pm.listRelatives(s, children = True, type = 'transform')
# deparent children
for c in children:
c.setParent(world = True)
# duplicate group parent
for p in parent :
newGroup = pm.duplicate(parent, renameChildren = True, name = p.name().replace('R_', 'L_'))
# rename children
child = pm.listRelatives(newGroup, children = True, type = 'transform')
print(child)
for c in child:
pm.rename(c, c.name().replace('R_', 'L_'))
# reparent children
for c in children:
c.setParent(s)
# deparent copy
print(children)
tempGrp = pm.group(em = True, world = True, name = "tempMirrorGrp" )
for grp in newGroup:
grp.setParent(tempGrp)
# reverse
tempGrp.scaleX.set(-1)
# parent copy group parent to world to world
grp.setParent(world = True)
# parent copy to facial 'facial_ctrl_grp'
grp.setParent(root)
pm.delete(tempGrp)
def duplicate_rigid_body(self):
self.bound_geo = pm.duplicate(self.rigid_body,
name= '%s_rb' % (self.rigid_body))[0]
shape_nodes = self.bound_geo.getShapes()
for shape_node in shape_nodes:
if 'rigidBody' in '%s' % (shape_node):
pm.delete(shape_node)
def rig_makeBlockGeoFromJoint(meshes, influence, *args):
'''Takes in a list of meshes to cut pieces that are influenced by influence object (joint)
Args:
meshes (list(pm.nt.Transform)): meshes to cut up
influence (pm.nt.Joint): figures out the faces influenced based on this one joint
Returns:
list (pm.nt.Transform): list of block geometries created for that influence/joint
Usage:
rig_makeBlockGeoFromJoint(pm.ls(sl=True), 'jointTest_JNT')
'''
blockgeo=[]
for mesh in meshes:
skinCluster = rig_getConnectedSkinCluster(mesh)
if pm.objExists(skinCluster):
influences = skinCluster.getWeightedInfluence()
if influence in influences:
faces = rig_getSkinClusterInfluencedMostFace(mesh, skinCluster, influence)
if faces:
deleteFaces=[]
dup = pm.duplicate(mesh, rr=True)
allFaces = pm.ls(pm.polyListComponentConversion( mesh, tf=True), fl=True)
deleteFaces = list( set(allFaces).difference(set(faces)))
deleteFaces = [pm.PyNode(face.name().replace(mesh.getShape().name(), dup[0].getShape().name())) for face in deleteFaces]
if deleteFaces:
pm.delete(deleteFaces)
dup[0].rename('%s_%s_CUTUP'%(mesh.name(),influence.replace('_JNT','')))
blockgeo.append(dup[0])
else:
pm.delete(dup[0])
return blockgeo
def transfer_shape(source, target, flip=True):
"""it will replace the shape of selected number 2 with the shapes of selected number 1"""
target_shape = target.getShape(noIntermediate=True)
target_shape_orig = get_orig_shape(target_shape)
dup = pymel.duplicate(source, rc=1)[0]
tmp = pymel.createNode('transform')
pymel.parent(tmp, dup)
pymel.xform(tmp, t=(0, 0, 0), ro=(0, 0, 0), scale=(1, 1, 1))
pymel.parent(tmp, w=1)
for sh in dup.getShapes(noIntermediate=True):
pymel.parent(sh, tmp, r=1, s=1)
pymel.delete(dup)
temp_grp_negScale = pymel.createNode('transform')
pymel.parent(tmp, temp_grp_negScale)
if flip:
temp_grp_negScale.scaleX.set(-1)
pymel.parent(tmp, target)
pymel.delete(temp_grp_negScale)
pymel.makeIdentity(tmp, t=True) # this brings translate values at 0 before scale freezing
pymel.makeIdentity(tmp, apply=True, t=True, r=True, s=True)
pymel.parent(tmp, w=1)
color_info, vis_master = get_previous_controller_info(target)
shapes_has_been_deleted = False
for sh in tmp.getShapes():
if target_shape_orig:
adapt_to_orig_shape(sh, target.getShape())
else:
if not shapes_has_been_deleted:
shapesDel = target.getShapes()
if shapesDel: pymel.delete(shapesDel)
shapes_has_been_deleted = True
pymel.parent(sh, target, r=1, s=1)
pymel.rename(sh.name(), target.name() + "Shape")
if color_info[0]:
if color_info[1]:
sh.overrideEnabled.set(True)
sh.overrideRGBColors.set(1)
sh.overrideColorRGB.set(color_info[2])
else:
sh.overrideEnabled.set(True)
sh.overrideRGBColors.set(0)
sh.overrideColor.set(color_info[2])
else:
sh.overrideEnabled.set(False)
if vis_master:
vis_master.connect(sh.visibility)
pymel.delete(tmp)
def bdAddExtraGrp(nameMaskCon,grpType,empty):
controllers = pm.ls(nameMaskCon,type = 'transform')
conPyNodes = []
for con in controllers:
conPyNodes.append(con)
for node in conPyNodes:
if empty:
pm.select(cl=True)
conGrp = pm.group(name = node.name() + '_' + grpType)
pos = node.getTranslation(space='world')
rot = node.getRotation(space='world')
conGrp.setTranslation(pos)
conGrp.setRotation(rot)
parent = node.getParent()
pm.parent(conGrp,parent)
else:
conGrp = pm.duplicate(node,name = node.name().replace('CON',grpType))
'''
for axis in ['X','Y','Z']:
conGrp[0].attr('translate' + axis).setKeyable(True)
conGrp[0].attr('translate' + axis).setLocked(False)
'''
conGrpRelatives = pm.listRelatives(conGrp,ad = True)
#print sdkConRelatives
pm.delete(conGrpRelatives)
pm.parent(node,conGrp)
def cam_projection(selected):
if not selected:
pm.informBox(title="ERROR", message="Please Select a shot Camera to continue", ok="OK")
return None
else:
newCamera = pm.duplicate(ic=False, name="proj_cam_fr" + frame_name)
return newCamera
def addZero(*args, **kwargs):
oblist = makeList(args)
results = []
for item in oblist:
if item.type() == 'joint':
zero = pm.createNode('transform', n=item+'Zero')
zero.rotateOrder.set( item.rotateOrder.get() )
snap(zero, item)
pm.parent(item, zero)
results.append(zero)
elif item.type() == 'transform':
zero = pm.duplicate(item, rr=True)[0]
children = zero.getChildren()
if len(children):
pm.delete(children)
zero.rename(item+'Zero')
for attr in 'trs':
for axis in 'xyz':
pAttr = zero.attr(attr+axis)
pAttr.set(lock=False)
pAttr.set(k=True)
pm.parent(item, zero)
results.append(zero)
if len(results) == 0:
return None
elif len(results) == 1:
return(results[0])
else:
return(results)
def qClothCmd(*args, **kwargs):
'''
create qCloth
step 1: Select an anim geo
step 2: Duplicate a cloth geo and a output geo from the anim geo
step 3: Do blendshape both anim geo and cloth geo with output geo
step 4: Create QCloth on cloth geo
'''
try:
pm.loadPlugin("qualoth-2014-x64.mll")
except:
pass
sel = pm.ls(sl=1)
outputGrpName = 'output_Grp'
clothGrpName = 'cloth_Grp'
if pm.objExists(outputGrpName):
outputGrp = pm.PyNode(outputGrpName)
else:
outputGrp = pm.createNode('transform', name=outputGrpName)
outputGrp.v.set(0)
if pm.objExists(clothGrpName):
clothGrp = pm.PyNode(clothGrpName)
else:
clothGrp = pm.createNode('transform', name=clothGrpName)
outputGeos = [
pm.duplicate(i, name=i.name().replace("_anim", "_output"))[0]
for i in sel
]
[outputGeo.setParent(outputGrp) for outputGeo in outputGeos]
[i.v.set(0) for i in sel]
clothShape = []
for i in sel:
pm.select(i)
clothShape.append(pm.mel.qlCreateCloth())
clothGeos = [pm.PyNode(i).outputMesh.outputs(p=0)[0] for i in clothShape]
[clothGeo.setParent(clothGrp) for clothGeo in clothGeos]
blendNodes = [
pm.blendShape(sel[i], clothGeos[i], outputGeos[i], w=[(0, 0), (1, 1)])
for i in range(len(sel))
]
def IK_createAveObj(cur, number, s="group"):
newCur = pm.duplicate(cur, rr=1, n=cur + "_copyCurve1")
curInfo = pm.arclen(cur, ch=1)
ns = int(curInfo.arcLength.get())
pm.delete(curInfo)
pm.rebuildCurve(newCur,
ch=1,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=0,
s=ns * 100,
d=3,
tol=0.01)
allNewInfo = []
aimObj = []
p = 1.0 / float((number - 1))
prF = 0.0
if s == "position":
allPoistion = []
for i in range(number):
if i == number - 1:
NewInfo = pm.pointOnCurve(newCur, ch=1, top=1, pr=1)
else:
NewInfo = pm.pointOnCurve(newCur, ch=1, top=1, pr=prF)
prF += p
allNewInfo.append(NewInfo)
t = pm.getAttr(NewInfo + ".position")
if s == "position":
allPoistion.append(t)
if s == "group":
obj = pm.group(em=1, n=cur + "_AimGrp" + str(i + 1))
aimObj.append(obj)
pm.setAttr(obj + ".translate", t)
cmds.select(cl=1)
pm.delete(allNewInfo, newCur)
if s == "position":
return allPoistion
if s == "group":
return aimObj
def target(self, source):
dup = pm.duplicate(source)[0]
# pm.select(dup,r=1)
# pm.mel.eval("hyperShade -assign lambert1")
for dAttr in ["displayBorders", "displayEdges"]:
dup.getShape().attr(dAttr).set(1)
for attr in ["tx", "ty", "tz", "rx", "ry", "rz", "sx", "sy", "sz"]:
dup.attr(attr).unlock()
self.targetMesh = dup
def bswExtract(sel):
if not sel:
bs_qui.bs_displayMessage('error', 'Please select geometries.')
return False
mainGrp = pm.createNode('transform', n='blendshapeMain_grp', ss=True)
for each in bsLS:
shapeGrp = pm.createNode('transform', n=each + '_BSGrp', ss=True)
for eachGeo in sel:
dupShape = pm.duplicate(eachGeo, rr=True, n=each + '__' + eachGeo)
pm.parent(dupShape, shapeGrp)
pm.parent(shapeGrp, mainGrp)
def create_chain(self, prefix):
chain = []
dup_chain = self.rig_joints
if prefix == RIG:
dup_chain = self.bnd_joints
for jnt in dup_chain:
if prefix == RIG:
new_jnt = pm.duplicate(jnt, name=RIG + '_' + jnt.name(),
po=1)[0]
else:
new_jnt = pm.duplicate(jnt,
name=jnt.name().replace(RIG, prefix),
po=1)[0]
chain.append(new_jnt)
for i in range(len(chain) - 1, 0, -1):
pm.parent(chain[i], chain[i - 1])
return chain
def duplicateSourceMesh(self, obj, ctrl):
"""
:param obj:
:param ctrl:
:return: Mesh Shape for the Control
"""
dupliObj = pm.duplicate(obj)
pm.rename(dupliObj, ctrl[0].name())
return dupliObj[0], dupliObj[0].getShape()
def exportAnimation(path=None):
"""
Bakes and exports animation on a rig in the scene.
Args:
path(str): An destination fbx path to export.
"""
if path is None:
path = pmc.sceneName()
path = path.replace('.ma', '.fbx')
# Get the root joint
root = None
namespace = None
for namespace in pmc.listNamespaces():
root = getRootJoint(namespace)
if root is not None:
namespace = namespace
break
if root is None:
raise RootJointException('Could not find a root in the scene with a namespace.')
try:
pmc.undoInfo(openChunk=True)
# Create a duplicate root joint
dupRoot = pmc.duplicate(root)[0]
pmc.rename(dupRoot, root.nodeName().split(':')[-1])
# Copy animation tags
copyTagAttribiutes(root, dupRoot)
# Bind skeleton
constraints = []
exportJoints = [dupRoot] + getBindSkeleton()
for joint in [dupRoot] + getBindSkeleton():
source = pmc.PyNode('%s:%s' % (namespace, joint.nodeName()))
constraints.append(pmc.parentConstraint(source, joint))
# Bake animation and remove constraints
bakeAnimation(exportJoints)
pmc.delete(constraints)
# Export animation and convert to hkx
exportFbx([dupRoot] + getBindSkeleton(), path=path, animation=True)
ckcmd.importanimation(
getSceneSkeletonHkx(legacy=True), path,
getSceneAnimationDirectory(), cache_txt=getSceneCacheFile(),
behavior_directory=getSceneBehaviorDirectory()
)
# TODO copy cache file to correct directory
finally:
pmc.undoInfo(closeChunk=True)
def duplicateSourceMesh(self, obj, joint):
"""
:param obj:
:param ctrl:
:return: Mesh Shape for the Control
"""
dupliObj = pm.duplicate(obj)
pm.rename(dupliObj, name.removeSuffix(joint) + '_PRX')
return dupliObj[0], dupliObj[0].getShape()
def duplicate_rigid_body(self):
'''
# duplicates the rigid body object, and names with _rb
'''
self.bound_geo = pm.duplicate(self.rigid_body,
name='%s_rb' % (self.rigid_body))[0]
shape_nodes = self.bound_geo.getShapes()
# deleting the rigid body shape on the duplicated object
for shape_node in shape_nodes:
if 'rigidBody' in '%s' % (shape_node):
pm.delete(shape_node)
def advancedTwist(start, end, baseCtrl, endCtrl, ik):
# Setup advanced twist
startAxis = duplicate(start, po=True)[0]
startAxis.rename('startAxis')
startAxis.setParent(baseCtrl)
core.dagObj.lockTrans(core.dagObj.lockRot(
core.dagObj.lockScale(startAxis)))
endAxis = duplicate(start, po=True)[0]
endAxis.rename('endAxis')
endAxis.setParent(endCtrl)
endAxis.t.set(0, 0, 0)
core.dagObj.lockTrans(core.dagObj.lockRot(core.dagObj.lockScale(endAxis)))
hide(startAxis, endAxis)
ik.dTwistControlEnable.set(1)
ik.dWorldUpType.set(4)
startAxis.worldMatrix[0] >> ik.dWorldUpMatrix
endAxis.worldMatrix[0] >> ik.dWorldUpMatrixEnd
def add_sine(self):
nurbs_sine = pm.duplicate(self.nurbs,
name='geo_' + self.ribbon_name + '_sine')
# create sine deformer
dfm_sine, tfm_sine = pm.nonLinear(nurbs_sine, type='sine')
tfm_sine.setRotation([0, 0, 90], space='world')
dfm_sine.dropoff.set(1)
pm.blendShape(nurbs_sine, self.nurbs, weight=[0, 1])
def generateReposer():
rJoints = []
rCards = []
# Build all the cards and joints
cards = core.findNode.allCards()
for card in cards:
rCard = duplicate(card, po=0)[0]
rCard.deleteAttr('fossilRigData')
for child in rCard.listRelatives():
if not child.type() == 'nurbsSurface':
delete(child)
rCards.append(rCard)
makeIdentity(rCard, t=False, r=False, s=True, apply=True)
core.dagObj.lockScale(rCard)
for jnt in card.joints:
j = joint(None)
j.rename(simpleName(jnt, '{}_repose'))
core.dagObj.matchTo(j, jnt)
assert jnt.info.get('options', {}).get(
'mirroredSide',
False) is False, 'parent to mirrored joints not supported yet'
j.addAttr('bpj', at='message')
jnt.message >> j.bpj
rJoints.append(j)
# Set their parents
for j in rJoints:
parent = j.bpj.listConnections()[0].parent
if parent:
j.setParent(getRJoint(parent))
# Put under cards, card pivot to lead joint
for rCard, card in zip(rCards, cards):
bpj = card.parentCardJoint
if bpj:
start = card.start() if card.joints else bpj
rCard.setParent(getRJoint(bpj))
core.dagObj.unlock(rCard)
xform(rCard, ws=True, piv=xform(start, q=True, t=True, ws=True))
core.dagObj.lockTrans(rCard)
start = getRJoint(card.start())
start.setParent(rCard)
core.dagObj.lockTrans(core.dagObj.lockScale(start))
for j in rJoints:
lockRYZ(j)
def prepareObjectForMirror(objs=None):
if objs:
objs = pm.ls(objs)
else:
objs = pm.ls(sl=True)
for obj in objs:
nameSpaceAndName = obj.name().split(":")
if len(nameSpaceAndName) > 1:
objNameSpace = nameSpaceAndName[0]
objName = nameSpaceAndName[1]
else:
objName = obj.name()
if objName[:2] == ('L_'):
otherObj = pm.PyNode(obj.name().replace('L_', 'R_'))
elif objName[:2] == ('R_'):
otherObj = pm.PyNode(obj.name().replace('R_', 'L_'))
else:
otherObj = obj.name()
if not (pm.objExists(obj.name() + '_AIM')):
aim = pm.spaceLocator(name='%s_AIM' % obj.name())
pm.parent(aim, obj)
aim.translate.set(1, 0, 0)
aim.rotate.set(0, 0, 0)
up = pm.spaceLocator(name='%s_UP' % obj.name())
pm.parent(up, obj)
up.translate.set(0, 1, 0)
up.rotate.set(0, 0, 0)
aim2 = pm.duplicate(aim)[0]
pm.parent(aim2, world=True)
aim2.translateX.set(-aim2.translateX.get())
pm.parent(aim2, otherObj)
pm.rename(aim2, '%s_AIM' % otherObj.name())
up2 = pm.duplicate(up)[0]
pm.parent(up2, world=True)
up2.translateX.set(-up2.translateX.get())
pm.parent(up2, otherObj)
pm.rename(up2, '%s_UP' % otherObj.name())
def build_spine(self, spine_num):
spine_curve_dup = pm.duplicate('spine_guide__curve', n = 'spine_guide__curve_dup')[0]
pm.makeIdentity(spine_curve_dup , n=0, s=1, r=1, t=1, apply=True, pn=1)
pm.parent(spine_curve_dup, world=True)
poc = adb_PointonCurve.PointToCurveJnt(spine_num, sel=spine_curve_dup)
spine_joints = poc.getJoints
adb_spine.SpineSetUp(spine_joints)
pm.delete(spine_curve_dup)
[pm.delete(pm.PyNode(x).getParent()) for x in spine_joints]
def rebuild_targets_with_mask():
"""
Rebuilds targets by duplicating the mesh.
:return:
"""
sel = pymel.selected()
skin_node = sel[0].listHistory(type='skinCluster')
tweak_node = sel[0].listHistory(type='tweak')
if skin_node:
skin_node[0].envelope.set(0)
if tweak_node:
tweak_node[0].envelope.set(0)
blend_shape_node = sel[0].listHistory(type='blendShape')[0]
blend_aliases = blend_shape_node.listAliases()
connection_dict = {}
for alias in blend_aliases:
attribute = '{}.{}'.format(blend_shape_node, alias[0])
connection = pymel.listConnections(attribute,
destination=True,
plugs=True)
if connection:
print connection[0]
connection_dict[attribute] = connection[0]
pymel.disconnectAttr(connection[0], attribute)
pymel.setAttr(attribute, 0)
for alias in blend_aliases:
attribute = '{}.{}'.format(blend_shape_node, alias[0])
pymel.setAttr(attribute, 1)
dup = pymel.duplicate(sel[0], name=alias[0])
for attr in dup.listAttributes():
try:
attr.unlock()
except:
pass
pymel.parent(dup[0], world=True)
pymel.setAttr(attribute, 0)
if attribute in connection_dict.keys():
pymel.connectAttr(connection_dict[attribute], attribute)
if skin_node:
skin_node[0].envelope.set(1)
if tweak_node:
tweak_node[0].envelope.set(1)
def make_chain_surface(cls, spans=10):
count = 1
nurbs = pm.nurbsPlane(u=1, v=spans, lr=5, n="surface")
geo = pm.PyNode(nurbs[0])
fols = []
fol_shapes = []
while count < spans:
fol = pm.createNode('transform', n='follicle1', ss=True)
fol_shape = pm.createNode('follicle',
name="folicle_shape",
p=fol,
ss=True)
pm.connectAttr(geo.local, fol_shape.inputSurface)
pm.connectAttr(geo.worldMatrix[0], fol_shape.inputWorldMatrix)
pm.connectAttr(fol_shape.outRotate, fol.rotate)
pm.connectAttr(fol_shape.outTranslate, fol.translate)
fol.inheritsTransform.set(False)
fol_shape.parameterU.set(0.5)
fol_shape.parameterV.set(0.1 * count)
fols.append(fol)
fol_shapes.append(fol_shapes)
count += 1
nurbs_jnts = Chain.make_jnt_chain(
fols, name_template="_surface_{number}_JNT")
for nurbs_JNT, fol in zip(nurbs_jnts[0:], fols[:-1]):
nurbs_JNT.setParent(fol)
drivers = []
driver_a_jnt = pm.duplicate(nurbs_jnts[0], name="driver_A")
driver_b_jnt = pm.duplicate(nurbs_jnts[(spans / 2) - 1],
name="driver_B")
driver_c_jnt = pm.duplicate(nurbs_jnts[-1], name="driver_C")
drivers.append(driver_a_jnt)
drivers.append(driver_b_jnt)
drivers.append(driver_c_jnt)
pm.parent(drivers, w=True)
for driver in drivers:
pm.setAttr(driver[0] + ".radius", 1.5)
pm.bindSkin(nurbs, drivers)
def mirrorJoints(sJnt, side=""):
sJnt = pym.PyNode(sJnt)
if side == "":
if "_r_" in sJnt.name():
mirrorJoints(sJnt, side="l")
return
if "_l_" in sJnt.name():
mirrorJoints(sJnt, side="r")
return
if side == "r":
src = "_l_"
tgt = "_r_"
aux = "_rr_"
if side == "l":
src = "_r_"
tgt = "_l_"
aux = "_ll_"
print src, tgt, aux
mGrp = pym.createNode("transform", n="mirror_grp")
name = sJnt.name()
auxname = name.replace(src, aux)
nJnt = pym.duplicate(sJnt, n=auxname)[0]
for cJnt in nJnt.listRelatives(ad=True):
cName = cJnt.name()
cAuxName = cName.replace(src, aux)
cJnt.rename(cAuxName)
pym.parent(nJnt, mGrp, a=True)
mGrp.scaleX.set(-1)
def recurse(root, p=None):
nf = root.name()
newname = nf.replace(aux, tgt)
newJnt = pym.createNode("joint", n=newname)
copyTM(root, newJnt)
newJnt.radius.set(root.radius.get())
pym.makeIdentity(newJnt,
apply=True,
translate=True,
rotate=True,
scale=True)
if p:
pym.parent(newJnt, p)
for child in root.getChildren(type="joint"):
recurse(child, p=newJnt)
recurse(nJnt)
pym.delete(mGrp)
def splitSidesAPI(targetObj, sourceObj, falloff=0.2):
# look at number of verticies
pm.select(sourceObj)
tgtVertex = getObjVertex(targetObj.name())
srcVertex = getObjVertex(sourceObj.name())
bBox = getBBox(targetObj.name())
rgtX = bBox.max.x
# duplicate face twice (one left, one right)
targetObj_Lft = pm.duplicate(targetObj, n='R_' + targetObj)[0]
pm.move(targetObj_Lft, rgtX * -2.1, 0, 0, r=1)
targetObj_Rgt = pm.duplicate(targetObj, n='L_' + targetObj)[0]
pm.move(targetObj_Rgt, rgtX * 2.1, 0, 0, r=1)
side = 1
# on each object
for target in ([targetObj_Lft, targetObj_Rgt]):
side *= -1
newPoint = om2.MPoint()
newPntArray = om2.MPointArray()
for id in range(len(srcVertex)):
# get vert positions
# find difference
differencePos = (srcVertex[id][0] - tgtVertex[id][0],
srcVertex[id][1] - tgtVertex[id][1],
srcVertex[id][2] - tgtVertex[id][2])
# get falloff amount from side of object
falloffDist = getValue(srcVertex[id][0], falloff * side)
# move vert difference * falloff amount
newPntArray.append(
om2.MPoint(tgtVertex[id][0] + (differencePos[0] * falloffDist),
tgtVertex[id][1] + (differencePos[1] * falloffDist),
tgtVertex[id][2] +
(differencePos[2] * falloffDist)))
setObjVertex(target.name(), newPntArray)
def reacquisition_curPosList(newcur, paramList, myface) :
print "カーブ", newcur.name(), "を複製し，ターゲットカーブとします."
if pm.objExists(myface.projection_curve_name) :
c = pm.PyNode(myface.projection_curve_name)
pm.delete(c)
c = pm.duplicate(newcur, n = myface.projection_curve_name)
myface.curve = c[0]
global curPosList
curPosList = getCurvePoint(c[0],paramList, "curvature")
def makeOrigShape(obj):
"""Given a transform with some shape, create the basic foundation
of deformation order, ie an "orig" shape."""
try:
shape = obj.getShape()
except AttributeError:
pmc.error("makeOrigShape argument must be a shape's transform node")
orig = pmc.duplicate(shape, addShape=True, n=shape.name() + "Orig")[0]
orig.ws >> shape.create
# toggle this real quick to fix a texture bug
orig.doubleSided.set(False)
orig.doubleSided.set(True)
orig.intermediateObject.set(True)
def create_jnt_chain(name, ref_jnt, ref_jnt_end, number, suffix):
"""
This module creates a joint chain by given to points' position and number of the joints in between these.
:param name: str, base_name of the joints
:param ref_jnt: str, start reference joint name
:param ref_jnt_end: str, end reference joint name
:param number: int, number of the joints in between the ref points
:param suffix: str, suffix of the joint chain
:return jnt_chain: str array, array of the newly created joints
:return distance: float, distance between the ref joints
"""
jnt_chain = []
start_jnt = pm.duplicate(ref_jnt,
n='{}_ref'.format(ref_jnt),
parentOnly=True)[0]
pm.parent(start_jnt, w=True)
end_jnt = pm.duplicate(ref_jnt_end,
n='{}_ref'.format(ref_jnt_end),
parentOnly=True)[0]
pm.parent(end_jnt, start_jnt)
pm.joint(start_jnt, e=True, zso=True, oj="xyz", sao="yup")
distance = pm.getAttr('{}.translateX'.format(end_jnt)) / number
def recurse_jnt_chain(base_name, current_jnt, suf, count):
if number >= count:
jnt_name = '{}_{}_{}_jnt'.format(base_name, str(count), suf)
jnt_chain.append(jnt_name)
pm.joint(n=jnt_name)
orient_node(current_jnt, jnt_name, 'b')
pm.parent(jnt_name, current_jnt)
if count > 0:
pm.xform(jnt_name, t=(distance, 0, 0))
current_jnt = jnt_name
else:
return None
return recurse_jnt_chain(name, current_jnt, suf, count + 1)
recurse_jnt_chain(name, start_jnt, suffix, 0)
return jnt_chain, distance
def bdCreateFKChain(self):
fkRootObj = pm.duplicate(self.rootObj)[0]
fkRootObj.rename(self.rootObj.name() + '_FK')
fkChain = fkRootObj.listRelatives(type='joint', ad=True, f=True)
#fkChain.append(fkRootObj)
fkChain.reverse()
for jnt in fkChain:
jnt.rename(jnt.name() + '_FK')
pm.skinCluster(fkRootObj, self.dynCrv)
return fkRootObj
def zeroJoints(jointsList=None):
if not jointsList:
jointsList = pm.ls(sl=1)
for eachJnt in jointsList:
dup = pm.duplicate(eachJnt, rc=1, n=eachJnt[:-3] + "zero")
try:
for eachChild in pm.listRelatives(dup[0], c=1):
pm.delete(eachChild)
except:
pass
pm.parent(eachJnt, dup[0])
def extractShapes(self):
"""
extract Shapes from targets
"""
self.__reset__()
parent = pym.createNode("transform", n=self.bsNode.name() + "_grp")
for key, attr in self.__attrs__.iteritems():
attr.set(1.0)
dup = pym.duplicate(self.defNode, n=key)
pym.parent(dup, parent, a=True)
attr.set(0.0)
self.__restore__()
return parent
def unique_spine_zero_controller(self):
# Create Root Costrain Jnt Unde Hip cotrol
# Duplicate zero Jnt
tempConst = pm.duplicate(self.joints.zeroJoint, po=True,
name=("Const_" + self.joints.zeroJoint ))
rootConst_jnt = tempConst[0]
pm.parent(rootConst_jnt, self.hipCtrl.drawnNode)
pm.pointConstraint(rootConst_jnt, self.joints.zeroJoint)
pm.orientConstraint(rootConst_jnt, self.joints.zeroJoint)
pm.setAttr(rootConst_jnt.visibility, 0)
self._stuff.append(rootConst_jnt)
def copyShape(source, dest, mirror=False):
'''
Make a copy of the source's shape for the dest.
:param bool mirror: If true, it is build mirrored on the x axis.
'''
source = duplicate(source)[0]
color = getShader(dest)
delete(core.shape.getShapes(dest))
hasSharedShape = False
if lib.sharedShape.find(dest):
hasSharedShape = True
lib.sharedShape.remove(dest)
srcShapes = []
newShapes = []
for shape in core.shape.getShapes(source):
srcShapes.append(shape)
newShapes.append(
parent(shape, dest, s=True, add=True)[0]
) # Might be a 2017 bug that shape.setParent() doesn't return an object
if source.hasAttr('shapeType'):
if not dest.hasAttr('shapeType'):
try:
dest.addAttr('shapeType', dt='string')
except:
pass
if source.hasAttr('shapeType'):
dest.shapeType.set(source.shapeType.get())
if color:
core.shader.assign(dest, color)
# Reapply the shared shape if it exists to ensure it is at the end
if hasSharedShape:
lib.sharedShape.use(dest)
addDisplayAttr(dest)
if mirror:
for srcShape, newShape in zip(srcShapes, newShapes):
for sCv, dCv in zip(srcShape.cv, newShape.cv):
pos = xform(sCv, q=True, ws=True, t=True)
pos[0] *= -1
xform(dCv, ws=True, t=pos)
delete(source)
def jntOnCrv(self, numOfJnts=5, crv=None, *args):
try: # if in UI mode, get number of joints from UI
numOfJnts = pm.intSliderGrp(self.slider, q=True, value=True)
except:
pass
if crv == None:
try:
crv = pm.ls(sl=True)[0]
except:
pm.warning(
'ehm_tools...JntOnCrv: Select a curve to create joints on it.'
)
return None
if numOfJnts < 2:
pm.warning("number of joints must be greater than 1.")
return None
try:
curveShape = crv.getShape().type()
except:
pm.warning("specified object is not a curve.")
return None
if curveShape != 'nurbsCurve':
pm.warning("specified object is not a curve.")
return None
crv = pm.duplicate(crv)[0]
pm.rebuildCurve(crv,
ch=False,
rpo=True,
rt=0,
end=1,
kr=0,
kcp=False,
kep=True,
kt=0,
s=200,
d=1,
tol=0.01)
crvShape = crv.getShape()
pm.select(clear=True)
segSize = 1.0 / (numOfJnts - 1)
for i in range(numOfJnts):
pos = crvShape.getPointAtParam(segSize * i, 'world')
self.newJnts.append(pm.joint(p=pos))
pm.delete(crv)
def distribute(self, increment, bbox=False, *args, **kwargs):
if not (self.curves and self.transformMesh):
logger.info('No curves were saved, please excecute .saveObjects() before')
return
for curve in self.curves:
currentCurvePos = 0.0
if increment >= curve.length():
logger.info('Increment value is higher than %s length' % curve)
continue
curveGrp = pm.createNode('transform', n='%sGrp' % curve)
self.curveGroups.add(curveGrp)
while currentCurvePos < 1.0:
random.shuffle(self.transformMesh) # random items
logger.debug('currentCurvePos value is: %s' % currentCurvePos)
if bbox:
currentCurvePos += self.boundingBoxObject(self.transformMesh[0])/curve.length()
# validateChecks
if currentCurvePos > 1:
logger.debug('currentCurvePos value is bigger than 1: %s : %s' % (curve, currentCurvePos))
break
if currentCurvePos <= 0:
logger.warning('currentCurvePos is not incrementing its value: %s' % currentCurvePos)
break
# create duplicate obj
trnfMesh = pm.duplicate(self.transformMesh[0])[0]
logger.debug('trnsMesh is type: %s' % type(trnfMesh))
# group object and parent it in its respective curveGrp
trnfGrp = pm.createNode('transform', n='%sOffset' % trnfMesh)
motionPath = pm.PyNode(pm.pathAnimation(trnfGrp, c=curve, follow=True, followAxis='x', upAxis='y', fractionMode=True))
motionPath.setUStart(currentCurvePos)
pm.parent(trnfGrp, curveGrp)
# pm.disconnectAttr('%s_uValue.output' % motionPath, motionPath.uValue)
pm.delete('%s_uValue' % str(motionPath))
# pos group and set transforms to zero
pm.parent(trnfMesh, trnfGrp)
trnfMesh.setTranslation((0,0,0), space='object')
trnfMesh.setRotation((0,0,0))
self.randomizerItem(trnfMesh, *args, **kwargs)
currentCurvePos += increment / curve.length() # this syntax type doesn't work on Int
if bbox:
currentCurvePos += self.boundingBoxObject(self.transformMesh[0]) / curve.length()
# validateChecks
if currentCurvePos > 1:
logger.debug('currentCurvePos value is bigger than 1: %s : %s' % (curve, currentCurvePos))
break
if currentCurvePos <= 0:
logger.warning('currentCurvePos is not incrementing its value: %s' % currentCurvePos)
break
def createMainNodes(self):
#grps
#chain grp
self.chainGrp = pm.duplicate(self.rigGrp, parentOnly=True)[0]
self.chainGrp.renameNode(name=self.TipName, nodeType='chain')
self.chainGrp.setParent(self.rigGrp)
#horizontal driver
self.horizontalDriver = pm.duplicate(self.chainGrp, parentOnly=True)[0]
self.horizontalDriver.renameNode(name=self.TipName, nodeType='horizDriver')
pm.delete(pm.pointConstraint(self.startJoint, self.horizontalDriver))
#vertical driver
self.verticalDriver = pm.duplicate(self.horizontalDriver, parentOnly=True)[0]
self.verticalDriver.renameNode(name=self.TipName, nodeType='vertDriver')
#main
pm.select(self.horizontalDriver)
self.driver = pm.joint()
self.driver.renameNode(name=self.TipName, nodeType='driver')
self.driver.addCon()
self.driver.getParent().setParent(self.chainGrp)
self.driver.getParent().visibility.set(0)
pm.select(self.driver)
self.main = pm.joint()
self.main.renameNode(name=self.TipName, descriptor='system')
pm.select(self.endJoint)
self.eff = pm.joint()
self.eff.renameNode(name=self.TipName, nodeType='effector')
self.eff.setParent(self.driver)
self.horizontalDriver.setParent(self.chainGrp)
self.verticalDriver.setParent(self.chainGrp)
#connectEye
self.startJoint.rotate.connect(self.driver.getParent().rotate)
def createRbnSrf(self):
startJntVec = om.MVector(self.start[0], self.start[1], self.start[2])
endJntVec = om.MVector(self.end[0], self.end[1], self.end[2])
diffVec = endJntVec - startJntVec
# calculate the witdth of the surface as a fraction of the total joint chain length
jntChainLength = diffVec.length()
self.width = jntChainLength * self.widthMult
crv1 = pm.duplicate(pm.ls(self.buildCrv)[0])[0]
crv1.setPivots(self.start)
crv2 = pm.duplicate(crv1)[0]
self.offsetCrv(crv1, -0.3 * self.width)
self.offsetCrv(crv2, 0.3 * self.width)
loftSrf = pm.loft(crv1,
crv2,
ch=0,
u=1,
c=0,
ar=1,
d=1,
ss=1,
rn=0,
po=0,
rsn=1)[0]
loftSrf = \
pm.rebuildSurface(ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kc=0, su=0, du=1, sv=0, dv=1, tol=0, fr=0, dir=2,
n=self.name + "_srf")[0]
pm.rename(loftSrf, self.name + "_srf")
loftSrf.setPivots(loftSrf.c.get())
self.rbnSrf = loftSrf
pm.delete(self.rbnSrf, ch=1)
pm.delete([crv1, crv2])
pm.parent(self.rbnSrf, self.mainGrp)
