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')