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