def makeRoll(firstJoint, lastJoint, rollJoint): # place root group under its rig group if "elbow" in firstJoint: rigGroup = nameLib.groupNames.leftArmRigGroup["name"] if "right" in firstJoint: rigGroup = nameLib.groupNames.rightArmRigGroup["name"] else: rigGroup = nameLib.groupNames.leftLegRigGroup["name"] if "right" in firstJoint: rigGroup = nameLib.groupNames.rightLegRigGroup["name"] rollSuffix = "_roll_null" rootGroup = makeGroup.MakeGroup(name=rollJoint + "_rig" + nameLib.prefixNames.groupSuffix, snapTo=firstJoint, parent=rigGroup) firstJointNull = makeGroup.MakeGroup(name=firstJoint + rollSuffix, snapTo= firstJoint, parent=rootGroup.groupName) rollJointNull = makeGroup.MakeGroup(name=rollJoint + rollSuffix, snapTo= rollJoint, parent=rootGroup.groupName) lastJointNull = makeGroup.MakeGroup(name=lastJoint + rollSuffix, snapTo= lastJoint, parent=rootGroup.groupName) # make constraint setup mc.parentConstraint(firstJoint, rootGroup.groupName, maintainOffset=True) mc.parentConstraint(lastJoint, lastJointNull.groupName) mc.orientConstraint(firstJointNull.groupName, rollJointNull.groupName, maintainOffset=True) mc.orientConstraint(lastJointNull.groupName, rollJointNull.groupName, maintainOffset=True) rollConstraint = mc.orientConstraint(rollJointNull.groupName, rollJoint, skip=["y", "z"])[0] mc.setAttr(rollConstraint + ".interpType", 2)
def connectDeform(ikRigNodes, fingerSetupNodes): armNodes = ikRigNodes[0] legNodes = ikRigNodes[1] fkJoints = nameLib.skeletonNames.allJoints fkJoints = list(itertools.chain(*fkJoints)) for i in fkJoints: deformJoint = i.replace(nameLib.prefixNames.jointSuffix, nameLib.prefixNames.deformSuffix) if "hip" in i: mc.parentConstraint(i, deformJoint) else: mc.orientConstraint(i, deformJoint) # connect root_DEFORM joit to placement mc.parentConstraint(nameLib.prefixNames.globalControl + nameLib.prefixNames.controlSuffix, "root" + nameLib.prefixNames.deformSuffix) # connect ikBlend for arms to constraints leftArmIkBlend = armNodes[0][0] rightArmIkBlend = armNodes[1][0] connectIkBlend(leftArmIkBlend, rightArmIkBlend, armNodes, fingers=fingerSetupNodes) # connect ikBlend for legs to constraints leftLegIkBlend = legNodes[0][0] rightLegIkBlend = legNodes[1][0] connectIkBlend(leftLegIkBlend, rightLegIkBlend, legNodes, fingers=fingerSetupNodes)
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 __init__(self, joints, parentGroup, groupToConstraint): # joints[0] = snapTo joint # joints[1] = local parent # parentGroup = where to parent spaceSwitch groups # what group will be driven rootGroup = makeGroup.MakeGroup(name=joints[0] + "_spaceSwitch_GRP") worldGroup = makeGroup.MakeGroup(name=joints[0] + "_world", snapTo=joints[0]) localGroup = makeGroup.MakeGroup(name=joints[0] + "_local", snapTo=joints[0]) mc.parent(worldGroup.groupName, rootGroup.groupName) mc.parent(localGroup.groupName, rootGroup.groupName) mc.parent(rootGroup.groupName, parentGroup) # constraint setup for groups mc.parentConstraint(joints[1], localGroup.groupName, maintainOffset=True) mc.pointConstraint(localGroup.groupName, worldGroup.groupName) mc.orientConstraint(nameLib.prefixNames.globalControl + nameLib.prefixNames.controlSuffix, worldGroup.groupName, maintainOffset=True) # sonctraint for groupToConstraint for i in [worldGroup.groupName, localGroup.groupName]: swConstraint = mc.parentConstraint(i, groupToConstraint)[0] driver = joints[0] + ".parent" reverseNode = mc.shadingNode("reverse", name = joints[0] + "_swReverse", asUtility=True) # connect channels mc.connectAttr(driver, reverseNode + ".input.inputX") mc.connectAttr(driver, swConstraint + "." + joints[0] + "_worldW0") mc.connectAttr(reverseNode + ".output.outputX", swConstraint + "." + joints[0] + "_localW1")
def setCST(self, constrainttype = 'parent', source = '', weight = 1, mo = True, remove = False, skip = "none"): """This can be used instead of the constraint class to constrain the current superObject to something quickly. @param type: the type of constraint,valid options are point, parent, aim, scale, orient. @param source: what you want to constrain to. single source only @param weight: the weight of the constraint @param mo: maintain offset @param remove: remove from constraint @type type: string @type target: string @type weight: int @type mo: boolean @type remove: boolean """ self.cstName = self.name + constrainttype + '_Constraint' self.cstType = constrainttype self.source = source cstTypes = ['point', 'orient', 'aim', 'parent', 'scale'] if self.cstType not in cstTypes: print 'Invalid constraint type called for superObject %s, try again' % self.name elif self.cstType == 'point': cmds.pointConstraint(self.source, self.name, weight = weight, mo = mo, rm = remove, n = self.cstName, skip = skip) elif self.cstType == 'parent': cmds.parentConstraint(self.source, self.name, weight = weight, mo = mo, rm = remove, n = self.cstName) elif self.cstType == 'aim': cmds.aimConstraint(self.source, self.name, weight = weight, mo = mo, rm = remove, n = self.cstName) elif self.cstType == 'scale': cmds.scaleConstraint(self.source, self.name, weight = weight, mo = mo, rm = remove, n = self.cstName) elif self.cstType == 'orient': cmds.orientConstraint(self.source, self.name, weight = weight, mo = mo, rm = remove, n = self.cstName)
def createDriverSkeleton(self): #there will always be a root bone, so let's duplicate that dupe = cmds.duplicate("root", rc = True)[0] cmds.select("root", hi = True) joints = cmds.ls(sl = True) cmds.select(dupe, hi = True) dupeJoints = cmds.ls(sl = True) driverJoints = [] for i in range(int(len(dupeJoints))): if cmds.objExists(dupeJoints[i]): driverJoint = cmds.rename(dupeJoints[i], "driver_" + joints[i]) driverJoints.append(driverJoint) #create a direct connection between the driver and the export joints for joint in driverJoints: exportJoint = joint.partition("_")[2] cmds.connectAttr(joint + ".translate", exportJoint + ".translate") cmds.orientConstraint(joint, exportJoint) cmds.connectAttr(joint + ".scale", exportJoint + ".scale")
def fkFingerSetup(self): """ #- fk finger setup """ cmds.select(cl = True) for fingerElement in self.allfingers: for lr in self.lrPrefix: for elem in fingerElement[0:-1]: if lr == self.left: ctlColor = 6 else: ctlColor = 12 ctl = controller.circleController('%s%s_ctl' %(lr, elem), 'yz', 0.5, ctlColor, ['tr', 'sc', 'vi'], doublePadding = True) cmds.select('%s%s_jnt' %(lr, elem), r = True) cmds.select('%s_grp' %ctl, tgl = True) cmds.pointConstraint(mo = False, weight = 1) cmds.orientConstraint(mo = False, weight = 1) cmds.delete('%s_grp_pointConstraint1' %ctl) cmds.delete('%s_grp_orientConstraint1' %ctl) #- constrain joints cmds.select(ctl, r = True) cmds.select('%s%s_jnt' %(lr, elem), tgl = True) cmds.orientConstraint(mo = False, weight = 1) fingerElementTmp = fingerElement[:-1] fingerElementTmp.reverse() for i in range(len(fingerElementTmp)-1): self.util.parent('%s%s_ctl_grp' %(lr, fingerElementTmp[i]), '%s%s_ctl' %(lr, fingerElementTmp[i+1]))
def create_joints(): '''Subelements: vertecies, faces, edges should be selected''' # Get selected object name selection_list = cmds.ls(selection=True) for selection in selection_list: selected_object = selection.split('.')[0] break old_loc_list = cmds.ls('*LOC*', flatten=True) #Create locators constrained to subelements HZrivet.UI.HZrivet_finalCC() current_loc_list = cmds.ls('*LOC*', flatten=True) #Filter created locators new_loc_list = [loc for loc in current_loc_list if loc not in old_loc_list] # Get list of locators names and apply it as a prefix to a joint name loc_list = [loc for loc in new_loc_list if 'Shape' not in loc] root_joint = 'root' if not cmds.objExists(root_joint): cmds.select(clear=True) cmds.joint(name=root_joint) root_p_constraint = cmds.pointConstraint(selected_object, root_joint) root_o_constraint = cmds.orientConstraint(selected_object, root_joint) cmds.delete(root_p_constraint, root_o_constraint) for loc in loc_list: joint_prefix = re.sub("\D", "", loc) joint_name = 'JNT_' + joint_prefix cmds.select(clear=True) cmds.joint(name=joint_name) cmds.pointConstraint(loc, joint_name) cmds.orientConstraint(loc, joint_name) cmds.parent(joint_name, 'root')
def Neck_Control(*args, **kwargs): NeckJt = "Neck_Jt" NeckCtrl = [mc.curve(name="Neck_Ctrl",degree=3,point=[(-0.801407, 0, 0.00716748),(-0.802768, 0.023587, -0.220859), (-0.805489, 0.0707609, -0.676912), (0.761595, -0.283043, -0.667253), (1.045492, -0.194522, -0.0218101), (1.046678, -0.194804, 0.0403576),(0.758039, -0.282198, 0.63974), (-0.806291, 0.0676615, 0.650803),(-0.803035, 0.0225538, 0.221713),(-0.801407, 0, 0.00716748)]), mc.setAttr("Neck_Ctrl.overrideColor",18),mc.setAttr("Neck_Ctrl.overrideEnabled",1)] mc.scale(2.1,3.16,2.8) mc.makeIdentity( 'Neck_Ctrl', apply=True, translate=True,scale=True) lockScaling = mc.setAttr("Neck_Ctrl.scale",lock=True) # xform translation valNeck = mc.xform(NeckJt,ws=True,query=True,translation=True) mc.xform(NeckCtrl,ws=1,t = (valNeck[0],valNeck[1],valNeck[2])) mc.orientConstraint("Neck_Ctrl", NeckJt) mc.pointConstraint("Neck_Ctrl", NeckJt) grpNeck = mc.group("Neck_Ctrl", name="GRP_Neck") mc.parent("GRP_Neck","Front_Spine_Ctrl") #Lock translation for curve lockTranslation = mc.setAttr("Neck_Ctrl.translate",lock=True) return NeckCtrl,NeckJt
def Jaw_Control(*args,**kwargs): prefix = "_" JawJt = "Lower_Jaw_Jt" JawCtrl = [mc.curve(name="Jaw"+prefix+"Ctrl",d=1, p=[(-0.484806, -0.465148, -0.560784 ),(-0.484806, -0.465148, 0.595512), (-0.275612, 0.538987, 0.636341),(1.356108, 0.120597, 0.636341 ), (2.161106, 0.0592024, 0.01008 ),(1.356108, 0.120597, -0.610974), (-0.275612, 0.538987, -0.610974),(-0.484806, -0.465148, -0.560784), (1.146913, -0.67078, -0.560784 ),(1.951911, -0.670601, 0.01008), (1.146913, -0.67078, 0.595512),(1.356108, 0.120597, 0.636341), (2.161106, 0.0592024, 0.01008),(1.356108, 0.120597, -0.610974), (1.146913, -0.67078, -0.560784),(1.146913, -0.67078, 0.595512), (-0.484806, -0.465148, 0.595512),(1.146913, -0.67078, 0.595512), (1.951911, -0.670601, 0.01008),(2.161106, 0.0592024, 0.01008)]), mc.setAttr("Jaw"+prefix+"Ctrl.overrideColor",18), mc.setAttr("Jaw"+prefix+"Ctrl.overrideEnabled",1),mc.scale(0.5,1,1.15)] #xform translation valPos = mc.xform(JawJt,query=True,ws=True,translation=True) mc.xform(JawCtrl[0],ws=1,t=(valPos[0],valPos[1],valPos[2])) #xform rotation valRot = mc.xform(JawJt,query=True,ws=True,rotation=True) mc.xform(JawCtrl[0],ws=1,ro=(valRot[0],valRot[1],valRot[2])) mc.setAttr("Jaw"+prefix+"Ctrl.rotateZ",-22) mc.makeIdentity(JawCtrl[0],a=True,r=True,t=True,s=True) mc.orientConstraint(JawCtrl[0], JawJt, mo=True) mc.pointConstraint(JawCtrl[0], JawJt, mo=True) mc.parent(JawCtrl[0],"Head_Ctrl") #Lock attributes for Jaw rig for lock in JawJt: mc.setAttr("Jaw"+prefix+"Ctrl.scale",lock=True), mc.setAttr("Jaw"+prefix+"Ctrl.translate",lock=True)
def _create_wrist(self): """Creates the special wrist setup for the 3 different rotation axes of Dave's wrist. @todo: change the constraining to the PLY GRP to something save """ hand = '%s_hand_result_%s' % (self.side, self.nc.joint) hand_end = '%s_handEnd_result_%s' % (self.side, self.nc.joint) fore_arm = '%s_foreArm_result_%s' % (self.side, self.nc.joint) # joints cmds.select(cl=True) root_jnt = cmds.joint(n='%s_wristRoot_%s' % (self.side, self.nc.joint)) end_jnt = cmds.joint(n='%s_wristEnd_%s' % (self.side, self.nc.joint)) tmp_end_jnt = cmds.joint(n='%s_wristTmpEnd_%s' % (self.side, self.nc.joint)) self.c.snap_a_to_b(root_jnt, hand) self.c.snap_a_to_b(end_jnt, hand_end) self.c.snap_a_to_b(tmp_end_jnt, hand_end) # orient joints properly self.orient_joint(root_jnt) cmds.delete(tmp_end_jnt) cmds.parent(end_jnt, w=True) # constrain joints cmds.parentConstraint(hand, root_jnt, mo=True) cmds.pointConstraint(root_jnt, end_jnt, mo=True) cmds.orientConstraint(root_jnt, end_jnt, mo=True) # constrain hand const group cmds.parentConstraint('%s_wristRotZ_PLY_%s' % (self.side, self.nc.group), '%s_hand_const_%s' % (self.side, self.nc.group), mo=True) cmds.parent(root_jnt, end_jnt, '%s_hand_%s' % (self.side, self.nc.group))
def rigExtrudePlane() : mc.select(cl = True) lf_leg = ['lf_upLeg_nrJnt', 'L_leg_profileCrv'] rt_leg = ['rt_upLeg_nrJnt', 'R_leg_profileCrv'] lf_arm = ['lf_upArm_nrJnt', 'L_arm_profileCrv'] rt_arm = ['rt_upArm_nrJnt', 'R_arm_profileCrv'] set1 = [lf_leg, rt_leg, lf_arm, rt_arm] for each in set1 : # constraint nonRoll to profile curve mc.orientConstraint(each[0], each[1], mo = True) print each[0], each[1] mc.select(cl = True) naming1 = ['L_arm_pathCrv', 'L_arm_profileCrv', 'R_arm_pathCrv', 'R_arm_profileCrv'] naming2 = ['L_leg_pathCrv', 'L_leg_profileCrv', 'R_leg_pathCrv', 'R_leg_profileCrv'] mc.select(naming1, naming2) mm.eval('tazGrp;') mc.select(cl = True) grp = ['L_armProfileCrv_zGrp', 'R_armProfileCrv_zGrp', 'L_legProfileCrv_zGrp', 'R_legProfileCrv_zGrp'] for each in grp : mc.scaleConstraint('placement_ctrl', each) # mc.select(cl = True) # # bind skin # mc.skinCluster('lf_upArm_jnt', 'lf_loArm_jnt', 'lf_wrist_jnt', 'L_arm_pathCrv', tsb = True) # mc.skinCluster('lf_upArm_jnt', 'lf_loArm_jnt', 'lf_wrist_jnt', 'L_arm_pathCrv', tsb = True) # mc.skinCluster('rt_upLeg_jnt', 'rt_loLeg_jnt', 'rt_ankle_jnt', 'R_leg_pathCrv', tsb = True) # mc.skinCluster('rt_upArm_jnt', 'rt_loArm_jnt', 'rt_wrist_jnt', 'Larm_pathCrv', tsb = True) # print 'Done'
def runWithRig() : # clear name allObjs = mc.ls() for each in allObjs : if 'Char_' in each : try : newName = each.replace('Char_', '') mc.rename(each, newName) except : pass allCtrlJntGrp = 'allJnt_grp' allIkGrp = 'allIK_grp' leftLeg = ['cnt_pelvis_jnt', 'lf_upLeg_jnt', 'lf_loLeg_jnt'] rightLeg = ['cnt_pelvis_jnt', 'rt_upLeg_jnt', 'rt_loLeg_jnt'] leftArm = ['lf_clavicle1_jnt', 'lf_upArm_jnt', 'lf_loArm_jnt'] rightArm = ['rt_clavicle1_jnt', 'rt_upArm_jnt', 'rt_loArm_jnt'] setupNonRoll = [leftLeg, rightLeg, leftArm, rightArm] for each in setupNonRoll : mc.select(each[1], each[2]) jnt1, jnt2, ik, nrJntGrp, ikAllGrp = run() mc.orientConstraint(each[0], jnt1) mc.parent(nrJntGrp, allCtrlJntGrp) mc.parent(ikAllGrp, allIkGrp) print 'Add nonroll'
def setupIKCtrl(self, x, IKHandle): ############# MODIFY FOR INHERITANCE ############# side = self.prefixList[x] thisChain = self.IKChains[x] #create a control for the ik name = "%s_%s_IK_CTRL"%(side, self.limbName) if x==0: IKCtrl = rig.createControl(name, "cube", self.jAxis1, "blue") if x==1: IKCtrl = rig.createControl(name, "cube", self.jAxis1, "red") self.IKCtrls.append(IKCtrl) #strip to rotate and translate rig.stripToRotateTranslate(IKCtrl) #G.O. control rig.groupOrient(thisChain[2], IKCtrl, self.groupSuffix) #orient constraint joint 2 (wrist ankle) to control cmds.orientConstraint(IKCtrl, thisChain[2]) #parent ik handle to control cmds.parent(IKHandle, IKCtrl) return IKCtrl
def connect_ikfk(self): for ik_jnt, fk_ctl_key in zip(self.ik.ik_joints, self.fk.controls.keys()): ctl = self.fk.controls[fk_ctl_key] cmds.orientConstraint(ik_jnt, ctl.grp, mo=True) ik_joints = self.ik.ik_joints fk_ctls = [self.fk.controls[k] for k in self.fk.controls.keys()] print len(self.ik.ik_joints) - len(self.fk.fk_joints), len(ik_joints) for index in range(len(self.ik.ik_joints) - len(self.fk.fk_joints), len(ik_joints)): fk_ctl = self.fk.get_control(index) for child_index in range(index + 1, len(ik_joints)): fk_child_ctl = self.fk.get_control(child_index) if fk_child_ctl: cons = cmds.listConnections(fk_child_ctl.inb, type='plusMinusAverage', scn=True, s=True, d=False, p=False) if not cons: pma = cmds.createNode("plusMinusAverage", name=name.set_suffix(fk_child_ctl.name, "ctlOrient")) cmds.connectAttr("%s.output3D" % pma, "%s.rotate" % fk_child_ctl.inb) else: pma = cons[0] v = cmds.getAttr("%s.input3D" % pma, size=True) cmds.connectAttr("%s.rotate" % fk_ctl.ctl, "%s.input3D[%s]" % (pma, index))
def __init__(self, objs = [], vertices = []): self.objs = objs self.vertices = vertices #lattice -divisions 2 3 2 -objectCentered true -ol 1; #mc.select( self.objs, self.vertices ) #CREATION grp = mn.Node( mc.group( n = "head_toon_GRP", em = True ) ) deGrp = mn.Node( mc.group( n = "head_toon_deformer_GRP", em = True ) ) deGrp.parent = grp deGrp.a.v.v = False deGrp.a.v.locked = True latNods = mc.lattice( self.objs, self.vertices, divisions = [ 2,3,2], objectCentered = True, ol = 1, n = 'head_toon_LAT' ) latBase = mn.Node( latNods[2] ) latBase.parent = deGrp lat = mn.Node( latNods[1] ) lat.parent = deGrp #mc.select( lat + ".pt[0:1][2][0]", lat + ".pt[0:1][2][1]" ) topClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][2][0]", lat.shape.name + ".pt[0:1][2][1]", n = 'top_face_toon_CLU' )[1] ) topClus.a.v.v = False topClus.a.v.locked = True #mc.select( lat + ".pt[0:1][1][0]", lat + ".pt[0:1][1][1]" ) midClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][1][0]", lat.shape.name + ".pt[0:1][1][1]", n = 'mid_face_toon_CLU' )[1] ) #mc.select( lat + ".pt[0:1][0][0]", lat + ".pt[0:1][0][1]" ) lowClus = mn.Node( mc.cluster( lat.shape.name + ".pt[0:1][0][0]", lat.shape.name + ".pt[0:1][0][1]", n = 'low_face_toon_CLU' )[1] ) ctl = crv.Curve( "head_toon_CTL" ) ctl = ctl.create( "sphere" ) ctl.a.t.v = topClus.worldPosition mc.makeIdentity( ctl.name, apply = True, t = 1, r = 1, s = 1, n = 2 ) topClus.parent = ctl midClus.parent = deGrp lowClus.parent = deGrp ctl.parent = grp #CONSTRAINS midClus.a.r >> topClus.a.r mc.pointConstraint( topClus.name, lowClus.name, midClus.name, mo = True ) #SCALE FOR MID CLUSTER dist = mn.createNode( 'distanceBetween', n = 'head_toon_DIS' ) ctl.a.worldMatrix >> dist.a.inMatrix1 ctl.a.rp >> dist.a.point1 lowClus.a.worldMatrix >> dist.a.inMatrix2 lowClus.a.rp >> dist.a.point2 mul = mn.createNode( 'multiplyDivide', n = 'head_toon_scale_MUL' ) mul.a.input1.v = [dist.a.distance.v]*3 mul.a.operation.v = 2 dist.a.distance >> mul.a.input2X dist.a.distance >> mul.a.input2Y dist.a.distance >> mul.a.input2Z mul.a.output >> midClus.a.s #AIM CONSTRAINT upLocGrp = mn.Node( mc.group( n = "head_upVector_GRP", em = True ) ) upLocGrp.a.t.v = midClus.worldPosition mc.makeIdentity( upLocGrp.name, apply = True, t = 1, r = 1, s = 1, n = 2 ) upLocGrp.parent = deGrp mc.orientConstraint( ctl.name, lowClus.name, upLocGrp.name, mo = True ) upLoc = mn.Node( mc.spaceLocator( n = 'head_upVector_LOC' )[0] ) upLoc.a.t.v = midClus.worldPosition upLoc.a.tz.v = upLoc.a.tz.v + 5 mc.aimConstraint( topClus.name, midClus.name, mo = True, weight = 1, aimVector = [1, 0, 0], upVector = [0, 1, 0], worldUpType = "object", worldUpObject = upLoc.name ) upLoc.parent = upLocGrp mc.pointConstraint( topClus.name, lowClus.name, upLoc.name, mo = True )
def getParentConstraintDic (self, parentConstraint) : returnedDic = {'alias':{}, "object":None } aliasDic={} if cmds.objectType(parentConstraint)=="parentConstraint": WA = cmds.parentConstraint (parentConstraint, q = True, weightAliasList = True) TL = cmds.parentConstraint (parentConstraint, q = True, targetList = True) elif cmds.objectType(parentConstraint)=="orientConstraint": WA = cmds.orientConstraint (parentConstraint, q = True, weightAliasList = True) TL = cmds.orientConstraint (parentConstraint, q = True, targetList = True) elif cmds.objectType(parentConstraint)=="pointConstraint": WA = cmds.pointConstraint (parentConstraint, q = True, weightAliasList = True) TL = cmds.pointConstraint (parentConstraint, q = True, targetList = True) else: "error No constraint Type identified" if len(WA) == len(TL): for eachWAIndex in range(0,len(WA)): aliasDic[WA[eachWAIndex]] = TL[eachWAIndex] returnedDic["object"] = cmds.listConnections(parentConstraint + ".constraintRotateX")[0] returnedDic["alias"] = aliasDic return returnedDic
def create_ik_setup(self): """Creates the IK setup.""" ik = cmds.ikHandle(sj=self.result_jnts[0], ee=self.result_jnts[-1], sol='ikSplineSolver', ns=1) cmds.rename(ik[1], '%s_%s_%s' % (self.side, 'neck', self.nc.effector)) curve = cmds.rename(ik[2], '%s_%s_%s' % (self.side, 'neck', self.nc.curve)) cmds.setAttr('%s.inheritsTransform' % curve, 0) ik = cmds.rename(ik[0], '%s_%s_%s' % (self.side, 'neck', self.nc.ikhandle)) cmds.select(self.additional_jnts, curve) cmds.skinCluster(tsb=True) cmds.parent(ik, self.top_grp) cmds.setAttr('%s.dTwistControlEnable' % ik, 1) cmds.setAttr('%s.dWorldUpType' % ik, 4) cmds.setAttr('%s.dWorldUpAxis' % ik, 4) cmds.setAttr('%s.dWorldUpVectorY' % ik, -1) cmds.setAttr('%s.dWorldUpVectorEndY' % ik, 1) cmds.setAttr('%s.dWorldUpVectorEndZ' % ik, -1) cmds.connectAttr('%s.worldMatrix[0]' % self.additional_jnts[0], '%s.dWorldUpMatrix' % ik, f=True) cmds.connectAttr('%s.worldMatrix[0]' % self.additional_jnts[1], '%s.dWorldUpMatrixEnd' % ik, f=True) self.head_grp = cmds.group(self.controls['head']) self.head_grp = cmds.rename(self.head_grp, '%s_head_CTL_%s' % (self.side, self.nc.group)) cmds.parent(self.head_grp, self.top_grp) self.c.move_pivot_to(self.guides['neckEnd'][0], self.guides['neckEnd'][1], self.guides['neckEnd'][2], self.head_grp) cmds.parentConstraint(self.controls['head'], self.additional_jnts[-1], mo=True, weight=1) cmds.orientConstraint(self.controls['head_rot'], self.result_jnts[-1], mo=True, weight=1)
def RMRedistributeConstraint(self,ListOfDrivers, ListOfConstrained, MaxInfluences, KeepBorders = True, ConstraintType = "parent"): DeltaMaxInfluence = 1/(float (len(ListOfDrivers))-1) CentersControlDic = {} for i in range (0,len( ListOfDrivers)): CentersControlDic[ListOfDrivers[i]] = ( DeltaMaxInfluence*i) pprint.pprint (CentersControlDic) DeltaPositionConstrained = float(1/(float(len(ListOfConstrained))-1)) PositionConstDic = {} for i in range(0,len( ListOfConstrained)): PositionConstDic[ListOfConstrained[i]] = (DeltaPositionConstrained*i) pprint.pprint (PositionConstDic) reach = MaxInfluences * DeltaMaxInfluence for eachConstrained in ListOfConstrained: for eachDriver in ListOfDrivers: weight = self.RMGaussCosine( PositionConstDic [ eachConstrained ], CentersControlDic [ eachDriver ], reach ) if weight > 0: if ConstraintType == "parent": cmds.parentConstraint(eachDriver, eachConstrained , weight = weight,mo = True) elif ConstraintType == "point": cmds.pointConstraint(eachDriver, eachConstrained , weight = weight,mo = True) elif ConstraintType == "orient": cmds.orientConstraint(eachDriver, eachConstrained , weight = weight,mo = True) else: print "not valid costraintType requested, valid types are point, parent, or orient"
def shadowRig(): controls = [ "translateX", "translateY", "translateZ", \ "rotateX", "rotateY", "rotateZ", \ "scaleX", "scaleY", "scaleZ", "v" ] negLightAttr = [ "decayRate", "emitSpecular", "useDepthMapShadows", \ "dmapResolution", "dmapFilterSize", "color", \ "shadowColor", "useRayTraceShadows", "lightRadius", \ "shadowRays"] # Create group shadowSpot = cmds.group(em=True, name='shadowSpot#') # Grab index index = None if re.search('[0-9]+$', shadowSpot): index = re.search('[0-9]+$', shadowSpot).group()[0] # Save spotlight names shadowLightName = ('shadowLight' + index) shadowNegLightName = ('shadowNegLight' + index) # Create spotlights shadowLight = cmds.spotLight( name=shadowLightName ) shadowNegLight = cmds.spotLight( name=shadowNegLightName ) # Add spotlights to group cmds.group( shadowLightName, shadowNegLightName, useAsGroup=shadowSpot ) # Create constraints cmds.pointConstraint( shadowLightName, shadowNegLightName ) cmds.orientConstraint( shadowLightName, shadowNegLightName ) # Connect shape attributes cmds.connectAttr( (shadowLight + '.coneAngle'), (shadowNegLight + '.coneAngle'), force=True ) cmds.connectAttr( (shadowLight + '.dropoff'), (shadowNegLight + '.dropoff'), force=True ) cmds.connectAttr( (shadowLight + '.penumbraAngle'), (shadowNegLight + '.penumbraAngle'), force=True ) # Create utility node shadowSpotIntensity = cmds.shadingNode( 'multiplyDivide', asUtility=True, name=(shadowSpot + 'mdIntensity') ) cmds.connectAttr( (shadowLight + '.intensity'), (shadowSpotIntensity + '.input1X') ) cmds.setAttr ( (shadowSpotIntensity + '.input2X'), -1 ) cmds.connectAttr ( (shadowSpotIntensity + '.outputX'), (shadowNegLight + '.intensity') ) # Zero out shadow light attributes cmds.setAttr ( (shadowNegLightName + ".useDepthMapShadows"), 0 ) cmds.setAttr ( (shadowNegLightName + ".useRayTraceShadows"), 0 ) # Lock attributes for attr in negLightAttr: cmds.setAttr ( (shadowNegLightName + "." + attr), lock=True, keyable=False ) # Lock and hide spotlight controls for control in controls: cmds.setAttr ( (shadowSpot + "." + control), lock=True, keyable=False ) cmds.setAttr ( (shadowNegLightName + "." + control), lock=True, keyable=False ) # Activate displayHandle cmds.setAttr ( (shadowLightName + ".displayHandle"), 1 )
def rehook_constrain(self, *args): group_sel = cmds.ls(sl=True, fl=True) for dummy_group in group_sel: locator_name = str(dummy_group) + '_constrain' dummy_geo_list = cmds.listRelatives(dummy_group, c=True) for dummy_geo in dummy_geo_list: cmds.orientConstraint( locator_name, dummy_geo )
def createFKControls(part, FK_Joints): print "In Create FK Controls" # create circle controllers for the FK chain circleCtl = [] circleCtlGrp = [] x = 0 for eachJoint in FK_Joints: # set the name here FKname = str(FK_Joints[x])[:len(FK_Joints[x])-6] # create the controller circleCtl.append(cmds.circle(sections=8, ch=False, n=FKname + "_CTRL")) # rotates the joint 90 degrees in y and freeze transformations cmds.xform(r=True, ro=(0, 90, 0), s=(0.5, 0.5, 0.5)) cmds.makeIdentity(apply=True, t=True, r=True, s=True, n=False) # groups the controller to itself, and renames circleCtlGrp.append(cmds.group(n=FKname + "_CTRL_GRP")) #parent constrains the group to the joint to place it in the correct place, and deletes the constraint fk_pctemp = cmds.parentConstraint(FK_Joints[x], circleCtlGrp[x], mo = False) cmds.delete(fk_pctemp) # orient constrains the joint to the controller cmds.orientConstraint(circleCtl[x], FK_Joints[x], mo = True) x += 1 y = 0 # parents the controls and groups up the hierarchy for eachGroup in circleCtlGrp: cmds.parent(circleCtlGrp[y+1], circleCtl[y]) y += 1 if y == len(circleCtlGrp)-1: break x = 0 handCtl = [] handCtlGrp = [] return circleCtl
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 install(self): cmds.select(d=True) # Create Ik joints self.rig_info['ikjnts']=utils.createJoint(self.module_info['ikjnts'], self.rig_info['positions'], self.instance) # Create Fk joints self.rig_info['fkjnts']=utils.createJoint(self.module_info['fkjnts'], self.rig_info['positions'], self.instance) # Create Rig joints self.rig_info['rigjnts']=utils.createJoint(self.module_info['rigjnts'], self.rig_info['positions'], self.instance) # Create Ik Rig # Ik handle #"ikcontrols": ["ctrl_ik_arm, ikh_arm", "ctrl_pv_arm" # Generate a name for the ik handle using self.instance ikhname = self.module_info["ikcontrols"][1].replace('_s_', self.instance) self.rig_info['ikh']=cmds.ikHandle(n=ikhname, sj=self.rig_info['ikjnts'][0], ee=self.rig_info['ikjnts'][2], sol='ikRPsolver', p=2, w=1 ) ikctrlname = self.module_info["ikcontrols"][0].replace('_s_', self.instance) self.rig_info['ikcontrol']=utils.createControl([[self.rig_info['positions'][2], ikctrlname, 'HandControl.ma']])[0] pvpos = utils.calculatePVPosition([self.rig_info['ikjnts'][0], self.rig_info['ikjnts'][1], self.rig_info['ikjnts'][2]]) self.rig_info['pvcontrol']=utils.createControl([[pvpos, self.module_info["ikcontrols"][2], 'RectangleControl.ma']])[0] # Make a control for arm settings self.rig_info['setcontrol']=utils.createControl([[self.rig_info['positions'][2], 'ctrl_settings', 'RectangleControl.ma']])[0] cmds.addAttr(self.rig_info['setcontrol'][1], ln='IK_FK', at="enum", en="fk:ik:", k=True ) # Parent ikh to ctrl cmds.parent(self.rig_info['ikh'][0], self.rig_info['ikcontrol'][1]) # PV constraint cmds.poleVectorConstraint(self.rig_info['pvcontrol'][1], self.rig_info['ikh'][0]) # orient constrain arm ik_wrist to ctrl_arm cmds.orientConstraint(self.rig_info['ikcontrol'][1], self.rig_info['ikjnts'][2], mo=True) # Create FK rig self.rig_info['fkcontrols'] = utils.createControl([[self.rig_info['positions'][0], self.module_info["fkcontrols"][0], 'RectangleControl.ma'], [self.rig_info['positions'][1], self.module_info["fkcontrols"][1], 'RectangleControl.ma'], [self.rig_info['positions'][2], self.module_info["fkcontrols"][2], 'RectangleControl.ma']]) # Parent fk controls cmds.parent(self.rig_info['fkcontrols'][2][0], self.rig_info['fkcontrols'][1][1]) cmds.parent(self.rig_info['fkcontrols'][1][0], self.rig_info['fkcontrols'][0][1]) # Connect Ik and Fk to Rig joints switchattr = self.rig_info['setcontrol'][1] + '.IK_FK' utils.connectThroughBC(self.rig_info['ikjnts'], self.rig_info['fkjnts'], self.rig_info['rigjnts'], self.instance, switchattr ) # Constrain fk joints to controls. [cmds.parentConstraint(self.rig_info['fkcontrols'][i][1], self.rig_info['fkjnts'][i], mo=True) for i in range(len(self.rig_info['fkcontrols']))] # SetupIk/Fk match scriptJob """
def orientConstraintCmd(maintainOffset): # Get selection Objects selection = cmds.ls (sl = True) # Error Checking if len(selection) != 2: raise Warning ("Please Select 2 Objects") return cmds.orientConstraint(selection[0], selection[1], maintainOffset=maintainOffset)
def build(self): self.main_grp = cmds.group(empty=1, name=(self.name + "_base_grp")) common.align(self.main_grp, self.target) self.main_jnt = cmds.joint(name=(self.main_grp.replace("grp", "jnt"))) self.orient_jnt = cmds.joint(name=(self.main_jnt.replace("base", "orient"))) cmds.select(self.main_jnt) self.reader_jnt = cmds.joint(name=(self.main_jnt.replace("base", "reader"))) cmds.setAttr(self.reader_jnt + ".t" + self.axis, 1.0) cmds.parentConstraint(self.orient_jnt, self.reader_jnt, mo=1) cmds.orientConstraint(self.target, self.orient_jnt)
def orient(self): """make a orient constraint between lists""" fromItems, toItems = self._getItemsInLists() maintainOffset = self.maintainOffset_chb.isChecked() if len( fromItems ) == 1: for toNode in toItems: mc.orientConstraint( fromItems[0].name, toNode.name, mo = maintainOffset ) else: for fromNode,toNode in zip( fromItems, toItems ): mc.orientConstraint( fromNode.name, toNode.name, mo = maintainOffset )
def constrain_geometry(self, *args): run_list = cmds.ls(sl=True, fl=True) for dummy_list in run_list: dummy_geo_list = cmds.listRelatives(dummy_list, c=True) dummy_locator = cmds.spaceLocator(n = dummy_list+'_constrain') #dummy_logo = cmds.textCurves( f='Times-Roman|h-1|w-400|c0', o = True, t=dummy_list + '_control' ) #cmds.parent( dummy_logo, dummy_locator, add=True ) for dummy_geo in dummy_geo_list: cmds.orientConstraint( dummy_locator, dummy_geo )
def CreateSpaceSwitchReverse(self, AfectedObject, SpaceObjects, ControlObject, Name = "spaceSwitch", constraintType = "parent", mo = True, sswtype = "enum"): # ''' Creates a simple space Switch that uses a reverse for simple solution it can only hold 2 spaces ''' if len(SpaceObjects) == 2: if sswtype == "enum": SpaceObjectShortName =[] for eachObject in SpaceObjects: SpaceObjectShortName.append(self.NameConv.RMGetAShortName(eachObject)) self.AddEnumParameters(SpaceObjectShortName, ControlObject, Name = Name) else: if Name=="": index = 0 SwitchName = 'SW' for eachString in SpaceObjects: SwitchName = SwitchName + self.NameConv.RMGetAShortName(eachString).title() index = index + 1 Name = SwitchName self.AddNumericParameter( ControlObject, Name = Name) reverse = cmds.shadingNode('reverse', asUtility=True, name = Name + "SWReverse") multiply = cmds.shadingNode('multiplyDivide', asUtility=True, name = Name + "SWMultDiv") #cmds.connectAttr(ControlObject + "." + Name, reverse + ".inputX") cmds.connectAttr(ControlObject + "." + Name, multiply + ".input1X") cmds.setAttr(multiply + ".input2X", 10) cmds.setAttr(multiply + ".operation", 2) cmds.connectAttr(multiply + ".outputX", reverse + ".inputX") for eachObject in SpaceObjects: if constraintType == "point": parentConstraint = cmds.pointConstraint (eachObject, AfectedObject, mo = mo, name = AfectedObject + "SpaceSwitchConstraint") WA = cmds.pointConstraint (parentConstraint, q = True, weightAliasList = True) elif constraintType == "orient": parentConstraint = cmds.orientConstraint (eachObject, AfectedObject, mo = mo, name = AfectedObject + "SpaceSwitchConstraint") WA = cmds.orientConstraint (parentConstraint, q = True, weightAliasList = True) elif constraintType == "parent": parentConstraint = cmds.parentConstraint (eachObject, AfectedObject, mo = mo, name = AfectedObject + "SpaceSwitchConstraint") WA = cmds.parentConstraint (parentConstraint, q = True, weightAliasList = True) cmds.setAttr("%s.interpType"%parentConstraint[0] , 0) if self.NameConv.RMIsNameInFormat (AfectedObject): reverse = self.NameConv.RMRenameBasedOnBaseName(AfectedObject, reverse, NewName = reverse) multiply = self.NameConv.RMRenameBasedOnBaseName(AfectedObject, multiply, NewName = multiply) parentConstraint[0] = self.NameConv.RMRenameBasedOnBaseName (AfectedObject, parentConstraint[0], NewName = Name) else: reverse = self.NameConv.RMRenameNameInFormat(reverse) multiply = self.NameConv.RMRenameNameInFormat(multiply) parentConstraint[0] = self.NameConv.RMRenameNameInFormat ( parentConstraint[0]) cmds.connectAttr( multiply + ".outputX", parentConstraint[0] + "." + WA[1]) cmds.connectAttr( reverse + ".outputX", parentConstraint[0]+ "." + WA[0])
def hook(self): """Hooks up the arm module to the shoulder. Sets up the space switching. """ hook = '%s_arm_shoulder_space_%s' % (self.side, self.nc.locator) result_const = '%s_arm_result_const_%s' % (self.side, self.nc.group) fk_const = '%s_arm_FK_const_%s' % (self.side, self.nc.group) ik_const = '%s_arm_base_IK_const_%s' % (self.side, self.nc.group) cmds.pointConstraint(hook, ik_const, mo=True, weight=1) cmds.pointConstraint(hook, fk_const, mo=True, weight=1) cmds.pointConstraint(hook, result_const, mo=True, weight=1) # rotation spaces body = '%s_arm_body_space_%s' % (self.side, self.nc.locator) root = '%s_arm_root_space_%s' % (self.side, self.nc.locator) self.c.snap_a_to_b(root, self.result_jnts[0]) self.c.snap_a_to_b(body, self.result_jnts[0]) fk_constr = cmds.orientConstraint(hook, body, root, fk_const, mo=True, weight=1)[0] result_constr = cmds.orientConstraint(hook, body, root, result_const, mo=True, weight=1)[0] cmds.setDrivenKeyframe('%s.%s_arm_shoulder_space_LOCW0' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=0, v=1) cmds.setDrivenKeyframe('%s.%s_arm_body_space_LOCW1' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=0, v=0) cmds.setDrivenKeyframe('%s.%s_arm_root_space_LOCW2' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=0, v=0) cmds.setDrivenKeyframe('%s.%s_arm_shoulder_space_LOCW0' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=1, v=0) cmds.setDrivenKeyframe('%s.%s_arm_body_space_LOCW1' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=1, v=1) cmds.setDrivenKeyframe('%s.%s_arm_root_space_LOCW2' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=1, v=0) cmds.setDrivenKeyframe('%s.%s_arm_shoulder_space_LOCW0' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=2, v=0) cmds.setDrivenKeyframe('%s.%s_arm_body_space_LOCW1' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=2, v=0) cmds.setDrivenKeyframe('%s.%s_arm_root_space_LOCW2' % (fk_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=2, v=1) cmds.setDrivenKeyframe('%s.%s_arm_shoulder_space_LOCW0' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=0, v=1) cmds.setDrivenKeyframe('%s.%s_arm_body_space_LOCW1' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=0, v=0) cmds.setDrivenKeyframe('%s.%s_arm_root_space_LOCW2' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=0, v=0) cmds.setDrivenKeyframe('%s.%s_arm_shoulder_space_LOCW0' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=1, v=0) cmds.setDrivenKeyframe('%s.%s_arm_body_space_LOCW1' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=1, v=1) cmds.setDrivenKeyframe('%s.%s_arm_root_space_LOCW2' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=1, v=0) cmds.setDrivenKeyframe('%s.%s_arm_shoulder_space_LOCW0' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=2, v=0) cmds.setDrivenKeyframe('%s.%s_arm_body_space_LOCW1' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=2, v=0) cmds.setDrivenKeyframe('%s.%s_arm_root_space_LOCW2' % (result_constr, self.side), cd='%s.FK_Rotation_Space' % self.switch_control, dv=2, v=1) # rotation bleed fix blend = cmds.shadingNode('blendColors', asUtility=True) blend = cmds.rename(blend, '%s_arm_result_orient_BLD' % self.side) cmds.connectAttr('%s.constraintRotate' % result_constr, '%s.color2' % blend, f=True) cmds.setAttr('%s.color1R' % blend, 0) cmds.disconnectAttr('%s.constraintRotateX' % result_constr, '%s.rotateX' % result_const) cmds.disconnectAttr('%s.constraintRotateY' % result_constr, '%s.rotateY' % result_const) cmds.disconnectAttr('%s.constraintRotateZ' % result_constr, '%s.rotateZ' % result_const) cmds.connectAttr('%s.output' % blend, '%s.rotate' % result_const, f=True) cmds.connectAttr('%s.FK_IK_Blend' % self.switch_control, '%s.blender' % blend, f=True) # temporary fix for arm cycle problem cmds.parent('%s_upperArmToElbowLengthStart_%s' % (self.side, self.nc.locator), '%s_shoulderEnd_result_%s' % (self.side, self.nc.joint))
def orientConstraint(master, slave, mo=False, attrList=['rx', 'ry', 'rz']): ''' Create a point constraint between the specifiec master and slave transforms. Only constrains open, settable channels. @param master: Constraint master transform. @type master: str @param slave: Constraint slave transform. @type slave: str @param mo: Maintain constraint offset @type mo: bool @param attrList: List of transform attributes to constrain. @type attrList: list ''' # ========== # - Checks - # ========== # Check Target (Master) if isinstance(master, types.StringTypes): if not mc.objExists(master): raise Exception('Constraint target "' + master + '" does not exist!') if not glTools.utils.transform.isTransform(master): raise Exception('Constraint target "' + master + '" is not a valid transform!') elif isinstance(master, types.ListType): for target in master: if not mc.objExists(target): raise Exception('Constraint target "' + target + '" does not exist!') if not glTools.utils.transform.isTransform(target): raise Exception('Constraint target "' + target + '" is not a valid transform!') # Check Slave if not mc.objExists(slave): raise Exception('Constraint slave "' + slave + '" does not exist!') if not glTools.utils.transform.isTransform(slave): raise Exception('Constraint slave "' + slave + '" is not a valid transform!') # Check Settable Channels sr = [] if not 'rx' in attrList or not mc.getAttr(slave + '.rx', se=True): sr.append('x') if not 'ry' in attrList or not mc.getAttr(slave + '.ry', se=True): sr.append('y') if not 'rz' in attrList or not mc.getAttr(slave + '.rz', se=True): sr.append('z') if not st: st = 'none' # Skip All Check if len(sr) == 3: print('No axis to constrain! Unable to create constraint...') return None # ===================== # - Create Constraint - # ===================== constraint = '' try: constraint = mc.orientConstraint(master, slave, sk=sr, mo=mo)[0] except Exception, e: raise Exception('Error creating constraint from "' + master + '" to "' + slave + '"! Exception msg: ' + str(e))
def __init__(self, prefix='new', scale=1.0, translateTo='', rotateTo='', parent='', shape=1, angle='y', lockChannels=['s', 'v']): ################################################################################################### # @param shape : 1 = circle # @param shape : 2 = square # @param shape : 2 = sphere control_object = None self.angle = angle if shape == 1: control_object = cmds.circle(n=prefix + '_CTL', normal=[0, 1, 0], ch=False, radius=1.0)[0] elif shape == 2: control_object = cmds.curve(n=prefix + '_CTL', d=1, p=[(-1, 0, -1), (-1, 0, 1), (1, 0, 1), (1, 0, -1), (-1, 0, -1)], k=[0, 1, 2, 3, 4]) elif shape == 3: control_object = cmds.circle(n=prefix + '_CTL', ch=False, normal=[1, 0, 0], radius=1.0)[0] add_shape = cmds.circle(n=prefix + '_CTL2', ch=False, normal=[0, 0, 1], radius=1.0)[0] cmds.parent(cmds.listRelatives(add_shape, shapes=True), control_object, r=True, s=True) cmds.delete(add_shape) elif shape == 4: control_object = cmds.circle(n=prefix + '_CTL', ch=False, normal=[1, 0, 0], radius=1.0)[0] add_shape_2 = cmds.circle(n=prefix + '_CTL3', ch=False, normal=[0, 1, 0], radius=1.0)[0] add_shape = cmds.circle(n=prefix + '_CTL2', ch=False, normal=[0, 0, 1], radius=1.0)[0] cmds.parent(cmds.listRelatives(add_shape, shapes=True), control_object, r=True, s=True) cmds.parent(cmds.listRelatives(add_shape_2, shapes=True), control_object, r=True, s=True) cmds.delete(add_shape) cmds.delete(add_shape_2) # result = tools.create_groups(control_object) cmds.scale(scale, scale, scale, control_object + ".cv[*]", relative=True) # public members: self.control = control_object self.root = result[0] self.auto = result[1] self.lockChannels = lockChannels self._angle = angle # translate control if cmds.objExists(translateTo): cmds.delete(cmds.pointConstraint(translateTo, self.root)) # rotate control if cmds.objExists(rotateTo): cmds.delete(cmds.orientConstraint(rotateTo, self.root)) # parent control if cmds.objExists(parent): cmds.parent(self.root, parent) # execute methods self.overide_color() self.lock_control_channels() self.setAngle(self._angle)
def build(self): ''' This is where the builds will happen. ''' super(Brow, self).build() # get all of the inputs to the node. side = self.getAttributeByName("side").getValue() anchor = self.getAttributeByName("anchor").getValue() browInner = self.getAttributeByName("browInner").getValue().format( side=side) browMain = self.getAttributeByName("browMain").getValue().format( side=side) browPeak = self.getAttributeByName("browPeak").getValue().format( side=side) curve = self.getAttributeByName("curve").getValue().format(side=side) browInnerJoint = self.getAttributeByName( "browInnerJoint").getValue().format(browInner=browInner) browMainJoint = self.getAttributeByName( "browMainJoint").getValue().format(browMain=browMain) browPeakJoint = self.getAttributeByName( "browPeakJoint").getValue().format(browPeak=browPeak) driverParent = self.getAttributeByName("driverParent").getValue() geometry = self.getAttributeByName("geometry").getValue() mc.parent(self.name, driverParent) # going to create the control hierarchies. browMainNul, browMainOrient, browMainCtrl = control.create( name=browMain, controlType="null", hierarchy=['nul', 'ort'], color=common.BLUE, parent=anchor, type='face') browInnerNul, browInnerOrient, browInnerCtrl = control.create( name=browInner, controlType="null", hierarchy=['nul', 'ort'], color=common.BLUE, parent=anchor, type='face') browPeakNul, browPeakOrient, browPeakCtrl = control.create( name=browPeak, controlType="null", hierarchy=['nul', 'ort'], color=common.BLUE, parent=anchor, type='face') # Position the controls # # Main mc.xform(browMainNul, ws=1, t=mc.xform(browMainJoint, q=1, ws=1, t=1)) con = mc.orientConstraint(browMainJoint, browMainOrient)[0] if '_r_' in browMainJoint: mc.setAttr(con + '.offsetZ', -180) mc.setAttr(browMainNul + '.ry', -180) mc.setAttr(browMainNul + '.sz', -1) mc.delete(con) # Inner mc.xform(browInnerNul, ws=1, t=mc.xform(browInnerJoint, q=1, ws=1, t=1)) con = mc.orientConstraint(browInnerJoint, browInnerOrient)[0] if '_r_' in browInnerJoint: mc.setAttr(con + '.offsetZ', -180) mc.setAttr(browInnerNul + '.ry', -180) mc.setAttr(browInnerNul + '.sz', -1) mc.delete(con) mc.xform(browPeakNul, ws=1, t=mc.xform(browPeakJoint, q=1, ws=1, t=1)) con = mc.orientConstraint(browPeakJoint, browPeakOrient)[0] if '_r_' in browPeakJoint: mc.setAttr(con + '.offsetZ', -180) mc.setAttr(browPeakNul + '.ry', -180) mc.setAttr(browPeakNul + '.sz', -1) mc.delete(con) mc.parent(browInnerNul, browMainCtrl) mc.parent(browPeakNul, browMainCtrl) # create the driver nodes browMainDriverNul = mc.createNode( "transform", name="{}_driver_nul".format(browMain), parent=self.name) browMainDriverOrt = mc.createNode( "transform", name="{}_driver_ort".format(browMain), parent=browMainDriverNul) browMainDriver = mc.createNode("joint", name="{}_driver".format(browMain), parent=browMainDriverOrt) # position the driver mc.xform(browMainDriverNul, ws=True, matrix=mc.xform(browMainNul, q=True, ws=True, matrix=True)) for attr in ['t', 'r', 's']: mc.connectAttr("{}.{}".format(browMainOrient, attr), "{}.{}".format(browMainDriverOrt, attr), f=True) mc.pointConstraint(browMainCtrl, browMainDriver) # TX and TY isolated drivers browMain_TX_driver = mc.duplicate( browMainDriver, po=1, name="{}_TX_driver".format(browMain))[0] browMain_TY_driver = mc.duplicate( browMainDriver, po=1, name="{}_TY_driver".format(browMain))[0] mc.connectAttr(browMainDriver + '.tx', browMain_TX_driver + '.tx') mc.connectAttr(browMainDriver + '.ty', browMain_TY_driver + '.ty') browInnerDriverNul = mc.createNode( "transform", name="{}_driver_nul".format(browInner), parent=self.name) browInnerDriverOrt = mc.createNode( "transform", name="{}_driver_ort".format(browInner), parent=browInnerDriverNul) browInnerDriver = mc.createNode("joint", name="{}_driver".format(browInner), parent=browInnerDriverOrt) # position the driver mc.xform(browInnerDriverNul, ws=True, matrix=mc.xform(browInnerNul, q=True, ws=True, matrix=True)) for attr in ['t', 'r', 's']: mc.connectAttr("{}.{}".format(browInnerOrient, attr), "{}.{}".format(browInnerDriverOrt, attr), f=True) mc.pointConstraint(browInnerCtrl, browInnerDriver) # TX and TY isolated drivers browInner_TX_driver = mc.duplicate( browInnerDriver, po=1, name="{}_TX_driver".format(browInner))[0] browInner_TY_driver = mc.duplicate( browInnerDriver, po=1, name="{}_TY_driver".format(browInner))[0] mc.connectAttr(browInnerDriver + '.tx', browInner_TX_driver + '.tx') mc.connectAttr(browInnerDriver + '.ty', browInner_TY_driver + '.ty') browPeakDriverNul = mc.createNode( "transform", name="{}_driver_nul".format(browPeak), parent=self.name) browPeakDriverOrt = mc.createNode( "transform", name="{}_driver_ort".format(browPeak), parent=browPeakDriverNul) browPeakDriver = mc.createNode("joint", name="{}_driver".format(browPeak), parent=browPeakDriverOrt) # position the driver mc.xform(browPeakDriverNul, ws=True, matrix=mc.xform(browPeakNul, q=True, ws=True, matrix=True)) for attr in ['t', 'r', 's']: mc.connectAttr("{}.{}".format(browPeakOrient, attr), "{}.{}".format(browPeakDriverOrt, attr), f=True) mc.pointConstraint(browPeakCtrl, browPeakDriver) # create the set driven key nodes. browMainSdkNul = mc.createNode("transform", name="{}_sdk_nul".format(browMain), parent=self.name) browMainSdkDefAuto = mc.createNode( "transform", name="{}_sdk_def_auto".format(browMain), parent=browMainSdkNul) browMainSdkRotDefAuto = mc.createNode( "transform", name="{}_sdk_rot_def_auto".format(browMain), parent=browMainSdkDefAuto) browMainSdk = mc.createNode("transform", name="{}_sdk".format(browMain), parent=browMainSdkRotDefAuto) # position the SDK nodes thanks mc.xform(browMainSdkNul, ws=True, matrix=mc.xform(browMainDriverOrt, q=True, ws=True, matrix=True)) # create the keys for the brow main sdk nodes for attribute in ['x', 'y', 'z']: mc.setDrivenKeyframe("{}.t{}".format(browMainSdkDefAuto, attribute), cd="{}.t{}".format(browMainDriver, attribute), v=0, dv=0) mc.setDrivenKeyframe("{}.t{}".format(browMainSdkDefAuto, attribute), cd="{}.t{}".format(browMainDriver, attribute), v=1, dv=1) mc.setDrivenKeyframe("{}.t{}".format(browMainSdkDefAuto, attribute), cd="{}.t{}".format(browMainDriver, attribute), v=-1, dv=-1) mc.setDrivenKeyframe("{}.r{}".format(browMainSdkRotDefAuto, attribute), cd="{}.t{}".format(browMainDriver, attribute), v=0, dv=0) mc.setDrivenKeyframe("{}.r{}".format(browMainSdkRotDefAuto, attribute), cd="{}.t{}".format(browMainDriver, attribute), v=.1, dv=1) mc.setDrivenKeyframe("{}.r{}".format(browMainSdkRotDefAuto, attribute), cd="{}.t{}".format(browMainDriver, attribute), v=-.1, dv=-1) # create the set driven key nodes. browInnerSdkNul = mc.createNode("transform", name="{}_sdk_nul".format(browInner), parent=self.name) browInnerSdkDefAuto = mc.createNode( "transform", name="{}_sdk_def_auto".format(browInner), parent=browInnerSdkNul) browInnerSdkRotDefAuto = mc.createNode( "transform", name="{}_sdk_rot_def_auto".format(browInner), parent=browInnerSdkDefAuto) browInnerSdk = mc.createNode("transform", name="{}_sdk".format(browInner), parent=browInnerSdkRotDefAuto) # position the SDK nodes mc.xform(browInnerSdkNul, ws=True, matrix=mc.xform(browInnerDriverOrt, q=True, ws=True, matrix=True)) # create the keys for the brow inner sdk nodes for attribute in ['x', 'y', 'z']: mc.setDrivenKeyframe("{}.t{}".format(browInnerSdkDefAuto, attribute), cd="{}.t{}".format(browInnerDriver, attribute), v=0, dv=0) mc.setDrivenKeyframe("{}.t{}".format(browInnerSdkDefAuto, attribute), cd="{}.t{}".format(browInnerDriver, attribute), v=1, dv=1) mc.setDrivenKeyframe("{}.t{}".format(browInnerSdkDefAuto, attribute), cd="{}.t{}".format(browInnerDriver, attribute), v=-1, dv=-1) mc.setDrivenKeyframe("{}.r{}".format(browInnerSdkRotDefAuto, attribute), cd="{}.t{}".format(browInnerDriver, attribute), v=0, dv=0) mc.setDrivenKeyframe("{}.r{}".format(browInnerSdkRotDefAuto, attribute), cd="{}.t{}".format(browInnerDriver, attribute), v=.1, dv=1) mc.setDrivenKeyframe("{}.r{}".format(browInnerSdkRotDefAuto, attribute), cd="{}.t{}".format(browInnerDriver, attribute), v=-.1, dv=-1) # create the set driven key nodes. browPeakSdkNul = mc.createNode("transform", name="{}_sdk_nul".format(browPeak), parent=self.name) browPeakSdkDefAuto = mc.createNode( "transform", name="{}_sdk_def_auto".format(browPeak), parent=browPeakSdkNul) browPeakSdkRotDefAuto = mc.createNode( "transform", name="{}_sdk_rot_def_auto".format(browPeak), parent=browPeakSdkDefAuto) browPeakSdk = mc.createNode("transform", name="{}_sdk".format(browPeak), parent=browPeakSdkDefAuto) # position the SDK nodes mc.xform(browPeakSdkNul, ws=True, matrix=mc.xform(browPeakDriverOrt, q=True, ws=True, matrix=True)) # create the keys for the brow peak sdk nodes for attribute in ['x', 'y', 'z']: mc.setDrivenKeyframe("{}.t{}".format(browPeakSdkDefAuto, attribute), cd="{}.t{}".format(browPeakDriver, attribute), v=0, dv=0) mc.setDrivenKeyframe("{}.t{}".format(browPeakSdkDefAuto, attribute), cd="{}.t{}".format(browPeakDriver, attribute), v=1, dv=1) mc.setDrivenKeyframe("{}.t{}".format(browPeakSdkDefAuto, attribute), cd="{}.t{}".format(browPeakDriver, attribute), v=-1, dv=-1) mc.setDrivenKeyframe("{}.r{}".format(browPeakSdkRotDefAuto, attribute), cd="{}.t{}".format(browPeakDriver, attribute), v=0, dv=0) mc.setDrivenKeyframe("{}.r{}".format(browPeakSdkRotDefAuto, attribute), cd="{}.t{}".format(browPeakDriver, attribute), v=.1, dv=1) mc.setDrivenKeyframe("{}.r{}".format(browPeakSdkRotDefAuto, attribute), cd="{}.t{}".format(browPeakDriver, attribute), v=-.1, dv=-1) # constrain the bind joints to the sdk nodes for jnt, sdkNode in zip((browMainJoint, browInnerJoint, browPeakJoint), (browMainSdk, browInnerSdk, browPeakSdk)): mc.pointConstraint(sdkNode, jnt) mc.orientConstraint(sdkNode, jnt) # create the corrugator corrugatorName = "brow_corrugator_{}".format(side) cluster.create(geometry, name=corrugatorName, parent=browInnerCtrl) # rename the cluster and control mc.rename(corrugatorName, '{}_cluster'.format(corrugatorName)) mc.rename('{}_ctrl'.format(corrugatorName), corrugatorName) mc.xform("{}_nul".format(corrugatorName), ws=True, matrix=mc.xform(browInnerCtrl, q=True, ws=True, matrix=True)) mc.setAttr("{}.displayHandle".format(corrugatorName), 1) control.tagAsControl(corrugatorName, type='face') # lock and hide scale and rotates for all of the brow controls rigrepo.libs.attribute.lockAndHide( [browMainCtrl, browInnerCtrl, browPeakCtrl, corrugatorName], ['r', 'rx', 'ry', 'rz', 's', 'sx', 'sy', 'sz']) # Set driven keys to be post and pre infinity driven_keys = mc.listConnections(browMainDriver, type='animCurveUA') driven_keys += mc.listConnections(browMainDriver, type='animCurveUL') driven_keys += mc.listConnections(browInnerDriver, type='animCurveUA') driven_keys += mc.listConnections(browInnerDriver, type='animCurveUL') driven_keys += mc.listConnections(browPeakDriver, type='animCurveUA') driven_keys += mc.listConnections(browPeakDriver, type='animCurveUL') for x in driven_keys: mc.setAttr(x + '.preInfinity', 1) mc.setAttr(x + '.postInfinity', 1) mc.keyTangent(x, index=(0, 0), inTangentType='spline') mc.keyTangent(x, index=(0, 0), outTangentType='spline') mc.keyTangent(x, index=(2, 2), inTangentType='spline') mc.keyTangent(x, index=(2, 2), outTangentType='spline') # create the curve rig for the brows. curveControlNames = [ 'brow_bend_{}_{}'.format(index, side) for index in range(len(mc.ls('{}.cv'.format(curve), fl=True))) ] curveRig = rigrepo.libs.wire.buildCurveRig( curve, name='brow_bend_{}'.format(side), ctrl_names=curveControlNames, parent=self.rigGroup, control_type='face', control_color=rigrepo.libs.common.RED) bindmeshGeometry, follicleList, controlHieracrchyList, jointList, baseCurveJointList = curveRig for controlHieracrchy in controlHieracrchyList: shapeNode = mc.listRelatives(controlHieracrchy[-1], c=True, shapes=True)[0] mc.setAttr('{}.lodv'.format(shapeNode), 0) # create the wire deformer. # create the skinCluster for the curve wireDeformer = mc.wire(geometry, gw=False, en=1.00, ce=0.00, li=0.00, w=curve, name="{}_wire".format(curve))[0] # set the default values for the wire deformer mc.setAttr("{}.rotation".format(wireDeformer), 0) mc.setAttr("{}.dropoffDistance[0]".format(wireDeformer), 100) # create skinCluster for the base wire baseCurve = "{}BaseWire".format(curve) baseCurveSkin = mc.skinCluster(*baseCurveJointList + mc.ls(baseCurve), n="{}_skinCluster".format(baseCurve), tsb=True)[0] # parent the curves into the hiearchy. mc.parent([curve, baseCurve], 'brow_bend_{}_grp'.format(side))
def createController(self): # create controller haindLegControllerName = controllerShape( self.IkHindLegJointList[3].replace( 'ball_JNT', 'hindLeg_CON' ), 'cube', 'blue' ) cmds.move( self.anklePos[0], self.anklePos[1], self.anklePos[2], haindLegControllerName ) hipControllerName = controllerShape( self.IkHindLegJointList[0].replace( 'JNT', 'CON' ), 'cube', 'blue' ) POsnap( hipControllerName, self.IkHindLegJointList[0] ) hipWorldControllerName = controllerShape( self.IkHindLegJointList[0].replace( 'JNT', 'world_CON' ), 'cube', 'blue' ) Psnap( hipWorldControllerName, self.IkHindLegJointList[0] ) kneePVContollerName = cmds.spaceLocator( n=self.IkHindLegJointList[1].replace( 'JNT', 'LOC' ) )[0] kneePVPos = cmds.xform( self.IkHindLegJointList[0], t=True, ws=True, q=True ) cmds.move( kneePVPos[0], kneePVPos[1], kneePVPos[2] + 20, kneePVContollerName ) anklePVContollerName = controllerShape( self.IkHindLegJointList[2].replace( 'JNT', 'CON' ), 'sphere', 'blue' ) anklePVPos = cmds.xform( self.IkHindLegJointList[2], t=True, ws=True, q=True ) cmds.move( anklePVPos[0], anklePVPos[1], anklePVPos[2], anklePVContollerName ) # controller homeNull homeNul( haindLegControllerName ) hipNul = homeNul( hipControllerName ) hipRotZNul = homeNul( hipControllerName, hipNul.replace( 'hip', 'hipRotZ' ) ) hipNulWorldNul = homeNul( hipWorldControllerName ) kneePVNul = homeNul( kneePVContollerName ) homeNul( anklePVContollerName ) # constraints & grouping cmds.parent( self.pivotNulList[0], haindLegControllerName ) cmds.parent( kneePVNul, hipControllerName ) cmds.parent( hipNul, hipWorldControllerName ) if self.side != 'R' : cmds.aimConstraint( haindLegControllerName, hipRotZNul, mo=True, weight=1, aimVector=[ 1, 0, 0 ], upVector=[ 0, 1, 0 ], worldUpType='none', skip=[ 'x', 'y' ] ) else : cmds.aimConstraint( haindLegControllerName, hipRotZNul, mo=True, weight=1, aimVector=[ -1, 0, 0 ], upVector=[ 0, 1, 0 ], worldUpType='none', skip=[ 'x', 'y' ] ) cmds.pointConstraint( hipControllerName, self.IkHindLegJointList[0] ) cmds.pointConstraint( hipControllerName, self.subIkJointList[0] ) cmds.orientConstraint( hipControllerName, self.subIkJointList[0] ) cmds.poleVectorConstraint( anklePVContollerName, self.sRPsName ) cmds.poleVectorConstraint( kneePVContollerName, self.RPsName ) # addAttr & connection cmds.addAttr( haindLegControllerName, longName='auto', at='enum', en='Angle', keyable=True ) cmds.setAttr( '%s.auto' % haindLegControllerName, lock=True ) cmds.addAttr( haindLegControllerName, longName='front', at='double', keyable=True, attributeType='float', min=0, max=1, dv=0.5 ) cmds.addAttr( haindLegControllerName, longName='subController', at='enum', en='Visibility', keyable=True ) cmds.setAttr( '%s.subController' % haindLegControllerName, lock=True ) cmds.addAttr( haindLegControllerName, longName='vis', at='bool', keyable=True ) cmds.setKeyframe( '%s.rz' % hipRotZNul ) cmds.disconnectAttr( 'pairBlend1_inRotateZ1.output', 'pairBlend1.inRotateZ1' ) cmds.delete( 'pairBlend1_inRotateZ1' ) cmds.rename( 'pairBlend1', hipRotZNul.replace( 'NUL', 'PBD' ) ) cmds.connectAttr ( '%s.front' % haindLegControllerName, '%s.blendAim1' % hipRotZNul ) # create foot controller ankleRollCONT = controllerShape( self.anklePivotName.replace( 'PIVOT', 'CON' ), 'cube', 'yellow' ) cvNum = cmds.getAttr( '%s.spans' % ankleRollCONT ) + cmds.getAttr( '%s.degree' % ankleRollCONT ) cmds.select( '%s.cv[0:%s]' % ( ankleRollCONT, cvNum-1 ) ) cmds.scale( 0.5, 0.5, 0.5 ) cmds.select( cl=True ) cmds.parent( '%sShape' % ankleRollCONT, self.anklePivotName, r=True, s=True ) cmds.delete( ankleRollCONT ) ankleRollCON = cmds.rename( self.anklePivotName, self.anklePivotName.replace( 'PIVOT', 'CON' ) ) for x in range( len( self.pivotList ) ): CONT = controllerShape( self.pivotList[x].replace( 'PIVOT', 'CON' ), 'cube', 'yellow' ) cvNum = cmds.getAttr( '%s.spans' % CONT ) + cmds.getAttr( '%s.degree' % CONT ) cmds.select( '%s.cv[0:%s]' % ( CONT, cvNum-1 ) ) cmds.scale( 0.5, 0.5, 0.5 ) cmds.select( cl=True ) cmds.parent( '%sShape' % CONT, self.pivotList[x], r=True, s=True ) cmds.delete( CONT ) ankleRollCON = cmds.rename( self.pivotList[x], self.pivotList[x].replace( 'PIVOT', 'CON' ) ) cmds.connectAttr( '%s.vis' % haindLegControllerName, '%s.visibility' % self.pivotNulList[0] )
def constrainSelected(copyBreakdowns=True, frameRange=False, nodeList=None, info=True, skipUD=True, keyLocOnEveryFrame=True, bakeGrp='ConstraintLocators_grp', smartKey=True): """ """ print 'info = {0}'.format(info) print 'keyLocOnEveryFrame = {0}'.format(keyLocOnEveryFrame) print 'frameRange = {0}'.format(frameRange) locDescriptor = 'Constraint' locSuffix = '_loc' cmds.refresh(suspend=True) locList = [] currTime = cmds.currentTime(q=True) if frameRange: timeMin = cmds.playbackOptions(q=1, min=1) timeMax = cmds.playbackOptions(q=1, max=1) if info: print('timeMin = ' + str(timeMin)) print('timeMax = ' + str(timeMax)) nodeList = nodeList or cmds.ls(sl=True) try: cmds.undoInfo(openChunk=True) if info: print('nodeList = ' + str(nodeList)) if not len(nodeList): raise Exception() if not cmds.objExists(bakeGrp): cmds.createNode('transform', n=bakeGrp) keyFrameInfo = {} for (i, each) in enumerate(nodeList): print each, '(', i + 1, '/', len(nodeList), ')' keyFrameInfo[each] = {} # Query keyframe info udList = cmds.listAttr(each, ud=1) if info: print('udList = ' + str(udList)) keyframes = cmds.keyframe(each, query=True, name=True) keyFrameInfo[each]['keyframes'] = keyframes if keyframes: timeList = sorted( list( set( cmds.keyframe(keyframes, query=True, timeChange=True)))) else: timeList = [cmds.currentTime(q=1)] keyFrameInfo[each]['timeList'] = timeList keyFrameInfo[each]['udList'] = udList if info: print('timeList = ' + str(timeList)) locName = '{}{}{}'.format(each, locDescriptor, locSuffix) if cmds.objExists(locName): foo = 0 if info: print('locName "' + str(locName) + '" already exists...') while cmds.objExists(locName): foo += 1 locName = '{}{}{}{}'.format(each, locDescriptor, foo, locSuffix) if info: print('new locName = "' + str(locName) + '" ') conLoc = cmds.spaceLocator(n=locName)[0] keyFrameInfo[each]['conLoc'] = conLoc if info: print('Created Constraint Locator "' + str(conLoc) + '"') cmds.addAttr(conLoc, at='message', ln=MESSAGEATTR) cmds.connectAttr('{0}.message'.format(each), '{0}.{1}'.format(conLoc, MESSAGEATTR)) locList.append(conLoc) cmds.parent(conLoc, bakeGrp) # Gather the earliest start frame frameList = [] for each in keyFrameInfo: timeList = keyFrameInfo[each]['timeList'] if keyLocOnEveryFrame: if info: print('keyLocOnEveryFrame') keyLocEveryFrameMin = timeMin if frameRange else timeList[0] if info: print('keyLocEveryFrameMin = {0}'.format( keyLocEveryFrameMin)) keyLocEveryFrameMax = timeMax if frameRange else timeList[-1] if info: print('keyLocEveryFrameMax = {0}'.format( keyLocEveryFrameMax)) timeList = range(int(keyLocEveryFrameMin), int(keyLocEveryFrameMax + 1)) if info: print '"{0}" timeList = {1}'.format(each, timeList) keyFrameInfo[each]['timeList'] = timeList frameList = frameList + timeList frameList = sorted(set(frameList)) if info: print 'frameList = {0}'.format(frameList) if info: print 'keyFrameInfo = {0}'.format(keyFrameInfo) if frameRange: frameListCopy = copy.copy(frameList) frameList = [] for frame in frameListCopy: if frame < timeMin: continue if frame > timeMax: break frameList.append(frame) # Iterate through each frame pacList = [] gMainProgressBar = mel.eval('$tmp = $gMainProgressBar') cmds.progressBar(gMainProgressBar, edit=True, beginProgress=True, isInterruptable=True, status='querying frames...', maxValue=len(frameList)) progressBarCancelled = False for frame in frameList: if cmds.progressBar(gMainProgressBar, query=True, isCancelled=True): progressBarCancelled = True break cmds.progressBar(gMainProgressBar, edit=True, step=1, status='frame {0}'.format(frame)) cmds.currentTime(frame) if info: print '\n========================' if info: print 'frame: {0}'.format(frame) for each in keyFrameInfo: if info: print '{}'.format(each) # check if the current frame is in each timelist if not frame in keyFrameInfo[each]['timeList']: # continue on if it's not continue conLoc = keyFrameInfo[each]['conLoc'] keyframes = keyFrameInfo[each]['keyframes'] # check if we've already connected the locator for baking if not 'startFrame' in keyFrameInfo[each]: if info: print '"startFrame" not in keyFrameInfo["{0}"], defining...'.format( each) # store the start frame if we haven't keyFrameInfo[each]['startFrame'] = frame # Setup constraint to constraint locator # with an initial keyframe, so that when # the constraint is made we get a pairblend cmds.delete(cmds.parentConstraint(each, conLoc)) cmds.setKeyframe(conLoc) pacList.append(cmds.parentConstraint(each, conLoc)[0]) # Query additional information for breakdowns settings if copyBreakdowns: if info: print('copyBreakdowns = ' + str(copyBreakdowns)) roVal = cmds.getAttr('{0}.ro'.format(each)) cmds.setAttr('{0}.ro'.format(conLoc), roVal) # query associated attributes keyFrameInfo[each]['keyable'] = {} for keyframe in keyframes: connections = cmds.listConnections(keyframe, plugs=1, s=0, d=1) xAttr = connections[0].split('.')[1] if udList: if skipUD and xAttr in keyFrameInfo[each][ 'udList']: if info: print 'xAttr "{0}" in udList, skipping...'.format( xAttr) continue keyFrameInfo[each]['keyable'][keyframe] = {} keyFrameInfo[each]['keyable'][keyframe][ 'attr'] = xAttr if info: print( 'keyFrameInfo["{0}"]["{1}"][\'attr\'] = {2}' .format( each, keyframe, keyFrameInfo[each] ['keyable'][keyframe]['attr'])) keyFrameInfo[each]['keyable'][keyframe][ 'tList'] = cmds.keyframe(keyframe, query=1, timeChange=1) keyFrameInfo[each]['keyable'][keyframe][ 'vList'] = cmds.keyframe(keyframe, query=1, valueChange=1) # set keys if keyLocOnEveryFrame: if info: print 'keyLocOnEveryFrame' cmds.setKeyframe(conLoc) elif copyBreakdowns: if info: print 'copyBreakdowns' for keyframe in keyFrameInfo[each]['keyable']: if info: print 'keyframe = "{0}"'.format(keyframe) ''' if not keyframe in keyFrameInfo[each]['keyable']: if info: print 'not "{0}" in {1}'.format(keyframe, keyFrameInfo[each]['keyable']) continue ''' if not frame in keyFrameInfo[each]['keyable'][ keyframe]['tList']: if info: print('not "{}" in {}'.format( frame, keyFrameInfo[each]['keyable'] [keyframe]['tList'])) if smartKey: cmds.setKeyframe(conLoc, attribute=keyFrameInfo[each] ['keyable'][keyframe]['attr']) continue index = keyFrameInfo[each]['keyable'][keyframe][ 'tList'].index(frame) breakdown = cmds.keyframe(keyframe, query=1, index=(index, index), breakdown=1) bd = True if breakdown else False cmds.setKeyframe(conLoc, attribute=keyFrameInfo[each] ['keyable'][keyframe]['attr'], breakdown=bd) if info: print('setKeyframe("{}")'.format(conLoc)) else: if info: print 'not keyLocOnEveryFrame or copyBreakdowns' cmds.setKeyframe(conLoc) # clean up cmds.delete(pacList) # Now attach destination nodes to constraint locators if not progressBarCancelled: for each in keyFrameInfo: conLoc = keyFrameInfo[each]['conLoc'] constrainMulti = False try: cmds.orientConstraint(conLoc, each) constrainMulti = True print 'could orient constrain' except: pass try: cmds.pointConstraint(conLoc, each) constrainMulti = True print 'could point constrain' except: pass if not constrainMulti: channels = ['x', 'y', 'z'] for channel in channels: channelList = copy.copy(channels) channelList.pop(channelList.index(channel)) try: cmds.orientConstraint(conLoc, each, skip=channelList) print 'could orient constrain ', channel except: pass try: cmds.pointConstraint(conLoc, each, skip=channelList) print 'could point constrain ', channel except: pass else: cmds.warning( 'constrain selected cancelled, skipping constraining to locators...' ) except Exception as E: traceback.print_exc(file=sys.stderr) cmds.progressBar(gMainProgressBar, edit=True, endProgress=True) cmds.refresh(suspend=False) cmds.undoInfo(closeChunk=True) cmds.progressBar(gMainProgressBar, edit=True, endProgress=True) cmds.refresh(suspend=False) cmds.currentTime(currTime) cmds.select(nodeList) cmds.undoInfo(closeChunk=True)
def setupControl(self,*args): #Load variables name = cmds.textFieldButtonGrp(self.nameField,q=True,text=True) control = cmds.textFieldButtonGrp(self.controlField,q=True,text=True) rivet = cmds.textFieldButtonGrp(self.rivetField,q=True,text=True) constObj = cmds.textFieldButtonGrp(self.jointField,q=True,text=True) #Load selection verts = cmds.ls(sl=True,fl=True) #Create Cluster clusterName,clusterHandle = cmds.cluster(rel=True,n=name+'_clstr') #Delete Rivet's aim constraint because it causes flipping if the rivets lofted nurbs plane flips. #Add parent constraint to object.(constObj) try: temp = cmds.listConnections(rivet) cmds.delete(temp[1]) except: # No constraint to delete on rivet pass #Rivet WS location rivetLocation = cmds.xform(rivet,q=True,ws=True,t=True) #Snap Cluster pivots to rivetLocation self.move(clusterHandle, rivetLocation,t=False,sp=True,rp=True) #Snap Controls pivots to rivetLocation self.move(control, rivetLocation,t=False,sp=True,rp=True) #Group Cluster clusterGrp = cmds.group(clusterHandle) clusterGrp = cmds.rename(clusterGrp, name + 'Cluster_' + clusterHandle) #Create over ride group or_grp = cmds.group(em=True,name=name+"OR1") or2_grp = cmds.group(em=True,name=name+"OR2") #Parent override group to rivet cmds.parent(or_grp,or2_grp) cmds.parent(or2_grp,rivet) #Freeze transforms on override group cmds.makeIdentity(or_grp,apply=True,t=True,r=True,s=True,n=True) #Zero Control zeroNode = cmds.group(em=True,n=name + "nullGrp") pos = cmds.xform( control, q=1, ws=True, t=1) cmds.xform( zeroNode, ws=True, t=[pos[0], pos[1], pos[2]]) rot = cmds.xform( control, q=1, ws=True, ro=1) cmds.xform( zeroNode, ws=True, ro=[rot[0], rot[1], rot[2]]) scale = cmds.xform( control, q=1, r=1, s=1) cmds.xform( zeroNode, ws=True, s=[scale[0], scale[1], scale[2]]) #Snap zeroNode pivot to control controlLocation = cmds.xform(control,q=True,ws=True,rp=True) self.move(zeroNode, controlLocation, t=False, sp=True, rp=True) #parent control to OverRide group cmds.parent(control, zeroNode, a=True) cmds.parent(zeroNode,or_grp) #Connect control t,r,s to cluster, then hide the cluster and rivet group cmds.connectAttr(control + ".translate", clusterHandle + ".translate") cmds.connectAttr(control + ".rotate", clusterHandle + ".rotate") cmds.connectAttr(control + ".scale", clusterHandle + ".scale") #Create utility node and negate double transform #by reversing the transformation of or_grp <---- Cause of double transforms mdNode = cmds.createNode("multiplyDivide") nodeName = name + "_MD" cmds.rename(mdNode,nodeName) mdNode = nodeName #Unparent control cmds.parent(zeroNode,w=True) #Set up the MD node cmds.setAttr( "%s.input2X"%mdNode, -1) cmds.setAttr( "%s.input2Y"%mdNode, -1) cmds.setAttr( "%s.input2Z"%mdNode, -1) #Connect the nodes # control ---> mdNode cmds.connectAttr("%s.translateX"%control,"%s.input1X"%mdNode,f=True) cmds.connectAttr("%s.translateY"%control,"%s.input1Y"%mdNode,f=True) cmds.connectAttr("%s.translateZ"%control,"%s.input1Z"%mdNode,f=True) #mdNode ---> or_grp cmds.connectAttr("%s.outputX"%mdNode,"%s.translateX"%or_grp,f=True) cmds.connectAttr("%s.outputY"%mdNode,"%s.translateY"%or_grp,f=True) cmds.connectAttr("%s.outputZ"%mdNode,"%s.translateZ"%or_grp,f=True) #Reparent control cmds.parent(zeroNode,or_grp) #Get mesh name # ex. "meshName.vtx[35]" mesh = verts[0].split('.')[0] #Get meshDeformer meshDeformer = mel.eval('findRelatedSkinCluster("%s");'%mesh) """ history = cmds.listHistory(mesh) for each in history: #print " History: " + each if("skinCluster" in str(each)): #Possible match for meshDeformer if("Group" not in str(each)): meshDeformer = each if("cMuscleSystem" in str(each)): if("Group" not in str(each)): meshDeformer = each """ #Reorder deformer nodes #Move cluster + meshDeformer to top of deformer stack cmds.reorderDeformers(clusterHandle,meshDeformer,mesh) #Move meshDeformer to top of deformer stack cmds.reorderDeformers(meshDeformer,clusterHandle,mesh) #Create final group topGrp = cmds.group(em=True,name=name+"_followCnt_grp") cmds.parent(clusterGrp,rivet,topGrp) #Orient constrain rivet to constrain object cmds.orientConstraint(constObj,rivet,mo=True) #Hide cluster grp cmds.setAttr(clusterGrp + ".visibility",0) #Hide the rivet rivetShape = cmds.listRelatives(rivet,shapes=True) cmds.setAttr(rivetShape[0] + ".visibility",0) #Clear selection cmds.select(clear=True)
def setIK(self, *jnt): buffer = [] copied = [] crv = '' tmp = cmds.listRelatives(jnt[0], c=1, ad=1) c = jnt[0] buffer.append(c) for i in range(len(tmp)): if jnt[-1] in c: break else: c = cmds.listRelatives(c, c=True) buffer.append(c[0]) #조인트 복사 및 중복된 네임 정리 for e in buffer: name = e.split('_')[0] + '_IK_' + e.split('_')[2] dup = cmds.duplicate(e, n=name, rr=True, rc=True) tmp = setUniqueName(dup[0], 'JNT') par = cmds.listRelatives(tmp, p=True, typ='joint') chi = cmds.listRelatives(tmp, c=True, typ='joint') if par is not None: if len(copied) is not 0: cmds.parent(tmp, copied[-1]) if cmds.connectionInfo(tmp + '.inverseScale', id=True) is False: cmds.connectAttr(copied[-1] + '.scale', tmp + '.inverseScale', f=True) if chi is not None: cmds.delete(chi) copied.append(tmp) #커브 그리기 for i in range(len(copied)): pos = cmds.xform(copied[i], q=True, ws=True, t=True) if i is 0: continue elif copied[i] is copied[1]: tmp = cmds.curve(n='C_IK_spineCurve', d=3, p=pos) crv = setUniqueName(tmp, 'CRV') else: cmds.curve(crv, a=True, p=pos) cmds.parent(copied[0], 'IKJoint_GRP') tmp = ikHandleMaker(copied[1], copied[-1], 'ikSplineSolver', crv) hdl = cmds.rename(tmp[0], copied[0].replace('JNT', 'HDL')) cmds.parent(crv, hdl, 'auxillary_GRP') #컨트롤러 생성 / 스플라인 커브 컨트롤 셋 cons = splineControllerMaker(crv, hdl) #스플라인 스트레치 연결 st = splineStretchy() st.stretchy(cons[1], crv, copied[1], copied[2], copied[3]) #힙 컨트롤러 생성 buf = controllerShape('C_IK_hip', 'square', 'yellow') hip = setUniqueName(buf, 'CON') hipNul = homeNul(hip) cmds.delete(cmds.parentConstraint(cons[0], hipNul, w=True)) cmds.parentConstraint(hip, copied[0], mo=True) cmds.parent(hipNul, cons[0]) cmds.orientConstraint(cons[1], copied[-1], mo=True) #루트 컨트롤러 생성 cmds.delete(cmds.parentConstraint(cons[0], 'root_NUL', w=True)) cons.append(hip) #return control curves return cons
def chain_create(self, objs = None, fwd = None, up=None, name = None, upSetup = "guess", extendStart = None, extendEnd = True, mNucleus=None, upControl = None, aimUpMode = None, **kws): _str_func = 'chain_create' if not objs: _sel = mc.ls(sl=1) if _sel:objs = _sel ml = cgmMeta.asMeta( objs, noneValid = True ) ml_baseTargets = copy.copy(ml) if not ml: return log.warning("No objects passed. Unable to chain_create") if not name: name = ml[-1].p_nameBase _idx = self.get_nextIdx() #Make our sub group... mGrp = self.doCreateAt(setClass=1) mGrp.p_parent = self mGrp.rename("chain_{0}_grp".format(name)) mGrp.dagLock() self.connectChildNode(mGrp.mNode,'chain_{0}'.format(_idx),'owner') #holders and dat... ml_targets = [] ml_posLocs = [] ml_aim_locs = [] fwd = fwd or self.fwd up = up or self.up upSetup = upSetup or self.upSetup extendStart = extendStart or self.extendStart extendEnd = extendEnd or self.extendEnd upControl = upControl or self.upControl aimUpMode = aimUpMode or self.aimUpMode #fwdAxis = simpleAxis(fwd) #upAxis = simpleAxis(up) fwdAxis = TRANS.closestAxisTowardObj_get(ml[0], ml[1]) upAxis = TRANS.crossAxis_get(fwdAxis) mGrp.doStore('fwd', fwdAxis.p_string) mGrp.doStore('up', upAxis.p_string) #Curve positions... l_pos = [] if upSetup == 'manual': if len(ml) < 2: log.debug(cgmGEN.logString_msg(_str_func, 'Single count. Adding extra handle.')) mLoc = ml[0].doLoc() mLoc.rename("chain_{0}_end_loc".format(name)) _size = DIST.get_bb_size(ml[0],True,'max') mLoc.p_position = ml[0].getPositionByAxisDistance(fwdAxis.p_string,_size) ml.append(mLoc) mLoc.p_parent = mGrp for obj in ml: l_pos.append(obj.p_position) _v_baseDist = DIST.get_distance_between_points(l_pos[-1],l_pos[-2]) _v_baseDist = MATHUTILS.Clamp(_v_baseDist, .5,None) _p_baseExtend = DIST.get_pos_by_axis_dist(ml[-1], fwdAxis.p_string, _v_baseDist) if extendEnd: log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd...')) extendEnd = VALID.valueArg(extendEnd) if issubclass(type(extendEnd),bool):#VALID.boolArg(extendEnd): log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd | guess')) l_pos.append(_p_baseExtend) elif extendEnd: log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd | {0}'.format(extendEnd))) l_pos.append( DIST.get_pos_by_axis_dist(ml[-1], fwdAxis.p_string, extendEnd )) else: l_pos.append( _p_baseExtend) if extendStart: f_extendStart = VALID.valueArg(extendStart) if f_extendStart: l_pos.insert(0, DIST.get_pos_by_axis_dist(ml[0], fwdAxis.inverse.p_string, f_extendStart )) else: log.debug(cgmGEN.logString_msg(_str_func, 'Resolving aim')) if len(ml) < 2: return log.error(cgmGEN.logString_msg(_str_func, 'Single count. Must use manual upSetup and aim/up args')) for obj in ml: l_pos.append(obj.p_position) _vecEnd = MATHUTILS.get_vector_of_two_points(l_pos[-2],l_pos[-1]) if extendEnd: log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd...')) extendEnd = VALID.valueArg(extendEnd) if issubclass(type(extendEnd),bool):#VALID.boolArg(extendEnd): log.debug(cgmGEN.logString_msg(_str_func, 'extendEnd | guess')) l_pos.append( DIST.get_pos_by_vec_dist(l_pos[-1], _vecEnd, (DIST.get_distance_between_points(l_pos[-2],l_pos[-1])/2))) elif extendEnd: log.debug(cgmGEN.logString_msg(_str_func, 'extendStart | {0}'.format(extendEnd))) l_pos.append( DIST.get_pos_by_vec_dist(l_pos[-1], _vecEnd, extendEnd)) if extendStart: f_extendStart = VALID.valueArg(extendStart) if f_extendStart: log.debug(cgmGEN.logString_msg(_str_func, 'extendStart...')) _vecStart = MATHUTILS.get_vector_of_two_points(l_pos[1],l_pos[0]) l_pos.insert(0, DIST.get_pos_by_vec_dist(l_pos[0], _vecStart, f_extendStart)) #pprint.pprint(l_pos) #for i,p in enumerate(l_pos): # LOC.create(position=p,name='p_{0}'.format(i)) crv = CORERIG.create_at(create='curve',l_pos= l_pos, baseName = name) mInCrv = cgmMeta.asMeta(crv) mInCrv.rename("{0}_inCrv".format(name)) mGrp.connectChildNode(mInCrv.mNode,'mInCrv') mc.select(cl=1) # make the dynamic setup log.debug(cgmGEN.logString_sub(_str_func,'dyn setup')) b_existing = False b_existing_nucleus = False mHairSys = self.getMessageAsMeta('mHairSysShape') if mHairSys: mHairSysDag = mHairSys.getTransform(asMeta=1) log.info(cgmGEN.logString_msg(_str_func,'Using existing system: {0}'.format(mHairSys.mNode))) mc.select(mHairSysDag.mNode, add=True) b_existing = True if self.useExistingNucleus or mNucleus: mNucleus = self.get_nucleus(mNucleus) if mNucleus: #mc.select(mNucleus.mNode,add=1) b_existing_nucleus = True log.info(cgmGEN.logString_msg(_str_func,'Using existing nucleus: {0}'.format(mNucleus.mNode))) self.connectChildNode(mNucleus.mNode,'mNucleus') mc.select(mInCrv.mNode,add=True) mel.eval('makeCurvesDynamic 2 { "0", "0", "1", "1", "0" }') # get relevant nodes follicle = mc.listRelatives(mInCrv.mNode,parent=True)[0] mFollicle = cgmMeta.asMeta(follicle) mFollicle.rename("{0}_foll".format(name)) parent = mFollicle.getParent(asMeta=1) mFollicle.p_parent = mGrp mFollicleShape = mFollicle.getShapes(1)[0] mc.delete(parent.mNode) _follicle = mFollicle.mNode mGrp.connectChildNode(mFollicle.mNode,'mFollicle','group') follicleShape = mFollicleShape.mNode#mc.listRelatives(mFollicle.mNode, shapes=True)[0] _hairSystem = mc.listRelatives( mc.listConnections('%s.currentPosition' % follicleShape)[0], shapes=True)[0] if not b_existing: mHairSys = cgmMeta.asMeta(_hairSystem) mHairSysDag = mHairSys.getTransform(asMeta=1) mHairSysDag.rename("{0}_hairSys".format(self.baseName)) self.connectChildNode(mHairSysDag.mNode,'mHairSysDag','owner') self.connectChildNode(mHairSys.mNode,'mHairSysShape','owner') mHairSysDag.p_parent = self _hairSystem = mHairSys.mNode outCurve = mc.listConnections('%s.outCurve' % _follicle)[0] mCrv = cgmMeta.asMeta(outCurve) parent = mCrv.getParent(asMeta=1) outCurveShape = mc.listRelatives(mCrv.mNode, shapes=True)[0] mCrv.p_parent = mGrp.mNode mc.delete(parent.mNode) _nucleus = mc.listConnections( '%s.currentState' % mHairSys.mNode )[0] if not b_existing_nucleus: mNucleus = cgmMeta.asMeta(_nucleus) mNucleus.rename("cgmDynFK_nucleus") #self.connectChildNode(mNucleus.mNode,'mNucleus','owner') self.connectChildNode(mNucleus.mNode,'mNucleus') if self.startFrame is not None: mNucleus.startFrame = self.startFrame else: #Because maya is crappy we gotta manually wire the existing nucleus ##startFrame out to startFrame in ##outputObjects[x] - nextState ##shape.currentState>inputActive[x] ##shape.startState>inputActiveStart[x] if cgmMeta.asMeta(_nucleus).mNode != mNucleus.mNode: mc.delete(_nucleus) _useNucleus = mNucleus.mNode """ _useIdx = ATTR.get_nextCompoundIndex(mNucleus.mNode,'outputObjects') log.info("useIdx: {0}".format(_useIdx)) ATTR.connect('{0}.outputObjects[{1}]'.format(_useNucleus,_useIdx),'{0}.nextState'.format(_hairSystem)) ATTR.connect('{0}.currentState'.format(_hairSystem),'{0}.inputActive[{1}]'.format(_useNucleus,_useIdx)) ATTR.connect('{0}.startState'.format(_hairSystem),'{0}.inputActiveStart[{1}]'.format(_useNucleus,_useIdx))""" mParent = ml[0].getParent(asMeta=1) if not mParent: mParent = ml[0].doGroup(1,1, asMeta=True, typeModifier = 'dynFKParent', setClass='cgmObject') #else: #mParent.getParent(asMeta=1) mGrp.connectChildNode(mCrv.mNode,'mOutCrv','group') #self.follicles.append(follicle) #self.outCurves.append(outCurve) # set default properties mFollicleShape.pointLock = 1 #mc.setAttr( '%s.pointLock' % follicleShape, 1 ) mc.parentConstraint(ml[0].getParent(), _follicle, mo=True) # create locators on objects locators = [] prs = [] ml_locs = [] ml_aims = [] ml_prts = [] _upVector = None if upSetup == 'guess': log.debug(cgmGEN.logString_msg(_str_func, 'Resolving up/aim')) poci_base = CURVES.create_pointOnInfoNode(mInCrv.mNode,1) mPoci_base = cgmMeta.asMeta(poci_base) _upVector = mPoci_base.normalizedNormal log.debug(cgmGEN.logString_msg(_str_func, "upVector: {0}".format(_upVector))) #Let's make an up object as the parent of the root isn't good enough mUp = ml[0].doCreateAt(setClass=1) mUp.rename("chain_{0}_up".format(name)) mUp.p_parent = mGrp if _upVector: SNAP.aim_atPoint(mUp.mNode, DIST.get_pos_by_vec_dist(mUp.p_position, _upVector, 10),aimAxis='y+',upAxis='z+') if upControl: log.debug(cgmGEN.logString_msg(_str_func,'upControl')) if len(ml_baseTargets)>1: sizeControl = DIST.get_distance_between_targets([mObj.mNode for mObj in ml_baseTargets],True) else: sizeControl = DIST.get_bb_size(ml[0],True,'max') crv = CURVES.create_controlCurve(mUp.mNode,'arrowSingle', size= sizeControl, direction = 'y+') CORERIG.shapeParent_in_place(mUp.mNode, crv, False) mUpGroup = mUp.doGroup(True,True, asMeta=True, typeModifier = 'master', setClass='cgmObject') mc.parentConstraint(ml[0].getParent(), mUpGroup.mNode, mo=True) else: mc.parentConstraint(ml[0].getParent(), mUp.mNode, mo=True) # create control joint chain mc.select(cl=True) chain = [] for obj in ml: if len(chain) > 0: mc.select(chain[-1]) jnt = mc.joint(name='%s_%s_jnt' % (name, obj.p_nameBase)) SNAP.matchTarget_set(jnt, obj.mNode) mObj = cgmMeta.asMeta(jnt) mObj.doSnapTo(mObj.getMessageAsMeta('cgmMatchTarget')) chain.append(jnt) mc.parent(chain[0], _follicle) mInCrv.p_parent = mGrp mc.bindSkin(mInCrv.mNode, chain[0], ts=True) log.debug(cgmGEN.logString_msg(_str_func,'aimUpMode: {0}'.format(aimUpMode))) for i, mObj in enumerate(ml): if not i: mUpUse = mUp else: mUpUse = ml_locs[-1] mLoc = cgmMeta.asMeta( LOC.create(mObj.getNameLong()) ) loc = mLoc.mNode ml_locs.append(mLoc) #loc = LOC.create(mObj.getNameLong()) mAim = mLoc.doGroup(False,False, asMeta=True, typeModifier = 'aim', setClass='cgmObject') ml_aims.append(mAim) #aimNull = mc.group(em=True) #aimNull = mc.rename('%s_aim' % mObj.getShortName()) poc = CURVES.create_pointOnInfoNode(outCurveShape) #mc.createNode('pointOnCurveInfo', name='%s_pos' % loc) mPoci_obj = cgmMeta.asMeta(poc) mPoci_obj.rename('%s_pos' % loc) pocAim = CURVES.create_pointOnInfoNode(outCurveShape) #mc.createNode('pointOnCurveInfo', name='%s_aim' % loc) pr = CURVES.getUParamOnCurve(loc, outCurve) mPoci_obj.parameter = pr #mc.connectAttr( '%s.worldSpace[0]' % outCurveShape, '%s.inputCurve' % poc, f=True ) #mc.connectAttr( '%s.worldSpace[0]' % outCurveShape, '%s.inputCurve' % pocAim, f=True ) #mc.setAttr( '%s.parameter' % poc, pr ) if i < len(ml)-1: nextpr = CURVES.getUParamOnCurve(ml[i+1], outCurve) mc.setAttr('%s.parameter' % pocAim, (nextpr))# + pr))# * .5) else: if extendStart: mc.setAttr( '%s.parameter' % pocAim, len(ml)+1 ) else: mc.setAttr( '%s.parameter' % pocAim, len(ml) ) mLocParent = mLoc.doGroup(False,False, asMeta=True, typeModifier = 'pos', setClass='cgmObject') ml_prts.append(mLocParent) #locParent = mc.group(em=True) #locParent = mc.rename( '%s_pos' % mObj.getShortName() ) mc.connectAttr( '%s.position' % mPoci_obj.mNode, '%s.translate' % mLocParent.mNode) mc.connectAttr( '%s.position' % pocAim, '%s.translate' % mAim.mNode) if aimUpMode == 'master': aimConstraint = mc.aimConstraint( mAim.mNode, mLocParent.mNode, aimVector=fwdAxis.p_vector, upVector = upAxis.p_vector, worldUpType = "objectrotation", worldUpVector = upAxis.p_vector, worldUpObject = mUp.mNode ) elif aimUpMode == 'orientToMaster': mc.orientConstraint( mUp.mNode, mLocParent.mNode, maintainOffset = 1) elif aimUpMode == 'sequential': aimConstraint = mc.aimConstraint( mAim.mNode, mLocParent.mNode, aimVector=fwdAxis.p_vector, upVector = upAxis.p_vector, worldUpType = "objectrotation", worldUpVector = upAxis.p_vector, worldUpObject = mUpUse.mNode ) elif aimUpMode == 'joint': aimConstraint = mc.aimConstraint( mAim.mNode, mLocParent.mNode, aimVector=fwdAxis.p_vector, upVector = upAxis.p_vector, worldUpType = "objectrotation", worldUpVector = upAxis.p_vector, worldUpObject = chain[i] ) elif aimUpMode == 'curveNormal': mUpLoc = mLoc.doGroup(False,False, asMeta=True, typeModifier = 'up', setClass='cgmObject') mUpLoc.p_parent = mLocParent aimConstraint = mc.aimConstraint( mAim.mNode, mLocParent.mNode, aimVector=fwdAxis.p_vector, upVector = upAxis.p_vector, worldUpType = "object") mPlusMinusAverage = cgmMeta.cgmNode(name="{0}_pma".format(mObj.p_nameBase), nodeType = 'plusMinusAverage') mPlusMinusAverage.operation = 3 mPoci_obj.doConnectOut('position','{0}.input3D[0]'.format(mPlusMinusAverage.mNode)) mPoci_obj.doConnectOut('normalizedNormal','{0}.input3D[1]'.format(mPlusMinusAverage.mNode)) mUpLoc.doConnectIn('translate','{0}.output3D'.format(mPlusMinusAverage.mNode)) mLoc.p_parent = mLocParent mAim.p_parent = mGrp mLocParent.p_parent = mGrp #mc.parent(loc, locParent) mCrv.rename("{0}_outCrv".format(name)) mCrvParent = mCrv.getParent(asMeta=1) mCrvParent.p_parent = mGrp mGrp.msgList_connect('mLocs',ml_locs) mGrp.msgList_connect('mAims',ml_aims) mGrp.msgList_connect('mParents',ml_prts) mGrp.msgList_connect('mTargets',ml) mGrp.msgList_connect('mBaseTargets',ml_baseTargets) mGrp.msgList_connect('mObjJointChain',chain) mGrp.doStore('cgmName', name) mNucleus.doConnectOut('startFrame',"{0}.startFrame".format(mHairSys.mNode))
def switchConstraint(attachType, transform, targetList, aliasList=[], createTarget=True, switchCtrl=None, switchAttr=None, prefix=''): """ Setup a single or multi target switchable constraint based on the input arguments @param attachType: Attach constraint type. Accepted types are "point", "orient", "parent", "scale" and "all". @type attachType: str @param transform: The transform that will be the slave of the attach constraint. @type transform: str @param targetList: A list of transforms that will be the parent/master of the attach constraint. @type targetList: list @param aliasList: A list of name alias' for each item in targetList. Uses to populate the enum attr for constraint target switching. @type aliasList: list @param createTarget: If True, create a new null transform under the current target that will result in a zero offset constraint. If False, use the transform specified in targetList. @type createTarget: bool @param switchCtrl: The control object that will hold the constraint target switch attribute. @type switchCtrl: str @param switchAttr: Name of the constraint target switch attribute. @type switchAttr: str @param prefix: Name prefix for new nodes. @type prefix: str """ # ========== # - Checks - # ========== # Attach Type if not attachType in ['point', 'orient', 'parent', 'scale', 'all']: raise Exception('Invalid attach type! ("' + attachType + '")') # Prefix if not prefix: prefix = transform # Transform if not cmds.objExists(transform): raise Exception('Transform "' + transform + '" does not exist!') # Target for target in targetList: if not cmds.objExists(target): raise Exception('Target transform "' + target + '" does not exist!') # Target Alias List if not aliasList: aliasList = targetList # Switch Control if switchCtrl and not cmds.objExists(switchCtrl): raise Exception('Switch control "' + switchCtrl + '" does not exist!') # ===================== # - Switch Attributes - # ===================== # Create Switch Attribute if switchCtrl: if not cmds.objExists(switchCtrl + '.' + switchAttr): cmds.addAttr(switchCtrl, ln=switchAttr, at='enum', en=':'.join(aliasList), k=True) # ============================ # - Create Target Transforms - # ============================ # Initialize new target list if createTarget: # For Each Target cTargetList = [] for t in range(len(targetList)): # Duplicate transform to generate new target cTarget = cmds.createNode('transform', n=prefix + '_' + aliasList[t] + '_target') glTools.utils.transform.match(cTarget, transform) # Parent Control Target to Current Constraint Target try: cTarget = cmds.parent(cTarget, targetList[t])[0] except: raise Exception('Unable to parent target null "' + cTarget + '" to target transform "' + targetList[t] + '"!') # Target Display Override glTools.utils.base.displayOverride(cTarget, overrideEnable=1, overrideDisplay=2) # Append to Target List cTargetList.append(cTarget) # Update target list targetList = cTargetList # Set Channel States chStateUtil = glTools.utils.channelState.ChannelState() chStateUtil.setFlags([2, 2, 2, 2, 2, 2, 2, 2, 2, 2], objectList=targetList) # ===================== # - Create Constraint - # ===================== # Initialize scale constraint valiables ("all" only) scaleConstraint = None scaleWtAlias = [] if attachType == 'point': constraint = cmds.pointConstraint(targetList, transform, mo=False, n=prefix + '_pointConstraint')[0] wtAlias = cmds.pointConstraint(constraint, q=True, wal=True) if attachType == 'orient': constraint = cmds.orientConstraint(targetList, transform, mo=False, n=prefix + '_orientConstraint')[0] wtAlias = cmds.orientConstraint(constraint, q=True, wal=True) if attachType == 'parent': constraint = cmds.parentConstraint(targetList, transform, mo=False, n=prefix + '_parentConstraint')[0] wtAlias = cmds.parentConstraint(constraint, q=True, wal=True) if attachType == 'scale': constraint = cmds.scaleConstraint(targetList, transform, mo=False, n=prefix + '_scaleConstraint')[0] wtAlias = cmds.parentConstraint(constraint, q=True, wal=True) if attachType == 'all': constraint = cmds.parentConstraint(targetList, transform, mo=False, n=prefix + '_parentConstraint')[0] wtAlias = cmds.parentConstraint(constraint, q=True, wal=True) scaleConstraint = cmds.scaleConstraint(targetList, transform, mo=False, n=prefix + '_scaleConstraint')[0] scaleWtAlias = cmds.scaleConstraint(scaleConstraint, q=True, wal=True) # ============================= # - Connect to Switch Control - # ============================= if switchCtrl: # Initialize switch list switchNodes = [] for i in range(len(targetList)): # Create Switch Node switchNode = cmds.createNode('condition', n=prefix + '_' + wtAlias[i] + '_condition') # Connect to switch attr cmds.connectAttr(switchCtrl + '.' + switchAttr, switchNode + '.firstTerm', f=True) cmds.setAttr(switchNode + '.secondTerm', i) cmds.setAttr(switchNode + '.operation', 0) # Equal cmds.setAttr(switchNode + '.colorIfTrue', 1, 0, 0) cmds.setAttr(switchNode + '.colorIfFalse', 0, 1, 1) # Connect to constraint target weight cmds.connectAttr(switchNode + '.outColorR', constraint + '.' + wtAlias[i]) # Connect to scale constraint, if necessary ("all" only) if scaleConstraint: cmds.connectAttr(switchNode + '.outColorR', scaleConstraint + '.' + scaleWtAlias[i]) # Append switch list switchNodes.append(switchNode) # ================= # - Return Result - # ================= return constraint
def build(inputJoints=None): """ create Slave joints for given joints list. if inputJoints = None, create slave joints for all joints in the scene without end joint in the joint chain :param inputJoints: str list, target joints list for create Slave joints :return: None """ if inputJoints: targetJoints = inputJoints else: targetJoints = [] # list all selected inputJoints without end inputJoints allJoints = cmds.ls(type='joint') for joint in allJoints: if cmds.attributeQuery('slaveJoint', node=joint, exists=1): targetJoints.append(joint) cmds.select(cl=1) # 1. generate slave joint for each target joint if targetJoints: for joint in targetJoints: slaveJoint = cmds.joint(n='Slave_' + joint) cmds.select(cl=1) cmds.delete(cmds.parentConstraint(joint, slaveJoint, mo=0)) cmds.makeIdentity(slaveJoint, apply=1, t=1, r=1, s=1) if not cmds.attributeQuery('slaveJoint', node=slaveJoint, exists=1): cmds.addAttr(slaveJoint, ln='slaveJoint', at='message') cmds.connectAttr(joint + '.slaveJoint', slaveJoint + '.slaveJoint', f=1) cmds.select(cl=1) # 2. parenting if targetJoints: for joint in targetJoints: slaveJoint = cmds.listConnections(joint + '.slaveJoint', destination=1, source=0, type='joint')[0] if cmds.attributeQuery('slaveParent', node=joint, exists=1): parent = cmds.getAttr(joint + '.slaveParent') if cmds.attributeQuery('slaveJoint', node=parent, exists=1): parentSlave = cmds.listConnections(parent + '.slaveJoint', source=0, destination=1, type='joint')[0] if parentSlave: cmds.parent(slaveJoint, parentSlave) else: parent = cmds.listRelatives(joint, c=0, p=1, s=0, type='joint', path=1) if parent: if cmds.attributeQuery('slaveJoint', node=parent[0], exists=1): parentSlave = cmds.listConnections(parent[0] + '.slaveJoint', source=0, destination=1, type='joint') if parentSlave: cmds.parent(slaveJoint, parentSlave[0]) cmds.select(cl=1) # 3. Constraint slave joint if targetJoints: for joint in targetJoints: slaveJoint = cmds.listConnections(joint + '.slaveJoint', destination=1, source=0, type='joint')[0] if cmds.attributeQuery('slavePointConst', node=joint, exists=1): pointConst = cmds.getAttr(joint + '.slavePointConst') if pointConst: cmds.pointConstraint(pointConst, slaveJoint, mo=0) else: cmds.pointConstraint(joint, slaveJoint, mo=0) cmds.orientConstraint(joint, slaveJoint, mo=0) cmds.scaleConstraint(joint, slaveJoint, mo=0) cmds.select(cl=1)
def main(templateFile=None, inheritTemplateRotations=False, controlShapes=None, oglControlShapes=None, fbx=False, scale=1, radius=1, numTwistJoints=4, ikShape="cube"): template(filepath=templateFile, scale=scale) root.main(name="assembly", position="spine1", fbx=fbx, radius=radius) # # spine and head # spine.main( positions=["spine1", "spine2", "spine3", "spine4", "spine5", "spine6"], radius=radius) mc.parent("spine", "pelvis_ctrl") mc.parentConstraint("body_ctrl", "spine_ik2_ctrl_grp", mo=True) mc.setAttr("spine_ik1_ctrlShape.lodVisibility", False) mc.connectAttr("assembly.joints", "spine_ik1_ctrl.joints") mc.setAttr("spine_ik1_ctrl.joints", k=False) mc.connectAttr("assembly.editJoints", "spine_ik1_ctrl.editJoints") mc.setAttr("spine_ik1_ctrl.editJoints", k=False) head.main(control="spine_ik6_ctrl", parent="spine_jnt6", positions=["jaw", "eye_lf", "eye_rt"], radius=radius, ikShape=ikShape) mc.connectAttr("assembly.joints", "spine_ik6_ctrl.joints") mc.setAttr("spine_ik6_ctrl.joints", k=False) mc.connectAttr("assembly.editJoints", "spine_ik6_ctrl.editJoints") mc.setAttr("spine_ik6_ctrl.editJoints", k=False) # # legs # leg.main(name="leg_lf", positions=[ "leg_lf1", "leg_lf2", "leg_lf3", "leg_lf4", "leg_lf5", "leg_lf6" ], radius=radius, ikShape=ikShape, inheritTemplateRotations=inheritTemplateRotations) mc.parent("leg_lf", "cog_ctrl") mc.parentConstraint("pelvis_ctrl", "leg_lf_ik1_grp", mo=True) mc.connectAttr("assembly.joints", "leg_lf_ik1_ctrl.joints") mc.setAttr("leg_lf_ik1_ctrl.joints", k=False) mc.connectAttr("assembly.editJoints", "leg_lf_ik1_ctrl.editJoints") mc.setAttr("leg_lf_ik1_ctrl.editJoints", k=False) mc.setAttr("leg_lf_ik1_ctrl.fkControls", False) leg.main(name="leg_rt", positions=[ "leg_rt1", "leg_rt2", "leg_rt3", "leg_rt4", "leg_rt5", "leg_rt6" ], radius=radius, ikShape=ikShape, inheritTemplateRotations=inheritTemplateRotations) mc.parent("leg_rt", "cog_ctrl") mc.parentConstraint("pelvis_ctrl", "leg_rt_ik1_grp", mo=True) mc.connectAttr("assembly.joints", "leg_rt_ik1_ctrl.joints") mc.setAttr("leg_rt_ik1_ctrl.joints", k=False) mc.connectAttr("assembly.editJoints", "leg_rt_ik1_ctrl.editJoints") mc.setAttr("leg_rt_ik1_ctrl.editJoints", k=False) mc.setAttr("leg_rt_ik1_ctrl.fkControls", False) # # arms # arm.main(name="arm_lf", positions=["arm_lf1", "arm_lf2", "arm_lf3", "arm_lf4"], radius=radius, ikShape=ikShape, inheritTemplateRotations=inheritTemplateRotations) mc.parent("arm_lf", "body_ctrl") mc.parentConstraint("spine_jnt3", "arm_lf", mo=True) mc.connectAttr("assembly.joints", "arm_lf_ik2_ctrl.joints") mc.setAttr("arm_lf_ik2_ctrl.joints", k=False) mc.connectAttr("assembly.editJoints", "arm_lf_ik2_ctrl.editJoints") mc.setAttr("arm_lf_ik2_ctrl.editJoints", k=False) mc.setAttr("arm_lf_ik2_ctrl.fkControls", False) arm.main(name="arm_rt", positions=["arm_rt1", "arm_rt2", "arm_rt3", "arm_rt4"], radius=radius, ikShape=ikShape, inheritTemplateRotations=inheritTemplateRotations) mc.parent("arm_rt", "body_ctrl") mc.parentConstraint("spine_jnt3", "arm_rt", mo=True) mc.connectAttr("assembly.joints", "arm_rt_ik2_ctrl.joints") mc.setAttr("arm_rt_ik2_ctrl.joints", k=False) mc.connectAttr("assembly.editJoints", "arm_rt_ik2_ctrl.editJoints") mc.setAttr("arm_rt_ik2_ctrl.editJoints", k=False) mc.setAttr("arm_rt_ik2_ctrl.fkControls", False) # # hands and fingers # positions = [] l = mc.ls("finger_lf*_1", typ="joint") or [] for n in l: l2 = mc.listRelatives(n, pa=True, ad=True) or [] positions.append(sorted([n] + l2)) hand.main(name="hand", side="lf", control="arm_lf_ik2_ctrl", parent="arm_lf_fk4_ctrl", radius=radius, positions=positions, inheritTemplateRotations=inheritTemplateRotations) mc.setAttr("arm_lf_ik2_ctrl.fingerControls", False) positions = [] l = mc.ls("finger_rt*_1", typ="joint") or [] for n in l: l2 = mc.listRelatives(n, pa=True, ad=True) or [] positions.append(sorted([n] + l2)) hand.main(name="hand", side="rt", control="arm_rt_ik2_ctrl", parent="arm_rt_fk4_ctrl", radius=radius, positions=positions, inheritTemplateRotations=inheritTemplateRotations) mc.setAttr("arm_rt_ik2_ctrl.fingerControls", False) # # delete template # mc.delete("template") # # twist joints # if numTwistJoints: twist.main(name="leg_lf_up", control="leg_lf_ik1_ctrl", parent="leg_lf_ik1_grp", count=numTwistJoints, stable="leg_lf_fk1_ctrl", _twist="leg_lf_fk2_ctrl", scale="leg_lf_ik1", wu=(1, 0, 0), wuo="leg_lf") mc.delete("leg_lf_jnt1") twist.main(name="leg_rt_up", control="leg_rt_ik1_ctrl", parent="leg_rt_ik1_grp", count=numTwistJoints, stable="leg_rt_fk1_ctrl", _twist="leg_rt_fk2_ctrl", scale="leg_rt_ik1", wu=(1, 0, 0), wuo="leg_rt") mc.delete("leg_rt_jnt1") twist.main(name="leg_lf_lo", control="leg_lf_ik1_ctrl", parent="leg_lf_fk2_ctrl", count=numTwistJoints, stable="leg_lf_fk2_ctrl", _twist="leg_lf_fk3_ctrl", scale="leg_lf_ik1") mc.delete("leg_lf_jnt2") twist.main(name="leg_rt_lo", control="leg_rt_ik1_ctrl", parent="leg_rt_fk2_ctrl", count=numTwistJoints, stable="leg_rt_fk2_ctrl", _twist="leg_rt_fk3_ctrl", scale="leg_rt_ik1") mc.delete("leg_rt_jnt2") twist.main(name="arm_lf_up", control="arm_lf_ik2_ctrl", parent="arm_lf_fk1_ctrl", count=numTwistJoints, stable="arm_lf_fk2_ctrl", _twist="arm_lf_fk3_ctrl", scale="arm_lf_ik2") mc.delete("arm_lf_jnt2") twist.main(name="arm_rt_up", control="arm_rt_ik2_ctrl", parent="arm_rt_fk1_ctrl", count=numTwistJoints, stable="arm_rt_fk2_ctrl", _twist="arm_rt_fk3_ctrl", scale="arm_rt_ik2", aim=(-1, 0, 0)) mc.delete("arm_rt_jnt2") twist.main(name="arm_lf_lo", control="arm_lf_ik2_ctrl", parent="arm_lf_fk3_ctrl", count=numTwistJoints, stable="arm_lf_fk3_ctrl", _twist="arm_lf_fk4_ctrl", scale="arm_lf_ik2") mc.delete("arm_lf_jnt3") twist.main(name="arm_rt_lo", control="arm_rt_ik2_ctrl", parent="arm_rt_fk3_ctrl", count=numTwistJoints, stable="arm_rt_fk3_ctrl", _twist="arm_rt_fk4_ctrl", scale="arm_rt_ik2", aim=(-1, 0, 0)) mc.delete("arm_rt_jnt3") # # transformation spaces for some controls # common.space("leg_lf_ik1_ctrl", "leg_lf_ik1_ctrl_grp", constraint="parent", name="local") common.space("leg_lf_ik1_ctrl", "body_ctrl", constraint="parent", name="body") common.space("leg_lf_ik1_ctrl", "cog_ctrl", constraint="parent", name="cog") common.space("leg_lf_ik1_ctrl", "world_ctrl", constraint="parent", name="world") common.space("leg_rt_ik1_ctrl", "leg_rt_ik1_ctrl_grp", constraint="parent", name="local") common.space("leg_rt_ik1_ctrl", "body_ctrl", constraint="parent", name="body") common.space("leg_rt_ik1_ctrl", "cog_ctrl", constraint="parent", name="cog") common.space("leg_rt_ik1_ctrl", "world_ctrl", constraint="parent", name="world") common.space("leg_lf_pv_ctrl", "leg_lf_pv_ctrl_grp", constraint="parent", name="local") common.space("leg_lf_pv_ctrl", "body_ctrl", constraint="parent", name="body") common.space("leg_lf_pv_ctrl", "cog_ctrl", constraint="parent", name="cog") common.space("leg_lf_pv_ctrl", "world_ctrl", constraint="parent", name="world") common.space("leg_rt_pv_ctrl", "leg_rt_pv_ctrl_grp", constraint="parent", name="local") common.space("leg_rt_pv_ctrl", "body_ctrl", constraint="parent", name="body") common.space("leg_rt_pv_ctrl", "cog_ctrl", constraint="parent", name="cog") common.space("leg_rt_pv_ctrl", "world_ctrl", constraint="parent", name="world") common.space("spine_ik3_ctrl", "spine_ik3_ctrl_grp", constraint="parent", name="local") common.space("spine_ik3_ctrl", "body_ctrl", constraint="parent", name="body") common.space("spine_ik3_ctrl", "cog_ctrl", constraint="parent", name="cog") common.space("spine_ik3_ctrl", "world_ctrl", constraint="parent", name="world") common.space("arm_lf_pv_ctrl", "arm_lf_pv_ctrl_grp", constraint="parent", name="local") common.space("arm_lf_pv_ctrl", "spine_jnt3", constraint="parent", name="chest") common.space("arm_lf_pv_ctrl", "body_ctrl", constraint="parent", name="body") common.space("arm_lf_pv_ctrl", "cog_ctrl", constraint="parent", name="cog") common.space("arm_lf_pv_ctrl", "world_ctrl", constraint="parent", name="world") mc.setAttr("arm_lf_pv_ctrl.space", 3) common.space("arm_rt_pv_ctrl", "arm_rt_pv_ctrl_grp", constraint="parent", name="local") common.space("arm_rt_pv_ctrl", "spine_jnt3", constraint="parent", name="chest") common.space("arm_rt_pv_ctrl", "body_ctrl", constraint="parent", name="body") common.space("arm_rt_pv_ctrl", "cog_ctrl", constraint="parent", name="cog") common.space("arm_rt_pv_ctrl", "world_ctrl", constraint="parent", name="world") mc.setAttr("arm_rt_pv_ctrl.space", 3) common.space("arm_lf_ik2_ctrl", "arm_lf_ik2_ctrl_grp", constraint="parent", name="local") common.space("arm_lf_ik2_ctrl", "spine_jnt6", constraint="parent", name="head") common.space("arm_lf_ik2_ctrl", "spine_jnt3", constraint="parent", name="chest") common.space("arm_lf_ik2_ctrl", "body_ctrl", constraint="parent", name="body") common.space("arm_lf_ik2_ctrl", "cog_ctrl", constraint="parent", name="cog") common.space("arm_lf_ik2_ctrl", "world_ctrl", constraint="parent", name="world") mc.setAttr("arm_lf_ik2_ctrl.space", 4) common.space("arm_rt_ik2_ctrl", "arm_rt_ik2_ctrl_grp", constraint="parent", name="local") common.space("arm_rt_ik2_ctrl", "spine_jnt6", constraint="parent", name="head") common.space("arm_rt_ik2_ctrl", "spine_jnt3", constraint="parent", name="chest") common.space("arm_rt_ik2_ctrl", "body_ctrl", constraint="parent", name="body") common.space("arm_rt_ik2_ctrl", "cog_ctrl", constraint="parent", name="cog") common.space("arm_rt_ik2_ctrl", "world_ctrl", constraint="parent", name="world") mc.setAttr("arm_rt_ik2_ctrl.space", 4) common.space("spine_ik6_ctrl", "spine_ik6_ctrl_grp", constraint="orient", name="local") common.space("spine_ik6_ctrl", "spine_jnt3", constraint="orient", name="chest") common.space("spine_ik6_ctrl", "body_ctrl", constraint="orient", name="body") common.space("spine_ik6_ctrl", "cog_ctrl", constraint="orient", name="cog") common.space("spine_ik6_ctrl", "world_ctrl", constraint="orient", name="world") mc.setAttr("spine_ik6_ctrl.space", 3) common.space("head_eyes_ik_ctrl", "spine_ik6_ctrl", constraint="parent", name="local") common.space("head_eyes_ik_ctrl", "world_ctrl", constraint="parent", name="world") mc.setAttr("head_eyes_ik_ctrl.space", 1) # # global switch for control visibility # for n in ["fk_controls_set", "ik_controls_set"]: for n2 in mc.sets(n, q=True): if mc.nodeType(n2) == "objectSet": l = mc.sets(n2, q=True) else: l = [n2] for n3 in l: n3 = mc.listRelatives(n3, pa=True, s=True)[0] mc.setAttr(n3 + ".overrideEnabled", True) try: mc.connectAttr("assembly.controls", n3 + ".overrideVisibility") except: pass # # fbx skeleton # if fbx: mc.createNode("joint", n="root_fbx", p="skeleton_fbx") mc.setAttr("root_fbx.radius", radius * 0.25) c = mc.pointConstraint("pelvis_ctrl", "root_fbx", sk=["y"])[0] mc.parent(c, "constraints_fbx") c = mc.orientConstraint("pelvis_ctrl", "root_fbx", sk=["x", "z"])[0] mc.parent(c, "constraints_fbx") c = mc.scaleConstraint("pelvis_ctrl", "root_fbx")[0] mc.parent(c, "constraints_fbx") l = [ None, "pelvis_ctrl", "spine_jnt1", "spine_jnt2", "spine_jnt3", "spine_jnt4", "spine_jnt5", "spine_jnt6", "jaw_jnt" ] l2 = [ "root_fbx", "pelvis_fbx", "spine_fbx1", "spine_fbx2", "spine_fbx3", "spine_fbx4", "spine_fbx5", "spine_fbx6", "jaw_fbx" ] for i in range(1, len(l)): mc.createNode("joint", n=l2[i], p=l2[i - 1]) mc.setAttr(l2[i] + ".radius", radius * 0.25) mc.delete(mc.parentConstraint(l[i], l2[i])) r = mc.getAttr(l2[i] + ".r")[0] mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2]) mc.setAttr(l2[i] + ".r", 0, 0, 0) c = mc.pointConstraint(l[i], l2[i], mo=True)[0] mc.parent(c, "constraints_fbx") c = mc.orientConstraint(l[i], l2[i], mo=True)[0] r = mc.getAttr(l2[i] + ".r")[0] mc.setAttr(c + ".o", -r[0], -r[1], -r[2]) mc.parent(c, "constraints_fbx") for side in ["lf", "rt"]: mc.createNode("joint", n="eye_" + side + "_fbx", p="spine_fbx6") mc.setAttr("eye_" + side + "_fbx" + ".radius", radius * 0.25) mc.delete( mc.parentConstraint("eye_" + side + "_jnt", "eye_" + side + "_fbx")) r = mc.getAttr("eye_" + side + "_fbx.r")[0] mc.setAttr("eye_" + side + "_fbx.jo", r[0], r[1], r[2]) mc.setAttr("eye_" + side + "_fbx.r", 0, 0, 0) c = mc.parentConstraint("eye_" + side + "_jnt", "eye_" + side + "_fbx", mo=True)[0] mc.parent(c, "constraints_fbx") mc.duplicate("eye_" + side + "_fbx") mc.parent("eye_" + side + "_fbx1", "eye_" + side + "_fbx") mc.duplicate("eye_" + side + "_fbx1") mc.parent("eye_" + side + "_fbx2", "eye_" + side + "_fbx1") if numTwistJoints: l = [ "leg_" + side + "_up_twr1", "leg_" + side + "_up_tw1", "leg_" + side + "_up_tw2", "leg_" + side + "_up_tw3", "leg_" + side + "_lo_twr1", "leg_" + side + "_lo_tw1", "leg_" + side + "_lo_tw2", "leg_" + side + "_lo_tw3", "leg_" + side + "_jnt3", "leg_" + side + "_jnt4" ] l2 = [ "leg_" + side + "_tw_fbx1", "leg_" + side + "_tw_fbx2", "leg_" + side + "_tw_fbx3", "leg_" + side + "_tw_fbx4", "leg_" + side + "_tw_fbx5", "leg_" + side + "_tw_fbx6", "leg_" + side + "_tw_fbx7", "leg_" + side + "_tw_fbx8", "leg_" + side + "_fbx1", "leg_" + side + "_fbx4" ] last_good = "pelvis_fbx" for i in range(0, len(l)): if not mc.objExists(l[i]): continue mc.createNode("joint", n=l2[i], p=last_good) last_good = l2[i] mc.setAttr(l2[i] + ".radius", radius * 0.25) mc.delete(mc.parentConstraint(l[i], l2[i])) r = mc.getAttr(l2[i] + ".r")[0] mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2]) mc.setAttr(l2[i] + ".r", 0, 0, 0) c = mc.parentConstraint(l[i], l2[i], mo=True)[0] mc.parent(c, "constraints_fbx") l = [ "arm_" + side + "_jnt1", "arm_" + side + "_up_twr1", "arm_" + side + "_up_tw1", "arm_" + side + "_up_tw2", "arm_" + side + "_up_tw3", "arm_" + side + "_lo_twr1", "arm_" + side + "_lo_tw1", "arm_" + side + "_lo_tw2", "arm_" + side + "_lo_tw3", "arm_" + side + "_jnt4" ] l2 = [ "arm_" + side + "_fbx1", "arm_" + side + "_tw_fbx1", "arm_" + side + "_tw_fbx2", "arm_" + side + "_tw_fbx3", "arm_" + side + "_tw_fbx4", "arm_" + side + "_tw_fbx5", "arm_" + side + "_tw_fbx6", "arm_" + side + "_tw_fbx7", "arm_" + side + "_tw_fbx8", "arm_" + side + "_fbx4" ] last_good = "spine_fbx3" for i in range(0, len(l)): if not mc.objExists(l[i]): continue mc.createNode("joint", n=l2[i], p=last_good) last_good = l2[i] mc.setAttr(l2[i] + ".radius", radius * 0.25) mc.delete(mc.parentConstraint(l[i], l2[i])) r = mc.getAttr(l2[i] + ".r")[0] mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2]) mc.setAttr(l2[i] + ".r", 0, 0, 0) c = mc.parentConstraint(l[i], l2[i], mo=True)[0] mc.parent(c, "constraints_fbx") else: l = [ "leg_" + side + "_jnt1", "leg_" + side + "_jnt2", "leg_" + side + "_jnt3", "leg_" + side + "_jnt4" ] l2 = [ "leg_" + side + "_fbx1", "leg_" + side + "_fbx2", "leg_" + side + "_fbx3", "leg_" + side + "_fbx4" ] last_good = "pelvis_fbx" for i in range(0, len(l)): if not mc.objExists(l[i]): continue mc.createNode("joint", n=l2[i], p=last_good) last_good = l2[i] mc.setAttr(l2[i] + ".radius", radius * 0.25) mc.delete(mc.parentConstraint(l[i], l2[i])) r = mc.getAttr(l2[i] + ".r")[0] mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2]) mc.setAttr(l2[i] + ".r", 0, 0, 0) c = mc.parentConstraint(l[i], l2[i], mo=True)[0] mc.parent(c, "constraints_fbx") l = [ "arm_" + side + "_jnt1", "arm_" + side + "_jnt2", "arm_" + side + "_jnt3", "arm_" + side + "_jnt4" ] l2 = [ "arm_" + side + "_fbx1", "arm_" + side + "_fbx2", "arm_" + side + "_fbx3", "arm_" + side + "_fbx4" ] last_good = "spine_fbx3" for i in range(0, len(l)): if not mc.objExists(l[i]): continue mc.createNode("joint", n=l2[i], p=last_good) last_good = l2[i] mc.setAttr(l2[i] + ".radius", radius * 0.25) mc.delete(mc.parentConstraint(l[i], l2[i])) r = mc.getAttr(l2[i] + ".r")[0] mc.setAttr(l2[i] + ".jo", r[0], r[1], r[2]) mc.setAttr(l2[i] + ".r", 0, 0, 0) c = mc.parentConstraint(l[i], l2[i], mo=True)[0] mc.parent(c, "constraints_fbx") for i in range(1, 6): l = [None] + mc.ls("finger_" + side + str(i) + "_jnt*", typ="joint") or [] l2 = ["arm_" + side + "_fbx4"] + [ "finger_" + side + str(i) + "_fbx" + str(j + 1) for j in range(len(l) - 1) ] for j in range(1, len(l)): mc.createNode("joint", n=l2[j], p=l2[j - 1]) mc.setAttr(l2[j] + ".radius", radius * 0.25) mc.delete(mc.parentConstraint(l[j], l2[j])) r = mc.getAttr(l2[j] + ".r")[0] mc.setAttr(l2[j] + ".jo", r[0], r[1], r[2]) mc.setAttr(l2[j] + ".r", 0, 0, 0) c = mc.parentConstraint(l[j], l2[j], mo=True)[0] mc.parent(c, "constraints_fbx") mc.createNode("joint", n="props_" + side + "_fbx", p="arm_" + side + "_fbx4") mc.setAttr("props_" + side + "_fbx.radius", radius * 0.25) if side == "lf": mc.setAttr("props_" + side + "_fbx.ty", scale) else: mc.setAttr("props_" + side + "_fbx.ty", -scale) common.control(name="props_"+side, parent="arm_"+side+"_fk4_ctrl", \ position="props_"+side+"_fbx", rotation="props_"+side+"_fbx", \ normal=(0,1,0), color=13, radius=radius*0.5, hideAttr=["v"]) mc.addAttr("arm_" + side + "_ik2_ctrl", ln="propsControls", at="bool", k=True) mc.connectAttr("arm_" + side + "_ik2_ctrl.propsControls", "props_" + side + "_ctrl.v") mc.delete( mc.parentConstraint("props_" + side + "_ctrl", "props_" + side + "_fbx")) r = mc.getAttr("props_" + side + "_fbx.r")[0] mc.setAttr("props_" + side + "_fbx.jo", r[0], r[1], r[2]) mc.setAttr("props_" + side + "_fbx.r", 0, 0, 0) c = mc.parentConstraint("props_" + side + "_ctrl", "props_" + side + "_fbx", mo=True)[0] c = mc.rename(c, "props_" + side + "_fbx_parcon") mc.parent(c, "constraints_fbx") # # rename controls for nice # mc.rename("leg_lf_ik1_ctrl", "leg_lf_ik_ctrl") mc.rename("leg_lf_fk1_ctrl", "leg_up_lf_fk_ctrl") mc.rename("leg_lf_fk2_ctrl", "leg_lo_lf_fk_ctrl") mc.rename("leg_lf_fk3_ctrl", "ankle_lf_fk_ctrl") mc.rename("leg_lf_fk4_ctrl", "toes_lf_fk_ctrl") mc.rename("leg_rt_ik1_ctrl", "leg_rt_ik_ctrl") mc.rename("leg_rt_fk1_ctrl", "leg_up_rt_fk_ctrl") mc.rename("leg_rt_fk2_ctrl", "leg_lo_rt_fk_ctrl") mc.rename("leg_rt_fk3_ctrl", "ankle_rt_fk_ctrl") mc.rename("leg_rt_fk4_ctrl", "toes_rt_fk_ctrl") mc.rename("spine_ik2_ctrl", "waist_ctrl") mc.rename("spine_ik3_ctrl", "chest_ctrl") mc.rename("spine_ik5_ctrl", "neck_ctrl") mc.rename("spine_ik6_ctrl", "head_ctrl") mc.rename("arm_lf_ik1_ctrl", "shoulder_lf_ik_ctrl") mc.rename("arm_lf_ik2_ctrl", "arm_lf_ik_ctrl") mc.rename("arm_lf_fk1_ctrl", "shoulder_lf_fk_ctrl") mc.rename("arm_lf_fk2_ctrl", "arm_up_lf_fk_ctrl") mc.rename("arm_lf_fk3_ctrl", "arm_lo_lf_fk_ctrl") mc.rename("arm_lf_fk4_ctrl", "wrist_lf_fk_ctrl") mc.rename("arm_rt_ik1_ctrl", "shoulder_rt_ik_ctrl") mc.rename("arm_rt_ik2_ctrl", "arm_rt_ik_ctrl") mc.rename("arm_rt_fk1_ctrl", "shoulder_rt_fk_ctrl") mc.rename("arm_rt_fk2_ctrl", "arm_up_rt_fk_ctrl") mc.rename("arm_rt_fk3_ctrl", "arm_lo_rt_fk_ctrl") mc.rename("arm_rt_fk4_ctrl", "wrist_rt_fk_ctrl") # # load control shapes # if controlShapes: if os.path.isfile(THIS_DIR + "/" + controlShapes): common.loadControlShapes(THIS_DIR + "/" + controlShapes) elif os.path.isfile(controlShapes): common.loadControlShapes(controlShapes) # # load OpenGL shapes # if oglControlShapes: f = None if os.path.isfile(THIS_DIR + "/" + oglControlShapes): f = THIS_DIR + "/" + oglControlShapes elif os.path.isfile(oglControlShapes): f = oglControlShapes if f: # delete wire control shapes l = [] for t in ["fk", "ik"]: for n in mc.sets(t + "_controls_set", q=True): if mc.nodeType(n) != "objectSet": l.append(n) else: l += mc.sets(n, q=True) for n in l: mc.delete(mc.listRelatives(n, pa=True, s=True)) # create OpenGL control shapes f2 = open(f) s = f2.read() f2.close() mm.eval(s) # connect OpenGL shape visibility attributes to rig parameters f = mc.internalVar(userScriptDir=True) + "/icons.cfg" for n in l: try: n2 = mc.listRelatives(n, pa=True, s=True)[0] except: continue mc.setAttr(n2 + ".overrideEnabled", True) mc.connectAttr("assembly.controls", n2 + ".overrideVisibility") mc.setAttr(n + ".iconsConfigFile", f, typ="string") mc.setAttr(n + ".reloadIconsData", True) for side in ["lf", "rt"]: for n in [ "shoulder_" + side + "_fk_ctrl", "arm_up_" + side + "_fk_ctrl", "arm_lo_" + side + "_fk_ctrl", "wrist_" + side + "_fk_ctrl" ]: mc.connectAttr("arm_" + side + "_ik_ctrl.fkControls", n + "Shape.v") for n in [ "shoulder_" + side + "_ik_ctrl", "arm_" + side + "_pv_ctrl", "lines_arm_" + side ]: mc.connectAttr("arm_" + side + "_ik_ctrl.ikControls", n + "Shape.v") for i in ["1", "2", "3", "4", "5"]: for j in ["1", "2", "3"]: mc.connectAttr( "arm_" + side + "_ik_ctrl.fingerControls", "finger_" + side + i + "_fk" + j + "_ctrlShape.v") for n in [ "leg_up_" + side + "_fk_ctrl", "leg_lo_" + side + "_fk_ctrl", "ankle_" + side + "_fk_ctrl", "toes_" + side + "_fk_ctrl" ]: mc.connectAttr("leg_" + side + "_ik_ctrl.fkControls", n + "Shape.v") for n in ["leg_" + side + "_pv_ctrl", "lines_leg_" + side]: mc.connectAttr("leg_" + side + "_ik_ctrl.ikControls", n + "Shape.v") for n in ["lines_arm_" + side, "lines_leg_" + side]: mc.connectAttr("assembly.controls", n + "Shape.overrideVisibility") for n in [ "head_jaw_fk_ctrl", "head_eye_rt_fk_ctrl", "head_eye_lf_fk_ctrl" ]: mc.connectAttr("head_ctrl.fkControls", n + "Shape.v") mc.connectAttr("head_ctrl.ikControls", "head_eyes_ik_ctrlShape.v") mc.connectAttr("head_ctrl.ikControls", "lines_eyesShape.v") mc.connectAttr("assembly.controls", "lines_eyesShape.overrideVisibility") mc.connectAttr("assembly.controls", "lines_spineShape.overrideVisibility") mc.parent("lines", "lines_arm_lf", "lines_arm_rt", "lines_leg_lf", "lines_leg_rt", "lines_eyes", "lines_spine", "assembly") mc.setAttr("assembly.joints", False) try: mc.setAttr("assembly.fbxJoints", False) except: pass mc.select(cl=True) mc.dgdirty(a=True)
def go(): project = Project() environment = Environment() # Create a global position locator which will grab Jampa's position despite his scaled translations mc.currentTime(0) globalPos = mc.spaceLocator(p=[0,0,0]) globPos = mc.rename(globalPos, "jampaGlobalPos") mc.select("jampa_rig_main_global_cc_01") mc.select(globPos, add=True) mc.pointConstraint(offset=[0,0,0], weight=1) mc.orientConstraint(offset=[0,0,0], weight=1) # Get transformation variables from globPos locator tx = mc.getAttr(globPos+".translateX") ty = mc.getAttr(globPos+".translateY") tz = mc.getAttr(globPos+".translateZ") rx = mc.getAttr(globPos+".rotateX") ry = mc.getAttr(globPos+".rotateY") rz = mc.getAttr(globPos+".rotateZ") # get alembic filepath for scene's animation (requires prior export) src = mc.file(q=True, sceneName=True) src_dir = os.path.dirname(src) checkout_element = project.get_checkout_element(src_dir) checkout_body_name = checkout_element.get_parent() body = project.get_body(checkout_body_name) element = body.get_element(Department.ANIM) cache_file = os.path.join(element.get_dir(), "cache", "jampa_rig_main.abc") # checkout cfx scene for corresponding shot number current_user = environment.get_current_username() element = body.get_element(Department.CFX) cfx_filepath = element.checkout(current_user) #open cfx file if cfx_filepath is not None: if not mc.file(q=True, sceneName=True) == '': mc.file(save=True, force=True) #save file if not os.path.exists(cfx_filepath): mc.file(new=True, force=True) mc.file(rename=cfx_filepath) mc.file(save=True, force=True) else: mc.file(cfx_filepath, open=True, force=True) # import alembic command = "AbcImport -mode import \"" + cache_file + "\"" maya.mel.eval(command) # delete all geo except jampa skin and rename geometry = mc.ls(geometry=True) transforms = mc.listRelatives(geometry, p=True, path=True) mc.select(transforms, r=True) for geo in mc.ls(sl=True): if(geo != "jampa_rig_main_jampa_geo_body"): mc.delete(geo) collide = "JAMPA_COLLIDE" mc.rename("jampa_rig_main_jampa_geo_body", collide) # reference robe body = project.get_body("jampa_robe") element = body.get_element(Department.MODEL) robe_file = element.get_app_filepath() mc.file(robe_file, reference=True) # set robe transforms to variables above mc.setAttr("jampa_robe_model_main_jampa_robe_sim.translateX", tx) mc.setAttr("jampa_robe_model_main_jampa_robe_sim.translateY", ty) mc.setAttr("jampa_robe_model_main_jampa_robe_sim.translateZ", tz) mc.setAttr("jampa_robe_model_main_jampa_robe_sim.rotateX", rx) mc.setAttr("jampa_robe_model_main_jampa_robe_sim.rotateY", ry) mc.setAttr("jampa_robe_model_main_jampa_robe_sim.rotateZ", rz) # make jampa skin a passive collider mc.select(collide) command = "makeCollideNCloth" maya.mel.eval(command) rigid_shape = "nRigid_jampa" mc.rename("nRigid1", rigid_shape) mc.setAttr(rigid_shape+".stickiness", 0.2) mc.setAttr(rigid_shape+".friction", 0.5) # make cloth objects and display layers of each robe piece jampa_torso = "jampa_robe_model_main_robe_torso_01" jampa_sash = "jampa_robe_model_main_robe_sash_01" jampa_skirt = "jampa_robe_model_main_robe_skirt_01" cloth_pieces = {jampa_torso, jampa_sash, jampa_skirt} command = "createNCloth 0" for cp in cloth_pieces: mc.select(cp) maya.mel.eval(command) mc.rename("nCloth1", "nCloth_"+cp) mc.select(cp) layername = "cloth_"+cp[:-3].replace("robe_model_main_robe_", "") mc.createDisplayLayer(name=layername.upper(), number=1, noRecurse=True) # set appropriate values in nucleus node nucleus = "nucleus_jampa" mc.rename("nucleus1", nucleus) mc.setAttr(nucleus+".subSteps", 30) mc.setAttr(nucleus+".startFrame", -30) mc.setAttr(nucleus+".spaceScale", 0.23) mc.currentTime(-50)
def CreateProxies(self): thumbsOn = True fingersNum = 4 toesNum = 1 spineNum = 4 neckNum = 2 self.Main = "Proxies_Main" self.Proxies_Root = "Proxies_Root" self.Proxies_SpineTop = "Proxies_SpineTop" self.Proxies_Head = "Proxies_Head" self.Proxies_Jaw = "Proxies_Jaw" self.Proxies_JawTip = "Proxies_JawTip" self.Proxies_HeadTip = "Proxies_HeadTip" self.Proxies_L_Eye = "Proxies_L_Eye" self.Proxies_R_Eye = "Proxies_R_Eye" self.Proxies_SpineOrientLocator = "Proxies_SpineOrientLocator" self.Proxies_NeckOrientLocator = "Proxies_NeckOrientLocator" # todo : SET UNITS TO CENTIMETERS # todo : Close NODE EDITOR # Joint Base Main = cmds.circle(n=self.Main, c=(0, 0, 0), nr=(0, 1, 0), sw=360, r=8, d=3, ut=0, tol=0.01, s=8, ch=0) # Root self.CreatePrixyNode(name=self.Proxies_Root, mScale=[1.6, 1.6, 1.6], mMvoe=[0, 15.25, 0], lScale=[0.4, 0.4, 0.4]) # Top self.CreatePrixyNode(name=self.Proxies_SpineTop, PC=self.Proxies_Root, mScale=[1.6, 1.6, 1.6], mMvoe=[0, 6.6, 0], lScale=[0.4, 0.4, 0.4]) # Aim Locator loc = cmds.spaceLocator(n=self.Proxies_SpineOrientLocator) cmds.parent(self.Proxies_SpineOrientLocator, self.Main) cmds.pointConstraint(self.Proxies_Root, self.Proxies_SpineOrientLocator) cmds.aimConstraint(self.Proxies_SpineTop, self.Proxies_SpineOrientLocator, aimVector=[0, 1, 0], upVector=[1, 0, 0], worldUpType="vector", worldUpVector=[1, 0, 0]) cmds.setAttr("%s.visibility" % self.Proxies_SpineOrientLocator, 0) # Spline self.spineProxies = [] i2 = spineNum - 1 nPad = "0" for i in range(1, spineNum): self.ProxyBase("Proxies_Spine_%s%s" % (nPad, i)) cmds.group("Proxies_Spine_%s%s" % (nPad, i), n="Proxies_Spine_%s%s_GRP" % (nPad, i)) cmds.xform(os=True, piv=[0, 0, 0]) cmds.makeIdentity("Proxies_Spine_%s%s_GRP" % (nPad, i), apply=True, t=1, r=1, s=1) cmds.pointConstraint(self.Proxies_Root, self.Proxies_SpineTop, "Proxies_Spine_%s%s_GRP" % (nPad, i)) cmds.orientConstraint(self.Proxies_SpineOrientLocator, "Proxies_Spine_%s%s_GRP" % (nPad, i)) cmds.setAttr("Proxies_Spine_%s%s_GRP_pointConstraint1.Proxies_RootW0" % (nPad, i), i2) cmds.setAttr("Proxies_Spine_%s%s_GRP_pointConstraint1.Proxies_SpineTopW1" % (nPad, i), i) self.spineProxies.append("Proxies_Spine_%s%s" % (nPad, i)) # CONNECTORS if i == 1: self.ProxyConnectors(self.Proxies_Root, "Proxies_Spine_%s%s" % (nPad, i)) else: self.ProxyConnectors("Proxies_Spine_%s%s" % (nPad, i), "Proxies_Spine_%s%s" % (nPad, i - 1)) i2 = i2 - 1 self.ProxyConnectors("Proxies_Spine_%s%s" % (nPad, spineNum - 1), self.Proxies_SpineTop) cmds.select(self.spineProxies) cmds.pickWalk(d="up") spineProxiesG = cmds.ls(sl=True) # Head self.CreatePrixyNode(name=self.Proxies_Head, PC=self.Proxies_SpineTop, mMvoe=[0, 2, 0], mScale=[1.25, 1.25, 1.25]) # CREATE AIM LOCATOR TO ORIENT NECK PROXIES cmds.spaceLocator(n=self.Proxies_NeckOrientLocator) cmds.parent(self.Proxies_NeckOrientLocator, self.Main) cmds.pointConstraint(self.Proxies_SpineTop, self.Proxies_NeckOrientLocator) cmds.aimConstraint(self.Proxies_Head, self.Proxies_NeckOrientLocator, aimVector=[0, 1, 0], upVector=[1, 0, 0], worldUpType="vector", worldUpVector=[1, 0, 0]) cmds.setAttr("%s.visibility" % self.Proxies_NeckOrientLocator, 0) # Neck self.neckProxies = [] i2 = neckNum - 1 nPad = "0" for i in range(1, neckNum): self.ProxyBase("Proxies_Neck_%s%s" % (nPad, i)) cmds.scale(0.8, 0.8, 0.8, "Proxies_Neck_%s%s" % (nPad, i), r=True) cmds.makeIdentity("Proxies_Neck_%s%s" % (nPad, i), apply=True, t=1, r=1, s=1) cmds.group("Proxies_Neck_%s%s" % (nPad, i), n="Proxies_Neck_%s%s_GRP" % (nPad, i)) cmds.xform(os=True, piv=[0, 0, 0]) cmds.makeIdentity("Proxies_Neck_%s%s_GRP" % (nPad, i), apply=True, t=1, r=1, s=1) cmds.pointConstraint(self.Proxies_SpineTop, self.Proxies_Head, "Proxies_Neck_%s%s_GRP" % (nPad, i)) cmds.orientConstraint(self.Proxies_NeckOrientLocator, "Proxies_Neck_%s%s_GRP" % (nPad, i)) cmds.setAttr("Proxies_Neck_%s%s_GRP_pointConstraint1.Proxies_SpineTopW0" % (nPad, i), i2) cmds.setAttr("Proxies_Neck_%s%s_GRP_pointConstraint1.Proxies_HeadW1" % (nPad, i), i) self.neckProxies.append("Proxies_Neck_%s%s" % (nPad, i)) if i == 1: self.ProxyConnectors(self.Proxies_SpineTop, "Proxies_Neck_%s%s" % (nPad, i)) else: self.ProxyConnectors("Proxies_Neck_%s%s" % (nPad, i), "Proxies_Neck_%s%s" % (nPad, i - 1)) i2 = i2 - 1 cmds.select(self.neckProxies) cmds.pickWalk(d="up") neckProxiesG = cmds.ls(sl=True) self.ProxyConnectors("Proxies_Neck_%s%s" % (nPad, neckNum - 1), self.Proxies_Head) # Jaw self.CreatePrixyNode(self.Proxies_Jaw, PC=self.Proxies_Head, mMvoe=[0, 0.83, 0.38], isConnect=True) self.CreatePrixyNode(self.Proxies_JawTip, PC=self.Proxies_Jaw, mMvoe=[0, -0.83, 1.52], isConnect=True) self.CreatePrixyNode(self.Proxies_HeadTip, PC=self.Proxies_Head, mMvoe=[0, 3.38, 0], isConnect=True) # Eye self.CreatePrixyNode(self.Proxies_L_Eye, PC=self.Proxies_Head, mMvoe=[0.57, 1.53, 1.64], isConnect=True) self.CreatePrixyNode(self.Proxies_R_Eye, PC=self.Proxies_Head, mMvoe=[-0.57, 1.53, 1.64], isConnect=True) # Arms armLoop = 1 armPrefx = "_L" armMultiplier = 1.0 while armLoop <= 2: Clavicle = "Proxies" + armPrefx + "_Clavicle" self.CreatePrixyNode(Clavicle, PC=self.Proxies_SpineTop, mMvoe=[armMultiplier * 1.25, 0.5, 0], isConnect=True, isParent=True) Shoulder = "Proxies" + armPrefx + "_Shoulder" self.CreatePrixyNode(Shoulder, PC=Clavicle, mMvoe=[armMultiplier * 1.7, 0, 0], isConnect=True, isParent=True) Elbow = "Proxies" + armPrefx + "_Elbow" self.CreatePrixyNode(Elbow, PC=Shoulder, mMvoe=[armMultiplier * 3.5, 0, 0], isConnect=True) Wrist = "Proxies" + armPrefx + "_Wrist" self.CreatePrixyNode(Wrist, PC=Elbow, mMvoe=[armMultiplier * 3.5, 0, 0], isConnect=True) ElbowG = "Proxies" + armPrefx + "_Elbow_GRP" cmds.group(n=ElbowG, em=True) PCons = cmds.pointConstraint(Elbow, ElbowG) cmds.delete(PCons) cmds.parent(Elbow, ElbowG) cmds.makeIdentity(ElbowG, apply=True, t=1, r=1, s=1) cmds.move(0, 0, 0.001, "%s.scalePivot" % ElbowG, "%s.rotatePivot" % ElbowG, r=True) cmds.pointConstraint(Shoulder, Wrist, ElbowG, mo=True) cmds.parent(ElbowG, Wrist, self.Main) Palm = "Proxies" + armPrefx + "_Palm" self.CreatePrixyNode(Palm, PC=Wrist, mMvoe=[armMultiplier * 0.7, 0, 0], mScale=[0.7, 0.7, 0.7], lScale=[0.175, 0.175, 0.175], isConnect=True, isParent=True) if thumbsOn: ThumbJ1 = "Proxies" + armPrefx + "_ThumbJ1" self.CreatePrixyNode(ThumbJ1, PC=Wrist, mMvoe=[armMultiplier * 0.45, 0, 0.51], mScale=[0.75, 0.75, 0.75], lScale=[0.1875, 0.1875, 0.1875], isConnect=True, isParent=True) ThumbJ2 = "Proxies" + armPrefx + "_ThumbJ2" self.CreatePrixyNode(ThumbJ2, PC=ThumbJ1, mMvoe=[armMultiplier * 0, 0, 0.75], mScale=[0.75, 0.75, 0.75], lScale=[0.1875, 0.1875, 0.1875], isConnect=True, isParent=True) ThumbJ3 = "Proxies" + armPrefx + "_ThumbJ3" self.CreatePrixyNode(ThumbJ3, PC=ThumbJ2, mMvoe=[armMultiplier * 0, 0, 0.75], mScale=[0.75, 0.75, 0.75], lScale=[0.1875, 0.1875, 0.1875], isConnect=True, isParent=True) ThumbJTip = "Proxies" + armPrefx + "_ThumbJTip" self.CreatePrixyNode(ThumbJTip, PC=ThumbJ3, mMvoe=[armMultiplier * 0, 0, 0.75], mScale=[0.75, 0.75, 0.75], lScale=[0.1875, 0.1875, 0.1875], isConnect=True, isParent=True) fingerIndex = 1 while fingerIndex <= fingersNum: FingerJ1 = "Proxies" + armPrefx + "_Finger_" + str(fingerIndex) + "_J1" if fingerIndex == 1: self.ProxyBase(FingerJ1) PCons = cmds.pointConstraint(Wrist, FingerJ1) cmds.delete(PCons) cmds.move(armMultiplier * 1.47, 0, 0, FingerJ1, r=True, os=True, wd=True) if fingersNum == 2: cmds.move(0, 0, 0.25, FingerJ1, r=True) cmds.makeIdentity(FingerJ1, apply=True, t=1, r=1, s=1) elif fingersNum >= 3: cmds.move(0, 0, 0.5, FingerJ1, r=True) cmds.makeIdentity(FingerJ1, apply=True, t=1, r=1, s=1) else: FingerJ0 = "Proxies" + armPrefx + "_Finger_" + str(fingerIndex - 1) + "_J1" self.ProxyBase(FingerJ1) PCons = cmds.pointConstraint(FingerJ0, FingerJ1) cmds.delete(PCons) cmds.move(0, 0, -0.4, FingerJ1, r=True, os=True, wd=True) cmds.scale(0.62, 0.62, 0.62, FingerJ1) cmds.makeIdentity(FingerJ1, apply=True, t=1, r=1, s=1) cmds.setAttr("%sSnapShape.localScaleX" % FingerJ1, 0.155) cmds.setAttr("%sSnapShape.localScaleY" % FingerJ1, 0.155) cmds.setAttr("%sSnapShape.localScaleZ" % FingerJ1, 0.155) cmds.parent(FingerJ1, Palm) self.ProxyConnectors(Palm, FingerJ1) FingerJ2 = "Proxies" + armPrefx + "_Finger_" + str(fingerIndex) + "_J2" self.CreatePrixyNode(FingerJ2, PC=FingerJ1, mMvoe=[armMultiplier * 0.61, 0, 0], mScale=[0.62, 0.62, 0.62], lScale=[0.155, 0.155, 0.155], isConnect=True, isParent=True) FingerJ3 = "Proxies" + armPrefx + "_Finger_" + str(fingerIndex) + "_J3" self.CreatePrixyNode(FingerJ3, PC=FingerJ2, mMvoe=[armMultiplier * 0.61, 0, 0], mScale=[0.62, 0.62, 0.62], lScale=[0.155, 0.155, 0.155], isConnect=True, isParent=True) FingerJTip = "Proxies" + armPrefx + "_Finger_" + str(fingerIndex) + "_JTip" self.CreatePrixyNode(FingerJTip, PC=FingerJ3, mMvoe=[armMultiplier * 0.61, 0, 0], mScale=[0.62, 0.62, 0.62], lScale=[0.155, 0.155, 0.155], isConnect=True, isParent=True) fingerIndex += 1 cmds.makeIdentity(Wrist, apply=True, t=1, r=1, s=1) armPrefx = "_R" armMultiplier = -1.0 armLoop += 1 # Legs legLoop = 1 legPrefx = "_L" legMultiplier = 1.0 while legLoop <= 2: Hip = "Proxies" + legPrefx + "_Hip" self.CreatePrixyNode(Hip, PC=self.Proxies_Root, mMvoe=[legMultiplier * 1.72, -0.8, 0], isConnect=True, isParent=True) Knee = "Proxies" + legPrefx + "_Knee" self.CreatePrixyNode(Knee, PC=Hip, mMvoe=[0, -6.4, 0], mRotate=[0, 180, 90], isConnect=True, isParent=True) Ankle = "Proxies" + legPrefx + "_Ankle" self.CreatePrixyNode(Ankle, PC=Knee, mMvoe=[0, -6.4, 0], isConnect=True, isParent=True) KneeG = "Proxies" + legPrefx + "_Knee_GRP" cmds.group(n=KneeG, em=True) PCons = cmds.pointConstraint(Knee, KneeG) cmds.delete(PCons) cmds.parent(Knee, KneeG) cmds.makeIdentity(KneeG, apply=True, t=1, r=1, s=1) # cmds.move(0,0,0.001,"%s.scalePivot" % KneeG,"%s.rotatePivot" % KneeG ,r=True) cmds.pointConstraint(Hip, Ankle, KneeG, mo=True) cmds.parent(KneeG, Ankle, self.Main) Ball = "Proxies" + legPrefx + "_Ball" self.CreatePrixyNode(Ball, PC=Ankle, mMvoe=[0, -1.65, 2.26], isConnect=True, isParent=True) Toe = "Proxies" + legPrefx + "_Toe" self.CreatePrixyNode(Toe, PC=Ball, mMvoe=[0, 0, 1.7]) if toesNum == 1: self.ProxyConnectors(Ball, Toe) BallG = "Proxies" + legPrefx + "_Ball_GRP" cmds.group(n=BallG, em=True) cmds.parent(BallG, Ball) cmds.parent(Toe, BallG) KneeLocator = "Proxies" + legPrefx + "_KneeLocator" cmds.spaceLocator(n=KneeLocator) PCons = cmds.pointConstraint(Knee, KneeLocator) cmds.delete(PCons) cmds.parent(KneeLocator, Knee) cmds.move(0, 0, 1.5, KneeLocator, r=True) cmds.setAttr("%s.v" % KneeLocator, 0) # toe num cmds.makeIdentity(Ball, apply=True, t=1, r=1, s=1) legLoop += 1 legPrefx = "_R" legMultiplier = -1.0 # PARENT CONTROLS cmds.parent(self.Proxies_Root, spineProxiesG, self.Proxies_SpineTop, neckProxiesG, self.Proxies_Head, self.Main) cmds.parent(self.Proxies_Jaw, self.Proxies_HeadTip, self.Proxies_L_Eye, self.Proxies_R_Eye, self.Proxies_Head) cmds.parent(self.Proxies_JawTip, self.Proxies_Jaw) # INDICATOR self.ElbowIndicator("L") self.ElbowIndicator("R") self.KneeIndicator("L") self.KneeIndicator("R") # LOCATORS FOR FOOT TILT self.FootTilt("L") self.FootTilt("R") self.LimitAndLock() # CREATE LAYER cmds.select(self.Main) layer = cmds.objExists("ProxiesLayer") if layer is not None: cmds.createDisplayLayer(n="ProxiesLayer", number=1, nr=True) else: cmds.editDisplayLayerMembers("ProxiesLayer", self.Main, noRecurse=True) cmds.select(clear=True) # menber self.Main = "Proxies_Main" self.Proxies_Root = "Proxies_Root" self.Proxies_SpineTop = "Proxies_SpineTop" self.Proxies_Head = "Proxies_Head" self.Proxies_Jaw = "Proxies_Jaw" self.Proxies_JawTip = "Proxies_JawTip" self.Proxies_HeadTip = "Proxies_HeadTip" self.Proxies_L_Eye = "Proxies_L_Eye" self.Proxies_R_Eye = "Proxies_R_Eye" self.Proxies_L_Clavicle = "Proxies_L_Clavicle" self.Proxies_L_Shoulder = "Proxies_L_Shoulder" self.Proxies_L_Wrist = "Proxies_L_Wrist" self.Proxies_L_Palm = "Proxies_L_Palm" self.Proxies_L_Hip = "Proxies_L_Hip" self.Proxies_L_Ankle = "Proxies_L_Ankle" self.Proxies_L_Elbow = "Proxies_L_Elbow" self.Proxies_L_Knee = "Proxies_L_Knee" self.Proxies_L_Ball = "Proxies_L_Ball" self.Proxies_L_Toe = "Proxies_L_Toe" self.Proxies_R_Clavicle = "Proxies_R_Clavicle" self.Proxies_R_Shoulder = "Proxies_R_Shoulder" self.Proxies_R_Wrist = "Proxies_R_Wrist" self.Proxies_R_Palm = "Proxies_R_Palm" self.Proxies_R_Hip = "Proxies_R_Hip" self.Proxies_R_Ankle = "Proxies_R_Ankle" self.Proxies_R_Elbow = "Proxies_R_Elbow" self.Proxies_R_Knee = "Proxies_R_Knee" self.Proxies_R_Ball = "Proxies_R_Ball" self.Proxies_R_Toe = "Proxies_R_Toe" pass
def makeArm(self, isLeft, leftRight, jntArmArray, jntClavicle, jntScapula, colourTU, jntShoulderRoot, ctrlFKIK, ctrlFKIKAttr, jntSpine6, checkboxTwists, checkboxSpine, checkGeo, checkboxSwitch, ctrlIKChest, ctrlCOG, grpFollow, geoJntArray, *args): # Adding the twist joints if checkboxTwists: # xprNameTwist, twistExpression, geoJntArray = self.makeTwists(3, leftRight, jntArmArray, geoJntArray, makeExpression) xprNameTwist, twistExpression, geoJntArray = self.makeTwists( 3, leftRight, jntArmArray, geoJntArray) # NOTE: I use a slightly different order than the originals, leaving the SetGeo section to the lat # Creating FK and IK Joints bndJnts, fkJnts, ikJnts = self.getBndFkIkJnts(jntArmArray) fkLen = len(fkJnts) ikLen = len(ikJnts) bndLen = len(bndJnts) if bndLen != fkLen or bndLen != ikLen: mc.warning("Your arm joints are somehow not equal") return else: ikFkJntConstraints = [] for i in range(bndLen): temp = mc.orientConstraint(fkJnts[i], ikJnts[i], bndJnts[i])[0] ikFkJntConstraints.append(temp) for i in range(len(ikFkJntConstraints)): self.tgpSetDriverArmFKIKSwitch(ctrlFKIK, ctrlFKIKAttr, ikFkJntConstraints[i]) # we want to create FK controls for the limbs except the end armLength, fkJntOffsetCtrls = self.createArmFKs(fkJnts, colourTU) # create the shoulder control shoulderOffsetCtrl = self.setupShoulder(jntShoulderRoot, bndJnts, fkJntOffsetCtrls, colourTU) # create the clavicle if jntClavicle: clavicleOffsetCtrl = self.setupClavicle(jntClavicle, colourTU, leftRight, shoulderOffsetCtrl, jntArmArray) # create the scapula if jntScapula: scapulaOffsetCtrl = self.setupScapula( jntScapula, colourTU, leftRight, shoulderOffsetCtrl, ) # for testing purposes only, setting the IK to active: mc.setAttr("{0}.{1}".format(ctrlFKIK, ctrlFKIKAttr), 0.5) # Setting up the IK Arm ikOffsetCtrl, ikArms, ikJntsDrive, ikSide = self.createArmIK( ikJnts, leftRight, colourTU, isLeft) # create the twists self.setupIkElblowArmTwist(ikOffsetCtrl, ikJnts, ikArms, isLeft) # change the rotation order rotationChange = [ ikJnts[1], jntArmArray[1], fkJnts[1], ikJntsDrive[1], fkJntOffsetCtrls[1][1] ] CRU.changeRotateOrder(rotationChange, "YZX") # Adding the Elbow Control elbowOffsetCtrl = self.createElbow( ikJntsDrive, leftRight, armLength, ikArms, isLeft, colourTU, ) # Adding Space Switching # NOTE: This is something I added from the finalizing section if checkboxSwitch: # self.makeArmSwitch(ctrlLimb, ctrlShoulder, ctrlChest, ctrlCOG, grpFollow, leftRight, colourTU) self.makeArmSwitch(fkJntOffsetCtrls[0][1], shoulderOffsetCtrl[1], ctrlIKChest, ctrlCOG, grpFollow, leftRight, colourTU) # Organize the rig self.armCleanUp(fkJnts, ikJnts, ikJntsDrive, bndJnts, jntShoulderRoot, jntScapula, jntClavicle, checkboxSpine, shoulderOffsetCtrl, scapulaOffsetCtrl, clavicleOffsetCtrl, ikOffsetCtrl, elbowOffsetCtrl, ikArms, jntSpine6, ikSide, fkJntOffsetCtrls, ctrlFKIK, ctrlFKIKAttr) if checkGeo: CRU.tgpSetGeo(geoJntArray, setLayer=True)
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 bicepJnts(side): import maya.cmds as mc # refer to the no roll attribute control attrCtrl = "%s_arm_SW_ctrl" % side rev = mc.createNode("reverse", n="%s_arm_01_no_twist_rev" % side) mc.connectAttr("%s.%s_nr" % (attrCtrl, side), "%s.ix" % rev) # refer to bicep joints jnt1 = ("%s_arm_01_deform_ctrl_01" % side) jnt2 = ("%s_arm_01_deform_ctrl_02" % side) jnt3 = ("%s_arm_01_deform_ctrl_03" % side) jnt4 = ("%s_arm_01_deform_ctrl_04" % side) # refer to bicep nt joints ntjnt1 = ("%s_arm_01_no_twist_ctrl_01" % side) ntjnt2 = ("%s_arm_01_no_twist_ctrl_02" % side) ntjnt3 = ("%s_arm_01_no_twist_ctrl_03" % side) ntjnt4 = ("%s_arm_01_no_twist_ctrl_04" % side) # controls tempCrcl1 = mc.circle(n="%s_tempCircle1" % side) mc.delete(tempCrcl1, ch=True) mc.rotate(90, 0, 0, "%s.cv[0:9]" % tempCrcl1[0], r=1) mc.scale(.9, .7, .5, "%s.cv[0:9]" % tempCrcl1[0], r=1) mc.parent("%sShape" % tempCrcl1[0], ntjnt1, s=True, r=True) mc.select(cl=True) mc.delete(tempCrcl1[0]) oriConst1 = mc.orientConstraint(jnt1, ntjnt1, mo=True) mc.connectAttr("%s.ox" % rev, "%s.w0" % oriConst1[0]) tempCrcl2 = mc.circle(n="%s_tempCircle2" % side) mc.delete(tempCrcl2, ch=True) mc.rotate(90, 0, 0, "%s.cv[0:9]" % tempCrcl2[0], r=1) mc.scale(.9, .7, .5, "%s.cv[0:9]" % tempCrcl2[0], r=1) mc.parent("%sShape" % tempCrcl2[0], ntjnt2, s=True, r=True) mc.select(cl=True) mc.delete(tempCrcl2[0]) oriConst2 = mc.orientConstraint(jnt2, ntjnt2, mo=True) mc.connectAttr("%s.ox" % rev, "%s.w0" % oriConst2[0]) tempCrcl3 = mc.circle(n="%s_tempCircle3" % side) mc.delete(tempCrcl3, ch=True) mc.rotate(90, 0, 0, "%s.cv[0:9]" % tempCrcl3[0], r=1) mc.scale(.9, .7, .5, "%s.cv[0:9]" % tempCrcl3[0], r=1) mc.parent("%sShape" % tempCrcl3[0], ntjnt3, s=True, r=True) mc.select(cl=True) mc.delete(tempCrcl3[0]) oriConst3 = mc.orientConstraint(jnt3, ntjnt3, mo=True) mc.connectAttr("%s.ox" % rev, "%s.w0" % oriConst3[0]) tempCrcl4 = mc.circle(n="%s_tempCircle4" % side) mc.delete(tempCrcl4, ch=True) mc.rotate(90, 0, 0, "%s.cv[0:9]" % tempCrcl4[0], r=1) mc.scale(.9, .7, .5, "%s.cv[0:9]" % tempCrcl4[0], r=1) mc.parent("%sShape" % tempCrcl4[0], ntjnt4, s=True, r=True) mc.select(cl=True) mc.delete(tempCrcl4[0]) oriConst4 = mc.orientConstraint(jnt4, ntjnt4, mo=True) mc.connectAttr("%s.ox" % rev, "%s.w0" % oriConst4[0])
def createFKJointCtls(controlBaseGrp, parentJntsArray, lettersArray, side="L", jntPrefix="JNT", grpPrefix="GRP", ctlPrefix="CTL", part="toe"): #Get information fkJntChains = parentJntsArray curlGrps = [] #Contains curl offset groups for each ctl rootCtlGrp = [] incre = -1 #For toe lettering for jntChain in fkJntChains: incre2 = 0 #For down chain numbering incre = incre + 1 #Get all of a toes segments parentAndChildJntChain = returnParentAndChildren(jntChain, reverse=False) #Remove the end joint from the list del parentAndChildJntChain[len(parentAndChildJntChain) - 1] #For each joint in each toe for jnt in parentAndChildJntChain: incre2 = incre2 + 1 #Duplicate the controlBaseGrp newCtlGrp = ma.duplicate(controlBaseGrp) #Rename grp and ctl and return both newCtlGrp, newCtl = renameControl( newCtlGrp[0], (side + "_" + part + lettersArray[incre] + "FKCtl0" + str(incre2) + "_" + grpPrefix), (side + "_" + part + lettersArray[incre] + "FK0" + str(incre2) + "_" + ctlPrefix)) #Lock unwanted attributes (all but rotation) for attr1 in (".translate", ".scale", ".visibility"): if attr1 != ".visibility": for attr2 in ("X", "Y", "Z"): ma.setAttr(str(newCtl) + attr1 + attr2, l=True, k=False) else: ma.setAttr(str(newCtl) + attr1, l=True, k=False) #point and orient to the current joint pointAndOrientSelected(item1=jnt, item2=newCtlGrp) #Duplicate point and orientated Grp for curl grp curlGrp = ma.duplicate( newCtlGrp, po=True, n=(side + "_" + part + lettersArray[incre] + "FKCurl0" + str(incre2) + "_" + grpPrefix)) #parent group under original group then parent ctl under that ma.parent(newCtl, curlGrp) ma.parent(curlGrp, newCtlGrp) newCtl = findLastChild(newCtlGrp) #constrainCtlJnt to Ctl ma.orientConstraint(newCtl, jnt) if incre2 == 1: rootCtlGrp.append(newCtlGrp) parentCtl = newCtl else: #print str(newCtlGrp)+" "+str(parentCtl) ma.parent(newCtlGrp, parentCtl) parentCtl = findLastChild(parentCtl) for rootJnt in rootCtlGrp: toeHierach = returnParentAndChildren(rootJnt, reverse=False) incre = 0 incre2 = 0 for jntTransform in toeHierach: if incre2 == 1: curlGrps.append(jntTransform) incre2 = incre2 + 1 elif incre2 == 2: if incre == 2: curlGrps.append(jntTransform) incre = 0 else: incre = incre + 1 else: incre2 = incre2 + 1 return rootCtlGrp, curlGrps #Return all the rootctlGrps, and curl offset grps
def _bakeCamera(sourceCamera = ''): """ Used for quickly baking out a camera into an existing CAM group. Useful for checking in tracked cameras etc """ if sourceCamera == '': sourceCamera = cmds.ls(sl=True)[0] sourceCameraShape = cmds.listRelatives(sourceCamera, shapes = True)[0] startFrame = int(cmds.playbackOptions(query = True, animationStartTime = True)) endFrame = int(cmds.playbackOptions(query = True, animationEndTime = True)) focallength = int(cmds.getAttr('%s.focalLength' % sourceCameraShape) ) camName = '%s_bake' % (sourceCamera) newCam = cmds.camera( name = camName, centerOfInterest = 5, focalLength = cmds.getAttr('%s.focalLength' % sourceCamera), lensSqueezeRatio = 1, cameraScale = cmds.getAttr('%s.cameraScale' % sourceCamera), horizontalFilmAperture = cmds.getAttr('%s.horizontalFilmAperture' % sourceCamera), horizontalFilmOffset = 0, verticalFilmAperture = cmds.getAttr('%s.verticalFilmAperture' % sourceCamera), verticalFilmOffset = 0, filmFit = getFilmFit(cmds.getAttr('%s.filmFit' % sourceCamera)) , overscan = cmds.getAttr('%s.overscan' % sourceCamera), motionBlur = 0, shutterAngle = 144, nearClipPlane = cmds.getAttr('%s.nearClipPlane' % sourceCamera), farClipPlane = cmds.getAttr('%s.farClipPlane' % sourceCamera), orthographic = 0, orthographicWidth = 30, panZoomEnabled = 0, horizontalPan = 0, verticalPan = 0, zoom = 1, dgm = True, dr= True, dsa = True ) cmds.rename('%s1' % camName, camName)#stupid freaking maya can't create a new freaking node without putting a 1 at the end of it. createTypeTag(camName, 'shotCam') cmds.connectAttr('%s.focalLength' % sourceCameraShape, '%sShape.focalLength' % camName) cmds.pointConstraint(sourceCamera, camName, n = 'TmpPoint', mo = False) cmds.orientConstraint(sourceCamera, camName, n = 'TmpOrient', mo = False) cmds.bakeResults( camName, simulation = True, t = (startFrame,endFrame), sampleBy = 1, disableImplicitControl = True, preserveOutsideKeys = False, sparseAnimCurveBake = False, removeBakedAttributeFromLayer = False, bakeOnOverrideLayer = False, controlPoints = False, shape = True ) cmds.delete('TmpPoint') cmds.delete('TmpOrient') try: cmds.parent(camName, 'BAKE_CAM_hrc') except TypeError: cmds.group(n = 'BAKE_CAM_hrc', em = True) cmds.parent(camName, 'BAKE_CAM_hrc') except ValueError: cmds.group(n = 'BAKE_CAM_hrc', em = True) cmds.parent(camName, 'BAKE_CAM_hrc') #get the imageplane and put it into the new camera. try: for input in cmds.listConnections('%s' % sourceCameraShape, source = True): if 'imagePlane' in input: cmds.shadingNode('imagePlane', asUtility = True , name = 'tempPlane') cmds.connectAttr('%s.message' % input, '%sShape.imagePlane[0]' % camName) cmds.delete('tempPlane') except TypeError: print 'No image plane found, skipping...' return camName
def createIKLeg(side="L", grpPrefix="GRP", ctlPrefix="CTL", ikhPrefix="IKH", jntPrefix="JNT", masterToe=1, legStretchOffset=0.6): #Get selected sel = ma.ls(sl=True) #I didn't know how to get alphabetical letters for toe ik handles nicely, sue me #No one have this many toes on a single footJnt, but gotta be safe letters = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J"] #List of floating point attributes to add to the ik control IKfootJntAttrs = [ "toeEndTip", "toeEndSwivel", "toeUpperTip", "heelTip", "heelSwivel" ] #Store variables legStartJnt = sel[0] legMidJnt = sel[1] legEndJnt = sel[2] footJnt = sel[3] #IK Controls footJntIKCtlGrp = sel[4] footJntIKCtl = None legPVCtlGrp = sel[5] legPVCtl = None #FK Controls legFKUpperCtlGrp = sel[6] legFKUpperCtl = None legFKLowerCtlGrp = sel[7] legFKLowerCtl = None legFKHeelCtlGrp = sel[8] legFKHeelCtl = None legFKFootCtlGrp = sel[9] legFKFootCtl = None #FKIK switch fkIKCtlGrp = sel[10] fkIKCtl = None fkToeCtlGrp = sel[11] # Control is duped for each toe joint control toeStartEnd = [] # to hold all toe start and ends toeIKHs = [] #To hold all toe ik handles fkToeCtlGrps = [] #To hold all the fk toe controls fkToeJnts = [] #To Hold all toe jnt roots to be given fk ctls fkToeCurlGrps = [] #To hold the curl offset groups for the toes ### PREP FOR FK TOES #Make duplicate toes parent old joints to new and get new start and end toeStartEnd = dupAndParentChildChainStartEnd(footJnt, letters, side, jntPrefix) #### MAKE IK #### #Create IK handle for leg itself ma.select(cl=True) ma.select((legStartJnt, legEndJnt)) legIK = ma.ikHandle(sol="ikRPsolver") #Rename IK handle legIKH = ma.rename(legIK[0], side + "_leg_" + ikhPrefix) #Create IK handle for footJnt ma.select(cl=True) ma.select((legEndJnt, footJnt)) footJntIK = ma.ikHandle(sol="ikSCsolver") footJntIKH = ma.rename(footJntIK[0], side + "_footJnt_" + ikhPrefix) #Create IK handle for toe ma.select(cl=True) ma.select((footJnt, toeStartEnd[masterToe][0])) toeIK = ma.ikHandle(sol="ikSCsolver") toeIKH = ma.rename(toeIK[0], side + "_toe_" + ikhPrefix) #Rename IK Control footJntIKCtlGrp, footJntIKCtl = renameControl( footJntIKCtlGrp, side + "_legIkCtl_" + grpPrefix, side + "_legIk_" + ctlPrefix) #Rename IK PV Control legPVCtlGrp, legPVCtl = renameControl(legPVCtlGrp, side + "_legPVCtl_" + grpPrefix, side + "_legPV_" + ctlPrefix) #lock and hide unwanted attributes on ikctl and pvCtl for fkCtlAttr in ("X", "Y", "Z"): ma.setAttr(footJntIKCtl + ".scale" + fkCtlAttr, l=True, k=False) ma.setAttr(legPVCtl + ".scale" + fkCtlAttr, l=True, k=False) ma.setAttr(legPVCtl + ".rotate" + fkCtlAttr, l=True, k=False) ma.setAttr(footJntIKCtl + ".visibility", l=True, k=False) ma.setAttr(legPVCtl + ".visibility", l=True, k=False) #Move IK Contol pointConTemp = ma.pointConstraint(legEndJnt, footJntIKCtlGrp) ma.delete(pointConTemp) #Point contraint footJntIKH to footJntIKCtl #ma.pointConstraint(footJntIKCtl, legIKH) #Move PV Control pointConTemp = ma.pointConstraint(legMidJnt, legPVCtlGrp) ma.delete(pointConTemp) ma.move(0, 0, 50, legPVCtlGrp, os=True, r=True) #Create Pole Vector Constraint ma.poleVectorConstraint(legPVCtl, legIKH) ##Create each toe IK and store handle in toeIKHs! incr = -1 for toe in toeStartEnd: incr = incr + 1 ma.select(cl=True) ma.select(toe[0], toe[1]) ikTemp = ma.ikHandle(sol="ikSCsolver") ikTemp = ma.rename(ikTemp[0], side + "_toe" + letters[incr] + "IK_" + ikhPrefix) ma.setAttr(toe[1] + ".visibility", 0) toeIKHs.append(ikTemp) #### Create FKIK Switch! #### #Name IKFK CTL fkIKCtlGrp, fkIKCtl = renameControl(fkIKCtlGrp, side + "_legFKIKCtl_" + grpPrefix, side + "_legFKIK_" + ctlPrefix) #Move IKFK Ctl pointConTemp = ma.pointConstraint(legEndJnt, fkIKCtlGrp) ma.delete(pointConTemp) #Add attribute to FKIK ma.addAttr(fkIKCtl, ln="FKIK", min=0, max=1, dv=0, k=True) #FK Toe visibility (for use later!) ma.addAttr(fkIKCtl, ln="fkToeVisibility", min=0, max=1, dv=0, k=True) #Connect attribute IKH ikblend attributes to FKIK #leg, foot, toe for hdl in (legIKH, footJntIKH, toeIKH): ma.connectAttr(fkIKCtl + ".FKIK", hdl + ".ikBlend") #toes for hdl in toeIKHs: ma.connectAttr(fkIKCtl + ".FKIK", hdl + ".ikBlend") #### Reverse footJnt Setup! #### #Create root joint reverse footJnt joint (Heel joint) ma.select(cl=True) rvHeelJnt = ma.joint(rad=0.5) rvHeelJnt = ma.rename(rvHeelJnt, side + "_footJntRV01_" + jntPrefix) #Move root reverse footJnt pointConTemp = ma.pointConstraint(legEndJnt, rvHeelJnt) ma.delete(pointConTemp) ma.move(0, rvHeelJnt, y=True) #make the rest of the reverse footJnt #Get locations for the reverse footJnt joints reversefootJntLocations = [] for rvLocation in (toeStartEnd[masterToe][1], toeStartEnd[masterToe][0], footJnt, legEndJnt): reversefootJntLocations.append( tuple(ma.xform(rvLocation, q=True, ws=True, t=True))) #Create the IK toe joints rvJnts = createJointChainOnPos(reversefootJntLocations) #Rename all joints incr = len(rvJnts) + 2 for jnt in rvJnts: incr = incr - 1 if incr == 2: #If it is the second to last joint, parent it under the heel root ma.parent( ma.rename(jnt, side + "_footJntRV0" + str(incr) + "_" + jntPrefix), rvHeelJnt) else: ma.rename(jnt, side + "_footJntRV0" + str(incr) + "_" + jntPrefix) #Re obtain all the now children of rvHeelJnt, these are the rvJnts rvJnts = returnParentAndChildren(rvHeelJnt, reverse=False) #parent toesIKHs under the toe jnt on reverse footJnt rig for toeHandle in toeIKHs: ma.parent(toeHandle, rvJnts[1]) #parent toeIKH under the first toe rvjnt ma.parent(toeIKH, rvJnts[2]) #parent footJntIKH under footJnt rvjnt ma.parent(footJntIKH, rvJnts[3]) #parent leg IKH under leg rvjnt ma.parent(legIKH, rvJnts[4]) #Make custom attributes for footJnt IK control for attr in IKfootJntAttrs: ma.addAttr(footJntIKCtl, ln=attr, dv=0, k=True) #Connect new attributes to their respective reverse footJnt joint attributes ma.connectAttr(footJntIKCtl + "." + IKfootJntAttrs[0], rvJnts[1] + ".rotateX") #Toe End Tip ma.connectAttr(footJntIKCtl + "." + IKfootJntAttrs[1], rvJnts[1] + ".rotateY") #Toe End End Swivel ma.connectAttr(footJntIKCtl + "." + IKfootJntAttrs[2], rvJnts[2] + ".rotateX") #Toe Tip Upper ma.connectAttr(footJntIKCtl + "." + IKfootJntAttrs[3], rvJnts[3] + ".rotateX") #Heel Tip ma.connectAttr(footJntIKCtl + "." + IKfootJntAttrs[4], rvJnts[3] + ".rotateY") #Heel Swivel #Parent Constrain the root Reverse footJnt to the ikCtl ma.parentConstraint(footJntIKCtl, rvJnts[0], mo=True) #hide the RV foot ma.setAttr(rvJnts[0] + ".visibility", 0) #### Attatching FK Leg Controls #### #rename controls legFKUpperCtlGrp, legFKUpperCtl = renameControl( legFKUpperCtlGrp, side + "_legFK01Ctl_" + grpPrefix, side + "_legFK01_" + ctlPrefix) legFKLowerCtlGrp, legFKLowerCtl = renameControl( legFKLowerCtlGrp, side + "_legFK02Ctl_" + grpPrefix, side + "_legFK02_" + ctlPrefix) legFKHeelCtlGrp, legFKHeelCtl = renameControl( legFKHeelCtlGrp, side + "_legFK03Ctl_" + grpPrefix, side + "_legFK03_" + ctlPrefix) legFKFootCtlGrp, legFKFootCtl = renameControl( legFKFootCtlGrp, side + "_legFK04Ctl_" + grpPrefix, side + "_legFK04_" + ctlPrefix) #position controls for fkJnt, fkCtlGrp, fkCtl in zip( (legStartJnt, legMidJnt, legEndJnt, footJnt), (legFKUpperCtlGrp, legFKLowerCtlGrp, legFKHeelCtlGrp, legFKFootCtlGrp), (legFKUpperCtl, legFKLowerCtl, legFKHeelCtl, legFKFootCtl)): #Move ctls to joints pointAndOrientSelected(item1=fkJnt, item2=fkCtlGrp) #orientConstrain joints to ctls ma.orientConstraint(fkCtl, fkJnt) #Make an orient constraint group for each iktoe so that they have a default orient when not in ikblend 1 ikToesOrientGrpCns = [] incr = -1 for ikToeJnt in toeStartEnd: incr = incr + 1 ikToeCnGrp = ma.createNode("transform", n=side + "_ikToe" + letters[incr] + "OrientCn_" + grpPrefix) pointAndOrientSelected(item1=ikToeJnt[0], item2=ikToeCnGrp) ma.orientConstraint(ikToeCnGrp, ikToeJnt[0]) ikToesOrientGrpCns.append(ikToeCnGrp) #CreateToeOrientCnGrp to contain all toes orient constraint groups ikToesCnGrpGrp = ma.createNode("transform", n=side + "_ikToeOrientCnGrp_" + grpPrefix) for cnGrp in ikToesOrientGrpCns: ma.parent(cnGrp, ikToesCnGrpGrp) #parent grpgrp under last FKlegCtl ma.parent(ikToesCnGrpGrp, legFKFootCtl) for toe in toeStartEnd: fkToeJnts.append(ma.listRelatives(toe[0], f=True)[1]) #parent fk controls in hierachy ma.parent(legFKFootCtlGrp, legFKHeelCtl) ma.parent(legFKHeelCtlGrp, legFKLowerCtl) ma.parent(legFKLowerCtlGrp, legFKUpperCtl) #### FK TOES CREATION! #### #Create FK toe ctls and curl offset grps fkToeCtlGrps, fkToeCurlGrps = createFKJointCtls(fkToeCtlGrp, fkToeJnts, letters, side, jntPrefix, grpPrefix, ctlPrefix) #Add attributes to FKIK Ctl ma.addAttr(fkIKCtl, ln="toeScrunch", dv=0, k=True) ma.addAttr(fkIKCtl, ln="toeSpread", dv=0, k=True) #linking up to scrunch, rotate Z incre = 0 #Create reverse node for toe scrunch toeScrunchRVNode = ma.createNode("reverse", n=side + "_toeScrunch_RV") ma.connectAttr(fkIKCtl + ".toeScrunch", toeScrunchRVNode + ".inputX") for toeCurlGrp in fkToeCurlGrps: if incre == 0: incre = incre + 1 ma.connectAttr(fkIKCtl + ".toeScrunch", toeCurlGrp + ".rotateZ") #Toe End Tip elif incre == 2: incre = 0 ma.connectAttr(toeScrunchRVNode + ".outputX", toeCurlGrp + ".rotateZ") else: incre = incre + 1 ma.connectAttr(toeScrunchRVNode + ".outputX", toeCurlGrp + ".rotateZ") #Linking up rotate Y for toe spread attr incre = 0 #Create toe spread reverse node toeSpreadRVNode = ma.createNode("reverse", n=side + "_toeSpread_RV") #Create divide nodes toeSpreadRVDiv = ma.createNode("multiplyDivide", n=side + "_toeSpreadRV_MDV") toeSpreadDiv = ma.createNode("multiplyDivide", n=side + "_toeSpread_MDV") #Set divide node input 2X ma.setAttr(toeSpreadRVDiv + ".operation", 2) ma.setAttr(toeSpreadDiv + ".operation", 2) ma.setAttr(toeSpreadRVDiv + ".input2X", 2) ma.setAttr(toeSpreadDiv + ".input2X", 2) #Connect up divide and reverse nodes ma.connectAttr(fkIKCtl + ".toeSpread", toeSpreadRVNode + ".inputX") ma.connectAttr(fkIKCtl + ".toeSpread", toeSpreadDiv + ".input1X") ma.connectAttr(toeSpreadRVNode + ".outputX", toeSpreadRVDiv + ".input1X") #Attatch all the toe starts to spread for toeCurlGrp in fkToeCurlGrps: incre = incre + 1 if incre == 1: ma.connectAttr(toeSpreadRVDiv + ".outputX", toeCurlGrp + ".rotateY") elif incre == 4: ma.connectAttr(toeSpreadRVNode + ".outputX", toeCurlGrp + ".rotateY") elif incre == 7: ma.connectAttr(toeSpreadRVDiv + ".outputX", toeCurlGrp + ".rotateY") elif incre == 10: ma.connectAttr(toeSpreadDiv + ".outputX", toeCurlGrp + ".rotateY") elif incre == 13: ma.connectAttr(fkIKCtl + ".toeSpread", toeCurlGrp + ".rotateY") else: pass #### SETTING VISIBILITY, PARENTING #### #Create fkik reverse node and connect to fkik fkikRV = ma.createNode("reverse", n=side + "_fkIK_RV") ma.connectAttr(fkIKCtl + ".FKIK", fkikRV + ".inputX") #set visibility of IK foot #legFKUpperCtlGrp, footJntIKCtlGrp ma.connectAttr(fkIKCtl + ".FKIK", footJntIKCtlGrp + ".visibility") ma.connectAttr(fkIKCtl + ".FKIK", legPVCtlGrp + ".visibility") ma.connectAttr(fkikRV + ".outputX", legFKUpperCtlGrp + ".visibility") ## Parent constrain fkIKCtlGrp to the legEndJnt ma.parentConstraint(legEndJnt, fkIKCtlGrp, mo=True) #Create fkToeCtls_GRP to contain all the toe ctls fkToeCtlsGrp = ma.createNode("transform", n=side + "_fkToeCtls_" + grpPrefix) #parent constrain root toes toe their respective ik switching toe jnts for toe, toeRootGrp in zip(toeStartEnd, fkToeCtlGrps): ma.parentConstraint(toe[0], toeRootGrp) ma.connectAttr(fkIKCtl + ".fkToeVisibility", toeRootGrp + ".visibility") # Parent all toeRootGrps under fkToeCtlsGrp ma.parent(toeRootGrp, fkToeCtlsGrp) #### CREATE STRETCHY LEGS! #### #Create and name locators! legStretchStartLoc = ma.spaceLocator(n=side + "_legStartStretch_LOC") legStretchEndLoc = ma.spaceLocator(n=side + "_legEndStretch_LOC") #point constrain locators to start and end ma.pointConstraint(legStartJnt, legStretchStartLoc) ma.pointConstraint(footJntIKCtl, legStretchEndLoc) #Create a distance between node legStretchDst = ma.createNode("distanceBetween", n=side + "_legStretch_DST") ma.connectAttr(legStretchStartLoc[0] + ".worldMatrix", legStretchDst + ".inMatrix1") ma.connectAttr(legStretchEndLoc[0] + ".worldMatrix", legStretchDst + ".inMatrix2") #Create a divide node! legStretchDiv = ma.createNode("multiplyDivide", n=side + "_legStretchValue_MDV") ma.setAttr(legStretchDiv + ".operation", 2) #Create worldscale divide node! worldScaleMult = ma.createNode("multiplyDivide", n=side + "_legWorldScale_MDV") #Set input2X to default distance (leaving 1X open for the world scale) ma.setAttr(worldScaleMult + ".input2X", (ma.getAttr(legStretchDst + ".distance") + legStretchOffset)) ma.setAttr(worldScaleMult + ".input1X", 1) # This will need to be attatched to the world scale later! #Connect distance node to input1X and worldScaleMult to input2X ma.connectAttr(legStretchDst + ".distance", legStretchDiv + ".input1X") ma.connectAttr(worldScaleMult + ".outputX", legStretchDiv + ".input2X") #Create a condition node legStretchCon = ma.createNode("condition", n=side + "_legStretch_CN") #Create stretch attribute on ikfootctl ma.addAttr(footJntIKCtl, ln="stretch", min=0, max=1, dv=0, k=True) #Create stretchSwitchAttrMDV and stretchSwitchFKIK legStretchSwitchMult = ma.createNode("multiplyDivide", n=side + "_legStretchSwitch_MDV") legStretchSwitchFKIKMult = ma.createNode("multiplyDivide", n=side + "_legStretchSwitchFKIK_MDV") #Connect stretch attribute to legStretchSwitchMult input1X ma.connectAttr(footJntIKCtl + ".stretch", legStretchSwitchMult + ".input1X") #Connect FKIK attribute to legStretchSwitchFKIKMult input1X ma.connectAttr(fkIKCtl + ".FKIK", legStretchSwitchFKIKMult + ".input1X") #Connect legStretchDiv to legStretchSwitchMult.input2X ma.connectAttr(legStretchDiv + ".outputX", legStretchSwitchMult + ".input2X") #Connect legStretchSwitchMult to legStretchSwitchFKIKMult.input2X ma.connectAttr(legStretchSwitchMult + ".outputX", legStretchSwitchFKIKMult + ".input2X") #Connect legStretchSwitchFKIKMult to firstTerm ma.connectAttr(legStretchSwitchFKIKMult + ".outputX", legStretchCon + ".firstTerm") #Connect MDV to the colorIfTrue.colorIfTrueR ma.connectAttr(legStretchDiv + ".outputX", legStretchCon + ".colorIfTrue.colorIfTrueR") #set second term and operation of legStretchCon ma.setAttr(legStretchCon + ".secondTerm", 1) ma.setAttr(legStretchCon + ".operation", 2) #Connect condition nodes outColor.outColorR to scaleX on legStartJnt and legMidJnt ma.connectAttr(legStretchCon + ".outColor.outColorR", legStartJnt + ".scaleX") ma.connectAttr(legStretchCon + ".outColor.outColorR", legMidJnt + ".scaleX") #Create a group to hold the two locators legStretchGrp = ma.createNode("transform", n=side + "_legStretch_" + grpPrefix) ma.parent(legStretchStartLoc[0], legStretchGrp) ma.parent(legStretchEndLoc[0], legStretchGrp)
import maya.cmds as cmds
def parentManips(side): import maya.cmds as mc blendelbFrnt = "%s_elbowFrnt_twist_choice_bta" % side blendfrarm = "%s_forearm_twist_choice_bta" % side blendwrist = "%s_wrist_twist_choice_bta" % side attrControl = "%s_arm_SW_ctrl" % side rev = mc.createNode("reverse", n="%s_arm_02_no_twist_rev" % side) mc.connectAttr("%s.%s_nr" % (attrControl, side), "%s.ix" % rev) ntJnt1 = "%s_arm_02_no_twist_ctrl_01" % side ntJnt2 = "%s_arm_02_no_twist_ctrl_02" % side ntJnt3 = "%s_arm_02_no_twist_ctrl_03" % side ntJnt4 = "%s_arm_02_no_twist_ctrl_04" % side Jnt1 = "%s_arm_02_deform_ctrl_01" % side Jnt2 = "%s_arm_02_deform_ctrl_02" % side Jnt3 = "%s_arm_02_deform_ctrl_03" % side Jnt4 = "%s_arm_02_deform_ctrl_04" % side svl1 = "%s_sleeve_01_pivot_top_ctrl" % side svl2 = "%s_sleeve_02_pivot_top_ctrl" % side svl3 = "%s_sleeve_03_pivot_top_ctrl" % side svl4 = "%s_sleeve_04_pivot_top_ctrl" % side svl5 = "%s_sleeve_05_pivot_top_ctrl" % side elbow = mc.duplicate("%s_arm_02" % side, n="%s_arm_02_no_twist" % side, po=True) mc.parent(elbow[0], "%s_arm_02" % side) tempOriConst = mc.orientConstraint(ntJnt4, elbow[0]) mc.delete(tempOriConst) tempConst1 = mc.pointConstraint(ntJnt4, "%s_orig" % svl1, sk=("y", "z")) mc.delete(tempConst1) tempConst2 = mc.pointConstraint(ntJnt3, "%s_orig" % svl2, sk=("y", "z")) mc.delete(tempConst2) tempConst3 = mc.pointConstraint(ntJnt2, "%s_orig" % svl3, sk=("y", "z")) mc.delete(tempConst3) tempConst4 = mc.pointConstraint(ntJnt1, "%s_orig" % svl4, sk=("y", "z")) mc.delete(tempConst4) grp1 = mc.group(em=True, n="%s_transform" % svl1, p=ntJnt4) tempConst5 = mc.pointConstraint(ntJnt4, grp1) mc.delete(tempConst5) oriCnst1 = mc.orientConstraint(ntJnt4, elbow[0], grp1, mo=True) mc.connectAttr("%s.%s_nr" % (attrControl, side), "%s.w0" % oriCnst1[0]) mc.connectAttr("%s.ox" % rev, "%s.w1" % oriCnst1[0]) mc.parent("%s_orig" % svl1, grp1) grp5 = mc.group(em=True, n="%s_transform" % svl5, p=ntJnt4) tempConst6 = mc.pointConstraint(ntJnt4, grp5, sk="x") mc.delete(tempConst6) oriCnst2 = mc.orientConstraint(ntJnt4, elbow[0], grp5, mo=True) mc.connectAttr("%s.%s_nr" % (attrControl, side), "%s.w0" % oriCnst2[0]) mc.connectAttr("%s.ox" % rev, "%s.w1" % oriCnst2[0]) mc.parent("%s_orig" % svl5, grp5) grp2 = mc.group(em=True, n="%s_transform" % svl2, p=ntJnt3) tempConst7 = mc.pointConstraint(ntJnt3, grp2) mc.delete(tempConst7) oriCnst3 = mc.orientConstraint(ntJnt3, elbow[0], grp2, mo=True) mc.connectAttr("%s.%s_nr" % (attrControl, side), "%s.w0" % oriCnst3[0]) mc.connectAttr("%s.ox" % rev, "%s.w1" % oriCnst3[0]) mc.parent("%s_orig" % svl2, grp2) grp3 = mc.group(em=True, n="%s_transform" % svl3, p=ntJnt2) tempConst8 = mc.pointConstraint(ntJnt2, grp3) mc.delete(tempConst8) oriCnst4 = mc.orientConstraint(ntJnt2, elbow[0], grp3, mo=True) mc.connectAttr("%s.%s_nr" % (attrControl, side), "%s.w0" % oriCnst4[0]) mc.connectAttr("%s.ox" % rev, "%s.w1" % oriCnst4[0]) mc.parent("%s_orig" % svl3, grp3) grp4 = mc.group(em=True, n="%s_transform" % svl4, p=ntJnt1) tempConst9 = mc.pointConstraint(ntJnt1, grp4) mc.delete(tempConst9) oriCnst5 = mc.orientConstraint(ntJnt1, elbow[0], grp4, mo=True) mc.connectAttr("%s.%s_nr" % (attrControl, side), "%s.w0" % oriCnst5[0]) mc.connectAttr("%s.ox" % rev, "%s.w1" % oriCnst5[0]) mc.parent("%s_orig" % svl4, grp4)
def createCtrlSys(crv, rootCrv, surface, rootSurface, name, parameter=0.5, iteration=1): # Get surface shape crv_shape = cmds.listRelatives(crv[0], type="shape")[0] rootCrv_shape = cmds.listRelatives(rootCrv[0], type="shape")[0] surface_shape = cmds.listRelatives(surface[0], type="shape") rootSurface_shape = cmds.listRelatives(rootSurface[0], type="shape") # create wire, cluster wire = cmds.wire(surface, gw=False, en=1.0, ce=0.0, li=0.0, dds=(0, 1000), w=crv, n=name + "_wire")[0] newCluster = cmds.cluster(rootCrv[0] + '.cv[:]', n="{}_{}_FreeSys_Crv_Clst".format( name, iteration), envelope=1) # run dynamicClst script cmds.select(rootCrv[0], r=1) dynamicSys_data = tp_createDynamicClst() cmds.select(cl=1) # Get arc length rootCrv_arcLength = cmds.arclen(rootCrv) # Create control ctrl_data = bd_buildCtrl(ctrl_type="sphere", name="{}_{}".format(name, iteration), sufix="_FreeSys_Ctrl", offset=1) # Create follicle on surface follicle_data = createFollicle(inputSurface=rootSurface_shape, name=name + '_FreeSys_Ctrl_Flc', hide=0) # Point constraint ctrl grp cmds.pointConstraint(follicle_data[0], ctrl_data[1], offset=(0, 0, 0), weight=1) # Orient constroint ctrl cmds.orientConstraint(follicle_data[0], ctrl_data[0], mo=1, weight=1) # Create attributes on control - Division, Parameter, Twist, Interpotaion cmds.addAttr(ctrl_data[0], ln="customAttr", nn="________", at="enum", en="Custom:", keyable=True) cmds.setAttr(ctrl_data[0] + ".customAttr", lock=1) cmds.addAttr(ctrl_data[0], ln="parameter", nn="Parameter", at="double", min=0, max=rootCrv_arcLength, dv=(rootCrv_arcLength / 2), keyable=True) cmds.addAttr(ctrl_data[0], ln="twist", nn="Twist", at="double", min=-1000, max=1000, dv=0, keyable=True) cmds.addAttr(ctrl_data[0], ln="interpolation", nn="Interpolation", at="long", min=1, max=6, dv=4, keyable=True) cmds.connectAttr(ctrl_data[0] + ".interpolation", dynamicSys_data[0] + ".interpolation") # Create setRange for translate conversion 0 1 ctrl_setRange = cmds.shadingNode('setRange', au=1, n=name + '_ctrl_t_setRange') cmds.setAttr(ctrl_setRange + '.max.maxX', 1) cmds.setAttr(ctrl_setRange + '.oldMax.oldMaxX', rootCrv_arcLength) cmds.connectAttr(ctrl_data[0] + '.parameter', ctrl_setRange + '.value.valueX') # Connect ctrl translate x to follicle uVlue cmds.connectAttr(ctrl_setRange + '.outValue.outValueX', follicle_data[1] + '.parameterU') # Create set range for scale X, output max 0-1, control ramp falloff scale_setRange = cmds.shadingNode('setRange', au=1, n=name + '_ctrl_scaleToFalloff_setRange') cmds.setAttr(scale_setRange + '.oldMin.oldMinX', 0.2) cmds.setAttr(scale_setRange + '.oldMax.oldMaxX', 5) cmds.setAttr(scale_setRange + '.min.minX', 0.1) cmds.setAttr(scale_setRange + '.max.maxX', 1) cmds.connectAttr(ctrl_data[0] + '.scale.scaleX', scale_setRange + '.value.valueX') # Calcaulating start and end position colorStart_mpDiv = cmds.shadingNode('multiplyDivide', au=1, n=name + '_scaleInvert_mpDivide') colorStartEnd_plusMA = cmds.shadingNode('plusMinusAverage', au=1, n=name + '_falloffResult_plusMA') # Invert Scale newRange value cmds.setAttr(colorStart_mpDiv + '.input2.input2X', -1) cmds.connectAttr(scale_setRange + '.outValue.outValueX', colorStart_mpDiv + '.input1.input1X') # Connect to plusMinusAvarege node cmds.connectAttr(colorStart_mpDiv + '.output.outputX', colorStartEnd_plusMA + '.input2D[0].input2Dx') cmds.connectAttr(scale_setRange + '.outValue.outValueX', colorStartEnd_plusMA + '.input2D[0].input2Dy') cmds.connectAttr(ctrl_setRange + '.outValue.outValueX', colorStartEnd_plusMA + '.input2D[1].input2Dx') cmds.connectAttr(ctrl_setRange + '.outValue.outValueX', colorStartEnd_plusMA + '.input2D[1].input2Dy') # Create clamp setRange - Limiting calculation to 0 to 1 clamp_setRenge = cmds.shadingNode('setRange', au=1, n=name + '_resultClamp_setRange') cmds.setAttr(clamp_setRenge + '.oldMax.oldMaxX', 1) cmds.setAttr(clamp_setRenge + '.max.maxX', 1) cmds.setAttr(clamp_setRenge + '.oldMax.oldMaxY', 1) cmds.setAttr(clamp_setRenge + '.max.maxY', 1) cmds.connectAttr(colorStartEnd_plusMA + '.output2D.output2Dx', clamp_setRenge + '.value.valueX') cmds.connectAttr(colorStartEnd_plusMA + '.output2D.output2Dy', clamp_setRenge + '.value.valueY') # Connect to ramp colors # Connect and configure color 1 mid cmds.connectAttr(ctrl_setRange + '.outValue.outValueX', dynamicSys_data[0] + '.colorEntryList[0].position') cmds.setAttr(dynamicSys_data[0] + '.colorEntryList[0].color', 1, 1, 1, type="double3") # Connect and configure color 0 start cmds.connectAttr(clamp_setRenge + '.outValue.outValueX', dynamicSys_data[0] + '.colorEntryList[2].position') cmds.setAttr(dynamicSys_data[0] + '.colorEntryList[2].color', 0, 0, 0, type="double3") # Connect and configure color 2 end cmds.connectAttr(clamp_setRenge + '.outValue.outValueY', dynamicSys_data[0] + '.colorEntryList[1].position') cmds.setAttr(dynamicSys_data[0] + '.colorEntryList[1].color', 0, 0, 0, type="double3") # Connect ctrl to cluster cmds.connectAttr(ctrl_data[0] + '.translate', newCluster[1] + '.translate') # Create and connect dropoff locators cmds.select("{}.u[{}]".format(crv[0], 0), r=True) dropoffLoc1 = cmds.dropoffLocator(1.0, 1.0, wire)[0] cmds.select("{}.u[{}]".format(crv[0], 0.1), r=True) dropoffLoc2 = cmds.dropoffLocator(1.0, 1.0, wire)[0] cmds.select("{}.u[{}]".format(crv[0], 0.2), r=True) dropoffLoc3 = cmds.dropoffLocator(1.0, 1.0, wire)[0] cmds.select(cl=1) cmds.connectAttr(ctrl_data[0] + ".twist", "{}.wireLocatorTwist[{}]".format(wire, 1)) cmds.connectAttr(ctrl_setRange + '.outValue.outValueX', dropoffLoc2 + '.param') cmds.connectAttr(clamp_setRenge + '.outValue.outValueX', dropoffLoc1 + '.param') cmds.connectAttr(clamp_setRenge + '.outValue.outValueY', dropoffLoc3 + '.param') lock_hide([ctrl_data[0]], [".rx", ".ry", ".rz"]) # Set control parameter of choice ctrl_tergetPosition = rootCrv_arcLength * parameter cmds.setAttr(ctrl_data[0] + '.parameter', ctrl_tergetPosition) # Group everything or pass creations to master grouper return newCluster[1], ctrl_data[1], follicle_data[0], ctrl_data[0]
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 build(self): ''' ''' super(Spine, self).build() # store the joint list jointList = eval(self.jointList) # initialize the spline class scaleFactor = self.getAttributeByName('scaleFactor').getValue() self.spline = spline.SplineBase(jointList=jointList + [self._chestBind], splineName=self._splineName, scaleFactor=scaleFactor) # create the spline self.spline.create() # get the name of the curveInfo node. This is hard coded to be this way in the # spline code. If that changes, this will not work. We can change the code below # to use the API to get the length of the curve instead of this node, but for now, this # is quicker because it's available already. spineCurveInfo = self._splineName + "_curveInfo" # get the attributes from the user geometry = self.getAttributeByName("geometry").getValue() bendyCurve = self.getAttributeByName("bendyCurve").getValue() createBendySpline = self.getAttributeByName( "createBendySpline").getValue() hipSwivelPivotValue = self.getAttributeByName( "hipSwivelPivot").getValue() chestPivotValue = self.getAttributeByName("chestPivot").getValue() # Hips hipMatrix = mc.xform(self._hipsBind, q=True, ws=True, matrix=True) hipsPivotNul, hipsPivotCtrl = control.create( name="hipsPivot", controlType="cube", hideAttrs=["sx", "sy", "sz", "v"], hierarchy=['nul'], color=rigrepo.libs.common.RED) # create the grp that we will use to move the pivot of the hips movablePivotGrp = mc.createNode("transform", name="{}_grp".format(hipsPivotCtrl)) mc.xform(hipsPivotNul, ws=True, matrix=hipMatrix) mc.xform(movablePivotGrp, ws=True, matrix=hipMatrix) mc.parent(movablePivotGrp, hipsPivotNul) # connect the movable pivot control to the grp mc.connectAttr("{}.t".format(hipsPivotCtrl), "{}.rotatePivot".format(movablePivotGrp), f=True) mc.connectAttr("{}.r".format(hipsPivotCtrl), "{}.r".format(movablePivotGrp), f=True) hipsCtrlHierarchy = control.create(name="hips", controlType="cube", hideAttrs=["sx", "sy", "sz", "v"], hierarchy=['nul']) hipsCtrl = hipsCtrlHierarchy[-1] hipsNul = hipsCtrlHierarchy[0] rigrepo.libs.attribute.lockAndHide(hipsCtrl, ["sx", "sy", "sz", "v"]) mc.xform(hipsNul, ws=True, matrix=hipMatrix) hipsGimbalCtrlHierarchy = control.create( name="hips_gimbal", controlType="cube", hierarchy=['nul'], hideAttrs=["sx", "sy", "sz", "v"], parent=hipsCtrl) hipsGimbalCtrl = hipsGimbalCtrlHierarchy[-1] hipsGimbalNul = hipsGimbalCtrlHierarchy[0] rigrepo.libs.attribute.lockAndHide(hipsGimbalCtrl, ["sx", "sy", "sz", "v"]) mc.xform(hipsGimbalNul, ws=True, matrix=hipMatrix) # hip swivel ctrlHierarchy = control.create(name="hip_swivel", controlType="cube", color=common.GREEN, hideAttrs=["sx", "sy", "sz", "v"], hierarchy=['nul']) hipSwivelCtrl = ctrlHierarchy[-1] hipSwivelNul = ctrlHierarchy[0] rigrepo.libs.attribute.lockAndHide(hipSwivelCtrl, ["sx", "sy", "sz", "v"]) mc.xform(hipSwivelNul, ws=True, matrix=hipMatrix) averagePos = rigrepo.libs.transform.getAveragePosition([jointList[0]]) mc.xform(hipSwivelNul, ws=True, t=mc.xform(jointList[0], q=True, ws=True, t=True)) mc.parent(hipSwivelNul, hipsGimbalCtrl) clusters = self.spline._clusters # create a group that is driven by the ctrl hipSwivelGrp = mc.createNode("transform", n="hips_swivel_grp") # move the group into the same matrix as the control mc.xform(hipSwivelGrp, ws=True, matrix=mc.xform(hipSwivelCtrl, q=True, ws=True, matrix=True)) # parent the group into the same space as the control mc.parent(hipSwivelGrp, hipSwivelCtrl) mc.parent(clusters[0:2], hipSwivelGrp) mc.orientConstraint(hipSwivelGrp, self.spline._startTwistNul, mo=1) # Parent the entire ik group to the hips mc.parent(self.spline.getGroup(), hipsGimbalCtrl) # torso ctrlHierarchy = control.create(name="torso", controlType="cube", hideAttrs=["sx", "sy", "sz", "v"], hierarchy=['nul']) torsoCtrl = ctrlHierarchy[-1] torsoNul = ctrlHierarchy[0] rigrepo.libs.attribute.lockAndHide(torsoCtrl, ["sx", "sy", "sz", "v"]) rotation = mc.xform(hipsCtrl, q=True, ws=True, rotation=True) averagePos = rigrepo.libs.transform.getAveragePosition(jointList[:2]) mc.xform(torsoNul, ws=True, rotation=rotation) mc.xform(torsoNul, ws=True, t=averagePos) mc.parent(torsoNul, hipsGimbalCtrl) # chest ctrlHierarchy = control.create(name="chest", controlType="cube", color=common.GREEN, hideAttrs=["sx", "sy", "sz", "v"], hierarchy=['nul']) chestCtrl = ctrlHierarchy[-1] chestNul = ctrlHierarchy[0] rigrepo.libs.attribute.lockAndHide(chestCtrl, ["sx", "sy", "sz", "v"]) matrix = mc.xform(self._chestBind, q=True, ws=True, matrix=True) mc.xform(chestNul, ws=True, matrix=matrix) mc.parent(chestNul, torsoCtrl) # chest IK ctrlHierarchy = control.create(name="chest_ik", controlType="cube", color=common.GREEN, hideAttrs=["sx", "sy", "sz", "v"], hierarchy=['nul']) chestIkCtrl = ctrlHierarchy[-1] chestIkNul = ctrlHierarchy[0] rigrepo.libs.attribute.lockAndHide(chestIkCtrl, ["sx", "sy", "sz", "v"]) mc.xform(chestIkNul, ws=True, matrix=matrix) mc.parent(chestIkNul, chestCtrl) # connect the rotate pivots so the pivots for these two controls are in the same location. mc.connectAttr("{}.rp".format(chestCtrl), "{}.rp".format(chestIkCtrl), f=True) # chest top ctrlHierarchy = control.create(name="chest_top", controlType="cube", hideAttrs=["sx", "sy", "sz", "v"], hierarchy=['nul']) chestTopCtrl = ctrlHierarchy[-1] chestTopNul = ctrlHierarchy[0] rigrepo.libs.attribute.lockAndHide(chestTopCtrl, ["sx", "sy", "sz", "v"]) mc.xform(chestTopNul, ws=True, matrix=matrix) mc.parent(chestTopNul, chestIkCtrl) mc.parent(clusters[2:], chestIkCtrl) chestTopGrp = mc.createNode("transform", name="chest_top_grp") mc.xform(chestTopGrp, ws=True, matrix=matrix) mc.parent(chestTopGrp, chestTopCtrl) mc.orientConstraint(chestTopGrp, self.spline._endTwistNul, mo=1) # ========================================================================================== # chest pivot # create pivot attributes to use for moving the pivot and tangent heights. mc.addAttr(chestCtrl, ln="pivotHeight", at="double", dv=0, min=0, max=10, keyable=True) mc.setAttr("{}.pivotHeight".format(chestCtrl), chestPivotValue) # create the remap node to use to remap the pivot height to the lenght of the curve chestRemapNode = mc.createNode("remapValue", n="chest_pivot_remap") # map the 0-10 to the length of the curve on the spine curveLength = mc.getAttr("{}.arcLength".format(spineCurveInfo)) # set the max output value for the remap to be the length of the curve mc.setAttr("{}.outputMax".format(chestRemapNode), curveLength) # set the input max mc.setAttr("{}.inputMax".format(chestRemapNode), 10) # connect the slider for pivot to the input max mc.connectAttr("{}.pivotHeight".format(chestCtrl), "{}.inputValue".format(chestRemapNode), f=True) # get the aim axis chestPivotNulGrp = mc.createNode("transform", name="chestPivot_aim_nul") chestPivotAimGrp = mc.createNode("transform", name="chestPivot_aim_grp") chestPivotDriver = mc.createNode("transform", name="chestPivot_aim_drv") mc.parent(chestPivotAimGrp, chestPivotNulGrp) mc.parent(chestPivotNulGrp, chestCtrl) mc.parent(chestPivotDriver, chestPivotAimGrp) mc.xform(chestPivotNulGrp, ws=True, matrix=matrix) mc.xform(chestPivotDriver, ws=True, matrix=hipMatrix) aimAxis, aimVector = self._getDistanceVector( mc.getAttr('{}.t'.format(chestPivotDriver))[0]) mc.parent(chestPivotNulGrp, chestNul) # move the transform back to the skull mc.xform(chestPivotDriver, ws=True, matrix=matrix) mc.xform(chestPivotNulGrp, ws=True, t=mc.xform(chestNul, q=True, ws=True, t=True)) mc.orientConstraint(chestNul, chestPivotNulGrp) mc.parent(chestPivotDriver, chestNul) mc.pointConstraint(chestPivotAimGrp, chestPivotDriver) mc.orientConstraint(chestPivotAimGrp, chestPivotDriver) if '-' in aimAxis: chestCtrlPivotMdl = mc.createNode('multDoubleLinear', n='chest_pivot_mdl') mc.connectAttr('{}.outValue'.format(chestRemapNode), '{}.input1'.format(chestCtrlPivotMdl), f=True) mc.setAttr('{}.input2'.format(chestCtrlPivotMdl), -1) mc.connectAttr('{}.output'.format(chestCtrlPivotMdl), '{}.t{}'.format(chestPivotAimGrp, aimAxis.strip('-')), f=True) mc.connectAttr('{}.t'.format(chestPivotDriver), '{}.rotatePivot'.format(chestCtrl), f=True) else: mc.connectAttr('{}.outValue'.format(chestRemapNode), '{}.t{}'.format(chestPivotAimGrp, aimAxis), f=True) mc.connectAttr('{}.t'.format(chestPivotDriver), '{}.rotatePivot'.format(chestCtrl), f=True) # ========================================================================================== # hip swivel pivot # create pivot attributes to use for moving the pivot and tangent heights. mc.addAttr(hipSwivelCtrl, ln="pivotHeight", at="double", dv=0, min=0, max=10, keyable=False) mc.setAttr("{}.pivotHeight".format(hipSwivelCtrl), hipSwivelPivotValue) # create the remap node to use to remap the pivot height to the lenght of the curve hipSwivelRemapNode = mc.createNode("remapValue", n="hipSwivel_pivot_remap") # set the max output value for the remap to be the length of the curve mc.setAttr("{}.outputMax".format(hipSwivelRemapNode), curveLength) # set the input max mc.setAttr("{}.inputMax".format(hipSwivelRemapNode), 10) # connect the slider for pivot to the input max mc.connectAttr("{}.pivotHeight".format(hipSwivelCtrl), "{}.inputValue".format(hipSwivelRemapNode), f=True) # get the aim axis tempNode = mc.createNode("transform", name="temp") mc.parent(tempNode, hipSwivelGrp) mc.xform(tempNode, ws=True, matrix=matrix) aimAxis, aimVector = self._getDistanceVector( mc.getAttr('{}.t'.format(tempNode))[0]) mc.delete(tempNode) if '-' in aimAxis: hipSwivelPivotMdl = mc.createNode('multDoubleLinear', n='hipSwivel_pivot_pma') mc.connectAttr("{}.outValue".format(hipSwivelRemapNode), '{}.input1'.format(hipSwivelPivotMdl), f=True) mc.setAttr('{}.input2'.format(hipSwivelPivotMdl), -1) mc.connectAttr('{}.output'.format(hipSwivelPivotMdl), '{}.rotatePivot{}'.format( hipSwivelCtrl, aimAxis.strip('-').capitalize()), f=True) else: mc.connectAttr("{}.outValue".format(hipSwivelRemapNode), '{}.rotatePivot{}'.format(hipSwivelCtrl, aimAxis.capitalize()), f=True) self._hipsCtrl = hipsCtrl self._hipSwivelCtrl = hipSwivelCtrl self._torsoCtrl = torsoCtrl self._chestCtrl = chestCtrl self._chestTopCtrl = chestTopCtrl self._chestIkCtrl = chestIkCtrl # Remove existing constraint on chestBind orientConstraint = mc.orientConstraint(self._chestBind, q=1) pointConstraint = mc.pointConstraint(self._chestBind, q=1) if orientConstraint: mc.delete(orientConstraint) if pointConstraint: mc.delete(pointConstraint) mc.pointConstraint(chestTopGrp, self._chestBind, mo=1) mc.orientConstraint(chestTopGrp, self._chestBind, mo=1) #mc.connectAttr(chestTopCtrl+'.s', self._chestBind+'.s') mc.parentConstraint(hipSwivelGrp, self._hipsBind, mo=1) mc.connectAttr(hipSwivelGrp + '.s', self._hipsBind + '.s') mc.parent(hipsPivotNul, self.name) mc.parent(hipsNul, movablePivotGrp) mc.hide(self.spline._group, clusters) if createBendySpline and mc.objExists(bendyCurve): bindmeshGeometry, follicleList, controlHieracrchyList, bendJointList = self.__buildCurveRig( bendyCurve, name='{}_bend'.format(self.getName()), parent=self.name) if mc.objExists(geometry): #deform the lid bindmesh with the lid curve using a wire deformer. wireDeformer = mc.wire(geometry, gw=False, en=1.00, ce=0.00, li=0.00, w=bendyCurve, name="{}_wire".format(bendyCurve))[0] baseCurveJointList = list() i = 0 for jnt, controlList in zip(bendJointList, controlHieracrchyList): # create the joint that we will use later to deform the base wire. baseCurveJoint = mc.joint( name=jnt.replace("_jnt", "_baseCurve_jnt")) baseCurveJointList.append(baseCurveJoint) # hide the base curve joint. Then parent it under the null node mc.setAttr("{}.v".format(baseCurveJoint), 0) mc.parent(baseCurveJoint, controlList[1]) mc.setAttr("{}.t".format(baseCurveJoint), 0, 0, 0) baseCurve = "{}BaseWire".format(bendyCurve) mc.parent([bendyCurve, baseCurve], self.name) baseCurveSkin = mc.skinCluster( *[baseCurveJointList] + mc.ls(baseCurve), n="{}_skinCluster".format(baseCurve), tsb=True)[0] # set the default values for the wire deformer mc.setAttr("{}.rotation".format(wireDeformer), 0) mc.setAttr("{}.dropoffDistance[0]".format(wireDeformer), 100) bindMeshSkin = mc.skinCluster( *jointList + [self._hipsBind, self._chestBind] + mc.ls(bindmeshGeometry), n="{}_skinCluster".format(bindmeshGeometry), tsb=True)[0] mc.skinPercent(bindMeshSkin, '{}.vtx[0:3]'.format(bindmeshGeometry), transformValue=[(self._hipsBind, 1.0), (jointList[0], 0.0)]) mc.skinPercent(bindMeshSkin, '{}.vtx[4:7]'.format(bindmeshGeometry), transformValue=[(jointList[0], 0.0), (jointList[1], 1.0), (jointList[2], 0.0)]) mc.skinPercent(bindMeshSkin, '{}.vtx[8:11]'.format(bindmeshGeometry), transformValue=[(jointList[3], 1.0), (jointList[1], 0.0)]) mc.skinPercent(bindMeshSkin, '{}.vtx[12:15]'.format(bindmeshGeometry), transformValue=[(jointList[2], 0.0), (jointList[4], 0.0), (self._chestBind, 1.0)]) mc.skinPercent(bindMeshSkin, '{}.vtx[16:19]'.format(bindmeshGeometry), transformValue=[(self._chestBind, 1.0), (jointList[1], 0.0), (jointList[2], 0.0)]) # ------------------------------------------------------------------------------------ # Length Preservation # ------------------------------------------------------------------------------------ spline.preserveLength(name='spineIk_length', curve='spineIk_curve', primary_control='chest', rotate_controls=['torso', 'chest', 'chest_ik'], no_rotate_cvs=[2, 3], parent='spine', position_output_child='chest_top_nul')
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 install(self): # Create a master group self.rig_info['mastergrp'] = cmds.group(n=self.module_info['rootname'][0].replace('s_', self.instance)+'_M_GRP', em=True) cmds.xform(self.rig_info['mastergrp'], ws=True, t=self.rig_info['positions'][0]) # Create a world group self.rig_info['worldgrp'] = cmds.group(n=self.module_info['rootname'][0].replace('s_', self.instance)+'_W_GRP', em=True) cmds.xform(self.rig_info['worldgrp'], ws=True, t=self.rig_info['positions'][0]) # Create a local group self.rig_info['localgrp'] = cmds.group(n=self.module_info['rootname'][0].replace('s_', self.instance)+'_L_GRP', em=True) cmds.xform(self.rig_info['localgrp'], ws=True, t=self.rig_info['positions'][0]) cmds.parent(self.rig_info['worldgrp'], self.rig_info['mastergrp']) cmds.parent(self.rig_info['localgrp'], self.rig_info['mastergrp']) cmds.select(d=True) #Try duplicate joint method self.rig_info['ikjnts']=utils.duplicateJoints(self.rig_info['seljnts'], self.module_info['ikjnts'], self.instance) cmds.parent(self.rig_info['ikjnts'][0], self.rig_info['localgrp']) self.rig_info['fkjnts']=utils.duplicateJoints(self.rig_info['seljnts'], self.module_info['fkjnts'], self.instance) cmds.parent(self.rig_info['fkjnts'][0], self.rig_info['localgrp']) self.rig_info['rigjnts']=utils.duplicateJoints(self.rig_info['seljnts'], self.module_info['rigjnts'], self.instance) cmds.parent(self.rig_info['rigjnts'][0], self.rig_info['localgrp']) # Make a control for arm settings lockattrs = (['.tx', '.ty', '.tz', '.rx', '.ry', '.rz', '.sx', '.sy', '.sz']) setctrlname = self.module_info["settingscontrol"][0].replace('s_', self.instance) self.rig_info['setcontrol']=utils.createControl([[self.rig_info['positions'][2], setctrlname, 'SettingsControl.ma', lockattrs]])[0] cmds.addAttr(self.rig_info['setcontrol'][1], shortName='IK_FK', longName='Ik_Fk', defaultValue=1, min=0, max=1, k=True) cmds.addAttr(self.rig_info['setcontrol'][1], shortName='stretch', longName='Stretchy', defaultValue=0, min=0, max=1, k=True) cmds.addAttr(self.rig_info['setcontrol'][1], shortName='Root_Length', longName='Root_Length', defaultValue=0, min=-5, max=5, k=True) cmds.addAttr(self.rig_info['setcontrol'][1], shortName='End_Length', longName='End_Length', defaultValue=0, min=-5, max=5, k=True) cmds.parent(self.rig_info['setcontrol'][2], self.rig_info['localgrp']) # Connect Ik and Fk to Rig joints switchattr = self.rig_info['setcontrol'][1] + '.IK_FK' self.rig_info['bcnodes'] = utils.connectThroughBC(self.rig_info['ikjnts'], self.rig_info['fkjnts'], self.rig_info['rigjnts'], self.instance, switchattr ) # Create Ik Rig lockattrs = (['.sx', '.sy', '.sz']) ikctrlname = self.module_info["ikcontrols"][0].replace('s_', self.instance) self.rig_info['ikcontrol']=utils.createControl([[self.rig_info['positions'][2], ikctrlname, 'FootControl.ma', lockattrs]])[0] cmds.parent(self.rig_info['ikcontrol'][0], self.rig_info['localgrp']) lockattrs = (['.rx', '.ry', '.rz', '.sx', '.sy', '.sz']) pvpos = utils.calculatePVPosition([self.rig_info['ikjnts'][0], self.rig_info['ikjnts'][1], self.rig_info['ikjnts'][2]]) pvctrlname = self.module_info["ikcontrols"][2].replace('s_', self.instance) self.rig_info['pvcontrol']=utils.createControl([[[pvpos[0], pvpos[1], pvpos[2]], pvctrlname, 'PVControl.ma', lockattrs]])[0] tmpcon = cmds.orientConstraint(self.rig_info['ikjnts'][1], self.rig_info['pvcontrol'][0], mo=False) cmds.delete(tmpcon) cmds.select(self.rig_info['pvcontrol'][0]) #cmds.move(-5, z=True, r=True) cmds.parent(self.rig_info['pvcontrol'][2], self.rig_info['localgrp']) # Generate a name for the ik handle using self.instance ikhname = self.module_info["ikcontrols"][1].replace('s_', self.instance) # Create Stretchy IK pmas = 1 pvMA = self.instance + "PV" self.rig_info['ikinfo']=utils.createStretchyIk(self.rig_info['ikjnts'], self.rig_info['rigjnts'], self.rig_info['ikcontrol'], ikhname, pvctrlname, self.instance, False, pmas, pvMA, '.tx', self.rig_info['setcontrol']) # Parent ikh to ctrl cmds.parent(self.rig_info['ikinfo'][0], self.rig_info['ikcontrol'][1]) cmds.parent(self.rig_info['ikinfo'][1], self.rig_info['localgrp']) for each in self.rig_info['ikinfo'][2]: try: cmds.parent(each, self.rig_info['worldgrp']) except: pass # orient constrain ik_wrist to ctrl cmds.orientConstraint(self.rig_info['ikcontrol'][1], self.rig_info['ikjnts'][2], mo=True) # Create FK rig lockattrs = (['.sx', '.sy', '.sz']) self.rig_info['fkcontrols'] = utils.createControl([ [self.rig_info['positions'][0], self.module_info["fkcontrols"][0].replace('s_', self.instance), 'RectangleControl.ma', lockattrs], [self.rig_info['positions'][1], self.module_info["fkcontrols"][1].replace('s_', self.instance), 'RectangleControl.ma', lockattrs], [self.rig_info['positions'][2], self.module_info["fkcontrols"][2].replace('s_', self.instance), 'RectangleControl.ma', lockattrs]]) # Orient the fk controls to the fk joints for i in range(len(self.rig_info['fkcontrols'])): tc = cmds.parentConstraint(self.rig_info['fkjnts'][i], self.rig_info['fkcontrols'][i][0], mo=False) cmds.delete(tc) # Parent fk controls cmds.parent(self.rig_info['fkcontrols'][2][2], self.rig_info['fkcontrols'][1][1]) cmds.parent(self.rig_info['fkcontrols'][1][2], self.rig_info['fkcontrols'][0][1]) cmds.parent(self.rig_info['fkcontrols'][0][2], self.rig_info['localgrp']) # Constrain fk joints to controls. [cmds.parentConstraint(self.rig_info['fkcontrols'][i][1], self.rig_info['fkjnts'][i], mo=True) for i in range(len(self.rig_info['fkcontrols']))]
def build(bnd_jnts, side='l', prefix='leg', rig_scale=1.0, base_rig=None, hip_ctrl=None): """ @param spine_jnts: list(str), list of 6 spine jnts @param root_jnt: str, root_jnt @param prefix: str, prefix to name new object @param rig_scale: float, scale factor for size of controls @param base_rig: instance of base.module.Base class @return: dictionary with rig module objects """ #make rig module rig_module = module.Module(prefix=side + '_' + prefix, base_obj=base_rig, create_dnt_grp=True, drv_pos_obj='pelvis') #create drv skels ik_leg_jnts = joint.duplicate(bnd_jnts, prefix='ik', maintain_hierarchy=True) fk_leg_jnts = joint.duplicate(bnd_jnts, prefix='fk', maintain_hierarchy=True) cmds.parent(ik_leg_jnts[0], fk_leg_jnts[0], rig_module.drv_grp) cmds.parentConstraint(hip_ctrl.ctrl, rig_module.drv_grp, mo=True) #create IK controls ik_anim_grp = side + '_' + prefix + '_ik_anim_grp' cmds.group(n=ik_anim_grp, em=True, p=rig_module.ctrl_grp) temp_pole_loc = limbs.create_pole_vector_locator(side + '_' + prefix, bnd_jnts[1], [0, -30, 0]) ik_foot_ctrl = control.Control(shape=side + '_foot_ctrl_template', prefix=side + '_foot_IK', translate_to=bnd_jnts[2], scale=rig_scale, parent=ik_anim_grp, lock_channels=['s', 'v']) ik_knee_ctrl = control.Control(shape='sphere_ctrl_template', prefix=side + '_knee_IK', translate_to=temp_pole_loc, scale=rig_scale, parent=ik_anim_grp, lock_channels=['v']) cmds.delete(temp_pole_loc) ik_ctrl_list = [ik_foot_ctrl, ik_knee_ctrl] #create FK controls fk_anim_grp = side + '_' + prefix + '_fk_anim_grp' cmds.group(n=fk_anim_grp, em=True, p=rig_module.ctrl_grp) # transform.snap('pelvis', fk_anim_grp) transform.snap(hip_ctrl.ctrl, fk_anim_grp) fk_thigh_ctrl = control.Control(shape='cube_ctrl_template', prefix=side + '_thigh_FK', translate_to=[bnd_jnts[0], bnd_jnts[1]], rotate_to=bnd_jnts[0], scale=rig_scale, parent=fk_anim_grp, lock_channels=['s', 'v']) transform.snap_pivot(bnd_jnts[0], fk_thigh_ctrl.ctrl) transform.snap_pivot(bnd_jnts[0], fk_thigh_ctrl.ofst) fk_calf_ctrl = control.Control(shape='cube_ctrl_template', prefix=side + '_calf_FK', translate_to=[bnd_jnts[1], bnd_jnts[2]], rotate_to=bnd_jnts[1], scale=rig_scale * 0.7, parent=fk_thigh_ctrl.ctrl, lock_channels=['s', 'v']) transform.snap_pivot(bnd_jnts[1], fk_calf_ctrl.ctrl) transform.snap_pivot(bnd_jnts[1], fk_calf_ctrl.ofst) fk_foot_ctrl = control.Control(shape='cube_ctrl_template', prefix=side + '_foot_FK', translate_to=[bnd_jnts[2], bnd_jnts[3]], rotate_to=bnd_jnts[3], scale=rig_scale * 0.6, parent=fk_calf_ctrl.ctrl, lock_channels=['s', 'v']) transform.snap_pivot(bnd_jnts[2], fk_foot_ctrl.ctrl) transform.snap_pivot(bnd_jnts[2], fk_foot_ctrl.ofst) #hook up FK ctrls fk_ctrl_list = [fk_thigh_ctrl, fk_calf_ctrl, fk_foot_ctrl] for i in range(len(fk_ctrl_list)): cmds.orientConstraint(fk_ctrl_list[i].ctrl, fk_leg_jnts[i], mo=False) #set up ik leg_ik_handle = cmds.ikHandle(n=side + '_leg_ikHandle', sj=ik_leg_jnts[0], ee=ik_leg_jnts[2], sol='ikRPsolver')[0] ball_ik_handle = cmds.ikHandle(n=side + 'ball_ikHandle', sj=ik_leg_jnts[2], ee=ik_leg_jnts[3], sol='ikSCsolver')[0] toe_ik_handle = cmds.ikHandle(n=side + 'toe_ikHandle_', sj=ik_leg_jnts[3], ee=ik_leg_jnts[4], sol='ikSCsolver')[0] ik_list = [leg_ik_handle, ball_ik_handle, toe_ik_handle] cmds.hide(ik_list) cmds.parent(ik_list, ik_foot_ctrl.ctrl) cmds.poleVectorConstraint(ik_knee_ctrl.ctrl, leg_ik_handle) #set up ik/fk switch limbs.setup_ikfk_switch(base_rig.ikfk_ctrl, side, prefix, ik_leg_jnts[0:3], fk_leg_jnts[0:3], bnd_jnts[0:3], ik_anim_grp, fk_anim_grp) #set up twist joints limbs.create_twist_jnts(side + '_' + prefix, bnd_jnts) #set up fk space switching limbs.setup_fk_space_switching(side + '_' + prefix, fk_anim_grp, fk_leg_jnts, base_rig.master_ctrl.ctrl, fk_thigh_ctrl.ofst) cmds.parentConstraint(hip_ctrl.ctrl, fk_anim_grp, mo=True) #set up limb stretching # limbs.setup_limb_stretch(prefix, rig_module, ik_leg_jnts, ik_ctrl_list) limbs.add_ikpop_counter(side + '_' + prefix, ik_leg_jnts, bnd_jnts, ik_foot_ctrl.ctrl) #set up ribbon ribbon.create_ep_curve('temp_' + prefix + '_ribbon_crv_01', [bnd_jnts[0], bnd_jnts[1], bnd_jnts[2]], degree=1) ribbon_sfc = ribbon.loft_using_curve('temp_' + prefix + '_ribbon_crv_01', 10, 'z', side + '_' + prefix) cmds.rebuildSurface(ribbon_sfc, su=0, sv=11, du=1, dv=3, ch=True) limb_foll_list = ribbon.add_follicles(ribbon_sfc, 11, on_edges=False, create_joints=True) limb_foll_jnts_list = limb_foll_list[1] limb_foll_list = limb_foll_list[0] for jnt in limb_foll_jnts_list: cmds.xform(jnt, os=True, ro=[-90, 0, 90]) cmds.makeIdentity(jnt, t=0, r=1, s=0, apply=True) limb_follicles_grp = '_'.join([side, prefix, 'follicles', 'grp']) cmds.group(limb_foll_list, n=limb_follicles_grp) #set up blendshapes leg_drv_jnts = [ u'thigh_l', u'calf_l', u'ankle_l', u'calf_l_twist', u'thigh_l_twist' ] cmds.select(leg_drv_jnts, ribbon_sfc) limb_ribbon_clstr = cmds.skinCluster(tsb=True, dr=4.5) shape = cmds.listRelatives(ribbon_sfc, shapes=True)[0] #'body_geo' must have a skinCluster associated with it. geo_skin_clstr = cmds.listConnections(shape, type='skinCluster')[0] limbs.create_deformer_blend(side + '_' + prefix, ribbon_sfc, geo_skin_clstr, ik_foot_ctrl.ctrl, limb_foll_jnts_list, num_jnts=3)
def build(spineJoints, rootJnt, spineCurve, bodyLocator, chestLocator, pelvisLocator, prefix='spine', rigScale=1.0, baseRig=None): """ @param spineJoints: list( str ), list of spine joints @param rootJnt: str, root joint @param spineCurve: str, name of spine cubic curve with CVs matching first 5 spine joints @param bodyLocator: str, reference transform for position of body control @param chestLocator: str, reference transform for position of chest control @param pelvisLocator: str, reference transform for position of pelvis control @param prefix: str, prefix to name new objects @param rigScale: float, scale factor for size of controls @param baseRig: instance of base.module.Base class @return: dictionary with rig module objects """ # make rig module rigmodule = module.Module(prefix=prefix, baseObj=baseRig) # make spine curve clusters spineCurveCVs = mc.ls(spineCurve + '.cv[*]', fl=1) numSpineCVs = len(spineCurveCVs) spineCurveClusters = [] for i in range(numSpineCVs): cls = mc.cluster(spineCurveCVs[i], n=prefix + 'Cluster%d' % (i + 1))[1] spineCurveClusters.append(cls) mc.hide(spineCurveClusters) # parent spine curve mc.parent(spineCurve, rigmodule.partsNoTransGrp) # make controls bodyCtrl = control.Control(prefix=prefix + 'Body', translateTo=bodyLocator, scale=rigScale * 7, parent=rigmodule.controlsGrp) chestCtrl = control.Control(prefix=prefix + 'Chest', translateTo=chestLocator, scale=rigScale * 50, parent=bodyCtrl.C, shape='circleZ') pelvisCtrl = control.Control(prefix=prefix + 'Pelvis', translateTo=pelvisLocator, scale=rigScale * 40, parent=bodyCtrl.C, shape='circleZ') middleCtrl = control.Control(prefix=prefix + 'Middle', translateTo=spineCurveClusters[-3], scale=rigScale * 50, parent=bodyCtrl.C, shape='circleZ') # attach controls mc.parentConstraint(chestCtrl.C, pelvisCtrl.C, middleCtrl.Off, sr=['x', 'y', 'z'], mo=1) # attach clusters mc.parent(spineCurveClusters[3:], chestCtrl.C) mc.parent(spineCurveClusters[2], middleCtrl.C) mc.parent(spineCurveClusters[:2], pelvisCtrl.C) # attach chest joint mc.orientConstraint(chestCtrl.C, spineJoints[-1], mo=1) # make IK handle spineIk = mc.ikHandle(n=prefix + '_ikh', sol='ikSplineSolver', sj=spineJoints[0], ee=spineJoints[-2], c=spineCurve, ccv=0, parentCurve=0)[0] mc.hide(spineIk) mc.parent(spineIk, rigmodule.partsNoTransGrp) # setup IK twist mc.setAttr(spineIk + '.dTwistControlEnable', 1) mc.setAttr(spineIk + '.dWorldUpType', 4) mc.connectAttr(chestCtrl.C + '.worldMatrix[0]', spineIk + '.dWorldUpMatrixEnd') mc.connectAttr(pelvisCtrl.C + '.worldMatrix[0]', spineIk + '.dWorldUpMatrix') # attach root joint mc.parentConstraint(pelvisCtrl.C, rootJnt, mo=1) return {'module': rigmodule, 'bodyCtrl': bodyCtrl}
def Constraints(self, *args): # creat a loc # creat constrain from rootM to loc, all axes # bake anim for loc # rootm --> parent -w # rootm delete keyfarme # creat constrain from loc to root ,tx,tz, rz # parent(rootm, root) # creat constrain from loc to root ,all axes # startNum = cmds.playbackOptions(q = True , ast = True) # endNum = cmds.playbackOptions(q = True , aet = True) # returnMess = cmds.confirmDialog( title='Confirm', message='烘焙时间轴为' + str(startNum) + '-' + str(endNum), button=['Yes','No'], defaultButton='Yes', cancelButton='No', dismissString='No' ) # if returnMess == "No": # return startNum = cmds.intFieldGrp("StartFrame", q = True, value1 = True) endNum = cmds.intFieldGrp("EndFrame", q = True, value1 = True) cmds.currentUnit( time='ntsc', linear='centimeter') cmds.currentTime( startNum ) locPos = cmds.spaceLocator() cmds.parentConstraint( 'Root_M', locPos, mo = True) cmds.bakeResults( locPos, simulation=True, t = (startNum, endNum), hierarchy= "below", sb = 1, dic = True, pok = True, ral = False, rwl = False, cp = True) cmds.parent( 'Root_M', world=True ) keyframelist = cmds.ls(type='animCurveTL')+cmds.ls(type='animCurveTA')+cmds.ls(type='animCurveTU') for i in keyframelist: if not ('Root_M' not in i): cmds.delete(i) ty = cmds.checkBoxGrp("translateAxes", q = True, value2 = True) tx = cmds.checkBoxGrp("translateAxes", q = True, value1 = True) trans = [] if not ty: trans += "y" if not tx: trans += "x" orientConA = None ry = cmds.checkBoxGrp("rotateAxes", q = True, value2 = True) rot = ["x","z"] if ry: orientConA = cmds.orientConstraint(locPos, 'Root', mo = True, skip=rot) # parentConA = cmds.parentConstraint( locPos, 'Root', st=trans, sr=rot, mo = True) pointConA = cmds.pointConstraint(locPos, 'Root', mo = True, skip=trans) cmds.bakeResults( 'Root', simulation=True, t = (startNum, endNum), hierarchy= "below", sb = 1, dic = True, pok = True, ral = False, rwl = False, cp = True) cmds.delete(pointConA) cmds.delete(orientConA) cmds.parent( 'Root_M', 'Root' ) parentConB = cmds.parentConstraint( locPos, 'Root_M', mo = True) cmds.bakeResults( 'Root_M', simulation=True, t = (startNum, endNum), hierarchy= "below", sb = 1, dic = True, pok = True, ral = False, rwl = False, cp = True) cmds.delete(parentConB) cmds.delete(locPos) keyframelist = cmds.ls(type='animCurveTL')+cmds.ls(type='animCurveTA')+cmds.ls(type='animCurveTU') keyCurve = [] for i in keyframelist: if 'Root_M' in i or 'Root' in i: keyCurve.append(i) cmds.filterCurve(keyCurve)
cmds.select(i) Grupo = cmds.group(n=str(i) + '_mixamoConstraint') cmds.parentConstraint(Mixamo[X], Grupo, mo=True) X = X + 1 copyPart(RdMControllers_Arms, MixamoJoints_Arms) #copyPart (RdMControllers_Legs, MixamoJoints_Legs) copyPart(RdMControllers_Spine, MixamoJoints_Spine) copyPart(RdMControllers_Head, MixamoJoints_Head) #Legs #LegNotWorking cmds.orientConstraint('LeftUpLeg', 'L_Leg_FK_CC', mo=True) cmds.orientConstraint('RightUpLeg', 'R_Leg_FK_CC', mo=True) cmds.orientConstraint('LeftLeg', 'L_Knee_FK_CCGRP', mo=True) cmds.orientConstraint('LeftFoot', 'L_Ankle_FK_CCGRP', mo=True) cmds.orientConstraint('LeftToeBase', 'L_Ball_FK_CCGRP', mo=True) cmds.orientConstraint('RightLeg', 'R_Knee_FK_CCGRP', mo=True) cmds.orientConstraint('RightFoot', 'R_Ankle_FK_CCGRP', mo=True) cmds.orientConstraint('RightToeBase', 'R_Ball_FK_CCGRP', mo=True)