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)
