def add_constraint(self): self.left_arm.add_constraint() self.right_arm.add_constraint() self.left_leg.add_constraint() self.right_leg.add_constraint() self.tail.add_constraint() self.neck_root.add_constraint() self.head.add_constraint() self.tip.add_constraint() self.spine.add_constraint() # parenting the front and back leg and tail under spine ctrl outliner.batch_parent([ self.left_arm.ctrl_offset_list[0], self.right_arm.ctrl_offset_list[0] ], self.spine.ctrl_list[-1]) outliner.batch_parent([ self.left_leg.ctrl_offset_list[0], self.right_leg.ctrl_offset_list[0] ], self.spine.ctrl_list[0]) cmds.parentConstraint(self.spine.ctrl_list[0], self.tail.master_ctrl, mo=1) # hide tail ctrl and connect ik/fk switch to spine master ctrl cmds.connectAttr(self.spine.master_ctrl + '.FK_IK', self.tail.master_ctrl + '.FK_IK') # parent head up cmds.parent(self.neck_root.ctrl_offset_grp, self.spine.ctrl_list[-1]) cmds.parent(self.head.ctrl_offset_grp, self.neck_root.ctrl) cmds.parent(self.tip.ctrl_offset_grp, self.head.ctrl)
def construct_joint(self): # Result joint cmds.select(clear=1) for i, component in enumerate(self.limb_components): loc = cmds.ls(self.loc_list[i], transforms=1) loc_pos = cmds.xform(loc, q=1, t=1, ws=1) jnt = cmds.joint(p=loc_pos, name=self.jnt_list[i]) cmds.setAttr(jnt + '.radius', 1) # FK Joint cmds.select(clear=1) for i, component in enumerate(self.limb_components): loc = cmds.ls(self.loc_list[i], transforms=1) loc_pos = cmds.xform(loc, q=1, t=1, ws=1) fk_jnt = cmds.joint(p=loc_pos, name=self.fk_jnt_list[i]) cmds.setAttr(fk_jnt + '.radius', 1) # IK Joint cmds.select(clear=1) for i, component in enumerate(self.limb_components): loc = cmds.ls(self.loc_list[i], transforms=1) loc_pos = cmds.xform(loc, q=1, t=1, ws=1) ik_jnt = cmds.joint(p=loc_pos, name=self.ik_jnt_list[i]) cmds.setAttr(ik_jnt + '.radius', 1) # Cleanup outliner.batch_parent( [self.jnt_list[0], self.ik_jnt_list[0], self.fk_jnt_list[0]], self.jnt_grp) joint.orient_joint( [self.jnt_list[0], self.ik_jnt_list[0], self.fk_jnt_list[0]]) return cmds.ls(self.jnt_list[0])
def construct_joint(self): self.left_arm.construct_joint() self.right_arm.construct_joint() self.left_leg.construct_joint() self.right_leg.construct_joint() self.spine.construct_joint() self.neck.construct_joint() self.head.construct_joint() self.tip.construct_joint() # Connect # Leg root to spine root left_leg_jnt = cmds.ls(self.left_leg.limb.jnt_list[0]) right_leg_jnt = cmds.ls(self.right_leg.limb.jnt_list[0]) root_spine_jnt = cmds.ls(self.spine.jnt_list[0]) outliner.batch_parent([left_leg_jnt, right_leg_jnt], root_spine_jnt) # Arm root spine root left_arm_jnt = cmds.ls(self.left_arm.limb.jnt_list[0]) right_arm_jnt = cmds.ls(self.right_arm.limb.jnt_list[0]) top_spine_jnt = cmds.ls(self.spine.jnt_list[-1]) outliner.batch_parent([left_arm_jnt, right_arm_jnt], top_spine_jnt) # Neck to spine tip, head to neck cmds.parent(self.neck.jnt, top_spine_jnt) cmds.parent(self.head.jnt, self.neck.jnt) cmds.parent(self.tip.jnt, self.head.jnt)
def construct_joint(self): # Result jnt cmds.select(clear=1) for i, loc in enumerate(self.loc_list): loc_pos = cmds.xform(loc, q=1, t=1, ws=1) jnt = cmds.joint(p=loc_pos, name=self.jnt_list[i]) cmds.setAttr(jnt + '.radius', self.scale) # IK jnt cmds.select(clear=1) for i, loc in enumerate(self.loc_list): loc_pos = cmds.xform(loc, q=1, t=1, ws=1) jnt = cmds.joint(p=loc_pos, name=self.ik_jnt_list[i]) cmds.setAttr(jnt + '.radius', self.scale) # FK jnt cmds.select(clear=1) for i, loc in enumerate(self.loc_list): loc_pos = cmds.xform(loc, q=1, t=1, ws=1) jnt = cmds.joint(p=loc_pos, name=self.fk_jnt_list[i]) cmds.setAttr(jnt + '.radius', self.scale) # Cleanup cmds.setAttr(self.fk_jnt_list[0] + '.visibility', 0) cmds.setAttr(self.ik_jnt_list[0] + '.visibility', 0) outliner.batch_parent( [self.jnt_list[0], self.fk_jnt_list[0], self.ik_jnt_list[0]], self.jnt_grp) joint.orient_joint( [self.jnt_list[0], self.fk_jnt_list[0], self.ik_jnt_list[0]]) return self.jnt_list[0]
def construct_joint(self): left_shoulder = self.left_arm.construct_joint() right_shoulder = self.right_arm.construct_joint() left_hip = self.left_leg.construct_joint() right_hip = self.right_leg.construct_joint() spine_root = self.spine.construct_joint() tail_root = self.tail.construct_joint() neck_root = self.neck_root.construct_joint() head = self.head.construct_joint() tip = self.tip.construct_joint() # parent leg root joints to root spline joint outliner.batch_parent([left_shoulder, right_shoulder], self.spine.jnt_list[-1]) # parent arm root joints to top spline joint outliner.batch_parent([left_hip, right_hip], spine_root) # parent tail to spine cmds.parent(tail_root, spine_root) # parent neck, head, tip cmds.parent(neck_root, self.spine.jnt_list[-1]) cmds.parent(head, neck_root) cmds.parent(tip, head)
def place_controller(self): self.set_controller_shape() # IK Setup foot_ctrl = cmds.duplicate('Foot_tempShape', name=self.ctrl_name)[0] cmds.addAttr(foot_ctrl, longName='foot_Roll', attributeType='double', defaultValue=0, minValue=-10, maxValue=40, keyable=1) cmds.addAttr(foot_ctrl, longName='foot_Bank', attributeType='double', defaultValue=0, minValue=-20, maxValue=20, keyable=1) foot_pos = cmds.xform(self.ball_jnt_name, q=1, t=1, ws=1) cmds.move(foot_pos[0], foot_pos[1], foot_pos[2] + 1, foot_ctrl) cmds.makeIdentity(foot_ctrl, apply=1, t=1, r=1, s=1) heel_loc = cmds.xform(self.heel_jnt_name, q=1, t=1, ws=1) cmds.move(heel_loc[0], heel_loc[1], heel_loc[2], '%s.scalePivot' % foot_ctrl, '%s.rotatePivot' % foot_ctrl, absolute=1) # FK Setup foot_fk_ctrl = cmds.duplicate('FootFK_tempShape', name=self.fk_ctrl_name)[0] cmds.move(foot_pos[0], foot_pos[1], foot_pos[2], foot_fk_ctrl) cmds.makeIdentity(foot_fk_ctrl, apply=1, t=1, r=1, s=1) # IK/FK Switch Setup switch = cmds.duplicate('FootSwitch_tempShape', name=self.switch_ctrl_name)[0] if self.side == "L": cmds.move(foot_pos[0] + 2, foot_pos[1], foot_pos[2], switch) elif self.side == "R": cmds.move(foot_pos[0] - 3, foot_pos[1], foot_pos[2], switch) cmds.scale(0.5, 0.5, 0.5, switch) cmds.addAttr(switch, longName='FK_IK', attributeType='double', defaultValue=1, minValue=0, maxValue=1, keyable=1) cmds.makeIdentity(switch, apply=1, t=1, r=1, s=1) # Cleanup outliner.batch_parent([switch, foot_ctrl, foot_fk_ctrl], self.ctrl_grp) self.delete_shape()
def place_controller(self): self.set_controller_shape() # Shoulder shoulder = cmds.ls(self.jnt_list[0]) shoulder_ctrl = cmds.duplicate('Shoulder_tempShape', name=self.ctrl_list[0])[0] shoulder_pos = cmds.xform(shoulder, q=1, ws=1, t=1) shoulder_rot = cmds.xform(shoulder, q=1, ws=1, ro=1) shoulder_ctrl_offset = cmds.group(em=1, name=self.ctrl_offset_list[0]) cmds.move(shoulder_pos[0], shoulder_pos[1], shoulder_pos[2], shoulder_ctrl_offset) cmds.rotate(shoulder_rot[0], shoulder_rot[1], shoulder_rot[2], shoulder_ctrl_offset) cmds.parent(shoulder_ctrl, shoulder_ctrl_offset, relative=1) # Front foot paw = cmds.ls(self.jnt_list[3]) paw_ctrl = cmds.duplicate('Paw_tempShape', name=self.ctrl_list[3])[0] paw_pos = cmds.xform(paw, q=1, ws=1, t=1) cmds.move(paw_pos[0], 0, paw_pos[2], paw_ctrl) # custom attribute for later pivot group access cmds.addAttr(paw_ctrl, longName='Flex', attributeType='double', keyable=1) cmds.addAttr(paw_ctrl, longName='Swivel', attributeType='double', keyable=1) cmds.addAttr(paw_ctrl, longName='Toe_Tap', attributeType='double', keyable=1) cmds.addAttr(paw_ctrl, longName='Toe_Tip', attributeType='double', keyable=1) cmds.addAttr(paw_ctrl, longName='Wrist', attributeType='double', keyable=1) cmds.makeIdentity(paw_ctrl, apply=1, t=1, r=1, s=1) # Elbow control - aka. pole vector elbow = cmds.ls(self.jnt_list[1]) pole_ctrl = cmds.duplicate('Pole_tempShape', name=self.ctrl_list[1])[0] pole_ctrl_offset = cmds.group(em=1, name=self.ctrl_offset_list[1]) elbow_pos = cmds.xform(elbow, q=1, ws=1, t=1) cmds.move(elbow_pos[0], elbow_pos[1], elbow_pos[2] - self.distance, pole_ctrl_offset) cmds.parent(pole_ctrl, pole_ctrl_offset, relative=1) cmds.parent(pole_ctrl_offset, paw_ctrl) outliner.batch_parent([shoulder_ctrl_offset, paw_ctrl], self.ctrl_grp) self.delete_shape()
def add_measurement(self): # add length segment hip_pos = cmds.xform(self.jnt_list[0], q=1, ws=1, t=1) knee_pos = cmds.xform(self.jnt_list[1], q=1, ws=1, t=1) ankle_pos = cmds.xform(self.jnt_list[2], q=1, ws=1, t=1) foot_pos = cmds.xform(self.jnt_list[3], q=1, ws=1, t=1) straighten_len = ((knee_pos[0]-ankle_pos[0]) ** 2+(knee_pos[1]-ankle_pos[1]) ** 2+(knee_pos[2]-ankle_pos[2]) ** 2) ** 0.5+ \ ((foot_pos[0]-ankle_pos[0]) ** 2+(foot_pos[1]-ankle_pos[1]) ** 2+(foot_pos[2]-ankle_pos[2]) ** 2) ** 0.5+ \ ((hip_pos[0]-knee_pos[0]) ** 2+(hip_pos[1]-knee_pos[1]) ** 2+(hip_pos[2]-knee_pos[2]) ** 2) ** 0.5 # create measurement measure_shape = cmds.distanceDimension(sp=hip_pos, ep=foot_pos) locs = cmds.listConnections(measure_shape) measure_node = cmds.listRelatives(measure_shape, parent=1, type='transform') length_node = '{}length_node'.format(self.name) hip_loc = '{}hip_node'.format(self.name) ankle_loc = '{}ankle_node'.format(self.name) cmds.rename(measure_node, length_node) cmds.rename(locs[0], hip_loc) cmds.rename(locs[1], ankle_loc) stretch_node = cmds.shadingNode('multiplyDivide', asUtility=1, name='{}stretch_node'.format( self.name)) cmds.setAttr(stretch_node + '.operation', 2) cmds.setAttr(stretch_node + '.input2X', straighten_len) cmds.connectAttr(length_node + '.distance', stretch_node + '.input1X') condition_node = cmds.shadingNode('condition', asUtility=1, name='{}condition_node'.format( self.name)) cmds.connectAttr(stretch_node + '.outputX', condition_node + '.firstTerm') cmds.setAttr(condition_node + '.secondTerm', 1) cmds.setAttr(condition_node + '.operation', 2) # greater than cmds.connectAttr(stretch_node + '.outputX', condition_node + '.colorIf1R') cmds.setAttr(condition_node + '.colorIfFalseR', 1) for joint in [ self.jnt_list[0], self.jnt_list[1], self.jnt_list[2], self.jnt_helper_list[0], self.jnt_helper_list[1], self.jnt_helper_list[2] ]: cmds.connectAttr(condition_node + '.outColorR', joint + '.scaleX') cmds.setAttr(length_node + '.visibility', 0) cmds.setAttr(hip_loc + '.visibility', 0) cmds.setAttr(ankle_loc + '.visibility', 0) outliner.batch_parent([length_node, hip_loc, ankle_loc], self.ctrl_grp) cmds.parentConstraint(self.ctrl_list[0], hip_loc) cmds.parentConstraint(self.ctrl_list[3], ankle_loc, mo=1)
def add_constraint(self): self.build_ik() # Shoulder pivot cmds.parentConstraint(self.ctrl_list[0], self.jnt_list[0]) # Front foot pivot group toe_tap_pivot_grp = cmds.group(em=1, name='{}toetap_pivot_grp'.format( self.name)) flex_pivot_grp = cmds.group(em=1, name='{}flex_pivot_grp'.format(self.name)) swivel_pivot_grp = cmds.group(em=1, name='{}swivel_pivot_grp'.format( self.name)) toe_tip_pivot_grp = cmds.group(em=1, name='{}toetip_pivot_grp'.format( self.name)) wrist_pivot_grp = cmds.group(em=1, name='{}wrist_pivot_grp'.format( self.name)) paw_pos = cmds.xform(self.jnt_list[3], q=1, ws=1, t=1) toe_pos = cmds.xform(self.jnt_list[4], q=1, ws=1, t=1) wrist_pos = cmds.xform(self.jnt_list[2], q=1, ws=1, t=1) cmds.move(paw_pos[0], paw_pos[1], paw_pos[2], toe_tap_pivot_grp) cmds.move(paw_pos[0], paw_pos[1], paw_pos[2], flex_pivot_grp) cmds.move(paw_pos[0], paw_pos[1], paw_pos[2], swivel_pivot_grp) cmds.move(toe_pos[0], toe_pos[1], toe_pos[2], toe_tip_pivot_grp) cmds.move(wrist_pos[0], wrist_pos[1], wrist_pos[2], wrist_pivot_grp) cmds.parent(self.toe_ik_name, toe_tap_pivot_grp) outliner.batch_parent([self.leg_ik_name, self.foot_ik_name], flex_pivot_grp) outliner.batch_parent([toe_tap_pivot_grp, flex_pivot_grp], swivel_pivot_grp) cmds.parent(swivel_pivot_grp, toe_tip_pivot_grp) cmds.parent(toe_tip_pivot_grp, wrist_pivot_grp) cmds.parent(wrist_pivot_grp, self.ctrl_list[3]) cmds.connectAttr(self.ctrl_list[3] + '.Flex', flex_pivot_grp + '.rotateX') cmds.connectAttr(self.ctrl_list[3] + '.Swivel', swivel_pivot_grp + '.rotateY') cmds.connectAttr(self.ctrl_list[3] + '.Toe_Tap', toe_tap_pivot_grp + '.rotateX') cmds.connectAttr(self.ctrl_list[3] + '.Toe_Tip', toe_tip_pivot_grp + '.rotateX') cmds.connectAttr(self.ctrl_list[3] + '.Wrist', wrist_pivot_grp + '.rotateX') # Pole vector constraint cmds.poleVectorConstraint(self.ctrl_list[1], self.leg_ik_name) # Scalable rig setup self.add_measurement()
def add_measurement(self): # add length segment shoulder_pos = cmds.xform(self.jnt_list[0], q=1, ws=1, t=1) elbow_pos = cmds.xform(self.jnt_list[1], q=1, ws=1, t=1) wrist_pos = cmds.xform(self.jnt_list[2], q=1, ws=1, t=1) straighten_len = ((shoulder_pos[0]-elbow_pos[0]) ** 2+(shoulder_pos[1]-elbow_pos[1]) ** 2+(shoulder_pos[2]-elbow_pos[2]) ** 2) ** 0.5+ \ ((wrist_pos[0]-elbow_pos[0]) ** 2+(wrist_pos[1]-elbow_pos[1]) ** 2+(wrist_pos[2]-elbow_pos[2]) ** 2) ** 0.5 # create measurement measure_shape = cmds.distanceDimension(sp=shoulder_pos, ep=wrist_pos) locs = cmds.listConnections(measure_shape) measure_node = cmds.listRelatives(measure_shape, parent=1, type='transform') length_node = '{}length_node'.format(self.name) shoulder_loc = '{}shoulder_node'.format(self.name) elbow_loc = '{}elbow_node'.format(self.name) cmds.rename(measure_node, length_node) cmds.rename(locs[0], shoulder_loc) cmds.rename(locs[1], elbow_loc) stretch_node = cmds.shadingNode('multiplyDivide', asUtility=1, name='{}stretch_node'.format( self.name)) cmds.setAttr(stretch_node + '.operation', 2) cmds.setAttr(stretch_node + '.input2X', straighten_len) cmds.connectAttr(length_node + '.distance', stretch_node + '.input1X') condition_node = cmds.shadingNode('condition', asUtility=1, name='{}condition_node'.format( self.name)) cmds.connectAttr(stretch_node + '.outputX', condition_node + '.firstTerm') cmds.setAttr(condition_node + '.secondTerm', 1) cmds.setAttr(condition_node + '.operation', 2) # Greater than cmds.connectAttr(stretch_node + '.outputX', condition_node + '.colorIf1R') cmds.setAttr(condition_node + '.colorIfFalseR', 1) cmds.connectAttr(condition_node + '.outColorR', self.jnt_list[0] + '.scaleX') cmds.connectAttr(condition_node + '.outColorR', self.jnt_list[1] + '.scaleX') cmds.setAttr(length_node + '.visibility', 0) cmds.setAttr(shoulder_loc + '.visibility', 0) cmds.setAttr(elbow_loc + '.visibility', 0) outliner.batch_parent([length_node, shoulder_loc, elbow_loc], self.ctrl_grp) cmds.parentConstraint(self.ctrl_list[0], shoulder_loc) cmds.parentConstraint(self.ctrl_list[3], elbow_loc, mo=1)
def place_controller(self): self.set_controller_shape() # Master control cmds.duplicate('TailIK_tempShape', name=self.master_ctrl) tail_pos = cmds.xform(self.jnt_list[0], q=1, t=1, ws=1) cmds.move(tail_pos[0], tail_pos[1], tail_pos[2] - 1, self.master_ctrl) cmds.addAttr(self.master_ctrl, longName='FK_IK', attributeType='double', defaultValue=1, minValue=0, maxValue=1, keyable=1) # IK and FK control has the same setup for i in range(self.segment): cmds.duplicate('TailIK_tempShape', name=self.ik_ctrl_list[i]) cmds.group(em=1, name=self.ik_offset_list[i]) cmds.duplicate('TailFK_tempShape', name=self.fk_ctrl_list[i]) cmds.group(em=1, name=self.fk_offset_list[i]) for i, tail in enumerate(self.jnt_list): tail_pos = cmds.xform(tail, q=1, t=1, ws=1) tail_rot = cmds.xform(tail, q=1, ro=1, ws=1) cmds.move(tail_pos[0], tail_pos[1], tail_pos[2], self.ik_offset_list[i]) cmds.rotate(tail_rot[0], tail_rot[1], tail_rot[2], self.ik_offset_list[i]) cmds.move(tail_pos[0], tail_pos[1], tail_pos[2], self.fk_offset_list[i]) cmds.rotate(tail_rot[0], tail_rot[1], tail_rot[2], self.fk_offset_list[i]) for i in range(self.segment): cmds.parent(self.ik_ctrl_list[i], self.ik_offset_list[i], relative=1) cmds.parent(self.fk_ctrl_list[i], self.fk_offset_list[i], relative=1) if i != 0: cmds.parent(self.ik_offset_list[i], self.ik_ctrl_list[i - 1]) cmds.parent(self.fk_offset_list[i], self.fk_ctrl_list[i - 1]) else: outliner.batch_parent( [self.ik_offset_list[i], self.fk_offset_list[i]], self.master_ctrl) # Cleanup cmds.parent(self.master_ctrl, self.ctrl_grp) self.delete_shape() return self.master_ctrl
def construct_joint(self): # Result Foot ankle = cmds.ls(self.ankle_loc_name) cmds.select(clear=1) ankle_pos = cmds.xform(ankle, q=1, t=1, ws=1) ankle_jnt = cmds.joint(p=ankle_pos, name=self.ankle_jnt_name) ball = cmds.ls(self.ball_loc_name) ball_pos = cmds.xform(ball, q=1, t=1, ws=1) ball_jnt = cmds.joint(p=ball_pos, name=self.ball_jnt_name) toe = cmds.ls(self.toe_loc_name) toe_pos = cmds.xform(toe, q=1, t=1, ws=1) toe_jnt = cmds.joint(p=toe_pos, name=self.toe_jnt_name) # Reverse Foot inner = cmds.ls(self.inner_loc_name) cmds.select(clear=1) inner_pos = cmds.xform(inner, q=1, t=1, ws=1) inner_jnt = cmds.joint(p=inner_pos, name=self.inner_jnt_name) outer = cmds.ls(self.outer_loc_name) outer_pos = cmds.xform(outer, q=1, t=1, ws=1) outer_jnt = cmds.joint(p=outer_pos, name=self.outer_jnt_name) heel = cmds.ls(self.heel_loc_name) heel_pos = cmds.xform(heel, q=1, t=1, ws=1) heel_jnt = cmds.joint(p=heel_pos, name=self.heel_jnt_name) reverse_toe_jnt = cmds.joint(p=toe_pos, radius=0.8, name=self.rev_toe_jnt_name) reverse_ball_jnt = cmds.joint(p=ball_pos, radius=0.8, name=self.rev_ball_jnt_name) reverse_ankle_jnt = cmds.joint(p=ankle_pos, radius=0.8, name=self.rev_ankle_jnt_name) cmds.setAttr(inner_jnt + '.visibility', 0) # FK Foot cmds.select(clear=1) ankle_jnt_fk = cmds.joint(p=ankle_pos, name=self.fk_ankle_jnt_name) ball_jnt_fk = cmds.joint(p=ball_pos, name=self.fk_ball_jnt_name) toe_jnt_fk = cmds.joint(p=toe_pos, name=self.fk_toe_jnt_name) cmds.setAttr(ankle_jnt_fk + '.visibility', 0) # Cleanup outliner.batch_parent([ankle_jnt_fk, inner_jnt, ankle_jnt], self.jnt_grp)
def place_controller(self): self.set_controller_shape() # Hip hip = cmds.ls(self.jnt_list[0]) hip_ctrl = cmds.duplicate('Hip_tempShape', name=self.ctrl_list[0])[0] hip_pos = cmds.xform(hip, q=1, ws=1, t=1) hip_rot = cmds.xform(hip, q=1, ws=1, ro=1) hip_ctrl_offset = cmds.group(em=1, name=self.ctrl_offset_list[0]) cmds.move(hip_pos[0], hip_pos[1], hip_pos[2], hip_ctrl_offset) cmds.rotate(hip_rot[0], hip_rot[1], hip_rot[2], hip_ctrl_offset) cmds.parent(hip_ctrl, hip_ctrl_offset, relative=1) # Back foot foot = cmds.ls(self.jnt_list[3]) foot_ctrl = cmds.duplicate('Foot_tempShape', name=self.ctrl_list[3])[0] foot_pos = cmds.xform(foot, q=1, ws=1, t=1) cmds.move(foot_pos[0], 0, foot_pos[2], foot_ctrl) cmds.makeIdentity(foot_ctrl, apply=1, t=1, r=1, s=1) # custom attribute for later pivot group access cmds.addAttr(foot_ctrl, longName='Flex', attributeType='double', keyable=1) cmds.addAttr(foot_ctrl, longName='Swivel', attributeType='double', keyable=1) cmds.addAttr(foot_ctrl, longName='Toe_Tap', attributeType='double', keyable=1) cmds.addAttr(foot_ctrl, longName='Toe_Tip', attributeType='double', keyable=1) # Ankle control - poleVector ankle = cmds.ls(self.jnt_list[2]) pole_ctrl = cmds.duplicate('Pole_tempShape', name=self.ctrl_list[2])[0] pole_ctrl_offset = cmds.group(em=1, name=self.ctrl_offset_list[2]) ankle_pos = cmds.xform(ankle, q=1, ws=1, t=1) cmds.move(ankle_pos[0], ankle_pos[1], ankle_pos[2] + self.distance, pole_ctrl_offset) cmds.parent(pole_ctrl, pole_ctrl_offset, relative=1) cmds.parent(pole_ctrl_offset, foot_ctrl) outliner.batch_parent([hip_ctrl_offset, foot_ctrl], self.ctrl_grp) self.delete_shape()
def place_controller(self): self.set_controller_shape() root_pos = cmds.xform(self.jnt_list[0], q=1, t=1, ws=1) root_rot = cmds.xform(self.jnt_list[0], q=1, ro=1, ws=1) top_pos = cmds.xform(self.jnt_list[-1], q=1, t=1, ws=1) top_rot = cmds.xform(self.jnt_list[-1], q=1, ro=1, ws=1) # master ctrl is positioned on top of root ctrl cmds.duplicate('Master_tempShape', name=self.master_ctrl) cmds.group(em=1, name=self.master_offset) cmds.move(root_pos[0], root_pos[1] + 2, root_pos[2], self.master_offset) cmds.parent(self.master_ctrl, self.master_offset, relative=1) # root ctrl is positioned at the root joint # root ctrl needs to be accessed outside for parenting cmds.duplicate('Spine_tempShape', name=self.ctrl_list[0]) cmds.group(em=1, name=self.ctrlOffset_list[0]) cmds.move(root_pos[0], root_pos[1], root_pos[2], self.ctrlOffset_list[0]) cmds.rotate(root_rot[0], root_rot[1], root_rot[2], self.ctrlOffset_list[0]) cmds.parent(self.ctrl_list[0], self.ctrlOffset_list[0], relative=1) # top ctrl is positioned at the top joint # top ctrl needs to be accessed outside for parenting cmds.duplicate('Spine_tempShape', name=self.ctrl_list[-1]) cmds.group(em=1, name=self.ctrlOffset_list[-1]) cmds.move(top_pos[0], top_pos[1], top_pos[2], self.ctrlOffset_list[-1]) cmds.rotate(top_rot[0], top_rot[1], top_rot[2], self.ctrlOffset_list[-1]) cmds.parent(self.ctrl_list[-1], self.ctrlOffset_list[-1], relative=1) # mid ctrl is positioned at the middle joint / or middle two joint if self.segment % 2 != 0: mid_pos = cmds.xform(self.jnt_list[(self.segment - 1) / 2], q=1, t=1, ws=1) mid_rot = cmds.xform(self.jnt_list[(self.segment - 1) / 2], q=1, ro=1, ws=1) else: mid_upper_pos = cmds.xform(self.jnt_list[(self.segment + 1) / 2], q=1, t=1, ws=1) mid_upper_rot = cmds.xform(self.jnt_list[(self.segment + 1) / 2], q=1, ro=1, ws=1) mid_lower_pos = cmds.xform(self.jnt_list[(self.segment - 1) / 2], q=1, t=1, ws=1) mid_lower_rot = cmds.xform(self.jnt_list[(self.segment - 1) / 2], q=1, ro=1, ws=1) mid_pos = [(mid_upper_pos[0] + mid_lower_pos[0]) / 2, (mid_upper_pos[1] + mid_lower_pos[1]) / 2, (mid_upper_pos[2] + mid_lower_pos[2]) / 2] mid_rot = [(mid_upper_rot[0] + mid_lower_rot[0]) / 2, (mid_upper_rot[1] + mid_lower_rot[1]) / 2, (mid_upper_rot[2] + mid_lower_rot[2]) / 2] cmds.duplicate('Spine_tempShape', name=self.ctrl_list[1]) cmds.group(em=1, name=self.ctrlOffset_list[1]) cmds.move(mid_pos[0], mid_pos[1], mid_pos[2], self.ctrlOffset_list[1]) cmds.rotate(mid_rot[0], mid_rot[1], mid_rot[2], self.ctrlOffset_list[1]) cmds.parent(self.ctrl_list[1], self.ctrlOffset_list[1], relative=1) # Cleanup outliner.batch_parent([ self.ctrlOffset_list[0], self.ctrlOffset_list[1], self.ctrlOffset_list[-1] ], self.master_ctrl) cmds.parent(self.master_offset, self.ctrl_grp) self.delete_shape() return self.master_ctrl
def add_constraint(self): # Result Joint + IK/FK Switch for i, type in enumerate(self.limb_components): if i == 0: cmds.parentConstraint(self.ik_jnt_list[i], self.fk_jnt_list[i], self.jnt_list[i]) cmds.setDrivenKeyframe( '{}_parentConstraint1.{}W0'.format(self.jnt_list[i], self.ik_jnt_list[i]), currentDriver='{}.FK_IK'.format(self.switch_ctrl), driverValue=1, value=1) cmds.setDrivenKeyframe( '{}_parentConstraint1.{}W1'.format(self.jnt_list[i], self.fk_jnt_list[i]), currentDriver='{}.FK_IK'.format(self.switch_ctrl), driverValue=1, value=0) cmds.setDrivenKeyframe( '{}_parentConstraint1.{}W0'.format(self.jnt_list[i], self.ik_jnt_list[i]), currentDriver='{}.FK_IK'.format(self.switch_ctrl), driverValue=0, value=0) cmds.setDrivenKeyframe( '{}_parentConstraint1.{}W1'.format(self.jnt_list[i], self.fk_jnt_list[i]), currentDriver='{}.FK_IK'.format(self.switch_ctrl), driverValue=0, value=1) else: cmds.orientConstraint(self.ik_jnt_list[i], self.fk_jnt_list[i], self.jnt_list[i]) cmds.setDrivenKeyframe( '{}_orientConstraint1.{}W0'.format(self.jnt_list[i], self.ik_jnt_list[i]), currentDriver='{}.FK_IK'.format(self.switch_ctrl), driverValue=1, value=1) cmds.setDrivenKeyframe( '{}_orientConstraint1.{}W1'.format(self.jnt_list[i], self.fk_jnt_list[i]), currentDriver='{}.FK_IK'.format(self.switch_ctrl), driverValue=1, value=0) cmds.setDrivenKeyframe( '{}_orientConstraint1.{}W0'.format(self.jnt_list[i], self.ik_jnt_list[i]), currentDriver='{}.FK_IK'.format(self.switch_ctrl), driverValue=0, value=0) cmds.setDrivenKeyframe( '{}_orientConstraint1.{}W1'.format(self.jnt_list[i], self.fk_jnt_list[i]), currentDriver='{}.FK_IK'.format(self.switch_ctrl), driverValue=0, value=1) for i, component in enumerate(self.limb_components): cmds.setDrivenKeyframe(self.fk_ctrl_list[i] + '.visibility', currentDriver=self.switch_ctrl + '.FK_IK', driverValue=0, value=1) cmds.setDrivenKeyframe(self.fk_ctrl_list[i] + '.visibility', currentDriver=self.switch_ctrl + '.FK_IK', driverValue=1, value=0) cmds.setDrivenKeyframe(self.ik_ctrl_name + '.visibility', currentDriver=self.switch_ctrl + '.FK_IK', driverValue=1, value=1) cmds.setDrivenKeyframe(self.ik_ctrl_name + '.visibility', currentDriver=self.switch_ctrl + '.FK_IK', driverValue=0, value=0) cmds.setDrivenKeyframe(self.ik_pole_name + '.visibility', currentDriver=self.switch_ctrl + '.FK_IK', driverValue=1, value=1) cmds.setDrivenKeyframe(self.ik_pole_name + '.visibility', currentDriver=self.switch_ctrl + '.FK_IK', driverValue=0, value=0) # FK Setup for i, component in enumerate(self.limb_components): cmds.orientConstraint(self.fk_ctrl_list[i], self.fk_jnt_list[i], mo=1) cmds.setAttr(self.fk_jnt_list[0] + '.visibility', 0) # IK Setup # Set Preferred Angles # middle_ik_jnt = self.ik_jnt_list[1] if self.direction == 'Vertical': cmds.rotate(0, 0, -20, middle_ik_jnt, relative=1) cmds.joint(middle_ik_jnt, edit=1, ch=1, setPreferredAngles=1) cmds.rotate(0, 0, 20, middle_ik_jnt, relative=1) else: if self.side == 'L': cmds.rotate(0, 0, 20, middle_ik_jnt, relative=1) cmds.joint(middle_ik_jnt, edit=1, ch=1, setPreferredAngles=1) cmds.rotate(0, 0, -20, middle_ik_jnt, relative=1) elif self.side == 'R': cmds.rotate(0, 0, 20, middle_ik_jnt, relative=1) cmds.joint(middle_ik_jnt, edit=1, ch=1, setPreferredAngles=1) cmds.rotate(0, 0, -20, middle_ik_jnt, relative=1) cmds.setAttr(self.ik_jnt_list[0] + '.visibility', 0) # IK Handle # ik_handle = cmds.ikHandle(startJoint=self.ik_jnt_list[0], endEffector=self.ik_jnt_list[-1], name='{}_ikhandle'.format(self.name), solver='ikRPsolver')[0] cmds.pointConstraint(self.ik_ctrl_name, ik_handle, mo=1) cmds.orientConstraint(self.ik_ctrl_name, self.ik_jnt_list[-1], mo=1) cmds.poleVectorConstraint(self.ik_pole_name, ik_handle) cmds.setAttr(ik_handle + '.visibility', 0) # Cleanup cmds.pointConstraint(self.switch_ctrl, self.ik_jnt_list[0], mo=1) cmds.pointConstraint(self.switch_ctrl, self.fk_jnt_list[0], mo=1) outliner.batch_parent([ self.ik_offset_name, self.ik_pole_offset_name, self.fk_offset_list[0], ik_handle ], self.switch_ctrl)
def build_guide(self): grp = cmds.group(em=1, n=self.loc_grp_name) side_factor = 1 if self.side == 'R': side_factor = -1 # Finger Locators z_value = self.start_pos[2] offsets = [ z_value + 2 * self.interval, z_value + self.interval, z_value, z_value - self.interval, z_value - 2 * self.interval ] thumb = finger.Finger(side=self.side, base_name='thumb', finger_type='Thumb') thumb.set_locator_attr(start_pos=[ self.start_pos[0] - side_factor * 0.7, self.start_pos[1], offsets[0] ], interval=0.3) # x offset 0.7 thumb_grp = thumb.build_guide() index = finger.Finger(side=self.side, base_name='index') index.set_locator_attr( start_pos=[self.start_pos[0], self.start_pos[1], offsets[1]], interval=0.5) index_grp = index.build_guide() middle = finger.Finger(side=self.side, base_name='middle') middle.set_locator_attr( start_pos=[self.start_pos[0], self.start_pos[1], offsets[2]], interval=0.55) middle_grp = middle.build_guide() ring = finger.Finger(side=self.side, base_name='ring') ring.set_locator_attr( start_pos=[self.start_pos[0], self.start_pos[1], offsets[3]], interval=0.5) ring_grp = ring.build_guide() pinky = finger.Finger(side=self.side, base_name='pinky') pinky.set_locator_attr(start_pos=[ self.start_pos[0] - side_factor * 0.3, self.start_pos[1], offsets[4] ], interval=0.4) # x offset 0.3 pinky_grp = pinky.build_guide() self.finger_list = [thumb, index, middle, ring, pinky] # Single Wrist Locator self.wrist = base.Base(side=self.side, base_name='wrist') self.wrist.set_locator_attr(start_pos=[ self.start_pos[0] - side_factor * self.distance, self.start_pos[1], self.start_pos[2] ]) wrist = self.wrist.build_guide() # Cleanup outliner.batch_parent( [thumb_grp, index_grp, middle_grp, ring_grp, pinky_grp], wrist) cmds.parent(wrist, grp) cmds.parent(grp, self.loc_grp) return wrist
def construct_joint(self): fingers = [finger.construct_joint() for finger in self.finger_list] wrist = self.wrist.construct_joint() outliner.batch_parent(fingers, wrist)