def UI(self, parentLayout): ikHandleControl = self.blueprintNamespace + ":" + self.moduleNamespace + ":ikHandleControl" if cmds.objExists(ikHandleControl): controlObjectInstance = controlObject.ControlObject( ikHandleControl) controlObjectInstance.UI(parentLayout) cmds.attrControlGrp(attribute=ikHandleControl + ".stretchiness", label="Stretchiness") twistControl = self.blueprintNamespace + ":" + self.moduleNamespace + ":twistControl" controlObjectInstance = controlObject.ControlObject(twistControl) controlObjectInstance.UI(parentLayout)
def initFKControl(self, joint, spaceSwitchable=False): translationControl = False jointName = utils.stripAllNamespaces(joint)[1] blueprintJoint = self.blueprintNamespace + ":blueprint_" + jointName if cmds.objExists(blueprintJoint + "_addTranslate"): translationControl = True name = jointName + "_fkControl" controlObjectInstance = controlObject.ControlObject() fkControlInfo = controlObjectInstance.create( name, "fourArrowControl.ma", self, lod=1, translation=translationControl, rotation=True, globalScale=False, spaceSwitching=spaceSwitchable) fkControl = fkControlInfo[0] cmds.connectAttr(joint + ".rotateOrder", fkControl + ".rotateOrder") return (fkControlInfo[0], fkControlInfo[1], translationControl)
def createRootEndControl(self, name, orientJoint, posJoint, translation, containedNodes, moduleGrp): # Create control object controlObjectInstance = controlObject.ControlObject() controlObjectInfo = controlObjectInstance.create( name, "flattenedCube.ma", self, lod=1, translation=translation, rotation=True, globalScale=False, spaceSwitching=True) controlObj = controlObjectInfo[0] controlParent = controlObjectInfo[1] # Create a pre-transform to orient the control preTransform = cmds.group(empty=True, n=controlObj + "_preTransform") containedNodes.append(preTransform) cmds.parent(controlObj, preTransform, relative=True) cmds.parent(preTransform, controlParent, relative=True) # Get the true worldSpace orientation of the joint tempOrientationLocator = cmds.spaceLocator()[0] tempOrientConstraint = cmds.orientConstraint(orientJoint, tempOrientationLocator, maintainOffset=False)[0] targetOrientation = cmds.xform(tempOrientationLocator, q=True, worldSpace=True, rotation=True) cmds.delete(tempOrientConstraint) cmds.delete(tempOrientationLocator) cmds.xform(preTransform, worldSpace=True, absolute=True, rotation=targetOrientation) cmds.parent(controlParent, moduleGrp, relative=True) cmds.setAttr(controlObj + ".rotateOrder", cmds.getAttr(orientJoint + ".rotateOrder")) cmds.xform(controlObj, worldSpace=True, absolute=True, translation=cmds.xform(posJoint, q=True, worldSpace=True, translation=True)) return (controlObj, controlParent)
def UI(self, parentLayout): footControl = self.blueprintNamespace+":"+self.moduleNamespace+":footControl" controlObjectInstance = controlObject.ControlObject(footControl) controlObjectInstance.UI(parentLayout) cmds.attrControlGrp(attribute=footControl+".stretchiness", label="Stretchiness") circleIK.CircleControlStretchyIK.UI(self, parentLayout) jointsGrp = self.blueprintNamespace+":"+self.moduleNamespace+":joints_grp" joints = utils.findJointChain(jointsGrp) ballJoint = joints[4] toeJoint = joints[5] for joint in [ballJoint, toeJoint]: jointControl = joint+"_ryControl" controlObjectInstance = controlObject.ControlObject(jointControl) controlObjectInstance.UI(parentLayout)
def UI(self, parentLayout): rootControl = self.blueprintNamespace + ":" + self.moduleNamespace + ":rootControl" if cmds.objExists(rootControl): controlObjectInstance = controlObject.ControlObject(rootControl) controlObjectInstance.UI(parentLayout) jointsGrp = self.blueprintNamespace + ":" + self.moduleNamespace + ":joints_grp" joints = utils.findJointChain(jointsGrp) joints.pop(0) joints.pop(0) joints.pop() for joint in joints: offsetControl = joint + "_offsetControl" controlObjectInstance = controlObject.ControlObject(offsetControl) controlObjectInstance.UI(parentLayout) endControl = self.blueprintNamespace + ":" + self.moduleNamespace + ":endControl" controlObjectInstance = controlObject.ControlObject(endControl) controlObjectInstance.UI(parentLayout)
def UI(self, parentLayout): jointsGrp = self.blueprintNamespace + ":" + self.moduleNamespace + ":joints_grp" joints = utils.findJointChain(jointsGrp) joints.pop(0) joints.pop() for joint in joints: fkControl = joint + "_fkControl" controlObjectInstance = controlObject.ControlObject(fkControl) controlObjectInstance.UI(parentLayout) cmds.attrControlGrp(attribute=fkControl + ".stretch", label="Stretch")
def UI(self, parentLayout): armControl = self.blueprintNamespace + ":" + self.moduleNamespace + ":armControl" controlObjectInstance = controlObject.ControlObject(armControl) controlObjectInstance.UI(parentLayout) cmds.attrControlGrp(attribute=armControl + ".stretchiness", label="Stretchiness") circleIK.CircleControlStretchyIK.UI(self, parentLayout) jointsGrp = self.blueprintNamespace + ":" + self.moduleNamespace + ":joints_grp" joints = utils.findJointChain(jointsGrp)
def UI(self, parentLayout): jointsGrp = self.blueprintNamespace + ":" + self.moduleNamespace + ":joints_grp" joints = utils.findJointChain(jointsGrp) joints.pop(0) numJoints = len(joints) if numJoints > 1: numJoints -= 1 for i in range(numJoints): fkControl = joints[i] + "_fkControl" controlObjectInstance = controlObject.ControlObject(fkControl) controlObjectInstance.UI(parentLayout)
def install_custom(self, joints, moduleGrp, moduleContainer): joint = joints[1] name = "globalControl" controlObjectInstance = controlObject.ControlObject() globalControlInfo = controlObjectInstance.create(name, "cubeLocator.ma", self, lod=1, translation=True, rotation=True, globalScale=True, spaceSwitching=True) globalControl = globalControlInfo[0] globalControl_rootParent = globalControlInfo[1] # Position and orient control object pos = cmds.xform(joint, q=True, worldSpace=True, translation=True) orient = cmds.xform(joint, q=True, worldSpace=True, rotation=True) cmds.xform(globalControl, worldSpace=True, absolute=True, translation=pos) cmds.xform(globalControl, worldSpace=True, absolute=True, rotation=orient) """ Try freezing transforms """ #cmds.makeIdentity(globalControl, apply=True, t=True, r=False, s=False) cmds.parent(globalControl_rootParent, moduleGrp, absolute=True) cmds.connectAttr(joint + ".rotateOrder", globalControl + ".rotateOrder") parentConstraint = cmds.parentConstraint(globalControl, joint, maintainOffset=False, n=joint + "_parentConstraint")[0] scaleConstraint = cmds.scaleConstraint(globalControl, joint, maintainOffset=False, n=joint + "_scaleConstraint")[0] utils.addNodeToContainer(moduleContainer, [parentConstraint, scaleConstraint])
def install_custom(self, joints, moduleGrp, moduleContainer): moduleNamespace = self.blueprintNamespace + ":" + self.moduleNamespace """ Assign the joint indices to a variable """ ankleJoint = joints[3] ballJoint = joints[4] toeJoint = joints[5] """ Create a list of objects that need to be added to a namespace """ namespaceObjects = [] """ Get the module positions by creating a temp locator which is parented to each module in turn. Use xform on the locator and save it's position to a new variable. """ """ Temp locator used to get the module positions """ tempLocator = cmds.spaceLocator()[0] """ Ball Joint """ cmds.parent(tempLocator, ballJoint, relative=True) cmds.parent(tempLocator, moduleGrp, absolute=True) ballJoint_modulePos = [ cmds.getAttr(tempLocator + ".translateX"), cmds.getAttr(tempLocator + ".translateY"), cmds.getAttr(tempLocator + ".translateZ") ] """ Ankle Joint """ cmds.parent(tempLocator, ankleJoint) for attr in [".translateX", ".translateY", ".translateZ"]: cmds.setAttr(tempLocator + attr, 0) cmds.parent(tempLocator, moduleGrp, absolute=True) ankleJoint_modulePos = [ cmds.getAttr(tempLocator + ".translateX"), cmds.getAttr(tempLocator + ".translateY"), cmds.getAttr(tempLocator + ".translateZ") ] """ Toe Joint """ cmds.parent(tempLocator, toeJoint) for attr in [".translateX", ".translateY", ".translateZ"]: cmds.setAttr(tempLocator + attr, 0) cmds.parent(tempLocator, moduleGrp, absolute=True) toeJoint_modulePos = [ cmds.getAttr(tempLocator + ".translateX"), cmds.getAttr(tempLocator + ".translateY"), cmds.getAttr(tempLocator + ".translateZ") ] """ Delete the temp locator """ cmds.delete(tempLocator) """ containedNodes is an empty list that will store all the nodes that should be added to the animation module container """ containedNodes = [] """ Pass in functionality from basic IK """ ikNodes = circleIK.CircleControlStretchyIK.install_custom( self, joints, moduleGrp, moduleContainer, createHandleControl=False, poleVectorAtRoot=False) ikEndPosLocator = ikNodes["endLocator"] ikPoleVectorLocator = ikNodes["poleVectorObject"] #namespaceObjects.append(ikEndPosLocator) #namespaceObjects.append(ikPoleVectorLocator) stretchinessAttribute = ikNodes["stretchinessAttribute"] """ Import the foot control """ name = "footControl" controlObjectInstance = controlObject.ControlObject() footControlInfo = controlObjectInstance.create(name, "footControl.ma", self, lod=1, translation=True, rotation=True, globalScale=False, spaceSwitching=True) footControl = footControlInfo[0] footControlRootParent = footControlInfo[1] """ Create control attributes on the foot control """ footControlAttributes = ('roll', 'roll_break', 'toe_twist', 'ball_twist', 'heel_twist', 'bank', 'toe_flap') cmds.select(footControl) for attr in footControlAttributes: cmds.addAttr(shortName=attr, defaultValue=0.0, k=True) self.publishNameToModuleContainer(footControl + '.' + attr, attr, publishToOuterContainers=True) #footControlAttributes = ('pv_follow') #cmds.select(footControl) #cmds.addAttr(shortName=footControlAttributes[0], at='enum', en='off:on', k=True) """ Publish attributes to the top level character container """ #self.publishNameToModuleContainer(footControl + '.' + attr, attr, publishToOuterContainers=True) """ Parent foot control to root parent""" cmds.parent(footControlRootParent, moduleGrp, relative=True) """ Position and orient foot control""" footControlPos = [ ankleJoint_modulePos[0], ballJoint_modulePos[1], ankleJoint_modulePos[2] ] cmds.xform(footControl, objectSpace=True, absolute=True, translation=footControlPos) """ Position the foot control pivot at the ankle """ cmds.xform(footControl, ws=True, p=True, piv=[ ankleJoint_modulePos[0], ankleJoint_modulePos[1], ankleJoint_modulePos[2] ]) cmds.setAttr(footControl + ".rotateOrder", 3) #3 = xyz orientationVector = [ toeJoint_modulePos[0] - ankleJoint_modulePos[0], toeJoint_modulePos[2] - ankleJoint_modulePos[2] ] footControlRotation = atan2(orientationVector[1], orientationVector[0]) cmds.setAttr(footControl + ".rotateY", -degrees(footControlRotation)) # Hookup stretchiness attribute cmds.select(footControl) cmds.addAttr(at="float", minValue=0.0, maxValue=1.0, defaultValue=1.0, keyable=True, longName="stretchiness") self.publishNameToModuleContainer(footControl + ".stretchiness", "stretchiness", publishToOuterContainers=True) cmds.connectAttr(footControl + ".stretchiness", stretchinessAttribute, force=True) """ Setup for ball and Toe controls""" ballToeControls = [] ballToeControl_orientGrps = [] rootParents = [] for joint in [ankleJoint, ballJoint]: controlObjectInstance = controlObject.ControlObject() jointName = utils.stripAllNamespaces(joint)[1] name = jointName + "_pivotControl" ryControlInfo = controlObjectInstance.create(name, "needleControl.ma", self, lod=2, translation=True, rotation=False, globalScale=False, spaceSwitching=False) ryControl = ryControlInfo[0] ryControlRootParent = ryControlInfo[0] ballToeControls.append(ryControl) rootParents.append(ryControlInfo[0]) orientGrp = cmds.group(empty=True, n=ryControl + "_orientGrp") containedNodes.append(orientGrp) ballToeControl_orientGrps.append(orientGrp) cmds.parent(ryControl, orientGrp, relative=True) cmds.xform(ballToeControl_orientGrps[0], objectSpace=True, absolute=True, translation=ankleJoint_modulePos) cmds.xform(ballToeControl_orientGrps[1], objectSpace=True, absolute=True, translation=ballJoint_modulePos) heelControlRootParent = rootParents[0] bankControlRootParent = rootParents[1] for grp in ballToeControl_orientGrps: cmds.parent(grp, moduleGrp, absolute=True) """ This aligns the leg """ #cmds.parent(ikEndPosLocator, ballToeControls[0], absolute=True) """ Ankle IK """ ankleIKNodes = cmds.ikHandle(sj=ankleJoint, ee=ballJoint, solver="ikSCsolver", n=ankleJoint + "_ikHandle") ankleIKNodes[1] = cmds.rename(ankleIKNodes[1], ankleIKNodes[1] + "_ikEffector") containedNodes.extend(ankleIKNodes) namespaceObjects.append(ankleIKNodes[0]) namespaceObjects.append(ankleIKNodes[1]) cmds.setAttr(ankleIKNodes[0] + ".visibility", 0) """ Ball IK """ ballIKNodes = cmds.ikHandle(sj=ballJoint, ee=toeJoint, solver="ikSCsolver", n=ballJoint + "_ikHandle") ballIKNodes[1] = cmds.rename(ballIKNodes[1], ballIKNodes[1] + "_ikEffector") containedNodes.extend(ballIKNodes) namespaceObjects.append(ballIKNodes[0]) namespaceObjects.append(ballIKNodes[1]) cmds.setAttr(ballIKNodes[0] + ".visibility", 0) utils.addNodeToContainer(moduleContainer, containedNodes, ihb=True) """ Empty the contained nodes list """ containedNodes = [] """ Create the IK_Groups """ ikGroups = [] """ These groups go at the ankle """ ikGrp = cmds.group(em=True, name='footIK_grp') cmds.xform(ikGrp, a=True, t=ankleJoint_modulePos) ikGroups.append(ikGrp) containedNodes.append(ikGrp) """ These go at the ball """ groupNames = ('bank_grp', 'ballTwist_grp', 'ballRoll_grp', 'toeFlap_grp') for group in groupNames: cmds.group(em=True, name=group) cmds.xform(group, a=True, t=ballJoint_modulePos) ikGroups.append(group) containedNodes.append(group) """ These go at the toe """ ikGrp = cmds.group(em=True, name='toeRoll_grp') cmds.xform(ikGrp, a=True, t=toeJoint_modulePos) ikGroups.append(ikGrp) containedNodes.append(ikGrp) """ Create a heel roll group """ """ TODO: How do I get this to sit at the heel without adding a joint for it? """ ikGrp = cmds.group(em=True, name='heelRoll_grp') cmds.xform(ikGrp, a=True, t=(ankleJoint_modulePos[0], 0, ankleJoint_modulePos[2])) ikGroups.append(ikGrp) containedNodes.append(ikGrp) """ Create 3 locators to be used for roll attribute """ rollLctrs = [] dynRollLctr = cmds.spaceLocator(name='dynRoll_lctr')[0] cmds.xform(dynRollLctr, a=True, t=ballJoint_modulePos) rollLctrs.append(dynRollLctr) containedNodes.append(dynRollLctr) statRollLctr = cmds.spaceLocator(name='statRoll_lctr')[0] cmds.xform(statRollLctr, a=True, t=ballJoint_modulePos) rollLctrs.append(statRollLctr) containedNodes.append(statRollLctr) """ heelRoll_lctr """ heelRollLctr = cmds.spaceLocator(name='heelRoll_lctr')[0] cmds.xform(heelRollLctr, a=True, t=ballJoint_modulePos) rollLctrs.append(heelRollLctr) containedNodes.append(heelRollLctr) for locator in rollLctrs: cmds.setAttr(locator + '.visibility', 0) """ Parent the adjustment controls to the foot control """ cmds.parent(heelControlRootParent, ikGroups[3], absolute=True) cmds.makeIdentity(heelControlRootParent, apply=True, translate=True) cmds.parent(bankControlRootParent, ikGroups[3], absolute=True) """ Parent the ikHandles under the appropriate group """ cmds.parent(ankleIKNodes[0], ikGroups[3]) cmds.parent(ikEndPosLocator, ikGroups[3]) cmds.parent(ballIKNodes[0], ikGroups[4]) cmds.parent(ikGroups[3], ikGroups[5]) #ballRoll toeRoll cmds.parent(ikGroups[4], ikGroups[5]) #toeFlap toeRoll cmds.parent(ikGroups[5], ikGroups[2]) #toeRoll ballTwist cmds.parent(ikGroups[2], ikGroups[1]) #ballTwist bank cmds.parent(ikGroups[1], ikGroups[6]) #bank heelRoll cmds.parent(ikGroups[6], ikGroups[0]) #heelRoll footIK cmds.parent(dynRollLctr, ikGroups[0]) cmds.parent(heelRollLctr, ikGroups[0]) cmds.parent(statRollLctr, ikGroups[6]) """ Parent constrain ball and toe groups to roll_lctrs """ parentConstraints = [] rollParentConstraint = cmds.parentConstraint(dynRollLctr, ikGroups[3], mo=True, st=('x', 'y', 'z'), sr=('y', 'z')) parentConstraints.append(rollParentConstraint[0]) rollParentConstraint = cmds.parentConstraint(statRollLctr, ikGroups[3], mo=True, st=('x', 'y', 'z'), sr=('y', 'z')) parentConstraints.append(rollParentConstraint[0]) rollParentConstraint = cmds.parentConstraint(statRollLctr, ikGroups[5], mo=True, st=('x', 'y', 'z'), sr=('y', 'z')) parentConstraints.append(rollParentConstraint[0]) rollParentConstraint = cmds.parentConstraint(dynRollLctr, ikGroups[5], mo=True, st=('x', 'y', 'z'), sr=('y', 'z')) parentConstraints.append(rollParentConstraint[0]) for constraint in parentConstraints: print constraint newName = moduleNamespace + ':' + constraint cmds.rename(constraint, newName) """ Create a remap value node to control foot roll """ cmds.createNode('remapValue', name='roll_rv') cmds.setAttr('roll_rv.inputMax', 180.0) """ Connect to the remap value node """ """" Connect the output of dynRollLctr to roll_rv input value """ cmds.connectAttr(dynRollLctr + '.rx', 'roll_rv.inputValue') """ roll_break to input min """ cmds.setAttr(footControl + '.roll_break', 45.0) cmds.connectAttr(footControl + '.roll_break', 'roll_rv.inputMin') """ roll_break to parent constraint switches """ cmds.connectAttr('roll_rv.outColorG', ikGroups[3] + '.blendParent2') cmds.connectAttr('roll_rv.outColorR', ikGroups[5] + '.blendParent2') namespaceObjects.append('roll_rv') """ constrain the heelRoll_grp to heelRoll_lctr. Switch off the constraint when greater than 0 """ cmds.createNode('condition', name='roll_cond') heelOrientConstraint = cmds.orientConstraint(heelRollLctr, ikGroups[6], skip=('y', 'z'), mo=True) heelOrientAttr = (heelOrientConstraint[0] + '.' + heelRollLctr + 'W0') cmds.connectAttr('roll_cond.outColorR', heelOrientAttr) cmds.connectAttr(heelRollLctr + '.rx', 'roll_cond.firstTerm') cmds.setAttr('roll_cond.operation', 3) newName = moduleNamespace + ':' + heelOrientConstraint[0] cmds.rename(heelOrientConstraint[0], newName) namespaceObjects.append('roll_cond') """ Connect the foot attributes to respective groups and locators """ cmds.connectAttr(footControl + ".roll", heelRollLctr + '.rx') cmds.connectAttr(footControl + ".roll", 'dynRoll_lctr.rx') cmds.connectAttr(footControl + ".toe_twist", 'toeRoll_grp.ry') cmds.connectAttr(footControl + ".ball_twist", 'ballTwist_grp.ry') cmds.connectAttr(footControl + ".heel_twist", 'heelRoll_grp.ry') cmds.connectAttr(footControl + ".bank", 'bank_grp.rz') cmds.connectAttr(footControl + ".toe_flap", 'toeFlap_grp.rx') """ Connect pivot controls to the rotatePivot of appropriate group """ cmds.connectAttr(rootParents[1] + '.translate', 'bank_grp.rotatePivot') cmds.connectAttr(rootParents[0] + '.translate', 'heelRoll_grp.rotatePivot') """ Parent the footIK_grp to the foot control """ cmds.parent('footIK_grp', footControl, absolute=True) utils.addNodeToContainer(moduleContainer, containedNodes, ihb=True) for node in containedNodes: newName = moduleNamespace + ':' + node cmds.rename(node, newName) """ Add the namespaceObjects to the moduleNamespace """ for node in namespaceObjects: print node newName = moduleNamespace + ':' + node cmds.rename(node, newName)
def install_custom(self, joints, moduleGrp, moduleContainer, createHandleControl=True, poleVectorAtRoot=True): rootJoint = joints[1] hingeJoint = joints[2] endJoint = joints[3] containedNodes = [] twistRotationAimer = cmds.group(empty=True, n=rootJoint + "_twistRotationAimer") containedNodes.append(twistRotationAimer) containedNodes.append( cmds.pointConstraint(rootJoint, twistRotationAimer, maintainOffset=False, n=twistRotationAimer + "_pointConstraint")[0]) cmds.pointConstraint(endJoint, twistRotationAimer, maintainOffset=False) upVectorTarget = cmds.group(empty=True, n=rootJoint + "_twistRotationAimer_upVectorTarget") containedNodes.append(upVectorTarget) cmds.parent(upVectorTarget, hingeJoint, relative=True) cmds.setAttr(upVectorTarget + ".translateZ", cmds.getAttr(hingeJoint + ".translateX")) containedNodes.append( cmds.aimConstraint(endJoint, twistRotationAimer, maintainOffset=False, n=twistRotationAimer + "_aimConstraint", aimVector=[0.0, 0.0, 1.0], upVector=[1.0, 0.0, 0.0], worldUpType="object", worldUpObject=upVectorTarget)[0]) tempLocator = cmds.spaceLocator()[0] cmds.parent(tempLocator, twistRotationAimer, relative=True) cmds.setAttr(tempLocator + ".translateY", 10) twistRotationAimerPos = cmds.xform(twistRotationAimer, q=True, worldSpace=True, translation=True) tempLocatorPos = cmds.xform(tempLocator, q=True, worldSpace=True, translation=True) offsetVector = [ tempLocatorPos[0] - twistRotationAimerPos[0], tempLocatorPos[1] - twistRotationAimerPos[1], tempLocatorPos[2] - twistRotationAimerPos[2] ] cmds.delete(tempLocator) ikNodes = utils.basic_stretchy_IK( rootJoint, endJoint, container=moduleContainer, scaleCorrectionAttribute=self.blueprintNamespace + ":module_grp.hierarchicalScale") ikHandle = ikNodes["ikHandle"] rootPosLocator = ikNodes["rootLocator"] endPosLocator = ikNodes["endLocator"] poleVectorLocator = ikNodes["poleVectorObject"] stretchinessAttribute = ikNodes["stretchinessAttribute"] for node in [ ikHandle, rootPosLocator, endPosLocator, poleVectorLocator ]: cmds.parent(node, moduleGrp, absolute=True) if poleVectorAtRoot: poleVectorPos = cmds.xform(rootJoint, q=True, worldSpace=True, translation=True) else: poleVectorPos = cmds.xform(endJoint, q=True, worldSpace=True, translation=True) poleVectorPos[0] += offsetVector[0] poleVectorPos[1] += offsetVector[1] poleVectorPos[2] += offsetVector[2] cmds.xform(poleVectorLocator, worldSpace=True, absolute=True, translation=poleVectorPos) if createHandleControl: name = "ikHandleControl" controlObjectInstance = controlObject.ControlObject() handleControlInfo = controlObjectInstance.create( name, "cubeLocator.ma", self, lod=1, translation=True, rotation=True, globalScale=False, spaceSwitching=True) handleControl = handleControlInfo[0] handleRootParent = handleControlInfo[1] cmds.parent(handleRootParent, moduleGrp, relative=True) cmds.xform(handleControl, worldSpace=True, absolute=True, translation=cmds.xform(endPosLocator, q=True, worldSpace=True, translation=True)) pointConstraint = cmds.pointConstraint(handleControl, endPosLocator, maintainOffset=False, n=endPosLocator + "_pointConstraint")[0] containedNodes.append(pointConstraint) cmds.select(handleControl) cmds.addAttr(at="float", minValue=0.0, maxValue=1.0, defaultValue=1.0, keyable=True, longName="stretchiness") cmds.connectAttr(handleControl + ".stretchiness", stretchinessAttribute) self.publishNameToModuleContainer(handleControl + ".stretchiness", "stretchiness", publishToOuterContainers=True) rotationCancellation = cmds.group(empty=True, n=self.blueprintNamespace + ":" + self.moduleNamespace + ":twistRotationCancellation") containedNodes.append(rotationCancellation) cmds.parent(rotationCancellation, twistRotationAimer, relative=True) twistControlOffset = cmds.group(empty=True, n=self.blueprintNamespace + ":" + self.moduleNamespace + ":twistControlOffset") containedNodes.append(twistControlOffset) cmds.parent(twistControlOffset, rotationCancellation, relative=True) twistControlObjectInstance = controlObject.ControlObject() twistControlInfo = twistControlObjectInstance.create( "twistControl", "zAxisCircle.ma", self, lod=2, translation=False, rotation=[False, False, True], globalScale=False, spaceSwitching=True) twistControl = twistControlInfo[0] cmds.parent(twistControl, twistControlOffset, relative=True) cmds.connectAttr(twistControl + ".rotateZ", ikHandle + ".twist") pivotMultNode = cmds.shadingNode("multiplyDivide", asUtility=True, n=twistControl + "_invertOffset") containedNodes.append(pivotMultNode) cmds.connectAttr(twistControlOffset + ".translateX", pivotMultNode + ".input1X") cmds.setAttr(pivotMultNode + ".input2X", -1) cmds.connectAttr(pivotMultNode + ".output", twistControl + ".rotatePivot") multNode = cmds.shadingNode("multiplyDivide", asUtility=True, n=rotationCancellation + "_invertRotateZ") containedNodes.append(multNode) cmds.connectAttr(twistControl + ".rotateZ", multNode + ".input1X") cmds.setAttr(multNode + ".input2X", -1) cmds.connectAttr(multNode + ".outputX", rotationCancellation + ".rotateZ") cmds.parent(twistRotationAimer, moduleGrp, absolute=True) ikJoints = [joints[1], joints[2], joints[3]] jointName = utils.stripAllNamespaces(joints[1])[1] creationPoseRoot = self.blueprintNamespace + ":creationPose_" + jointName creationPoseJoints = utils.findJointChain(creationPoseRoot) targetJoints = [ creationPoseJoints[0], creationPoseJoints[1], creationPoseJoints[2] ] utils.matchTwistAngle(twistControl + ".rotateZ", ikJoints, targetJoints) offsetNode = cmds.shadingNode("plusMinusAverage", asUtility=True, n=twistControl + "_twistOffset") containedNodes.append(offsetNode) cmds.setAttr(offsetNode + ".input1D[0]", cmds.getAttr(twistControl + ".rotateZ")) cmds.connectAttr(twistControl + ".rotateZ", offsetNode + ".input1D[1]") cmds.connectAttr(offsetNode + ".output1D", ikHandle + ".twist", force=True) utils.forceSceneUpdate() cmds.setAttr(twistControl + ".rotateZ", 0) utils.addNodeToContainer(moduleContainer, containedNodes) self.publishNameToModuleContainer(twistControlOffset + ".translateX", "twistControlOffset", publishToOuterContainers=True) cmds.setAttr(moduleGrp + ".lod", 2) return (ikNodes)
def install_custom(self, joints, moduleGrp, moduleContainer): wristJoint = joints[3] handJoint = joints[4] """ The temp locator is used to find the position of each joint """ tempLocator = cmds.spaceLocator()[0] cmds.parent(tempLocator, handJoint, relative=True) cmds.parent(tempLocator, moduleGrp, absolute=True) handJoint_modulePos = [ cmds.getAttr(tempLocator + ".translateX"), cmds.getAttr(tempLocator + ".translateY"), cmds.getAttr(tempLocator + ".translateZ") ] cmds.parent(tempLocator, wristJoint) for attr in [".translateX", ".translateY", ".translateZ"]: cmds.setAttr(tempLocator + attr, 0) cmds.parent(tempLocator, moduleGrp, absolute=True) wristJoint_modulePos = [ cmds.getAttr(tempLocator + ".translateX"), cmds.getAttr(tempLocator + ".translateY"), cmds.getAttr(tempLocator + ".translateZ") ] cmds.delete(tempLocator) containedNodes = [] """ Pass in functionality from basic IK """ ikNodes = circleIK.CircleControlStretchyIK.install_custom( self, joints, moduleGrp, moduleContainer, createHandleControl=False, poleVectorAtRoot=False) ikEndPosLocator = ikNodes["endLocator"] ikPoleVectorLocator = ikNodes["poleVectorObject"] stretchinessAttribute = ikNodes["stretchinessAttribute"] name = "armControl" controlObjectInstance = controlObject.ControlObject() handControlInfo = controlObjectInstance.create(name, "handControl.ma", self, lod=1, translation=True, rotation=True, globalScale=False, spaceSwitching=True) handControl = handControlInfo[0] handControlRootParent = handControlInfo[1] """ Parent foot control to root parent """ cmds.parent(handControlRootParent, moduleGrp, relative=True) """ Position and orient foot control """ handControlPos = [ wristJoint_modulePos[0], handJoint_modulePos[1], wristJoint_modulePos[2] ] cmds.xform(handControl, objectSpace=True, absolute=True, translation=handControlPos) cmds.setAttr(handControl + ".rotateOrder", 3) #3 = xyz orientationVector = [ handJoint_modulePos[0] - wristJoint_modulePos[0], handJoint_modulePos[2] - wristJoint_modulePos[2] ] handControlRotation = atan2(orientationVector[1], orientationVector[0]) cmds.setAttr(handControl + ".rotateY", -degrees(handControlRotation)) pointConstraint = cmds.pointConstraint(handControl, ikEndPosLocator, maintainOffset=False, n=ikEndPosLocator + "_pointConstraint")[0] containedNodes.append(pointConstraint) """ Hookup stretchiness attribute """ cmds.select(handControl) cmds.addAttr(at="float", minValue=0.0, maxValue=1.0, defaultValue=1.0, keyable=True, longName="stretchiness") self.publishNameToModuleContainer(handControl + ".stretchiness", "stretchiness", publishToOuterContainers=True) cmds.connectAttr(handControl + ".stretchiness", stretchinessAttribute, force=True) """ Hand IK """ handIKNodes = cmds.ikHandle(sj=wristJoint, ee=handJoint, solver="ikRPsolver", n=handJoint + "_ikHandle") handIKNodes[1] = cmds.rename(handIKNodes[1], handIKNodes[1] + "_ikEffector") containedNodes.extend(handIKNodes) cmds.parent(handIKNodes[0], handControl) cmds.setAttr(handIKNodes[0] + ".visibility", 0) utils.addNodeToContainer(moduleContainer, containedNodes, ihb=True)
def install_custom(self, joints, moduleGrp, moduleContainer): result = cmds.confirmDialog( title="Interpolation-based Stretchy Spline", message="please specify the root control type:", button=["Translation and Rotation", "Rotation Only", "None"], defaultButton="Translation and Rotation", cancelButton="None", dismissString="None") rootControlTranslation = (result == "Translation and Rotation") createRootControl = not (result == "None") containedNodes = [] creationPoseJoints = [] for joint in joints: jointName = utils.stripAllNamespaces(joint)[1] creationPoseJoint = self.blueprintNamespace + ":creationPose_" + jointName creationPoseJoints.append(creationPoseJoint) # Create root and end controls rootControlObject = moduleGrp if createRootControl: rootControlObjectInfo = self.createRootEndControl( "rootControl", creationPoseJoints[1], creationPoseJoints[1], rootControlTranslation, containedNodes, moduleGrp) #"Return Tuple. [0] is object, [1] parent" rootControlObject = rootControlObjectInfo[0] rootControlParent = rootControlObjectInfo[1] if not rootControlTranslation: containedNodes.append( cmds.pointConstraint(moduleGrp, rootControlParent, maintainOffset=True)[0]) # Orient end joint based off second to last joint endControlObjectInfo = self.createRootEndControl( "endControl", creationPoseJoints[len(creationPoseJoints) - 2], creationPoseJoints[len(creationPoseJoints) - 1], True, containedNodes, moduleGrp) endControlObject = endControlObjectInfo[0] # Setup splineIK # Duplicate stretchyIKJoints and rename stretchyIKJoints = cmds.duplicate(joints, renameChildren=True) index = 0 for joint in stretchyIKJoints: stretchyIKJoints[index] = cmds.rename( joint, joints[index] + "_stretchyIKJoint") index += 1 containedNodes.extend(stretchyIKJoints) # Get the ws position of the root and end joints rootJoint = stretchyIKJoints[1] endJoint = stretchyIKJoints[len(stretchyIKJoints) - 1] secondJoint = stretchyIKJoints[2] secondToLastJoint = stretchyIKJoints[len(stretchyIKJoints) - 2] rootPos = cmds.xform(rootJoint, q=True, ws=True, translation=True) endPos = cmds.xform(endJoint, q=True, ws=True, translation=True) rootLocator = cmds.spaceLocator(n=stretchyIKJoints[0] + "_systemStretch_rootLocator")[0] cmds.xform(rootLocator, ws=True, absolute=True, translation=rootPos) #containedNodes.append(rootLocator) endLocator = cmds.spaceLocator(n=stretchyIKJoints[0] + "_systemStretch_endLocator")[0] cmds.xform(endLocator, ws=True, absolute=True, translation=endPos) #containedNodes.append(endLocator) # Hide locators for loc in [rootLocator, endLocator]: cmds.setAttr(loc + ".visibility", 0) #parent locators to controls cmds.parent(rootLocator, rootControlObject, absolute=True) cmds.parent(endLocator, endControlObject, absolute=True) index = 0 for joint in stretchyIKJoints: if index > 2 and index < len(stretchyIKJoints) - 1: cmds.select(stretchyIKJoints[index], replace=True) cmds.addAttr(at="float", longName="originalLength") originalLength = cmds.getAttr(stretchyIKJoints[index] + ".translateX") cmds.setAttr(stretchyIKJoints[index] + ".originalLength", originalLength) index += 1 # Setup the scale factor scaleFactorAttr = self.createDistanceCalculations( rootLocator, endLocator, containedNodes) rootScaler = self.createScalar(rootLocator, scaleFactorAttr, containedNodes) endScaler = self.createScalar(endLocator, scaleFactorAttr, containedNodes) rootIKLocators = self.setupBasicStretchyIK(rootJoint, secondJoint, creationPoseJoints[1], rootControlObject, moduleContainer, moduleGrp) rootIK_rootLocator = rootIKLocators[0] rootIK_endLocator = rootIKLocators[1] cmds.parent(rootIK_endLocator, rootScaler, absolute=True) endIKLocators = self.setupBasicStretchyIK( secondToLastJoint, endJoint, creationPoseJoints[len(creationPoseJoints) - 2], endControlObject, moduleContainer, moduleGrp) endIK_rootLocator = endIKLocators[0] endIK_endLocator = endIKLocators[1] cmds.parent(endIK_endLocator, endControlObject, absolute=True) ikNodes = cmds.ikHandle(sj=secondJoint, ee=secondToLastJoint, n=secondJoint + "_splineIKHandle", sol="ikSplineSolver", rootOnCurve=False, createCurve=True) ikNodes[1] = cmds.rename(ikNodes[1], secondJoint + "_splineIKEffector") ikNodes[2] = cmds.rename(ikNodes[2], secondJoint + "_splineIKCurve") splineIKhandle = ikNodes[0] splineIKCurve = ikNodes[2] containedNodes.extend(ikNodes) cmds.parent(splineIKhandle, moduleGrp, absolute=True) cmds.setAttr(splineIKhandle + ".visibility", 0) cmds.setAttr(splineIKCurve + ".visibility", 0) cmds.parent(splineIKCurve, world=True, absolute=True) cmds.setAttr(splineIKCurve + ".inheritsTransform", 0) cmds.parent(splineIKCurve, moduleGrp, relative=True) # Create a cluster for the CV's on the curve. cmds.select(splineIKCurve + ".cv[0:1]", replace=True) clusterNodes = cmds.cluster(n=splineIKCurve + "_rootCluster") cmds.container(moduleContainer, edit=True, addNode=clusterNodes, ihb=True, includeNetwork=True) rootClusterHandle = clusterNodes[1] cmds.select(splineIKCurve + ".cv[2:3]", replace=True) clusterNodes = cmds.cluster(n=splineIKCurve + "_endCluster") cmds.container(moduleContainer, edit=True, addNode=clusterNodes, ihb=True, includeNetwork=True) endClusterHandle = clusterNodes[1] for handle in [rootClusterHandle, endClusterHandle]: cmds.setAttr(handle + ".visibility", 0) cmds.parent(rootClusterHandle, rootScaler, absolute=True) cmds.parent(endClusterHandle, endScaler, absolute=True) containedNodes.append( cmds.parentConstraint(rootControlObject, rootJoint, maintainOffset=True)[0]) targetLocatorNodes = cmds.duplicate(endIK_rootLocator, name=endIK_rootLocator + "_duplicateTarget") targetLocator = targetLocatorNodes[0] cmds.delete(targetLocatorNodes[1]) cmds.parent(targetLocator, endScaler, absolute=True) splineScaleFactorAttr = self.createDistanceCalculations( rootIK_endLocator, targetLocator, containedNodes) # Use scaleFactor on each of the joints index = 0 for joint in stretchyIKJoints: if index > 2 and index < len(stretchyIKJoints) - 1: multNode = cmds.shadingNode("multiplyDivide", asUtility=True, n=joint + "_jointScale") containedNodes.append(multNode) cmds.connectAttr(scaleFactorAttr, multNode + ".input1X") cmds.setAttr(multNode + ".input2X", cmds.getAttr(joint + ".originalLength")) cmds.connectAttr(multNode + ".outputX", joint + ".translateX") index += 1 cmds.setAttr(splineIKhandle + ".dTwistControlEnable", 1) cmds.setAttr(splineIKhandle + ".dWorldUpType", 4) cmds.setAttr(splineIKhandle + ".dWorldUpAxis", 5) cmds.setAttr(splineIKhandle + ".dWorldUpVector", 0.0, 0.0, 1.0, type="double3") cmds.setAttr(splineIKhandle + ".dWorldUpVectorEnd", 0.0, 0.0, 1.0, type="double3") if createRootControl: cmds.connectAttr(rootControlObject + ".worldMatrix[0]", splineIKhandle + ".dWorldUpMatrix") else: dummyNode = cmds.duplicate(rootJoint, parentOnly=True, n=rootJoint + "_dummyDuplicate")[0] containedNodes.append(dummyNode) cmds.parent(dummyNode, moduleGrp, absolute=True) cmds.connectAttr(dummyNode + ".worldMatrix[0]", splineIKhandle + ".dWorldUpMatrix") cmds.connectAttr(endControlObject + ".worldMatrix[0]", splineIKhandle + ".dWorldUpMatrixEnd") # Create 2 attributes for "offsetY and offsetZ". cmds.select(moduleGrp) cmds.addAttr(at="float", defaultValue=0.0, softMinValue=-10.0, softMaxValue=10.0, keyable=True, longName="offsetY") cmds.addAttr(at="float", defaultValue=0.0, softMinValue=-10.0, softMaxValue=10.0, keyable=True, longName="offsetZ") # Publish new attrs to container self.publishNameToModuleContainer(moduleGrp + ".offsetY", "interpolator_offsetY", publishToOuterContainers=True) self.publishNameToModuleContainer(moduleGrp + ".offsetZ", "interpolator_offsetZ", publishToOuterContainers=True) # Create a node to inverse offset inverseNode = cmds.shadingNode("multiplyDivide", asUtility=True, n=moduleGrp + "_offsetInverse") containedNodes.append(inverseNode) cmds.connectAttr(moduleGrp + ".offsetY", inverseNode + ".input1Y") cmds.connectAttr(moduleGrp + ".offsetZ", inverseNode + ".input1Z") cmds.setAttr(inverseNode + ".input2Y", -1) cmds.setAttr(inverseNode + ".input2Z", -1) # Setup interpolators numStretchyIKJoints = len(stretchyIKJoints) - 1 interpolators_ikParents = [] aimChildren = [] for i in range(1, numStretchyIKJoints): if i > 1: # Create a group to follow each joint jointFollower = cmds.group(empty=True, n=stretchyIKJoints[i] + "_follower") containedNodes.append(jointFollower) # Parent the group to the joint we are following cmds.parent(jointFollower, moduleGrp, relative=True) containedNodes.append( cmds.parentConstraint(stretchyIKJoints[i], jointFollower, maintainOffset=False, n=jointFollower + "_parentConstraint")[0]) offset = cmds.group(empty=True, n=stretchyIKJoints[i] + "_interpolatorOffset") containedNodes.append(offset) # parent the offset group to the follower group cmds.parent(offset, jointFollower, relative=True) cmds.connectAttr(moduleGrp + ".offsetY", offset + ".translateY") cmds.connectAttr(moduleGrp + ".offsetZ", offset + ".translateZ") name = utils.stripAllNamespaces( joints[i])[1] + "_offsetControl" controlObjectInstance = controlObject.ControlObject() offsetControlObject = controlObjectInstance.create( name, "cubeLocator.ma", self, lod=2, translation=True, rotation=False, globalScale=False, spaceSwitching=False)[0] # parent control object under offset group cmds.parent(offsetControlObject, offset, relative=True) offsetCancelation = cmds.group(empty=True, n=stretchyIKJoints[i] + "interpolatorOffsetCancelation") containedNodes.append(offsetCancelation) cmds.parent(offsetCancelation, offsetControlObject, relative=True) cmds.connectAttr(inverseNode + ".outputY", offsetCancelation + ".translateY") cmds.connectAttr(inverseNode + ".outputZ", offsetCancelation + ".translateZ") interpolators_ikParents.append(offsetCancelation) aimChild = cmds.group(empty=True, n=stretchyIKJoints[i] + "_aimChild") containedNodes.append(aimChild) aimChildren.append(aimChild) if i > 1: cmds.parent(aimChild, offsetCancelation, relative=True) print "parent offset cancel" else: cmds.parent(aimChild, stretchyIKJoints[i], relative=True) cmds.setAttr(aimChild + ".translateY", -1) # Make use of interpolation nodes for i in range(1, numStretchyIKJoints): ikNodes = utils.basic_stretchy_IK( joints[i], joints[i + 1], container=moduleContainer, scaleCorrectionAttribute=self.blueprintNamespace + ":module_grp.hierarchicalScale", lockMinimumLength=False, poleVectorObject=aimChildren[i - 1]) ikHandle = ikNodes["ikHandle"] rootLocator = ikNodes["rootLocator"] endLocator = ikNodes["endLocator"] for loc in (ikHandle, rootLocator): cmds.parent(loc, moduleGrp, absolute=True) utils.matchTwistAngle(ikHandle + ".twist", [ joints[i], ], [ stretchyIKJoints[i], ]) if i == 1: if createRootControl: containedNodes.append( cmds.pointConstraint(rootControlObject, joints[i], maintainOffset=False, n=joints[i] + "_pointConstraint")[0]) cmds.setAttr(endLocator + ".translate", 0.0, 0.0, 0.0, type="double3") if i < numStretchyIKJoints - 1: cmds.parent(endLocator, interpolators_ikParents[i - 1], relative=True) else: cmds.parent(endLocator, endControlObject, relative=True) cmds.setAttr(moduleGrp + ".lod", 2) utils.addNodeToContainer(moduleContainer, containedNodes, ihb=True) # Publish joints to module container. for joint in stretchyIKJoints: jointName = utils.stripAllNamespaces(joint)[1] self.publishNameToModuleContainer(joint + ".rotate", jointName + "_R", publishToOuterContainers=False) self.publishNameToModuleContainer(joint + ".translate", jointName + "_T", publishToOuterContainers=False)
def UI(self, parentLayout): globalControl = self.blueprintNamespace + ":" + self.moduleNamespace + ":globalControl" controlObjectInstance = controlObject.ControlObject(globalControl) controlObjectInstance.UI(parentLayout)
def spaceSwitching_spaceSwitch(self, controlObj, targetObject, *args): controlObjectInstance = controlObject.ControlObject(controlObj) controlObjectInstance.switchSpace_UI(targetObject)
def install_custom(self, joints, moduleGrp, moduleContainer): ankleJoint = joints[3] ballJoint = joints[4] toeJoint = joints[5] tempLocator = cmds.spaceLocator()[0] cmds.parent(tempLocator, ballJoint, relative=True) cmds.parent(tempLocator, moduleGrp, absolute=True) ballJoint_modulePos = [cmds.getAttr(tempLocator+".translateX"), cmds.getAttr(tempLocator+".translateY"), cmds.getAttr(tempLocator+".translateZ")] cmds.parent(tempLocator, ankleJoint) for attr in [".translateX", ".translateY", ".translateZ"]: cmds.setAttr(tempLocator+attr, 0) cmds.parent(tempLocator, moduleGrp, absolute=True) ankleJoint_modulePos = [cmds.getAttr(tempLocator+".translateX"), cmds.getAttr(tempLocator+".translateY"), cmds.getAttr(tempLocator+".translateZ")] cmds.parent(tempLocator, toeJoint) for attr in [".translateX", ".translateY", ".translateZ"]: cmds.setAttr(tempLocator+attr, 0) cmds.parent(tempLocator, moduleGrp, absolute=True) toeJoint_modulePos = [cmds.getAttr(tempLocator+".translateX"), cmds.getAttr(tempLocator+".translateY"), cmds.getAttr(tempLocator+".translateZ")] cmds.delete(tempLocator) containedNodes = [] # Pass in functionality from basic IK ikNodes = circleIK.CircleControlStretchyIK.install_custom(self, joints, moduleGrp, moduleContainer, createHandleControl=False, poleVectorAtRoot=False) ikEndPosLocator = ikNodes["endLocator"] ikPoleVectorLocator = ikNodes["poleVectorObject"] stretchinessAttribute = ikNodes["stretchinessAttribute"] name = "footControl" controlObjectInstance = controlObject.ControlObject() footControlInfo = controlObjectInstance.create(name, "footControl.ma", self, lod=1, translation=True, rotation=True, globalScale=False, spaceSwitching=True) footControl = footControlInfo[0] footControlRootParent = footControlInfo[1] # Parent foot control to root parent cmds.parent(footControlRootParent, moduleGrp, relative=True) # Position and orient foot control footControlPos = [ankleJoint_modulePos[0], ballJoint_modulePos[1], ankleJoint_modulePos[2]] cmds.xform(footControl, objectSpace=True, absolute=True, translation=footControlPos) cmds.setAttr(footControl+".rotateOrder", 3) #3 = xyz orientationVector = [toeJoint_modulePos[0] - ankleJoint_modulePos[0], toeJoint_modulePos[2] - ankleJoint_modulePos[2] ] footControlRotation = atan2(orientationVector[1], orientationVector[0]) cmds.setAttr(footControl+".rotateY", -degrees(footControlRotation)) # Hookup stretchiness attribute cmds.select(footControl) cmds.addAttr(at="float", minValue=0.0, maxValue=1.0, defaultValue=1.0, keyable=True, longName="stretchiness") self.publishNameToModuleContainer(footControl+".stretchiness", "stretchiness", publishToOuterContainers=True) cmds.connectAttr(footControl+".stretchiness", stretchinessAttribute, force=True) # Setup for ball and Toe controls ballToeControls = [] ballToeControl_orientGrps = [] for joint in [ballJoint, toeJoint]: controlObjectInstance = controlObject.ControlObject() jointName = utils.stripAllNamespaces(joint)[1] name = jointName + "_ryControl" ryControlInfo = controlObjectInstance.create(name, "yAxisCircle.ma", self, lod=2, translation=False, rotation=[True, True, True], globalScale=False, spaceSwitching=False) ryControl = ryControlInfo[0] ballToeControls.append(ryControl) orientGrp = cmds.group(empty=True, n=ryControl+"_orientGrp") containedNodes.append(orientGrp) ballToeControl_orientGrps.append(orientGrp) # Constrain to inherit orientations orientGrp_parentConstraint = cmds.parentConstraint(joint, orientGrp, maintainOffset=False) cmds.delete(orientGrp_parentConstraint) cmds.parent(ryControl, orientGrp, relative=True) for grp in ballToeControl_orientGrps: cmds.parent(grp, moduleGrp, absolute=True) # Constrain ball control containedNodes.append(cmds.parentConstraint(footControl, ballToeControl_orientGrps[1], maintainOffset=True, n=ballToeControl_orientGrps[1] + "_parentConstraint")[0]) # Constrain toe control containedNodes.append(cmds.parentConstraint(ballToeControls[1], ballToeControl_orientGrps[0], maintainOffset=True, n=ballToeControl_orientGrps[0] + "_parentConstraint")[0]) # Connect IK handles cmds.parent(ikEndPosLocator, ballToeControls[0], absolute=True) cmds.parent(ikPoleVectorLocator, ballToeControls[0], absolute=True) # Ankle IK ankleIKNodes = cmds.ikHandle(sj=ankleJoint, ee=ballJoint, solver="ikSCsolver", n=ankleJoint+"_ikHandle") ankleIKNodes[1] = cmds.rename(ankleIKNodes[1], ankleIKNodes[1]+"_ikEffector") containedNodes.extend(ankleIKNodes) cmds.parent(ankleIKNodes[0], ballToeControls[0]) cmds.setAttr(ankleIKNodes[0]+".visibility", 0) #Ball IK ballIKNodes = cmds.ikHandle(sj=ballJoint, ee=toeJoint, solver="ikSCsolver", n=ballJoint+"_ikHandle") ballIKNodes[1] = cmds.rename(ballIKNodes[1], ballIKNodes[1]+"_ikEffector") containedNodes.extend(ballIKNodes) cmds.parent(ballIKNodes[0], ballToeControls[1]) cmds.setAttr(ballIKNodes[0]+".visibility", 0) utils.addNodeToContainer(moduleContainer, containedNodes, ihb=True)
def install_custom(self, joints, moduleGrp, moduleContainer): containedNodes = [] rootJoint = joints[1] endJoint = joints[len(joints)-1] ikNodes = utils.basic_stretchy_IK(rootJoint, endJoint, container=moduleContainer, scaleCorrectionAttribute=self.blueprintNamespace+":module_grp.hierarchicalScale") ikHandle = ikNodes["ikHandle"] rootLocator = ikNodes["rootLocator"] endLocator = ikNodes["endLocator"] poleVectorLocator = ikNodes["poleVectorObject"] stretchinessAttribute = ikNodes["stretchinessAttribute"] # Create controls and parent ikHandles for node in [rootLocator, ikHandle, poleVectorLocator]: cmds.parent(node, moduleGrp, absolute=True) name = "ikHandleControl" # controlObject class controlObjectInstance = controlObject.ControlObject() handleControlInfo = controlObjectInstance.create(name, "cubeLocator.ma", self, lod=1, translation=True, rotation=False, globalScale=False, spaceSwitching=True) handleControl = handleControlInfo[0] handleRootParent = handleControlInfo[1] cmds.parent(handleRootParent, moduleGrp, relative=True) cmds.xform(handleControl, worldSpace=True, absolute=True, translation=cmds.xform(endLocator, q=True, worldSpace=True, translation=True)) cmds.parent(endLocator, handleControl, absolute=True) # Create a pre-transform node that sits above the control object. handleControlParent = cmds.listRelatives(handleControl, parent=True)[0] preTransform = cmds.group(empty=True, n=handleControl+"_preTransform") containedNodes.append(preTransform) cmds.parent(preTransform, handleControl, relative=True) cmds.parent(preTransform, handleControlParent, absolute=True) cmds.parent(handleControl, preTransform, absolute=True) #Add attributes to control cmds.select(handleControl) cmds.addAttr(at="float", minValue=0.0, maxValue=1.0, defaultValue=1.0, keyable=True, longName="stretchiness") cmds.addAttr(at="float", softMinValue=-360.0, softMaxValue=360.0, defaultValue=0.0, keyable=True, longName="twist") #connect attrs cmds.connectAttr(handleControl+".twist", ikHandle+".twist") cmds.connectAttr(handleControl+".stretchiness", stretchinessAttribute) # Add attrs to container self.publishNameToModuleContainer(handleControl+".twist", "twist", publishToOuterContainers=True) self.publishNameToModuleContainer(handleControl+".stretchiness", "stretchiness", publishToOuterContainers=True) # 171 > jointName = utils.stripAllNamespaces(rootJoint)[1] ikJoints = utils.findJointChain(rootJoint) targetJoints = utils.findJointChain(self.blueprintNamespace+":creationPose_"+jointName) utils.matchTwistAngle(handleControl+".twist", ikJoints, targetJoints) offsetNode = cmds.shadingNode("plusMinusAverage", asUtility=True, n=handleControl+"_twistOffset") containedNodes.append(offsetNode) cmds.setAttr(offsetNode+".input1D[0]", cmds.getAttr(handleControl+".twist")) cmds.connectAttr(handleControl+".twist", offsetNode+".input1D[1]") cmds.connectAttr(offsetNode+".output1D", ikHandle+".twist", force=True) cmds.setAttr(handleControl+".twist", 0.0) # < 171 utils.addNodeToContainer(moduleContainer, containedNodes)