def MakePointOnSurfaceNd(surface):
mc.select ("mesh_*MouthLip")
lx_mesh = mc.ls(sl=1)
mc.select ("snd_mouthLip*")
lx_sndJnt = mc.ls(sl=True )
lx_node ,lx_locGrp=[],[]
for lx_i in lx_sndJnt :
lx_temp=mc.xform(lx_i,q=1,ws =1,t=1)
lx_locN= "loc_"+lx_i
mc.spaceLocator(n=lx_locN,a=1,p=(lx_temp[0],lx_temp[1],lx_temp[2]))
lx_locGrp.append(lx_locN)
lx_null = 'grp_'+lx_i+'02'
mc.group(n=lx_null,em =1)
mc.toggle (lx_null,la=1)
mc.parent (lx_null ,('grp_'+lx_i+'01'))
mc.parent (('grp_'+lx_i+'03'),lx_null)
nd=mc.pointOnSurface(lx_mesh,ch=True )
#lx_node.insert(1,nd);
ndName = "pntNd_"+lx_i
mc.rename(nd,ndName )
mc.connectAttr ((ndName +".position"),('grp_'+lx_i+'02.translate'))
mc.setAttr (('grp_'+lx_i+'01.translate'),0,0,0,type ="double3")
mc.setAttr (('grp_'+lx_i+'03.translate'),0,0,0,type="double3")
mc.xform (('grp_'+lx_i+'01'),cp=True)
mc.select(cl=1)
mc.select(lx_locGrp )
mc.group (n="grp_locMouthLip01")
def pointOnCurveLocCV(name,curve):
if not cmds.nodeType(curve) == 'shape':
curve = cmds.listRelatives(curve, type = 'shape')[0]
mobject = GenAPI.getMObject(curve)
iterCVs = om.MItCurveCV(mobject)
while not iterCVs.isDone():
index = iterCVs.index()
nameIndex = index + 1
moPath = cmds.createNode('motionPath')
moPath = cmds.createNode('motionPath',n = '%s_0%i_MotionPath'%(name,nameIndex))
cmds.connectAttr('%s.worldSpace[0]'%curve,'%s.geometryPath'%moPath)
locator = cmds.spaceLocator(n = '%s_0%i_MP_Loc'%(name,nameIndex))
cmds.addAttr(locator[0],ln = "Offset" ,at = 'double')
cmds.setAttr('%s.Offset'%locator[0], e = True, keyable = True)
upLocator = cmds.spaceLocator(n = '%s_0%i_MP_Up_Loc'%(name,nameIndex))
cmds.connectAttr('%s.allCoordinates'%moPath,'%s.translate'%locator[0])
cmds.connectAttr('%s.rotate'%moPath,'%s.rotate'%locator[0])
cmds.connectAttr('%s.rotateOrder'%moPath, '%s.rotateOrder'%locator[0])
uValue = MeasuringTool.curveCVtoU(curve,index)
cmds.setAttr('%s.uValue'%moPath, uValue)
cmds.setAttr('%s.worldUpType'%moPath, 2)
cmds.setAttr ('%s.frontAxis'%moPath,0)
cmds.setAttr ('%s.upAxis'%moPath,2)
offsetMD = cmds.createNode('multiplyDivide', n = '%s_0%i_Offset_MD'%(locator[0],nameIndex))
cmds.connectAttr('%s.Offset'%locator[0],'%s.input1X'%offsetMD)
cmds.setAttr('%s.input2X'%offsetMD, 0.1)
offsetPMA = cmds.createNode('plusMinusAverage', n = '%s_0%i_Offset_PMA'%(locator[0],nameIndex))
cmds.connectAttr('%s.outputX'%offsetMD,'%s.input1D[0]'%offsetPMA )
cmds.setAttr('%s.input1D[1]'%offsetPMA,uValue)
cmds.connectAttr('%s.output1D'%offsetPMA, '%s.uValue'%moPath)
locPos = cmds.xform(locator[0], q = True, ws = True, translation = True)
locOrient = cmds.xform(locator[0], q = True, ws = True, rotation = True)
cmds.setAttr ('%s.worldUpVectorX'%moPath,0)
cmds.setAttr ('%s.worldUpVectorY'%moPath,0)
cmds.setAttr ('%s.worldUpVectorZ'%moPath,1)
cmds.connectAttr('%s.worldMatrix[0]'%upLocator[0], '%s.worldUpMatrix'%moPath)
nullGroup = cmds.group(empty = True, n = '%s_Group'%upLocator[0])
cmds.move(locPos[0], locPos[1],locPos[2],nullGroup)
cmds.rotate(locOrient[0],locOrient[1],locOrient[2], nullGroup)
cmds.parent(upLocator[0], nullGroup,r = True)
cmds.move(0,0,10,upLocator[0], a = True, os = True)
cmds.group(locator[0],nullGroup,n = '%s_0%i_MP_Loc_Group'%(name,nameIndex))
iterCVs.next()
def rotateOrderReference(self, rotorder, *args):
if rotorder == 0:
# 既に存在するかチェック
if cmds.objExists("locatorXYZ"):
print ("locatorXYZ exists already.")
else:
cmds.spaceLocator(p=(0, 0, 0), n="locatorXYZ")
cmds.select("locatorXYZ")
cmds.setAttr("locatorXYZ.rotateOrder", 0)
if rotorder == 2:
# 既に存在するかチェック
if cmds.objExists("locatorXYZ"):
print ("locatorZXY exists already.")
else:
cmds.spaceLocator(p=(0, 0, 0), n="locatorZXY")
cmds.select("locatorZXY")
cmds.setAttr("locatorZXY.rotateOrder", 2)
else:
print ("Info: RotateOrder Input Parameter Error <Sync Unity Transform> ")
def aimRig(self,name):
#query start location and orient
startPosition = MeasuringTool.getPointLocation(self.objectStart)
startOrient = MeasuringTool.getWorldEulerRotation(self.objectStart)
#create locators
aimLoc = cmds.spaceLocator(n = '%s_Aim_AimVector_Loc'%(name))
upLoc = cmds.spaceLocator(n = '%s_Aim_UpVector_Loc'%(name))
tgt = cmds.spaceLocator(n = '%s_Aim_Target_Loc'%(name))
#create hierarchy
posNull = cmds.group(aimLoc[0],upLoc[0],tgt[0],n = '%s_Aim_Pos_Null'%(name))
cmds.move(startPosition[0],startPosition[1],startPosition[2],posNull)
cmds.rotate(startOrient[0],startOrient[1],startOrient[2],posNull)
#find vector length
distance = self.getPointDistanceBetween()
length = MeasuringTool.getVectorLength([distance[0],distance[1],distance[2]])
#move and apply constraints to target
cmds.move(length,0,0,tgt, a = True, os = True)
cmds.move(0,0,10,upLoc[0],os = True)
cmds.parentConstraint(self.objectStart,posNull)
cmds.pointConstraint(self.objectEnd,tgt[0])
cmds.aimConstraint(tgt,aimLoc, aimVector = (1,0,0), upVector = (0,0,1), worldUpType = "object", worldUpObject = upLoc[0])
def setup_dof(target, camera, f_stop):
cmds.setAttr(camera + ".depthOfField", 1)
# create a locator parented to the camera
cam_matrix = cmds.xform(camera, q=True, m=True, ws=True)
cam_locator = cmds.spaceLocator()
cmds.xform(cam_locator, m=cam_matrix, ws=True)
cmds.select(cam_locator, camera, r=True)
cmds.parent()
# create a locator parented to the target
target_matrix = cmds.xform(target, q=True, m=True, ws=True)
target_locator = cmds.spaceLocator()
cmds.xform(target_locator, m=target_matrix, ws=True)
cmds.select(target_locator, target, r=True)
cmds.parent()
distance_node = cmds.distanceDimension(cam_locator, target_locator)
cmds.connectAttr(distance_node + ".distance", camera + ".focusDistance")
f_stop_multiplier = 1.0
while f_stop < 1.0:
f_stop *= 2.0
f_stop_multiplier /= 2.0
cmds.setAttr(camera + ".fStop", f_stop)
cmds.setAttr(camera + ".focusRegionScale", f_stop_multiplier)
def bdGetComMain():
locators = cmds.ls('locator*')
if locators:
cmds.delete(locators)
mDagObject = om.MDagPath()
mSelList = om.MSelectionList()
om.MGlobal.getActiveSelectionList(mSelList)
centerMass = om.MPoint(0,0,0)
mSelList.getDagPath(0,mDagObject)
print centerMass.x, centerMass.y, centerMass.z
if mSelList.length():
if mDagObject.hasFn(om.MFn.kMesh):
mFnMesh = om.MFnMesh(mDagObject)
for i in range(mFnMesh.numVertices()):
mVertPos = om.MPoint()
mFnMesh.getPoint(i,mVertPos,om.MSpace.kWorld)
print i
print mVertPos.x, mVertPos.y,mVertPos.z
centerMass += om.MVector(mVertPos)
print centerMass.x, centerMass.y,centerMass.z
cmds.spaceLocator(p=[mVertPos.x,mVertPos.y,mVertPos.z])
print mFnMesh.numVertices()
centerMass = centerMass / (mFnMesh.numVertices())
cmds.spaceLocator(p=[centerMass.x,centerMass.y,centerMass.z])
def createPathLocators(*argv):
oPathLoc = cmds.spaceLocator(n='pathLocator')
oStopLoc = cmds.spaceLocator(n='stopLocator')
oPathLocGrp = cmds.group(oPathLoc,n='pathLocatorGrp')
cmds.group(oStopLoc,n='stopLocatorGrp')
cmds.pathAnimation( oPathLocGrp, stu=0, etu=1000, fa='x', ua='y', bank=True, fm = True,c='pathCurve' )
cmds.parentConstraint(oPathLoc,oStopLoc,cmds.ls('*:Master_Anim')[0])
def set_knee_IK():
# メッセージ
cmds.inViewMessage(amg="<hl>「指のコントローラー設置」</hl>を押してください。", pos="midCenter", fade=True, fit=1, fst=4000, fts=20)
# 座標取得
positionR = cmds.xform("Knee_R", q=True, ws=True, t=True)
locatorNameR = "Knee_R_Locator"
# ロケーター設置
cmds.spaceLocator(p=(positionR[0], positionR[1], positionR[2] + 3.8), n=locatorNameR)
knee_ik_add("Hip_R", "Ankle_R", "Knee_R_Effector", positionR, locatorNameR)
# 座標取得
positionL = cmds.xform("Knee_L", q=True, ws=True, t=True)
locatorNameL = "Knee_L_Locator"
# ロケーター設置
cmds.spaceLocator(p=(positionL[0], positionL[1], positionL[2] + 3.8), n=locatorNameL)
knee_ik_add("Hip_L", "Ankle_L", "Knee_L_Effector", positionL, locatorNameL)
# つま先のIK実行
toe_ik_add("Ankle_R", "MiddleToe2_R", "Ankle_R_Effector")
toe_ik_add("Ankle_L", "MiddleToe2_L", "Ankle_L_Effector")
# 足のコントローラー、 座標取得
toePositionR = cmds.xform("MiddleToe1_R", q=True, ws=True, t=True)
toePositionL = cmds.xform("MiddleToe1_L", q=True, ws=True, t=True)
foot_controller("foot_R_controller", toePositionR[0])
foot_controller("foot_L_controller", toePositionL[0])
# コントローラー内にエフェクター移動
cmds.parent("Ankle_L_Effector", "foot_L_controller")
cmds.parent("Knee_L_Effector", "foot_L_controller")
cmds.parent("Ankle_R_Effector", "foot_R_controller")
cmds.parent("Knee_R_Effector", "foot_R_controller")
# 親子関係移動
cmds.parent("Knee_R_Locator", "Knee_L_Locator", "foot_R_controller", "foot_L_controller", "main_controller")
def _createBaseJoints(self, verteces, baseName, skipTips = False, baseGrp = None ): """create based joints with the verteces and name it all with baseName""" #Create UP vector Locator upVecLoc = mn.Node( mc.spaceLocator( n = baseName + '_UP_LOC' )[0] ) upVecLoc.shape.a.localScale.v = [self.SCALE]*3 upVecLoc.a.t.v = [ self.center[0], self.center[1] + 1, self.center[2] ] upVecLoc.parent = baseGrp #GROUPS grp = mn.Node( mc.group( n = baseName + '_JNT_GRP', em = True ) ) locgrp = mn.Node( mc.group( n = baseName + '_LOC_GRP', em = True ) ) locs = [] if skipTips: verteces = verteces[1: len( verteces ) - 1 ] for i,v in enumerate( verteces ): grp() baseJnt = mn.Node( mc.joint( n = baseName + "%i"%i + '_JNT', p = self.center ) ) jnt = mn.Node( mc.joint( n = baseName + "%i"%i + '_SKN', p = v ) ) mc.joint( baseJnt.name, e=True, zso=True, oj='xyz' ) #create locator for AIM loc = mn.Node( mc.spaceLocator( n = baseName + "%i"%i + '_LOC' )[0] ) loc.a.t.v = v loc.shape.a.localScale.v = [self.SCALE/6.0]*3 loc.parent = locgrp locs.append( loc ) mc.aimConstraint( loc.name, baseJnt.name, weight = 1, mo = True, aimVector = [1,0,0], upVector = [0,1,0], worldUpType = "object", wuo = upVecLoc.name ) grp.parent = baseGrp locgrp.parent = baseGrp return locs
def buildOffsetCloud(self, rootReference=None, raw=False):
'''
Build a point cloud up for each node in nodes
:param nodes: list of objects to be in the cloud
:param rootReference: the node used for the initial pivot location
:param raw: build the cloud but DON'T snap the nodes into place - an optimisation for the PoseLoad sequence
'''
self.posePointRoot=cmds.ls(cmds.spaceLocator(name='posePointCloud'),l=True)[0]
ppcShape=cmds.listRelatives(self.posePointRoot,type='shape')[0]
cmds.setAttr("%s.localScaleZ" % ppcShape, 30)
cmds.setAttr("%s.localScaleX" % ppcShape, 30)
cmds.setAttr("%s.localScaleY" % ppcShape, 30)
if self.settings:
if self.prioritySnapOnly:
self.settings.searchPattern=self.settings.filterPriority
self.inputNodes=r9Core.FilterNode(self.inputNodes, self.settings).ProcessFilter()
if self.inputNodes:
self.inputNodes.reverse() # for the snapping operations
if self.mayaUpAxis=='y':
cmds.setAttr('%s.rotateOrder' % self.posePointRoot, 2)
if rootReference: # and not mesh:
r9Anim.AnimFunctions.snap([rootReference,self.posePointRoot])
for node in self.inputNodes:
pnt=cmds.spaceLocator(name='pp_%s' % r9Core.nodeNameStrip(node))[0]
if not raw:
r9Anim.AnimFunctions.snap([node,pnt])
cmds.parent(pnt,self.posePointRoot)
self.posePointCloudNodes.append((pnt,node))
cmds.select(self.posePointRoot)
if self.mesh:
self.shapeSwapMesh()
return self.posePointCloudNodes
def joint(side, lowerJoint, upperJoint, useSphere=0, sharedUpper=0, sharedLower=0, show=1, heightScale=1):
name = lowerJoint + "_" + upperJoint
upperName = "SKEL_"
if sharedUpper == 0:
upperName += side + "_"
upperName += upperJoint
lowerName = "SKEL_"
if sharedLower == 0:
lowerName += side + "_"
lowerName += lowerJoint
print name
cmds.spaceLocator(name="%s_%s" % (side, name))
cmds.pointConstraint(lowerName, "%s_%s" % (side, name))
cmds.pointConstraint(upperName, "%s_%s" % (side, name))
cmds.aimConstraint(upperName, "%s_%s" % (side, name))
if useSphere:
cmds.sphere(name="%s_%s_C" % (side, name), radius=1)
else:
cmds.cylinder(name="%s_%s_C" % (side, name), radius=0.5, heightRatio=6 * heightScale)
cmds.setAttr("%s_%s_C.doubleSided" % (side, name), 0)
if show == 0:
cmds.setAttr("%s_%s_C.primaryVisibility" % (side, name), 0)
# cmds.rotate( 0, 0, 90, '%s_FOREARM_C' % (side) )
# cmds.makeIdentity( '%s_FOREARM_C' % (side), apply = 1, rotate = 1 )
cmds.select("%s_%s" % (side, name), "%s_%s_C" % (side, name))
cmds.parentConstraint()
return
def locatorOnly(self):
sel = cmds.ls(sl=True)
# Gives error if more than one object is selected.
if len(sel) > 1:
cmds.error("Too many objects selected!")
# Creates and snaps a locator to object.
elif len(sel):
tObj = sel[0]
tLoc = "{0}_tLoc".format(tObj)
LScale = cmds.floatField(LocScale, q=True, v=True)
if cmds.objExists(tLoc):
cmds.delete(tLoc)
cmds.spaceLocator(n="{0}_tLoc".format(tObj))
cmds.scale(LScale, LScale, LScale)
cmds.parentConstraint(tObj, tLoc, mo=False)
cmds.parentConstraint(tObj, tLoc, rm=True)
print LScale
# Gives error if no objects are selected.
else:
cmds.error("No objects selected!")
def build(start=None, end=None, startLoc=None, endLoc=None, name=''):
'''
Creates a distance tool with locators aligned to start and end nodes
Returns a dictionary containing keys for shape, transform, startLoc and endLoc
If locators are supplied for either startLoc or endLoc, they are used in place of creating new ones
'''
if not start or not end:
return common.showDialog('Agument Error. Please supply start and end nodes')
distanceShape = cmds.createNode('distanceDimShape')
distanceTransform = cmds.listRelatives(distanceShape, parent=True, fullPath=True)
if not startLoc:
startLoc = cmds.spaceLocator(name = '%s_distance_start_loc' % name)[0]
common.align(startLoc, start)
if not endLoc:
endLoc = cmds.spaceLocator(name = '%s_distance_end_loc' % name)[0]
common.align(endLoc, end)
cmds.connectAttr('%s.worldPosition[0]' % startLoc, '%s.startPoint' % distanceShape)
cmds.connectAttr('%s.worldPosition[0]' % endLoc, '%s.endPoint' % distanceShape)
distanceTransform = cmds.rename(distanceTransform, name, ignoreShape=True)
distanceShape = cmds.rename(distanceShape, '%sShape' % distanceTransform)
returnDict = {'shape':distanceShape, 'xform':distanceTransform, 'start':startLoc, 'end':endLoc}
return returnDict
def setUp(self):
cmds.file(newFile=True,f=True)
self.sphere = cmds.polySphere()
self.loc1 = cmds.spaceLocator()[0]
self.loc2 = cmds.spaceLocator()[0]
self.joint = cmds.joint()
def createPoleVector(self, prefix=None, distanceScale=2, verbose=False):
print 'Building pole vector...'
if prefix is None:
prefix = self.prefix
# Create Joint Vectors
shoulderIkPos = cmds.xform(self.shoulder, q=True, ws=True, t=True)
shoulderIkVec = OpenMaya.MVector(shoulderIkPos[0], shoulderIkPos[1], shoulderIkPos[2])
elbowIkPos = cmds.xform(self.elbow, q=True, ws=True, t=True)
elbowIkVec = OpenMaya.MVector(elbowIkPos[0], elbowIkPos[1], elbowIkPos[2])
wristIkPos = cmds.xform(self.wrist, q=True, ws=True, t=True)
wristIkVec = OpenMaya.MVector(wristIkPos[0], wristIkPos[1], wristIkPos[2])
# Transpose vectors to correct pole vector translation point
bisectorVec = (shoulderIkVec * 0.5) + (wristIkVec * 0.5)
transposedVec = (elbowIkVec * distanceScale) - (bisectorVec * distanceScale)
ikChainPoleVec = bisectorVec + transposedVec
# Create a pole vector
poleVecCon = self.utils.createBoxControl('%selbowPV' % self.prefix, 0.125)
poleVecPos = [ikChainPoleVec.x, ikChainPoleVec.y, ikChainPoleVec.z]
cmds.xform(poleVecCon, t=poleVecPos)
self.utils.orientSnap(self.elbow, poleVecCon)
# Visualize Vectors and End Points
if verbose:
for vector, letter in zip([bisectorVec, transposedVec, ikChainPoleVec,
shoulderIkVec, elbowIkVec, wristIkVec],
['bisectorVec', 'transposedVec', 'ikChainPoleVec',
'shoulderIk', 'elbowIk', 'wristIk']):
cmds.spaceLocator(n='%sVecLoc' % letter, p=[vector.x, vector.y, vector.z])
cmds.curve(n='%sVecCurve' % letter, degree=1, p=[(0, 0, 0), (vector.x, vector.y, vector.z)])
return poleVecCon
def addJoint(side='L'):
if mc.objExists('%s_armPalm_bnd_0'%side):return
# make joint and locators
Joint = mc.createNode('joint', name='%s_armPalm_bnd_0'%side)
JointGroup = mc.group(Joint, name='%s_armPalm_bndgrp_0'%side)
FKloc = mc.spaceLocator(p=(0,0,0), name='%s_armPalmFK_loc_0'%side)[0]
IKloc = mc.spaceLocator(p=(0,0,0), name='%s_armPalmIK_loc_0'%side)[0]
# constraint
constraintNode = mc.parentConstraint(FKloc, IKloc, JointGroup)
# match position
mc.delete(mc.parentConstraint('%s_armMiddleAIK_jnt_0'%side, FKloc))
mc.delete(mc.parentConstraint('%s_armMiddleAIK_jnt_0'%side, IKloc))
# parent locator
mc.parent(FKloc, '%s_armWristFk_jnt_0'%side)
mc.parent(IKloc, '%s_armMiddleAIK_jnt_0'%side)
# make ikfk switch
reverseNode = [x.split('.')[0] for x in mc.connectionInfo('%s_armFkIk_ctl_0.FKIKBlend'%side, dfs=True) if mc.nodeType(x.split('.')[0])=='reverse'][0]
mc.connectAttr('%s.outputX'%reverseNode, '%s.%sW0'%(constraintNode[0], FKloc))
mc.connectAttr('%s_armFkIk_ctl_0.FKIKBlend'%side, '%s.%sW1'%(constraintNode[0], IKloc))
# add to bind set
mc.sets(Joint, e=True, forceElement='bind_joints_set')
# connect jointLayer
mc.connectAttr('jointLayer.drawInfo', '%s.drawOverride'%Joint)
# parent joint
mc.parent(JointGroup, '%s_armBind_org_0'%side)
def _buildOffsetCloud(self,nodes,rootReference=None,raw=False):
'''
Build a point cloud up for each node in nodes
@param nodes: list of objects to be in the cloud
@param rootReference: the node used for the initial pibot location
@param raw: build the cloud but DON'T snap the nodes into place - an optimisation for the PoseLoad sequence
'''
self.posePointCloudNodes=[]
self.posePointRoot=cmds.ls(cmds.spaceLocator(name='posePointCloud'),l=True)[0]
ppcShape=cmds.listRelatives(self.posePointRoot,type='shape')[0]
cmds.setAttr( "%s.localScaleZ" % ppcShape, 30)
cmds.setAttr( "%s.localScaleX" % ppcShape, 30)
cmds.setAttr( "%s.localScaleY" % ppcShape, 30)
if self.mayaUpAxis=='y':
cmds.setAttr('%s.rotateOrder' % self.posePointRoot, 2)
if rootReference:# and not mesh:
r9Anim.AnimFunctions.snap([rootReference,self.posePointRoot])
for node in nodes:
pnt=cmds.spaceLocator(name='pp_%s' % r9Core.nodeNameStrip(node))[0]
if not raw:
r9Anim.AnimFunctions.snap([node,pnt])
cmds.parent(pnt,self.posePointRoot)
self.posePointCloudNodes.append((pnt,node))
return self.posePointCloudNodes
def test_setupHeirarchy(self):
#--- Setup the scene
startJnt = cmds.joint(n='startJnt',p=(3, 0, 0))
endJnt = cmds.joint(n='endJnt',p=(3, 5, -2))
locs = []
locs.append(cmds.spaceLocator(n='test_topLoc_pos', p=(0, 0, 1))[0])
locs.append(cmds.spaceLocator(n='test_midLoc_pos',p=(1, 2, 2))[0])
locs.append(cmds.spaceLocator(n='test_btmLoc_pos',p=(2, 4, 3))[0])
locGrp = cmds.group(em=True)
fGrp = cmds.group(em=True)
plane = cmds.nurbsPlane( w=1, lengthRatio=5, d=3, u=1, v=6, ax=[0, 0, 1])[0]
for each in locs:
cmds.parent(each,locGrp)
#--- Call method, get results
result = self.rig._setupHeirarchy(name='test', startObj=startJnt, endObj=endJnt,
locGrp=locGrp, plane=plane, follicleGrp=fGrp)
#--- Check Results
expectedTopNode = 'test_rbbnTopNode'
self.assertEqual(result, expectedTopNode)
self.assertTrue(cmds.objExists(expectedTopNode))
self.assertEqual(cmds.listRelatives(fGrp,parent=True)[0], expectedTopNode)
self.assertEqual(cmds.listRelatives(plane,parent=True)[0], expectedTopNode)
self.test.assertConstrained(startJnt,locs[2],type='parent')
self.test.assertConstrained(endJnt,locs[0],type='parent')
def createDistanceNode(**kwargs):
startTransform = kwargs.get('start')
endTransform = kwargs.get('end')
name = kwargs.get('name')
startPos = cmds.xform(startTransform,q = True,ws = True, translation = True)
endPos = cmds.xform(endTransform,q = True,ws = True, translation = True)
group = cmds.group(empty = True, name = '%s_Locator_Group'%name)
startGroup = cmds.group(empty = True, name = '%s_Start_Locator_Group'%name)
endGroup = cmds.group(empty = True, name = '%s_End_Locator_Group'%name)
cmds.parent(startGroup,group)
cmds.parent(endGroup,group)
startLocator = cmds.spaceLocator(name = '%s_Start_Locator'%name)[0]
endLocator = cmds.spaceLocator(name = '%s_End_Locator'%name)[0]
cmds.parent(startLocator,startGroup)
cmds.parent(endLocator,endGroup)
cmds.move(startPos[0],startPos[1],startPos[2],startLocator,ws = True)
cmds.move(endPos[0],endPos[1],endPos[2],endLocator,ws = True)
lengthNode = cmds.createNode('kLengthNode',name = '%s_Length'%name)
cmds.connectAttr('%s.worldMatrix[0]'%startLocator, '%s.startWorldMatrix'%lengthNode)
cmds.connectAttr('%s.parentInverseMatrix[0]'%startLocator, '%s.startParentInverseMatrix'%lengthNode)
cmds.connectAttr('%s.worldMatrix[0]'%endLocator, '%s.endWorldMatrix'%lengthNode)
cmds.connectAttr('%s.parentInverseMatrix[0]'%endLocator, '%s.endParentInverseMatrix'%lengthNode)
return lengthNode
def setupSw(self):
for joint in self._joints:
name = joint.replace(nameLib.prefixNames.jointSuffix, "") + nameLib.prefixNames.locator
# create locators
worldLocator = mc.spaceLocator(name="world_" + name)
localLocator = mc.spaceLocator(name="local_" + name)
# group for locators
rootGroup = utils.makeGroup.MakeGroup(name=name + nameLib.prefixNames.offsetGroup)
mc.parent(worldLocator, rootGroup.groupName)
mc.parent(localLocator, rootGroup.groupName)
# snap locators to posittion
mc.delete(mc.parentConstraint(joint, rootGroup.groupName))
# put them into root group
mc.parent(rootGroup.groupName, self._parent)
# orient constrain from global control
mc.orientConstraint(nameLib.prefixNames.globalControl + nameLib.prefixNames.controlSuffix, worldLocator, maintainOffset=True)
# constraint from parent
parent = mc.listRelatives(joint, parent=True)[0].replace(nameLib.prefixNames.jointSuffix, "")
parentControl = nameLib.prefixNames.fkPrefix + parent + nameLib.prefixNames.controlSuffix
mc.parentConstraint(parentControl, rootGroup.groupName, maintainOffset=True)
# create constraint for cotroller's driven group
drivenGroup = nameLib.prefixNames.fkPrefix + name.replace(nameLib.prefixNames.locator, "") + nameLib.prefixNames.controlSuffix + nameLib.prefixNames.drivenGroup
localWorldConstraint = mc.parentConstraint(worldLocator, drivenGroup)
localWorldConstraint = mc.parentConstraint(localLocator, drivenGroup)
# create connections from controller
weightList = [worldLocator[0] + "W0", localLocator[0] + "W1"]
self.connectSW(localWorldConstraint[0], parentControl, weightList)
def _plotter_avrg(self):
'''plots a locator to a vertice or face per keyframe in a timeline'''
selObj=cmds.ls(sl=1, fl=1)
if len(selObj)>0:
pass
else:
print "Select 1 object"
return
getTopRange=cmds.playbackOptions(q=1, max=1)+1#get framerange of scene to set keys in iteration
getLowRange=cmds.playbackOptions(q=1, min=1)-1#get framerange of scene to set keys in iteration
edgeBucket=[]
getRange=arange(getLowRange,getTopRange, 1 )
getloc=cmds.spaceLocator(n=selObj[0]+"cnstr_lctr")
cmds.normalConstraint(selObj[0], getloc[0])
placeloc=cmds.spaceLocator(n=selObj[0]+"lctr")
for each in getRange:
cmds.currentTime(each)
transform=cmds.xform(selObj, q=1, ws=1, t=1)
posBucketx=self.array_median_find(transform[0::3])
posBuckety=self.array_median_find(transform[1::3])
posBucketz=self.array_median_find(transform[2::3])
cmds.xform(getloc[0], ws=1, t=(posBucketx, posBuckety, posBucketz))
cmds.SetKeyTranslate(getloc[0])
cmds.xform(placeloc[0], ws=1, t=(posBucketx, posBuckety, posBucketz))
cmds.SetKeyTranslate(placeloc[0])
rotate=cmds.xform(getloc[0], q=True, ws=1, ro=True)
cmds.xform(placeloc[0], ws=1, ro=rotate)
cmds.SetKeyRotate(placeloc[0])
cmds.currentTime(each)
def reCenterPivot(obj):
locName = obj + "_loc"
cmds.spaceLocator(n=locName )
cmds.parent( locName, obj )
cmds.setAttr(locName + ".translateX",0)
cmds.setAttr(locName + ".translateY",0)
cmds.setAttr(locName + ".translateZ",0)
cmds.setAttr(locName + ".rotateX",0)
cmds.setAttr(locName + ".rotateY",0)
cmds.setAttr(locName + ".rotateZ",0)
cmds.Unparent(locName)
pConst = cmds.parentConstraint(obj,locName,mo=True,w=1)
cmds.bakeResults(locName,sm=True, t=(0,44),at=["tx","ty","tz","rx","ry","rz"])
cmds.delete(pConst)
newObj = cmds.duplicate(obj,n=obj+"_new")
cmds.xform(newObj[0],cp=True)
nConst = cmds.parentConstraint(locName,newObj, mo=True,w=1)
cmds.bakeResults(newObj,sm=True, t=(0,44),at=["tx","ty","tz","rx","ry","rz"])
cmds.delete(nConst)
cmds.delete(locName)
def createCurveFromMesh( meshName, centerIndices, startIndex, endIndices, numSample=20 ):
bb = om.MBoundingBox()
for i in centerIndices:
point = om.MPoint( *cmds.xform( meshName+'.vtx[%d]' % i, q=1, ws=1, t=1 ) )
bb.expand( point )
centerPoint = bb.center()
bb = om.MBoundingBox()
for i in endIndices:
point = om.MPoint( *cmds.xform( meshName+'.vtx[%d]' % i, q=1, ws=1, t=1 ) )
bb.expand( point )
endPoint = bb.center()
startPoint = om.MPoint( *cmds.xform( meshName+'.vtx[%d]' % startIndex, q=1, ws=1, t=1 ) )
aimVector = om.MVector( endPoint ) - om.MVector( startPoint )
eachPoints = []
multRate = 1.0/( numSample-1 )
for i in range( numSample ):
eachPoint = aimVector * (multRate*i) + om.MVector( centerPoint )
eachPoints.append( om.MPoint( eachPoint ) )
fnMesh = getMFnMesh( meshName )
mtx = fnMesh.dagPath().inclusiveMatrix()
mtxInv = mtx.inverse()
intersector = om.MMeshIntersector()
intersector.create( fnMesh.object() )
pointOnMesh = om.MPointOnMesh()
for point in eachPoints:
intersector.getClosestPoint( point*mtxInv, pointOnMesh )
closePoint = om.MPoint( pointOnMesh.getPoint() )*mtx
cmds.spaceLocator( p=[closePoint.x, closePoint.y, closePoint.z] )
def addOffsetRig():
#===============================================================================
# SETUP LOCATORS FOR ALIGN AND AIM
#===============================================================================
# add offsetAimLocs to blockAimCrv
globalGrp = 'CT_teethOffset_mod_0'
mc.group(n=globalGrp, em=True)
name = 'CT_teethOffset'
targetCrv = 'CT_teethBlockAim_crv_0'
locs=[]
for locId in range(12):
loc = mc.spaceLocator(n=name+'_aim_loc_%d'%locId)[0]
mc.setAttr(loc+'.localScale', 0.1,0.1,0.1)
rt.attachToMotionPath(targetCrv, (float(locId)+0.5)/12, loc, True)
locs.append(loc)
mc.group(locs, n='CT_teethOffset_aim_loc_grp', p=globalGrp)
rt.connectVisibilityToggle(locs, globalGrp, 'aimLocs', False)
# add offsetAlignLocs to blockDrvCrv
targetCrv = 'CT_teethBlockDrv_crv_0'
locs=[]
for locId in range(12):
loc = mc.spaceLocator(n=name+'_align_loc_%d'%locId)[0]
mc.setAttr(loc+'.localScale', 0.1,0.1,0.1)
rt.alignOnMotionPath(targetCrv, (float(locId)+0.5)/12, loc, name+'_aim_loc_%d.matrix'%locId, True, ua=1, inverseUp=True)
locs.append(loc)
mc.group(locs, n='CT_teethOffset_align_loc_grp', p=globalGrp)
rt.connectVisibilityToggle(locs, globalGrp, 'alignLocs', False)
def cameraFrustum_build(cam_shape):
#make sure a camera is loaded
if cam_shape==0:
cmds.error('no camera loaded...select a camera and load')
else:
#create frustum only if one doesnt already exist
selCamXform = cmds.listRelatives(cam_shape[0], p=1)
prefix = 'frust_'
frustumGrpName = prefix + 'camera_frustum_all_grp'
if cmds.objExists(frustumGrpName)==0:
#create main grp
frustumMainGrp = cmds.group(em=1, n=frustumGrpName);
cmds.setAttr(frustumGrpName + '.tx', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.ty', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.tz', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.rx', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.ry', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.rz', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.sx', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.sy', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.sz', lock=1, keyable=0, channelBox=0)
cmds.setAttr(frustumGrpName + '.v', lock=1, keyable=0, channelBox=0)
#create frustum geo
frustumGeo = cmds.polyCube(w=2, h=2, d=2, n=prefix + 'camera_frustum_geo')
cmds.delete(frustumGeo[0], constructionHistory=True)
cmds.parent(frustumGeo[0], frustumMainGrp)
#load plugin "nearestPointOnMesh.mll" if needed and connect
plugin = cmds.pluginInfo('nearestPointOnMesh.mll', q=1, l=1)
if plugin==0:
cmds.loadPlugin('nearestPointOnMesh.mll')
nearNodeName = prefix + 'npomNode'
npomNode = cmds.createNode('nearestPointOnMesh', n=nearNodeName)
cmds.connectAttr(frustumGeo[0] + '.worldMesh', npomNode + '.inMesh')
#create clusters
cmds.select(frustumGeo[0] + '.vtx[4:7]', r=1)
nearCluster = cmds.cluster(n=prefix + 'camera_nearFrustum_cluster')
cmds.select(frustumGeo[0] + '.vtx[0:3]', r=1)
farCluster = cmds.cluster(n=prefix + 'camera_farFrustum_cluster')
#create near/far/camera locs
cameraLoc = cmds.spaceLocator(p=(0, 0, 0), n=prefix + 'camera_loc')
cmds.parent(cameraLoc[0], frustumMainGrp)
nearLoc = cmds.spaceLocator(p=(0, 0, 0), n=prefix + 'camera_nearFrustum_loc')
cmds.move(0, 0, -1)
farLoc = cmds.spaceLocator(p=(0, 0, 0), n=prefix + 'camera_farFrustum_loc')
cmds.move(0, 0, 1)
#parent clusters under loc -- parent locs under camera loc
cmds.parent(nearCluster[1], nearLoc[0])
cmds.parent(farCluster[1], farLoc[0])
cmds.parent(nearLoc[0], cameraLoc[0])
cmds.parent(farLoc[0], cameraLoc[0])
#constrain camera loc to camera
cmds.parentConstraint(selCamXform, cameraLoc, weight=1)
return frustumGeo[0]
def _create_pivots_setup(self):
# Transforms
top_grp = cmds.createNode("transform", name=name.create_name(self.position, "%sPivots" % self.description, 0, "grp"))
tip_grp = cmds.createNode("transform", name=name.create_name(self.position, "%sTipPivots" % self.description, 0, "grp"))
toe_grp = cmds.createNode("transform", name=name.create_name(self.position, "%sToePivots" % self.description, 0, "grp"))
ball_grp = cmds.createNode("transform", name=name.create_name(self.position, "%sBallPivots" % self.description, 0, "grp"))
xform.match_translates(tip_grp, self.joint_detail['tip'])
xform.match_translates(ball_grp, self.joint_detail['ball'])
xform.match_translates(toe_grp, self.joint_detail['ball'])
self.pivot_detail['heel'] = cmds.spaceLocator(name=name.create_name(self.position, self.description, 0, "heelNull"))[0]
ball_loc = cmds.spaceLocator(name=name.create_name(self.position, self.description, 0, "ballNull"))[0]
tip_loc = cmds.spaceLocator(name=name.create_name(self.position, self.description, 0, "tipNull"))[0]
self.pivot_detail['toe'] = toe_grp
self.pivot_detail['tip'] = tip_grp
self.pivot_detail['ball'] = ball_grp
self.pivot_detail['bank_in'] = cmds.spaceLocator(name=name.create_name(self.position, self.description, 0, "bankInNull"))[0]
self.pivot_detail['bank_out'] = cmds.spaceLocator(name=name.create_name(self.position, self.description, 0, "bankOutNull"))[0]
for key, loc in self.pivot_detail.items():
cmds.setAttr("%s.overrideEnabled" % loc, True)
cmds.setAttr("%s.overrideColor" % loc, 1)
cmds.connectAttr("%s.helpers" % self.settings_node, "%s.displayHandle" % loc)
cmds.connectAttr("%s.helpers" % self.settings_node, "%s.visibility" % loc)
# Load in positions if exist
if self.part_file:
log.debug("Data file found! Loading...")
key = os.path.splitext(os.path.basename(self.part_file))[0]
data = PartFileHandler(key).read()
for key, vector in data.items():
cmds.setAttr("%s.translate" % key, *vector, type="float3")
else:
log.warning("No data file found, please create before continuing.")
return
# Parent detail
cmds.parent(self.ik_detail['ball'], ball_loc)
cmds.parent(self.ik_detail['tip'], tip_loc)
cmds.parent(ball_loc, ball_grp)
cmds.parent(tip_loc, toe_grp)
cmds.parent([toe_grp, ball_grp], tip_grp)
cmds.parent(tip_grp, self.pivot_detail['bank_in'])
cmds.parent(self.pivot_detail['bank_in'], self.pivot_detail['bank_out'])
cmds.parent(self.pivot_detail['bank_out'], self.pivot_detail['heel'])
cmds.parent(self.pivot_detail['heel'], top_grp)
# Collect setups
for key, item in self.pivot_detail.items():
self.setups.append(item)
for key, item in self.ik_detail.items():
self.setups.append(item)
self.setups.append(top_grp)
def bankPivots(self,*args):
#
# First, we have the user place locators where they want
# the pivot points to be:
#
# Used for:
# Heel Pivot
# Bank Inner Medial Bank
# Bank Outer Lateral Bank
#Minimize Main window
mc.window("ms_footRigWin",edit=True,i=True)
#Prompt User
if(mc.window("ms_footRigWin2",exists=True)):
mc.deleteUI("ms_footRigWin2",window=True)
mc.window("ms_footRigWin2",title="Reverse Foot v1.0",rtf=True)
mc.columnLayout()
mc.text(" Place the three locators.\nClick 'Continue' when done.")
if(1):#Shorted to read from GUI
#Store prefix value
prefix = mc.textFieldGrp(self.prefixField,query=True,text=True)
if(0):
#Store prefix value
prefix = self.arguments[0]
#Create locators, center pivots after translation
temp = mc.spaceLocator(p=(0,0,0))
self.heelLoc = prefix + "heelPivot" + temp[0]
mc.rename(temp,self.heelLoc)
mc.move(-1,self.heelLoc,z=True)
temp = mc.spaceLocator(p=(0,0,0))
self.bankInnerLoc = prefix + "bankInner" + temp[0]
mc.rename(temp,self.bankInnerLoc)
mc.move(-1,self.bankInnerLoc,x=True)
temp = mc.spaceLocator(p=(0,0,0))
self.bankOuterLoc = prefix + "bankOuter" + temp[0]
mc.rename(temp,self.bankOuterLoc)
mc.move(1,self.bankOuterLoc,x=True)
if(0):
mc.text(" ")
mc.rowLayout(nc=2,cw=(1,50))
mc.text(" ")
mc.button(label = "Continue",c='mc.deleteUI("ms_footRigWin2",window=True),mc.window("ms_footRigWin",edit=True,i=False)')
mc.setParent("..")
if(1): # shorted to GUI call
mc.text(" ")
mc.rowLayout(nc=2,cw=(1,50))
mc.text(" ")
mc.button(label = "Continue",c=self.createFootCall)
mc.setParent("..")
mc.showWindow("ms_footRigWin2")
def createLocators(self, *args):
numLoc = cmds.intField(self.UIElements['numLocators'], query = True, value = True, w = 80, h = 80, minValue = 1, maxValue = 3, step = 1)
""" Define a default starting position for the locators. """
locPos = ([-5.0, 5.0, 0.0], [0.0, 5.0, 0.0], [5.0, 5.0, 0.0])
for index in range(numLoc):
cmds.spaceLocator(n = 'lytLoc_1', p = locPos[index])
def test():
name = 'test'
startLoc = cmds.spaceLocator( n=name+'_startLoc' )
endLoc = cmds.spaceLocator( n=name+'_endLoc' )
cmds.setAttr( endLoc[0]+'.tx', 5 )
print build( side='lf', name=name, startPos=startLoc, endPos=endLoc, jointCount=6, worldUpVector='z', worldUpObject=startLoc[0], twistReader=endLoc[0] )
def install(self):
controlZroGrp = cmds.listConnections(cmds.listConnections(self.nodes['control']+".controlMetadata")[0] + ".zeroGroup")
if not cmds.objExists(self.nodes['switcher']):
utils_transforms.createZeroGroup(controlZroGrp, name=self.nodes['switcher'])
# translate Spaces
for space in self.translateSpaces:
spaceGrp = space + "_space"
attrName = self.nodes['control']+"_translateSpace"
if cmds.attributeQuery(attrName, n = self.customAttribute, exists=True):
enumName = cmds.addAttr(self.customAttribute +'.'+ attrName, q=True, enumName=True)
enumName = enumName + ":" + space
cmds.addAttr(self.customAttribute +'.'+ attrName, e=True, enumName=enumName, k=True)
else:
cmds.addAttr(self.customAttribute, at='enum', enumName = space, ln=attrName, k=len(self.translateSpaces) > 1)
## space locator
spaceLoc = self.nodes['control'] + "_AT_" + space
if not cmds.objExists(spaceLoc):
cmds.spaceLocator(name = spaceLoc)[0]
cmds.setAttr(spaceLoc+".visibility", 0)
cmds.delete(cmds.parentConstraint(self.nodes['switcher'], spaceLoc, maintainOffset=False))
cmds.parent(spaceLoc, spaceGrp , absolute=True)
pCon = cmds.pointConstraint(spaceLoc, self.nodes['switcher'], name = self.nodes['switcher'] + "_pointConst")[0]
transWeights = cmds.pointConstraint(pCon, q=True, wal=True)
pCondition = self.enumCondition(self.customAttribute + '.' + self.nodes['control'] + "_translateSpace", self.nodes['control']+"_AT_"+ space + "_translateSpace_condition")
cmds.connectAttr(pCondition+".outColorR", pCon + "." + transWeights[-1])
# orient Spaces
for space in self.orientSpaces:
spaceGrp = space + "_space"
attrName = self.nodes['control']+"_orientSpace"
if cmds.attributeQuery(attrName, n = self.customAttribute, exists=True):
enumName = cmds.addAttr(self.customAttribute +'.'+ attrName, q=True, enumName=True)
enumName = enumName + ":" + space
cmds.addAttr(self.customAttribute +'.'+ attrName, e=True, enumName=enumName, k=True)
else:
cmds.addAttr(self.customAttribute, at='enum', enumName = space, ln=attrName, k=len(self.orientSpaces) > 1)
## space locator
spaceLoc = self.nodes['control'] + "_AT_" + space
if not cmds.objExists(spaceLoc):
cmds.spaceLocator(name = spaceLoc)[0]
cmds.setAttr(spaceLoc+".visibility", 0)
cmds.delete(cmds.parentConstraint(self.nodes['switcher'], spaceLoc, maintainOffset=False))
cmds.parent(spaceLoc, spaceGrp , absolute=True)
oCon = cmds.orientConstraint(spaceLoc, self.nodes['switcher'], name = self.nodes['switcher'] + "_orientConst")[0]
orientWeights = cmds.orientConstraint(oCon, q=True, wal=True)
oCondition = self.enumCondition(self.customAttribute + '.' + self.nodes['control'] + "_orientSpace", self.nodes['control']+"_AT_"+space + "_orientSpace_condition")
cmds.connectAttr(oCondition+".outColorR", oCon + "." + orientWeights[-1])
return
def createStretchyIk(self, footControl, ikHandleName, pvName, suffix,
*args):
rootPos = cmds.xform(self.jnt_info['ikJnts'][0],
q=True,
t=True,
ws=True)
midPos = cmds.xform(self.jnt_info['ikJnts'][1],
q=True,
t=True,
ws=True)
endPos = cmds.xform(self.jnt_info['ikJnts'][2],
q=True,
t=True,
ws=True)
# Create the ik solver
cmds.ikHandle(n=ikHandleName,
sj=self.jnt_info['ikJnts'][0],
ee=self.jnt_info['ikJnts'][2],
sol="ikRPsolver")
# Stretch ----------------------------------------------------------
#Start by creating all of the nodes we will need for the stretch.
adlStretch = cmds.shadingNode("addDoubleLinear",
asUtility=True,
n='adlNode_RStretch_' + suffix)
clmpStretch = cmds.shadingNode("clamp",
asUtility=True,
n='clampNode_Stretch_' + suffix)
mdLStretch = cmds.shadingNode("multiplyDivide",
asUtility=True,
n='mdNode_RStretch_' + suffix)
mdKStretch = cmds.shadingNode("multiplyDivide",
asUtility=True,
n='mdNode_MStretch_' + suffix)
mdAStretch = cmds.shadingNode("multiplyDivide",
asUtility=True,
n='mdNode_EStretch_' + suffix)
# NOTE: DisDim nodes are wacky. Can I use something else?
cmds.select(d=True)
disDim = cmds.distanceDimension(sp=(rootPos), ep=(endPos))
cmds.rename('distanceDimension1', 'disDimNode_Stretch_' + suffix)
cmds.rename('locator1', 'lctrDis_Root_' + suffix)
cmds.rename('locator2', 'lctrDis_End_' + suffix)
# TODO: Need to save these for later
# cmds.parent('lctrDis_hip', 'jnt_pelvis')
cmds.parent('lctrDis_End_' + suffix, footControl[1])
# Determine the length of the joint chain in default position
rootLen = cmds.getAttr(self.jnt_info['ikJnts'][1] + '.tx')
endLen = cmds.getAttr(self.jnt_info['ikJnts'][2] + '.tx')
chainLen = (rootLen + endLen)
cmds.setAttr(adlStretch + '.input2', chainLen)
cmds.setAttr(mdLStretch + '.input2X', chainLen)
cmds.setAttr(mdKStretch + '.input2X', rootLen)
cmds.setAttr(mdAStretch + '.input2X', endLen)
# The clamp node lets us control the amount of stretch.
cmds.connectAttr(footControl[1] + '.stretch', adlStretch + '.input1')
cmds.connectAttr(adlStretch + '.output', clmpStretch + '.maxR')
cmds.setAttr(clmpStretch + '.minR', chainLen)
cmds.setAttr(mdLStretch + '.operation', 2)
# Connect the distance dimension so we always know the current length of the leg.
cmds.connectAttr('disDimNode_Stretch_' + suffix + '.distance',
clmpStretch + '.inputR')
#Now we feed the total value into a multiply divide so we can distribute the value to our joints.
cmds.connectAttr(clmpStretch + '.outputR', mdLStretch + '.input1X')
cmds.connectAttr(mdLStretch + '.outputX', mdKStretch + '.input1X')
cmds.connectAttr(mdLStretch + '.outputX', mdAStretch + '.input1X')
#Finally, we output our new values into the translateX of the knee and ankle joints.
cmds.connectAttr(mdKStretch + '.outputX',
self.jnt_info['ikJnts'][1] + '.tx')
cmds.connectAttr(mdAStretch + '.outputX',
self.jnt_info['ikJnts'][2] + '.tx')
# Create a pv ----------------------------------------------
cmds.spaceLocator(n=pvName)
cmds.xform(pvName, t=rootPos, ws=True)
# Pv constrain the ik
cmds.poleVectorConstraint(pvName, ikHandleName, weight=1)
cmds.select(d=True)
#Create a plusMinusAverage utility
#Create a multiplyDivide utility
pmaTwist = cmds.shadingNode("plusMinusAverage",
asUtility=True,
n='pmaNode_twist_' + suffix)
# Set PMA to subtract
cmds.setAttr(pmaTwist + ".operation", 2)
mDivTwst = cmds.shadingNode("multiplyDivide",
asUtility=True,
n='mdNode_twist_' + suffix)
cmds.connectAttr(footControl[1] + '.twist', mDivTwst + '.input1X')
cmds.connectAttr(footControl[1] + '.ry', mDivTwst + '.input1Y')
# TODO: I need a pelvis or a better solution
#cmds.connectAttr('jnt_pelvis.ry', 'mdNode_LegTwist.input1Z')
cmds.setAttr(mDivTwst + '.input2X', -1)
cmds.setAttr(mDivTwst + '.input2Y', -1)
cmds.setAttr(mDivTwst + '.input2Z', -1)
cmds.connectAttr(mDivTwst + '.input1X', pmaTwist + '.input1D[0]')
cmds.connectAttr(mDivTwst + '.input1Y', pmaTwist + '.input1D[1]')
# Calculate twist offset
offset = part_utils.matchTwistAngle(ikHandleName + ".twist",
self.jnt_info['ikJnts'],
self.jnt_info['rigJnts'])
# Make a buffer between the control and the ik twist
cmds.setAttr(footControl[1] + '.twist_offset', offset)
cmds.connectAttr(footControl[1] + '.twist_offset',
pmaTwist + '.input1D[2]')
cmds.connectAttr(pmaTwist + '.output1D', ikHandleName + '.twist')
def R_ik_leg():
# create the Ik arm by duplicating
ik_leg = cmds.duplicate('R_Rig_femur_jnt', rc=True)
cmds.listRelatives(ik_leg, ad=True)
ik_femur = cmds.rename(ik_leg[0], 'R_Ik_femur_jnt')
ik_knee = cmds.rename(ik_leg[1], 'R_Ik_knee_jnt')
ik_ankle = cmds.rename(ik_leg[2], 'R_Ik_ankle_jnt')
ik_ball = cmds.rename(ik_leg[3], 'R_Ik_ball_jnt')
ik_toe = cmds.rename(ik_leg[4], 'R_Ik_toe_jnt')
# create Ik Rig
#create Rotate ikHandle between the femur and ankle
ik_hdl_femur = cmds.ikHandle(n='R_femurAnkle_Ikh',
sj=ik_femur,
ee=ik_ankle,
sol='ikRPsolver',
p=2,
w=1)
#create Single ikHandle between the ankle and ball
ik_hdl_ball = cmds.ikHandle(n='R_ankleBall_Ikh',
sj=ik_ankle,
ee=ik_ball,
sol='ikSCsolver',
p=2,
w=1)
#create Single ikHandle between the ball and toe
ik_hdl_toe = cmds.ikHandle(n='R_ballToe_Ikh',
sj=ik_ball,
ee=ik_toe,
sol='ikSCsolver',
p=2,
w=1)
# find the worldspace ws translate position of the ankle
pos_trans_ankle_ik = cmds.xform(ik_ankle, q=True, t=True, ws=True)
pos_trans_ball_ik = cmds.xform(ik_ball, q=True, t=True, ws=True)
pos_trans_toe_ik = cmds.xform(ik_toe, q=True, t=True, ws=True)
# find the worldspace ws orientation position of the ankle
pos_orient_ankle_ik = cmds.xform(ik_ankle, q=True, ro=True, ws=True)
pos_orient_ball_ik = cmds.xform(ik_ball, q=True, ro=True, ws=True)
pos_orient_toe_ik = cmds.xform(ik_toe, q=True, ro=True, ws=True)
# create the empty group
ik_grp = cmds.group(em=True, n='R_Ik_leg_Grp')
# create the control
ik_foot_ctl = cmds.circle(n='R_Ik_foot_Ctl',
nr=(0, 0, 1),
c=(0, 0, 0),
r=1.0)
cmds.xform(ik_foot_ctl, ro=(90, 0, 0), ws=True)
# create the offset control
ik_footOffset_ctl = cmds.circle(n='R_Ik_footOffset_Ctl',
nr=(0, 0, 1),
c=(0, 0, 0),
r=1.25)
cmds.xform(ik_footOffset_ctl, ro=(90, 0, 0), ws=True)
# orient the group to the ankle
cmds.xform(ik_grp, ro=(-90, -90, -90), ws=True)
# parent offset control to control
cmds.parent('R_Ik_footOffset_Ctl', 'R_Ik_foot_Ctl')
# parent the control to the group
cmds.parent('R_Ik_foot_Ctl', 'R_Ik_leg_Grp')
# freeze ik ctl
cmds.makeIdentity(ik_foot_ctl, r=True, a=True)
# remove history
cmds.delete(ik_foot_ctl, constructionHistory=True)
# move the group to the wrist
cmds.xform(ik_grp, t=pos_trans_ankle_ik, ws=True)
#create groups for the ikhandles
peel_heel_grp = cmds.group(em=True, n="R_peelheel_Grp")
toe_tap_grp = cmds.group(em=True, n="R_toeTap_Grp")
toe_tap_footRoll_grp = cmds.group(em=True, n="R_toeTap_footRoll_ball_Grp")
stand_tip_grp = cmds.group(em=True, n="R_standTip_Grp")
stand_tip_footRoll_grp = cmds.group(em=True,
n="R_standTip_footRoll_Toe_Grp")
heel_pivot_grp = cmds.group(em=True, n="R_heelPivot_Grp")
heel_pivot_footRoll_grp = cmds.group(em=True,
n="R_heel_pivot_footRoll_Grp")
peel_heel_footRoll_grp = cmds.group(em=True, n="R_peel_heel_footRoll_Grp")
twist_heel_grp = cmds.group(em=True, n="R_twistHeel_Grp")
twist_ball_grp = cmds.group(em=True, n="R_twistBall_Grp")
twist_toe_grp = cmds.group(em=True, n="R_twistToe_Grp")
left_bank_grp = cmds.group(em=True, n="R_leftBank_Grp")
right_bank_grp = cmds.group(em=True, n="R_rightBank_Grp")
foot_attr_grp = cmds.group(em=True, n="R_footAttr_Grp")
gimbal_grp = cmds.group(em=True, n="R_foot_gimbal_Grp")
#place the groups
cmds.xform(peel_heel_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(toe_tap_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(stand_tip_grp, t=pos_trans_toe_ik, ws=True)
cmds.xform(heel_pivot_grp, t=pos_trans_ankle_ik, ws=True)
cmds.xform(heel_pivot_footRoll_grp, t=pos_trans_ankle_ik, ws=True)
cmds.xform(toe_tap_footRoll_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(stand_tip_footRoll_grp, t=pos_trans_toe_ik, ws=True)
cmds.xform(heel_pivot_footRoll_grp, t=pos_trans_ankle_ik, ws=True)
cmds.xform(twist_heel_grp, t=pos_trans_ankle_ik, ws=True)
cmds.xform(twist_ball_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(twist_toe_grp, t=pos_trans_toe_ik, ws=True)
cmds.xform(left_bank_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(right_bank_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(foot_attr_grp, t=pos_trans_ball_ik, ws=True)
cmds.xform(gimbal_grp, t=pos_trans_ankle_ik, ws=True)
# parent the groups together to make the correct movement
cmds.parent("R_peelheel_Grp", "R_toeTap_footRoll_ball_Grp")
cmds.parent("R_toeTap_footRoll_ball_Grp", "R_peel_heel_footRoll_Grp")
cmds.parent("R_peel_heel_footRoll_Grp", "R_standTip_Grp")
cmds.parent("R_toeTap_Grp", "R_standTip_Grp")
cmds.parent("R_standTip_Grp", "R_standTip_footRoll_Toe_Grp")
cmds.parent("R_standTip_footRoll_Toe_Grp", "R_heelPivot_Grp")
cmds.parent("R_heelPivot_Grp", "R_heel_pivot_footRoll_Grp")
cmds.parent("R_heel_pivot_footRoll_Grp", "R_twistHeel_Grp")
cmds.parent("R_twistHeel_Grp", "R_twistBall_Grp")
cmds.parent("R_twistBall_Grp", "R_twistToe_Grp")
cmds.parent("R_twistToe_Grp", "R_leftBank_Grp")
cmds.parent("R_leftBank_Grp", "R_rightBank_Grp")
cmds.parent("R_rightBank_Grp", "R_footAttr_Grp")
cmds.parent("R_footAttr_Grp", "R_foot_gimbal_Grp")
# parent the ikhandles to the groups
cmds.parent('R_femurAnkle_Ikh', peel_heel_grp)
cmds.parent('R_ankleBall_Ikh', toe_tap_grp)
cmds.parent('R_ballToe_Ikh', toe_tap_grp)
# parent the Ikhandle GROUP to the controller
cmds.parent("R_foot_gimbal_Grp", 'R_Ik_footOffset_Ctl')
#create the attributes for the foot control
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="gimbalX", at="double")
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="gimbalY", at="double")
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="gimbalZ", at="double")
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
readable=False,
ln="seperator1",
nn="__",
min=0,
max=0,
en="__________",
at="enum")
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="PvControl",
min=0,
max=1,
en="off:on",
at="enum")
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="legTwist", at="float")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="offsetVis",
min=0,
max=1,
en="off:on",
at="enum")
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
readable=False,
ln="seperator2",
nn="__",
min=0,
max=0,
en="__________",
at="enum")
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="footFollow",
min=0,
max=3,
en="Fk ctl:hip:cog:world",
at="enum")
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
readable=False,
ln="seperator3",
nn="__",
min=0,
max=0,
en="__________",
at="enum")
#
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="footRoll", at="float")
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="toeBreak", at="float")
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="toeStraight", at="double")
cmds.setAttr('R_Ik_foot_Ctl.toeBreak', 20)
cmds.setAttr('R_Ik_foot_Ctl.toeStraight', 70)
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
readable=False,
ln="seperator4",
nn="__",
min=0,
max=0,
en="__________",
at="enum")
#
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="heelUp",
min=-10,
max=10,
at="float")
cmds.addAttr('R_Ik_foot_Ctl', keyable=True, ln="peelHeel", at="double")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="standTip",
min=0,
max=10,
at="float")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="toeTap",
min=-10,
max=10,
at="float")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="twistHeel",
min=-10,
max=10,
at="float")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="twistBall",
min=-10,
max=10,
at="float")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="twistToes",
min=-10,
max=10,
at="float")
cmds.addAttr('R_Ik_foot_Ctl',
keyable=True,
ln="footBank",
min=-10,
max=10,
at="float")
#
# getting controller to control the orient of the wrist
cmds.orientConstraint('R_Ik_footOffset_Ctl', 'R_Ik_ankle_jnt', mo=True)
#Create Pole vec
# create a locator as a poleVector
pv_loc = cmds.spaceLocator(n='R_poleVec_Loc')
# create a group as the group for a poleVector
pv_grp = cmds.group(em=True, n='R_poleVec_Grp')
# parent locator to the group
cmds.parent('R_poleVec_Loc', 'R_poleVec_Grp')
# place the group between the shoulder and the wrist
cmds.pointConstraint(ik_femur, ik_ankle, pv_grp)
# aim the locator twoards the elbow
cmds.aimConstraint(ik_knee, pv_grp, aim=(1, 0, 0), u=(0, 1, 0))
# delete the constraints
cmds.delete('R_poleVec_Grp_pointConstraint1')
cmds.delete('R_poleVec_Grp_aimConstraint1')
# place the locater out from the elbow using the X axis trans
cmds.move(5, pv_loc, x=True, os=True, ws=False)
#create controller for the polevector
ik_knee_ctl = cmds.circle(n='R_Ik_knee_Ctl',
nr=(0, 0, 1),
c=(0, 0, 0),
r=0.5)
# rotate the controller
#cmds.rotate(0, '90deg', 0, ik_knee_ctl)
# move parent the controller to the locator locatieon
cmds.pointConstraint(pv_loc, ik_knee_ctl)
# delete pointConstraint from controller
cmds.delete('R_Ik_knee_Ctl_pointConstraint1')
# parent controller to grp
cmds.parent('R_Ik_knee_Ctl', 'R_poleVec_Grp')
# freeze orientation on controller
cmds.makeIdentity(ik_knee_ctl, a=True)
# delete history on ctl
cmds.delete(ik_knee_ctl, ch=True)
# parent poleVEc to controller
cmds.parent('R_poleVec_Loc', 'R_Ik_knee_Ctl')
# connect the polevector constraint to the ikhandle and the locator
cmds.poleVectorConstraint(pv_loc, 'R_femurAnkle_Ikh')
# hide locator
cmds.hide(pv_loc)
# hide scale from ik control
cmds.setAttr('R_Ik_foot_Ctl.scaleX', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_foot_Ctl.scaleY', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_foot_Ctl.scaleZ', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_foot_Ctl.v', keyable=False, ch=False, lock=True)
# hide scale from ik offset control
cmds.setAttr('R_Ik_footOffset_Ctl.scaleX',
keyable=False,
ch=False,
lock=True)
cmds.setAttr('R_Ik_footOffset_Ctl.scaleY',
keyable=False,
ch=False,
lock=True)
cmds.setAttr('R_Ik_footOffset_Ctl.scaleZ',
keyable=False,
ch=False,
lock=True)
cmds.setAttr('R_Ik_footOffset_Ctl.v', keyable=False, ch=False, lock=True)
#hide rotate and scale from knee ik control
cmds.setAttr('R_Ik_knee_Ctl.rotateX', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_knee_Ctl.rotateY', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_knee_Ctl.rotateZ', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_knee_Ctl.scaleX', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_knee_Ctl.scaleY', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_knee_Ctl.scaleZ', keyable=False, ch=False, lock=True)
cmds.setAttr('R_Ik_knee_Ctl.v', keyable=False, ch=False, lock=True)
#delete history on the ik control
cmds.delete('R_Ik_foot_Ctl', ch=True)
# place them in the group hierarchy if there is one
placeInGroup = cmds.ls('main_Grp')
# if it is there parent them respectly
if placeInGroup:
cmds.parent('R_Ik_leg_Grp', 'R_Ik_Grp')
cmds.parent('R_poleVec_Grp', 'R_Ik_Grp')
else:
return
def setupRGFoot(self, suffix, footControl, ikJntPos, ikHandleName, *args):
print 'In Setup Foot'
newFootGrps = []
# Create utility nodes
conBRoll = cmds.shadingNode("condition",
asUtility=True,
n='conNode_ballRoll_' + suffix)
conNBRoll = cmds.shadingNode("condition",
asUtility=True,
n='conNode_negBallRoll_' + suffix)
conTRoll = cmds.shadingNode("condition",
asUtility=True,
n='conNode_toeRoll_' + suffix)
pmaBRoll = cmds.shadingNode("plusMinusAverage",
asUtility=True,
n='pmaNode_ballRoll_' + suffix)
pmaTRoll = cmds.shadingNode("plusMinusAverage",
asUtility=True,
n='pmaNode_toeRoll_' + suffix)
conHRoll = cmds.shadingNode("condition",
asUtility=True,
n='conNode_heelRoll_' + suffix)
cmds.setAttr(pmaTRoll + '.operation', 2)
cmds.setAttr(conTRoll + '.operation', 2)
cmds.setAttr(conTRoll + '.colorIfFalseR', 0)
cmds.setAttr(conTRoll + '.colorIfFalseG', 0)
cmds.setAttr(conTRoll + '.colorIfFalseB', 0)
cmds.setAttr(conHRoll + '.operation', 4)
cmds.setAttr(conHRoll + '.colorIfFalseB', 0)
cmds.setAttr(conHRoll + '.colorIfFalseR', 0)
cmds.setAttr(conHRoll + '.colorIfFalseG', 0)
cmds.setAttr(pmaBRoll + '.operation', 2)
cmds.setAttr(conNBRoll + '.operation', 3)
cmds.setAttr(conBRoll + '.operation', 3)
# Make Ik Handles
ikBall = cmds.ikHandle(n="ikh_ball_" + suffix,
sj=self.jnt_info['ikJnts'][2],
ee=self.jnt_info['ikJnts'][3],
sol="ikSCsolver")
print self.jnt_info['ikJnts']
ikToe = cmds.ikHandle(n="ikh_toe_" + suffix,
sj=self.jnt_info['ikJnts'][3],
ee=self.jnt_info['ikJnts'][4],
sol="ikSCsolver")
# Create the foot groups
footGrps = ('grp_footPivot', 'grp_heel', 'grp_toe', 'grp_ball',
'grp_flap')
for grp in footGrps:
grpName = (grp + '_' + suffix)
grp = cmds.group(n=grpName, empty=True)
cmds.xform(grp, t=ikJntPos[3])
if grp == footGrps[1] + '_' + suffix:
cmds.xform(grp, t=ikJntPos[2])
if grp == footGrps[2] + '_' + suffix:
cmds.xform(grp, t=ikJntPos[4])
for i in range(len(footGrps)):
newFootGrps.append(footGrps[i])
cmds.select(d=True)
if i == 0:
cmds.parent(footGrps[i] + '_' + suffix, footControl)
else:
cmds.parent(footGrps[i] + '_' + suffix,
footGrps[i - 1] + '_' + suffix)
if i == 4:
cmds.parent(footGrps[i] + '_' + suffix,
footGrps[2] + '_' + suffix)
cmds.parent(ikBall[0], footGrps[3] + '_' + suffix)
cmds.parent(ikToe[0], footGrps[4] + '_' + suffix)
cmds.parent(ikHandleName, footGrps[3] + '_' + suffix)
cmds.select(d=True)
# Setup toe ---------------------------------------------------
footRoll = footControl + '.foot_roll'
rollBreak = footControl + '.roll_break'
cmds.connectAttr(footRoll, conTRoll + '.firstTerm')
cmds.connectAttr(footRoll, conTRoll + '.colorIfTrueR')
cmds.connectAttr(rollBreak, conTRoll + '.secondTerm')
cmds.connectAttr(rollBreak, conTRoll + '.colorIfFalseR')
cmds.connectAttr(rollBreak, pmaTRoll + '.input1D[1]')
cmds.connectAttr(conTRoll + '.outColorR', pmaTRoll + '.input1D[0]')
cmds.connectAttr(pmaTRoll + '.output1D', 'grp_toe_' + suffix + '.rx')
# Setup the Heel -----------------------------------------------------
cmds.connectAttr(footRoll, conHRoll + '.firstTerm')
cmds.connectAttr(footRoll, conHRoll + '.colorIfTrueR')
cmds.connectAttr(conHRoll + '.outColorR', 'grp_heel_' + suffix + '.rx')
# Setup Ball ----------------------------------------------------------
cmds.connectAttr(footRoll, conBRoll + '.firstTerm')
cmds.connectAttr(footRoll, conBRoll + '.colorIfTrueR')
cmds.connectAttr(rollBreak, conNBRoll + '.secondTerm')
cmds.connectAttr(rollBreak, conNBRoll + '.colorIfTrueR')
cmds.connectAttr(conNBRoll + '.outColorR', pmaBRoll + '.input1D[0]')
cmds.connectAttr('grp_toe_' + suffix + '.rx', pmaBRoll + '.input1D[1]')
cmds.connectAttr(pmaBRoll + '.output1D', 'grp_ball_' + suffix + '.rx')
cmds.connectAttr(conBRoll + '.outColorR', conNBRoll + '.firstTerm')
cmds.connectAttr(conBRoll + '.outColorR', conNBRoll + '.colorIfFalseR')
# Toe Flap
cmds.connectAttr(footControl + '.toe_flap',
footGrps[4] + '_' + suffix + '.rx')
# Animated Pivot
pivLoc = cmds.spaceLocator(n='lctrTwist_' + suffix)
cmds.parent(pivLoc[0], footControl)
cmds.xform(pivLoc[0], t=ikJntPos[4])
fgTran = cmds.getAttr(footGrps[4] + '_' + suffix + '.translate')
#pmaFTwist = cmds.shadingNode("plusMinusAverage", asUtility=True, n='pmaNode_FootTwist_' + suffix))
#cmds.setAttr(pmaFTwist+'.input1')
#cmds.connectAttr(pivLoc[0]+'.translate', footGrps[0]+ '_' + suffix + '.rotatePivot')
cmds.connectAttr(footControl + '.pivot_posX', pivLoc[0] + '.tx')
cmds.connectAttr(footControl + '.pivot_posZ', pivLoc[0] + '.tz')
cmds.connectAttr(footControl + '.foot_twist',
footGrps[0] + '_' + suffix + '.ry')
cmds.connectAttr(footControl + '.foot_bank',
footGrps[0] + '_' + suffix + '.rz')
def bakeNonskins(objects, *args):
# bake objects to world space.
# create a locator constrained to each object, bake the constraints, then unparent objects, constrain to locators, and bake.
print 'RUNNING bakeNonskins'
locators = []
constraints = []
for x in range(0, len(objects)):
loc = cmds.spaceLocator()[0]
locators.append(loc)
pc = cmds.parentConstraint(objects[x], loc)
sc = cmds.scaleConstraint(objects[x], loc)
constraints.append(pc)
constraints.append(sc)
# bake locators.
mel.eval('setNamedPanelLayout "Single Perspective View"')
perspPane = cmds.getPanel(vis=1)
cmds.scriptedPanel('graphEditor1', e=1, rp=perspPane[0])
start = cmds.playbackOptions(q=1, min=1)
end = cmds.playbackOptions(q=1, max=1)
cmds.select(locators)
cmds.bakeResults(simulation=1, cp=0, s=0, sb=1.0, t=(start, end))
# now, parent objects to world space, then constrain them to the locators in order.
# need to delete all channel information first.
# in order to run CBdeleteConnection, we need to source a particular MEL.
mel.eval('source channelBoxCommand.mel;')
for c in constraints:
cmds.delete(c)
chans = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz', 'v']
objectsWorldSpace = []
for x in range(0, len(objects)):
for ch in chans:
melstr = 'CBdeleteConnection "' + objects[x] + '.' + ch + '";'
mel.eval(melstr)
# unlock channel, in case it's locked
cmds.setAttr(objects[x] + '.' + ch, lock=0)
# try to parent to world space. if this fails, it's already in world space.
try:
renamed = cmds.parent(objects[x], w=1)[0]
objectsWorldSpace.append(renamed)
except RuntimeError:
objectsWorldSpace.append(objects[x])
# now apply constraints from the locator with the same index x.
cmds.parentConstraint(locators[x], objectsWorldSpace[x])
cmds.scaleConstraint(locators[x], objectsWorldSpace[x])
# now bake out the constraints on objectsWorldSpace.
cmds.select(objectsWorldSpace)
cmds.bakeResults(simulation=1, cp=0, s=0, sb=1.0, t=(start, end))
for l in locators:
cmds.delete(l)
# now export objectsWorldSpace as FBX.
mel.eval('FBXResetExport;')
mel.eval('FBXExportCacheFile -v false;')
mel.eval('FBXExportCameras -v true;')
cacheDir = os.path.join(cmds.workspace(q=1, fn=1), 'data', 'FBX',
os.path.splitext(cmds.file(q=1, sn=1, shn=1))[0],
'keyframes').replace('\\', '/')
if not os.path.exists(cacheDir): os.makedirs(cacheDir)
fbxFile = os.path.join(
cacheDir,
os.path.splitext(cmds.file(q=1, sn=1, shn=1))[0] +
'_NONSKINS.fbx').replace('\\', '/')
cmds.select(objectsWorldSpace)
evalStr = 'FBXExport -f "' + fbxFile + '" -s'
mel.eval(evalStr)
print 'Exported non-skins to %s' % (fbxFile)
def create_joints():
# a. To make sure a joint is selected
if cmds.ls(sl=True,type='joint'):
sel=cmds.ls(sl=True)
# a.1 To check if multiple joints are selected
if len(sel)!=1:
cmds.warning('Please select only one joint.')
# a.2 To check whether the selected joint has any child joint
elif not cmds.listRelatives(sel[0],c=True,type='joint'):
cmds.warning('The joint has no child.')
# b. To duplicate the selected shoulder joint, to remove extra joints, and to give proper names;
elif 'shoulder' in sel[0].lower():
# b.1 To duplicate the selected shoulder joint as IK
ikShoulder=cmds.duplicate(sel[0],rc=True,name=sel[0]+'_IK')
for child in cmds.listRelatives(ikShoulder[0],ad=True,type='joint'):
#b.2 To delete forearm and hand joints
if 'forearm' in child.lower():
cmds.delete(child)
elif 'palm' in child.lower():
cmds.delete(child)
elif 'thum' in child.lower():
cmds.delete(child)
#b.3 To properly rename the rest joints
else:
# To remove the last digit added by maya
newName=child[:-1]
# To add IK to the names
cmds.joint(child,e=True,name=newName+'_IK')
#c.1 To duplicate the selected shoulder joint as FK
fkShoulder=cmds.duplicate(sel[0],rc=True,name=sel[0]+'_FK')
for child in cmds.listRelatives(fkShoulder[0],ad=True,type='joint'):
#c.2 To delete forearm and hand joints
if 'forearm' in child.lower():
cmds.delete(child)
elif 'palm' in child.lower():
cmds.delete(child)
elif 'thum' in child.lower():
cmds.delete(child)
#c.3 To properly rename the rest joints properly
else:
newName=child[:-1]
cmds.joint(child,e=True,name=newName+'_FK')
# d. To call the ik generator function and store the returned controls into variables
control_shapes=ik_generator(ikShoulder)
pole_vecCtrl=control_shapes[0]
ik_Ctrl=control_shapes[1]
# e. To set up a locator for IK/FK match, it will be further modified in the fk_generator[] function
fk_locator=cmds.spaceLocator(name=pole_vecCtrl[0].replace('_IK_PoleVec','')+'_FK_PoleVec')
cmds.matchTransform(fk_locator,pole_vecCtrl)
cmds.setAttr(fk_locator[0]+'.v',False)
# f. To call the fk generator function and store the returned controls into variables
fkGroups=fk_generator(fkShoulder,fk_locator)
# g. To generate an IK/FK switch and pass variables returned from other functions
switch_generator(sel,fkShoulder,ikShoulder,fkGroups,pole_vecCtrl,ik_Ctrl)
cmds.select(cl=True)
else:
cmds.warning('Please select a shoulder joint.')
else:
cmds.warning('Please select a joint.')
def getMaxAndMinAxis(objectName, preview=False):
"""
send a object to get the Max and Min X,Y and Z
@param objectName: Name of Object
@type objectName: String
--------------------------------------------
@param preview: to see the preview
@type preview: Bool
--------------------------------------------
@return: 0-maxX, 1-minX, 2-maxY, 3-minY, 4-maxZ, 5-minZ
"""
maxX, maxY, maxZ, minX, minY, minZ = 0, 0, 0, 0, 0, 0
vertexList = cmds.getAttr("%s.vrts" % objectName, multiIndices=True)
i = 0
for i in vertexList:
cmds.select("%s.pnts[%s]" % (objectName, i))
vertexPositionX, vertexPositionY, vertexPositionZ = cmds.xform(
"%s.pnts[%s]" % (objectName, i),
query=True,
translation=True,
worldSpace=True)
if vertexPositionX > maxX or i == 0:
maxX = vertexPositionX
if vertexPositionY > maxY or i == 0:
maxY = vertexPositionY
if vertexPositionZ > maxZ or i == 0:
maxZ = vertexPositionZ
if vertexPositionX < minX or i == 0:
minX = vertexPositionX
if vertexPositionY < minY or i == 0:
minY = vertexPositionY
if vertexPositionZ < minZ or i == 0:
minZ = vertexPositionZ
if preview == True:
cmds.spaceLocator(name="minX", p=(0, 0, 0))
cmds.spaceLocator(name="minY", p=(0, 0, 0))
cmds.spaceLocator(name="minZ", p=(0, 0, 0))
cmds.spaceLocator(name="maxX", p=(0, 0, 0))
cmds.spaceLocator(name="maxY", p=(0, 0, 0))
cmds.spaceLocator(name="maxZ", p=(0, 0, 0))
meshX, meshY, meshZ = cmds.xform(objectName,
query=True,
translation=True,
worldSpace=True)
cmds.move(minX, meshY, meshZ, 'minX')
cmds.move(maxX, meshY, meshZ, 'maxX')
cmds.move(meshX, minY, meshZ, 'minY')
cmds.move(meshX, maxY, meshZ, 'maxY')
cmds.move(meshX, meshY, minZ, 'minZ')
cmds.move(meshX, meshY, maxZ, 'maxZ')
return maxX, minX, maxY, minY, maxZ, minZ
def createLegs(side):
if side == 1:
if base.objExists('L_Leg_GRP'):
print 'nuttn'
else:
upperLegGRP = base.group(em=True, name='L_Leg_GRP')
base.parent(upperLegGRP, 'Loc_ROOT')
base.move(0.1, 1, 0, upperLegGRP)
upperLeg = base.spaceLocator(n='Loc_L_UpperLeg')
base.scale(0.1, 0.1, 0.1, upperLeg)
base.move(0.15, 1.5, 0, upperLeg)
base.parent(upperLeg, 'L_Leg_GRP')
## lower leg
lowerLeg = base.spaceLocator(n='Loc_L_LowerLeg')
base.scale(0.1, 0.1, 0.1, lowerLeg)
base.move(0.15, 0.75, 0.05, lowerLeg)
base.parent(lowerLeg, 'Loc_L_UpperLeg')
## foot
foot = base.spaceLocator(n='Loc_L_Foot')
base.scale(0.1, 0.1, 0.1, foot)
base.move(0.15, 0.2, 0, foot)
base.parent(foot, 'Loc_L_LowerLeg')
## football
football = base.spaceLocator(n='Loc_L_FootBall')
base.scale(0.1, 0.1, 0.1, football)
base.move(0.15, 0, 0.15, football)
base.parent(football, 'Loc_L_Foot')
## toes
toes = base.spaceLocator(n='Loc_L_Toes')
base.scale(0.1, 0.1, 0.1, toes)
base.move(0.15, 0, 0.3, toes)
base.parent(toes, 'Loc_L_FootBall')
else:
if base.objExists('R_Leg_GRP'):
print 'nuttn'
else:
upperLegGRP = base.group(em=True, name='R_Leg_GRP')
base.parent(upperLegGRP, 'Loc_ROOT')
base.move(-0.1, 1, 0, upperLegGRP)
upperLeg = base.spaceLocator(n='Loc_R_UpperLeg')
base.scale(0.1, 0.1, 0.1, upperLeg)
base.move(-0.15, 1.5, 0, upperLeg)
base.parent(upperLeg, 'R_Leg_GRP')
# lower leg
lowerLeg = base.spaceLocator(n='Loc_R_LowerLeg')
base.scale(0.1, 0.1, 0.1, lowerLeg)
base.move(-0.15, 0.75, 0.05, lowerLeg)
base.parent(lowerLeg, 'Loc_R_UpperLeg')
# foot
foot = base.spaceLocator(n='Loc_R_Foot')
base.scale(0.1, 0.1, 0.1, foot)
base.move(-0.15, 0.2, 0, foot)
base.parent(foot, 'Loc_R_LowerLeg')
## football
football = base.spaceLocator(n='Loc_R_FootBall')
base.scale(0.1, 0.1, 0.1, football)
base.move(-0.15, 0, 0.15, football)
base.parent(football, 'Loc_R_Foot')
## toes
toes = base.spaceLocator(n='Loc_R_Toes')
base.scale(0.1, 0.1, 0.1, toes)
base.move(-0.15, 0, 0.3, toes)
base.parent(toes, 'Loc_R_Foot')
def create_loc(self, pos):
loc = cmds.spaceLocator()
cmds.move(pos.x, pos.y, pos.z, loc)
def Locator(Locator, Offset):
cmds.spaceLocator(n=Locator, p=(0, 0, 0))
cmds.group(n=Offset)
def basic_stretchy_IK(rootJoint,
endJoint,
container=None,
lockMinimumLength=True,
poleVectorObject=None,
scaleCorrectionAttribute=None):
from math import fabs
containedNodes = []
# v024
totalOriginalLength = 0.0
done = False
parent = rootJoint
childJoints = []
while not done:
children = cmds.listRelatives(parent, children=True)
children = cmds.ls(children, type="joint")
if len(children) == 0:
done = True
else:
child = children[0]
childJoints.append(child)
""" This is where we adjust to make this work with meters """
totalOriginalLength += fabs(cmds.getAttr(child + ".translateX"))
parent = child
if child == endJoint:
done = True
# create RP IK on joint chain
ikNodes = cmds.ikHandle(sj=rootJoint,
ee=endJoint,
sol="ikRPsolver",
n=rootJoint + "_ikHandle")
ikNodes[1] = cmds.rename(ikNodes[1], rootJoint + "_ikEffector")
ikEffector = ikNodes[1]
ikHandle = ikNodes[0]
cmds.setAttr(ikHandle + ".visibility", 0)
containedNodes.extend(ikNodes)
# Create pole vector locator
if poleVectorObject == None:
poleVectorObject = cmds.spaceLocator(n=ikHandle +
"_poleVectorLocator")[0]
containedNodes.append(poleVectorObject)
cmds.xform(poleVectorObject,
ws=True,
absolute=True,
translation=cmds.xform(rootJoint,
q=True,
ws=True,
translation=True))
cmds.xform(poleVectorObject,
ws=True,
relative=True,
translation=[0.0, 1.0, 0.0])
cmds.setAttr(poleVectorObject + ".visibility", 0)
poleVectorConstraint = cmds.poleVectorConstraint(poleVectorObject,
ikHandle)[0]
containedNodes.append(poleVectorConstraint)
# Create root and end locators
rootLocator = cmds.spaceLocator(n=rootJoint + "_rootPosLocator")[0]
rootLocator_pointConstraint = cmds.pointConstraint(rootJoint,
rootLocator,
maintainOffset=False,
n=rootLocator +
"_pointConstraint")
endLocator = cmds.spaceLocator(n=endJoint + "_endPosLocator")[0]
cmds.xform(endLocator,
worldSpace=True,
absolute=True,
translation=cmds.xform(ikHandle,
q=True,
worldSpace=True,
translation=True))
ikHandle_pointConstraint = cmds.pointConstraint(endLocator,
ikHandle,
maintainOffset=False,
n=ikHandle +
"_pointConstraint")[0]
containedNodes.extend([
rootLocator, endLocator, rootLocator_pointConstraint,
ikHandle_pointConstraint
])
cmds.setAttr(rootLocator + ".visibility", 0)
cmds.setAttr(endLocator + ".visibility", 0)
#v024
# Grab distance between locators
rootLocatorWithoutNamespace = stripAllNamespaces(rootLocator)[1]
endLocatorWithoutNamespace = stripAllNamespaces(endLocator)[1]
moduleNamespace = stripAllNamespaces(rootJoint)[0]
distNode = cmds.shadingNode("distanceBetween",
asUtility=True,
n=moduleNamespace + ":distBetween_" +
rootLocatorWithoutNamespace + "_" +
endLocatorWithoutNamespace)
containedNodes.append(distNode)
cmds.connectAttr(rootLocator + "Shape.worldPosition[0]",
distNode + ".point1")
cmds.connectAttr(endLocator + "Shape.worldPosition[0]",
distNode + ".point2")
scaleAttr = distNode + ".distance"
#167
if scaleCorrectionAttribute != None:
scaleCorrection = cmds.shadingNode("multiplyDivide",
asUtility=True,
n=ikHandle + "_scaleCorrection")
containedNodes.append(scaleCorrection)
cmds.setAttr(scaleCorrection + ".operation", 2) # divide
cmds.connectAttr(distNode + ".distance", scaleCorrection + ".input1X")
cmds.connectAttr(scaleCorrectionAttribute,
scaleCorrection + ".input2X")
scaleAttr = scaleCorrection + ".outputX"
# Divide distance by total original length = scale factor
scaleFactor = cmds.shadingNode("multiplyDivide",
asUtility=True,
n=ikHandle + "_scaleFactor")
containedNodes.append(scaleFactor)
cmds.setAttr(scaleFactor + ".operation", 2) #Divide
cmds.connectAttr(scaleAttr, scaleFactor + ".input1X")
cmds.setAttr(scaleFactor + ".input2X", totalOriginalLength)
translationDriver = scaleFactor + ".outputX"
if lockMinimumLength:
conditionNode = cmds.shadingNode("condition",
asUtility=True,
n=ikHandle + "_scaleCondition")
containedNodes.append(conditionNode)
cmds.connectAttr(scaleAttr, conditionNode + ".firstTerm")
cmds.setAttr(conditionNode + ".secondTerm", totalOriginalLength)
cmds.setAttr(conditionNode + ".operation", 2) # (>)
cmds.connectAttr(scaleFactor + ".outputX",
conditionNode + ".colorIfTrueR")
cmds.setAttr(conditionNode + ".colorIfFalseR", 1)
translationDriver = conditionNode + ".outColorR"
lockBlend = cmds.shadingNode("blendColors",
asUtility=True,
n=ikHandle + "_lockBlend")
containedNodes.append(lockBlend)
cmds.connectAttr(translationDriver, lockBlend + ".color1R")
cmds.setAttr(lockBlend + ".color2R", 1)
stretchinessAttribute = lockBlend + ".blender"
cmds.setAttr(stretchinessAttribute, 1)
#<167
# Connect joints to stretch calculations
for joint in childJoints:
multNode = cmds.shadingNode("multiplyDivide",
asUtility=True,
n=joint + "_scaleMultiply")
containedNodes.append(multNode)
cmds.setAttr(multNode + ".input1X",
cmds.getAttr(joint + ".translateX"))
cmds.connectAttr(translationDriver, multNode + ".input2X")
cmds.connectAttr(multNode + ".outputX", joint + ".translateX")
if container != None:
# Edit v023
addNodeToContainer(container, containedNodes, ihb=True)
returnDict = {}
returnDict["ikHandle"] = ikHandle
returnDict["ikEffector"] = ikEffector
returnDict["rootLocator"] = rootLocator
returnDict["endLocator"] = endLocator
returnDict["poleVectorObject"] = poleVectorObject
returnDict["ikHandle_pointConstraint"] = ikHandle_pointConstraint
returnDict["rootLocator_pointConstraint"] = rootLocator_pointConstraint
returnDict["stretchinessAttribute"] = stretchinessAttribute
return returnDict
def RP_2segment_stretchy_IK(rootJoint,
hingeJoint,
endJoint,
container=None,
scaleCorrectionAttribute=None):
moduleNamespaceInfo = stripAllNamespaces(rootJoint)
moduleNamespace = ""
if moduleNamespaceInfo != None:
moduleNamespace = moduleNamespaceInfo[0]
rootLocation = cmds.xform(rootJoint, q=True, ws=True, t=True)
elbowLocation = cmds.xform(hingeJoint, q=True, ws=True, t=True)
endLocation = cmds.xform(endJoint, q=True, ws=True, t=True)
ikNodes = cmds.ikHandle(sj=rootJoint,
ee=endJoint,
n=rootJoint + "_ikHandle",
solver="ikRPsolver")
ikNodes[1] = cmds.rename(ikNodes[1], rootJoint + "_ikEffector")
ikEffector = ikNodes[1]
ikHandle = ikNodes[0]
cmds.setAttr(ikHandle + ".visibility", 0)
rootLoc = cmds.spaceLocator(n=rootJoint + "_positionLocator")[0]
cmds.xform(rootLoc,
worldSpace=True,
absolute=True,
translation=rootLocation)
cmds.parent(rootJoint, rootLoc, a=True)
endLoc = cmds.spaceLocator(n=ikHandle + "_positionLocator")[0]
cmds.xform(endLoc, worldSpace=True, absolute=True, translation=endLocation)
cmds.parent(ikHandle, endLoc, a=True)
elbowLoc = cmds.spaceLocator(n=hingeJoint + "_positionLocator")[0]
cmds.xform(elbowLoc,
worldSpace=True,
absolute=True,
translation=elbowLocation)
elbowLocatorConstraint = cmds.poleVectorConstraint(elbowLoc, ikHandle)[0]
# Make it stretchy
# make empty list for appending utility nodes
utilityNodes = []
for locators in ((rootLoc, elbowLoc, hingeJoint), (elbowLoc, endLoc,
endJoint)):
from math import fabs
startLocNamespaceInfo = stripAllNamespaces(locators[0])
startLocWithoutNamespace = ""
if startLocNamespaceInfo != None:
startLocWithoutNamespace = startLocNamespaceInfo[1]
endLocNamespaceInfo = stripAllNamespaces(locators[0])
endLocWithoutNamespace = ""
if endLocNamespaceInfo != None:
endLocWithoutNamespace = endLocNamespaceInfo[1]
startLocShape = locators[0] + "Shape"
endLocShape = locators[1] + "Shape"
distNode = cmds.shadingNode("distanceBetween",
asUtility=True,
name=moduleNamespace + ":distBetween_" +
startLocWithoutNamespace + "_" +
endLocWithoutNamespace)
cmds.connectAttr(startLocShape + ".worldPosition[0]",
distNode + ".point1")
cmds.connectAttr(endLocShape + ".worldPosition[0]",
distNode + ".point2")
utilityNodes.append(distNode)
scaleFactor = cmds.shadingNode("multiplyDivide",
asUtility=True,
n=distNode + "_scaleFactor")
utilityNodes.append(scaleFactor)
cmds.setAttr(scaleFactor + ".operation", 2) # divide
originalLength = cmds.getAttr(locators[2] + ".translateX")
cmds.connectAttr(distNode + ".distance", scaleFactor + ".input1X")
cmds.setAttr(scaleFactor + ".input2X", originalLength)
translationDriver = scaleFactor + ".outputX"
translateX = cmds.shadingNode("multiplyDivide",
asUtility=True,
n=distNode + "_translationValue")
utilityNodes.append(translateX)
cmds.setAttr(translateX + ".input1X", fabs(originalLength))
cmds.connectAttr(translationDriver, translateX + ".input2X")
cmds.connectAttr(translateX + ".outputX", locators[2] + ".translateX")
if container != None:
containedNodes = list(utilityNodes)
containedNodes.extend(ikNodes)
containedNodes.extend([rootLoc, elbowLoc, endLoc])
containedNodes.append(elbowLocatorConstraint)
addNodeToContainer(container, containedNodes, ihb=True)
return (rootLoc, elbowLoc, endLoc, utilityNodes)
from maya import cmds
import FabricEngine.Core
import textwrap
def splice(operator, command, *args, **kwargs):
json.dumps(kwargs)
return cmds.fabricSplice(command, operator, json.dumps(kwargs), *args)
def set_kl(operator, op_name, code):
#splice(operator, "addKLOperator", opName=op_name)
splice(operator, "setKLOperatorCode", code, opName=op_name)
cmds.spaceLocator(name="null")
cmds.move(7.21095660746, 14.9754557972, -0.257095710115)
cmds.spaceLocator(name="null")
cmds.move(-7.21079536001, 14.9612588443, -0.2533093422)
cmds.spaceLocator(name="null")
cmds.move(1.5139886508, 0.913547291364, -0.29962025889)
cmds.spaceLocator(name="null")
cmds.move(-1.5139886508, 0.913547291364, -0.299620258891)
cmds.spaceLocator(name="null")
klCode = textwrap.dedent("""
require Math;
require Characters;
require FABRIK;
require InlineDrawing;
'''
Grouping Tool [oGRP]
Instructions: This will group selected objects twice. Once under a locator and then the locator under a group.
'''
import maya.cmds as mc
selObj = mc.ls(sl=True)
for all in selObj:
grp = mc.group(em=True)
loc = mc.spaceLocator()
mc.setAttr(loc[0] + ".localScaleX", 0.001)
mc.setAttr(loc[0] + ".localScaleY", 0.001)
mc.setAttr(loc[0] + ".localScaleZ", 0.001)
rnm_grp = mc.rename(grp, all + "_grp")
rnm_loc = mc.rename(loc, all + "_loc")
mc.parent(rnm_grp, all)
mc.setAttr(rnm_grp + ".tx", 0)
mc.setAttr(rnm_grp + ".ty", 0)
mc.setAttr(rnm_grp + ".tz", 0)
mc.setAttr(rnm_grp + ".rx", 0)
mc.setAttr(rnm_grp + ".ry", 0)
mc.setAttr(rnm_grp + ".rz", 0)
def createArms(side):
global editMode
if side == 1: # left
if base.objExists('L_Arm_GRP'):
print 'im not doing anything'
else:
L_arm = base.group(em=True, name='L_Arm_GRP')
base.parent(L_arm, 'Loc_SPINE_' + str(spineCount - 1))
#clavicle start
clavicle = base.spaceLocator(n='Loc_L_Clavicle')
base.scale(0.1, 0.1, 0.1, clavicle)
base.parent(clavicle, 'Loc_SPINE_' + str(spineCount - 1))
base.move(0.1 * side, 1.5 + (0.25 * spineCount), 0.1, clavicle)
## upperarm
upperArm = base.spaceLocator(n='Loc_L_UpperArm')
base.scale(0.1, 0.1, 0.1, upperArm)
base.parent(upperArm, 'Loc_L_Clavicle')
base.move(0.35 * side, 1.5 + (0.25 * spineCount), 0, upperArm)
#elbow
if (_doubleElbow == False):
elbow = base.spaceLocator(n='Loc_L_Elbow')
base.scale(0.1, 0.1, 0.1, elbow)
base.parent(elbow, upperArm)
base.move(0.6 * side, 2, -0.2, elbow)
else:
elbow = base.spaceLocator(n='Loc_L_Elbow_1')
base.scale(0.1, 0.1, 0.1, elbow)
base.parent(elbow, upperArm)
base.move(0.58 * side, 2, -0.2, elbow)
elbow_2 = base.spaceLocator(n='Loc_L_Elbow_2')
base.scale(0.1, 0.1, 0.1, elbow_2)
base.parent(elbow_2, elbow)
base.move(0.62 * side, 1.98, -0.2, elbow_2)
#wrist
wrist = base.spaceLocator(n='Loc_L_Wrist')
base.scale(0.1, 0.1, 0.1, wrist)
base.parent(wrist, elbow)
base.move(0.35 * side, 1 + (0.25 * spineCount), 0, L_arm)
#move wrist
base.move(0.8 * side, 1.5, 0, wrist)
createHands(1, wrist)
else: # right
if base.objExists('R_Arm_GRP'):
print 'im still not doing anything'
else:
R_arm = base.group(em=True, name='R_Arm_GRP')
base.parent(R_arm, 'Loc_SPINE_' + str(spineCount - 1))
#clavicle start
clavicle = base.spaceLocator(n='Loc_R_Clavicle')
base.scale(0.1, 0.1, 0.1, clavicle)
base.parent(clavicle, 'Loc_SPINE_' + str(spineCount - 1))
base.move(0.1 * side, 1.5 + (0.25 * spineCount), 0.1, clavicle)
## upperarm
upperArm = base.spaceLocator(n='Loc_R_UpperArm')
base.scale(0.1, 0.1, 0.1, upperArm)
base.parent(upperArm, 'Loc_R_Clavicle')
base.move(0.35 * side, 1.5 + (0.25 * spineCount), 0, upperArm)
#elbow
if (_doubleElbow == False):
elbow = base.spaceLocator(n='Loc_R_Elbow')
base.scale(0.1, 0.1, 0.1, elbow)
base.parent(elbow, upperArm)
base.move(0.6 * side, 2, -0.2, elbow)
else:
elbow = base.spaceLocator(n='Loc_R_Elbow_1')
base.scale(0.1, 0.1, 0.1, elbow)
base.parent(elbow, upperArm)
base.move(0.58 * side, 2, -0.2, elbow)
elbow_2 = base.spaceLocator(n='Loc_R_Elbow_2')
base.scale(0.1, 0.1, 0.1, elbow_2)
base.parent(elbow_2, elbow)
base.move(0.62 * side, 1.98, -0.2, elbow_2)
#wrist
wrist = base.spaceLocator(n='Loc_R_Wrist')
base.scale(0.1, 0.1, 0.1, wrist)
base.parent(wrist, elbow)
base.move(0.35 * side, 1 + (0.25 * spineCount), 0, R_arm)
#move wrist
base.move(0.8 * side, 1.5, 0, wrist)
createHands(-1, wrist)
def createLocator(mpoint):
loc = cmds.spaceLocator(p=[mpoint.x, mpoint.y, mpoint.z])[0]
locShape = cmds.listRelatives(loc, s=1)[0]
cmds.setAttr(locShape + '.localScale', 0.1, 0.1, 0.1)
def pointSampleWeight(samplePt,
pntList,
weightCalc=[True, True, True],
prefix=''):
'''
'''
# Check prefix
if not prefix: prefix = 'triSampleWeight'
# Get tri points
posList = [
mc.xform(pntList[0], q=True, ws=True, rp=True),
mc.xform(pntList[1], q=True, ws=True, rp=True),
mc.xform(pntList[2], q=True, ws=True, rp=True)
]
# Build pntFace mesh
pntFace = mc.polyCreateFacet(p=posList, n=prefix + '_sample_mesh')[0]
mc.setAttr(pntFace + '.inheritsTransform', 0, l=True)
# Attach triPt locator to pntFace mesh
pntLoc = glTools.utils.mesh.locatorMesh(pntFace, prefix=prefix)
# Attach follow pt
followLoc = mc.spaceLocator(n=prefix + '_follow_locator')[0]
followGeoCon = mc.geometryConstraint(pntFace, followLoc)
followPntCon = mc.pointConstraint(samplePt, followLoc)
# Calculate triArea
triEdge1_pma = mc.createNode('plusMinusAverage',
n=prefix + '_triEdge1Vec_plusMinusAverage')
triEdge2_pma = mc.createNode('plusMinusAverage',
n=prefix + '_triEdge2Vec_plusMinusAverage')
mc.setAttr(triEdge1_pma + '.operation', 2) # Subtract
mc.setAttr(triEdge2_pma + '.operation', 2) # Subtract
mc.connectAttr(pntLoc[1] + '.worldPosition[0]',
triEdge1_pma + '.input3D[0]',
f=True)
mc.connectAttr(pntLoc[0] + '.worldPosition[0]',
triEdge1_pma + '.input3D[1]',
f=True)
mc.connectAttr(pntLoc[2] + '.worldPosition[0]',
triEdge2_pma + '.input3D[0]',
f=True)
mc.connectAttr(pntLoc[0] + '.worldPosition[0]',
triEdge2_pma + '.input3D[1]',
f=True)
triArea_vpn = mc.createNode('vectorProduct',
n=prefix + '_triArea_vectorProduct')
mc.setAttr(triArea_vpn + '.operation', 2) # Cross Product
mc.connectAttr(triEdge1_pma + '.output3D', triArea_vpn + '.input1', f=True)
mc.connectAttr(triEdge2_pma + '.output3D', triArea_vpn + '.input2', f=True)
triArea_dist = mc.createNode('distanceBetween',
n=prefix + '_triArea_distanceBetween')
mc.connectAttr(triArea_vpn + '.output', triArea_dist + '.point1', f=True)
# Calculate triPt weights
for i in range(3):
# Check weight calculation (bool)
if weightCalc[i]:
# Calculate triArea
pntEdge1_pma = mc.createNode('plusMinusAverage',
n=prefix + '_pt' + str(i) +
'Edge1Vec_plusMinusAverage')
pntEdge2_pma = mc.createNode('plusMinusAverage',
n=prefix + '_pt' + str(i) +
'Edge2Vec_plusMinusAverage')
mc.setAttr(pntEdge1_pma + '.operation', 2) # Subtract
mc.setAttr(pntEdge2_pma + '.operation', 2) # Subtract
mc.connectAttr(pntLoc[(i + 1) % 3] + '.worldPosition[0]',
pntEdge1_pma + '.input3D[0]',
f=True)
mc.connectAttr(followLoc + '.worldPosition[0]',
pntEdge1_pma + '.input3D[1]',
f=True)
mc.connectAttr(pntLoc[(i + 2) % 3] + '.worldPosition[0]',
pntEdge2_pma + '.input3D[0]',
f=True)
mc.connectAttr(followLoc + '.worldPosition[0]',
pntEdge2_pma + '.input3D[1]',
f=True)
pntArea_vpn = mc.createNode('vectorProduct',
n=prefix + '_pt' + str(i) +
'Area_vectorProduct')
mc.setAttr(pntArea_vpn + '.operation', 2) # Cross Product
mc.connectAttr(pntEdge1_pma + '.output3D',
pntArea_vpn + '.input1',
f=True)
mc.connectAttr(pntEdge2_pma + '.output3D',
pntArea_vpn + '.input2',
f=True)
pntArea_dist = mc.createNode('distanceBetween',
n=prefix + '_pt' + str(i) +
'Area_distanceBetween')
mc.connectAttr(pntArea_vpn + '.output',
pntArea_dist + '.point1',
f=True)
# Divide ptArea by triArea to get weight
pntWeight_mdn = mc.createNode('multiplyDivide',
n=prefix + '_pt' + str(i) +
'Weight_multiplyDivide')
mc.setAttr(pntWeight_mdn + '.operation', 2) # Divide
mc.connectAttr(pntArea_dist + '.distance',
pntWeight_mdn + '.input1X',
f=True)
mc.connectAttr(triArea_dist + '.distance',
pntWeight_mdn + '.input2X',
f=True)
# Add weight attribute to pntLoc
mc.addAttr(pntLoc[i], ln='weight', min=0.0, max=1.0, dv=0.0)
mc.connectAttr(pntWeight_mdn + '.outputX',
pntLoc[i] + '.weight',
f=True)
# Group mesh locators
pntLoc_grp = mc.group(pntLoc, n=prefix + '_3Point_grp')
mc.parent(pntFace, pntLoc_grp)
# Return result
return [pntLoc, pntFace, pntLoc_grp]
def build_stretch(start_joint, end_joint):
"""
builds the joint as stretchy joint from the starting joint to the end joint.
:param start_joint:
:param end_joint:
:return:
"""
cmds.setAttr("%s.jointOrientY" % listAllJointsInSelection[0], 0)
# Creates the splineIK to the selected joint hierarchy.
splineIk = cmds.ikHandle(startJoint=startJoint,
endEffector=endJoint,
sol="ikSplineSolver",
numSpans=numberOfPoints,
scv=True,
pcv=False,
createCurve=True)
splineCrvCvs = cmds.ls(splineIk[2] + '.cv[*]', flatten=True)
sysGrp = cmds.group(splineIk[0], splineIk[2], name='sys_stretch_grp')
# Adds the cluster locators.
startPt = cmds.xform(splineCrvCvs[0],
worldSpace=True,
translation=True,
query=True)
lastPt = cmds.xform(splineCrvCvs[-1],
worldSpace=True,
translation=True,
query=True)
cvStartLocator = cmds.spaceLocator(name='start_loc')[0]
cvEndLocator = cmds.spaceLocator(name='end_loc')[0]
for eachScale in ['.localScaleX', '.localScaleY', '.localScaleZ']:
print cvStartLocator + eachScale
cmds.setAttr('{0}Shape{1}'.format(cvStartLocator, eachScale), 5)
cmds.setAttr('{0}Shape{1}'.format(cvEndLocator, eachScale), 5)
cmds.xform(cvStartLocator, ws=True, translation=startPt)
cmds.xform(cvEndLocator, ws=True, translation=lastPt)
cmds.cluster([splineCrvCvs[0], splineCrvCvs[1]],
bindState=True,
relative=True,
weightedNode=[cvStartLocator, cvStartLocator + 'Shape'])
cmds.cluster([splineCrvCvs[-2], splineCrvCvs[-1]],
bindState=True,
relative=True,
weightedNode=[cvEndLocator, cvEndLocator + 'Shape'])
for eachClusterCv in [
splineCrvCvs[0], splineCrvCvs[1], splineCrvCvs[-2],
splineCrvCvs[-1]
]:
splineCrvCvs.remove(eachClusterCv)
ctlGrp = cmds.group(cvStartLocator, cvEndLocator, name='ctl_stretch_grp')
for index, eachLeftoverCVs in enumerate(splineCrvCvs):
cvMiddleLocator = cmds.spaceLocator(
name='middle{0}_loc'.format(index))[0]
midCvPosition = cmds.xform(eachLeftoverCVs,
ws=True,
translation=True,
query=True)
cmds.xform(cvMiddleLocator, ws=True, translation=midCvPosition)
cmds.cluster(eachLeftoverCVs,
bindState=True,
relative=True,
weightedNode=[cvMiddleLocator, cvMiddleLocator + 'Shape'])
cmds.parent(cvMiddleLocator, ctlGrp)
# Set the ikSpline advanced twist controls.
cmds.setAttr(splineIk[0] + '.dTwistControlEnable', 1)
cmds.setAttr(splineIk[0] + '.dWorldUpType', 4)
cmds.connectAttr(cvStartLocator + '.worldMatrix[0]',
splineIk[0] + '.dWorldUpMatrix')
cmds.connectAttr(cvEndLocator + '.worldMatrix[0]',
splineIk[0] + '.dWorldUpMatrixEnd')
# Add stretchiness element to the spline.
arcLen = cmds.arclen(splineIk[-1], ch=1)
# Adds scaleFactor setup.
stretchLocGrp = cmds.spaceLocator(name="stretchyIK_grp")[0]
scaleGrp = cmds.group(name="inheritSCALE", em=True)
cmds.setAttr("{0}.inheritsTransform".format(scaleGrp), 0)
cmds.scaleConstraint(stretchLocGrp, scaleGrp, mo=False)
scaleFactor = cmds.createNode('multiplyDivide', name='scaleFACTOR')
cmds.setAttr(scaleFactor + '.operation', 2)
cmds.connectAttr(arcLen + '.arcLength', scaleFactor + '.input1X')
cmds.connectAttr(scaleGrp + '.scaleX', scaleFactor + '.input2X')
lengthDiff = cmds.createNode('multiplyDivide', name='LengthDifference')
cmds.setAttr(lengthDiff + '.operation', 2)
cmds.connectAttr(scaleFactor + '.outputX', lengthDiff + '.input1X')
arcLenNumber = cmds.getAttr(arcLen + '.arcLength')
cmds.setAttr(lengthDiff + '.input2X', arcLenNumber)
for eachJoint in listAllJointsInSelection[:-1]:
translationX = cmds.getAttr(eachJoint + '.translateX')
transXDiff = cmds.createNode('multiplyDivide',
name='translationDifference')
cmds.setAttr(transXDiff + '.operation', 1)
cmds.setAttr(transXDiff + '.input1X', translationX)
cmds.connectAttr(lengthDiff + '.outputX', transXDiff + '.input2X')
cmds.connectAttr(transXDiff + '.outputX', eachJoint + '.tx')
cmds.parent(selection, scaleGrp, ctlGrp, sysGrp, stretchLocGrp)
def createLoc():
head = 2
mc.spaceLocator(n='FootLoc')
mc.scale(0.6, 0.6, 0.6)
mc.color(rgb=(0, 0, 1))
mc.spaceLocator(n='AnkleLoc')
mc.move(0, head * 0.5, 0)
mc.scale(0.2, 0.2, 0.2)
mc.color(rgb=(0.5, 0, 0))
mc.spaceLocator(n='KneeLoc')
mc.move(0, head * 2, 0)
mc.scale(0.3, 0.3, 0.3)
mc.color(rgb=(0.5, 0.2, 0))
mc.spaceLocator(n='PelvisLoc')
mc.move(0, head * 4, 0)
mc.scale(0.4, 0.4, 0.4)
mc.color(rgb=(0.5, 0.2, 0.5))
mc.spaceLocator(n='NeckLoc')
mc.move(0, head * 6.5, 0)
mc.scale(0.2, 0.2, 0.2)
mc.color(rgb=(0, 0.2, 0.5))
mc.spaceLocator(n='ShoulderLeftLoc')
mc.move(head, head * 6.5, 0)
mc.scale(0.2, 0.2, 0.2)
mc.color(rgb=(0, 0.2, 0.5))
mc.spaceLocator(n='ElbowLeftLoc')
mc.move(head * 2.5, head * 6.5, 0)
mc.scale(0.2, 0.2, 0.2)
mc.color(rgb=(0, 0.2, 0.5))
mc.spaceLocator(n='WristLeftLoc')
mc.move(head * 3.7, head * 6.5, 0)
mc.scale(0.2, 0.2, 0.2)
mc.color(rgb=(0, 0.2, 0.5))
mc.spaceLocator(n='IndexLoc3')
mc.move(head * 4.4, head * 6.5, 0)
mc.scale(0.1, 0.1, 0.1)
mc.color(rgb=(0, 0.2, 0.5))
mc.spaceLocator(n='IndexLoc0')
fingerEnd = mc.getAttr('IndexLoc3.tx')
wrist = mc.getAttr('WristLeftLoc.tx')
halfhand = wrist + (fingerEnd - wrist) * 0.5
mc.move(halfhand, head * 6.5, 0)
mc.scale(0.05, 0.05, 0.05)
mc.spaceLocator(n='IndexLoc1')
fingerEnd = mc.getAttr('IndexLoc3.tx')
middlefingerRoot = mc.getAttr('IndexLoc0.tx')
halfmiddleFinger = middlefingerRoot + (fingerEnd - middlefingerRoot) * 0.5
mc.move(halfmiddleFinger, head * 6.5, 0)
mc.scale(0.05, 0.05, 0.05)
mc.spaceLocator(n='IndexLoc2')
fingerEnd = mc.getAttr('IndexLoc3.tx')
IndexLoc1 = mc.getAttr('IndexLoc1.tx')
halfmiddleSecondFinger = IndexLoc1 + (fingerEnd - IndexLoc1) * 0.5
mc.move(halfmiddleSecondFinger, head * 6.5, 0)
mc.scale(0.05, 0.05, 0.05)
mc.select('IndexLoc0', 'IndexLoc1', 'IndexLoc2', 'IndexLoc3')
mc.move(0, 0, 0.2, r=True)
mc.spaceLocator(n='ShoulderRightLoc')
mc.move(-head, head * 6.5, 0)
mc.scale(0.2, 0.2, 0.2)
mc.color(rgb=(0, 0.2, 0.5))
mc.spaceLocator(n='HeadLoc')
mc.move(0, head * 7, 0)
mc.scale(0.5, 0.5, 0.5)
mc.color(rgb=(0, 0.2, 0.5))
mc.spaceLocator(n='HeadEndLoc')
mc.move(0, head * 8, 0)
mc.scale(0.7, 0.7, 0.7)
mc.color(rgb=(0, 0, 2))
#other fingers besides index
for i in range(3):
mc.select('IndexLoc0', 'IndexLoc1', 'IndexLoc2', 'IndexLoc3')
mc.duplicate()
mc.move(0, 0, -0.2 * (i + 1), r=True)
for j in range(4):
mc.rename('IndexLoc' + str(j + 4), 'MiddleLoc' + str(j))
for j in range(4, 8):
mc.rename('IndexLoc' + str(j + 4), 'RingLoc' + str(j - 4))
for j in range(8, 12):
mc.rename('IndexLoc' + str(j + 4), 'PinkieLoc' + str(j - 8))
for item in removalList:
CleanRemove(item)
#get the follicles associated with this nurbs surface
nurbsShape = cmds.listRelatives(newNurbsSurface)[0]
attachedFollicles = cmds.listConnections(nurbsShape + '.worldMatrix')
for i in range(len(attachedFollicles)):
follicle = cmds.rename(attachedFollicles[i],
theName + '_%02i_follicle' % (i + 1))
cmds.select(follicle)
cmds.joint(n=theName + 'follicle_%02i_jnt' % (i + 1))
#make control joints
cmds.select(cl=True)
locList = []
for i in range(theControlNum):
newLoc = cmds.spaceLocator()
locList.append(newLoc)
if i == 0:
cmds.move((theNumV / 2), z=True)
if i == (theControlNum - 1):
cmds.move(-(theNumV / 2), z=True)
#move the rest of the "joints" to their new spots
for i in range(len(locList)):
if (i > 0) & (i < (len(locList) - 1)):
print locList[i]
cmds.pointConstraint(locList[0], locList[i], mo=False)
cmds.pointConstraint(locList[len(locList) - 1], locList[i], mo=False)
def create(samplePt, pntList, weightCalc=[True, True, True], prefix=''):
'''
Generate the barycentric point weight setup based on the input arguments
@param samplePt: The locator used to define the triangle sample point to generate weights for
@type samplePt: str
@param pntList: List of points to define triangle
@type pntList: list
@param weightCalc: List of booleans to define which point weights are calculated
@type weightCalc: list
@param prefix: String name prefix for all created nodes
@type prefix: str
'''
# Check prefix
if not prefix: prefix = 'barycentricPointWeight'
# ========================
# - Setup Full Area Calc -
# ========================
# Build pntFace surface
pntFace = mc.nurbsPlane(p=(0, 0, 0),
ax=(0, 1, 0),
d=1,
ch=False,
n=prefix + '_sample_surface')[0]
pntLoc = glTools.utils.surface.locatorSurface(pntFace, prefix=prefix)
mc.delete(mc.pointConstraint(pntList[0], pntLoc[0]))
mc.delete(mc.pointConstraint(pntList[1], pntLoc[1]))
mc.delete(mc.pointConstraint(pntList[2], pntLoc[2]))
mc.delete(mc.pointConstraint(pntList[2], pntLoc[3]))
# Attach follow pt
followLoc = mc.spaceLocator(n=prefix + '_follow_locator')[0]
follow_cpos = mc.createNode('closestPointOnSurface',
n=prefix + '_closestPointOnSurface')
mc.connectAttr(samplePt + '.worldPosition[0]',
follow_cpos + '.inPosition',
f=True)
mc.connectAttr(pntFace + '.worldSpace[0]',
follow_cpos + '.inputSurface',
f=True)
mc.connectAttr(follow_cpos + '.position', followLoc + '.translate', f=True)
# Calculate triArea
triEdge1_pma = mc.createNode('plusMinusAverage',
n=prefix + '_triEdge1Vec_plusMinusAverage')
triEdge2_pma = mc.createNode('plusMinusAverage',
n=prefix + '_triEdge2Vec_plusMinusAverage')
mc.setAttr(triEdge1_pma + '.operation', 2) # Subtract
mc.setAttr(triEdge2_pma + '.operation', 2) # Subtract
mc.connectAttr(pntLoc[1] + '.worldPosition[0]',
triEdge1_pma + '.input3D[0]',
f=True)
mc.connectAttr(pntLoc[0] + '.worldPosition[0]',
triEdge1_pma + '.input3D[1]',
f=True)
mc.connectAttr(pntLoc[2] + '.worldPosition[0]',
triEdge2_pma + '.input3D[0]',
f=True)
mc.connectAttr(pntLoc[0] + '.worldPosition[0]',
triEdge2_pma + '.input3D[1]',
f=True)
triArea_vpn = mc.createNode('vectorProduct',
n=prefix + '_triArea_vectorProduct')
mc.setAttr(triArea_vpn + '.operation', 2) # Cross Product
mc.connectAttr(triEdge1_pma + '.output3D', triArea_vpn + '.input1', f=True)
mc.connectAttr(triEdge2_pma + '.output3D', triArea_vpn + '.input2', f=True)
triArea_dist = mc.createNode('distanceBetween',
n=prefix + '_triArea_distanceBetween')
mc.connectAttr(triArea_vpn + '.output', triArea_dist + '.point1', f=True)
# =======================
# - Setup Sub Area Calc -
# =======================
# Calculate triPt weights
for i in range(3):
# Check weight calculation (bool)
if weightCalc[i]:
# Calculate sub-TriArea
pntEdge1_pma = mc.createNode('plusMinusAverage',
n=prefix + '_pt' + str(i) +
'Edge1Vec_plusMinusAverage')
pntEdge2_pma = mc.createNode('plusMinusAverage',
n=prefix + '_pt' + str(i) +
'Edge2Vec_plusMinusAverage')
mc.setAttr(pntEdge1_pma + '.operation', 2) # Subtract
mc.setAttr(pntEdge2_pma + '.operation', 2) # Subtract
mc.connectAttr(pntLoc[(i + 1) % 3] + '.worldPosition[0]',
pntEdge1_pma + '.input3D[0]',
f=True)
mc.connectAttr(followLoc + '.worldPosition[0]',
pntEdge1_pma + '.input3D[1]',
f=True)
mc.connectAttr(pntLoc[(i + 2) % 3] + '.worldPosition[0]',
pntEdge2_pma + '.input3D[0]',
f=True)
mc.connectAttr(followLoc + '.worldPosition[0]',
pntEdge2_pma + '.input3D[1]',
f=True)
pntArea_vpn = mc.createNode('vectorProduct',
n=prefix + '_pt' + str(i) +
'Area_vectorProduct')
mc.setAttr(pntArea_vpn + '.operation', 2) # Cross Product
mc.connectAttr(pntEdge1_pma + '.output3D',
pntArea_vpn + '.input1',
f=True)
mc.connectAttr(pntEdge2_pma + '.output3D',
pntArea_vpn + '.input2',
f=True)
pntArea_dist = mc.createNode('distanceBetween',
n=prefix + '_pt' + str(i) +
'Area_distanceBetween')
mc.connectAttr(pntArea_vpn + '.output',
pntArea_dist + '.point1',
f=True)
# Divide ptArea by triArea to get weight
pntWeight_mdn = mc.createNode('multiplyDivide',
n=prefix + '_pt' + str(i) +
'Weight_multiplyDivide')
mc.setAttr(pntWeight_mdn + '.operation', 2) # Divide
mc.connectAttr(pntArea_dist + '.distance',
pntWeight_mdn + '.input1X',
f=True)
mc.connectAttr(triArea_dist + '.distance',
pntWeight_mdn + '.input2X',
f=True)
# Add weight attribute to pntLoc
mc.addAttr(pntLoc[i], ln='weight', min=0.0, max=1.0, dv=0.0)
mc.connectAttr(pntWeight_mdn + '.outputX',
pntLoc[i] + '.weight',
f=True)
# ============
# - CLEAN UP -
# ============
# Group mesh locators
pntLoc_grp = mc.group(pntLoc, n=prefix + '_3Point_grp')
mc.parent(pntFace, pntLoc_grp)
# Turn off inheritTransforms for tri point face
mc.setAttr(pntFace + '.inheritsTransform', 0)
# Scale follow locator
mc.setAttr(followLoc + '.localScale', 0.05, 0.05, 0.05)
# Parent and hide coincident locator
mc.parent(pntLoc[3], pntLoc[2])
mc.setAttr(pntLoc[3] + '.v', 0)
# =================
# - Return Result -
# =================
# Return result
return [pntLoc, pntFace, pntLoc_grp]
def _particleDyn(obj, weight, conserve, transfShapes, nucleus):
"Metodo generico di dinamica basata sulla particella"
c = obj
cNoPath = c[c.rfind("|")+1:]
dynName = cNoPath + "_DYN"
partName = cNoPath + "_INIT"
dynLocName = cNoPath + "_DYN_LOC"
statLocName = cNoPath + "_STAT_LOC"
revName = cNoPath + "_REV"
exprName = cNoPath + "_Expression"
octName = cNoPath + "Oct"
# leggo la posizione dell'oggetto
pos = cmds.xform(c, q=True, rp=True, ws=True)
# creo la particella
if nucleus:
partic, partShape = cmds.nParticle(n=partName, p=pos)
else:
partic, partShape = cmds.particle(n=partName, p=pos)
partShape = "%s|%s" % (partic, partShape)
# sposto il pivot
cmds.xform(partic, piv=pos, ws=True)
# aggiungo uno shape alla particella
octName = drawOct(octName, r=0.25, pos=pos)
octShapeName = cmds.listRelatives(octName, s=True, pa=True)[0]
cmds.setAttr(octShapeName + ".overrideEnabled", True)
cmds.setAttr(octShapeName + ".overrideColor", 13)
cmds.parent([octShapeName, partic], s=True, r=True)
cmds.delete(octName)
# creo i locator
statLocGrp = cmds.group("|" + cmds.spaceLocator(n=statLocName)[0], n="g_" + statLocName)
dynLocGrp = cmds.group("|" + cmds.spaceLocator(n=dynLocName)[0], n="g_" + dynLocName)
cmds.setAttr("|%s|%s.overrideEnabled" % (dynLocGrp, dynLocName), True)
cmds.setAttr("|%s|%s.overrideColor" % (dynLocGrp, dynLocName), 6)
# se e' attivo transfer shapes uso un gruppo invece di creare il cubetto
if transfShapes:
dyn = cmds.group(n=dynName, em=True)
else:
# cubetto colorato di blu orientato secondo l'oggetto
dyn = drawCube(dynName, l=0.5)
cubeShape = cmds.listRelatives(dyn, s=True, pa=True)[0]
cmds.setAttr(cubeShape + ".overrideEnabled", True) # colore
cmds.setAttr(cubeShape + ".overrideColor", 6)
# ruoto il cubetto e i locator (molto + carino)
cmds.xform(["|" + statLocGrp, "|" + dynLocGrp, dyn], ro=cmds.xform(c, q=True, ro=True, ws=True), ws=True)
cmds.xform(["|" + statLocGrp, "|" + dynLocGrp, dyn], t=pos, ws=True)
dyn = cmds.parent([dyn, c])[0]
cmds.makeIdentity(dyn, apply=True) # in questo modo il cubo assume le coordinate dell'oggetto pur essendo posizionato nel suo pivot
# parento dyn allo stesso parente dell'oggetto
parentObj = cmds.listRelatives(c, p=True, pa=True)
if parentObj:
dyn = cmds.parent([dyn, parentObj[0]])[0]
else:
dyn = cmds.parent(dyn, w=True)[0]
c = cmds.parent([c, dyn])[0]
cmds.parent(["|" + statLocGrp, "|" + dynLocGrp, dyn])
# aggiorna i nomi con i percorsi
statLocGrp = "%s|%s" % (dyn, statLocGrp)
dynLocGrp = "%s|%s" % (dyn, dynLocGrp)
statLoc = "%s|%s" % (statLocGrp, statLocName)
dynLoc = "%s|%s" % (dynLocGrp, dynLocName)
# goal particella-loc statico
cmds.goal(partic, g=statLoc, utr=True, w=weight)
# nascondo locator
cmds.hide([statLocGrp, dynLocGrp])
# rendo template la particella
cmds.setAttr(partShape + '.template', True)
# aggiungo l'attributo di velocita'
cmds.addAttr(c, ln="info", at="enum", en=" ", keyable=True)
cmds.setAttr(c + ".info", l=True)
cmds.addAttr(c, ln="velocity", at="double3")
cmds.addAttr(c, ln="velocityX", at="double", p="velocity", k=True)
cmds.addAttr(c, ln="velocityY", at="double", p="velocity", k=True)
cmds.addAttr(c, ln="velocityZ", at="double", p="velocity", k=True)
# point oggetto tra i locator statico e dinamico
pc = cmds.pointConstraint(statLoc, dynLoc, c, n=cNoPath + "_PC")[0]
cmds.addAttr(dyn, ln="settings", at="enum", en=" ", keyable=True)
cmds.setAttr(dyn + ".settings", l=True)
cmds.addAttr(dyn, ln="dynamicsBlend", at="double", min=0.0, max=1.0, dv=1.0, keyable=True)
cmds.addAttr(dyn, ln="weight", at="double", min=0.0, max=1.0, dv=weight, keyable=True)
cmds.addAttr(dyn, ln="conserve", at="double", min=0.0, max=1.0, dv=conserve, keyable=True)
rev = cmds.createNode("reverse", n=revName)
cmds.connectAttr(dyn + ".dynamicsBlend", pc + ".w1")
cmds.connectAttr(dyn + ".dynamicsBlend", rev + ".inputX")
cmds.connectAttr(rev + ".outputX", pc + ".w0")
cmds.connectAttr(dyn + ".weight", partShape + ".goalWeight[0]")
cmds.connectAttr(dyn + ".conserve", partShape + ".conserve")
# locco il point constraint
[cmds.setAttr("%s.%s" % (pc, s), l=True) for s in ["offsetX", "offsetY", "offsetZ", "w0", "w1", "nodeState"]]
# locco il reverse
[cmds.setAttr("%s.%s" % (revName, s), l=True) for s in ["inputX", "inputY", "inputZ"]]
# nParticle
if nucleus:
nucleusNode = cmds.listConnections(partShape + ".currentState")[0]
cmds.setAttr(nucleusNode + '.gravity', 0.0)
expr = """// rename if needed
string $dynHandle = "%s";
string $particleObject = "%s";
string $dynLocator = "%s";
undoInfo -swf 0;
$ast = `playbackOptions -q -ast`;
if (`currentTime -q` - $ast < 2) {
// %s.startFrame = $ast; // remove it if you don't want to change nucleus start time
$destPiv = `xform -q -rp -ws $dynHandle`;
$origPiv = `xform -q -rp -ws $particleObject`;
xform -t ($destPiv[0]-$origPiv[0]) ($destPiv[1]-$origPiv[1]) ($destPiv[2]-$origPiv[2]) -r -ws $particleObject;
}
$zvPos = `getParticleAttr -at worldPosition ($particleObject + ".pt[0]")`;
$currUnit = `currentUnit -q -linear`;
if ($currUnit != "cm") {
$zvPos[0] = `convertUnit -f "cm" -t $currUnit ((string)$zvPos[0])`;
$zvPos[1] = `convertUnit -f "cm" -t $currUnit ((string)$zvPos[1])`;
$zvPos[2] = `convertUnit -f "cm" -t $currUnit ((string)$zvPos[2])`;
}
xform -a -ws -t $zvPos[0] $zvPos[1] $zvPos[2] $dynLocator;
$zvVel = `getParticleAttr -at velocity ($particleObject + ".pt[0]")`; // velocity relative to the particleObject
%s.velocityX = $zvVel[0];
%s.velocityY = $zvVel[1];
%s.velocityZ = $zvVel[2];
undoInfo -swf 1;""" % (dyn, partic, dynLocName, nucleusNode, c, c, c)
# particella standard
else:
cmds.setAttr(partic + ".visibility", False)
expr = """// rename if needed
string $dynHandle = "%s";
string $particleObject = "%s";
string $dynLocator = "%s";
undoInfo -swf 0;
$ast = `playbackOptions -q -ast`;
if (`currentTime -q` - $ast < 2) {
%s.startFrame = $ast;
$destPiv = `xform -q -rp -ws $dynHandle`;
$origPiv = `xform -q -rp -ws $particleObject`;
xform -t ($destPiv[0]-$origPiv[0]) ($destPiv[1]-$origPiv[1]) ($destPiv[2]-$origPiv[2]) -r -ws $particleObject;
}
$zvPos = `getParticleAttr -at worldPosition ($particleObject + ".pt[0]")`;
$currUnit = `currentUnit -q -linear`;
if ($currUnit != "cm") {
$zvPos[0] = `convertUnit -f "cm" -t $currUnit ((string)$zvPos[0])`;
$zvPos[1] = `convertUnit -f "cm" -t $currUnit ((string)$zvPos[1])`;
$zvPos[2] = `convertUnit -f "cm" -t $currUnit ((string)$zvPos[2])`;
}
xform -a -ws -t $zvPos[0] $zvPos[1] $zvPos[2] $dynLocator;
$zvVel = `getParticleAttr -at velocity ($particleObject + ".pt[0]")`; // velocity relative to the particleObject
%s.velocityX = $zvVel[0];
%s.velocityY = $zvVel[1];
%s.velocityZ = $zvVel[2];
undoInfo -swf 1;""" % (dyn, partic, dynLocName, partShape, c, c, c)
# crea l'espressione
cmds.expression(n=exprName, s=expr)
# se il check e' attivo trasferisci le geometrie nel nodo dinamico
if transfShapes:
shapes = cmds.listRelatives(c, s=True, pa=True)
if shapes:
cmds.parent(shapes + [dyn], r=True, s=True)
# locks
[cmds.setAttr(partic + s, k=False, cb=True) for s in [".tx", ".ty", ".tz", ".rx", ".ry", ".rz", ".sx", ".sy", ".sz", ".v", ".startFrame"]]
return dyn
def quadromatic(self, function, orientation):
print function
print orientation
listObjs = mc.ls(sl=True)
selSize = len(listObjs)
num = 0
armJNames = ["scap", "shoulder", "elbow", "wrist", "hand"]
legJNames = ["hip", "knee", "calf", "ankle", "toe"]
try:
if orientation == "left":
orientString = "l_"
if orientation == "right":
orientString = "r_"
except:
print "No left or right directive entered"
if function == "spine":
print "spine function activated"
for i in range(0, selSize, 1):
mc.rename(listObjs[i], "spine" + "% d_jnt" % num)
num += 1
lastJointNum = selSize-1
mc.ikHandle(sj="spine_0_jnt", ee="spine_" + "% d_jnt" % lastJointNum, sol="ikSplineSolver", ccv=True, ns=3, n="spine_ik")
mc.rename("curve1", "spine_crv")
mc.select(cl=True)
mc.joint(n="spineBase_jntCtrl", rad=1.5)
pointy1 = mc.pointConstraint("spine_0_jnt", "spineBase_jntCtrl")
mc.delete(pointy1)
mc.select(cl=True)
mc.joint(n="spineEnd_jntCtrl", rad=1.5)
pointy2 = mc.pointConstraint("spine_" + "% d_jnt" % lastJointNum, "spineEnd_jntCtrl")
mc.delete(pointy2)
mc.select("spineBase_jntCtrl")
mc.select("spineEnd_jntCtrl", tgl=True)
mc.select("spine_crv", tgl=True)
mc.skinCluster()
upperbodyFrontCtrl = mc.circle(n="upperbodyFront_ctrl", r=4)
pointy3 = mc.pointConstraint("spineBase_jntCtrl",upperbodyFrontCtrl)
mc.delete(pointy3)
mc.select(upperbodyFrontCtrl)
mc.makeIdentity("upperbodyFront_ctrl", a=True, t=True, r=True, s=True)
mc.parentConstraint(upperbodyFrontCtrl, "spineBase_jntCtrl")
upperbodyBackCtrl = mc.circle(n="upperbodyBack_ctrl", r=4)
pointy4 = mc.pointConstraint("spineEnd_jntCtrl", upperbodyBackCtrl)
mc.delete(pointy4)
mc.select(upperbodyBackCtrl)
mc.makeIdentity("upperbodyBack_ctrl", a=True, t=True, r=True, s=True)
mc.parentConstraint(upperbodyBackCtrl, "spineEnd_jntCtrl")
upperbodyGroupCtrl = mc.circle(n="upperbody_ctrl")
mc.select(upperbodyGroupCtrl)
mc.scale(16, 26, 16)
mc.select(upperbodyGroupCtrl)
mc.rotate(90, 0, 0, r=False)
tempParent = mc.pointConstraint("spineBase_jntCtrl", "spineEnd_jntCtrl", upperbodyGroupCtrl)
mc.delete(tempParent)
mc.makeIdentity(upperbodyGroupCtrl, a=True, t=True, r=True, s=True)
mc.parent(upperbodyFrontCtrl, upperbodyGroupCtrl)
mc.parent(upperbodyBackCtrl, upperbodyGroupCtrl)
if function == "arm":
for i in range(0, selSize, 1):
print armJNames[i]
mc.rename(listObjs[i],orientString + armJNames[i] + "_jnt")
num+=1
#Adding some Iks
mc.ikHandle(sj=orientString + armJNames[0] + "_jnt", ee=orientString + armJNames[2] + "_jnt", sol="ikRPsolver", n=orientString + "upperarm_ik")
mc.ikHandle(sj=orientString + armJNames[2] + "_jnt", ee=orientString + armJNames[3] + "_jnt", sol="ikSCsolver", n=orientString + "armhock_ik")
mc.ikHandle(sj=orientString + armJNames[3] + "_jnt", ee=orientString + armJNames[4] + "_jnt", sol="ikSCsolver", n=orientString + "finger_ik")
#Making some Curves, arranging them
mc.curve(n=orientString+"hand_ctrl", p=[[0.5, 0.825, -0.75], [0.5, -0.001, -0.75], [-0.5, -0.001, -0.75], [-0.5, -0.001, 0.714], [0.5, -0.001, 0.714], [0.5, 0.546, 0.714], [-0.5, 0.546, 0.714], [-0.5, 0.825, -0.75], [0.5, 0.825, -0.75], [0.5, 0.546, 0.714], [0.5, -0.001, 0.714], [0.5, -0.001, -0.75], [-0.5, -0.001, -0.75], [-0.5, 0.825, -0.75], [-0.5, 0.546, 0.714], [-0.5, -0.001, 0.714]],d=1)
mc.pointConstraint(orientString + armJNames[4] + "_jnt", orientString + armJNames[3] + "_jnt", orientString+"hand_ctrl", n="temp")
mc.move(0, orientString+"hand_ctrl", y=True, r=False)
handEndLoc = mc.spaceLocator()
handStartLoc = mc.spaceLocator()
mc.matchTransform(handEndLoc, orientString + armJNames[4] + "_jnt")
mc.matchTransform(handStartLoc, orientString + armJNames[3] + "_jnt")
handMeasureNode = mc.distanceDimension(handEndLoc, handStartLoc)
handScaleFactor = mc.getAttr(handMeasureNode + ".distance")
mc.scale(handScaleFactor, handScaleFactor, handScaleFactor, orientString+"hand_ctrl")
mc.delete("temp")
mc.delete(handMeasureNode)
mc.delete(handEndLoc)
mc.delete(handStartLoc)
mc.circle(n=orientString+"handBall_ctrl")
mc.matchTransform(orientString+"handBall_ctrl", orientString + armJNames[2] + "_jnt", rot=False)
mc.rotate(-90,0,0, orientString+"handBall_ctrl", r=False)
mc.makeIdentity(orientString+"hand_ctrl", a=True, t=True, r=True, s=True)
mc.makeIdentity(orientString+"handBall_ctrl", a=True, t=True, r=True, s=True)
#Now the Locators, parenting them correctly and then positioning them appropriately
mc.spaceLocator(n=orientString + "handHindHeelRoll_LOC")
mc.spaceLocator(n=orientString + "handHindfingerRoll_LOC")
mc.parent(orientString +"handHindfingerRoll_LOC", orientString +"handHindHeelRoll_LOC")
mc.spaceLocator(n=orientString + "handHindTipRoll_LOC")
mc.parent(orientString + "handHindTipRoll_LOC", orientString +"handHindfingerRoll_LOC")
mc.spaceLocator(n=orientString + "handHindBallRoll_LOC")
mc.parent(orientString + "handHindBallRoll_LOC", orientString +"handHindfingerRoll_LOC")
mc.matchTransform(orientString + "handHindHeelRoll_LOC", orientString + armJNames[2] + "_jnt", rot=False, scl=False)
mc.move(0, orientString + "handHindHeelRoll_LOC", y=True, r=False)
mc.matchTransform(orientString + "handHindfingerRoll_LOC", orientString + armJNames[4] + "_jnt", rot=False, scl=False)
mc.matchTransform(orientString + "handHindTipRoll_LOC", orientString + armJNames[3] + "_jnt", rot=False, scl=False)
mc.matchTransform(orientString + "handHindBallRoll_LOC", orientString + armJNames[3] + "_jnt", rot=False, scl=False)
#Parenting Everything!
mc.parent(orientString + "armhock_ik", orientString+"hand_ctrl")
mc.parent(orientString + "handHindHeelRoll_LOC", orientString+"hand_ctrl")
mc.parent(orientString + "upperarm_ik", orientString+"handBall_ctrl")
mc.parent(orientString+"handBall_ctrl", orientString + "handHindTipRoll_LOC")
mc.parent(orientString + "finger_ik", orientString + "handHindBallRoll_LOC")
mc.makeIdentity(orientString + "handHindHeelRoll_LOC", a=True, t=True, r=True, s=True)
mc.makeIdentity(orientString + "handHindfingerRoll_LOC", a=True, t=True, r=True, s=True)
mc.makeIdentity(orientString + "handHindTipRoll_LOC", a=True, t=True, r=True, s=True)
mc.makeIdentity(orientString + "handHindBallRoll_LOC", a=True, t=True, r=True, s=True)
#Finally, set up new attributes on the hand control and connect them to the locator rotations
mc.addAttr(orientString+"hand_ctrl", at='float', ln="HeelRoll", h=False, w=True)
mc.setAttr(orientString+"hand_ctrl.HeelRoll", k=True, typ="float")
mc.addAttr(orientString+"hand_ctrl", at='float', ln="fingerRoll", h=False, w=True)
mc.setAttr(orientString+"hand_ctrl.fingerRoll", k=True, typ="float")
mc.addAttr(orientString+"hand_ctrl", at='float', ln="TipRoll", h=False, w=True)
mc.setAttr(orientString+"hand_ctrl.TipRoll", k=True, typ="float")
mc.connectAttr(orientString+"hand_ctrl.HeelRoll", orientString + "handHindHeelRoll_LOC.rotateX")
mc.connectAttr(orientString+"hand_ctrl.fingerRoll", orientString + "handHindfingerRoll_LOC.rotateX")
mc.connectAttr(orientString+"hand_ctrl.TipRoll", orientString + "handHindBallRoll_LOC.rotateX")
if function == "leg":
for i in range(0, selSize, 1):
mc.rename(listObjs[i],orientString + legJNames[i] + "_jnt")
num+=1
#Adding some Iks
mc.ikHandle(sj=orientString + legJNames[0] + "_jnt", ee=orientString + legJNames[2] + "_jnt", sol="ikRPsolver", n=orientString + "upperLeg_ik")
mc.ikHandle(sj=orientString + legJNames[2] + "_jnt", ee=orientString + legJNames[3] + "_jnt", sol="ikSCsolver", n=orientString + "leghock_ik")
mc.ikHandle(sj=orientString + legJNames[3] + "_jnt", ee=orientString + legJNames[4] + "_jnt", sol="ikSCsolver", n=orientString + "toe_ik")
#Now the Locators, parenting them correctly and then positioning them appropriately
mc.spaceLocator(n=orientString + "footHindHeelRoll_LOC")
mc.spaceLocator(n=orientString + "footHindToeRoll_LOC")
mc.parent(orientString +"footHindToeRoll_LOC", orientString +"footHindHeelRoll_LOC")
mc.spaceLocator(n=orientString + "footHindTipRoll_LOC")
mc.parent(orientString + "footHindTipRoll_LOC", orientString +"footHindToeRoll_LOC")
mc.spaceLocator(n=orientString + "footHindBallRoll_LOC")
mc.parent(orientString + "footHindBallRoll_LOC", orientString +"footHindToeRoll_LOC")
mc.matchTransform(orientString + "footHindHeelRoll_LOC", orientString + legJNames[2] + "_jnt", rot=False, scl=False)
mc.move(0, orientString + "footHindHeelRoll_LOC", y=True, r=False)
mc.matchTransform(orientString + "footHindToeRoll_LOC", orientString + legJNames[4] + "_jnt", rot=False, scl=False)
mc.matchTransform(orientString + "footHindTipRoll_LOC", orientString + legJNames[3] + "_jnt", rot=False, scl=False)
mc.matchTransform(orientString + "footHindBallRoll_LOC", orientString + legJNames[3] + "_jnt", rot=False, scl=False)
#Making some Curves, arranging them
mc.curve(n=orientString+"foot_ctrl", p=[[0.5, 0.825, -0.75], [0.5, -0.001, -0.75], [-0.5, -0.001, -0.75], [-0.5, -0.001, 0.714], [0.5, -0.001, 0.714], [0.5, 0.546, 0.714], [-0.5, 0.546, 0.714], [-0.5, 0.825, -0.75], [0.5, 0.825, -0.75], [0.5, 0.546, 0.714], [0.5, -0.001, 0.714], [0.5, -0.001, -0.75], [-0.5, -0.001, -0.75], [-0.5, 0.825, -0.75], [-0.5, 0.546, 0.714], [-0.5, -0.001, 0.714]],d=1)
mc.pointConstraint(orientString + legJNames[4] + "_jnt", orientString + legJNames[3] + "_jnt", orientString+"foot_ctrl", n="temp")
mc.move(0, orientString+"foot_ctrl", y=True, r=False)
footEndLoc = mc.spaceLocator()
footStartLoc = mc.spaceLocator()
mc.matchTransform(footEndLoc, orientString + legJNames[4] + "_jnt")
mc.matchTransform(footStartLoc, orientString + legJNames[3] + "_jnt")
measureNode = mc.distanceDimension(footEndLoc, footStartLoc)
scaleFactor = mc.getAttr(measureNode + ".distance")
mc.scale(scaleFactor, scaleFactor, scaleFactor, orientString+"foot_ctrl")
mc.delete("temp")
mc.delete(measureNode)
mc.delete(footEndLoc)
mc.delete(footStartLoc)
mc.rotate(0,0,0, orientString+"foot_ctrl", r=False)
mc.circle(n=orientString+"footBall_ctrl")
mc.matchTransform(orientString+"footBall_ctrl", orientString + legJNames[2] + "_jnt", rot=False)
mc.rotate(-90,0,0, orientString+"footBall_ctrl", r=False)
mc.makeIdentity(orientString+"footBall_ctrl", a=True, t=True, r=True, s=True)
mc.makeIdentity(orientString+"foot_ctrl", a=True, t=True, r=True, s=True)
#Parenting Everything!
mc.parent(orientString + "leghock_ik", orientString+"foot_ctrl")
mc.parent(orientString + "footHindHeelRoll_LOC", orientString+"foot_ctrl")
mc.parent(orientString + "upperLeg_ik", orientString+"footBall_ctrl")
mc.parent(orientString+"footBall_ctrl", orientString + "footHindTipRoll_LOC")
mc.parent(orientString + "toe_ik", orientString + "footHindBallRoll_LOC")
mc.makeIdentity(orientString + "footHindHeelRoll_LOC", a=True, t=True, r=True, s=True)
mc.makeIdentity(orientString + "footHindToeRoll_LOC", a=True, t=True, r=True, s=True)
mc.makeIdentity(orientString + "footHindTipRoll_LOC", a=True, t=True, r=True, s=True)
mc.makeIdentity(orientString + "footHindBallRoll_LOC", a=True, t=True, r=True, s=True)
#Finally, set up new attributes on the foot control and connect them to the locator rotations
mc.addAttr(orientString+"foot_ctrl", at='float', ln="HeelRoll", h=False, w=True)
mc.setAttr(orientString+"foot_ctrl.HeelRoll", k=True, typ="float")
mc.addAttr(orientString+"foot_ctrl", at='float', ln="ToeRoll", h=False, w=True)
mc.setAttr(orientString+"foot_ctrl.ToeRoll", k=True, typ="float")
mc.addAttr(orientString+"foot_ctrl", at='float', ln="TipRoll", h=False, w=True)
mc.setAttr(orientString+"foot_ctrl.TipRoll", k=True, typ="float")
mc.connectAttr(orientString+"foot_ctrl.HeelRoll", orientString + "footHindHeelRoll_LOC.rotateX")
mc.connectAttr(orientString+"foot_ctrl.ToeRoll", orientString + "footHindToeRoll_LOC.rotateX")
mc.connectAttr(orientString+"foot_ctrl.TipRoll", orientString + "footHindBallRoll_LOC.rotateX")
#Set up a knee controller
mc.curve(n=orientString+"knee_ctrl", p=[[-1.0, 0.0, 1.0], [1.0, 0.0, 1.0], [0.0, 0.0, -1.0], [-1.0, 0.0, 1.0]],d=1)
tempPC = mc.pointConstraint(orientString + legJNames[1] + "_jnt", orientString+"knee_ctrl")
mc.delete(tempPC)
mc.move(5 * scaleFactor/2, orientString + "knee_ctrl", z=True, r=False)
mc.poleVectorConstraint( orientString+"knee_ctrl", orientString + "upperLeg_ik")
if function == "tail":
#TAIL FUNCTION IS A WORK IN PROGRESS
for i in range(0, selSize, 1):
mc.rename(listObjs[i], "tail" + "% d_jnt" % num)
num += 1
def Rig(nameSpace='arm'):
#- get guides -
guides = [
'%s:link_start_gui' % nameSpace,
'%s:link_end_gui' % nameSpace,
'%s:link_up_gui' % nameSpace
]
#- make curve -
pathCurve = buildeCurve(guides[0], guides[1])
#- make up curve -
upvectorCurve = buidleUpCurve(*guides)
#- make Joints and locators-
Joints = []
locators = []
counts = mc.getAttr('%s.jointCount' % guides[0])
for i in range(counts):
#- 1 create
Joints.append(mc.createNode('joint'))
locators.append(mc.spaceLocator(p=(0, 0, 0))[0])
#- 2
parameter = (((float(i + 1) - 0) / (counts + 1 - 0)) * (1 - 0)) + 0
#- 3 attact to curve
attachToCurve(Joints[-1], pathCurve, parameter)
attachToCurve(locators[-1], upvectorCurve, parameter)
#- 4 connect object up
addUpObject(Joints[-1], locators[-1])
#- add rig Joins -
rigJoints = []
for i in range(4):
rigJoints.append(mc.createNode('joint'))
#- move
position = mc.pointOnCurve(pathCurve, pr=1.0 / 3 * i)
mc.move(position[0], position[1], position[2], rigJoints[-1], a=True)
#- orient
mc.delete(mc.orientConstraint(Joints[0], rigJoints[-1]))
#- bind Curve
mc.skinCluster(rigJoints, pathCurve)
mc.skinCluster(rigJoints, upvectorCurve)
#- rig rigJoints -
controlLst = []
for jnt in rigJoints:
#- make control
controls = [mc.createNode('transform') for i in range(4)]
for i in range(len(controls) - 1):
mc.parent(controls[i], controls[i + 1])
controlLst.append(controls)
#- match positions, parent Joint
mc.delete(mc.parentConstraint(jnt, controls[-1]))
mc.parent(jnt, controls[0])
#-add Shape
circle = mc.circle(nr=(1, 0, 0), ch=0)
mc.parent(mc.listRelatives(circle, s=True, path=True),
controls[0],
r=True,
s=True)
mc.delete(circle)
#-- comp hery --
curveGrp = mc.group(pathCurve, upvectorCurve)
jointGrp = mc.group(Joints)
locatorGrp = mc.group(locators)
controlGrp = mc.group([L[-1] for L in controlLst])
RootGrp = mc.group(curveGrp, jointGrp, locatorGrp, controlGrp)
#-- clean scene --
mc.hide(curveGrp, locatorGrp, rigJoints)
#-* rename *-
#- groups -
curveGrp = mc.rename(curveGrp, '%s_cusg_0' % nameSpace)
jointGrp = mc.rename(jointGrp, '%s_jntg_0' % nameSpace)
locatorGrp = mc.rename(locatorGrp, '%s_locg_0' % nameSpace)
controlGrp = mc.rename(controlGrp, '%s_ctlg_0' % nameSpace)
RootGrp = mc.rename(RootGrp, '%s_setg_0' % nameSpace)
#- joints -
for i, jnt in enumerate(Joints):
Joints[i] = mc.rename(jnt,
'%s_bnd%s_0' % (nameSpace, string.uppercase[i]))
#- locators -
for i, loc in enumerate(locators):
locators[i] = mc.rename(
loc, '%s_loc%s_0' % (nameSpace, string.uppercase[i]))
#- rig Joints -
for i, jnt in enumerate(rigJoints):
rigJoints[i] = mc.rename(
jnt, '%s_ctj%s_0' % (nameSpace, string.uppercase[i]))
#- control -
ctlType = ('ctl', 'ctu', 'cth', 'ctg')
for i, ctls in enumerate(controlLst):
for d, ctl in enumerate(ctls):
controlLst[i][d] = mc.rename(
ctl,
'%s%s_%s_0' % (nameSpace, string.uppercase[i], ctlType[d]))
#- curve -
pathCurve = mc.rename(pathCurve, '%s_TWbaseCus_0' % nameSpace)
upvectorCurve = mc.rename(upvectorCurve, '%s_TWupperCus_0' % nameSpace)
def createArm(uparmJnts=8, lowarmJnts=8):
"""""" """""" """""" """""" """""" """
El reto del brazo comienza. Enfrentate a el
con denuedo y determinacion. Confia en ti mismo y todo saldra
a pedir de Yume
Notas:
rotacion Z -58.251
Ha habido un problema con la orientacion del pole del arm_l_skn. Lo he arreglado seteand
atributos pero no garantiza que eso vaya a ser estable. OJO
hay que cambiar los skn por jnts para no confundirlos de los skn en el twist
Lista de locators que vas a necesitar:
clavicle_loc_END_autoRig
lowerArm_loc_autoRig
hand_loc_autoRig
ARM~~ARM~~ARM
""" """""" """""" """""" """""" """"""
brazo = ['shoulder', 'hand', 'elbow']
generalC = "general_c_ctr"
tw = 'twist'
Tv = 'twistValue'
Nr = 'nonRoll'
vectores = ['X', 'Y', 'Z']
shoulderLocPos = cmds.getAttr('clavicle_l_loc_END_autoRig.translate')
elbowLocPos = cmds.getAttr('lowerArm_l_loc_autoRig.translate')
handLocPos = cmds.getAttr('hand_loc_autoRig.translate')
cmds.joint(n='shoulder_l_skn', rad=0.1)
cmds.select(cl=True)
cmds.joint(n='elbow_l_skn', rad=0.1)
cmds.select(cl=True)
cmds.joint(n='elbow_l_End', rad=0.1)
cmds.xform('shoulder_l_skn', t=shoulderLocPos[0])
cmds.xform('elbow_l_skn', t=elbowLocPos[0])
cmds.xform('elbow_l_End', t=handLocPos[0])
cmds.parent('elbow_l_skn', 'shoulder_l_skn')
cmds.parent('elbow_l_End', 'elbow_l_skn')
side = ['l', 'r']
uA = 'shoulder_{}_skn'.format(side[0])
lA = 'elbow_{}_skn'.format(side[0])
cmds.mirrorJoint(uA, myz=True, mb=True, sr=['_l_', '_r_'])
cmds.joint(oj='xyz', sao='yup', e=True, ch=True)
hands = ['elbow_r_End', 'elbow_l_End']
for side in 'rl':
hnd = cmds.duplicate('elbow_{}_End'.format(side),
n='hand_{}_skn'.format(side),
po=True)
cmds.parent(hnd, w=True)
end = cmds.joint(n='hand_{}_End'.format(side), rad=0.05)
if side == 'l':
cmds.xform(end, t=(+0.25, 0, 0))
else:
cmds.xform(end, t=(-0.25, 0, 0))
cmds.joint(hnd, oj='xyz', sao='yup', e=True, ch=True)
cmds.pointConstraint('elbow_{}_End'.format(side), hnd)
#####################EQUACION DE LA ANTIVIDA PARA AGRUPAR###############
toGroup = ['hand_l_skn', 'hand_r_skn', 'shoulder_r_skn', 'shoulder_l_skn']
for element in toGroup:
pos = cmds.getAttr('{}.translate'.format(element))
grp = cmds.group(n='{}_offset'.format(str(element)), em=True)
cmds.xform(grp, t=pos[0], r=True)
cmds.parent(element, grp)
cmds.parent(grp, 'skeleton_c_grp')
#6.2. Creacion del ikHandle de la cadena principal
for side in 'rl':
cmds.select('shoulder_{}_skn'.format(side))
cmds.select('elbow_{}_End'.format(side), add=True)
ikH = cmds.ikHandle(n='arm_{}_ikHandle'.format(side),
sol='ikRPsolver',
s='sticky')
cmds.group(n='rig_arm_{}_grp'.format(side))
polX = cmds.getAttr('arm_r_ikHandle.poleVectorX')
polY = cmds.getAttr('arm_r_ikHandle.poleVectorY')
polZ = cmds.getAttr('arm_r_ikHandle.poleVectorZ')
cmds.setAttr('arm_l_ikHandle.poleVectorX', polX)
cmds.setAttr('arm_l_ikHandle.poleVectorY', polY)
cmds.setAttr('arm_l_ikHandle.poleVectorZ', polZ)
'''''' '''''' '''''' ''''
6.3. Configuracion de los sistemas nonRoll
6.3.1 Configuracion de la cadena NonRoll del Shoulde
'''
arms = ['shoulder_l_skn', 'shoulder_r_skn']
for side in 'rl':
arm = 'shoulder_{}_skn'.format(side)
nonRoll = cmds.duplicate(arm,
n='shoulder_{}_nonRoll'.format(side),
rc=True)
rollList = cmds.listRelatives(nonRoll, allDescendents=True)
cmds.delete(rollList[:2])
cmds.parent('shoulder_{}_nonRoll'.format(side), w=True)
cmds.rename(rollList[-1], 'shoulder_{}_nonRoll_End'.format(side))
cmds.group(n='shoulder_{}_nonRoll_grp'.format(side), em=True)
cmds.parent('shoulder_{}_nonRoll'.format(side),
'shoulder_{}_nonRoll_grp'.format(side))
#Creacion del Ik
ik = 'shoulder_{}_nonRoll'.format(side)
cmds.select(ik)
cmds.select('shoulder_{}_{}_End'.format(side, Nr))
nRH = cmds.ikHandle(n='shoulder_{}_ikHandle_{}'.format(side, Nr),
sol='ikSCsolver',
s='sticky')
cmds.parent(nRH[0], 'shoulder_{}_{}_grp'.format(side, Nr))
for a in 'XYZ':
cmds.setAttr(
'shoulder_{}_ikHandle_{}.poleVector{}'.format(side, Nr, a), 0)
#Creacion del pointConstraint
cmds.pointConstraint(
'shoulder_{}_skn'.format(side),
ik,
n='pointConstraint_{}_shoulderToNonRoll'.format(side))
cmds.pointConstraint(
'elbow_{}_skn'.format(side),
'shoulder_{}_ikHandle_{}'.format(side, Nr),
n='pointConstraint_{}_elbowToikHandle'.format(side))
cmds.parent('shoulder_{}_nonRoll_grp'.format(side),
'rig_arm_{}_grp'.format(side))
p = cmds.group(n='shoulder_{}_rollSystem'.format(side), em=True)
cmds.parent(p, 'rig_arm_{}_grp'.format(side))
cmds.parent('shoulder_{}_nonRoll_grp'.format(side), p)
'''
6.3.2 Configuracion de la cadena NonRoll del Elbow
'''
elbow = ['elbow_l_skn', 'elbow_r_skn']
for arm in elbow:
nonRoll = cmds.duplicate(arm,
n='elbow_{}_nonRoll'.format(arm[6]),
rc=True)
rollList = cmds.listRelatives(nonRoll, allDescendents=True)
cmds.delete(rollList[1])
cmds.parent('elbow_{}_nonRoll'.format(arm[6]), w=True)
cmds.rename(rollList[0], 'elbow_{}_nonRoll_End'.format(arm[6]))
cmds.group(n='elbow_l_nonRoll_grp', em=True)
cmds.parent('elbow_l_nonRoll', 'elbow_l_nonRoll_grp')
cmds.group(n='elbow_r_nonRoll_grp', em=True)
cmds.parent('elbow_r_nonRoll', 'elbow_r_nonRoll_grp')
ik2 = ['elbow_r_nonRoll', 'elbow_l_nonRoll']
for i in ik2: #Creacion del Ik
cmds.select(i)
cmds.select('elbow_{}_nonRoll_End'.format(i[6]))
nRH = cmds.ikHandle(n='elbow_{}_ikHandle_{}'.format(i[6], Nr),
sol='ikSCsolver',
s='sticky')
cmds.parent(nRH[0], 'elbow_{}_{}_grp'.format(i[6], Nr))
for a in vectores:
cmds.setAttr(
'elbow_{}_ikHandle_{}.poleVector{}'.format(i[6], Nr, a), 0)
for i in ik2: #Creacion del pointConstraint
cmds.pointConstraint(
'elbow_{}_skn'.format(i[6]),
i,
n='pointConstraint_{}_shoulderENDToNonRoll'.format(i[6]))
cmds.pointConstraint('hand_{}_skn'.format(i[6]),
'elbow_{}_ikHandle_nonRoll'.format(i[6]),
n='pointConstraint_{}_elbowENDToikHandle'.format(
i[6]))
'''''' '''
Global Sclae a los Non Roll
grupos de rollSystem de elbow
''' ''''''
for side in 'rl':
k = cmds.group(n='elbow_{}_rollSystem'.format(side), em=True)
cmds.parent(k, 'rig_arm_{}_grp'.format(side))
cmds.parent('elbow_{}_{}_grp'.format(side, Nr), k)
nonRollArm = [
'shoulder_l_rollSystem', 'elbow_l_rollSystem', 'shoulder_r_rollSystem',
'elbow_r_rollSystem'
]
for r in nonRollArm:
for a in vectores:
cmds.connectAttr('general_c_ctr.GlobalScale',
'{}.scale{}'.format(r, a))
#TwistValue
cmds.duplicate('shoulder_l_nonRoll_End', n='elbow_l_twistValue')
tvL = 'elbow_l_twistValue'
cmds.setAttr('elbow_l_twistValue.jointOrientX', 0)
cmds.parent(tvL, 'elbow_l_skn')
cmds.duplicate('shoulder_r_nonRoll_End', n='elbow_r_twistValue')
tvR = 'elbow_r_twistValue'
cmds.parent(tvR, 'elbow_r_skn')
tiwstValues = [tvL, tvR]
for indent in 'rl':
cmds.aimConstraint('hand_{}_skn'.format(indent),
'elbow_{}_twistValue'.format(indent),
aim=[1, 0, 0],
u=[0, 1, 0],
wu=[0, 1, 0],
n='elbow_{}_twistValue_elbowToHand'.format(indent),
wuo='elbow_{}_nonRoll'.format(indent),
wut="objectrotation",
mo=True)
cmds.parentConstraint(
'shoulder_r_nonRoll',
'elbow_r_nonRoll_grp',
mo=True,
n='parentConstraint_r_nonRoll_shoulderToelbowNonRollGrp')
cmds.parentConstraint(
'shoulder_l_nonRoll',
'elbow_l_nonRoll_grp',
mo=True,
n='parentConstraint_l_nonRoll_shoulderToelbowNonRollGrp')
'''
6.3.3 Configuracion de la cadena NonRoll del Hand
'''
for side in 'rl':
handNonRoll = cmds.duplicate('hand_{}_skn'.format(side),
n='hand_{}_nonRoll'.format(side),
rc=True)
handNonRollList = cmds.listRelatives(handNonRoll)
cmds.rename(handNonRollList[0], 'hand_{}_nonRoll_End'.format(side))
cmds.delete(handNonRollList[1])
cmds.group(n='hand_{}_nonRoll_grp'.format(side), em=True, w=True)
cmds.parent('hand_{}_nonRoll'.format(side),
'hand_{}_nonRoll_grp'.format(side))
cmds.parent('hand_{}_nonRoll_grp'.format(side),
'elbow_{}_rollSystem'.format(side))
cmds.select('hand_{}_nonRoll'.format(side))
cmds.select('hand_{}_{}_End'.format(side, Nr))
nRH = cmds.ikHandle(n='hand_{}_ikHandle_{}'.format(side, Nr),
sol='ikSCsolver',
s='sticky')
cmds.parent(nRH[0], 'hand_{}_{}_grp'.format(side, Nr))
for a in vectores:
cmds.setAttr(
'hand_{}_ikHandle_{}.poleVector{}'.format(side, Nr, a), 0)
cmds.pointConstraint(
'hand_{}_skn'.format(side),
'hand_{}_{}'.format(side, Nr),
n='pointConstraint_{}_handNonRollToHandSkn'.format(side))
cmds.pointConstraint(
'hand_{}_End'.format(side),
'hand_{}_ikHandle_{}'.format(side, Nr),
n='pointConstraint_{}_handENDToHandikHandle'.format(side))
#twistValue
h = cmds.duplicate('hand_{}_skn'.format(side),
n='hand_{}_{}'.format(side, Tv),
rc=True)
handList = cmds.listRelatives(h)
cmds.delete(handList[0])
cmds.delete(handList[1])
cmds.parent('hand_{}_{}'.format(side, Tv), 'hand_{}_skn'.format(side))
cmds.aimConstraint(
'hand_{}_End'.format(side),
'hand_{}_{}'.format(side, Tv),
n='aimConstraint_{}_twistValue_handTohandTwistValue'.format(side),
wuo='hand_{}_nonRoll'.format(side),
wut="objectrotation",
mo=False)
###
cmds.parentConstraint(
'elbow_{}_skn'.format(side),
'hand_{}_nonRoll_grp'.format(side),
mo=True,
n='eseParentQueNosCostoEncontratTanto_{}_pc'.format(side))
'''
~~~~CADENA TWIST JOINTS~~~~
1) upperARM
a)jointChain
i) Left
ii) Right
b)ikSpline
i) Left
ii) Right
2) foreARM
a)jointChain
i) Left
ii) Right
b)ikSpline
i) Left
ii) Right
'''
cmds.select(cl=True)
# upperARM - jointChain - LEFT
def upperArmJointLeft(cantidad, nombre, chin, radio):
inicio = 'clavicle_l_loc_END_autoRig'
fin = 'lowerArm_l_loc_autoRig'
start_point = cmds.xform(inicio, q=True, t=True)
end_point = cmds.xform(fin, q=True, t=True)
vector_sta = OpenMaya.MVector(start_point)
vector_end = OpenMaya.MVector(end_point)
i = 0
all_joints = []
for num in range(cantidad):
dif_point = vector_end - vector_sta
offset = 1.0 / (cantidad - 1)
new_point = dif_point * offset
final_point = vector_sta + new_point
mid_pos = dif_point * (offset * num)
final_pos = vector_sta + mid_pos
jnt = cmds.joint(n=nombre + str(i), p=list(final_pos), rad=radio)
if i != 0:
cmds.joint(all_joints[i - 1],
e=True,
zso=True,
oj='xyz',
sao='yup',
rad=radio)
i += 1
all_joints.append(jnt)
if chin == False:
cmds.select(cl=1)
if i == cantidad:
return all_joints
upperArmJointLeft(uparmJnts, 'upperArm_l_skn', chin=True, radio=0.1)
cmds.rename('upperArm_l_skn0', 'upperArm_l_skn')
foreArmJointList = cmds.listRelatives('upperArm_l_skn',
allDescendents=True)
foreArmJointList.append('upperArm_l_skn')
cmds.rename(foreArmJointList[0], 'upperArm_l_End')
cmds.select(cl=True)
# upperARM - jointChain - RIGHT
def upperArmJointRight(cantidad, nombre, chin, radio):
inicio = 'shoulder_r_nonRoll'
fin = 'elbow_r_nonRoll'
start_point = cmds.xform(inicio, q=True, t=True)
end_point = cmds.xform(fin, q=True, t=True)
vector_sta = OpenMaya.MVector(start_point)
vector_end = OpenMaya.MVector(end_point)
i = 0
all_joints = []
for num in range(cantidad):
dif_point = vector_end - vector_sta
offset = 1.0 / (cantidad - 1)
new_point = dif_point * offset
final_point = vector_sta + new_point
mid_pos = dif_point * (offset * num)
final_pos = vector_sta + mid_pos
jnt = cmds.joint(n=nombre + str(i), p=list(final_pos), rad=radio)
if i != 0:
cmds.joint(all_joints[i - 1],
e=True,
zso=True,
oj='xyz',
sao='yup',
rad=radio)
i += 1
all_joints.append(jnt)
if chin == False:
cmds.select(cl=1)
if i == cantidad:
return all_joints
upperArmJointRight(uparmJnts, 'upperArm_r_skn', chin=True, radio=0.1)
cmds.rename('upperArm_r_skn0', 'upperArm_r_skn')
foreArmJointList = cmds.listRelatives('upperArm_r_skn',
allDescendents=True)
foreArmJointList.append('upperArm_r_skn')
cmds.rename(foreArmJointList[0], 'upperArm_r_End')
# upperARM - ikSpline - LEFT
def upperArmIkSplineLeft():
cmds.ikHandle(n='upperArm_l_ikHandle_{}'.format(tw),
sj='upperArm_l_skn',
ee='upperArm_l_End',
sol='ikSplineSolver')
c = cmds.rename('curve1', 'upperArm_l_ikHandle_curve_{}'.format(tw))
cmds.parent('upperArm_l_ikHandle_curve_{}'.format(tw), 'rig_arm_l_grp')
cmds.parent('upperArm_l_ikHandle_{}'.format(tw),
'shoulder_l_rollSystem')
upperArmIkSplineLeft()
cmds.parent('upperArm_l_skn', 'shoulder_l_rollSystem')
# upperARM - ikSpline - RIGHT
def upperArmIkSplineRight():
cmds.ikHandle(n='upperArm_r_ikHandle_{}'.format(tw),
sj='upperArm_r_skn',
ee='upperArm_r_End',
sol='ikSplineSolver')
cmds.rename('curve1', 'upperArm_r_ikHandle_curve_{}'.format(tw))
cmds.parent('upperArm_r_ikHandle_curve_{}'.format(tw), 'rig_arm_r_grp')
cmds.parent('upperArm_r_ikHandle_{}'.format(tw),
'shoulder_r_rollSystem')
upperArmIkSplineRight()
cmds.parent('upperArm_r_skn', 'shoulder_r_rollSystem')
cmds.select(cl=True)
# foreARM - jointChain - LEFT
def foreArmJointLeft(cantidad, nombre, chin, radio):
inicio = 'lowerArm_l_loc_autoRig'
fin = 'hand_loc_autoRig'
start_point = cmds.xform(inicio, q=True, t=True)
end_point = cmds.xform(fin, q=True, t=True)
vector_sta = OpenMaya.MVector(start_point)
vector_end = OpenMaya.MVector(end_point)
i = 0
all_joints = []
for num in range(cantidad):
dif_point = vector_end - vector_sta
offset = 1.0 / (cantidad - 1)
new_point = dif_point * offset
final_point = vector_sta + new_point
mid_pos = dif_point * (offset * num)
final_pos = vector_sta + mid_pos
jnt = cmds.joint(n=nombre + str(i), p=list(final_pos), rad=radio)
if i != 0:
cmds.joint(all_joints[i - 1],
e=True,
zso=True,
oj='xyz',
sao='yup',
rad=radio)
i += 1
all_joints.append(jnt)
if chin == False:
cmds.select(cl=1)
if i == cantidad:
return all_joints
foreArmJointLeft(lowarmJnts, 'foreArm_l_skn', chin=True, radio=0.1)
cmds.rename('foreArm_l_skn0', 'foreArm_l_skn')
foreArmJointList = cmds.listRelatives('foreArm_l_skn', allDescendents=True)
foreArmJointList.append('foreArm_l_skn')
cmds.rename(foreArmJointList[0], 'foreArm_l_End')
cmds.parent('foreArm_l_skn', 'elbow_l_skn')
# foreARM - jointChain - RIGHT
cmds.select(cl=True)
def foreArmJointRight(cantidad, nombre, chin, radio):
inicio = 'elbow_r_nonRoll'
fin = 'hand_r_nonRoll'
start_point = cmds.xform(inicio, q=True, t=True)
end_point = cmds.xform(fin, q=True, t=True)
vector_sta = OpenMaya.MVector(start_point)
vector_end = OpenMaya.MVector(end_point)
i = 0
all_joints = []
for num in range(cantidad):
dif_point = vector_end - vector_sta
offset = 1.0 / (cantidad - 1)
new_point = dif_point * offset
final_point = vector_sta + new_point
mid_pos = dif_point * (offset * num)
final_pos = vector_sta + mid_pos
jnt = cmds.joint(n=nombre + str(i), p=list(final_pos), rad=radio)
if i != 0:
cmds.joint(all_joints[i - 1],
e=True,
zso=True,
oj='xyz',
sao='yup',
rad=radio)
i += 1
all_joints.append(jnt)
if chin == False:
cmds.select(cl=1)
if i == cantidad:
return all_joints
foreArmJointRight(lowarmJnts, 'foreArm_r_skn', chin=True, radio=0.1)
cmds.rename('foreArm_r_skn0', 'foreArm_r_skn')
foreArmJointList = cmds.listRelatives('foreArm_r_skn', allDescendents=True)
foreArmJointList.append('foreArm_r_skn')
cmds.rename(foreArmJointList[0], 'foreArm_r_End')
cmds.parent('foreArm_r_skn', 'elbow_r_skn')
# foreARM - ikSpline - LEFT
def foreArmIkSplineLeft():
cmds.ikHandle(n='foreArm_l_ikHandle_{}'.format(tw),
sj='foreArm_l_skn',
ee='foreArm_l_End',
sol='ikSplineSolver')
cmds.rename('curve1', 'foreArm_l_ikHandle_curve_{}'.format(tw))
cmds.parent('foreArm_l_ikHandle_curve_{}'.format(tw), 'rig_arm_l_grp')
cmds.parent('foreArm_l_ikHandle_{}'.format(tw), 'elbow_l_rollSystem')
foreArmIkSplineLeft()
# foreARM - ikSpline - RIGHT
side = 'rl'
def foreArmIkSplineRight():
cmds.ikHandle(n='foreArm_r_ikHandle_{}'.format(tw),
sj='foreArm_r_skn',
ee='foreArm_r_End',
sol='ikSplineSolver')
cmds.rename('curve1', 'foreArm_r_ikHandle_curve_{}'.format(tw))
cmds.parent('foreArm_r_ikHandle_curve_{}'.format(tw), 'rig_arm_r_grp')
cmds.parent('foreArm_r_ikHandle_{}'.format(tw), 'elbow_r_rollSystem')
foreArmIkSplineRight()
# twistUpperArm - nodos
def twistUpperArm():
for i in side:
elbowValeu = 'elbow_{}_{}'.format(i, Tv)
shoulderHandle = 'upperArm_{}_ikHandle_twist'.format(i)
multMenusUno = cmds.shadingNode('multDoubleLinear',
n='{}_{}_{}_multMenusUno'.format(
'Shoulder', Tv, i),
au=True)
cmds.connectAttr('{}.rotateX'.format(elbowValeu),
'{}.input1'.format(multMenusUno))
cmds.setAttr('{}.input2'.format(multMenusUno), -1)
cmds.connectAttr('{}.output'.format(multMenusUno),
'{}.twist'.format(shoulderHandle))
twistUpperArm()
def twistForeArm():
for i in side:
handValeu = 'hand_{}_{}'.format(i, Tv)
shandHandle = 'foreArm_{}_ikHandle_twist'.format(i)
multMenusUno = cmds.shadingNode('multDoubleLinear',
n='{}_{}_{}_multMenusUno'.format(
'Elbow', Tv, i),
au=True)
cmds.connectAttr('{}.rotateX'.format(handValeu),
'{}.input1'.format(multMenusUno))
cmds.setAttr('{}.input2'.format(multMenusUno), -1)
cmds.connectAttr('{}.output'.format(multMenusUno),
'{}.twist'.format(shandHandle))
twistForeArm()
'''
Colocacion de controles:
Hand_l_IK
FKs
Pole
'''
for i in 'rl':
ikOff = 'handIKCtr_{}_offset'.format(i)
handOff = 'handFKCtr_{}_offset'.format(i)
shoulderOff = 'shoulderFKCtr_{}_offset'.format(i)
elbowOff = 'elbowFKCtr_{}_offset'.format(i)
armSettingsOff = 'armSettingsCtr_{}_offset'.format(i)
handPos = cmds.xform('hand_{}_nonRoll'.format(i),
ws=True,
q=True,
t=True)
shouldePos = cmds.xform('shoulder_{}_nonRoll'.format(i),
ws=True,
q=True,
t=True)
elbowPos = cmds.xform('elbow_{}_nonRoll'.format(i),
ws=True,
q=True,
t=True)
cmds.xform(ikOff, ws=True, t=handPos)
cmds.xform(handOff, ws=True, t=handPos)
cmds.xform(shoulderOff, ws=True, t=shouldePos)
cmds.xform(elbowOff, ws=True, t=elbowPos)
cmds.parent(armSettingsOff, 'hand_{}_nonRoll_End'.format(i))
for a in vectores:
cmds.setAttr('{}.translate{}'.format(armSettingsOff, a), 0)
if i == 'l':
cmds.setAttr('{}.translateX'.format(armSettingsOff), 30)
else:
cmds.setAttr('{}.translateX'.format(armSettingsOff), -30)
cmds.parentConstraint('hand_{}_skn'.format(i),
armSettingsOff,
mo=True,
n='parentConstraint_{}_ArmSettingsParent')
####
def poleLocation():
from maya import cmds, OpenMaya
import math
for i in side:
start = cmds.xform('shoulder_{}_skn'.format(i), q=1, ws=1, t=1)
mid = cmds.xform('elbow_{}_skn'.format(i), q=1, ws=1, t=1)
end = cmds.xform('elbow_{}_End'.format(i), q=1, ws=1, t=1)
startV = OpenMaya.MVector(start[0], start[1], start[2])
midV = OpenMaya.MVector(mid[0], mid[1], mid[2])
endV = OpenMaya.MVector(end[0], end[1], end[2])
startEnd = endV - startV
startMid = midV - startV
dotP = startMid * startEnd
proj = float(dotP) / float(startEnd.length())
startEndN = startEnd.normal()
projV = startEndN * proj
arrowV = startMid - projV
arrowV *= 0.5
finalV = arrowV + midV
cross1 = startEnd ^ startMid
cross1.normalize()
cross2 = cross1 ^ arrowV
cross2.normalize()
arrowV.normalize()
matrixV = [
arrowV.x, arrowV.y, arrowV.z, 0, cross1.x, cross1.y, cross1.z,
0, cross2.x, cross2.y, cross2.z, 0, 0, 0, 0, 1
]
matrixM = OpenMaya.MMatrix()
OpenMaya.MScriptUtil.createMatrixFromList(matrixV, matrixM)
matrixFn = OpenMaya.MTransformationMatrix(matrixM)
rot = matrixFn.eulerRotation()
loc = 'armPoleCtr_{}_offset'.format(i)
cmds.xform(loc, ws=1, t=(finalV.x, finalV.y, finalV.z))
cmds.xform(loc,
ws=1,
rotation=((rot.x / math.pi * 180.0),
(rot.y / math.pi * 180.0),
(rot.z / math.pi * 180.0)))
poleLocation()
'''
Parent de Controles:
PACs
Parent Constrains
PoleVector Constraints
Orient Cosntraints (FK)
'''
for i in 'rl':
for partes in brazo:
PAC = cmds.duplicate('{}_{}_skn'.format(partes, i),
n='{}_{}_skn_PAC'.format(partes, i),
rc=True)
PAClist = cmds.listRelatives(PAC, ad=True)
for huesoDeParent in PAClist:
cmds.delete(huesoDeParent)
cmds.parent('{}_{}_skn_PAC'.format(partes, i),
'{}FK_{}_ctr'.format(partes, i))
PACdeIK = cmds.duplicate('hand_{}_skn_PAC'.format(i),
n='hand_IK_{}_skn_PAC'.format(i))
cmds.parent(PACdeIK, 'handIK_{}_ctr'.format(i))
cmds.pointConstraint(PACdeIK,
'arm_{}_ikHandle'.format(i),
n='pointConstraint_{}_PACofTheArmIK'.format(i))
cmds.poleVectorConstraint(
'armPole_{}_ctr'.format(i),
'arm_{}_ikHandle'.format(i),
n='poleVectorConstraint_{}_PoleofTheArmIK'.format(i))
for partes in brazo:
if partes != 'hand':
cmds.orientConstraint(
'{}_{}_skn_PAC'.format(partes, i),
'{}_{}_skn'.format(partes, i),
n='orientConstraint_{}_{}PACto{}sknFK'.format(
i, partes, partes))
else:
cmds.orientConstraint(
'{}_{}_skn_PAC'.format(partes, i),
'{}_IK_{}_skn_PAC'.format(partes, i),
'{}_{}_skn'.format(partes, i),
n='orientConstraint_{}_{}PACto{}sknFKandIK'.format(
i, partes, partes))
'''
Nodos:
Switch FK/IK
'''
for i in 'rl':
armSettings = 'armSettings_{}_ctr'.format(i)
ikH = 'arm_{}_ikHandle'.format(i)
cmds.connectAttr('{}.Arm_IK'.format(armSettings),
'{}.ikBlend'.format(ikH))
reverse = cmds.shadingNode('reverse',
au=True,
n='armSettings_{}_reverse'.format(i))
cmds.connectAttr('{}.Arm_IK'.format(armSettings),
'{}.inputY'.format(reverse))
cmds.connectAttr(
'{}.outputY'.format(reverse),
'orientConstraint_{}_handPACtohandsknFKandIK.hand_{}_skn_PACW0'.
format(i, i))
cmds.connectAttr(
'{}.Arm_IK'.format(armSettings),
'orientConstraint_{}_handPACtohandsknFKandIK.hand_IK_{}_skn_PACW1'.
format(i, i))
cmds.connectAttr('{}.Arm_IK'.format(armSettings),
'handIK_{}_ctr.visibility'.format(i))
for segmentos in brazo:
cmds.connectAttr('{}.outputY'.format(reverse),
'{}FK_{}_ctr.visibility'.format(segmentos, i))
'''
Nodos:
Stretch
'''
for i in 'rl':
for partes in brazo:
loc = cmds.spaceLocator(n='stretch{}_{}_loc'.format(partes, i))
cmds.parent(loc, '{}_{}_skn'.format(partes, i))
for a in vectores:
cmds.setAttr('{}.translate{}'.format(loc[0], a), 0)
if partes == 'shoulder':
cmds.parent(loc, 'clavicle_{}_END'.format(i))
elif partes == 'elbow':
cmds.parent(loc, 'armPole_{}_ctr'.format(i))
else:
cmds.parent(loc, 'handIK_{}_ctr'.format(i))
def stretchArm():
for i in 'rl':
shoulder = 'stretchshoulder_{}_locShape'.format(i)
elbow = 'stretchelbow_{}_locShape'.format(i)
hand = 'stretchhand_{}_locShape'.format(i)
up = cmds.shadingNode('distanceBetween',
n='upArm_{}_distance'.format(i),
au=True)
entire = cmds.shadingNode('distanceBetween',
n='entireArm_{}_distance'.format(i),
au=True)
low = cmds.shadingNode('distanceBetween',
n='lowArm_{}_distance'.format(i),
au=True)
cmds.connectAttr('{}.worldPosition'.format(shoulder),
'{}.point1'.format(up))
cmds.connectAttr('{}.worldPosition'.format(elbow),
'{}.point2'.format(up))
cmds.connectAttr('{}.worldPosition'.format(shoulder),
'{}.point1'.format(entire))
cmds.connectAttr('{}.worldPosition'.format(hand),
'{}.point2'.format(entire))
cmds.connectAttr('{}.worldPosition'.format(elbow),
'{}.point1'.format(low))
cmds.connectAttr('{}.worldPosition'.format(hand),
'{}.point2'.format(low))
nod = [up, entire, low]
for o in nod:
div = cmds.shadingNode('multiplyDivide',
n='{}_{}_normalStretch'.format(
o[:-11], i),
au=True)
cmds.setAttr('{}.operation'.format(div), 2)
cmds.connectAttr('{}.distance'.format(o),
'{}.input1Y'.format(div))
dis = cmds.getAttr('{}.distance'.format(o))
cmds.setAttr('{}.input2Y'.format(div), dis)
clamp = cmds.shadingNode('clamp',
n='armStretch_{}_clamp'.format(i),
au=True)
cmds.setAttr('{}.maxG'.format(clamp), 999)
cmds.connectAttr(
'{}_{}_normalStretch.outputY'.format(entire[:-11], i),
'{}.inputG'.format(clamp))
cmds.connectAttr('general_c_ctr.GlobalScale',
'{}.minG'.format(clamp))
blen = cmds.shadingNode('blendColors',
n='armStretch_pinElbow_{}_blend'.format(i),
au=True)
blenF = cmds.shadingNode('blendColors',
n='armStretch_FINAL_{}_blend'.format(i),
au=True)
blenS = cmds.shadingNode(
'blendColors',
n='armStretch_stretchiness_{}_blend'.format(i),
au=True)
dive = cmds.shadingNode(
'multiplyDivide',
n='armStretch_stretchByGlobal_{}_div'.format(i),
au=True)
rever = 'armSettings_{}_reverse'.format(i)
#Blen
cmds.connectAttr(
'{}_{}_normalStretch.{}'.format('upArm', i, 'outputY'),
'{}.color1G'.format(blen))
cmds.connectAttr('{}.{}'.format(clamp, 'outputG'),
'{}.color2G'.format(blen))
cmds.connectAttr('{}.{}'.format(clamp, 'outputG'),
'{}.color2B'.format(blen))
cmds.connectAttr(
'{}_{}_normalStretch.{}'.format('lowArm', i, 'outputY'),
'{}.color1B'.format(blen))
#BlenF
cmds.connectAttr('{}.outputG'.format(blen),
'{}.color1G'.format(blenF))
cmds.connectAttr('{}.outputB'.format(blen),
'{}.color1B'.format(blenF))
cmds.connectAttr('armSettings_{}_ctr.Arm_IK'.format(i),
'{}.blender'.format(blenF))
#BlenS
cmds.connectAttr('{}.outputG'.format(blenF),
'{}.color1G'.format(blenS))
cmds.connectAttr('{}.outputB'.format(blenF),
'{}.color1B'.format(blenS))
cmds.connectAttr('{}.GlobalScale'.format(generalC),
'{}.color2G'.format(blenS))
cmds.connectAttr('{}.GlobalScale'.format(generalC),
'{}.color2B'.format(blenS))
#Dive
cmds.setAttr('{}.operation'.format(dive), 2)
cmds.connectAttr('{}.outputG'.format(blenS),
'{}.input1Y'.format(dive))
cmds.connectAttr('{}.outputB'.format(blenS),
'{}.input1Z'.format(dive))
cmds.connectAttr('{}.GlobalScale'.format(generalC),
'{}.input2Y'.format(dive))
cmds.connectAttr('{}.GlobalScale'.format(generalC),
'{}.input2Z'.format(dive))
cmds.connectAttr('{}.outputY'.format(dive),
'shoulder_{}_skn.scaleX'.format(i))
cmds.connectAttr('{}.outputZ'.format(dive),
'elbow_{}_skn.scaleX'.format(i))
############################## Conexion Control Blender de BlenS
plusMinus = cmds.shadingNode(
'plusMinusAverage',
n='arm_autoStretchOverride_{}_sum'.format(i),
au=True)
clampPlusMinus = cmds.shadingNode(
'clamp',
n='arm_autoStretchOverride_{}_clamp'.format(i),
au=True)
cmds.setAttr('{}.maxG'.format(clampPlusMinus), 1)
cmds.connectAttr('{}.outputY'.format(rever),
'{}.input2D[0].input2Dy'.format(plusMinus))
cmds.connectAttr('handIK_{}_ctr.AutoStretch'.format(i),
'{}.input2D[1].input2Dy'.format(plusMinus))
cmds.connectAttr('{}.output2Dy'.format(plusMinus),
'{}.inputG'.format(clampPlusMinus))
cmds.connectAttr('{}.outputG'.format(clampPlusMinus),
'{}.blender'.format(blenS))
############################## Conexion Control de ColorG y colorB de BlenF
multDivUp = cmds.shadingNode(
'multiplyDivide',
n='armShoulder_{}_StretchByGlobal_mult'.format(i),
au=True)
multDivLow = cmds.shadingNode(
'multiplyDivide',
n='armElbow_{}_StretchByGlobal_mult'.format(i),
au=True)
cmds.connectAttr('shoulderFK_{}_ctr.Stretch'.format(i),
'{}.input1Y'.format(multDivUp))
cmds.connectAttr('{}.GlobalScale'.format(generalC),
'{}.input2Y'.format(multDivUp))
cmds.connectAttr('elbowFK_{}_ctr.Stretch'.format(i),
'{}.input1Y'.format(multDivLow))
cmds.connectAttr('{}.GlobalScale'.format(generalC),
'{}.input2Y'.format(multDivLow))
cmds.connectAttr('{}.outputY'.format(multDivUp),
'{}.color2G'.format(blenF))
cmds.connectAttr('{}.outputY'.format(multDivLow),
'{}.color2B'.format(blenF))
######################## Blender Blen
multDivPin = cmds.shadingNode(
'multiplyDivide',
n='armShoulder_{}_PinElbow_mult'.format(i),
au=True)
cmds.connectAttr('armPole_{}_ctr.PinElbow'.format(i),
'{}.input1Y'.format(multDivPin))
cmds.connectAttr('armSettings_{}_ctr.Arm_IK'.format(i),
'{}.input2Y'.format(multDivPin))
cmds.connectAttr('{}.outputY'.format(multDivPin),
'{}.blender'.format(blen))
cmds.connectAttr('{}.outputY'.format(multDivPin),
'{}.input2D[2].input2Dy'.format(plusMinus))
stretchArm()
def stretchTwistArm():
for i in side:
cvUp = 'upperArm_{}_ikHandle_curve_twist'.format(i)
cvLow = 'foreArm_{}_ikHandle_curve_twist'.format(i)
cvInfUp = cmds.shadingNode(
'curveInfo',
n='upArm_stretchTwitch_{}_info'.format(i),
au=True)
cvInfLow = cmds.shadingNode(
'curveInfo',
n='lowArm_stretchTwitch_{}_info'.format(i),
au=True)
cmds.connectAttr('{}.worldSpace'.format(cvUp),
'{}.inputCurve'.format(cvInfUp))
cmds.connectAttr('{}.worldSpace'.format(cvLow),
'{}.inputCurve'.format(cvInfLow))
divUp = cmds.shadingNode('multiplyDivide',
n='lowArm_stretchTwitch_{}_div'.format(i),
au=True)
divGlobUp = cmds.shadingNode(
'multiplyDivide',
n='lowArm_stretchTwitchbuGlobal_{}_div'.format(i),
au=True)
divLow = cmds.shadingNode('multiplyDivide',
n='upArm_stretchTwitch_{}_div'.format(i),
au=True)
divGlobLow = cmds.shadingNode(
'multiplyDivide',
n='upArm_stretchTwitchbbyGlobal_{}_div'.format(i),
au=True)
u = [divUp, divGlobUp, divLow, divGlobLow]
for indent in u:
cmds.setAttr('{}.operation'.format(indent), 2)
lenghtUp = cmds.getAttr('{}.arcLength'.format(cvInfUp))
lengthLow = cmds.getAttr('{}.arcLength'.format(cvInfLow))
cmds.connectAttr('{}.arcLength'.format(cvInfUp),
'{}.input1Y'.format(divUp))
cmds.connectAttr('{}.arcLength'.format(cvInfLow),
'{}.input1Y'.format(divLow))
cmds.setAttr('{}.input2Y'.format(divUp), lenghtUp)
cmds.setAttr('{}.input2Y'.format(divLow), lengthLow)
cmds.connectAttr('{}.outputY'.format(divUp),
'{}.input1Y'.format(divGlobUp))
cmds.connectAttr('{}.outputY'.format(divLow),
'{}.input1Y'.format(divGlobLow))
cmds.connectAttr('{}.GlobalScale'.format('general_c_ctr'),
'{}.input2Y'.format(divGlobUp))
cmds.connectAttr('{}.GlobalScale'.format('general_c_ctr'),
'{}.input2Y'.format(divGlobLow))
k = ['upper', 'fore']
for part in k:
huesosTwist = cmds.listRelatives('{}Arm_{}_skn'.format(
part, i),
ad=True)
huesosTwist.append('{}Arm_{}_skn'.format(part, i))
for hueso in huesosTwist:
if part == 'upper':
cmds.connectAttr('{}.outputY'.format(divGlobUp),
'{}.scaleX'.format(hueso))
else:
cmds.connectAttr('{}.outputY'.format(divGlobLow),
'{}.scaleX'.format(hueso))
stretchTwistArm()
for side in 'rl':
cmds.pointConstraint(
'elbow_{}_skn'.format(side),
'elbowFKCtr_{}_offset'.format(side),
n='pointConstraint_{}_elbowStretchFK'.format(side))
cmds.pointConstraint('hand_{}_skn'.format(side),
'handFKCtr_{}_offset'.format(side),
n='pointConstraint_{}_handStretchFK'.format(side))
''''
ordenar el outliner
'''
cmds.parent('rig_arm_l_grp', 'rig_arm_r_grp', 'bodyRig_c_grp')
for side in 'rl':
PolePosition = cmds.getAttr(
'armPoleCtr_{}_offset.translateZ'.format(side))
cmds.setAttr('armPoleCtr_{}_offset.translateZ'.format(side),
(PolePosition - 1))
jntClavicle = 'clavicle_{}_skn'.format(side)
jntClavicleEnd = 'clavicle_{}_END'.format(side)
grpShoulderRollSystem = 'shoulder_{}_rollSystem'.format(side)
jntShoulderOffset = 'shoulder_{}_skn_offset'.format(side)
ctrShoulderFKOffset = 'shoulderFKCtr_{}_offset'.format(side)
fun.blendSystem(CurveU='upperArm_{}_ikHandle_curve_twist'.format(side),
CurveL='foreArm_{}_ikHandle_curve_twist'.format(side),
ClusterName='ClusterBlendSystem_Arm_{}_'.format(side),
upJnt='shoulder_{}_skn'.format(side),
middleJnt='elbow_{}_skn'.format(side),
upBlend='armUpBlend_{}_ctr'.format(side),
middleBlend='armMiddleBlend_{}_ctr'.format(side),
lowBlend='armLowBlend_{}_ctr'.format(side))
shoulderFKPcon = cmds.group(em=True,
n='shoulderFK_{}_pcon'.format(side))
pconShoulderMatrix = cmds.xform(ctrShoulderFKOffset,
q=True,
matrix=True,
ws=True)
cmds.xform(shoulderFKPcon, ws=True, matrix=pconShoulderMatrix)
cmds.parent(shoulderFKPcon, jntClavicleEnd)
cmds.parentConstraint(jntClavicle, grpShoulderRollSystem, mo=True)
cmds.pointConstraint(jntClavicleEnd, jntShoulderOffset, mo=False)
cmds.pointConstraint(shoulderFKPcon, ctrShoulderFKOffset, mo=False)
cmds.move(-50, 'armPoleCtr_{}_offset'.format(side), z=True)
cmds.connectAttr('armSettings_{}_ctr.Arm_IK'.format(side),
'armPole_{}_ctr.visibility'.format(side))
cmds.parent('armPoleCtr_{}_offset'.format(side), 'center_c_ctr')
cmds.rename('shoulder_{}_skn'.format(side),
'shoulder_{}_jnt'.format(side))
cmds.rename('elbow_{}_skn'.format(side), 'elbow_{}_jnt'.format(side))
cmds.parent('handFKCtr_{}_offset'.format(side),
'elbowFK_{}_ctr'.format(side))
cmds.parent('elbowFKCtr_{}_offset'.format(side),
'shoulderFK_{}_ctr'.format(side))
#Configuracion de los spaces
for side in 'rl':
pos = cmds.xform('handIK_{}_ctr'.format(side), ws=True, m=True, q=True)
w = cmds.group(em=True, n='handIK_{}_worldSpace'.format(side))
h = cmds.group(em=True, n='handIK_{}_headSpace'.format(side))
c = cmds.group(em=True, n='handIK_{}_chestSpace'.format(side))
p = cmds.group(em=True, n='handIK_{}_pelvisSpace'.format(side))
for i in [w, h, c, p]:
cmds.xform(i, ws=True, m=pos)
cmds.parent(w, 'general_c_ctr')
cmds.parent(h, 'head_c_ctr')
cmds.parent(c, 'chest_c_ctr')
cmds.parent(p, 'pelvis_c_ctr')
cmds.parentConstraint(w,
h,
c,
p,
'handIKCtr_{}_offset'.format(side),
mo=False,
n='spaceParentIKHand_{}_cns'.format(side))
cmds.connectAttr(
'handIK_{}_ctr.ChestSpace'.format(side),
'spaceParentIKHand_{}_cns.handIK_{}_chestSpaceW2'.format(
side, side))
cmds.connectAttr(
'handIK_{}_ctr.HeadSpace'.format(side),
'spaceParentIKHand_{}_cns.handIK_{}_headSpaceW1'.format(
side, side))
cmds.connectAttr(
'handIK_{}_ctr.HipSpace'.format(side),
'spaceParentIKHand_{}_cns.handIK_{}_pelvisSpaceW3'.format(
side, side))
clampSpace = fun.clampCreator(name='handIKSpace_{}_clamp'.format(side),
MaxR=1,
MinR=0)
fun.plusCreator(name='handIKSpace_{}_sum'.format(side),
InputX0='handIK_{}_ctr.ChestSpace'.format(side),
InputX1='handIK_{}_ctr.HeadSpace'.format(side),
InputX2='handIK_{}_ctr.HipSpace'.format(side),
OutputX='{}.inputR'.format(clampSpace))
reverseSpace = cmds.shadingNode('reverse',
au=True,
n='handIKSpace_{}_rev'.format(side))
cmds.connectAttr('{}.outputR'.format(clampSpace),
'{}.inputX'.format(reverseSpace))
cmds.connectAttr(
'{}.outputX'.format(reverseSpace),
'spaceParentIKHand_{}_cns.handIK_{}_worldSpaceW0'.format(
side, side))
#Correccion del fallo del twist del brazo
cmds.setAttr("elbow_l_twistValue_elbowToHand.offsetX", 0)
cmds.setAttr("elbow_l_twistValue.jointOrientX", 0)
cmds.parent('armMiddleBlendCtr_r_offset', 'skeleton_c_grp')
cmds.parent('armMiddleBlendCtr_l_offset', 'skeleton_c_grp')
cmds.parent('shoulderFKCtr_l_offset', 'handIKCtr_l_offset', 'center_c_ctr')
cmds.parent('shoulderFKCtr_r_offset', 'handIKCtr_r_offset', 'center_c_ctr')
for part in ['foreArm', 'upperArm']:
for side in 'rl':
foreArmList = cmds.listRelatives('{}_{}_skn'.format(part, side),
ad=True)
foreArmList.reverse()
i = 1
for element in foreArmList:
if 'skn' in element:
cmds.rename(element, '{}{}_{}_skn'.format(part, i, side))
i += 1
else:
pass
joints = cmds.ls(type='joint')
for jnt in joints:
if '_skn_PAC' in jnt:
newName = jnt.replace('_skn_PAC', '_PAC')
cmds.rename(jnt, newName)
else:
pass
def __init__(self,
node,
name='',
suffixOverride='',
parent='',
side='C',
operation=None,
skipNum=False,
shaderNode=False):
""" The creation function to create new nodes.
[Args]:
node (string) - The type of node to create
name (string) - The name of the new node
suffixOverride (string) - The optional override for the suffix
(Uses object type not custom string
e.g 'locator' or 'group')
parent (string) - The name of the object to parent the
new node to
side (string) - The side of the new node
operation (int) - The value of the new node's operation
attribute (if applicable)
skipNumber (bool) - Toggles whether or not to skip the number
if possible
"""
self.node = node
nodeName = setupName(
name if name else node,
obj=node if not suffixOverride else suffixOverride,
side=side,
skipNumber=skipNum)
if shaderNode:
if shaderNode == 'shader':
self.name = cmds.shadingNode(node,
n=nodeName,
ss=1,
asShader=1)
if shaderNode == 'texture':
self.name = cmds.shadingNode(node,
n=nodeName,
ss=1,
asTexture=1)
if shaderNode == 'utility':
self.name = cmds.shadingNode(node,
n=nodeName,
ss=1,
asUtility=1)
else:
if node == 'locator':
self.name = cmds.spaceLocator(n=nodeName)[0]
elif node == 'group':
self.name = cmds.group(n=nodeName, em=1)
elif node == 'control' or node == 'gimbalCtrl':
self.name = cmds.circle(n=nodeName, ch=0)[0]
elif node == 'follicle':
fol = cmds.createNode(node, ss=1)
folTransform = cmds.listRelatives(fol, p=1)
self.name = cmds.rename(folTransform, nodeName)
elif node == 'hairSystem':
hs = cmds.createNode(node, ss=1)
hsTransform = cmds.listRelatives(hs, p=1)
self.name = cmds.rename(hsTransform, nodeName)
elif node == 'cluster':
clu, cluHdl = cmds.cluster(n=nodeName)
self.name = cmds.rename(cluHdl, '{}H'.format(nodeName))
self.clu = clu
elif node == 'shadingEngine':
self.name = cmds.sets(renderable=True,
noSurfaceShader=True,
empty=True,
name=nodeName)
elif node == 'mesh':
self.name = cmds.createNode(node, ss=1, name=nodeName)
self.transform = cmds.listRelatives(self.name, p=1)
else:
self.name = cmds.createNode(node, n=nodeName, ss=1)
if parent:
cmds.parent(self.name, parent)
if operation and 'operation' in cmds.listAttr(self.name):
cmds.setAttr('{}.operation'.format(self.name), operation)
cmds.select(cl=1)
def forearmTwistRig(color, rollGrpParent, fkArmJoint, ikArmJoint, suffix, name, prefix, lowerArm):
print "START Building the "+ suffix +" lower arm twists---------------------------------------"
print "suffix = "+suffix
print "name = "+name
print "prefix = "+prefix
print "lowerArm = "+lowerArm
# create a nice name
name = prefix + name + suffix
if name.find("_") == 0:
name = name.partition("_")[2]
lowerarm = prefix + lowerArm + suffix
driver_lowerarm = "driver_" + prefix + lowerArm + suffix
driver_hand = "driver_hand_"+name
numRolls = 0
for joint in ["_twist_01", "_twist_02", "_twist_03", "_twist_04", "_twist_05", "_twist_06"]:
if cmds.objExists("driver_" + prefix + lowerArm + joint + suffix):
numRolls = numRolls + 1
print "...There are a total of " + str(numRolls) + " to build."
for i in range(int(numRolls)):
print "...Building lower arm twist_0" + str(i + 1)
driver_lowerarm_twist = "driver_" + prefix + lowerArm + "_twist_0" + str(i + 1) + suffix
# create our roll group
rollGrp = cmds.group(empty = True, name = lowerarm + "_roll_grp_0" + str(i + 1))
cmds.parent(rollGrp, "arm_sys_grp")
# Make sure the twist joint is exactly at the hand and aimed at the lowerarm
#NOTE if the "side" method Jeremy is using in here(name) is intended to handle more than just "l" and "r" then the move part of this must be re-written to handle that accordingly.
'''if i == 0:
const = cmds.parentConstraint(driver_hand, driver_lowerarm_twist, weight=1, mo=False, sr=["x","y","z"])
cmds.delete(const)
cmds.select(driver_lowerarm_twist, r=True)
if name == "l":
cmds.move(-0.995369, 0, 0, driver_lowerarm_twist, r = True)
else:
cmds.move(0.995369, 0, 0, driver_lowerarm_twist, r = True)
cmds.makeIdentity(driver_lowerarm_twist, r = 1, t = 1, s = 1, apply =True)'''
# create a new heirarchy out of the driver skeleton
driver_lowerarm_offset = cmds.duplicate(driver_lowerarm, po=True, name=driver_lowerarm+"_Offset_0" + str(i + 1))[0]
cmds.parent(driver_lowerarm_offset, rollGrp)
cmds.setAttr(driver_lowerarm_offset + ".rotateOrder", 1)
cmds.setAttr(driver_lowerarm_offset + ".v", 1)
driver_lowerarm_twist_offset = cmds.duplicate(driver_lowerarm_twist, po=True, name=driver_lowerarm_twist+"_Offset")[0]
cmds.parent(driver_lowerarm_twist_offset, driver_lowerarm_offset)
cmds.setAttr(driver_lowerarm_twist_offset + ".rotateOrder", 1)
cmds.setAttr(driver_lowerarm_twist_offset + ".v", 1)
driver_hand_offset = cmds.duplicate(driver_lowerarm_twist_offset, po=True, name=driver_hand+"_Offset_0" + str(i + 1))[0]
const = cmds.parentConstraint(driver_hand, driver_hand_offset, weight=1, mo=False, sr=["x","y","z"])
cmds.delete(const)
cmds.setAttr(driver_hand_offset + ".rotateOrder", 1)
cmds.setAttr(driver_hand_offset + ".v", 1)
# create the manual twist control
if i == 0:
twistCtrl = utils.createControl("circle", 15, lowerarm + "_twist_anim")
else:
twistCtrl = utils.createControl("circle", 15, lowerarm + "_twist"+str(i + 1)+"_anim")
cmds.setAttr(twistCtrl + ".ry", -90)
cmds.setAttr(twistCtrl + ".sx", 0.8)
cmds.setAttr(twistCtrl + ".sy", 0.8)
cmds.setAttr(twistCtrl + ".sz", 0.8)
cmds.makeIdentity(twistCtrl, r = 1, s = 1, apply =True)
# move the manual control to the correct location
constraint = cmds.parentConstraint(driver_lowerarm_twist_offset, twistCtrl)[0]
cmds.delete(constraint)
# create a group for the manual control and parent the twist to it.
twistCtrlGrp = cmds.group(empty = True, name = twistCtrl + "_grp")
constraint = cmds.parentConstraint(driver_lowerarm_twist_offset, twistCtrlGrp)[0]
cmds.delete(constraint)
cmds.parent(twistCtrl, twistCtrlGrp)
cmds.parent(twistCtrlGrp, rollGrp)
cmds.makeIdentity(twistCtrl, t = 1, r = 1, s = 1, apply = True)
cmds.parentConstraint(driver_lowerarm_twist_offset, twistCtrlGrp)
# set the manual controls visibility settings
cmds.setAttr(twistCtrl + ".overrideEnabled", 1)
cmds.setAttr(twistCtrl + ".overrideColor", color)
for attr in [".sx", ".sy", ".sz"]:
cmds.setAttr(twistCtrl + attr, lock = True, keyable = False)
cmds.setAttr(twistCtrl + ".v", keyable = False)
# add attr on rig settings for manual twist control visibility
cmds.select("Rig_Settings")
if i == 0:
cmds.addAttr(longName=(name + "twistCtrlVisLower"), at = 'bool', dv = 0, keyable = True)
cmds.connectAttr("Rig_Settings." + name + "twistCtrlVisLower", twistCtrl + ".v")
# add attr to rig settings for the twist ammount values
cmds.select("Rig_Settings")
cmds.addAttr(longName= ( name + "ForearmTwist"+str(i + 1)+"Amount" ), defaultValue=0.5, minValue=0, maxValue=1, keyable = True)
for u in range(int(i+1)):
cmds.setAttr("Rig_Settings." + name + "ForearmTwist"+str(u + 1)+"Amount", (1.0/(i+2.0)*((2.0-u)+(i-1.0))) )
# Create a locator and group for the up vector of the aim for the twist.
forearmTwistUp = cmds.spaceLocator(n="forearmTwistUp_0"+str(i + 1)+"_"+name)[0]
constraint = cmds.parentConstraint(driver_hand_offset, forearmTwistUp)[0]
cmds.delete(constraint)
forearmTwistUpGrp = cmds.duplicate(driver_hand_offset, po=True, name=forearmTwistUp+"_grp")[0]
cmds.parent(forearmTwistUpGrp, rollGrp)
cmds.parent(forearmTwistUp, forearmTwistUpGrp)
cmds.setAttr(forearmTwistUpGrp + ".rotateOrder", 1)
cmds.setAttr(forearmTwistUp + ".v", 0)
# constrain the up group into the rig so that it takes the correct ammount of the twist
forearmGrpPrntConst = cmds.parentConstraint(driver_lowerarm_offset, driver_hand_offset, forearmTwistUpGrp, mo=True)[0]
cmds.setAttr(forearmGrpPrntConst+".interpType", 2)
cmds.move(0, 0, 6, forearmTwistUp, r = True)
twistAimConst = cmds.aimConstraint(driver_hand_offset, driver_lowerarm_twist_offset, weight=1, mo=True, aimVector=(1, 0, 0), upVector=(0, 0, 1), worldUpType="object", worldUpObject=forearmTwistUp)[0]
# constrain the offsets back to the original driver skeleton
cmds.parentConstraint(driver_hand, driver_hand_offset, mo=True)
cmds.parentConstraint(driver_lowerarm, driver_lowerarm_offset, mo=True)
# hook up the nodes to drive the twist based on the values on the rig settings node.
reverseNode = cmds.shadingNode("reverse", asUtility=True, name=forearmGrpPrntConst+"_reverse")
cmds.connectAttr("Rig_Settings."+name+"ForearmTwist"+str(i + 1)+"Amount", forearmGrpPrntConst+"."+driver_hand_offset+"W1", f=True)
cmds.connectAttr("Rig_Settings."+name+"ForearmTwist"+str(i + 1)+"Amount", reverseNode+".inputX", f=True)
cmds.connectAttr(reverseNode+".outputX", forearmGrpPrntConst+"."+driver_lowerarm_offset+"W0", f=True)
#constrain driver joint to twist joint
cmds.parentConstraint(twistCtrl, driver_lowerarm_twist, mo = True)
print ".END Building the "+ suffix +" lower arm twists---------------------------------------"
#forearmTwistRig(0, "", "", "", "_l", "", "", "lowerarm")
def Spine_Create():
Scale_Guide = cmds.xform('Guide_Ctrl_Master', ws=True, q=True, s=True)[0]
rot_Guide_Pelvis = cmds.xform('Guide_Pelvis', ws=True, q=True, ro=True)
trans_Guide_Pelvis = cmds.xform('Guide_Pelvis', ws=True, q=True, t=True)
trans_Loc_End_Pelvis = cmds.xform('Loc_End_Pelvis',
ws=True,
q=True,
t=True)
trans_Guide_Spine_2 = cmds.xform('Guide_Spine_1', ws=True, q=True, t=True)
trans_Guide_Spine_3 = cmds.xform('Guide_Spine_2', ws=True, q=True, t=True)
trans_Guide_Spine_4 = cmds.xform('Guide_Spine_3', ws=True, q=True, t=True)
trans_Guide_Spine_5 = cmds.xform('Guide_Chest', ws=True, q=True, t=True)
#Joints_Spine#
Joint_Spine_1 = cmds.joint(p=trans_Guide_Pelvis,
n=('J_Spine_1'),
rad=.6 * Scale_Guide)
Joint_Spine_2 = cmds.joint(p=trans_Guide_Spine_2,
n=('J_Spine_2'),
rad=.6 * Scale_Guide)
Joint_Spine_3 = cmds.joint(p=trans_Guide_Spine_3,
n=('J_Spine_3'),
rad=.6 * Scale_Guide)
Joint_Spine_4 = cmds.joint(p=trans_Guide_Spine_4,
n=('J_Spine_4'),
rad=.6 * Scale_Guide)
Joint_Spine_5 = cmds.joint(p=trans_Guide_Spine_5,
n=('J_Spine_5'),
rad=.6 * Scale_Guide)
#OJ_Joints_Spine#
OJ_Joint_Spine_1 = cmds.joint(Joint_Spine_1,
e=True,
zso=True,
oj='yxz',
sao='xup')
OJ_Joint_Spine_2 = cmds.joint(Joint_Spine_2,
e=True,
zso=True,
oj='yxz',
sao='xup')
OJ_Joint_Spine_3 = cmds.joint(Joint_Spine_3,
e=True,
zso=True,
oj='yxz',
sao='xup')
OJ_Joint_Spine_4 = cmds.joint(Joint_Spine_4,
e=True,
zso=True,
oj='yxz',
sao='xup')
#JointOrient_Chest#
joX_Joint_Chest = cmds.setAttr("J_Spine_5.jointOrientX", 0)
joY_Joint_Chest = cmds.setAttr("J_Spine_5.jointOrientY", 0)
joZ_Joint_Chest = cmds.setAttr("J_Spine_5.jointOrientZ", 0)
rot_Joint_Spine_1 = cmds.xform('J_Spine_1', ws=True, q=True, ro=True)
cmds.select(d=True)
#Create Ik Spline#
Select_Spine_1 = cmds.select(Joint_Spine_1, r=True)
Add_Select_Spine_5 = cmds.select(Joint_Spine_5, add=True)
IkHandle_Spine = cmds.ikHandle(n='IkSpline_Spine', sol='ikSplineSolver')
Rename_Cv = cmds.rename('curve1', 'CV_Spine_1')
cmds.select(d=True)
#Rot_Translate_J_Spine_4#
rot_J_Spine_4 = cmds.xform(Joint_Spine_4, ws=True, q=True, ro=True)
trans_J_Spine_4 = cmds.xform(Joint_Spine_4, ws=True, q=True, t=True)
emparentarTrans_J_Spine_4 = cmds.xform('P_M_SpineFK_01_CTL',
ws=True,
t=trans_J_Spine_4)
emparentarRot_J_Spine_4 = cmds.xform('P_M_SpineFK_01_CTL',
ws=True,
ro=rot_J_Spine_4)
#Grp_Offset_Spine#
rot_J_Spine_1 = cmds.xform('J_Spine_1', ws=True, q=True, ro=True)
trans_J_Spine_1 = cmds.xform('J_Spine_1', ws=True, q=True, t=True)
Grp_Z_J_Spine_1 = cmds.group(n='Z_J_Spine_1', em=True)
Grp_P_J_Spine_1 = cmds.group(n='P_J_Spine_1')
emparentarTrans = cmds.xform(Grp_P_J_Spine_1, ws=True, t=trans_J_Spine_1)
emparentarRot = cmds.xform(Grp_P_J_Spine_1, ws=True, ro=rot_J_Spine_1)
P_J_Pelvis_Z_J_Pelvis = cmds.parent('J_Spine_1', 'Z_J_Spine_1')
cmds.select(d=True)
#Pelvis#
translate_Guide_Pelvis = cmds.xform('Guide_Pelvis',
ws=True,
q=True,
t=True)
rot_Guide_Pelvis = cmds.xform('Guide_Pelvis', ws=True, q=True, ro=True)
J_Pelvis = cmds.joint(n=('J_Pelvis'), rad=.7 * Scale_Guide)
Z_J_Pelvis = cmds.group(n=("Z_J_Pelvis"))
emparentarTrans_J_Pelvis = cmds.xform(Z_J_Pelvis,
ws=True,
t=translate_Guide_Pelvis)
emparentarRot_J_Pelvis = cmds.xform(Z_J_Pelvis,
ws=True,
ro=rot_Guide_Pelvis)
J_End_Pelvis = cmds.joint(p=trans_Loc_End_Pelvis,
n=('J_End_Pelvis'),
rad=.5 * Scale_Guide)
cmds.parent('J_End_Pelvis', 'J_Pelvis')
#M_Pelvis_CTL#
Position_Ctrl_Pelvis = cmds.xform("P_M_Pelvis_CTL",
ws=True,
t=trans_J_Spine_1)
Parent_Constraint_Chest = cmds.parentConstraint('M_Pelvis_CTL',
'J_Pelvis',
mo=True)
cmds.select(d=True)
#COG#
J_COG = cmds.joint(n=('J_COG'), rad=1 * Scale_Guide)
Grp_J_COG = cmds.group(n='Z_J_COG')
emparentarTrans_J_Pelvis = cmds.xform(Grp_J_COG,
ws=True,
t=translate_Guide_Pelvis)
emparentarRot_J_Pelvis = cmds.xform(Grp_J_COG,
ws=True,
ro=rot_Guide_Pelvis)
#M_Cog_CTL#
Position_Ctrl_Pelvis = cmds.xform("P_M_Cog_CTL",
ws=True,
t=trans_J_Spine_1)
Parent_Constraint_Chest = cmds.parentConstraint('M_Cog_CTL',
'J_COG',
mo=True)
cmds.select(d=True)
#Create Joints_CV_Spine
trans_CV_Ctrl_Spine_1 = cmds.xform('J_Spine_1', ws=True, q=True, t=True)
rot_CV_Ctrl_Spine_1 = cmds.xform('J_Spine_1', ws=True, q=True, ro=True)
J_CV_Ctrl_Spine_1 = cmds.joint(n=('J_Ctrl_Spine_1'))
ZJ_CV_Ctrl_Spine_1 = cmds.group(n=("Z_J_Ctrl_Spine_1"))
emp_trans_CV_Ctrl_Spine_1 = cmds.xform(ZJ_CV_Ctrl_Spine_1,
ws=True,
t=trans_CV_Ctrl_Spine_1)
emp_rot_CV_Ctrl_Spine_1 = cmds.xform(ZJ_CV_Ctrl_Spine_1,
ws=True,
ro=rot_CV_Ctrl_Spine_1)
cmds.select(d=True)
#CV_Spine_Mid#
trans_CV_Ctrl_Spine_Mid = cmds.xform('J_Spine_3', ws=True, q=True, t=True)
rot_CV_Ctrl_Spine_Mid = cmds.xform('J_Spine_3', ws=True, q=True, ro=True)
J_CV_Ctrl_Spine_Mid = cmds.joint(n=('J_Ctrl_Spine_Mid'))
ZJ_CV_Ctrl_Spine_Mid = cmds.group(n=("Z_J_Ctrl_Spine_Mid"))
emp_trans_J_Spine_2 = cmds.xform(ZJ_CV_Ctrl_Spine_Mid,
ws=True,
t=trans_CV_Ctrl_Spine_Mid)
emp_rot_J_Spine_2 = cmds.xform(ZJ_CV_Ctrl_Spine_Mid,
ws=True,
ro=rot_CV_Ctrl_Spine_Mid)
cmds.select(d=True)
#CV_Spine_Chest#
trans_CV_Ctrl_Spine_Chest = cmds.xform('J_Spine_5',
ws=True,
q=True,
t=True)
rot_CV_Ctrl_Spine_Chest = cmds.xform('J_Spine_5', ws=True, q=True, ro=True)
J_CV_Ctrl_Spine_Chest = cmds.joint(n=('J_Ctrl_Spine_Chest'))
ZJ_CV_Ctrl_Spine_Chest = cmds.group(n=("Z_J_Ctrl_Spine_Chest"))
emp_trans_J_Spine_3 = cmds.xform(ZJ_CV_Ctrl_Spine_Chest,
ws=True,
t=trans_CV_Ctrl_Spine_Chest)
emp_rot_J_Spine_2 = cmds.xform(ZJ_CV_Ctrl_Spine_Chest,
ws=True,
ro=rot_CV_Ctrl_Spine_Chest)
cmds.select(d=True)
#SKIN_CV
Select_Joints_CV_1 = cmds.select(J_CV_Ctrl_Spine_1, r=True)
Select_Joints_CV_3 = cmds.select(J_CV_Ctrl_Spine_Mid, add=True)
Select_Joints_CV_5 = cmds.select(J_CV_Ctrl_Spine_Chest, add=True)
Seelct_CV = cmds.select('CV_Spine_1', add=True)
Skin_CV = cmds.skinCluster('J_Ctrl_Spine_1',
'J_Ctrl_Spine_Mid',
'J_Ctrl_Spine_Chest',
'CV_Spine_1',
dr=4)[0]
#M_SpineFK_00_CTL#
translate = cmds.xform('J_Spine_2', ws=True, q=True, t=True)
rot = cmds.xform('J_Spine_2', ws=True, q=True, ro=True)
Position = cmds.xform('P_M_SpineFK_00_CTL', ws=True, t=translate)
Rotation = cmds.xform('P_M_SpineFK_00_CTL', ws=True, ro=rot)
#SpineMidAJUSTE#
translateCtrl_Spine_Mid = cmds.xform('J_Ctrl_Spine_Mid',
ws=True,
q=True,
t=True)
rotCtrl_Spine_Mid = cmds.xform('J_Ctrl_Spine_Mid',
ws=True,
q=True,
ro=True)
Position = cmds.xform('P_M_SpineAdj_CTL',
ws=True,
t=translateCtrl_Spine_Mid)
Rotation = cmds.xform('P_M_SpineAdj_CTL', ws=True, ro=rotCtrl_Spine_Mid)
cmds.select(d=True)
#Create_J_Chest#
trans_Guide_Chest = cmds.xform('Guide_Chest', ws=True, q=True, t=True)
rot_Guide_Chest = cmds.xform('Guide_Chest', ws=True, q=True, ro=True)
Joint_Chest = cmds.joint(n=('J_Chest'), rad=1 * Scale_Guide)
Grp_J_Chest = cmds.group(n='Z_J_Chest')
emparentarTrans_J_Chest = cmds.xform(Grp_J_Chest,
ws=True,
t=trans_Guide_Chest)
emparentarRot_J_Chest = cmds.xform(Grp_J_Chest,
ws=True,
ro=rot_Guide_Chest)
#M_Chest_CTL#
translate_J_Chest = cmds.xform('Z_J_Chest', ws=True, q=True, t=True)
rotate_J_Chest = cmds.xform('Z_J_Chest', ws=True, q=True, ro=True)
Position_Chest = cmds.xform("P_M_Chest_CTL", ws=True, t=translate_J_Chest)
Orientation_Chest = cmds.xform("P_M_Chest_CTL", ws=True, ro=rotate_J_Chest)
Parent_Constraint_Chest = cmds.parentConstraint('M_Chest_CTL',
'J_Chest',
mo=True)
#Constraints#
Orient_J_Ctrl_Spine_1_Ctrl_Spine_1 = cmds.orientConstraint(
'M_SpineFK_00_CTL', ZJ_CV_Ctrl_Spine_1, mo=True)
Parent_J_Ctrl_Spine_Mid_Ctrl_Spine_Mid = cmds.parentConstraint(
'M_SpineAdj_CTL', J_CV_Ctrl_Spine_Mid, mo=True)
Parent_J_Ctrl_Spine_Chest_Ctrl_Spine_Chest = cmds.parentConstraint(
"M_Chest_CTL", J_CV_Ctrl_Spine_Chest, mo=True)
Point_Ctrl_Pelvis_J_CV_Ctrl_Spine_1 = cmds.pointConstraint(
'M_Pelvis_CTL', J_CV_Ctrl_Spine_1)
#Herarchy_Spine#
Parent_Ctrl_Spine_Mid_Ctrl_Spine_Mid2 = cmds.parent(
"P_M_SpineFK_01_CTL", "M_SpineFK_00_CTL")
Parent_Ctrl_Spine_Fk_2_Ctrl_Chest = cmds.parent("P_M_Chest_CTL",
"M_SpineFK_01_CTL")
#Squash_Stretch#
#Arclen#
Cv_Info = cmds.arclen('CV_Spine_1', ch=True)
Valor = cmds.getAttr('curveInfo1.arcLength')
#MultiplyDivide_Stretch#
NodeMultiplyDivide_Stretch_Spine = cmds.shadingNode('multiplyDivide',
au=True,
n="MD_Stretch_Spine")
Operation_NodeMultiplyDivide_Stretch_Spine = cmds.setAttr(
(NodeMultiplyDivide_Stretch_Spine) + ".operation", 2)
Set_Input2X_MD_Stretch = cmds.setAttr(
(NodeMultiplyDivide_Stretch_Spine) + ".input2X", Valor)
#MultiplyDivide_MASS_LOSS#
NodeMultiplyDivide_MASS_LOSS_Spine = cmds.shadingNode(
'multiplyDivide', au=True, n="MD_MASS_LOSS_Spine")
Operation_NodeMultiplyDivide_MASS_LOSS_Spine = cmds.setAttr(
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".operation", 2)
Set_Input2X_MD_MASS_LOSS = cmds.setAttr(
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".input1X", Valor)
#Average_Spine_Mass_Loss#
NodeplusMinusAverage = cmds.shadingNode('plusMinusAverage',
au=True,
n='AV_Spine_Mass_Loss')
Set_Operation_Average = cmds.setAttr(NodeplusMinusAverage + ".operation",
3)
#Conect Arclen_MD_STRETCH#
ConectArclen_MD_Stretch = cmds.connectAttr(
(Cv_Info) + ".arcLength",
(NodeMultiplyDivide_Stretch_Spine) + ".input1X")
#Conect Arclen_MASS_LOSS_STRETCH#
ConectArclen_MD_MASS_LOSS = cmds.connectAttr(
(Cv_Info) + ".arcLength",
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".input2X")
#Conect_MD_Stretch_Joints#
Conect_MD_Stretch_J1 = cmds.connectAttr(
(NodeMultiplyDivide_Stretch_Spine) + ".outputX", "J_Spine_1.scaleY")
Conect_MD_Stretch_J2 = cmds.connectAttr(
(NodeMultiplyDivide_Stretch_Spine) + ".outputX", "J_Spine_2.scaleY")
Conect_MD_Stretch_J3 = cmds.connectAttr(
(NodeMultiplyDivide_Stretch_Spine) + ".outputX", "J_Spine_3.scaleY")
Conect_MD_Stretch_J4 = cmds.connectAttr(
(NodeMultiplyDivide_Stretch_Spine) + ".outputX", "J_Spine_4.scaleY")
#Conect_MD_MASS_LOSS_Joints#
Conect_MD_Stretch_J2 = cmds.connectAttr(
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".outputX", "J_Spine_2.scaleX")
Conect_MD_Stretch_J2 = cmds.connectAttr(
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".outputX", "J_Spine_2.scaleZ")
Conect_MD_Stretch_J2 = cmds.connectAttr(
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".outputX", "J_Spine_3.scaleX")
Conect_MD_Stretch_J2 = cmds.connectAttr(
(NodeMultiplyDivide_MASS_LOSS_Spine) + ".outputX", "J_Spine_3.scaleZ")
Connect_MD_MASS_LOSS_AV_0_Spine = cmds.connectAttr(
NodeMultiplyDivide_MASS_LOSS_Spine + '.outputX',
NodeplusMinusAverage + '.input3D[0].input3Dx',
f=True)
Connect_MD_MASS_LOSS_AV_1_Spine = cmds.connectAttr(
NodeMultiplyDivide_MASS_LOSS_Spine + '.outputX',
NodeplusMinusAverage + '.input3D[1].input3Dx',
f=True)
Disconnect_MD_AV = cmds.disconnectAttr(
NodeMultiplyDivide_MASS_LOSS_Spine + '.outputX',
NodeplusMinusAverage + '.input3D[1].input3Dx')
Connect_AV_J_Spine_1_X = cmds.connectAttr('AV_Spine_Mass_Loss.output3Dx',
'J_Spine_1.scaleX',
f=True)
Connect_AV_J_Spine_1_Z = cmds.connectAttr('AV_Spine_Mass_Loss.output3Dx',
'J_Spine_1.scaleZ',
f=True)
Connect_AV_J_Spine_4_X = cmds.connectAttr('AV_Spine_Mass_Loss.output3Dx',
'J_Spine_4.scaleX',
f=True)
Connect_AV_J_Spine_4_Z = cmds.connectAttr('AV_Spine_Mass_Loss.output3Dx',
'J_Spine_4.scaleZ',
f=True)
##Herarchy_Ctrl_Clavicle_L_Ctrl_Chest
Parent_Ctrl_Clavicle_L_Ctrl_Chest = cmds.parent("P_L_Clavicle_CTL",
"M_Chest_CTL")
##Herarchy_Ctrl_Clavicle_R_Ctrl_Chest
Parent_Ctrl_Clavicle_R_Ctrl_Chest = cmds.parent("P_R_Clavicle_CTL",
"M_Chest_CTL")
#Grp_HiddenSpine
Grp_Hidden_Spine = cmds.group(em=True, name='Hidden_Spine')
Parent_CV_Spine_Group = cmds.parent('CV_Spine_1', 'Hidden_Spine')
Parent_Ik_Spline_Spine_Group = cmds.parent('IkSpline_Spine',
'Hidden_Spine')
Hidde_IK_Handle_Arm_L = cmds.hide(Grp_Hidden_Spine)
cmds.select(d=True)
#Loc_Follow_Spine_Mid
Loc_Follow_Spine_Mid = cmds.spaceLocator(n='Loc_Follow_Spine_Mid',
p=(0, 0, 0))
Grp_Loc_Follow_Spine_Mid = cmds.group(n='Z_Loc_Follow_Spine_Mid')
ZGrp_Loc_Follow_Spine_Mid = cmds.group(n='P_Loc_Follow_Spine_Mid')
cmds.select(d=True)
#Loc_Follow_Spine_Pelvis
Loc_Follow_Spine_Pelvis = cmds.spaceLocator(n='Loc_Follow_Spine_Pelvis',
p=(0, 0, 0))
Grp_Loc_Follow_Spine_Pelvis = cmds.group(n='Z_Loc_Follow_Spine_Pelvis')
ZGrp_Loc_Follow_Spine_Pelvis = cmds.group(n='P_Loc_Follow_Spine_Pelvis')
Position_Loc_Follow_Spine_Pelvis = cmds.xform(ZGrp_Loc_Follow_Spine_Pelvis,
ws=True,
t=translate_Guide_Pelvis)
Rotation_Loc_Follow_Spine_Pelvis = cmds.xform(ZGrp_Loc_Follow_Spine_Pelvis,
ws=True,
ro=rot_Guide_Pelvis)
cmds.select(d=True)
#Loc_Follow_Spine_Chest
Loc_Follow_Spine_Chest = cmds.spaceLocator(n='Loc_Follow_Spine_Chest',
p=(0, 0, 0))
Grp_Loc_Follow_Spine_Chest = cmds.group(n='Z_Loc_Follow_Spine_Chest')
ZGrp_Loc_Follow_Spine_Chest = cmds.group(n='P_Loc_Follow_Spine_Chest')
Position_Loc_Follow_Spine_Chest = cmds.xform(ZGrp_Loc_Follow_Spine_Chest,
ws=True,
t=translate_J_Chest)
Rotation_Loc_Follow_Spine_Chest = cmds.xform(ZGrp_Loc_Follow_Spine_Chest,
ws=True,
ro=rotate_J_Chest)
cmds.select(d=True)
Position_Loc_Follow_Spine_Mid = cmds.xform(ZGrp_Loc_Follow_Spine_Mid,
ws=True,
t=translateCtrl_Spine_Mid)
Rotation_Loc_Follow_Spine_Mid = cmds.xform(ZGrp_Loc_Follow_Spine_Mid,
ws=True,
ro=rotCtrl_Spine_Mid)
NodeBColors_Follow_Ctrl_Spine_Mid = cmds.shadingNode(
'blendColors', au=True, n='BC_Follow_Ctrl_Spine_Mid')
Connect_Pelvis_BC_Follow_Spine = cmds.connectAttr(
'M_Pelvis_CTL.translate',
NodeBColors_Follow_Ctrl_Spine_Mid + '.color1')
Connect_Chest_BC_Follow_Spine = cmds.connectAttr(
'M_Chest_CTL.translate', NodeBColors_Follow_Ctrl_Spine_Mid + '.color2')
Connect_BC_Follow_Spine_Loc_Follow = cmds.connectAttr(
NodeBColors_Follow_Ctrl_Spine_Mid + '.output',
'Loc_Follow_Spine_Mid.translate')
Aim_Cons_Pelvis_Loc_Follow_Spine = cmds.aimConstraint(
'Loc_Follow_Spine_Chest',
'Loc_Follow_Spine_Pelvis',
w=1,
aim=(0, 1, 0),
u=(0, 1, 0),
wut="objectrotation",
wu=(1, 0, 0),
wuo=('Loc_Follow_Spine_Chest'),
mo=True)
Connect_Ctrl_Chest_Loc_Follow_Spine_Chest = cmds.connectAttr(
'M_Chest_CTL' + '.translate', 'Loc_Follow_Spine_Chest.translate')
Connect_Ctrl_Pelvis_Loc_Follow_Spine_Pelvis = cmds.connectAttr(
'M_Pelvis_CTL' + '.translate', 'Loc_Follow_Spine_Pelvis.translate')
Connect_Loc_Follow_Spine_Z_Ctrl_Spine_Ajuste_Rot = cmds.connectAttr(
'Loc_Follow_Spine_Pelvis' + '.rotate', 'Loc_Follow_Spine_Mid.rotate')
Connect_Loc_Follow_Spine_Z_Ctrl_Spine_Ajuste_Trans = cmds.connectAttr(
'Loc_Follow_Spine_Mid' + '.translate', 'Z_M_SpineAdj_CTL.translate')
Connect_Loc_Follow_Spine_Z_Ctrl_Spine_Ajuste_Rot = cmds.connectAttr(
'Loc_Follow_Spine_Mid' + '.rotate', 'Z_M_SpineAdj_CTL.rotate')
ParentCons_Ctrl_Spine_Fk_2_Ctrl_Spine_Ajuste = cmds.parentConstraint(
'M_SpineFK_01_CTL', 'P_M_SpineAdj_CTL', mo=True)
ParentCons_Ctrl_Spine_Mid_Ctrl_Spine_Ajuste = cmds.parentConstraint(
'M_SpineFK_00_CTL', 'P_M_SpineAdj_CTL', mo=True)
Herarchy_P_Loc_Follow_Spine_Mid_Ctrl_COG = cmds.parent(
ZGrp_Loc_Follow_Spine_Mid, 'M_Cog_CTL')
Herarchy_P_Loc_Follow_Spine_Pelvis_Ctrl_COG = cmds.parent(
ZGrp_Loc_Follow_Spine_Pelvis, 'M_Cog_CTL')
Herarchy_P_Loc_Follow_Spine_Chest_Ctrl_COG = cmds.parent(
ZGrp_Loc_Follow_Spine_Chest, 'M_Cog_CTL')
#Herarchy_COG_Pelvis_Spine#
Herarchy_Pelvis_COG = cmds.parent('Z_J_Pelvis', 'J_COG')
Herarchy_P_Ctrl_Pelvis_Ctrl_COG = cmds.parent('P_M_Pelvis_CTL',
'M_Cog_CTL')
Herarchy_P_Ctrl_Spine_Fk_1_Ctrl_COG = cmds.parent('P_M_SpineFK_00_CTL',
'M_Cog_CTL')
#TwistSpine#
Set_Enable_Twist_Control = cmds.setAttr(
"IkSpline_Spine.dTwistControlEnable", 1)
Set_WorldUpType = cmds.setAttr("IkSpline_Spine.dWorldUpType", 4)
Set_FowardAxis = cmds.setAttr("IkSpline_Spine.dForwardAxis", 2)
Set_WorldUpAxis = cmds.setAttr("IkSpline_Spine.dWorldUpAxis", 3)
Set_WorldUpVectorY_0 = cmds.setAttr("IkSpline_Spine.dWorldUpVectorY", 0)
Set_WorldUpVectorEndY_0 = cmds.setAttr("IkSpline_Spine.dWorldUpVectorEndY",
0)
Set_WorldUpVectorZ_1 = cmds.setAttr("IkSpline_Spine.dWorldUpVectorZ", 1)
Set_WorldUpVectorEndZ_1 = cmds.setAttr("IkSpline_Spine.dWorldUpVectorEndZ",
1)
Connect_World_Matrix_World_Up_Matrix = cmds.connectAttr(
'M_Pelvis_CTL.worldMatrix[0]', 'IkSpline_Spine.dWorldUpMatrix', f=True)
Connect_World_Matrix_World_Up_MatrixEnd = cmds.connectAttr(
'M_Chest_CTL.worldMatrix[0]',
'IkSpline_Spine.dWorldUpMatrixEnd',
f=True)
cmds.select(d=True)
#Neck#
rot_Guide_Neck = cmds.xform('Guide_Neck', ws=True, q=True, ro=True)
trans_Guide_Neck = cmds.xform('Guide_Neck', ws=True, q=True, t=True)
J_Neck = cmds.joint(p=trans_Guide_Neck, n=('J_Neck'), rad=.6 * Scale_Guide)
Grp_J_Neck = cmds.group(n='Z_J_Neck')
cmds.select(d=True)
#Head#
rot_Guide_Head = cmds.xform('Guide_Head', ws=True, q=True, ro=True)
trans_Guide_Head = cmds.xform('Guide_Head', ws=True, q=True, t=True)
J_Head = cmds.joint(p=trans_Guide_Head, n=('J_Head'), rad=.6 * Scale_Guide)
Grp_J_Head = cmds.group(n='Z_J_Head')
cmds.select(d=True)
#M_Head_CTL#
Position_Ctrl_Head = cmds.xform("P_M_Head_CTL",
ws=True,
t=trans_Guide_Head)
Rotate_Ctrl_Head = cmds.xform("P_M_Head_CTL", ws=True, ro=rot_Guide_Head)
Parent_Constraint_Chest = cmds.parentConstraint('M_Head_CTL',
'J_Head',
mo=True)
#M_Neck_CTL#
Position_Ctrl_Neck = cmds.xform("P_M_Neck_CTL",
ws=True,
t=trans_Guide_Neck)
Rotate_Ctrl_Neck = cmds.xform("P_M_Neck_CTL", ws=True, ro=rot_Guide_Neck)
Parent_Constraint_Chest = cmds.parentConstraint('M_Neck_CTL',
'J_Neck',
mo=True)
#Herarchy_Joints#
Grp_J_Head_J_Neck = cmds.parent(Grp_J_Head, J_Neck)
Grp_J_Neck_J_Chest = cmds.parent(Grp_J_Neck, Joint_Chest)
#Herarchy_Ctrls#
Grp_Ctrl_Head_Ctrl_Neck = cmds.parent('P_M_Head_CTL', 'M_Neck_CTL')
Grp_Ctrl_Neck_Ctrl_Chest = cmds.parent('P_M_Neck_CTL', 'M_Chest_CTL')
cmds.select(d=True)
cmds.rename('curveInfo1', 'Cv_Info_Spine')
def trackAndParent(self):
# Queries the time slider.
aPlayBackSliderPython = mel.eval('$tmpVar=$gPlayBackSlider')
highlight = cmds.timeControl(aPlayBackSliderPython,
query=True,
rangeVisible=True)
sel = cmds.ls(sl=True)
v1 = cmds.checkBox(tTr, q=True, v=True)
v2 = cmds.checkBox(tRo, q=True, v=True)
v3 = cmds.checkBox(cTr, q=True, v=True)
v4 = cmds.checkBox(cRo, q=True, v=True)
v5 = cmds.checkBox(pTr, q=True, v=True)
v6 = cmds.checkBox(pRo, q=True, v=True)
tTranslation = 'none' if v1 else ["x", "y", "z"]
tRotation = 'none' if v2 else ["x", "y", "z"]
cTranslation = 'none' if v3 else ["x", "y", "z"]
cRotation = 'none' if v4 else ["x", "y", "z"]
pTranslation = 'none' if v5 else ["x", "y", "z"]
pRotation = 'none' if v6 else ["x", "y", "z"]
# Gives error if more than two objects are selected.
if len(sel) > 2:
cmds.error("Too many objects selected!")
# If two objects are selected, runs Track, Contrain, and Parent.
elif len(sel) > 1:
tObj = sel[0]
pObj = sel[1]
tLoc = "{0}_tLoc".format(tObj)
pLoc = "{0}_pLoc".format(pObj)
# Constrains existing locator and bakes it, and constrains object to it. Also constrains parent locator to second object.
if cmds.objExists(tLoc):
cmds.spaceLocator(n="{0}_pLoc".format(pObj))
cmds.parentConstraint(pObj,
pLoc,
st=pTranslation,
sr=pRotation,
mo=False)
cmds.parent(tLoc, pLoc)
cmds.parentConstraint(tObj,
tLoc,
st=tTranslation,
sr=tRotation,
mo=True)
if (highlight):
tRange = cmds.timeControl(aPlayBackSliderPython,
query=True,
rangeArray=True)
cmds.bakeResults(tLoc,
simulation=True,
t=(tRange[0], tRange[1]))
cmds.parentConstraint(tLoc,
tObj,
st=cTranslation,
sr=cRotation,
mo=True)
else:
startTime = cmds.playbackOptions(query=True, minTime=True)
endTime = cmds.playbackOptions(query=True, maxTime=True)
cmds.bakeResults(tLoc, simulation=True, t=(startTime, endTime))
cmds.parentConstraint(tLoc,
tObj,
st=cTranslation,
sr=cRotation,
mo=True)
cmds.select(tLoc)
# Creates a locator, constrains it and bakes it, and constrains object to it. Also constrains parent locator to second object.
else:
LScale = cmds.floatField(LocScale, q=True, v=True)
cmds.spaceLocator(n="{0}_tLoc".format(tObj))
cmds.scale(LScale, LScale, LScale)
cmds.spaceLocator(n="{0}_pLoc".format(pObj))
cmds.parent(tLoc, pLoc)
cmds.parentConstraint(pObj,
pLoc,
st=pTranslation,
sr=pRotation,
mo=False)
cmds.parentConstraint(tObj,
tLoc,
st=tTranslation,
sr=tRotation,
mo=False)
if (highlight):
tRange = cmds.timeControl(aPlayBackSliderPython,
query=True,
rangeArray=True)
cmds.bakeResults(tLoc,
simulation=True,
t=(tRange[0], tRange[1]))
cmds.parentConstraint(tLoc,
tObj,
st=cTranslation,
sr=cRotation,
mo=False)
else:
startTime = cmds.playbackOptions(query=True, minTime=True)
endTime = cmds.playbackOptions(query=True, maxTime=True)
cmds.bakeResults(tLoc, simulation=True, t=(startTime, endTime))
cmds.parentConstraint(tLoc,
tObj,
st=cTranslation,
sr=cRotation,
mo=False)
# Gives error if only one object is selected.
elif len(sel) == 1:
cmds.error("No parent object selected!")
# Gives error if no object is selected.
else:
cmds.error("No objects selected!")
def import2dTrack():
'''
'''
# Get UI Elements
perspCamListUI = 'importTrack_camListTSL'
fileUI = 'importTrack_fileTFB'
pixelWidthUI = 'importTrack_widthFFG'
pixelHeightUI = 'importTrack_heightFFG'
pointNameUI = 'importTrack_nameTFG'
# Get UI Values
w = mc.floatFieldGrp(pixelWidthUI, q=True, v1=True)
h = mc.floatFieldGrp(pixelHeightUI, q=True, v1=True)
cam = mc.textScrollList(perspCamListUI, q=True, si=True)[0]
filePath = mc.textFieldButtonGrp(fileUI, q=True, text=True)
pointName = mc.textFieldGrp(pointNameUI, q=True, text=True)
# Ensure Camera Transform is Selected
if mc.objectType(cam) == 'camera':
cam = mc.listRelatives(cam, p=True)[0]
# Check Track File Path
if not os.path.isfile(filePath):
raise Exception('Invalid file path "' + filePath + '"!')
# Build Track Point Scene Elements
point = mc.spaceLocator(n=pointName)[0]
plane = mc.nurbsPlane(ax=(0, 0, 1),
w=1,
lr=1,
d=1,
u=1,
v=1,
ch=1,
n=pointName + 'Plane')[0]
print plane
# Position Track Plane
plane = mc.parent(plane, cam)[0]
mc.setAttr(plane + '.translate', 0, 0, -5)
mc.setAttr(plane + '.rotate', 0, 0, 0)
for attr in ['.tx', '.ty', '.rx', '.ry', '.rz']:
mc.setAttr(plane + attr, l=True)
# Add FOV Attributes
if not mc.objExists(cam + '.horizontalFOV'):
mc.addAttr(cam, ln='horizontalFOV', at='double')
if not mc.objExists(cam + '.verticalFOV'):
mc.addAttr(cam, ln='verticalFOV', at='double')
# Create FOV Expression
expStr = '// Get Horizontal and Vertical FOV\r\n\r\n'
expStr += 'float $focal =' + cam + '.focalLength;\r\n'
expStr += 'float $aperture = ' + cam + '.horizontalFilmAperture;\r\n\r\n'
expStr += 'float $fov = (0.5 * $aperture) / ($focal * 0.03937);\r\n'
expStr += '$fov = 2.0 * atan ($fov);\r\n'
expStr += cam + '.horizontalFOV = 57.29578 * $fov;\r\n\r\n'
expStr += 'float $aperture = ' + cam + '.verticalFilmAperture;\r\n\r\n'
expStr += 'float $fov = (0.5 * $aperture) / ($focal * 0.03937);\r\n'
expStr += '$fov = 2.0 * atan ($fov);\r\n'
expStr += cam + '.verticalFOV = 57.29578 * $fov;\r\n\r\n'
expStr += '// Scale plane based on FOV\r\n\r\n'
expStr += 'float $dist = ' + plane + '.translateZ;\r\n'
expStr += 'float $hfov = ' + cam + '.horizontalFOV / 2;\r\n'
expStr += 'float $vfov = ' + cam + '.verticalFOV / 2;\r\n\r\n'
expStr += 'float $hyp = $dist / cos(deg_to_rad($hfov));\r\n'
expStr += 'float $scale = ($hyp * $hyp) - ($dist * $dist);\r\n'
expStr += plane + '.scaleX = (sqrt($scale)) * 2;\r\n\r\n'
expStr += 'float $hyp = $dist / cos(deg_to_rad($vfov));\r\n'
expStr += 'float $scale = ($hyp * $hyp) - ($dist * $dist);\r\n'
expStr += plane + '.scaleY = (sqrt($scale)) * 2;'
mc.expression(s=expStr, o=plane, n='planeFOV_exp', ae=1, uc='all')
# Open Track Data File
count = 0
f = open(filePath, 'r')
# Build Track Path Curve
crvCmd = 'curveOnSurface -d 1 '
for line in f:
u, v = line.split()
crvCmd += '-uv ' + str(float(u) *
(1.0 / w)) + ' ' + str(float(v) *
(1.0 / h)) + ' '
count += 1
crvCmd += plane
print crvCmd
path = mm.eval(crvCmd)
# Close Track Data File
f.close()
# Rebuild Curve
mc.rebuildCurve(path,
fitRebuild=False,
keepEndPoints=True,
keepRange=True,
spans=0,
degree=3)
# Attach Track Point to Path
motionPath = mc.pathAnimation(point,
path,
fractionMode=False,
follow=False,
startTimeU=1,
endTimeU=count)
exp = mc.listConnections(motionPath + '.uValue')
if exp: mc.delete(exp)
mc.setKeyframe(motionPath, at='uValue', t=1, v=0)
mc.setKeyframe(motionPath, at='uValue', t=count, v=count - 1)
# 3. Change or animate 'Goal Weight[0]' value (under 'luismiParticleShape') until #
# you are happy with the result. #
# 4. Execute SPRING BAKE script (by clicking on the shelf icon). #
# #
#######################################################################################
import maya.cmds as cmds
minTime = cmds.playbackOptions(minTime=True, query=True)
maxTime = cmds.playbackOptions(maxTime=True, query=True)
sel = cmds.ls(selection=True)
if len(sel) == 0:
cmds.warning("Nothing Selected")
elif cmds.objExists('luismiParticle'):
cmds.warning("luismiParticle already EXISTS!")
else:
cmds.currentTime(minTime, edit=True)
selLoc = cmds.spaceLocator(name='OriginalPosition_Loc')
cmds.particle(p=[(0, 0, 0)], name='luismiParticle')
tempConst = cmds.parentConstraint(sel, selLoc, mo=False)
cmds.bakeResults(selLoc, t=(minTime, maxTime))
cmds.delete(tempConst)
tempConst2 = cmds.parentConstraint(selLoc, 'luismiParticle', mo=False)
cmds.delete(tempConst2)
cmds.goal('luismiParticle', g=selLoc, w=.45)
cmds.spaceLocator(name='physicsLoc')
cmds.connectAttr('luismiParticleShape.worldCentroid',
'physicsLoc.translate')
tempConst3 = cmds.pointConstraint('physicsLoc', sel, mo=True)
cmds.select('luismiParticle')
