def returnPartNestedMessages(partNull): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Returns a nested dictionary of template objects info connected to a part ARGUMENTS: partNull(obj) RETURNS: nestedDict(dict) - nested dictionary of various null's infos >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ objectsDict = attributes.returnMessageAttrs(partNull) returnDict = {} for key in objectsDict.keys(): returnDict[key] = attributes.returnMessageAttrs(objectsDict[key]) return returnDict
def returnModules(masterNull): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Returns all the modules connected to a master null ARGUMENTS: masterNull(string) RETURNS: modules(list) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ modulesNull = returnInfoTypeNull(masterNull, 'modules') moduleNames = attributes.returnMessageAttrs(modulesNull) modules = [] for module in moduleNames: modules.append(attributes.returnMessageObject(modulesNull, module)) return modules
def returnModules(masterNull): """ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DESCRIPTION: Returns all the modules connected to a master null ARGUMENTS: masterNull(string) RETURNS: modules(list) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ modulesNull = returnInfoTypeNull(masterNull,'modules') moduleNames = attributes.returnMessageAttrs(modulesNull) modules = [] for module in moduleNames: modules.append(attributes.returnMessageObject(modulesNull,module)) return modules
def surfRigger(objectNull,anchor,worldScale,mirror,mode,jointsPerChain,deformChains,ctrlChains): """ Get variables""" nullBase = names.stripSuffixObj (objectNull) templateNull = (nullBase + '_templateNull') moverNull = (nullBase + '_mover') templateNullMessageData = [] templateNullMessageData = attributes.returnMessageAttrs (templateNull) templateObjects = [] coreNamesList = [] spineJointNumber = int(mc.getAttr (objectNull+'.rollJoints')) #spineChainList = search.returnChildrenJoints (spineChain) spineChainList = [] spineChainList.append (anchor) jointChains = [] for set in templateNullMessageData: templateObjects.append (set[1]) coreNamesList.append (set[0]) #>>>>>>>>>>>>>>>>>>>>>Store skin joint data """ check for master skin info group """ if mc.objExists ('master_skinJntList_grp'): masterSkinJointList = ('master_skinJntList_grp') else: masterSkinJointList = mc.group (n= ('master_skinJntList_grp'), w=True, empty=True) mc.parent(masterSkinJointList,'rigStuff_grp') """ check for segment skin info group """ if mc.objExists (nullBase+'_skinJntList_grp'): skinJointListGrp = (nullBase+'_skinJntList_grp') else: skinJointListGrp = mc.group (n= (nullBase+'_skinJntList_grp'), w=True, empty=True) attributes.storeObjNameToMessage (skinJointListGrp,masterSkinJointList) mc.parent (skinJointListGrp,masterSkinJointList) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> """ Rebuild curve - with actual curve in it!""" mc.rebuildCurve ((templateObjects[3]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5) mc.rebuildCurve ((templateObjects[7]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5) mc.rebuildCurve ((templateObjects[11]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=jointsPerChain, d=1, tol=5) """ Reverse the curve """ mc.reverseCurve ((templateObjects[3]),ch=False,rpo=True) mc.reverseCurve ((templateObjects[7]),ch=False,rpo=True) mc.reverseCurve ((templateObjects[11]),ch=False,rpo=True) """ loft our surface to figure out joint positions, then delete it""" controlSurface = mc.loft ([templateObjects[3],templateObjects[7],templateObjects[11]],name=(nullBase+'_surf'),ss=(ctrlChains-mode),ch=1,u=1,c=0,ar=1,d=3,rn=0,po=0,rsn=True) mc.select (cl=True) jointChains = joints.createJointChainsFromLoftSurface (nullBase,controlSurface[0],2,False) frontChain = jointChains[0] backChain = jointChains[-1] """ Chain - orienting, sizing """ for chain in jointChains: joints.orientJointChain (chain, 'xyz', 'zup') joints.setGoodJointRadius(chain,.5) #IF we have mode 0, gotta make a main ctrl if mode == 0: midChain = [] if (len(jointChains)) > 3: midChain = jointChains[int(len(jointChains)/2)] else: midChain = jointChains[1] jointChains.remove(midChain) if ctrlChains > 2: masterCtrlBuffer = mc.duplicate (midChain[0],parentOnly=True) else: masterCtrlBuffer = midChain[0] mc.delete (midChain[1]) masterCtrl = mc.rename (masterCtrlBuffer,(nullBase+'_master_anim')) position.movePointSnap(masterCtrl,moverNull) """ temp parenting the master control for mirroring purposes """ spineHookJoint = distance.returnClosestObject (masterCtrl, spineChainList) mc.parent (masterCtrl,spineHookJoint) mc.delete (controlSurface[0]) #>>>>>>>>>>>>Parent time """ Get closest joint """ if mode == 0: for chain in jointChains: mc.parent (chain[0],masterCtrl) else: for chain in jointChains: tailHookJoint = distance.returnClosestObject (chain[0], spineChainList) mc.parent (chain[0],tailHookJoint) #>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ctrl Joints to Ctrls cnt = 0 for chain in jointChains: ctrlSize = (distance.returnAverageDistanceBetweenObjects (chain)/2) for jnt in chain[0:-1]: rigging.makeObjCtrl (jnt,ctrlSize) """ adds our Anim tag """ chainBuffer = [] chainBuffer = names.addSuffixList ('anim', chain) jointChains[cnt]= chainBuffer cnt +=1 #>>>>>>>>>>>>>>>>>>>Mirroring while getting chain info """ If mirroring ....""" if mirror == True: # if we have a main control leftSkinChains = [] rightSkinChains = [] masterCtrls = [] if mode == 0: leftChain = [] rightChain = [] finHeirarchy = [] finHeirarchy.append (masterCtrl) children = search.returnChildrenJoints (masterCtrl) finHeirarchy += children leftChain = names.addPrefixList ('left',finHeirarchy) masterCtrl = leftChain [0] rightChainBuffer = mc.mirrorJoint (masterCtrl,mirrorYZ=True,mirrorBehavior=True, searchReplace =['left','right']) rightChainJointBuffer = mc.ls (rightChainBuffer,type='joint') rightChain = rightChainJointBuffer leftSkinChains.append(leftChain) rightSkinChains.append(rightChain) masterCtrls.append(leftChain[0]) masterCtrls.append(rightChain[0]) else: for chain in jointChains: leftChain =[] leftChain = names.addPrefixList ('left',chain) rightChainBuffer = (mc.mirrorJoint (leftChain[0],mirrorYZ=True,mirrorBehavior=True, searchReplace =['left','right'])) rightChainJointBuffer = mc.ls (rightChainBuffer,type='joint') rightChain = rightChainJointBuffer rightSkinChains.append (rightChainJointBuffer) leftSkinChains.append (leftChain) """ complile our chains to lists of skin joints """ leftSkinJointList=[] rightSkinJointList=[] for chain in leftSkinChains: for jnt in chain: leftSkinJointList.append (jnt) for chain in rightSkinChains: for jnt in chain: rightSkinJointList.append (jnt) """if we're not mirroring, let's return our skin joints for the deformation surface""" else: skinJointList = [] skinChains = [] for chain in jointChains: skinChains.append (chain) for jnt in chain: skinJointList.append (jnt) #>>>>>>>>>>>>>>>>>>>>>>>>>>Time to make the deformation surface stuff """ Rebuild curve - with actual curve in it!""" #mc.rebuildCurve ((templateObjects[3]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=(3), d=1, tol=5) #mc.rebuildCurve ((templateObjects[7]), ch=0, rpo=1, rt=0, end=0, kr=0, kcp=0, kep=1, kt=0, s=(3), d=1, tol=5) """ loft our surface to figure out joint positions, then delete it""" deformSurface = mc.loft ([templateObjects[3],templateObjects[7],templateObjects[11]],name=(nullBase+'_surf'),ss=(deformChains-1),ch=0,u=1,c=0,ar=1,d=3,rn=0,po=0,rsn=True) if mirror == True: deformSurfaceNameBuffer = deformSurface[0] """we have a surface to mirror...""" surfaceMirrorBuffer = mc.duplicate (deformSurface[0]) mc.setAttr ((surfaceMirrorBuffer[0]+'.sx'),-1) leftBuffer = mc.rename (deformSurface[0],('left_'+deformSurfaceNameBuffer)) rightBuffer = mc.rename (surfaceMirrorBuffer[0],('right_'+deformSurfaceNameBuffer)) deformSurface[0]=leftBuffer deformSurface.append(rightBuffer) leftDeformJointChains = joints.createJointChainsFromLoftSurface (('left_'+nullBase),deformSurface[0],2,False) rightDeformJointChains = joints.createJointChainsFromLoftSurface (('right_'+nullBase),deformSurface[1],2,False) """ Connecting to surface """ for chain in leftDeformJointChains: attachSurfaceReturn = joints.attachJointChainToSurface (chain,deformSurface[0],'xyz','zup') tailHookJoint = distance.returnClosestObject (chain[0], spineChainList) """ break the connection so we can parent it""" """first return the original thing to follow""" parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate')) attributes.doBreakConnection (chain[0]+'.translate') #mc.parent (chain[0],tailHookJoint) """ reconstrain it to the driver""" constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True) mc.rename (constraintBuffer[0],(chain[0]+'_pointConst')) """ store the skin joint data """ for jnt in chain: attributes.storeObjNameToMessage (jnt,skinJointListGrp) for chain in rightDeformJointChains: attachSurfaceMirrorReturn = joints.attachJointChainToSurface (chain,deformSurface[1],'xyz','zup') tailHookJoint = distance.returnClosestObject (chain[0], spineChainList) """ break the connection s we can parent it""" """first return the original thing to follow""" parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate')) attributes.doBreakConnection (chain[0]+'.translate') #mc.parent (chain[0],tailHookJoint) """ reconstrain it to the driver""" constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True) mc.rename (constraintBuffer[0],(chain[0]+'_pointConst')) """ store the skin joint data """ for jnt in chain: attributes.storeObjNameToMessage (jnt,skinJointListGrp) """ parent the scale stuff to rig stuff grp""" mc.select (cl=True) for item in attachSurfaceReturn[0]: mc.parent(item,'rigStuff_grp') for item in attachSurfaceMirrorReturn[0]: mc.parent(item,'rigStuff_grp') """ hook up world scale """ mc.connectAttr (worldScale,attachSurfaceReturn[1]) mc.connectAttr (worldScale,attachSurfaceMirrorReturn[1]) #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Skin in the control joints """ Time to set skin our surface to our control joints """ mc.skinCluster (leftSkinJointList,deformSurface[0],tsb=True, n=(deformSurface[0]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1) mc.skinCluster (rightSkinJointList,deformSurface[1],tsb=True, n=(deformSurface[1]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1) #>>>>>If we,re not mirrored, let's make our deform setup else: deformJointChains = [] deformJointChains = joints.createJointChainsFromLoftSurface (nullBase,deformSurface[0],2,False) """ Connecting to surface """ for chain in deformJointChains: attachSurfaceReturn = joints.attachJointChainToSurface (chain,deformSurface[0],'xyz','zup') tailHookJoint = distance.returnClosestObject (chain[0], spineChainList) """ break the connection so we can parent it""" """first return the original thing to follow""" parentBuffer = attributes.returnDriverObject ((chain[0]+'.translate')) attributes.doBreakConnection (chain[0]+'.translate') #mc.parent (chain[0],tailHookJoint) """ reconstrain it to the driver""" constraintBuffer = mc.pointConstraint (parentBuffer,chain[0], maintainOffset = True) mc.rename (constraintBuffer[0],(chain[0]+'_pointConst')) """ store the skin joint data """ for jnt in chain: attributes.storeObjNameToMessage (jnt,skinJointListGrp) """ hook up world scale """ partScaleBuffer = attachSurfaceReturn[1] mc.connectAttr (worldScale, partScaleBuffer) """ parent the scale stuff to rig stuff grp""" mc.select (cl=True) for item in attachSurfaceReturn[0]: mc.parent(item,'rigStuff_grp') """ Time to set skin our surface to our control joints """ mc.skinCluster (skinJointList,deformSurface[0],tsb=True, n=(deformSurface[0]+'_skinCluster'),maximumInfluences = 8, normalizeWeights = 1, dropoffRate=1,smoothWeights=.5,obeyMaxInfluences=True, weight = 1) """ Setting up the joint starts""" if mode == 0: if mirror == True: for ctrl in masterCtrls: rigging.makeObjCtrl (ctrl,(ctrlSize*4)) masterCtrlGrp = rigging.groupMeObject (ctrl,True) """ Get closest joint and connect the Cntrl """ spineHookJoint = distance.returnClosestObject (masterCtrlGrp, spineChainList) mc.parent(masterCtrlGrp,spineHookJoint) else: rigging.makeObjCtrl (masterCtrl,(ctrlSize*4)) masterCtrlGrp = rigging.groupMeObject (masterCtrl,True) """ Get closest joint and connect the Cntrl """ spineHookJoint = distance.returnClosestObject (masterCtrlGrp, spineChainList) mc.parent(masterCtrlGrp,spineHookJoint) #else we need to connect the individual chains to the spine else: if mirror == True: for chain in leftSkinChains: chainCtrlGrp = rigging.groupMeObject (chain[0],True) spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList) mc.parent(chainCtrlGrp,spineHookJoint) for chain in rightSkinChains: chainCtrlGrp = rigging.groupMeObject (chain[0],True) spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList) mc.parent(chainCtrlGrp,spineHookJoint) else: for chain in skinChains: chainCtrlGrp = rigging.groupMeObject (chain[0],True) spineHookJoint = distance.returnClosestObject (chainCtrlGrp, spineChainList) mc.parent(chainCtrlGrp,spineHookJoint)
def rigArm(objectNull): """return variables""" nullBase = names.stripSuffixObj(objectNull) templateNull = (nullBase + '_templateNull') templateNullMessageData = [] templateNullMessageData = attributes.returnMessageAttrs(templateNull) templateObjects = [] coreNamesList = [] for set in templateNullMessageData: templateObjects.append(set[1]) coreNamesList.append(set[0]) """ return rid of locators on our template objects so they don't screw up the distance locators""" templateObjects.remove(templateObjects[-1]) coreNamesList.remove(coreNamesList[-1]) for obj in templateObjects: if mc.objExists(obj + '_loc'): mc.delete(obj + '_loc') """make joint chains""" fkJoints = joints.createJointsFromObjPositions(templateObjects, 'fk') mc.select(cl=True) ikJoints = joints.createJointsFromObjPositions(templateObjects, 'ik') """orient joints""" joints.orientJointChain(fkJoints, 'xyz', 'yup') joints.orientJointChain(ikJoints, 'xyz', 'yup') """set rotation order - CHANGE to go for the names later and optional orientation schemes""" joints.setRotationOrderOnJoint(fkJoints[0], 'xyz') joints.setRotationOrderOnJoint(fkJoints[1], 'xzy') joints.setRotationOrderOnJoint(fkJoints[2], 'zyx') joints.setRotationOrderOnJoint(ikJoints[0], 'xyz') joints.setRotationOrderOnJoint(ikJoints[1], 'xzy') joints.setRotationOrderOnJoint(ikJoints[2], 'zyx') """ create hand_anim locs """ hand_animRegBuffer = locators.locMeObject(ikJoints[2]) hand_animPinnedBuffer = locators.locMeObject(ikJoints[2]) hand_animReg = mc.rename(hand_animRegBuffer, (coreNamesList[2] + '_anim')) hand_animPinned = mc.rename(hand_animPinnedBuffer, (coreNamesList[2] + '_elbow_anim')) """ creating measure stuff """ # Had to move this up here because distanceDimension doesn't let you specify which locator to use. Need to modify script to account for that uprArmMeasureLocBuffer = locators.locMeObject(ikJoints[0]) handMeasureLocBuffer = locators.locMeObject(ikJoints[2]) elbowMeasureLocBuffer = locators.locMeObject(ikJoints[1]) uprArmMeasureLoc = mc.rename(uprArmMeasureLocBuffer, (coreNamesList[0] + '_dist_loc')) handMeasureLoc = mc.rename(handMeasureLocBuffer, (coreNamesList[2] + '_dist_loc')) elbowMeasureLoc = mc.rename(elbowMeasureLocBuffer, (coreNamesList[1] + '_dist_loc')) measureFullLength = [uprArmMeasureLoc, handMeasureLoc] fullLengthMeassureObj = distance.createDistanceObjectsBetweenObjectList( measureFullLength) measureShoulderToElbow = [uprArmMeasureLoc, elbowMeasureLoc] uprLengthMeassureObj = distance.createDistanceObjectsBetweenObjectList( measureShoulderToElbow) measureElbowToHand = [elbowMeasureLoc, handMeasureLoc] lwrLengthMeassureObj = distance.createDistanceObjectsBetweenObjectList( measureElbowToHand) """>>>Set up Rotation Isolation for FK Mode """ """creates our locator parent""" UprArmRoot = locators.locMeObject(fkJoints[0]) """ Create 4 target locators""" UprArmTorsoOrientBuffer = mc.duplicate(UprArmRoot) UprArmBodyOrientBuffer = mc.duplicate(UprArmRoot) UprArmTorsoOrientDriverBuffer = mc.duplicate(UprArmRoot) UprArmBodyOrientDriverBuffer = mc.duplicate(UprArmRoot) UprArmOrientBuffer = mc.duplicate(UprArmRoot) """names our loctators intelligently""" uprArmTorsoOrient = mc.rename(UprArmTorsoOrientBuffer[0], (coreNamesList[0] + '_torso_orient')) uprArmBodyOrient = mc.rename(UprArmBodyOrientBuffer[0], (coreNamesList[0] + '_body_orient')) uprArmTorsoOrientDriver = mc.rename( UprArmTorsoOrientDriverBuffer[0], (coreNamesList[0] + '_torso_orient_driver')) uprArmBodyOrientDriver = mc.rename( UprArmBodyOrientDriverBuffer[0], (coreNamesList[0] + '_body_orient_driver')) UprArmOrient = mc.rename(UprArmOrientBuffer[0], (coreNamesList[0] + '_orient_anim')) """orients the orient_anim control placeholder""" attributes.setRotationOrderObj(UprArmOrient, 'xzy') """parents orient control loc to top node""" mc.parent(UprArmOrient, UprArmRoot) """parents arm to top loc""" mc.parent(fkJoints[0], UprArmOrient) """parents top loc and torso orient loc to torso diver""" mc.parent(UprArmRoot, uprArmTorsoOrientDriver) mc.parent(uprArmTorsoOrient, uprArmTorsoOrientDriver) mc.parent(uprArmBodyOrient, uprArmBodyOrientDriver) """ makes orient constraint for the fk arm""" orConstBuffer = mc.orientConstraint([uprArmBodyOrient, uprArmTorsoOrient], UprArmRoot, mo=True, weight=1) orConst = mc.rename(orConstBuffer, (fkJoints[0] + '_orConst')) """ adds our constraint toggle """ mc.addAttr(fkJoints[0], ln='orient', at='enum', en='torso:body:') mc.setAttr((fkJoints[0] + '.orient'), keyable=True) """ return our orient constraint channels """ orConstAttrs = (mc.listAttr(orConst, userDefined=True)) """ setups up toggle to change orientation """ mc.setDrivenKeyframe((orConst + '.' + orConstAttrs[0]), currentDriver=(fkJoints[0] + '.orient'), driverValue=0, value=0) mc.setDrivenKeyframe((orConst + '.' + orConstAttrs[1]), currentDriver=(fkJoints[0] + '.orient'), driverValue=0, value=1) mc.setDrivenKeyframe((orConst + '.' + orConstAttrs[0]), currentDriver=(fkJoints[0] + '.orient'), driverValue=1, value=1) mc.setDrivenKeyframe((orConst + '.' + orConstAttrs[1]), currentDriver=(fkJoints[0] + '.orient'), driverValue=1, value=0) """ >>>Sets up fk arm scaling """ """ adds our length attribute""" mc.addAttr(fkJoints[0], ln='length', at='float', minValue=0, defaultValue=1) mc.setAttr((fkJoints[0] + '.length'), keyable=True) mc.addAttr(fkJoints[1], ln='length', at='float', minValue=0, defaultValue=1) mc.setAttr((fkJoints[1] + '.length'), keyable=True) """ connects length to child joint length """ currentLength = mc.getAttr(fkJoints[1] + '.translateX') mc.setDrivenKeyframe((fkJoints[1] + '.translateX'), currentDriver=(fkJoints[0] + '.length'), driverValue=1, value=currentLength, inTangentType='linear', outTangentType='linear') mc.setDrivenKeyframe((fkJoints[1] + '.translateX'), currentDriver=(fkJoints[0] + '.length'), driverValue=0, value=0, inTangentType='linear', outTangentType='linear') currentLength = mc.getAttr(fkJoints[2] + '.translateX') mc.setDrivenKeyframe((fkJoints[2] + '.translateX'), currentDriver=(fkJoints[1] + '.length'), driverValue=1, value=currentLength, inTangentType='linear', outTangentType='linear') mc.setDrivenKeyframe((fkJoints[2] + '.translateX'), currentDriver=(fkJoints[1] + '.length'), driverValue=0, value=0, inTangentType='linear', outTangentType='linear') """ set sdk curves to infinity """ mc.setInfinity((fkJoints[1] + '.translateX'), pri='constant', poi='linear') mc.setInfinity((fkJoints[2] + '.translateX'), pri='constant', poi='linear') """ lockin stuff down on the fk end """ for jnt in fkJoints: attributes.doSetLockHideKeyableAttr( jnt, True, False, False, ['ty', 'tz', 'sx', 'sy', 'sz', 'v']) attributes.doSetLockHideKeyableAttr( UprArmOrient, True, False, False, ['tx', 'ty', 'tz', 'sx', 'sy', 'sz', 'v']) attributes.doSetLockHideKeyableAttr(fkJoints[1], False, False, False, ['tx']) attributes.doSetLockHideKeyableAttr(fkJoints[2], False, False, False, ['tx']) """ >>>IK arm time!""" """make elbow loc and a hand loc""" elbowIKLoc = locators.locMeObject(ikJoints[1]) handIKLoc = locators.locMeObject(ikJoints[2]) """set preferred rotation channel on elbow""" #---------------------->>>> Need to figure out how to generate this! mc.setAttr((ikJoints[1] + '.ry'), -30) mc.joint(ikJoints[1], edit=True, setPreferredAngles=True) mc.setAttr((ikJoints[1] + '.ry'), 0) """set up the ik handle""" ikHandleName = (nullBase + '_ikHandle') mc.ikHandle(name=ikHandleName, startJoint=ikJoints[0], endEffector=ikJoints[2], sol='ikRPsolver', snapHandleFlagToggle=True) """Polevector constraint""" mc.poleVectorConstraint(elbowIKLoc, ikHandleName, name=(nullBase + '.pvConst'), weight=1.0) mc.parent(ikHandleName, handIKLoc) """ >>> IK Stretch stuff""" """connecting measure stuff""" mc.parent(handMeasureLoc, handIKLoc) uprArmLength = mc.getAttr(ikJoints[1] + '.tx') lwrArmLength = mc.getAttr(ikJoints[2] + '.tx') fullLength = (uprArmLength + lwrArmLength) driver = (fullLengthMeassureObj[0] + 'Shape.distance') """sets base sdk key for length""" mc.setDrivenKeyframe((ikJoints[1] + '.tx'), currentDriver=driver, driverValue=fullLength, value=uprArmLength, inTangentType='linear', outTangentType='linear') mc.setDrivenKeyframe((ikJoints[2] + '.tx'), currentDriver=driver, driverValue=fullLength, value=lwrArmLength, inTangentType='linear', outTangentType='linear') """sets stetch sdk key for length""" mc.setDrivenKeyframe((ikJoints[1] + '.tx'), currentDriver=driver, driverValue=(fullLength * 2), value=(uprArmLength * 2), inTangentType='linear', outTangentType='linear') mc.setDrivenKeyframe((ikJoints[2] + '.tx'), currentDriver=driver, driverValue=(fullLength * 2), value=(lwrArmLength * 2), inTangentType='linear', outTangentType='linear') mc.setInfinity((ikJoints[1] + '.tx'), pri='constant', poi='linear') mc.setInfinity((ikJoints[2] + '.tx'), pri='constant', poi='linear') """ >>> Set up pinning""" """ creates blend node """ """upr""" uprBlendNode = mc.createNode('blendTwoAttr', name='upr_Choice_blendTwoNode', skipSelect=True) uprSDKCurve = mc.listConnections((ikJoints[1] + '.tx'), source=True) mc.connectAttr((uprSDKCurve[0] + '.output'), (uprBlendNode + '.input[0]'), force=True) mc.connectAttr((uprLengthMeassureObj[0] + 'Shape.distance'), (uprBlendNode + '.input[1]'), force=True) mc.connectAttr((uprBlendNode + '.output'), (ikJoints[1] + '.tx'), force=True) """lwr""" lwrBlendNode = mc.createNode('blendTwoAttr', name='lwr_Choice_blendTwoNode', skipSelect=True) lwrSDKCurve = mc.listConnections((ikJoints[2] + '.tx'), source=True) mc.connectAttr((lwrSDKCurve[0] + '.output'), (lwrBlendNode + '.input[0]'), force=True) mc.connectAttr((lwrLengthMeassureObj[0] + 'Shape.distance'), (lwrBlendNode + '.input[1]'), force=True) mc.connectAttr((lwrBlendNode + '.output'), (ikJoints[2] + '.tx'), force=True) """adds stetch attrs""" mc.addAttr(elbowIKLoc, ln='pin', at='float', minValue=0, defaultValue=1) mc.setAttr((elbowIKLoc + '.pin'), keyable=True) mc.connectAttr((elbowIKLoc + '.pin'), (uprBlendNode + '.attributesBlender')) mc.connectAttr((elbowIKLoc + '.pin'), (lwrBlendNode + '.attributesBlender')) mc.setAttr((elbowIKLoc + '.pin'), 0) mc.parent(elbowMeasureLoc, elbowIKLoc) """ >>> FK lower limb control setup """ """ creates our pinned lower limb fk joint """ pinnedLwrLimcgmuffer = mc.duplicate(ikJoints[1], renameChildren=True) nonJointStuff = search.returnNonJointObjsInHeirarchy(pinnedLwrLimcgmuffer) for item in nonJointStuff: mc.delete(item) """ name the joint we'll be using """ pinnedLwrLimb = mc.rename(pinnedLwrLimcgmuffer[0], (coreNamesList[1] + '_pinned_fk_anim')) mc.parent(pinnedLwrLimb, elbowIKLoc) pinnedLwrLimbEndBuffer = mc.listRelatives(pinnedLwrLimb, children=True) mc.rename(pinnedLwrLimbEndBuffer[0], (coreNamesList[1] + '_pinned_fk_end')) """ make the hand anim loc """ mc.parent(hand_animPinned, elbowIKLoc) ptConstBuffer = mc.pointConstraint([hand_animReg, hand_animPinned], handIKLoc, mo=False, weight=1) """ make the attr to drive it """ mc.addAttr(elbowIKLoc, ln='forearm', at='enum', en='fk:ik:') mc.setAttr((elbowIKLoc + '.forearm'), keyable=True) mc.setAttr((elbowIKLoc + '.forearm'), 1) """ connect it """ mc.connectAttr((elbowIKLoc + '.forearm'), (ptConstBuffer[0] + '.' + hand_animReg + 'W0')) revNodeBuffer = mc.createNode('reverse', name='hand_revNode') mc.connectAttr((elbowIKLoc + '.forearm'), (revNodeBuffer + '.inputX')) mc.connectAttr((revNodeBuffer + '.outputX'), (ptConstBuffer[0] + '.' + hand_animPinned + 'W1'))