def addJointChainToCurvePoints(crv, endPt, jointNum):
'''
add a joint chain on crv.u[0:endPt]
joints distributed by distance along curve
'''
length = findLengthFromParam(crv, endPt)
lengthBetweenEachJoint = length / (jointNum - 1)
lengthsAlongCurve = [lengthBetweenEachJoint * i for i in range(jointNum)]
paramsAlongCurve = [
crv.findParamFromLength(length) for length in lengthsAlongCurve
]
pointsAlongCurve = [
crv.getPointAtParam(param, space='world') for param in paramsAlongCurve
]
allJnts = []
pm.select(cl=True)
for ptId, ptPos in enumerate(pointsAlongCurve):
jnt = pm.joint(n=crv.name() + '_jnt_%d' % ptId)
jnt.setTranslation(ptPos, space='world')
allJnts.append(jnt)
# orient jnts
allJnts[0].orientJoint('xyz', ch=True)
pm.ikHandle(sj=allJnts[0],
ee=allJnts[-1],
curve=crv,
sol='ikSplineSolver',
createCurve=False,
n=crv.name() + 'ikH')
def build(self, startJoint, endJoint, curve=None, numOfCurveSpans=1):
if curve:
OpenMaya.MGlobal.displayWarning(
'Curve is specified, numOfCurveSpans option will be ignored')
ikHandle, effecotor = pm.ikHandle(startJoint=startJoint,
endEffector=endJoint,
createCurve=False,
curve=curve,
solver='ikSplineSolver',
parentCurve=False,
name=self.name + '_ikh',
rootOnCurve=True)
else:
ikHandle, effector, curve = pm.ikHandle(startJoint=startJoint,
endEffector=endJoint,
createCurve=True,
numSpans=numOfCurveSpans,
solver='ikSplineSolver',
parentCurve=False,
name=self.name + '_ikh',
rootOnCurve=True)
clusters = self.createClusters(curve)
self.createControls(clusters)
self.setStretch()
self.setSquash()
def make_spline_streatch(ikHandle):
'''
'''
joints = pm.ikHandle(ikHandle, q=True, jl=True)
curve = pm.PyNode(pm.ikHandle(ikHandle, q=True, c=True)).getParent()
if not curve.hasAttr('global_scale'):
pm.addAttr(curve, ln='global_scale', dv=1, k=True)
arcn = pm.arclen(curve, ch=True)
mult = pm.createNode('multDoubleLinear')
devi = pm.createNode('multiplyDivide')
arcn.al >> devi.i1x
curve.global_scale >> mult.i1
arcn.al >> mult.i2
arcn.al // mult.i2
mult.o >> devi.i2x
devi.op.set(2)
for jnt in joints:
devi.ox >> pm.PyNode('{0}.s{1}'.format(jnt, get_joint_axis(jnt)))
return True
def applyIK(sfx):
sfx = sfx
ikhandlelist = []
ikhandlelist.append(
pm.ikHandle(n="ikHandle_" + jntnamelist[2] + sfx,
sj=jntnamelist[0] + sfx,
ee=jntnamelist[2] + sfx,
sol="ikRPsolver")[0])
ikhandlelist.append(
pm.ikHandle(n="ikHandle_" + jntnamelist[3] + sfx,
sj=jntnamelist[2] + sfx,
ee=jntnamelist[3] + sfx,
sol="ikSCsolver")[0])
ikhandlelist.append(
pm.ikHandle(n="ikHandle_" + jntnamelist[4] + sfx,
sj=jntnamelist[3] + sfx,
ee=jntnamelist[4] + sfx,
sol="ikSCsolver")[0])
pm.parent("ikHandle_" + jntnamelist[2] + sfx,
"Rev_" + jntnamelist[2] + sfx)
pm.parent("ikHandle_" + jntnamelist[3] + sfx,
"Rev_" + jntnamelist[3] + sfx)
pm.parent("ikHandle_" + jntnamelist[4] + sfx,
"Rev_" + jntnamelist[5] + sfx)
def test_nonUniqueName(self):
cmds.file(f=1, new=1)
j1 = cmds.createNode('joint', name='j1')
j2 = cmds.createNode('joint', name='j2', parent=j1)
j3 = cmds.createNode('joint', name='j3', parent=j2)
j4 = cmds.createNode('joint', name='j4', parent=j3)
cmds.select(j1, j4)
ikh1 = pm.ikHandle(name='ikh')
self.assertEqual(len(ikh1), 2)
self.assertTrue(isinstance(ikh1[0], pm.nt.IkHandle))
self.assertTrue(isinstance(ikh1[1], pm.nt.IkEffector))
self.assertEqual(ikh1[0].nodeName(), 'ikh')
pm.group(ikh1, name='theGroup')
self.assertEqual(cmds.ls('*ikh', long=True), ['|theGroup|ikh'])
j3 = cmds.createNode('joint', name='j3')
j4 = cmds.createNode('joint', name='j4', parent=j3)
cmds.select(j3, j4)
ikh2 = pm.ikHandle(name='ikh')
self.assertEqual(len(ikh2), 2)
self.assertTrue(isinstance(ikh2[0], pm.nt.IkHandle))
self.assertTrue(isinstance(ikh2[1], pm.nt.IkEffector))
self.assertEqual(ikh2[0].nodeName(), 'ikh')
def generateLegs(self):
self.r_legJoints = []
self.generateLimb('l', 'r_leg', self.legLocators, self.r_legJoints,
self.spineJoints[len(self.spineJoints) - 1], False)
self.r_footJoints = []
self.generateLimb('l', 'r_foot', self.footLocators, self.r_footJoints,
self.r_legJoints[-1], False)
l_legJoints_raw = pm.mirrorJoint(self.r_legJoints[0],
mb=1,
mxy=1,
sr=('r_', 'l_'))
i = 2
self.l_legJoints = l_legJoints_raw[:i + 1]
l_footJointsRaw = l_legJoints_raw[2 + 1:]
self.l_footJoints = []
for i in l_footJointsRaw:
if pm.nodeType(i) == 'joint':
self.l_footJoints.append(i)
self.l_leg_ikHandle = pm.ikHandle(n='ik_l_leg',
sj=self.l_legJoints[0],
ee=self.l_legJoints[-1],
sol='ikRPsolver')
self.r_leg_ikHandle = pm.ikHandle(n='ik_r_leg',
sj=self.r_legJoints[0],
ee=self.r_legJoints[-1],
sol='ikRPsolver')
def generateHands(self, _wristTwist=False):
# TODO: orient hand bone away from elbow
self.r_hand = []
self.r_thumbJoints = []
self.r_indexJoints = []
self.r_midJoints = []
self.r_ringJoints = []
self.r_pinkyJoints = []
delta = self.loc_r_hand.t.get()
localPos = self.loc_r_hand.localPosition.get()
self.r_hand = pm.joint(p=delta + localPos, n='bind_r_hand')
pm.parent(self.r_hand, self.r_armJoints[-1])
self.r_hand.jointOrient.set(0, 0, 0)
self.r_thumbJoints = self.generateFinger(self.handLocators[1],
self.handLocators[2], 'thumb',
'r', 1)
self.r_indexJoints = self.generateFinger(self.handLocators[3],
self.handLocators[4], 'index',
'r')
self.r_midJoints = self.generateFinger(self.handLocators[5],
self.handLocators[6], 'mid',
'r')
self.r_ringJoints = self.generateFinger(self.handLocators[7],
self.handLocators[8], 'ring',
'r')
self.r_pinkyJoints = self.generateFinger(self.handLocators[9],
self.handLocators[10],
'pinky', 'r')
pm.parent(self.r_thumbJoints[0], self.r_hand)
pm.parent(self.r_indexJoints[0], self.r_hand)
pm.parent(self.r_midJoints[0], self.r_hand)
pm.parent(self.r_ringJoints[0], self.r_hand)
pm.parent(self.r_pinkyJoints[0], self.r_hand)
self.r_arm_ikHandle = pm.ikHandle(n='ik_r_arm',
sj=self.r_armJoints[1],
ee=self.r_armJoints[3],
sol='ikRPsolver')
self.l_armJoints = pm.mirrorJoint(self.r_armJoints[0],
mb=1,
mxy=1,
sr=('_r_', '_l_'))
self.l_arm_ikHandle = pm.ikHandle(n='ik_l_arm',
sj=self.l_armJoints[1],
ee=self.l_armJoints[3],
sol='ikRPsolver')
self.l_hand = self.l_armJoints[4]
self.l_thumbJoints = self.l_armJoints[5:8]
self.l_indexJoints = self.l_armJoints[8:12]
self.l_midJoints = self.l_armJoints[12:16]
self.l_ringJoints = self.l_armJoints[16:20]
self.l_pinkyJoints = self.l_armJoints[20:24]
if _wristTwist:
twistEnds = []
twistEnds.append(self.l_armJoints[2])
twistEnds.append(self.l_armJoints[3])
self.generateTwistSystem(twistEnds, self.l_hand)
twistEnds = []
twistEnds.append(self.r_armJoints[2])
twistEnds.append(self.r_armJoints[3])
self.generateTwistSystem(twistEnds, self.r_hand, True)
def test_nonUniqueName(self):
cmds.file(f=1, new=1)
j1 = cmds.createNode('joint', name='j1')
j2 = cmds.createNode('joint', name='j2', parent=j1)
j3 = cmds.createNode('joint', name='j3', parent=j2)
j4 = cmds.createNode('joint', name='j4', parent=j3)
cmds.select(j1, j4)
ikh1 = pm.ikHandle(name='ikh')
self.assertEqual(len(ikh1), 2)
self.assertTrue(isinstance(ikh1[0], pm.nt.IkHandle))
self.assertTrue(isinstance(ikh1[1], pm.nt.IkEffector))
self.assertEqual(ikh1[0].nodeName(), 'ikh')
pm.group(ikh1, name='theGroup')
self.assertEqual(cmds.ls('*ikh', long=True), ['|theGroup|ikh'])
j3 = cmds.createNode('joint', name='j3')
j4 = cmds.createNode('joint', name='j4', parent=j3)
cmds.select(j3, j4)
ikh2 = pm.ikHandle(name='ikh')
self.assertEqual(len(ikh2), 2)
self.assertTrue(isinstance(ikh2[0], pm.nt.IkHandle))
self.assertTrue(isinstance(ikh2[1], pm.nt.IkEffector))
self.assertEqual(ikh2[0].nodeName(), 'ikh')
def main():
prefRun()
center = pm.ikHandle(name="centerIK", startJoint="center1", endEffector="center13", sol="ikSplineSolver",ns=3)
left = pm.ikHandle(name="leftIK", startJoint="left1", endEffector="left13", sol="ikSplineSolver",ns=3)
right = pm.ikHandle(name="rightIK", startJoint="right1", endEffector="right13", sol="ikSplineSolver",ns=3)
pm.rename(center[2], "center_crv")
pm.rename(left[2], "left_crv")
pm.rename(right[2], "right_crv")
clusterGrp_center = clusterCurve("center_crv")
clusterGrp_left = clusterCurve("left_crv")
clusterGrp_right = clusterCurve("right_crv")
pm.connectAttr("jacketRight1.rz", clusterGrp_right+".rz")
pm.connectAttr("jacketLeft1.rz", clusterGrp_left+".rz")
pm.parent("center_crv", "rig")
pm.parent("left_crv", "rig")
pm.parent("right_crv", "rig")
pm.parent(clusterGrp_center, "world_ctrl")
pm.parent(clusterGrp_left, "world_ctrl")
pm.parent(clusterGrp_right, "world_ctrl")
for i in ["centerIK", "leftIK", "rightIK"]:
pm.setAttr(i+".visibility", 0)
pm.parent(i, "rig")
for i in ['center_crv','left_crv','right_crv','center_crv_cv0_loc', 'left_crv_cv0_loc', 'right_crv_cv0_loc', 'pageTargets_grp', 'pages_grp', 'jacket_grp']:
pm.setAttr(i+".visibility", 0)
def bdRigIkArm(side):
ikChain = bdBuildDrvChain(side, 'IK')
armIk = pm.ikHandle(sol='ikRPsolver',
sticky='sticky',
startJoint=ikChain[0],
endEffector=ikChain[2],
name=side + '_hand_ikHandle')[0]
handIk = pm.ikHandle(sol='ikSCsolver',
sticky='sticky',
startJoint=ikChain[2],
endEffector=ikChain[3],
name=side + '_palm_ikHandle')[0]
ikHandlesGrp = pm.group([armIk, handIk], n=side + '_hand_ikHandles_GRP')
wristPos = ikChain[2].getTranslation(space='world')
ikHandlesGrp.setPivots(wristPos)
'''
pvAnim = pm.ls(side + '_elbow_ik_anim', type='transform')[0]
if pvAnim:
pm.poleVectorConstraint(pvAnim,armIk[0])
'''
ikAnimCtrl = pm.ls(side + '_Hand_IK_CON', type='transform')[0]
pm.parentConstraint(ikAnimCtrl, ikHandlesGrp, mo=True)
def rig_ik(self):
self.ik_joints = self.create_chain(rn.IK)
self.create_chain_ctrls(rn.IK)
extra_jnt = pm.duplicate(self.ik_joints[-1])[0]
extra_jnt.rename(self.ik_joints[-1].name() + '_palm')
pm.parent(extra_jnt, self.ik_joints[-1])
extra_jnt.translateX.set(4 * self.side_sign)
self.ik_joints.append(extra_jnt)
pm.parent(self.ik_joints[0], self.rig_grp)
# Create Iks
arm_ik = pm.ikHandle(sol='ikRPsolver',
sticky='sticky',
startJoint=self.ik_joints[0],
endEffector=self.ik_joints[2],
name=self.side + '_arm_ikHandle')[0]
hand_ik = pm.ikHandle(sol='ikSCsolver',
sticky='sticky',
startJoint=self.ik_joints[2],
endEffector=self.ik_joints[3],
name=self.side + '_palm_ikHandle')[0]
pm.select(cl=1)
iks_grp = pm.group(n=self.side + '_arm_ikHandles_grp')
iks_grp.visibility.set(0)
wrist_pos = self.ik_joints[2].getTranslation(space='world')
iks_grp.setPivots(wrist_pos)
pm.parent([arm_ik, hand_ik], iks_grp)
pm.poleVectorConstraint(self.ik_ctrls[1], arm_ik)
pm.parent(iks_grp, self.ik_ctrls[0])
def reverseConstraint():
#redefining controllers
ikRH = pm.ls('ik_Hand_R')[0]
ikLH = pm.ls('ik_Hand_L')[0]
ikRFoot = pm.ls('ik_Foot_R')[0]
ikLFoot = pm.ls('ik_Foot_L')[0]
COG = pm.ls('COG')[0]
pvRElb = pm.ls('pv_RightElbow')[0]
pvLElb = pm.ls('pv_LeftElbow')[0]
pvRKnee = pm.ls('pv_RightKnee')[0]
pvLKnee = pm.ls('pv_LeftKnee')[0]
contrList = [
ikRH, ikLH, ikRFoot, ikLFoot, COG, pvRElb, pvLElb, pvRKnee, pvLKnee
]
contrDict = {
ikRH: 'Character1_Ctrl_RightWristEffector',
ikLH: 'Character1_Ctrl_LeftWristEffector',
ikRFoot: 'Character1_Ctrl_RightAnkleEffector',
ikLFoot: 'Character1_Ctrl_LeftAnkleEffector',
COG: 'Character1_Ctrl_HipsEffector',
pvRElb: 'Character1_Ctrl_RightForeArm',
pvLElb: 'Character1_Ctrl_LeftForeArm',
pvRKnee: 'Character1_Ctrl_RightLeg',
pvLKnee: 'Character1_Ctrl_LeftLeg'
}
resetCharTPose()
#set up IKs
ikHandleRH = pm.ikHandle(name='ikHandleRightHand',
sj='Character_RightArm',
ee='Character_RightHand',
solver='ikSCsolver')[0]
ikHandleLH = pm.ikHandle(name='ikHandleLeftHand',
sj='Character_LeftArm',
ee='Character_LeftHand',
solver='ikSCsolver')[0]
ikHandleRF = pm.ikHandle(name='ikHandleRightFoot',
sj='Character_RightUpLeg',
ee='Character_RightFoot',
solver='ikSCsolver')[0]
ikHandleLF = pm.ikHandle(name='ikHandleLeftFoot',
sj='Character_LeftUpLeg',
ee='Character_LeftFoot',
solver='ikSCsolver')[0]
#pm.parentConstraint('ik_Hand_R', 'ikHandle2', mo = True)#
pm.parentConstraint(ikRH, 'ikHandleRightHand', mo=True) #
pm.parentConstraint(ikLH, 'ikHandleLeftHand', mo=True) #
pm.parentConstraint(ikRFoot, 'ikHandleRightFoot', mo=True) #
pm.parentConstraint(ikLFoot, 'ikHandleLeftFoot', mo=True) #
pm.parentConstraint(COG, 'Character_Hips', mo=True)
#pm.parentConstraint(ikRFoot, 'Character_RightFoot', mo = True)#
#pm.parentConstraint(ikLFoot, 'Character_LeftFoot', mo = True)#
'''
def change_spline_ik_curve(ikHandle, new_curve):
'''
'''
old_curve = pm.PyNode(pm.PyNode(ikHandle).getCurve()).getParent().name()
pm.ikHandle(ikHandle, e=True, c=new_curve)
pm.delete(old_curve)
pm.rename(new_curve, old_curve)
return True
def create_ik_spline(self, *args):
""" Creates an ik spline with ik ctrls from the start and end locators, with the given selection the names will
be neck,head and else. This uses the crv type, crv color, locator scale for the ctrl crvs. This uses joints from
the create_jnt_chain, and makes a spline ik handle with advanced twist attributes for every rotation.
:param args:
:return: None
"""
# create ik handle spline solver
pm.ikHandle(n='{}_iks'.format(self.name),
sj=self.jnt_chain[0],
ee=self.jnt_chain[int(self.number)],
sol='ikSplineSolver',
ns=1,
ccv=True)
# get the name for crv
ik_crv = '{}_ik_crv'.format(self.name)
# rename the ik spline handle crv
pm.rename(pm.listConnections('{}_iks'.format(self.name), t='shape'),
ik_crv)
# select the ik crv
pm.select(ik_crv, r=True)
# create a curve info
crv_info = pm.arclen(ik_crv, ch=True)
# rename the curve info
pm.rename(crv_info, '{}_ik_crv_info'.format(self.name))
# enable advanced twist controls in ik handle
pm.setAttr('{}_iks.dTwistControlEnable'.format(self.name), 1)
# more advanced twist option changes
pm.setAttr('{}_iks.dWorldUpType'.format(self.name), 4)
# creating the ik ctrls by using the ik_ctrl_wloc module
start_loc_name, start_ctrl_name, self.top_start_grp = ik_ctrl_wloc(
self.name, self.ik_ctrl_s_scale, self.jnt_chain[0], self.crv_type,
self.color_index)
end_loc_name, end_ctrl_name, self.top_end_grp = ik_ctrl_wloc(
self.name_end, self.ik_ctrl_e_scale,
self.jnt_chain[int(self.number)], self.crv_type, self.color_index)
pm.connectAttr('{}.worldMatrix[0]'.format(start_loc_name),
'{}_iks.dWorldUpMatrix'.format(self.name))
pm.connectAttr('{}.worldMatrix[0]'.format(end_loc_name),
'{}_iks.dWorldUpMatrixEnd'.format(self.name))
# get the span number form the ik crv spans and degrees
crv_cv = pm.getAttr(ik_crv + '.spans') + pm.getAttr(ik_crv + '.degree')
# get the position and create a locator to that position
for x in range(crv_cv):
source_node = pm.pointPosition(ik_crv + '.cv[{:d}]'.format(x))
target_loc = '{}_ik_{:d}_loc'.format(self.name, x)
loc_grp = create_loc(source_node, target_loc)
pm.connectAttr(('{}Shape.worldPosition[0]'.format(target_loc)),
('{}Shape.controlPoints[{}]'.format(ik_crv, x)))
if x < 2:
loc_grp.setParent(start_ctrl_name)
else:
loc_grp.setParent(end_ctrl_name)
def __init__(self, hipJnt, ankleJnt, ballJntList, toeEndJntList, doSmartFootRoll=True):
"""
Build footRoll on selected joints
:param hipJnt: str
:param ankleJnt: str
:param ballJntList: list
:param toeEndJntList: list
:param doSmartFootRoll: bool
"""
self.side = name.getSide(hipJnt)
self.ballIkHandleList = []
self.toeIkHandleList= []
self.prefixJnt1 = name.removeSuffix(hipJnt)
self.prefixJnt2 = name.removeSuffix(ankleJnt)
self.ankleIkHandle = pm.ikHandle( n=self.prefixJnt1+'_IKH', sj=hipJnt, ee=ankleJnt)[0]
for ballJnt in ballJntList:
ballJntParent = pm.ls(ballJnt)[0].getParent()
prefix = name.removeSuffix(ballJnt)
tmpBallIkHandle = pm.ikHandle( n=prefix+'Ball_IKH', sj=ballJntParent, ee=ballJnt)[0]
self.ballIkHandleList.append(tmpBallIkHandle)
for toeJnt, ballJnt in zip(toeEndJntList, ballJntList):
prefix = name.removeSuffix(toeJnt)
tmpToeIkHandle = pm.ikHandle(n=prefix+'Fng_IKH', sj=ballJnt, ee=toeJnt)[0]
self.toeIkHandleList.append(tmpToeIkHandle)
# set temporarily ON Sticky
self.setSticky(1)
self.peelHeel()
self.toeTap()
self.tippyToe()
if doSmartFootRoll:
frontRollLoc = self.prefixJnt2 + '_frontRoll_LOC'
backRollLoc = self.prefixJnt2 + '_backRoll_LOC'
innerRollLoc = self.prefixJnt2 + '_innerRoll_LOC'
outerRollLoc = self.prefixJnt2 + '_outerRoll_LOC'
self.frontRollGrp, self.backRollGrp, self.innerRollGrp, self.outerRollGrp = self.rollGroups(frontRollLoc,
backRollLoc,
innerRollLoc,
outerRollLoc)
else:
self.frontRollGrp, self.backRollGrp, self.innerRollGrp, self.outerRollGrp = [None, None, None, None]
self.moveGrp()
# set OFF Sticky
self.setSticky(0)
def jointChainToDynamicChain( nodes=[] ):
if nodes:
pm.select(nodes)
nodes = pm.ls(sl=True)
# get joints
joints = pm.ls(sl=True, type='joint')
if not joints:
raise
crv = findSplineIKCrv( joints )[0]
hdl = findIKHandle( joints )[0]
pocs = crv.getShape().listHistory( future=True, type='pointOnCurveInfo' )
#
# makeDymicChain
#
outputCurve, follicle, hairSystem, nucleus = makeCurvesDynamic( crv )
#
# 일정간격 유지를 위해 커브 리빌드
#
rdbCrv, rbd = pm.rebuildCurve(
outputCurve,
ch=True,
replaceOriginal=False,
rebuildType=0, # uniform
endKnots=1, # 0 - uniform end knots, 1 - multiple end knots
keepRange=0, # 0 - reparameterize the resulting curve from 0 to 1, 1 - keep the original curve parameterization, 2 - reparameterize the result from 0 to number of spans
keepControlPoints=False,
keepEndPoints=True,
keepTangents=True,
spans=100,
degree=3,
tol=0.001
)
#
# ik핸들 커브 변경
#
pm.ikHandle( hdl, e=True, curve=outputCurve )
#
# pointOnCurveInfo 변경
#
for poc in pocs:
rdbCrv.worldSpace[0] >> poc.inputCurve
pm.select(outputCurve)
def attach_to_skeleton(self, target_skeleton_dict):
side = self.network['component'].node.side.get()
region = self.network['component'].node.region.get()
target_root = target_skeleton_dict[side][region]['root']
target_end = target_skeleton_dict[side][region]['end']
target_chain = rigging.skeleton.get_joint_chain(
target_root, target_end)
target_chain = rigging.skeleton.sort_chain_by_hierarchy(target_chain)
control_chain = self.get_control_dict()['reverse_fk']
control_chain = rigging.skeleton.sort_chain_by_hierarchy(control_chain)
control_chain.reverse()
# re-zero for binding so we can do mo=True without capturing a random rotation from the animation
skeleton_chain = self.network['skeleton'].get_connections()
rigging.skeleton.zero_character(self.skel_root, ignore_rigged=False)
rigging.rig_base.Component_Base.zero_all_rigging(
self.network['character'])
rigging.skeleton.zero_skeleton_joints(skeleton_chain)
constraint_list = []
maya_utils.node_utils.force_align(target_chain[-3], control_chain[-3])
constraint_list.append(
pm.orientConstraint(target_chain[0], control_chain[0], mo=True))
constraint_list.append(
pm.pointConstraint(target_chain[0], control_chain[0], mo=True))
constraint_list.append(
pm.orientConstraint(target_chain[-3], control_chain[-3], mo=True))
constraint_list.append(
pm.pointConstraint(target_chain[-3], control_chain[-3], mo=True))
ik_handle, end_effector = pm.ikHandle(
sj=control_chain[-2],
ee=control_chain[-1],
sol='ikSCsolver',
name="{0}_{1}_ball_retarget_ikHandle".format(side, region))
constraint_list.append(ik_handle)
ik_handle.setParent(target_chain[-1])
ik_handle, end_effector = pm.ikHandle(
sj=control_chain[-3],
ee=control_chain[-2],
sol='ikSCsolver',
name="{0}_{1}_toe_retarget_ikHandle".format(side, region))
constraint_list.append(ik_handle)
ik_handle.setParent(target_chain[-2])
return constraint_list
def identify_joints(self, ik_handle):
end_effector = pm.ikHandle(ik_handle, q=True, endEffector=True)
end_joint = self.rm.custom_pick_walk(end_effector,
1,
maya_node_type='joint',
direction="up")
end_joint = self.rm.custom_pick_walk(end_joint[len(end_joint) - 1],
1,
direction="down")
end_joint = end_joint[1]
start_joint = pm.ikHandle(ik_handle, q=True, startJoint=True)
[
self.joints.append(each)
for each in self.rm.find_in_hierarchy(start_joint, end_joint)
]
def _build(self, *args):
"""
Builds the joints on the curve.
"""
# naming convention
asset = self.asset
side = self.side
part = self.part
joints = self.joints
suffix = self.suffix
if self.gui:
asset = self.asset_name.text()
side = self.side.currentText()
part = self.part_name.text()
joints = self.joints_box.value()
suffix = self.suffix.currentText()
try:
curve = pm.ls(sl=True)[0]
curve_name = NameUtils.get_unique_name(asset, side, part, "crv")
self.curve = pm.rename(curve, curve_name)
except IndexError:
pm.warning("Please select a curve")
return
length_of_curve = pm.arclen(self.curve)
equal_spacing = length_of_curve / float(joints)
# clear the selection
pm.select(cl=True)
# # create the joints
curve_joints = list()
for x in xrange(int(joints) + 1):
name = NameUtils.get_unique_name(asset, side, part, suffix)
joint = pm.joint(n=name)
curve_joints.append(joint)
joint_position = (x * equal_spacing)
pm.move(0, joint_position, 0)
# rename last joint
last_joint = curve_joints[-1]
pm.rename(last_joint, last_joint + "End")
root_joint = pm.selected()[0].root()
end_joint = pm.ls(sl=True)[0]
solver = 'ikSplineSolver'
# attach joints to curve
ik_name = NameUtils.get_unique_name(asset, side, part, "ikHandle")
self.ikHandle = pm.ikHandle(sj=root_joint, ee=end_joint, sol=solver,
c=self.curve, pcv=True, roc=True, ccv=False, n=ik_name)
joint_chain = pm.ls(root_joint, dag=True)
# delete history
pm.makeIdentity(root_joint, apply=True)
# cleanup
self._cleanup()
def buildIK(self, *args):
"""
Build the IK
"""
#Setup variables
if self.normal == 1:
self.normal = (1, 0, 0)
if self.normal == 2:
self.normal = (0, 1, 0)
if self.normal == 3:
self.normal = (0, 0, 1)
#Create IK control
self.ikControl = pm.circle(nr=self.normal, r=self.radius, n='%s_ikCnt'%self.prefix)
pm.select(self.ikControl[0], r=True)
pm.mel.eval("DeleteHistory;")
pm.delete( pm.parentConstraint(self.ikChain[2], self.ikControl[0], mo=0) )
self.zero(self.ikControl[0])
#Create RP IK
self.arm_ikHandle = pm.ikHandle(sj=self.ikChain[0], ee=self.ikChain[2], solver='ikRPsolver', name=(self.prefix + '_armIkHandle'))
pm.setAttr(self.arm_ikHandle[0] + '.visibility', 0)
#Parent IK Handle to the ikWrist_cnt
pm.parent(self.arm_ikHandle[0], self.ikControl[0])
# Creates: self.pv_cnt
self.createPoleVector()
def buildIkCtrlSetup(self, side):
"""
Builds IK control for the limb. Create a controller and it places the controller to the right place
and create the pole vector and the constrains plus connections
:param side: string - 'L' or 'R'
"""
ikCtrl = self.placeCtrl(self.endJoint, type='ik')
if not self.limbPart == 'leg':
pm.delete(pm.orientConstraint(self.endJoint, ikCtrl, mo=True))
# create ik handle and pole vector for the IK limb
ikh = pm.ikHandle(name=side + '_' + self.limbPart + '_limb_ikh', sj=self.startJoint.replace('_jnt', '_IK_jnt'),
ee=self.endJoint.replace('_jnt', '_IK_jnt'), sol='ikRPsolver')[0]
rigUtils.setControlColor(ikCtrl)
self.placePoleVectorCtrl((self.startJoint, self.midJoint, self.endJoint))
pm.poleVectorConstraint(self.poleVectCtrl, ikh)
# End limb control constraint
# pm.parentConstraint(ikCtrl, ikh)
if self.limbPart == 'arm':
pm.parent(self.side + '_arm_limb_ikh', self.side + '_arm_ik_ctrl')
else:
pm.parent(self.side + '_leg_limb_ikh', self.side + '_leg_ik_ctrl')
rigUtils.hideAttributes(ikCtrl, trans=False, scale=True, rot=False, vis=True, radius=False)
rigUtils.hideAttributes(self.poleVectCtrl, trans=False, scale=True, rot=True, vis=True, radius=False)
def make_ikh(self,
solver="ikRPsolver",
start=0,
end=-1,
name=None,
num_spans=5):
"""
makes IKH
"""
ending = "solver_IKH"
if name:
ending = name
name = "_".join(self[0].split("_")[:2] + [ending])
kwargs = {
"solver": solver,
"startJoint": self[start],
"endEffector": self[end],
"name": name
}
if solver == "ikSplineSolver":
kwargs.update({"numSpans": num_spans - 3})
ikh = pm.ikHandle(**kwargs)
handle = ikh[0]
return handle
def __init__(self, spine_jnt, shoulder_jnt, scapulaShoulder_jnt):
"""
Create scapula IK
:param spine_jnt: str
:param shoulder_jnt: str
:param scapulaShoulder_jnt: str
"""
# get side and name
side = name.getSide(scapulaShoulder_jnt)
# get childern of shoulder
scapula_jnt = pm.listRelatives(scapulaShoulder_jnt, type='joint')[0]
# create ik
ikhandle = pm.ikHandle(n=side + 'scapula_IKH',
sj=scapulaShoulder_jnt,
ee=scapula_jnt)
effector = pm.listConnections(ikhandle[0].endEffector, source=True)
# group ik
grpName = name.removeSuffix(side + 'scapula_GRP')
self.scapulaGrp = pm.group(ikhandle, n=grpName)
# parent constraint group
pm.parentConstraint(spine_jnt, self.scapulaGrp, mo=True)
# parent constraint only transform
pm.parentConstraint(shoulder_jnt,
scapulaShoulder_jnt,
skipRotate=['x', 'y', 'z'],
mo=True)
# parent effector
pm.parent(effector, scapulaShoulder_jnt)
def addJointChainToCVs(crv, startCV, endCV):
'''
add one joint for each cv in crv.cvs[startCV:endCV]
'''
cvsPts = crv.getCVs()
pm.select(cl=True)
allJnts = []
for cvId, cvPt in enumerate(cvsPts[startCV:endCV]):
closestPt = crv.closestPoint(cvPt)
jnt = pm.joint(n=crv.name()+'_jnt_%d'%cvId)
jnt.setTranslation(closestPt, space='world')
allJnts.append(jnt)
pm.ikHandle(sj=allJnts[0], ee=allJnts[-1], curve=crv,
sol='ikSplineSolver', createCurve=False,
n=crv.name()+'ikH')
def ikSetup(self):
@changeColor('index', col=self.col_layer1)
@lockAttr(['sx', 'sy', 'sz'])
def create_ik_ctrl():
self.nameStructure['Suffix'] = NC.CTRL
self.shoulder_ik_ctrl_class = Control.Control(
name='{Side}__{Basename}_{Parts[1]}__{Suffix}'.format(
**self.nameStructure),
shape=sl.sl[self.config['CONTROLS']['Shoulder']['shape']],
scale=self.config['CONTROLS']['Shoulder']['scale'],
matchTransforms=(self.shoulder_joint, 1, 0),
parent=self.shoulder_MOD.INPUT_GRP)
self.shoulder_ik_ctrl = self.shoulder_ik_ctrl_class.control
adb.makeroot_func(self.shoulder_ik_ctrl,
suff='Offset',
forceNameConvention=True)
return self.shoulder_ik_ctrl
create_ik_ctrl()
self.nameStructure['Suffix'] = NC.IKHANDLE_SUFFIX
shoulder_IkHandle, shoulder_IkHandle_effector = pm.ikHandle(
n='{Side}__{Basename}__{Suffix}'.format(**self.nameStructure),
sj=self.clavicule_joint,
ee=self.shoulder_joint)
shoulder_IkHandle.v.set(0)
pm.parent(shoulder_IkHandle, self.shoulder_ik_ctrl)
pm.parentConstraint(self.clavicule_ctrl,
self.shoulder_ik_ctrl.getParent(),
mo=1)
adb.breakConnection(self.shoulder_ik_ctrl.getParent(),
['rx', 'ry', 'rz'])
def buildIK(self, *args):
"""
Build the IK
"""
#Setup variables
if self.normal == 1:
self.normal = (1, 0, 0)
if self.normal == 2:
self.normal = (0, 1, 0)
if self.normal == 3:
self.normal = (0, 0, 1)
#Create IK control
self.ikControl = pm.circle(nr=self.normal,
r=self.radius,
n='%s_ikCnt' % self.prefix)
pm.select(self.ikControl[0], r=True)
pm.mel.eval("DeleteHistory;")
pm.delete(pm.parentConstraint(self.ikChain[2], self.ikControl[0],
mo=0))
self.zero(self.ikControl[0])
#Create RP IK
self.arm_ikHandle = pm.ikHandle(sj=self.ikChain[0],
ee=self.ikChain[2],
solver='ikRPsolver',
name=(self.prefix + '_armIkHandle'))
pm.setAttr(self.arm_ikHandle[0] + '.visibility', 0)
#Parent IK Handle to the ikWrist_cnt
pm.parent(self.arm_ikHandle[0], self.ikControl[0])
# Creates: self.pv_cnt
self.createPoleVector()
def SnapIK(ctrlJoints):
for ctrl in ctrlJoints:
# Snap IK controller to joint
newPos = pm.dt.Vector(pm.xform(ctrlJoints[ctrl], rotatePivot=True, q=True, worldSpace=True))
initialPos = pm.dt.Vector(pm.xform(ctrl, rotatePivot=True, q=True, worldSpace=True)) - \
pm.dt.Vector(pm.xform(ctrl, translation=True, q=True, worldSpace=True))
pm.xform(ctrl, translation=newPos-initialPos, worldSpace=True)
try:
pm.getAttr(str(ctrl) + ".childIK")
except:
continue
else:
handle = pm.getAttr(str(ctrl) + ".childIK")
snapCtrl = pm.getAttr(str(handle) + ".snapController")
if not snapCtrl:
print("No snap controller has been set for IK handle {}".format(str(handle)))
continue
# Snap controller rotation
snapCtrlRot = pm.dt.TransformationMatrix(pm.xform(snapCtrl, worldSpace=True, matrix=True, q=True))
snapCtrlRotOffset = pm.dt.TransformationMatrix(pm.dt.EulerRotation(pm.getAttr(str(snapCtrl) + ".controllerRotOffset")))
ctrlRotOffset = pm.dt.TransformationMatrix(pm.dt.EulerRotation(pm.getAttr(str(ctrl) + ".controllerRotOffset")))
deltaMat = pm.dt.TransformationMatrix(snapCtrlRotOffset.asMatrixInverse() * snapCtrlRot)
newRot = (ctrlRotOffset * deltaMat).euler * 180 / math.pi
pm.xform(ctrl, rotation=newRot, worldSpace=True)
# Snap pole controller location
affectedJoints = pm.ikHandle(handle, q=True, jl=True)
poleCtrl = pm.getAttr(str(handle) + ".poleVectorController")
P0 = pm.dt.Vector(pm.xform(affectedJoints[0], rotatePivot=True, q=True, worldSpace=True))
P1 = pm.dt.Vector(pm.xform(affectedJoints[1], rotatePivot=True, q=True, worldSpace=True))
P2 = pm.dt.Vector(pm.xform(handle, rotatePivot=True, q=True, worldSpace=True))
P4 = pm.dt.Vector(pm.xform(poleCtrl, rotatePivot=True, q=True, worldSpace=True)) - \
pm.dt.Vector(pm.xform(poleCtrl, translation=True, q=True, worldSpace=True))
altP1 = pm.dt.Vector(pm.xform(snapCtrl, rotatePivot=True, q=True, worldSpace=True))
v0 = P2 - P1
v1 = P2 - P0
v2 = P1 - P0
altV2 = altP1 - P0
map(lambda x: x.normalize(), (v0, v1, v2, altV2))
# Find plane normal vectors
N1 = v1.cross(v2)
N2 = v1.cross(altV2)
map(lambda x: x.normalize(), (N1, N2))
# Find vector from the handle to the zero-translate pole vector controller
v3 = (N1.cross(v0) - v0).normal()
detMat = pm.dt.Matrix(N1, N2, N1.cross(N2).normal())
a = math.atan2(detMat.det3x3(), N1.dot(N2))
R1 = pm.dt.TransformationMatrix()
R1.setToRotationAxis(N1.cross(N2), -a)
P3 = R1 * v3 * pm.getAttr(str(handle) + ".poleVectorLength")
pm.xform(poleCtrl, translation=P2 + P3 - P4, worldSpace=True)
def ik_setup(side, data, joints, ctrl_parent, ik_parent):
prefix = '%s_%s' % (side, data['joints'][-1])
ik_handle = core.ikHandle(n='%s_ik_handle' % (prefix),
sj=joints[0],
ee=joints[-1],
s='sticy',
sol='ikRPsolver')
ik_handle[1].rename('%s_ik_effector' % (prefix))
control_name = '%s_ik_ctrl' % (prefix)
shape, group = control.create(control_name,
shape=data['control'],
raduis=data['radius'])
translate = core.xform(ik_handle[0], q=True, ws=True, t=True)
core.xform(group, ws=True, t=translate)
core.xform(group, ro=[0, 0, 0])
core.parentConstraint(shape,
ik_handle[0],
w=1,
n='%s_parent_constraint' % (prefix))
shape.addAttr('twist', at='double', dv=0, k=True)
shape.attr('twist').connect(ik_handle[0].attr('twist'))
generic.disable_attributes(shape, attributs=['sx', 'sy', 'sz', 'v'])
generic.disable_attributes(group, attributs=None)
group.setParent(ctrl_parent)
ik_handle[0].setParent(ik_parent)
def createSkinclusterAndSplineIk(self): #Skincluster #---------------------------------------------------- pm.select(cl = True) self.bound_curve_skincluster = pm.skinCluster( self.splineIkBoundJointsList , self.lowResCurveTrans ,tsb=True, n = self.prefix + '_bound_curve_skincluster', rui = False, ih = True) pm.select(cl = True) #Spline Ik #---------------------------------------------------- pm.select( cl = True ) #Create spline IK self.bound_curve_spline_ik = pm.ikHandle( sj= self.ikSplineJointsList[0] , ee= self.ikSplineJointsList[-1] , roc = True, n = self.prefix + '_ikSplineHandle_bound_curve', c = self.lowResCurveTrans, ccv = False, pcv = False, sol = 'ikSplineSolver' )[0] pm.select( cl = True ) #Group Spline_ik self.bound_curve_spline_ik_grp = pm.group(self.bound_curve_spline_ik , n= self.prefix + '_ikSplineHandle_bound_curve_grp' ) pm.select(cl = True)
def create_chain_for_curve(self, crv, obj=None, link_length=1):
"""
Uses the Curve and creates a chain based on the object that is passed into the function
crv = curve to be used
obj = object to be used
linklength = lenght of the obj
"""
if obj is None:
obj = self.create_link()
link_length = (2*(self.radius - self.section_radius*2)+self.extrude)
chain_length = int(pm.PyNode(crv).length()/link_length)
chain = self.make_chain(obj=obj, link_length=link_length, chain_length=chain_length)
joints = self.rig_chain(chain)
ik = pm.ikHandle(startJoint=joints[0], endEffector=joints[-1], solver='ikSplineSolver', createCurve=False, curve=crv)[0]
pm.rename(ik, self.name + "_ikHandle")
control_group = pm.group(joints[0], ik, n="%sctrl_grp" % self.name)
control_group.v.set(False)
pm.group(crv, self.name, control_group, n="%s_grp" % self.name)
self.add_cluster_handles(crv)
pm.select(deselect=True)
return self.name
def RigHand( butLimbJnt, endLimbJnt, father ): side = butLimbJnt.name()[0] handIKStuff = pm.ikHandle( sj = butLimbJnt, ee = endLimbJnt, solver = "ikSCsolver" ) handIK = pm.rename ( handIKStuff[0] , ( side + "_hand_ikh") ) pm.parent( handIK, father ) father.scale >> butLimbJnt.scale LockHideAttr( objs = handIKStuff, attr='vv' )
def createIk(self):
#create the curve for the ik
ikCrv = pm.duplicate(self.crv)
ikCrv = pm.rebuildCurve(ikCrv[0],
ch=0,
rpo=1,
rt=0,
end=1,
kr=0,
kcp=0,
kep=1,
kt=0,
s=self.numCtrl - 1,
d=3,
tol=0)[0]
ikCrv.rename(self.name + '_ik_crv')
self.ikCrv = ikCrv
#create the ik
self.ikHandle = pm.ikHandle(sj=self.ikJntList[0],
ee=self.ikJntList[-1],
c=ikCrv,
ccv=False,
sol='ikSplineSolver',
name=self.name + '_crv_ik')[0]
pm.select(cl=1)
pm.parent(self.ikHandle, self.mainGrp)
pm.parent(self.ikCrv, self.mainGrp)
pm.select(cl=1)
def RigSingleChain( startJnt, endJnt, father ): side = startJnt.name()[0] IKStuff = pm.ikHandle( sj = startJnt, ee = endJnt, solver = "ikSCsolver" ) IK = pm.rename ( IKStuff[0] , ( side + "_sc_ikh") ) pm.parent( IK, father ) father.scale >> startJnt.scale GNL.lockHideAttr.LockHideAttr( objs = IKStuff, attr='vv' )
def wiggleJointChain(strPnt, endPnt, side='FL', chainPos='Upper'):
'''
create joint chain between two points (strPnt & endPnt). require name string of strPnt & endPnt
'''
strPos = pm.xform( strPnt, q=True, ws=True, translation=True )
endPos = pm.xform( endPnt, q=True, ws=True, translation=True )
if side.endswith('L'):
sideLabel = 1
elif side.endswith('R'):
sideLabel = 2
ikSpCrv = pm.curve( degree=2, editPoint=( strPos, endPos) )
ikSpCrv.rename( 'wiggle_%s_%s_CRV'%(side, chainPos) )
ikSpCrvShp = ikSpCrv.listRelatives(shapes=True)[0]
pm.select(clear=True)
jnt2pos = pm.pointOnCurve( ikSpCrv, pr=0.3333, turnOnPercentage=True)
jnt3pos = pm.pointOnCurve( ikSpCrv, pr=0.6667, turnOnPercentage=True )
jntPos = ( strPos, jnt2pos, jnt3pos, endPos )
jntList = []
for pnt in jntPos:
jName = 'Wiggle_%s_%s_%02d'%(side, chainPos, jntPos.index(pnt)+1)
newJoint = pm.joint(name=jName, p=pnt)
newJoint.side.set(sideLabel)
newJoint.__getattr__('type').set(18)
newJoint.otherType.set(jName)
jntList.append(newJoint)
pm.joint( jntList[0], edit=True, orientJoint='xyz', secondaryAxisOrient='xup', children=True, zeroScaleOrient=True )
ikHandle = pm.ikHandle( name='Wiggle_%s_%s_ikHandle'%(side, chainPos),
solver='ikSplineSolver',
createCurve=False,
curve=ikSpCrvShp,
startJoint=jntList[0].name(),
endEffector=jntList[-1].name(),
rootOnCurve=False,
createRootAxis=True,
parentCurve=False )
jntGrp = jntList[0].listRelatives(parent=True)[0]
jntGrp.rename('Wiggle_%s_%s'%(side, chainPos))
crvInfo = pm.createNode('curveInfo', name='crvInf_wiggle_%s_%s'%(side, chainPos))
multDiv1 = pm.createNode('multiplyDivide', name='md_wiggle_%s_%s_01'%(side, chainPos))
multDiv2 = pm.createNode('multiplyDivide', name='md_wiggle_%s_%s_02'%(side, chainPos))
ikSpCrvShp.worldSpace >> crvInfo.inputCurve
arcLgt = crvInfo.arcLength.get()
multDiv1.input2X.set(arcLgt)
multDiv1.operation.set(2)
spacing = jntList[1].tx.get()
multDiv2.input2X.set(spacing)
multDiv1.outputX >> multDiv2.input1X
crvInfo.arcLength >> multDiv1.input1X
for jnt in jntList[1:]:
multDiv2.outputX >> jnt.tx
return ikSpCrvShp, ikSpCrv, ikHandle[0], jntGrp
def build(self):
self.joints = u.placeJointChain(
startLoc = self.startLoc,
endLoc = self.endLoc,
numJoints = self.numJoints,
parent = None,
name = self.name)
self.joints[0].setAttr('visibility', False)
self.ikHandle, self.ikEffector, self.ikCrv = pm.ikHandle(
startJoint = self.joints[0],
endEffector = self.joints[-1],
name = self.name + '_' + d.IK_HANDLE,
solver = 'ikSplineSolver')
self.ikCrv = pm.PyNode(self.ikCrv)
self.ikHandle = pm.PyNode(self.ikHandle)
self.ikHandle.inheritsTranform = False
self.ikHandle.setAttr('visibility',False)
self.ikCrv.rename(self.name + '_' + d.CURVE)
self.ikCrv.setAttr('visibility',False)
pm.rebuildCurve(self.ikCrv,
degree = 3,
spans = self.numSpans,
keepRange = 0,
constructionHistory = False)
def createIKSpline( jntList ):
pymelLogger.debug('Starting: createIKSpline()...')
# Make IK Spline
ikHandleTorso = pm.ikHandle( startJoint=jntList[0], endEffector=jntList[-1], solver = 'ikSplineSolver', numSpans = 4, name = jntList[-1]+'_'+Names.suffixes['ikhandle'])
# we should probably rename the object created to know names ......
# CAREFULL // inherits Transform OFF, to avoid double transformation when grouped later on
pm.setAttr(ikHandleTorso[2] + '.inheritsTransform', 0)
# Duplicate last and first joint to use as Drivers of the spine Ik curve
print jntList
drvStart = pm.duplicate(jntList[0], parentOnly=True, name = Names.prefixes['driver']+'_'+ jntList[0] +'_'+Names.suffixes['start'])
drvEnd = pm.duplicate(jntList[-1], parentOnly=True, name = Names.prefixes['driver']+'_'+ jntList[-1] +'_'+Names.suffixes['end'])
pm.parent(drvEnd, w=1)
# Make radius bigger
pm.joint(drvStart, edit = True, radius = 1)
pm.joint(drvEnd, edit = True, radius = 1)
# Skin hip/shldr jnt's to back curve
pm.skinCluster(drvStart,drvEnd,ikHandleTorso[2],dr=4)
# return nedded elements
rList = [ikHandleTorso, drvStart, drvEnd ]
pymelLogger.debug('End: createIKSpline()...')
return rList
def RigHand(startJnt, endJnt, father):
side = startJnt.name()[0]
handIKStuff = pm.ikHandle(sj=startJnt, ee=endJnt, solver="ikSCsolver")
handIK = pm.rename(handIKStuff[0], (side + "_sc_ikh"))
pm.parent(handIK, father)
father.scale >> startJnt.scale
LockHideAttr(objs=handIKStuff, attrs='vv')
def RigHand( startJnt, endJnt, father ): side = startJnt.name()[0] handIKStuff = pm.ikHandle( sj = startJnt, ee = endJnt, solver = "ikSCsolver" ) handIK = pm.rename ( handIKStuff[0] , ( side + "_sc_ikh") ) pm.parent( handIK, father ) father.scale >> startJnt.scale LockHideAttr( objs = handIKStuff, attrs='vv' )
def autoPoleVector( baseJnt=None, endJnt=None, side='L' ): baseJntPos = pm.xform( baseJnt, q=True, t=True, ws=True ) endJntPos = pm.xform( endJnt, q=True, t=True, ws=True ) pm.select(clear=True) poleVectorJnt_one = pm.joint( p=baseJntPos ) poleVectorJnt_two = pm.joint( p=endJntPos ) poleVectorIKstuff = pm.ikHandle( sj = poleVectorJnt_one, ee = poleVectorJnt_two, solver = "ikSCsolver" ) pv = pm.spaceLocator() pv.setParent( poleVectorJnt_two ) pv.translate.set( 0,0,0 ) pvZeros = ZeroGrp( pv ) pm.pointConstraint( poleVectorIKstuff[0], pvZeros[0] ) if side=='L': pv.translateX.set( 1 ) elif side=='R': pv.translateX.set( -1 ) pvZeros[0].setParent( poleVectorJnt_two ) return ( pv, poleVectorIKstuff, (poleVectorJnt_one, poleVectorJnt_two) )
def _createFeatherJoint(self , jointList = None):
'''
@jointList : list , Thes is the jointList is joint list
'''
allIkHandle = []
if jointList is None:
OpenMaya.MGlobal_clearSelectionList('@jointList : This is the jointList is None : jointList = %s'%(jointList))
for index , value in enumerate(jointList):
handle , effector = pm.ikHandle( n = value[0].name() + "_ikHandle" , sj = value[0] , ee = value[1] , sol="ikRPsolver" )
OpenMaya.MGlobal_clearSelectionList()
allIkHandle.append(handle)
handleGroup = self._objectGroup(handle)
pm.parentConstraint(value[1].name().replace('addBack' , 'back') , handle , w = 1 , mo = 1)
pm.parent(handleGroup , self.featherIkHandGroup)
handleGroup.v.set(0)
name = value[0].name().replace('addFront', 'addFront_bottom')
jointGroup = self._PlumeJiont(value[0] , value[1] , name)
pm.parent(jointGroup , self.featherJointGroup)
pm.parentConstraint(value[0].name().replace('addFront' , 'front') , jointGroup , w = 1 , mo = 1)
self.frontIkHandList += allIkHandle
return allIkHandle
def splineIK(name, chn, parent=None, cParent=None, curve=None):
data = {}
data["n"] = name
data["solver"] = "ikSplineSolver"
data["ccv"] = True
data["startJoint"] = chn[0]
data["endEffector"] = chn[-1]
if curve is not None:
data["curve"] = curve
node, effector, splineCrv = pm.ikHandle(**data)
# converting to pyNode
node = pm.PyNode("|" + node)
effector = pm.PyNode(effector)
splineCrv = pm.PyNode(splineCrv)
node.setAttr("visibility", False)
splineCrv.setAttr("visibility", False)
pm.rename(splineCrv, name + "_crv")
pm.rename(effector, name + "_eff")
if parent is not None:
parent.addChild(node)
if cParent is not None:
cParent.addChild(splineCrv)
return node, splineCrv
def addIkHandle(parent, name, chn, solver="ikRPsolver", poleV=None):
"""
Creates and connect an IKhandle to a joints chain.
Args:
parent (dagNode): The parent for the IKhandle.
name (str): The node name.
chn (list): List of joints.
solver (str): the solver to be use for the ikHandel. Default value is "ikRPsolver"
poleV (dagNode): Pole vector for the IKHandle
Returns:
dagNode: The IKHandle
>>> self.ikHandleUpvRef = pri.addIkHandle(self.root, self.getName("ikHandleLegChainUpvRef"), self.legChainUpvRef, "ikSCsolver")
"""
# creating a crazy name to avoid name clashing before convert to pyNode.
node = pm.ikHandle(n=name + "kjfjfklsdf049r58420582y829h3jnf",
sj=chn[0],
ee=chn[-1],
solver=solver)[0]
node = pm.PyNode(node)
pm.rename(node, name)
node.attr("visibility").set(False)
if parent:
parent.addChild(node)
if poleV:
pm.poleVectorConstraint(poleV, node)
return node
def autoPoleVector(baseJnt=None, endJnt=None, side='L'):
baseJntPos = pm.xform(baseJnt, q=True, t=True, ws=True)
endJntPos = pm.xform(endJnt, q=True, t=True, ws=True)
pm.select(clear=True)
poleVectorJnt_one = pm.joint(p=baseJntPos)
poleVectorJnt_two = pm.joint(p=endJntPos)
poleVectorIKstuff = pm.ikHandle(sj=poleVectorJnt_one,
ee=poleVectorJnt_two,
solver="ikSCsolver")
pv = pm.spaceLocator()
pv.setParent(poleVectorJnt_two)
pv.translate.set(0, 0, 0)
pvZeros = ZeroGrp(pv)
pm.pointConstraint(poleVectorIKstuff[0], pvZeros[0])
if side == 'L':
pv.translateX.set(1)
elif side == 'R':
pv.translateX.set(-1)
pvZeros[0].setParent(poleVectorJnt_two)
return (pv, poleVectorIKstuff, (poleVectorJnt_one, poleVectorJnt_two))
def create_ikspline(self):
# if self.model.ik_creation_switch:
# self.ik_spline = pmc.rebuildCurve(self.guides[1], rpo=0, rt=0, end=1, kr=0, kep=1, kt=0,
# s=self.model.how_many_ctrls - 1, d=3, ch=0, replaceOriginal=0,
# n="{0}_ik_CRV".format(self.model.module_name))[0]
# else:
# self.ik_spline = pmc.duplicate(self.guides[1], n="{0}_ik_CRV".format(self.model.module_name))[0]
#
self.ik_spline = pmc.duplicate(self.guides[1],
n="{0}_ik_CRV".format(
self.model.module_name))[0]
ik_handle = pmc.ikHandle(n=("{0}_ik_HDL".format(
self.model.module_name)),
startJoint=self.created_spine_jnts[0],
endEffector=self.created_spine_jnts[-1],
solver="ikSplineSolver",
curve=self.ik_spline,
createCurve=False,
parentCurve=False)[0]
pmc.parent(self.ik_spline, self.parts_grp, r=1)
pmc.parent(ik_handle, self.parts_grp, r=1)
ik_effector = pmc.listRelatives(self.created_spine_jnts[-2],
children=1)[1]
ik_effector.rename("{0}_ik_EFF".format(self.model.module_name))
def _buildDrivers(name, xforms, controls, **kwargs):
ctrl_orient = kwargs.get('ctrl_orient', None)
# Create IK joints
joints = createNodeChain(xforms, node_func=partial(
pm.createNode, 'joint'), prefix='ikj_')
for joint in joints:
pm.makeIdentity(joint, apply=True)
# Place control curve
controls[0].getParent().setTransformation(xforms[-1].getMatrix(ws=True))
if ctrl_orient:
pm.rotate(controls[0].getParent(), ctrl_orient)
# Create IK chain
ik_handle, _ = pm.ikHandle(n="Ik_{}_handle".format(name),
sj=joints[0], ee=joints[-1])
ik_handle.setParent(controls[0])
# Constrain end driver joint
pm.orientConstraint(controls[0], joints[-1], mo=True)
# Hide intermediate nodes
for node in joints + [ik_handle]:
node.visibility.set(False)
return joints
def splineIK_jntsOnCrv(self, *args):
""" Build splineIK
Args:
None
Returns (None)
"""
new_crv_name = self.jntNameFeild.getText() + '_CRV'
splineIK_name = self.jntNameFeild.getText() + '_SIK'
splineIK_effectorName = self.jntNameFeild.getText() + '_EFF'
pm.select(self.joints[0], r=True)
pm.select(self.joints[-1], add=True)
pm.ikHandle(n=splineIK_name, sol='ikSplineSolver',c= new_crv_name, ccv=False, pcv=False)
splineIK_effector = self.joints[0].listRelatives(ad = True, type = 'ikEffector')
pm.rename(splineIK_effector, splineIK_effectorName)
pm.select(clear = True)
def createFootIkSplineIkTipAndBase(self): pm.select(cl = True) #foot_spline_ik_tip #---------------------------------------------------- self.foot_spline_ik_tip = pm.ikHandle( sj= self.foot_ik_tip_j_base , ee= self.foot_ik_tip_j_tip , roc = True, n = self.prefix + '_ik_spline_handle_tip', c = self.foot_splineIk_curve, ccv = False, pcv = False, sol = 'ikSplineSolver')[0] pm.select(cl = True) #set splineIk twist attributes pm.setAttr(self.foot_spline_ik_tip.dTwistControlEnable, 1) pm.setAttr(self.foot_spline_ik_tip.dWorldUpType, 3) pm.setAttr(self.foot_spline_ik_tip.dWorldUpAxis, 0) pm.setAttr(self.foot_spline_ik_tip.dWorldUpVectorX, 0) pm.setAttr(self.foot_spline_ik_tip.dWorldUpVectorY, 1) pm.setAttr(self.foot_spline_ik_tip.dWorldUpVectorZ, 0) pm.connectAttr(self.manip_foot_ik_tip.worldMatrix[0], self.foot_spline_ik_tip.dWorldUpMatrix, f = True) pm.select(cl = True) #Group Spline_ik self.foot_spline_ik_tip_grp = pm.group(self.foot_spline_ik_tip , n= self.prefix + '_foot_spline_ik_tip_grp' ) pm.select(cl = True) #foot_spline_ik_base #---------------------------------------------------- self.foot_spline_ik_base = pm.ikHandle( sj= self.foot_ik_base_j_base , ee= self.foot_ik_base_j_tip , roc = True, n = self.prefix + '_ik_spline_handle_base', c = self.foot_splineIk_curve, ccv = False, pcv = False, sol = 'ikSplineSolver')[0] pm.select(cl = True) #set splineIk twist attributes pm.setAttr(self.foot_spline_ik_base.dTwistControlEnable, 1) pm.setAttr(self.foot_spline_ik_base.dWorldUpType, 3) pm.setAttr(self.foot_spline_ik_base.dWorldUpAxis, 0) pm.setAttr(self.foot_spline_ik_base.dWorldUpVectorX, 0) pm.setAttr(self.foot_spline_ik_base.dWorldUpVectorY, 1) pm.setAttr(self.foot_spline_ik_base.dWorldUpVectorZ, 0) pm.connectAttr(self.manip_foot_ik_base.worldMatrix[0], self.foot_spline_ik_base.dWorldUpMatrix, f = True) pm.select(cl = True) #Group Spline_ik self.foot_spline_ik_base_grp = pm.group(self.foot_spline_ik_base , n= self.prefix + '_foot_spline_ik_base_grp' ) pm.select(cl = True)
def bdRigIkArm(side): ikChain = bdBuildDrvChain(side,'ik') armIk = pm.ikHandle(sol= 'ikRPsolver',sticky='sticky', startJoint=ikChain[0],endEffector = ikChain[2],name = side + '_hand_ikHandle')[0] handIk = pm.ikHandle(sol= 'ikSCsolver',sticky='sticky', startJoint=ikChain[2],endEffector = ikChain[3],name = side + '_palm_ikHandle')[0] ikHandlesGrp = pm.group([armIk,handIk],n=side + '_hand_ikHandles_GRP') wristPos = ikChain[2].getTranslation(space = 'world') ikHandlesGrp.setPivots(wristPos) ''' pvAnim = pm.ls(side + '_elbow_ik_anim', type='transform')[0] if pvAnim: pm.poleVectorConstraint(pvAnim,armIk[0]) ''' ikAnimCtrl = pm.ls(side + '_hand_ik_ctrl',type='transform')[0] pm.parentConstraint(ikAnimCtrl, ikHandlesGrp, mo=True)
def createIkHandleLeg(self): #create ik handle self.leg_ik_handle = pm.ikHandle( sj= self.leg_ik_j_base , ee= self.leg_ik_j_tip , n = self.prefix +'_ik_rp_Handle_leg' , sol = 'ikRPsolver' )[0] pm.select(cl = True) #ik handle grp self.leg_ik_handle_grp = pm.group(self.leg_ik_handle, n = self.prefix + '_leg_ik_handle_grp') pm.select(cl = True)
def curveAimBelt(module, crv, aimCrv, numJnts, mo=True, aimVector=(0,1,0), upVector=(0,1,0), worldUpType="vector", worldUpVector=(0,1,0)):
'''Takes two curves, creates joints on the first and aims objects at the second.
Args:
crv (pm.nt.nurbsCurve): nurbs curve to generate things on
aimCrv (pm.nt.nurbsCurve): nurbs curve to aim things to
numJnts (int): number of joints to be generated
other : all of the aim vector constraint settings
Returns list(grp, list(joints))
Usage:
curveAimBelt("path", pm.ls(sl=True)[0], pm.ls(sl=True)[1], 40)
'''
grp = pm.group(em=True, n=module+'_GRP')
aimgrp = pm.group(em=True, n=module+'_AIMDRV_GRP', p=grp)
joints = rig_makeJointsAlongCurve(module+"Drive", crv, numJnts)
ikJoints = rig_makeJointsAlongCurve(module+"IK", crv, numJnts)
skelgrp = pm.group(em=True, n=module+'Skeleton_GRP', p=grp)
ikskelgrp = pm.group(em=True, n=module+'ikJNT_GRP', p=skelgrp)
jntgrp = pm.group(em=True, n=module+'JNT_GRP', p=skelgrp)
clstrGrp = pm.group(em=True, n=module+'Clusters_GRP', p=grp)
crvGrp = pm.group(em=True, n=module+'Curves_GRP', p=grp)
for joint,ikJoint in zip(joints,ikJoints):
joint.setParent(jntgrp)
pociResult = rig_getClosestPointAndPositionOnCurve(joint, crv)
pociResult[2].setParent(aimgrp)
pociOrig = pociResult[0]
poci = pm.nodetypes.PointOnCurveInfo(n=joint+"_POCI")
aimCrv.getShape().attr("worldSpace[0]").connect(poci.inputCurve)
pociOrig.parameter.connect(poci.parameter)
loc = pm.spaceLocator( n=joint+'AIMDRV_GRP' )
loc.setParent(aimgrp)
poci.position.connect(loc.t)
pm.pointConstraint(ikJoint, joint, mo=True)
pm.aimConstraint(loc, joint, mo=mo, aimVector=aimVector, upVector=upVector, worldUpType=worldUpType, worldUpVector=worldUpVector)
ikHandle=pm.ikHandle(sj=ikJoints[0], ee=ikJoints[-1], sol='ikSplineSolver', c=crv, ccv=False, rtm=False)[0]
origClusters = rig_clusterCurve(crv, ends=True)
offsetClusters = rig_clusterCurve(aimCrv, ends=True)
for clstr, oClstr in zip(origClusters, offsetClusters):
pm.parentConstraint(clstr[1], oClstr[1], mo=True)
oClstr[1].visibility.set(0)
clstr[1].setParent(clstrGrp)
oClstr[1].setParent(clstrGrp)
ikJoints[0].setParent(ikskelgrp)
ikskelgrp.visibility.set(0)
crvGrp.visibility.set(0)
crv.setParent(crvGrp)
aimCrv.setParent(crvGrp)
ikHandle.setParent(ikskelgrp)
aimgrp.inheritsTransform.set(0)
return [grp, joints]
def getPoleVectorFromIK(offset):
"""
Creates pole vector locator from a selected IK Handle
"""
ikHandle = pmc.selected()[0]
joints = pmc.ikHandle(ikHandle, q=True, jointList=True)
joints.extend(pmc.listConnections(ikHandle.getEndEffector().translateX))
loc = getPoleVectorPosition(joints, offset)
loc.select(replace=True)
def __finalizeIkChain(self):
'''
Create the ikHandle and the constraints to the control
'''
#create ikHandle
ikHandleName = nameUtils.getUniqueName(self.side, self.baseName, "IK")
self.ikHandle = pm.ikHandle(n = ikHandleName, sj = self.chain[0], ee = self.chain[-1], solver = "ikRPsolver")[0]
#create parent constraint from the ikHandle to the last control
pm.pointConstraint(self.controlsArray[-1].control, self.ikHandle, mo = 1)
#create a pole vector control
pm.poleVectorConstraint(self.controlsArray[0].control, self.ikHandle)
def rig_connectDynChain(startJoint, endJoint, curve, parent): '''Takes two joints as inputs and then returns the children in between the two inputs. Args: startJoint (pm.PyNode): the starting joint of the chain endJoint (pm.PyNode): the ending joint of the chain curve (pm.PyNode): The curve that we're going to use for the ik chain Returns: (pm.nt.IkHandle) - The generated IK handle ''' ik = pm.ikHandle (sol='ikSplineSolver', curve=curve, startJoint=startJoint, endEffector=endJoint,ccv=False, snc=True,pcv=False) ik[0].setParent(parent) return ik[0]
def create_ik_handle(self, solver='ikRPsolver'):
"""
Create a ik handle for a specific ik setup. Need to be overrided by children class to implement the good behavior
:return: Return the created ik handle and effector
"""
# Since the base Ik will always be two bone, we can use the fact that the effector is after the elbow
start = self._chain_ik[0]
end = self._chain_ik[self.iCtrlIndex]
ik_handle, ik_effector = pymel.ikHandle(startJoint=start, endEffector=end,
solver=solver)
return ik_handle, ik_effector
def createSplineIk(self): pm.select( cl = True ) #Create spline IK self.dynamicChain_spline_ik = pm.ikHandle( sj= self.ikDynamicJointsList[0] , ee= self.ikDynamicJointsList[-1] , roc = True, n = self.prefix + '_ikSplineHandle_dynamic_chain', c = self.dynamicOutputCurve, ccv = False, pcv = False, sol = 'ikSplineSolver' )[0] pm.select( cl = True ) #Group Spline_ik self.dynamicChain_spline_ik_grp = pm.group(self.dynamicChain_spline_ik , n= self.prefix + '_ikSplineHandle_dynamic_chain_grp' ) pm.select(cl = True)
def makeIK():
print "Create IK"
#disconnect first, and then reconnect after IK creation
discDevice()
#record joint location
for i in range(0,15):
point[i] = pm.joint(KinectSkelJoints[i]+'_jt', p=True, q=1)
#delete old joints#
pm.delete( 'SKEL_HEAD_jt' )
makeSkel()
for i in range(0,15):
pm.rename('joint'+str(i+1), KinectSkelJoints[i]+'_jt')
pm.ikHandle(n='L_arm', sj=KinectSkelJoints[3]+'_jt', ee=KinectSkelJoints[5]+'_jt',dh=False, eh=True)
pm.ikHandle(n='R_arm', sj=KinectSkelJoints[6]+'_jt', ee=KinectSkelJoints[8]+'_jt',dh=False, eh=True)
pm.ikHandle(n='L_leg', sj=KinectSkelJoints[9]+'_jt', ee=KinectSkelJoints[11]+'_jt',dh=False, eh=True)
pm.ikHandle(n='R_leg', sj=KinectSkelJoints[12]+'_jt', ee=KinectSkelJoints[14]+'_jt',dh=False, eh=True)
#Create IK End effector controls using point constraint
pm.pointConstraint( KinectSkelJoints[5], 'L_arm' )
pm.pointConstraint( KinectSkelJoints[8], 'R_arm' )
pm.pointConstraint( KinectSkelJoints[11], 'L_leg' )
pm.pointConstraint( KinectSkelJoints[14], 'R_leg' )
'''
#Create IK End effector controls using aim constraint
pm.aimConstraint( KinectSkelJoints[5], 'L_arm' )
pm.aimConstraint( KinectSkelJoints[8], 'R_arm' )
pm.aimConstraint( KinectSkelJoints[11], 'L_leg' )
pm.aimConstraint( KinectSkelJoints[14], 'R_leg' )
'''
#Add back the original pointConstraint ()
pm.pointConstraint( KinectSkelJoints[0], KinectSkelJoints[0]+'_jt')
pm.pointConstraint( KinectSkelJoints[1], KinectSkelJoints[1]+'_jt')
pm.pointConstraint( KinectSkelJoints[2], KinectSkelJoints[2]+'_jt')
pm.pointConstraint( KinectSkelJoints[3], KinectSkelJoints[3]+'_jt')
pm.pointConstraint( KinectSkelJoints[6], KinectSkelJoints[6]+'_jt')
pm.pointConstraint( KinectSkelJoints[9], KinectSkelJoints[9]+'_jt')
pm.pointConstraint( KinectSkelJoints[12], KinectSkelJoints[12]+'_jt')
print "reconnect!!!"
connectDevice()
print "connect again!?"
SwitchPerspective()
def createIkRpHandleAnimated(self): pm.select(cl = True) #create ik handle self.ikHandleAnimated = pm.ikHandle( sj= self.ikAnimatedJointsList[0] , ee= self.ikAnimatedJointsList[-1] , n = self.prefix +'_ik_rp_Handle_animated' , sol = 'ikRPsolver' )[0] pm.select(cl = True) #Group ik solver self.ikHandleAnimatedGrp = pm.group(n = self.prefix + '_ik_rp_Handle_animated_grp') pm.select(cl = True) pm.parent(self.ikHandleAnimated, self.ikHandleAnimatedGrp) pm.select(cl = True)
def createIk(self):
#create the curve for the ik
ikCrv = pm.duplicate(self.crv)
ikCrv = pm.rebuildCurve(ikCrv[0],ch=0, rpo=1, rt=0, end=1, kr=0, kcp=0, kep=1, kt=0, s=self.numCtrl-1, d=3, tol=0)[0]
ikCrv.rename(self.name + '_ik_crv')
self.ikCrv = ikCrv
#create the ik
self.ikHandle = pm.ikHandle(sj = self.ikJntList[0], ee = self.ikJntList[-1], c=ikCrv, ccv=False, sol='ikSplineSolver',name = self.name + '_crv_ik')[0]
pm.select(cl=1)
pm.parent(self.ikHandle,self.mainGrp)
pm.parent(self.ikCrv,self.mainGrp)
pm.select(cl=1)
def _setup_ikfk(self):
ik_jnt_names = [x + '_ik' for x in self._joints]
fk_jnt_names = [x + '_fk' for x in self._joints]
# duplicate command will also duplicate children nodes, including constraint nodes
# thus must duplicate before setting up any connections/ constraints.
ik_chain = joints.duplicate_chain(self._root, ik_jnt_names)
fk_chain = joints.duplicate_chain(self._root, fk_jnt_names)
# constraint deformation chain:
ik_weight_attrs = []
for index, jnt in enumerate(ik_chain):
constraint = pm.parentConstraint(jnt, self._joints[index])
alias = constraint.getWeightAliasList()
ik_weight_attrs.append(alias)
fk_weight_attrs = []
for index, jnt in enumerate(fk_chain):
constraint = pm.parentConstraint(jnt, self._joints[index])
alias = constraint.getWeightAliasList()
fk_weight_attrs.append(alias)
# flatten the lists
ik_weight_attrs = general.flatten_list(ik_weight_attrs)
fk_weight_attrs = general.flatten_list(fk_weight_attrs)
fk_weight_attrs = [x for x in fk_weight_attrs if x not in ik_weight_attrs]
# setup blend switch
# create a switch object, if no specified.
# fixme: if switch object specified
switch_transform = pm.createNode('transform')
attr_name = 'IK_FK'
switch_transform.addAttr(attr_name, attributeType='double', min=0, max=1, dv=0, k=1)
switch_attr = switch_transform.attr(attr_name)
# use a plusMinusAverage node to control the blending:
plus_minus_node = pm.createNode('plusMinusAverage')
plus_minus_node.operation.set(2)
plus_minus_node.input1D[0].set(1)
switch_attr.connect(plus_minus_node.input1D[1])
for ik_attr in ik_weight_attrs:
plus_minus_node.output1D.connect(ik_attr)
for fk_attr in fk_weight_attrs:
switch_attr.connect(fk_attr)
# setup IK
ik = pm.ikHandle(n=ik_chain[0] + '_ikHandle', sj=ik_chain[0], ee=ik_chain[-1], sol='ikRPsolver', s=0)
ik_handle = ik[0]
def buildSolver(self):
jntSystem = self.ikJointSystem
# Build the main single degree curve
baseCurve = utils.createCurve(jntSystem.positions, degree=1)
baseCurve.rename(utils.nameMe(self.side, self.part, "CtrlCurve"))
self.controlCurve = core.MovableSystem(baseCurve.name())
self.controlCurve.part = self.part
self.transferPropertiesToChild(self.controlCurve, "CtrlCurve")
self.controlCurve.resetName()
# Build the bspline ik curve
curve_name = utils.nameMe(self.side, self.part, "BaseCurve")
# Sometimes bSpline might generate less CVs as the source....Investigate
ikCurve, fitNode = pm.fitBspline(baseCurve,
ch=1,
tol=0.01,
n=curve_name)
if len(ikCurve.getCVs()) != len(jntSystem.positions):
pm.delete(ikCurve)
ikCurve = utils.createCurve(jntSystem.positions)
ikCurve.rename(curve_name)
self.bSpline = False
self.ikCurve = core.MovableSystem(ikCurve.name())
self.ikCurve.part = self.part
self.transferPropertiesToChild(self.ikCurve, "BaseCurve")
if self.bSpline:
fitNodeMeta = core.MetaRig(fitNode.name())
fitNodeMeta.part = self.part
self.ikCurve.addSupportNode(fitNodeMeta, "BaseDriver")
self.ikCurve.transferPropertiesToChild(fitNodeMeta, "FitNode")
fitNodeMeta.resetName()
# Build the spline IK
name = utils.nameMe(self.side, self.part, "IkHandle")
startJoint = jntSystem.joints[0].shortName()
endJoint = jntSystem.joints[-1].shortName()
# noinspection PyArgumentList
ikHandle = pm.ikHandle(name=name,
sj=startJoint,
ee=endJoint,
sol="ikSplineSolver",
curve=ikCurve,
createCurve=False,
freezeJoints=False,
rootOnCurve=True
)[0]
ikHandleMeta = core.MovableSystem(ikHandle.name(), nodeType="IkHandle")
self.transferPropertiesToChild(ikHandleMeta, "IkHandle")
ikHandleMeta.part = "IkHandle"
ikHandleMeta.v = False
ikHandleMeta.addParent()
self.ikHandle = ikHandleMeta
