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)
