def setupSpaceSwitching(self, blueprintModuleNamespace, animationModuleNamespace, animationModuleInstance): cmds.select(self.controlObject, replace=True) # Do we have spaceswitching and is it orientation only cmds.addAttr(at="bool", defaultValue=True, keyable=False, longName="spaceSwitching") cmds.addAttr(at="bool", defaultValue=False, keyable=False, longName="switchOrientationOnly") spaceSwitcher = cmds.group(empty=True, name=self.controlObject + "_spaceSwitcher") if self.translation != [True, True, True]: cmds.setAttr(self.controlObject + ".switchOrientationOnly", True) cmds.parent(self.rootParent, spaceSwitcher, absolute=True) self.rootParent = spaceSwitcher utils.addNodeToContainer( animationModuleNamespace + ":module_container", spaceSwitcher) self.switchSpace(blueprintModuleNamespace + ":HOOK_IN", "Module Hook") controlObjectName = utils.stripAllNamespaces(self.controlObject)[1] animationModuleInstance.publishNameToModuleContainer( spaceSwitcher + ".currentSpace", controlObjectName + "_currentSpace", publishToOuterContainers=True)
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 installTemplate(self, templateAndPath, *args): cmds.file(templateAndPath, i=True, namespace='TEMPLATE_1') self.resolveNamespaceClashes('TEMPLATE_1') groupContainer = 'TEMPLATE_1:Group_container' if cmds.objExists(groupContainer): self.resolveGroupNameClashes('TEMPLATE_1') cmds.lockNode(groupContainer, lock=False, lockUnpublished=False) oldGroupContainer ='Group_container' if cmds.objExists(oldGroupContainer): cmds.lockNode(oldGroupContainer, lock=False, lockUnpublished=False) nodeList = cmds.container(groupContainer, q=True, nodeList=True) utils.addNodeToContainer(oldGroupContainer, nodeList, force=True) cmds.delete(groupContainer) else: cmds.rename(groupContainer, oldGroupContainer) cmds.lockNode('Group_container', lock=True, lockUnpublished=True) cmds.namespace(setNamespace=':') cmds.namespace(moveNamespace=('TEMPLATE_1',':'), force=True) cmds.namespace(removeNamespace='TEMPLATE_1')
def createFKControl(self, joint, parent, moduleContainer): jointName = utils.stripAllNamespaces(joint)[1] containedNodes = [] name = jointName + "_fkControl" fkControl = cmds.sphere(n=joint+ "_fkControl")[0] utils.addNodeToContainer(moduleContainer, fkControl, ihb=True) self.publishNameToModuleContainer(fkControl+".rotate", name+"_R", publishToOuterContainers=True) cmds.connectAttr(joint+".rotateOrder", fkControl+".roatateOrder") orientGrp = cmds.group(n=fkControl+"_orientGrp", empty=True, parent=parent) containedNodes.append(orientGrp) orientGrp_parentConstraint = cmds.parentConstraint(joint, orientGrp, maintainOffset=False)[0] cmds.delete(orientGrp_parentConstraint) jointParent = cmds.listRelatives(joint, parent=True)[0] orientGrp_parentConstraint = cmds.parentConstraint(jointParent, orientGrp, maintainOffset=True, n=orientGrp+"_parentConsraint")[0] orientGrp_scaleConstraint = cmds.scaleConstraint(jointParent, orientGrp, maintainOffset=True, n=orientGrp+"_scaleConsraint")[0] containedNodes.extend(orientGrp_parentConstraint, orientGrp_scaleConstraint) cmds.parent(fkControl, orientGrp, relative=True) orientContstraint = cmds.orientConstraint(fkControl, joint, maintainOffset=False, n=joint+"_orientConstraint")[0] containedNodes.append(orientConstraint) utils.addNodeToContainer(moduleContainer, containedNodes) return fkControl
def setupStretchyJointSegment(self, parentJoint, childJoint): parentTranslationControl = self.getTranslationControl(parentJoint) childTranslationControl = self.getTranslationControl(childJoint) poleVectorLocator = cmds.spaceLocator (n=parentTranslationControl + '_poleVectorLocator')[0] poleVectorLocatorGrp = cmds.group(poleVectorLocator, n=(poleVectorLocator + '_parentConstraintGrp')) cmds.parent(poleVectorLocatorGrp, self.moduleGrp, absolute=True) parentConstraint = cmds.parentConstraint(parentTranslationControl,poleVectorLocatorGrp,maintainOffset=False)[0] cmds.setAttr((poleVectorLocator + '.visibility'), 0) cmds.setAttr((poleVectorLocator + '.ty'), -0.5) ikNodes = utils.basic_stretchy_IK(parentJoint, childJoint, container=self.containerName, lockMinimumLength=False, poleVectorObject=poleVectorLocator,scaleCorrectionAttribute=None) ikHandle = ikNodes['ikHandle'] rootLocator = ikNodes['rootLocator'] endLocator = ikNodes['endLocator'] if self.mirrored: if self.mirrorPlane == 'XZ': cmds.setAttr(ikHandle + '.twist', 90) childPointConstraint = cmds.pointConstraint(childTranslationControl, endLocator, maintainOffset=False, n=(endLocator + '_pointConstraint'))[0] utils.addNodeToContainer(self.containerName, [poleVectorLocatorGrp,parentConstraint,childPointConstraint],ihb=True ) for node in [ikHandle,rootLocator, endLocator]: cmds.parent(node, self.jointsGrp, absolute=True) cmds.setAttr((node + '.visibility'),0) self.createHierarchyRepresentation(parentJoint,childJoint)
def setupMirroring(self, blueprintModuleNamespace, animationModuleNamespace, axisInverse): moduleGrp = blueprintModuleNamespace + ':module_grp' if cmds.attributeQuery('mirrorInfo',n=moduleGrp, exists=True): enumValue = cmds.getAttr(moduleGrp+'.mirrorInfo') if enumValue == 0: # 'None' return mirrorAxis = '' if enumValue == 1: mirrorAxis = 'X' elif enumValue == 2: mirrorAxis = 'Y' elif enumValue == 3: mirrorAxis = 'Z' mirrorGrp = cmds.group(empty=True, name=self.controlObject+'_mirror_grp') self.rootParent = mirrorGrp cmds.parent(self.controlObject, mirrorGrp, absolute=True) cmds.setAttr(mirrorGrp+'.scale'+mirrorAxis, -1) cmds.setAttr(axisInverse+'.scale'+mirrorAxis, -1) utils.addNodeToContainer(animationModuleNamespace+':module_container',mirrorGrp)
def createPreferredAngleRepresentation(self,joint,scaleTarget, childOfOrientationControl=False): paRepresentationFile = os.environ['RIGGING_TOOL_ROOT'] + '/ControlObjects/Blueprint/preferredAngle_representation.ma' cmds.file(paRepresentationFile, i=True) container = cmds.rename('preferredAngle_representation_container', joint + '_preferredAngle_representation_container') utils.addNodeToContainer(self.containerName, container) for node in cmds.container(container, q=True, nodeList=True): cmds.rename(node, joint + '_' + node, ignoreShape=True) control = joint + '_preferredAngle_representation' controlName = utils.stripAllNamespaces(control)[1] cmds.container(self.containerName,edit=True, publishAndBind=[container + '.axis' , controlName + '_axis']) controlGroup = cmds.group(control, n=joint + '_preferredAngle_parentConstraintGrp',absolute=True) containedNodes = [controlGroup] cmds.parent(controlGroup, self.preferredAngleRepresentationGrp, absolute=True) containedNodes.append(cmds.parentConstraint(joint, controlGroup, maintainOffset=False)[0]) if childOfOrientationControl: rotateXGrp = cmds.group(control, n=control + '_rotateX_grp', absolute=True) orientationControl = self.getOrientationControl(joint) cmds.connectAttr(orientationControl + '.rotateX', rotateXGrp + '.rotateX') containedNodes.append(rotateXGrp) containedNodes.append(cmds.scaleConstraint(scaleTarget, controlGroup, maintainOffset=False)[0]) utils.addNodeToContainer(container, containedNodes) return control
def installTemplate(self, templateAndPath, *args): cmds.file(templateAndPath, i=True, namespace="TEMPLATE_1") self.resolveNamespaceClashes("TEMPLATE_1") groupContainer = "TEMPLATE_1:Group_container" if cmds.objExists(groupContainer): self.resolveGroupNameClashes("TEMPLATE_1") cmds.lockNode(groupContainer, lock=False, lockUnpublished=False) oldGroupContainer = "Group_container" if cmds.objExists(oldGroupContainer): cmds.lockNode(oldGroupContainer, lock=False, lockUnpublished=False) nodeList = cmds.container(groupContainer, q=True, nodeList=True) utils.addNodeToContainer(oldGroupContainer, nodeList, force=True) cmds.delete(groupContainer) else: cmds.rename(groupContainer, oldGroupContainer) cmds.lockNode("Group_container", lock=True, lockUnpublished=True) cmds.namespace(setNamespace=":") cmds.namespace(moveNamespace=("TEMPLATE_1",":"), force=True) cmds.namespace(removeNamespace="TEMPLATE_1")
def setupMirroring(self, blueprintModuleNamespace, animationModuleNamespace, axisInverse): moduleGrp = blueprintModuleNamespace + ":module_grp" if cmds.attributeQuery("mirrorInfo", n=moduleGrp, exists=True): enumValue = cmds.getAttr(moduleGrp + ".mirrorInfo") if enumValue == 0: # "None" return mirrorAxis = "" if enumValue == 1: mirrorAxis = "X" elif enumValue == 2: mirrorAxis = "Y" elif enumValue == 3: mirrorAxis = "Z" mirrorGrp = cmds.group(empty=True, name=self.controlObject + "_mirror_grp") self.rootParent = mirrorGrp cmds.parent(self.controlObject, mirrorGrp, absolute=True) cmds.setAttr(mirrorGrp + ".scale" + mirrorAxis, -1) cmds.setAttr(axisInverse + ".scale" + mirrorAxis, -1) utils.addNodeToContainer( animationModuleNamespace + ":module_container", mirrorGrp)
def createSingleOrientationControlAtJoint(self,joint): controlFile = os.environ['RIGGING_TOOL_ROOT'] + '/ControlObjects/Blueprint/singleJointOrientation_control.ma' cmds.file(controlFile, i=True) container = cmds.rename('singleJointOrientation_control_container', joint + '_singleJointOrientation_control_container') utils.addNodeToContainer(self.containerName, container) for node in cmds.container(container, q=True, nodeList=True): cmds.rename(node, joint + '_' + node, ignoreShape=True) control = joint + '_singleJointOrientation_control' cmds.parent(control, self.moduleTransform, absolute=True) translationControl = self.getTranslationControl(joint) pointConstraint = cmds.pointConstraint(translationControl, control, maintainOffset=False, n=control + '_pointConstraint')[0] utils.addNodeToContainer(self.containerName, pointConstraint) jointOrient = cmds.xform(joint, q=True, worldSpace=True, rotation=True) cmds.xform(control, worldSpace=True, absolute=True, rotation=jointOrient) jointNameWithoutNamespace = utils.stripLeadingNamespace(joint)[1] attrName = jointNameWithoutNamespace + '_R' cmds.container(container, edit=True, publishAndBind=[control+'.rotate', attrName]) cmds.container(self.containerName, edit=True, publishAndBind=[container + '.' + attrName, attrName]) return control
def install_custom(self, joints): cmds.select(clear=True) ikJoints=[] if not self.mirrored: index=0 for joint in self.jointInfo: ikJoints.append(cmds.joint(n=self.moduleNamespace+":IK_"+joint[0], p=joint[1], absolute=True)) cmds.setAttr(ikJoints[index]+".visibility",0) if index!=0: cmds.joint(ikJoints[index-1],edit=True, oj="xyz", sao="yup") index+=1 else: rootJointName=self.jointInfo[0][0] tempDuplicateNodes=cmds.duplicate(self.originalModule+":IK_"+rootJointName, renameChildren=True) cmds.delete(tempDuplicateNodes.pop()) mirrorXY=False mirrorYZ=False mirrorXZ=False if self.mirrorPlane=="XY": mirrorXY=True elif self.mirrorPlane=="YZ": mirrorYZ=True elif self.mirrorPlane=="XZ": mirrorXZ=True mirrorBehavior=False if self.rotationFunction=="behaviour": mirrorBehaviour=True mirrorJoints=cmds.mirrorJoint(tempDuplicateNodes[0], mirrorXY=mirrorXY, mirrorYZ=mirrorYZ, mirrorXZ=mirrorXZ, mirrorBehavior=mirrorBehavior) cmds.delete(tempDuplicateNodes) cmds.xform(mirrorJoints[0], worldSpace=True, absolute=True, translation=cmds.xform(self.moduleNamespace+":"+rootJointName, q=True, worldSpace=True, translation=True)) for i in range(3): jointName=self.jointInfo[i][0] newName=cmds.rename(mirrorJoints[i], self.moduleNamespace+":IK_"+jointName) ikJoints.append(newName) utils.addNodeToContainer(self.containerName, ikJoints) for joint in ikJoints: jointName=utils.stripAllNamespaces(joint)[1] cmds.container(self.containerName, edit=True, publishAndBind=[joint+".rotate", jointName+"_R"]) cmds.setAttr(ikJoints[0]+".preferredAngleY", -50.0) cmds.setAttr(ikJoints[1]+".preferredAngleY", 50.0) ikNodes=utils.RP_2segment_stretchy_IK(ikJoints[0], ikJoints[1], ikJoints[2], self.containerName) locators=(ikNodes[0], ikNodes[1], ikNodes[2]) distanceNodes=ikNodes[3] constraints=[] for i in range(3): constraints.append(cmds.pointConstraint(self.getTranslationControl(joints[i]), locators[i], maintainOffset=False)[0]) cmds.parent(locators[i],self.moduleNamespace+":module_grp", absolute=True) cmds.setAttr(locators[i]+".visibility",0) utils.addNodeToContainer(self.containerName, constraints) scaleTarget=self.getTranslationControl(joints[1]) paRepresentation=self.createPreferredAngleRepresentation(ikJoints[1], scaleTarget) cmds.setAttr(paRepresentation+".axis",lock=True) #107
def addGroupToContainer(self,group): groupContainer = 'Group_container' utils.addNodeToContainer(groupContainer, group, includeShapes=True) groupName = group.partition('Group__')[2] cmds.container(groupContainer, edit=True, publishAndBind=[(group + '.translate'), (groupName + '_t')]) cmds.container(groupContainer, edit=True, publishAndBind=[(group + '.rotate'), (groupName + '_r')]) cmds.container(groupContainer, edit=True, publishAndBind=[(group + '.globalScale'), (groupName + '_globalScale')])
def addGroupToContainer(self, group): groupContainer = "Group_container" utils.addNodeToContainer(groupContainer, group, includeShapes=True) groupName = group.partition("Group__")[2] cmds.container(groupContainer, edit=True, publishAndBind=[group+".translate", groupName+"_t"]) cmds.container(groupContainer, edit=True, publishAndBind=[group+".rotate", groupName+"_r"]) cmds.container(groupContainer, edit=True, publishAndBind=[group+".globalScale", groupName+"_globalScale"])
def createFKControl(self, joint, parent, moduleContainer): fkControlInfo = self.initFKControl(joint, spaceSwitchable=True) fkControl = fkControlInfo[0] rootControlParent = fkControlInfo[1] translationControl = fkControlInfo[2] cmds.parent(rootControlParent, parent, relative=True) pointConstraint = "" if translationControl: cmds.xform(fkControl, worldSpace=True, a=True, translation=cmds.xform(joint, q=True, ws=True, translation=True)) pointConstraint = cmds.pointConstraint(fkControl, joint, mo=False, n=joint+"_pointConstraint")[0] else: pointConstraint = cmds.pointConstraint(joint, rootControlParent, maintainOffset=False, n=rootControlParent+"_pointConstraint")[0] jointOrientation = cmds.xform(joint, q=True, ws=True, rotation=True) cmds.xform(fkControl, ws=True, a=True, rotation=jointOrientation) children = cmds.listRelatives(joint, children=True, type="joint") childJoint = None if children == None: childJoint = cmds.duplicate(joint, n=joint+"_child")[0] utils.addNodeToContainer(moduleContainer, childJoint) cmds.parent(childJoint, joint, a=True) cmds.setAttr(childJoint+".translateX", 1.0) else: childJoint = children[0] ikNodes = cmds.ikHandle(sj=joint, ee=childJoint, n=joint+"_ikHandle", sol="ikRPsolver") ikNodes[1] = cmds.rename(ikNodes[1], joint+"_effector") ikHandle = ikNodes[0] cmds.parent(ikHandle, fkControl, a=True) poleVectorLocator = cmds.spaceLocator(n=joint+"_poleVectorLoc")[0] cmds.parent(poleVectorLocator, joint, relative=True) cmds.setAttr(poleVectorLocator+".translateY", 3) cmds.parent(poleVectorLocator, fkControl, a=True) for node in [poleVectorLocator, ikHandle]: cmds.setAttr(node+".visibility", 0) jointName = utils.stripAllNamespaces(joint)[1] creationPoseJoint = self.blueprintNamespace + ":creationPose_" + jointName utils.matchTwistAngle(ikHandle+".twist", [joint,], [creationPoseJoint,]) containedNodes = list(ikNodes) containedNodes.append(pointConstraint) containedNodes.append(poleVectorLocator) utils.addNodeToContainer(moduleContainer, containedNodes)
def installDuplicate(self,duplicatePath, selection, *args): cmds.file(duplicatePath, i=True, namespace='TEMPLATE_1') moduleNames = self.resolveNamespaceClashes('TEMPLATE_1') groupNames = self.resolveGroupNameClashes('TEMPLATE_1') groups = [] for name in groupNames: groups.append(name[1]) if len(groups) > 0: sceneGroupContainer = 'Group_container' cmds.lockNode(sceneGroupContainer, lock=False, lockUnpublished=False) utils.addNodeToContainer(sceneGroupContainer, groups, includeShapes=True, force=True) for group in groups: groupNiceName = group.partition('__')[2] cmds.container(sceneGroupContainer, edit=True, publishAndBind=[group+'.translate',groupNiceName+'_t']) cmds.container(sceneGroupContainer, edit=True, publishAndBind=[group+'.rotate',groupNiceName+'_r']) cmds.container(sceneGroupContainer, edit=True, publishAndBind=[group+'.globalScale',groupNiceName+'_globalScale']) cmds.lockNode(sceneGroupContainer, lock=True, lockUnpublished=True) cmds.namespace(setNamespace=':') cmds.namespace(moveNamespace=('TEMPLATE_1',':'),force=True) cmds.namespace(removeNamespace='TEMPLATE_1') newSelection = [] for node in selection: found = False for group in groupNames: oldName = group[0].partition('TEMPLATE_1:')[2] newName = group[1] if node == oldName: newSelection.append(newName) found = True break if not found: nodeNamespaceInfo = utils.stripLeadingNamespace(node) if nodeNamespaceInfo != None: nodeNamespace = nodeNamespaceInfo[0] nodeName = nodeNamespaceInfo[1] searchName = 'TEMPLATE_1:' + nodeNamespace for module in moduleNames: if module[0] == searchName: newSelection.append(module[1] + ':' + nodeName) if len(newSelection) > 0: cmds.select(newSelection, replace=True)
def install_init(self): cmds.namespace(setNamespace=self.blueprintNamespace) cmds.namespace(add=self.moduleNamespace) cmds.namespace(setNamespace=":") characterContainer = self.characterNamespaceOnly+":character_container" blueprintContainer = self.blueprintNamespace+":module_container" containers = [characterContainer, blueprintContainer] for c in containers: cmds.lockNode(c, lock=False, lockUnpublished=False) # Duplicate creation pose joints to create new instance. Stored in external method. self.joints = self.duplicateAndRenameCreationPose() moduleJointsGrp = self.joints[0] # Group everything for animation module and parent to "Hook_IN_Grp" moduleGrp = cmds.group(empty=True, name=self.blueprintNamespace+":"+self.moduleNamespace+":module_grp") hookIn = self.blueprintNamespace+":HOOK_IN" cmds.parent(moduleGrp, hookIn, relative=True) cmds.parent(moduleJointsGrp, moduleGrp, absolute=True) # Attr to define icon size. cmds.select(moduleGrp) cmds.addAttr(at="float", ln="iconScale", min=0.001, softMaxValue=10.0, defaultValue=1, k=True) cmds.setAttr(moduleGrp+".overrideEnabled", 1) cmds.setAttr(moduleGrp+".overrideColor", 6) utilityNodes = self.setupBlueprintWeightBasedBlending() self.setupModuleVisibility(moduleGrp) containedNodes = list(self.joints) containedNodes.append(moduleGrp) containedNodes.extend(utilityNodes) self.moduleContainer = cmds.container(n=self.moduleContainer) utils.addNodeToContainer(self.moduleContainer, containedNodes, ihb=True) utils.addNodeToContainer(blueprintContainer, self.moduleContainer) #151 index = 0 publishToOuterContainers=False for joint in self.joints: if index > 0: niceJointName = utils.stripAllNamespaces(joint)[1] self.publishNameToModuleContainer(joint+".rotate", niceJointName+"_R", publishToOuterContainers=False) publishToOuterContainers=False index += 1 self.publishNameToModuleContainer(moduleGrp+".lod", "Control_LOD") self.publishNameToModuleContainer(moduleGrp+".iconScale", "Icon_Scale") self.publishNameToModuleContainer(moduleGrp+".overrideColor", "Icon_Color") self.publishNameToModuleContainer(moduleGrp+".visibility", "Vis") self.publishNameToModuleContainer(moduleGrp+".visibility", "Vis", publishToOuterContainers=False) return (self.joints, moduleGrp, self.moduleContainer)
def install_custom(self, joints, moduleGrp, moduleContainer): controlsGrp = cmds.group(empty=True, name=self.blueprintNamespace+":"+self.moduleNamespace+":controls_grp") cmds.parent(controlsGrp, moduleGrp, absolute=True) utils.addNodeToContainer(moduleContainer, controlsGrp) numJoints = len(joints)-1 for i in range(1, len(joints)): if i < numJoints or numJoints == 1: self.createFKControl(joints[i], controlsGrp, moduleContainer)
def setup_interpolation(self, unlockContainer=False, *args): previousSelection = cmds.ls(selection=True) if unlockContainer: cmds.lockNode(self.containerName, lock=False, lockUnpublished=False) joints = self.getJoints() numberOfJoints = len(joints) startControl = self.getTranslationControl(joints[0]) endControl = self.getTranslationControl(joints[numberOfJoints - 1]) pointConstraints = [] for i in range(1, numberOfJoints - 1): material = joints[i] + "_m_translation_control" cmds.setAttr(material + ".colorR", 0.815) cmds.setAttr(material + ".colorG", 0.629) cmds.setAttr(material + ".colorB", 0.498) translationControl = self.getTranslationControl(joints[i]) endWeight = 0.0 + (float(i) / (numberOfJoints - 1)) startWeight = 1.0 - endWeight pointConstraints.append( cmds.pointConstraint(startControl, translationControl, maintainOffset=False, weight=startWeight)[0]) pointConstraints.append( cmds.pointConstraint(endControl, translationControl, maintainOffset=False, weight=endWeight)[0]) for attr in [".translateX", ".translateY", ".translateZ"]: cmds.setAttr(translationControl + attr, lock=True) interpolationContainer = cmds.container(n=self.moduleNamespace + ":interpolation_container") utils.addNodeToContainer(interpolationContainer, pointConstraints) utils.addNodeToContainer(self.containerName, interpolationContainer) if unlockContainer: cmds.lockNode(self.containerName, lock=True, lockUnpublished=True) if len(previousSelection) > 0: cmds.select(previousSelection, replace=True) else: cmds.select(clear=True)
def installDuplicate(self, duplicatePath, selection, *args): cmds.file(duplicatePath, i=True, namespace="TEMPLATE_1") moduleNames = self.resolveNamespaceClashes("TEMPLATE_1") groupNames = self.resolveGroupNameClashes("TEMPLATE_1") groups = [] for name in groupNames: groups.append(name[1]) if len(groups) > 0: sceneGroupContainer = "Group_container" cmds.lockNode(sceneGroupContainer, lock=False, lockUnpublished=False) utils.addNodeToContainer(sceneGroupContainer, groups, includeShapes=True, force=True) for group in groups: groupNiceName = group.partition("__")[2] cmds.container(sceneGroupContainer, edit=True, publishAndBind = [group+".translate", groupNiceName+"_t"]) cmds.container(sceneGroupContainer, edit=True, publishAndBind = [group+".rotate", groupNiceName+"_r"]) cmds.container(sceneGroupContainer, edit=True, publishAndBind = [group+".globalScale", groupNiceName+"_globalScale"]) cmds.lockNode(setNamespace=":") cmds.namespace(moveNamespace=("TEMPLATE_1", ":"), force=True) cmds.namespace(removeNamespace="TEMPLATE_1") newSelection = [] for node in selection: found = False for group in groupNames: oldName = group[0].partition("TEMPLATE_1:")[2] newName = group[1] if node == oldName: newSelection.append(newName) found = True break if not found: nodeNamespaceInfo = utils.stripLeadingNamespace(node) if nodeNamespaceInfo != None: nodeNamespace = nodeNamespaceInfo[0] nodeName = nodeNamespaceInfo[1] searchName = "TEMPLATE_1:" +nodeNamespace for module in moduleNames: if module[0] == searchName: newSelection.append(module[1] + ":" +nodeName) if len(newSelection) > 0: cmds.select(newSelection, replace=True)
def install_init(self): cmds.namespace(setNamespace=self.blueprintNamespace) cmds.namespace(add=self.moduleNamespace) cmds.namespace(setNamespace=":") characterContainer = self.characterNamespaceOnly+":character_container" blueprintContainer = self.blueprintNamespace+":module_container" containers = [characterContainer, blueprintContainer] for c in containers: cmds.lockNode(c, lock=False, lockUnpublished=False) self.joints = self.duplicateAndRenameCreationPose() moduleJointsGrp = self.joints[0] moduleGrp = cmds.group(empty=True,name=self.blueprintNamespace+":"+self.moduleNamespace+":module_grp") hookIn = self.blueprintNamespace+":HOOK_IN" cmds.parent(moduleGrp, hookIn, relative=True) cmds.parent(moduleJointsGrp, moduleGrp, absolute=True) cmds.select(moduleGrp) cmds.addAttr(at="float", ln="iconScale", min=0.001, softMaxValue=10.0, defaultValue=1, k=True) cmds.setAttr(moduleGrp+".overrideEnabled", 1) cmds.setAttr(moduleGrp+".overrideColor", 6) utilityNodes = self.setupBlueprintWeightBasedBlending() self.setupModuleVisibility(moduleGrp) containedNodes = list(self.joints) containerNodes.append(moduleGrp) containedNodes.extend(utilityNodes) self.moduleContainer = cmds.container(n=self.moduleContainer) utils.addNodeToContainer(self.moduleContainer, containedNodes, ihb=True) utils.addNodeToContainer(blueprintContainer, self.moduleContainer) index = 0 for joint in self.joints: if index > 0: niceJointName = utils.stripAllNamespaces(joint)[1] self.publisheNameToModuleContainer(joint+".rotate", niceJointName+"_R", publishToOuterContainers=False) index += 1 self.publishNameToModuleContainer(moduleGrp+".lod", "Control_LOD") self.publishNameToModuleContainer(moduleGrp+".iconScale", "Icon_Scale") self.publishNameToModuleContainer(moduleGrp+".overrideColor", "Icon_Colour") self.publishNameToModuleContainer(moduleGrp+".visibility", "Vis", publishNameToModuleContainers=False) return (self.joints, moduleGrp, self.moduleContainer)
def setupSymmetryMoveForObject(self, obj,mirrorObj, axis,translation=True, orientation=False, globalScale=False): duplicateObject = cmds.duplicate(obj, parentOnly=True, inputConnections=True, name=obj + '_mirrorHelper')[0] emptyGroup = cmds.group(empty=True, name=obj + 'mirror_scale_grp') cmds.parent(duplicateObject, emptyGroup, absolute=True) scaleAttribute = '.scale' + axis cmds.setAttr(emptyGroup + scaleAttribute, -1) #expressionString = 'namespace -setNamespace \":\";\n' original script expressionString = "" if translation: expressionString += '$worldSpacePos = `xform -q -ws -translation ' + obj + '`;\n' if orientation: expressionString += '$worldSpaceOrient = `xform -q -ws -rotation ' + obj + '`;\n' attrs = [] if translation: attrs.extend(['.translateX', '.translateY', '.translateZ']) if orientation: attrs.extend(['.rotateX', '.rotateY', '.rotateZ']) for attr in attrs: expressionString += duplicateObject + attr + ' = ' + obj + attr + ';\n' i = 0 for axis in ['X','Y', 'Z']: if translation: expressionString += duplicateObject + '.translate' + axis + ' = $worldSpacePos[' + str(i) + '];\n' if orientation: expressionString += duplicateObject + '.rotate' + axis + ' = $worldSpaceOrient[' + str(i) + '];\n' i += 1 if globalScale: expressionString += duplicateObject + '.globalScale = ' + obj + '.globalScale;\n' #expression = cmds.expression(n=duplicateObject + '_symmetryMoveExpression', string=expressionString) original script expression = cmds.expression(n="tempName_symmetryMoveExpression ", string=expressionString) constraint = '' if translation and orientation: constraint = cmds.parentConstraint(duplicateObject, mirrorObj, maintainOffset=False, n=mirrorObj + '_symmetryMoveConstraint')[0] elif translation: constraint = cmds.pointConstraint(duplicateObject, mirrorObj, maintainOffset=False, n=mirrorObj + '_symmetryMoveConstraint')[0] elif orientation: constraint = cmds.orientConstraint(duplicateObject, mirrorObj, maintainOffset=False, n=mirrorObj + '_symmetryMoveConstraint')[0] if globalScale: cmds.connectAttr(duplicateObject + '.globalScale', mirrorObj + '.globalScale') utils.addNodeToContainer('symmetryMove_container', [duplicateObject, emptyGroup, expression, constraint], ihb=True)
def install_init(self): cmds.namespace(setNamespace=self.blueprintNamespace) cmds.namespace(add=self.moduleNamespace) cmds.namespace(setNamespace=':') characterContainer = self.characterNamespaceOnly + ':character_container' blueprintContainer = self.blueprintNamespace + ':module_container' containers = [characterContainer,blueprintContainer] for c in containers: cmds.lockNode(c, lock=False, lockUnpublished=False) self.joints = self.duplicateAndRenameCreationPose() moduleJointsGrp = self.joints[0] moduleGrp = cmds.group(empty=True, name=self.blueprintNamespace + ':' + self.moduleNamespace + ':module_grp') hookIn = self.blueprintNamespace + ':HOOK_IN' cmds.parent(moduleGrp, hookIn, moduleGrp, relative=True) cmds.parent(moduleJointsGrp, moduleGrp, absolute=True) cmds.select(moduleGrp) cmds.addAttr(at='float',ln='iconScale', min=0.001, softMaxValue=10.0, defaultValue=1,k=True) cmds.setAttr(moduleGrp + '.overrideEnabled',1) cmds.setAttr(moduleGrp + '.overrideColor',6) utilityNodes = self.setupBlueprintWeightBasedBlending() self.setupModuleVisibility(moduleGrp) containedNodes = list(self.joints) containedNodes.append(moduleGrp) containedNodes.extend(utilityNodes) self.moduleContainer = cmds.container(n=self.moduleContainer) utils.addNodeToContainer(self.moduleContainer,containedNodes, ihb=True) utils.addNodeToContainer(blueprintContainer, self.moduleContainer) index = 0 for joint in self.joints: if index > 0: niceJointName = utils.stripAllNamespaces(joint)[1] self.publishNameToModuleContainer(joint + '.rotate', niceJointName + '_R', publishToOuterContainers=False) index += 1 self.publishNameToModuleContainer(moduleGrp + '.lod','Control_LOD') self.publishNameToModuleContainer(moduleGrp + '.iconScale', 'Icon_Scale') self.publishNameToModuleContainer(moduleGrp + '.overrideColor','Icon_Colour') self.publishNameToModuleContainer(moduleGrp + '.visibility', 'Vis', publishToOuterContainers=False) return (self.joints, moduleGrp, self.moduleContainer)
def initialiseHook(self, rootTranslationControl): unhookedLocator = cmds.spaceLocator(name=self.moduleNamespace + ':unhookedTarget')[0] #i have made some changes here on my own to rename to parent constraint. the original version #is commented out. #cmds.pointConstraint(rootTranslationControl, unhookedLocator, offset=[0,0.001,0]) parentConstraint =cmds.pointConstraint(rootTranslationControl, unhookedLocator, offset=[0,0.001,0])[0] cmds.rename(parentConstraint, (self.moduleNamespace + ':' + parentConstraint)) cmds.setAttr(unhookedLocator + '.visibility', 0) if self.hookObject == None: self.hookObject = unhookedLocator rootPos = cmds.xform(rootTranslationControl, q=True, worldSpace=True, translation=True) targetPos = cmds.xform(self.hookObject, q=True, worldSpace=True, translation=True) cmds.select(clear=True) rootJointWithoutNamespace = 'hook_root_joint' rootJoint = cmds.joint(n=self.moduleNamespace + ':' + rootJointWithoutNamespace, p=rootPos) cmds.setAttr((rootJoint + '.visibility'), 0) targetJointWithoutNamespace = 'hook_target_joint' targetJoint = cmds.joint(n=self.moduleNamespace + ':' + targetJointWithoutNamespace, p=targetPos) cmds.setAttr((targetJoint + '.visibility'), 0) cmds.joint(rootJoint, edit=True, orientJoint='xyz', sao='yup') hookGroup = cmds.group([rootJoint, unhookedLocator], name=self.moduleNamespace + ':hook_grp', parent=self.moduleGrp) hookContainer = cmds.container(name=self.moduleNamespace + ':hook_container') utils.addNodeToContainer(hookContainer, hookGroup, ihb=True) utils.addNodeToContainer(self.containerName, hookContainer) for joint in [rootJoint, targetJoint]: jointName = utils.stripAllNamespaces(joint)[1] cmds.container(hookContainer, edit=True, publishAndBind=[joint+'.rotate', jointName+'_R']) ikNodes = utils.basic_stretchy_IK(rootJoint, targetJoint, hookContainer, lockMinimumLength=False) ikHandle = ikNodes['ikHandle'] rootLocator = ikNodes['rootLocator'] endLocator = ikNodes['endLocator'] poleVectorLocator = ikNodes['poleVectorObject'] rootPointConstraint = cmds.pointConstraint(rootTranslationControl, rootJoint, maintainOffset=False, n=(rootJoint + '_pointConstraint'))[0] targetPointConstraint = cmds.pointConstraint(self.hookObject, endLocator, maintainOffset=False, n=(self.moduleNamespace + ':hook_pointConstraint'))[0] utils.addNodeToContainer(hookContainer, [rootPointConstraint, targetPointConstraint]) for node in [ikHandle, rootLocator, endLocator, poleVectorLocator]: cmds.parent(node, hookGroup, absolute=True) cmds.setAttr((node + '.visibility'), 0) objectNodes = self.createStretchyObject('/ControlObjects/Blueprint/hook_representation.ma', 'hook_representation_container', 'hook_representation', rootJoint, targetJoint) constrainedGrp = objectNodes[2] cmds.parent(constrainedGrp, hookGroup, absolute=True) hookRepresentationContainer = objectNodes[0] cmds.container(self.containerName, edit=True, removeNode=hookRepresentationContainer) utils.addNodeToContainer(hookContainer, hookRepresentationContainer)
def lock_phase3(self,hookObject): moduleContainer = (self.moduleNamespace + ':module_container') if hookObject != None: hookObjectModuleNode = utils.stripLeadingNamespace(hookObject) hookObjModule = hookObjectModuleNode[0] hookObjJoint = hookObjectModuleNode[1].split('_translation_control')[0] hookObj = (hookObjModule + ':blueprint_' + hookObjJoint) parentConstraint = cmds.parentConstraint(hookObj, (self.moduleNamespace + ':HOOK_IN'), maintainOffset=True, n=(self.moduleNamespace + ':hook_parent_constraint'))[0] scaleConstraint = cmds.scaleConstraint(hookObj, (self.moduleNamespace + ':HOOK_IN'), maintainOffset=True, n=(self.moduleNamespace + ':hook_scale_constraint'))[0] utils.addNodeToContainer(moduleContainer, [parentConstraint,scaleConstraint]) cmds.lockNode(moduleContainer, lock=True, lockUnpublished=True)
def install_custom(self, joints, moduleGrp, moduleContainer): #group all blueprintNames controlsGrp = cmds.group(empty=True, name=self.blueprintNamespace+":"+self.moduleNamespace+":controls_grp") #parent the moduleGrp to controlsGrp cmds.parent(controlsGrp, moduleGrp, absolute=True) #add it to the container utils.addNodeToContainer(moduleContainer, controlsGrp) numJoints = len(joints) - 1 #create fkControl for the joints for i in range(1, len(joints)): if i < numJoints or numJoints == 1: self.createFKControl(joints[i], controlsGrp, moduleContainer)
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 setupSymmetryMoveForObject(self, obj, mirrorObj, axis, translation=True, orientation=False, globalScale=False): duplicateObject = cmds.duplicate(obj, parentOnly=True, inputConnections=True, name=obj+"_mirrorHelper")[0] emptyGroup = cmds.group(empty=True, name=obj+"mirror_scale_grp") cmds.parent(duplicateObject, emptyGroup, absolute=True) scaleAttribute = ".scale" + axis cmds.setAttr(emptyGroup+scaleAttribute, -1) expressionString = "namespace -setNamespace \":\";\n" if translation: expressionString += "$worldSpacePos = `xform -q -ws -translation "+ obj + "`; \n" if orientation: expressionString += "$worldSpaceOrient = `xform -q -ws -rotation "+ obj +"`; \n" attrs =[] if translation: attrs.extend([".translateX", ".translateY", ".translateZ"]) if orientation: attrs.extend([".rotateX", ".rotateY", ".rotateZ"]) for attr in attrs: expressionString += duplicateObject+attr+" = " +obj + attr + ";\n" i = 0 for axis in ["X", "Y", "Z"]: if translation: expressionString += duplicateObject+".translate"+axis+" = $worldSpacePos["+str(i)+"];\n" if orientation: expressionString += duplicateObject+".rotate"+axis+" = $worldSpaceOrient["+str(i)+"]; \n" i += 1 if globalScale: expressionString += duplicateObject+ ".globalScale = "+ obj + ".globalScale;\n" expression = cmds.expression(n=duplicateObject+"_symmetryMoveExpression", string=expressionString) constraint = "" if translation and orientation: constraint = cmds.parentConstraint(duplicateObject, mirrorObj, maintainOffset=False, n=mirrorObj+"_symmetryMoveConstraint")[0] elif translation: constraint = cmds.pointConstraint(duplicateObject, mirrorObj, maintainOffset=False, n=mirrorObj+"_symmetryMoveConstraint")[0] elif orientation: constraint = cmds.orientConstraint(duplicateObject, mirrorObj, maintainOffset=False, n=mirrorObj+"_symmetryMoveConstraint")[0] if globalScale: cmds.connectAttr(duplicateObject+".globalScale", mirrorObj+".globalScale") utils.addNodeToContainer("symmetryMove_container", [duplicateObject, emptyGroup, expression, constraint], ihb=True)
def initialiseModuleTransform(self, rootPos): controlGrpFile = os.environ['RIGGING_TOOL_ROOT'] + '/ControlObjects/Blueprint/controlGroup_control.ma' cmds.file(controlGrpFile, i=True) self.moduleTransform = cmds.rename('controlGroup_control', self.moduleNamespace + ':module_transform') cmds.xform(self.moduleTransform, worldSpace=True, absolute=True, translation=rootPos) if self.mirrored: duplicateTransform = cmds.duplicate(self.originalModule + ':module_transform', parentOnly=True,name='TEMP_TRANSFORM')[0] emptyGroup = cmds.group(empty=True) cmds.parent(duplicateTransform, emptyGroup, absolute=True) scaleAttr = '.scaleX' if self.mirrorPlane == 'XZ': scaleAttr = '.scaleY' elif self.mirrorPlane == 'XY': scaleAttr = '.scaleZ' cmds.setAttr((emptyGroup + scaleAttr), -1) parentConstraint = cmds.parentConstraint(duplicateTransform, self.moduleTransform, maintainOffset=False) cmds.delete(parentConstraint) cmds.delete(emptyGroup) tempLocator = cmds.spaceLocator()[0] scaleConstraint = cmds.scaleConstraint(self.originalModule + ':module_transform', tempLocator,maintainOffset=False)[0] scale = cmds.getAttr(tempLocator + '.scaleX') cmds.delete([tempLocator,scaleConstraint]) cmds.xform(self.moduleTransform, objectSpace=True, scale=[scale,scale,scale]) utils.addNodeToContainer(self.containerName, self.moduleTransform, ihb=True) #Setup global scaling cmds.connectAttr((self.moduleTransform + '.scaleY'),(self.moduleTransform + '.scaleX')) cmds.connectAttr((self.moduleTransform + '.scaleY'),(self.moduleTransform + '.scaleZ')) cmds.aliasAttr('globalScale', (self.moduleTransform + '.scaleY')) cmds.container(self.containerName, edit=True, publishAndBind=[(self.moduleTransform + '.translate'),'moduleTransform_T']) cmds.container(self.containerName, edit=True, publishAndBind=[(self.moduleTransform + '.rotate'),'moduleTransform_R']) cmds.container(self.containerName, edit=True, publishAndBind=[(self.moduleTransform + '.globalScale'),'moduleTransform_globalScale'])
def setup_interpolation(self, unlockContainer=False, *args): previousSelection = cmds.ls(selection=True) if unlockContainer: cmds.lockNode(self.containerName, lock=False, lockUnpublished=False) joints = self.getJoints() numberOfJoints = len(joints) startControl = self.getTranslationControl(joints[0]) endControl = self.getTranslationControl(joints[numberOfJoints-1]) pointConstraints = [] for i in range(1,numberOfJoints-1): material = joints[i] + '_m_translation_control' cmds.setAttr(material + '.colorR', 0.815) cmds.setAttr(material + '.colorG', 0.629) cmds.setAttr(material + '.colorB', 0.498) translationControl = self.getTranslationControl(joints[i]) endWeight = 0.0 + (float(i) / (numberOfJoints-1)) startWeight = 1.0 - endWeight pointConstraints.append(cmds.pointConstraint(startControl,translationControl,maintainOffset=False,weight=startWeight)[0]) pointConstraints.append(cmds.pointConstraint(endControl,translationControl,maintainOffset=False,weight=endWeight)[0]) for attr in ['.translateX', '.translateY','.translateZ']: cmds.setAttr(translationControl + attr, lock=True) interpolationContainer = cmds.container(n=self.moduleNamespace+':interpolation_container') utils.addNodeToContainer(interpolationContainer, pointConstraints) utils.addNodeToContainer(self.containerName,interpolationContainer) if unlockContainer: cmds.lockNode(self.containerName, lock=True, lockUnpublished=True) if len(previousSelection) > 0: cmds.select(previousSelection,replace=True) else: cmds.select(clear=True)
def createFKControl(self,joint,parent,moduleContainer): containedNodes = [] fkControlInfo = self.initFKControl(joint,spaceSwitchable=False) fkControl = fkControlInfo[0] translationControl = fkControlInfo[2] orientGrp = cmds.group(n=fkControl + '_orientGrp',empty=True,parent=parent) containedNodes.append(orientGrp) orientGrp_parentConstraint = cmds.parentConstraint(joint,orientGrp,maintainOffset=False)[0] cmds.delete(orientGrp_parentConstraint) jointParent = cmds.listRelatives(joint,parent=True)[0] orientGrp_parentConstraint = cmds.parentConstraint(jointParent,orientGrp, maintainOffset=True, skipTranslate=['x','y','z'] ,n=orientGrp + '_parentConstraint')[0] pointConstraint_parent = joint if translationControl: pointConstraint_parent = jointParent orientGrp_pointConstraint = cmds.pointConstraint(pointConstraint_parent, orientGrp, maintainOffset=False, n=orientGrp+'_pointCostraint')[0] orientGrp_scaleConstraint = cmds.scaleConstraint(jointParent,orientGrp, maintainOffset=True,n=orientGrp + '_scaleConstraint')[0] containedNodes.extend([orientGrp_parentConstraint,orientGrp_pointConstraint,orientGrp_scaleConstraint]) cmds.parent(fkControl, orientGrp,relative=True) orientConstraint = cmds.orientConstraint(fkControl, joint,maintainOffset=False, n=joint+'_orientConstraint')[0] containedNodes.append(orientConstraint) if translationControl: cmds.xform(fkControl, worldSpace=True, absolute=True, translation=cmds.xform(joint,q=True,worldSpace=True, translation=True)) pointConstraint = cmds.pointConstraint(fkControl, joint, maintainOffset=False, n=joint+'_pointConstraint')[0] containedNodes.append(pointConstraint) utils.addNodeToContainer(moduleContainer, containedNodes) return fkControl
def setupSpaceSwitching(self,blueprintModuleNamespace,animationModuleNamespace,animationModuleInstance): cmds.select(self.controlObject,replace=True) cmds.addAttr(at='bool',defaultValue=True,keyable=False,longName='spaceSwitching') cmds.addAttr(at='bool',defaultValue=False,keyable=False,longName='switchOrientationOnly') spaceSwitcher = cmds.group(empty=True, name=self.controlObject+'_spaceSwitcher') if self.translation != [True,True,True]: cmds.setAttr(self.controlObject+'.switchOrientationOnly',True) cmds.parent(self.rootParent,spaceSwitcher, absolute=True) self.rootParent = spaceSwitcher utils.addNodeToContainer(animationModuleNamespace+':module_container',spaceSwitcher) self.switchSpace(blueprintModuleNamespace+':HOOK_IN','Module Hook') controlObjectName = utils.stripAllNamespaces(self.controlObject)[1] animationModuleInstance.publishNameToModuleContainer(spaceSwitcher+'.currentSpace', controlObjectName+'_currentSpace', publishToOuterContainers=True)
def createFKControl(self,joint,parent,moduleContainer): fkControl = fk.FK.createFKControl(self,joint,parent,moduleContainer) children = cmds.listRelatives(joint, children=True, type='joint') childJoint = children[0] cmds.select(fkControl, replace=True) cmds.addAttr(at='float', defaultValue=1.0, minValue=0.001, softMaxValue=5.0, keyable=True, longName='stretch') cmds.addAttr(at='float', keyable=False, longName='originalLength') cmds.setAttr(fkControl+'.originalLength',cmds.getAttr(childJoint+'.translateX')) stretchFactorMultiply = cmds.shadingNode('multiplyDivide', asUtility=True, n=childJoint+'_stretchFactorMultiply') cmds.connectAttr(fkControl+'.stretch',stretchFactorMultiply+'.input1X',force=True) cmds.connectAttr(fkControl+'.originalLength',stretchFactorMultiply+'.input2X',force=True) cmds.connectAttr(stretchFactorMultiply+'.outputX',childJoint+'.translateX',force=True) utils.addNodeToContainer(moduleContainer,stretchFactorMultiply) attributeNiceName = utils.stripAllNamespaces(childJoint)[1]+'_stretch' self.publishNameToModuleContainer(fkControl+'.stretch', attributeNiceName,publishToOuterContainers=True)
def createFKControl(self, joint, parent, moduleContainer): fkControl = fk.FK.createFKControl(self, joint, parent, moduleContainer) children = cmds.listRelatives(joint, children=True, type="joint") childJoint = children[0] cmds.select(fkControl, replace=True) cmds.addAttr(at="float", defaultValue=1.0, minValue=0.001, softMaxValue=5.0, keyable=True, longName="stretch") cmds.addAttr(at="float", keyable=False, longName="originalLength") cmds.setAttr(fkControl+".originalLength", cmds.getAttr(childJoint+".translateX")) stretchFactorMultiply = cmds.shadingNode("multiplyDivide", asUtility=True, n=childJoint+"_stretchFactorMultiply") cmds.connectAttr(fkControl+".stretch", stretchFactorMultiply+".input1X", force=True) cmds.connectAttr(fkControl+".originalLength", stretchFactorMultiply+".input2X", force=True) cmds.connectAttr(stretchFactorMultiply+".outputX", childJoint+".translateX", force=True) utils.addNodeToContainer(moduleContainer, stretchFactorMultiply) attributeNiceName = utils.stripAllNamespaces(childJoint)[1]+"_stretch" self.publishNameToModuleContainer(fkControl+".stretch", attributeNiceName, publishToOuterContainers=True)
def createFKControl(self, joint, parent, moduleContainer): containedNodes = [] fkControlInfo = self.initFKControl(joint, spaceSwitchable=False) fkControl = fkControlInfo[0] translationControl = fkControlInfo[2] orientGrp = cmds.group(n=fkControl+"_orientGrp", empty=True, parent=parent) containedNodes.append(orientGrp) orientGrp_parentConstraint = cmds.parentConstraint(joint, orientGrp, maintainOffset=False)[0] cmds.delete(orientGrp_parentConstraint) jointParent = cmds.listRelatives(joint, parent=True)[0] orientGrp_parentConstraint = cmds.parentConstraint(jointParent, orientGrp, maintainOffset=True, skipTranslate=["x", "y", "z"], n=orientGrp+"_parentConstraint")[0] pointConstraint_parent = joint if translationControl: pointConstraintParent = jointParent orientGrp_pointConstraint = cmds.pointConstraint(pointConstraint_parent, orientGrp, maintainOffset=False, n=orientGrp+"_pointConstraint")[0] orientGrp_scaleConstraint = cmds.scaleConstraint(jointParent, orientGrp, maintainOffset=True, n=orientGrp+"_scaleConstraint")[0] containedNodes.extend([orientGrp_parentConstraint, orientGrp_scaleConstraint, orientGrp_pointConstraint ]) cmds.parent(fkControl, orientGrp, relative=True) orientConstraint = cmds.orientConstraint(fkControl, joint, maintainOffset=False, n=joint+"_orientConstraint")[0] containedNodes.append(orientConstraint) if translationControl: cmds.xform(fkControl, worldSpace=True, absolute=True, translation=cmds.xform(joint, q=True, ws=True, translation=True)) pointConstraint = cmds.pointConstraint(fkControl, joint, mo=False, n=joint+"_pointConstraint")[0] containedNodes.append(pointConstraint) utils.addNodeToContainer(moduleContainer, containedNodes) return fkControl
def createFKControl(self, joint, parent, moduleContainer): fkControl = fk.FK.createFKControl(self, joint, parent, moduleContainer) children = cmds.listRelatives(joint, children=True, type="joint") childJoint = children[0] cmds.select(fkControl, replace=True) cmds.addAttr(at="float", defaultValue=1.0, minValue=0.001, softMaxValue=5.0, keyable=True, longName="stretch") cmds.addAttr(at="float", keyable=False, longName="originalLength") cmds.setAttr(fkControl + ".originalLength", cmds.getAttr(childJoint + ".translateX")) stretchFactorMultiply = cmds.shadingNode("multiplyDivide", asUtility=True, n=childJoint + "_stretchFactorMultiply") cmds.connectAttr(fkControl + ".stretch", stretchFactorMultiply + ".input1X", force=True) cmds.connectAttr(fkControl + ".originalLength", stretchFactorMultiply + ".input2X", force=True) cmds.connectAttr(stretchFactorMultiply + ".outputX", childJoint + ".translateX", force=True) utils.addNodeToContainer(moduleContainer, stretchFactorMultiply) attributeNiceName = utils.stripAllNamespaces( childJoint)[1] + "_stretch" self.publishNameToModuleContainer(fkControl + ".stretch", attributeNiceName, publishToOuterContainers=True)
def install_custom(self,joints,moduleGrp,moduleContainer): joint = joints[1] name = 'globalControl' controlObjectInstance = controlObject.ControlObject() globalControlInfo = controlObjectInstance.create(name, 'globalControl.ma', self, lod=1, translation=True, rotation=True, globalScale=True, spaceSwitching=True) globalControl = globalControlInfo[0] globalControl_rootParent = globalControlInfo[1] 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) 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 createStretchyObject(self,objectRelativeFilepath,objectContainerName,objectName,parentJoint,childJoint): objectFile = os.environ['RIGGING_TOOL_ROOT'] + objectRelativeFilepath cmds.file(objectFile, i=True) objectContainer = cmds.rename(objectContainerName, (parentJoint + '_' + objectContainerName)) for node in cmds.container(objectContainer, q=True, nodeList=True): cmds.rename(node, (parentJoint + '_' + node), ignoreShape=True) object = (parentJoint + '_' + objectName) constrainedGrp = cmds.group(empty=True, name=(object + '_parentConstraint_grp')) cmds.parent(object,constrainedGrp, absolute=True) parentConstraint = cmds.parentConstraint(parentJoint, constrainedGrp, maintainOffset=False)[0] cmds.connectAttr((childJoint + '.translateX'), (constrainedGrp + '.scaleX')) scaleConstraint = cmds.scaleConstraint(self.moduleTransform, constrainedGrp, skip=['x'],maintainOffset=False)[0] utils.addNodeToContainer(objectContainer, [constrainedGrp, parentConstraint,scaleConstraint], ihb=True) utils.addNodeToContainer(self.containerName, objectContainer) return (objectContainer, object, constrainedGrp)
def createTranslationControlAtJoint(self,joint): posControlFile = os.environ["RIGGING_TOOL_ROOT"] + "/ControlObjects/Blueprint/translation_control.ma" cmds.file(posControlFile, i=True) container = cmds.rename('translation_control_container', (joint + '_translation_control_container')) utils.addNodeToContainer(self.containerName, container) for node in cmds.container(container, q=True, nodeList=True): cmds.rename(node, (joint + '_' + node), ignoreShape=True) control = (joint + '_translation_control') cmds.parent(control, self.moduleTransform, absolute=True) jointPos = cmds.xform(joint, q=True, worldSpace=True, translation=True) cmds.xform(control, worldSpace=True, absolute=True, translation=jointPos) niceName = utils.stripLeadingNamespace(joint)[1] attrName = (niceName + '_T') cmds.container(container, edit=True, publishAndBind=[(control + '.translate'), attrName]) cmds.container(self.containerName, edit=True, publishAndBind=[(container + '.' + attrName), attrName]) return control
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 setupSymmetryMoveExpressions(self, *args): cmds.namespace(setNamespace=":") selection = cmds.ls(selection=True, transforms=True) expressionContainer = cmds.container(n="symmetryMove_container") if len(selection ) == 0: return linkedObjs = [] for obj in selection: if obj in linkedObjs: continue #check if module is in a group if obj.find("Group__") == 0: if cmds.attributeQuery("mirrorLinks", n=obj, exists=True): mirrorLinks = cmds.getAttr(obj+".mirrorLinks") groupInfo = mirrorLinks.rpartition("__") mirrorObj = groupInfo[0] axis = groupInfo[2] linkedObjs.append(mirrorObj) self.setupSymmetryMoveForObject(obj, mirrorObj, axis, translation=True, orientation=True, globalScale=True) #not in a group else: #does it belong to a module objNamespaceInfo = utils.stripLeadingNamespace(obj) if objNamespaceInfo != None: #check if mirrorLinks is in module_grp if cmds.attributeQuery("mirrorLinks", n=objNamespaceInfo[0]+":module_grp", exists=True): mirrorLinks = cmds.getAttr(objNamespaceInfo[0] + ":module_grp.mirrorLinks") #split from the right base on "__" moduleInfo = mirrorLinks.rpartition("__") module = moduleInfo[0] axis = moduleInfo[2] #Searching For the control types... #The name of the node we have selected, select translation control if objNamespaceInfo[1].find("translation_control") != -1: #find out the name of the obj to drive mirrorObj = module + ":" +objNamespaceInfo[1] #put mirror object in linked obj linkedObjs.append(mirrorObj) #drive translation only self.setupSymmetryMoveForObject(obj, mirrorObj, axis, translation=True, orientation=False, globalScale=False) #select the node for module transform elif objNamespaceInfo[1].find("module_transform") == 0: mirrorObj = module + ":module_transform" #put mirror object in linked obj linkedObjs.append(mirrorObj) #drive translation and Rotate/Orientation only self.setupSymmetryMoveForObject(obj, mirrorObj, axis, translation=True, orientation=True, globalScale=False) elif objNamespaceInfo[1].find("orientation_control") != -1: mirrorObj = module + ":" + objNamespaceInfo[1] linkedObjs.append(mirrorObj) expressionString = mirrorObj + ".rotateX = "+ obj + ".rotateX; \n" expression = cmds.expression(n=mirrorObj + "_symmetryMoveExpression", string=expressionString) utils.addNodeToContainer(expressionContainer, expression) elif objNamespaceInfo[1].find("singleJointOrientation_control") != -1: mirrorObj = module + ":" + objNamespaceInfo[1] linkedObjs.append(mirrorObj) expressionString += mirrorObj + ".rotateX = " + obj + ".rotateX; \n" expressionString += mirrorObj + ".rotateY = " + obj + ".rotateY; \n" expressionString += mirrorObj + ".rotateZ = " + obj + ".rotateZ; \n" expression = cmds.expression(n=mirrorObj+"_symmetryMoveExpression", string=expressionString) utils.addNodeToContainer(expressionContainer, expression) cmds.lockNode(expressionContainer, lock=True) cmds.select(selection, replace=True)
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, 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): 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 duplicateControlModule(self, withAnimation=True): # Unlock containers characterContainer = self.characterNamespaceOnly + ":character_container" blueprintContainer = self.blueprintNamespace + ":module_container" moduleContainer = self.moduleContainer containers = [ characterContainer, blueprintContainer, moduleContainer] for c in containers: cmds.lockNode(c, lock=False, lockUnpublished=False) # Find all the animation nodes and determine which are user created, space switch, etc. cmds.namespace(setNamespace=self.blueprintNamespace + ":" + self.moduleNamespace) allAnimationNodes = cmds.namespaceInfo(listOnlyDependencyNodes=True) # Get all the animation curves allAnimationNodes = cmds.ls(allAnimationNodes, type="animCurve") # Find all contained animation nodes containedAnimationNodes = cmds.container(moduleContainer, q=True, nodeList=True) containedAnimationNodes = cmds.ls(containedAnimationNodes, type="animCurve") animationNodes = [] spaceSwitchAnimationNodes = [] for node in allAnimationNodes: if not node in containedAnimationNodes: animationNodes.append(node) else: if node.rpartition("_")[2] == "currentSpace": spaceSwitchAnimationNodes.append(node) # Set namespace back to Root cmds.namespace(setNamespace=":") utils.addNodeToContainer(moduleContainer, animationNodes) # Create temp namespace to duplicate nodes into. cmds.namespace(addNamespace="TEMP") cmds.namespace(setNamespace="TEMP") # Duplicate the entire module container cmds.duplicate(moduleContainer, inputConnections=True) cmds.namespace(setNamespace=":"+self.blueprintNamespace) moduleNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True) baseModuleNamespace = self.moduleNamespace.rpartition("_")[0] + "_" baseNamespace = self.blueprintNamespace + ":" + baseModuleNamespace highestSuffix = utils.findHighestTrailingNumber(moduleNamespaces, baseNamespace) highestSuffix += 1 newModuleNamespace = baseModuleNamespace + str(highestSuffix) # Add the new module namespace and set the default namespace back to root. cmds.namespace(addNamespace=newModuleNamespace) cmds.namespace(setNamespace=":") cmds.namespace(moveNamespace=["TEMP", self.blueprintNamespace+":"+newModuleNamespace]) cmds.namespace(removeNamespace="TEMP") oldModuleNamespace = self.moduleNamespace self.moduleNamespace = newModuleNamespace newModuleContainer = self.blueprintNamespace + ":" + self.moduleNamespace + ":module_container" utils.addNodeToContainer(blueprintContainer, newModuleContainer) # Generate a publish name list. Name of the attribute on the container and the name of the attribute it is driving. publishedNameList = [] publishedNames = cmds.container(newModuleContainer, q=True, publishName=True) for name in publishedNames: drivenAttribute = cmds.connectionInfo(newModuleContainer+"."+name, getExactSource=True) publishedNameList.append( (name, drivenAttribute) ) # Now loop through the attribute names and rename the names on the container. #unbind the attributes on the new container. # This seems to be failing on the first .visibility attribute. A maya command error is returned. # I am adding a try so I can get past this for now. No fing clue why I error out. for name in publishedNameList: try: cmds.container(newModuleContainer, edit=True, unbindAndUnpublish=name[1]) nameInfo = name[0].partition(oldModuleNamespace) newName = nameInfo[0] + self.moduleNamespace + nameInfo[2] # Now that we have the new attribute name, publish that name to our container. cmds.container(newModuleContainer, edit=True, publishAndBind=[name[1], newName]) except: pass self.moduleContainer = moduleContainer oldPublishedNames = self.findAllNamesPublishedToOuterContainers() newPublishedNames = [] for name in oldPublishedNames: nameInfo = name.partition(oldModuleNamespace) newPublishedNames.append( (nameInfo[0] + self.moduleNamespace + nameInfo[2])) # Loop through and publish attributes to outer container. self.publishedNames = list(newPublishedNames) self.moduleContainer = newModuleContainer self.publishModuleContainerNamesToOuterContainers() deleteNodes = [] moduleJointsGrp = self.blueprintNamespace+":"+self.moduleNamespace+":joints_grp" self.joints = utils.findJointChain(moduleJointsGrp) for joint in self.joints: if cmds.objExists(joint+"_multiplyRotationsWeight"): deleteNodes.append(joint+"_multiplyRotationsWeight") if cmds.objExists(joint+"_multiplyTranslationWeight"): deleteNodes.append(joint+"_multiplyTranslationWeight")\ if cmds.objExists(joint+"_multiplyScaleWeight"): deleteNodes.append(joint+"_multiplyScaleWeight") cmds.delete(deleteNodes, inputConnectionsAndNodes=False) utilityNodes = self.setupBlueprintWeightBasedBlending() utils.addNodeToContainer(newModuleContainer, utilityNodes)
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)
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): 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): 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 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'] for node in [rootLocator, ikHandle, poleVectorLocator]: cmds.parent(node, moduleGrp, absolute=True) 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(endLocator, q=True, worldSpace=True, translation=True)) cmds.parent(endLocator, handleControl, absolute=True) 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) 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') cmds.connectAttr(handleControl+'.twist', ikHandle+'.twist') cmds.connectAttr(handleControl+'.stretchiness', stretchinessAttribute) self.publishNameToModuleContainer(handleControl+'.twist', 'twist', publishToOuterContainers=True) self.publishNameToModuleContainer(handleControl+'.stretchiness', 'stretchiness', publishToOuterContainers=True) 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) utils.addNodeToContainer(moduleContainer,containedNodes)
def duplicateControlModule(self, withAnimation=True): # Unlock containers characterContainer = self.characterNamespaceOnly + ":character_container" blueprintContainer = self.blueprintNamespace + ":module_container" moduleContainer = self.moduleContainer containers = [characterContainer, blueprintContainer, moduleContainer] for c in containers: cmds.lockNode(c, lock=False, lockUnpublished=False) # Find all the animation nodes and determine which are user created, space switch, etc. cmds.namespace(setNamespace=self.blueprintNamespace + ":" + self.moduleNamespace) allAnimationNodes = cmds.namespaceInfo(listOnlyDependencyNodes=True) # Get all the animation curves allAnimationNodes = cmds.ls(allAnimationNodes, type="animCurve") # Find all contained animation nodes containedAnimationNodes = cmds.container(moduleContainer, q=True, nodeList=True) containedAnimationNodes = cmds.ls(containedAnimationNodes, type="animCurve") animationNodes = [] spaceSwitchAnimationNodes = [] for node in allAnimationNodes: if not node in containedAnimationNodes: animationNodes.append(node) else: if node.rpartition("_")[2] == "currentSpace": spaceSwitchAnimationNodes.append(node) # Set namespace back to Root cmds.namespace(setNamespace=":") utils.addNodeToContainer(moduleContainer, animationNodes) # Create temp namespace to duplicate nodes into. cmds.namespace(addNamespace="TEMP") cmds.namespace(setNamespace="TEMP") # Duplicate the entire module container cmds.duplicate(moduleContainer, inputConnections=True) cmds.namespace(setNamespace=":" + self.blueprintNamespace) moduleNamespaces = cmds.namespaceInfo(listOnlyNamespaces=True) baseModuleNamespace = self.moduleNamespace.rpartition("_")[0] + "_" baseNamespace = self.blueprintNamespace + ":" + baseModuleNamespace highestSuffix = utils.findHighestTrailingNumber( moduleNamespaces, baseNamespace) highestSuffix += 1 newModuleNamespace = baseModuleNamespace + str(highestSuffix) # Add the new module namespace and set the default namespace back to root. cmds.namespace(addNamespace=newModuleNamespace) cmds.namespace(setNamespace=":") cmds.namespace(moveNamespace=[ "TEMP", self.blueprintNamespace + ":" + newModuleNamespace ]) cmds.namespace(removeNamespace="TEMP") oldModuleNamespace = self.moduleNamespace self.moduleNamespace = newModuleNamespace newModuleContainer = self.blueprintNamespace + ":" + self.moduleNamespace + ":module_container" utils.addNodeToContainer(blueprintContainer, newModuleContainer) # Generate a publish name list. Name of the attribute on the container and the name of the attribute it is driving. publishedNameList = [] publishedNames = cmds.container(newModuleContainer, q=True, publishName=True) for name in publishedNames: drivenAttribute = cmds.connectionInfo(newModuleContainer + "." + name, getExactSource=True) publishedNameList.append((name, drivenAttribute)) # Now loop through the attribute names and rename the names on the container. #unbind the attributes on the new container. # This seems to be failing on the first .visibility attribute. A maya command error is returned. # I am adding a try so I can get past this for now. No fing clue why I error out. for name in publishedNameList: try: cmds.container(newModuleContainer, edit=True, unbindAndUnpublish=name[1]) nameInfo = name[0].partition(oldModuleNamespace) newName = nameInfo[0] + self.moduleNamespace + nameInfo[2] # Now that we have the new attribute name, publish that name to our container. cmds.container(newModuleContainer, edit=True, publishAndBind=[name[1], newName]) except: pass self.moduleContainer = moduleContainer oldPublishedNames = self.findAllNamesPublishedToOuterContainers() newPublishedNames = [] for name in oldPublishedNames: nameInfo = name.partition(oldModuleNamespace) newPublishedNames.append( (nameInfo[0] + self.moduleNamespace + nameInfo[2])) # Loop through and publish attributes to outer container. self.publishedNames = list(newPublishedNames) self.moduleContainer = newModuleContainer self.publishModuleContainerNamesToOuterContainers() deleteNodes = [] moduleJointsGrp = self.blueprintNamespace + ":" + self.moduleNamespace + ":joints_grp" self.joints = utils.findJointChain(moduleJointsGrp) for joint in self.joints: if cmds.objExists(joint + "_multiplyRotationsWeight"): deleteNodes.append(joint + "_multiplyRotationsWeight") if cmds.objExists(joint + "_multiplyTranslationWeight"): deleteNodes.append(joint+"_multiplyTranslationWeight")\ if cmds.objExists(joint + "_multiplyScaleWeight"): deleteNodes.append(joint + "_multiplyScaleWeight") cmds.delete(deleteNodes, inputConnectionsAndNodes=False) utilityNodes = self.setupBlueprintWeightBasedBlending() utils.addNodeToContainer(newModuleContainer, utilityNodes)
def publish(self, *args): result = cmds.confirmDialog(messageAlign="center", title="Publish Character", message="The action of publishing cannot be undone.\nAre you sure you wish to continue?",button=["Accept","Cancel"], defaultButton="Accept", cancelButton="Cancel", dismissString="Cancel") if result != "Accept": return result = cmds.promptDialog(title="Publish Character", message="Please specify a character name [a-z] [A-Z] and _ only: ", button=["Accept","Cancel"],defaultButton="Accept", cancelButton="Cancel", dismissString="Cancel") if result == "Accept": characterName = cmds.promptDialog(q=True, text=True) characterFileName = os.environ["RIGGING_TOOL_ROOT"]+"/Characters/"+characterName+".ma" if os.path.exists(characterFileName): cmds.confirmDialog(title="Publish Character", message="Character already exists with that name. Aborting Publish.", button=["Accept"], defaultButton="Accept") return cmds.lockNode("Scene_Locked", lock=False, lockUnpublished=False) cmds.delete("Scene_Locked") cmds.namespace(setNamespace=":") namespaces = cmds.namespaceInfo(listOnlyNamespaces=True) moduleNameInfo = utils.findAllModuleNames("/Modules/Blueprint") validModules = moduleNameInfo[0] validModuleNames = moduleNameInfo[1] foundModuleInstances = [] for n in namespaces: splitString = n.partition("__") if splitString[1] != "": module = splitString[0] if module in validModuleNames: foundModuleInstances.append(n) moduleGroups = [] moduleContainers = [] for moduleInstance in foundModuleInstances: moduleGroups.append(moduleInstance+":module_grp") moduleContainers.append(moduleInstance+":module_container") for container in moduleContainers: cmds.lockNode(container, lock=False, lockUnpublished=False) characterGroup = cmds.group(empty=True, name="character_grp") for group in moduleGroups: cmds.parent(group, characterGroup, absolute=True) cmds.select(characterGroup, replace=True) cmds.addAttr(at="bool", defaultValue=0, keyable=False, longName="moduleMaintenanceVisibility") cmds.addAttr(at="bool", defaultValue=1, keyable=True, longName="animationControlVisibility") invertModuleMaintenanceVisibility = cmds.shadingNode("reverse", n="reverse_moduleMaintenanceVisibility", asUtility=True) cmds.connectAttr(characterGroup+".moduleMaintenanceVisibility", invertModuleMaintenanceVisibility+".inputX",force=True) moduleVisibilityMultiply = cmds.shadingNode("multiplyDivide", n="moduleVisibilityMultiply", asUtility=True) cmds.connectAttr(invertModuleMaintenanceVisibility+".outputX", moduleVisibilityMultiply+".input1X") cmds.connectAttr(characterGroup+".animationControlVisibility", moduleVisibilityMultiply+".input2X") characterNodes = list(moduleContainers) characterNodes.append(characterGroup) characterNodes.append(invertModuleMaintenanceVisibility) characterNodes.append(moduleVisibilityMultiply) characterContainer = cmds.container(name="character_container") utils.addNodeToContainer(characterContainer, characterNodes) cmds.container(characterContainer, edit=True, publishAndBind=[characterGroup+".animationControlVisibility", "animControlVis"]) for container in moduleContainers: moduleNamespace = utils.stripLeadingNamespace(container)[0] blueprintJointsGrp = moduleNamespace+":blueprint_joints_grp" cmds.connectAttr(characterGroup+".moduleMaintenanceVisibility", blueprintJointsGrp+".visibility") cmds.setAttr(blueprintJointsGrp+".overrideEnabled", 1) publishedNames = cmds.container(container, q=True, publishName=True) userSpecifiedName = moduleNamespace.partition("__")[2] for name in publishedNames: cmds.container(characterContainer, edit=True, publishAndBind=[container+"."+name, userSpecifiedName+"_"+name]) characterContainers = list(moduleContainers) characterContainers.append(characterContainer) cmds.select(all=True) topLevelTransforms = cmds.ls(sl=True, transforms=True) cmds.select(clear=True) topLevelTransforms.remove(characterGroup) if len(topLevelTransforms) != 0: nonBlueprintGroup = cmds.group(topLevelTransforms, absolute=True, parent=characterGroup, name="non_blueprint_grp") cmds.setAttr(nonBlueprintGroup+".overrideEnabled", 1) cmds.setAttr(nonBlueprintGroup+".overrideDisplayType", 2) #Reference display type cmds.select(nonBlueprintGroup, replace=True) cmds.addAttr(at="bool", defaultValue=1, longName="display", k=True) visibilityMultiply = cmds.shadingNode("multiplyDivide", n="non_blueprint_visibilityMultiply", asUtility=True) cmds.connectAttr(invertModuleMaintenanceVisibility+".outputX", visibilityMultiply+".input1X", force=True) cmds.connectAttr(nonBlueprintGroup+".display", visibilityMultiply+".input2X", force=True) cmds.connectAttr(visibilityMultiply+".outputX", nonBlueprintGroup+".visibility", force=True) nonBlueprintContainer = cmds.container(addNode=nonBlueprintGroup, ihb=True, includeNetwork=True, includeShapes=True, name="non_blueprint_container") utils.addNodeToContainer(characterContainer, nonBlueprintContainer) characterContainers.append(nonBlueprintContainer) publishedName = "displayNonBlueprintNodes" cmds.container(nonBlueprintContainer, edit=True, publishAndBind=[nonBlueprintGroup+".display", publishedName]) cmds.container(characterContainer, edit=True, publishAndBind=[nonBlueprintContainer+"."+publishedName, publishedName]) for container in characterContainers: cmds.lockNode(container, lock=True, lockUnpublished=True) cmds.select(characterContainer) cmds.file(characterFileName, exportSelected=True, type="mayaAscii") scenePublished = cmds.spaceLocator(n="Scene_Published")[0] cmds.setAttr(scenePublished+".visibility", 0) cmds.lockNode(scenePublished, lock=True, lockUnpublished=True) cmds.select(clear=True) cmds.button(self.UIElements["publishBtn"], edit=True, enable=False)
def switchSpace(self, targetObject, spaceName, index=-1, maintainOffset=False, setKeyframes=False): if cmds.objExists(targetObject + "_spaceSwitchTarget"): targetObject = targetObject + "_spaceSwitchTarget" setKeyframes = setKeyframes and maintainOffset currentPosition = cmds.xform(self.controlObject, q=True, worldSpace=True, translation=True) currentOrientation = cmds.xform(self.controlObject, q=True, worldSpace=True, rotation=True) currentScale = self.getCurrentScale() spaceSwitcher = self.controlObject + "_spaceSwitcher" animModuleNamespace = utils.stripAllNamespaces(self.controlObject)[0] if index == -1: cmds.select(spaceSwitcher) enumIndex = 0 if cmds.attributeQuery("currentSpace", n=spaceSwitcher, exists=True): currentEntries = cmds.attributeQuery("currentSpace", n=spaceSwitcher, listEnum=True)[0] newEntry = currentEntries + ":" + spaceName cmds.addAttr(spaceSwitcher + ".currentSpace", edit=True, enumName=newEntry) enumIndex = len(currentEntries.split(":")) else: cmds.addAttr(at="enum", enumName=spaceName, keyable=True, longName="currentSpace") if self.globalScale: scaleConstraint = cmds.scaleConstraint(targetObject, spaceSwitcher, n=spaceSwitcher + "_scaleConstraint", maintainOffset=False)[0] skipTranslate = "none" if cmds.getAttr(self.controlObject + ".switchOrientationOnly"): skipTranslate = ["x", "y", "z"] parentConstraint = cmds.parentConstraint( targetObject, spaceSwitcher, n=spaceSwitcher + "_parentConstraint", maintainOffset=False, skipTranslate=skipTranslate)[0] parentWeightList = cmds.parentConstraint(parentConstraint, q=True, weightAliasList=True) parentWeight = parentConstraint + "." + parentWeightList[ len(parentWeightList) - 1] attrs = [(parentWeight, "parent")] containedNodes = [parentConstraint] if self.globalScale: scaleWeightList = cmds.scaleConstraint(scaleConstraint, q=True, weightAliasList=True) scaleWeight = scaleConstraint + "." + scaleWeightList[ len(scaleWeightList) - 1] attrs.append((scaleWeight, "scale")) containedNodes.append(scaleConstraint) for attr in attrs: expressionString = attr[ 0] + " = (" + spaceSwitcher + ".currentSpace == " + str( enumIndex) + ");\n" expressionName = spaceSwitcher + "_" + attr[ 1] + "WeightExpression_" + str(enumIndex) containedNodes.append( cmds.expression(name=expressionName, string=expressionString)) utils.addNodeToContainer(animModuleNamespace + ":module_container", containedNodes) index = enumIndex transformAttributes = ([self.translation[0], "translateX"], [ self.translation[1], "translateY" ], [self.translation[2], "translateZ"], [self.rotation[0], "rotateX"], [self.rotation[1], "rotateY"], [self.rotation[2], "rotateZ"], [self.globalScale, "globalScale"]) currentTime = cmds.currentTime(q=True) if setKeyframes: for attribute in transformAttributes: if attribute[0]: if not cmds.selectKey(self.controlObject, attribute=attribute[1], time=(currentTime - 1, )) > 0: value = cmds.getAttr(self.controlObject + "." + attribute[1], time=currentTime - 1) cmds.setKeyframe(self.controlObject, attribute=attribute[1], time=currentTime - 1, value=value, outTangentType="step") cmds.setAttr(spaceSwitcher + ".currentSpace", index) cmds.setKeyframe(spaceSwitcher, at="currentSpace", ott="step") utils.addNodeToContainer(animModuleNamespace + ":module_container", spaceSwitcher + "_currentSpace") if maintainOffset: if self.globalScale == True: newScale = self.getCurrentScale() scaleRatio = newScale / currentScale newScaleAttributeValue = cmds.getAttr(self.controlObject + ".scaleY") / scaleRatio cmds.setAttr(self.controlObject + ".scaleY", newScaleAttributeValue) if self.rotation == [True, True, True]: cmds.xform(self.controlObject, ws=True, a=True, rotation=currentOrientation) if self.translation == [True, True, True]: cmds.xform(self.controlObject, ws=True, a=True, translation=currentPosition) if setKeyframes: for attribute in transformAttributes: if attribute[0]: cmds.setKeyframe(self.controlObject, attribute=attribute[1])
def create(self, name, controlFile, animationModuleInstance, lod=1, translation=True, rotation=True, globalScale=True, spaceSwitching=False): if translation == True or translation == False: translation = [translation, translation, translation] if rotation == True or rotation == False: rotation = [rotation, rotation, rotation] self.translation = translation self.rotation = rotation self.globalScale = globalScale animationModuleName = animationModuleInstance.moduleNamespace blueprintModuleNamespace = animationModuleInstance.blueprintNamespace blueprintModuleUserSpecifiedName = utils.stripAllNamespaces( blueprintModuleNamespace)[1].partition("__")[2] animationModuleNamespace = blueprintModuleNamespace + ":" + animationModuleName # This system currently pulls in control objects from a maya file. I would like to change this so control objects are built on the fly. # I may also want to use the lo rez geo as a control. controlObjectFile = os.environ[ "GEPPETTO"] + "/ControlObjects/Animation/" + controlFile cmds.file(controlObjectFile, i=True) self.controlObject = cmds.rename("control", animationModuleNamespace + ":" + name) self.rootParent = self.controlObject self.setupIconScale(animationModuleNamespace) # Set control object drawing overrides. cmds.setAttr(self.controlObject + ".overrideEnabled", 1) cmds.setAttr(self.controlObject + ".overrideShading", 0) cmds.connectAttr( animationModuleNamespace + ":module_grp.overrideColor", self.controlObject + ".overrideColor") # Add objects to container and setup attrs for global scale. cmds.container(animationModuleNamespace + ":module_container", edit=True, addNode=self.controlObject, ihb=True, includeNetwork=True) if globalScale: cmds.connectAttr(self.controlObject + ".scaleY", self.controlObject + ".scaleX") cmds.connectAttr(self.controlObject + ".scaleY", self.controlObject + ".scaleZ") cmds.aliasAttr("globalScale", self.controlObject + ".scaleY") # Promote attrs to top level container. attributes = [] if self.translation == [True, True, True]: attributes.append([True, ".translate", "T"]) else: attributes.extend([[translation[0], ".translateX", "TX"], [translation[1], ".translateY", "TY"], [translation[2], ".translateZ", "TZ"]]) if self.rotation == [True, True, True]: attributes.append([True, ".rotate", "R"]) else: attributes.extend([[rotation[0], ".rotateX", "RX"], [rotation[1], ".rotateY", "RY"], [rotation[2], ".rotateZ", "RZ"]]) attributes.append([globalScale, ".globalScale", "scale"]) for attrInfo in attributes: if attrInfo[0]: attributeNiceName = name + "_" + attrInfo[2] animationModuleInstance.publishNameToModuleContainer( self.controlObject + attrInfo[1], attributeNiceName, publishToOuterContainers=True) cmds.select(self.controlObject, replace=True) cmds.addAttr(at="bool", defaultValue=1, k=True, ln="display") animationModuleInstance.publishNameToModuleContainer( self.controlObject + ".display", "display", publishToOuterContainers=False) # Create an expression to tie together module grp vis and lod. moduleGrp = animationModuleNamespace + ":module_grp" visibilityExpression = self.controlObject + ".visibility = " + self.controlObject + ".display * (" + moduleGrp + ".lod >= " + str( lod) + ");" expression = cmds.expression(n=self.controlObject + "_visibility_expression", string=visibilityExpression) utils.addNodeToContainer( animationModuleNamespace + ":module_container", expression) # 173 > axisInverse = cmds.spaceLocator(name=self.controlObject + "_axisInverse")[0] cmds.parent(axisInverse, self.controlObject, relative=True) cmds.setAttr(axisInverse + ".visibility", 0) utils.addNodeToContainer(animationModuleNamespace + ":module_container", axisInverse, ihb=True) spaceSwitchTarget = cmds.spaceLocator(name=self.controlObject + "_spaceSwitchTarget")[0] cmds.setAttr(spaceSwitchTarget + ".visibility", 0) cmds.parent(spaceSwitchTarget, self.controlObject, relative=True) cmds.setAttr(axisInverse + ".visibility", 0) utils.addNodeToContainer(animationModuleNamespace + ":module_container", axisInverse, ihb=True) if self.rotation == [False, False, False]: self.setupMirroring(blueprintModuleNamespace, animationModuleNamespace, axisInverse) if spaceSwitching: self.setupSpaceSwitching(blueprintModuleNamespace, animationModuleNamespace, animationModuleInstance) # < 173 return (self.controlObject, self.rootParent)
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)