import maya.api.OpenMaya as OpenMaya
import maya.cmds as cmds
import cmt.shortcuts as shortcuts
from six import string_types
HIERARCHY = {"top": {"anim": None, "skeleton": None, "rig": None, "geo": None}}
class RigHierarchy(object):
def __init__(self, hierarchy=None, prefix=None, suffix=None, lock_and_hide=None):
if hierarchy is None:
hierarchy = HIERARCHY
self.hierarchy = hierarchy
self.prefix = prefix or ""
self.suffix = "_grp" if suffix is None else suffix
self.lock_and_hide = lock_and_hide or ["t", "r", "s", "v"]
def create(self, hierarchy=None, parent=None):
if hierarchy is None:
hierarchy = self.hierarchy
for name, children in hierarchy.items():
node = "{}{}{}".format(self.prefix, name, self.suffix)
setattr(self, name, node)
func = _create_parent_method(node)
setattr(self, "parent_to_{}".format(name), func)
if not cmds.objExists(node):
node = cmds.createNode("transform", name=node)
if parent:
current_parent = cmds.listRelatives(node, parent=True, path=True)
if current_parent:
current_parent = current_parent[0]
if current_parent != parent:
cmds.parent(node, parent)
lock_and_hide(node, attributes=self.lock_and_hide)
if children:
self.create(children, node)
def delete(self, name):
"""Delete the node from the hierarchy
:param name: Hierarchy node name (Could be different from the Maya node name)
"""
cmds.delete(getattr(self, name))
delattr(self, name)
def _create_parent_method(node):
def func(nodes_to_parent):
cmds.parent(nodes_to_parent, node)
return func
def lock_and_hide(node, attributes):
"""
:param node:
:param attributes:
:return:
"""
if isinstance(node, list) or isinstance(node, tuple):
for n in node:
lock_and_hide(n, attributes)
return
for attr in attributes:
if attr in ["translate", "rotate", "scale"]:
for x in "XYZ":
cmds.setAttr("%s.%s%s" % (node, attr, x), lock=True, keyable=False)
elif attr in ["t", "r", "s"]:
for x in "xyz":
cmds.setAttr("%s.%s%s" % (node, attr, x), lock=True, keyable=False)
else:
cmds.setAttr("%s.%s" % (node, attr), lock=True, keyable=False)
def duplicate_chain(start, end, prefix="", suffix="", search_for="", replace_with=""):
"""Duplicates the transform chain starting at start and ending at end.
:param start: The start transform.
:param end: The end transform.
:param prefix: Prefix to add to the new chain.
:param suffix: Suffix to add to the new chain.
:param search_for: Search for token
:param replace_with: Replace token
:return: A list of the duplicated joints, a list of the original joints that were
duplicated.
"""
joint = end
joints = []
original_joints = []
while joint:
name = "{0}{1}{2}".format(prefix, joint, suffix)
if search_for or replace_with:
name = name.replace(search_for, replace_with)
original_joints.append(joint)
duplicate_joint = cmds.duplicate(joint, name=name, parentOnly=True)[0]
if joints:
cmds.parent(joints[-1], duplicate_joint)
joints.append(duplicate_joint)
if joint == start:
break
joint = cmds.listRelatives(joint, parent=True, path=True)
if joint:
joint = joint[0]
else:
raise RuntimeError("{0} is not a descendant of {1}".format(end, start))
joints.reverse()
original_joints.reverse()
return joints, original_joints
def connect_attribute(
source,
destination,
offset=0,
multiplier=None,
negate=False,
clamp=False,
inverse=False,
):
output = source
name = source.split(".")[-1]
if negate:
mdl = cmds.createNode("multDoubleLinear", name="{}_negate".format(name))
cmds.setAttr("{}.input1".format(mdl), -1)
cmds.connectAttr(output, "{}.input2".format(mdl))
output = "{}.output".format(mdl)
if clamp:
clamp_node = cmds.createNode("clamp", name="{}_clamp".format(name))
cmds.setAttr("{}.minR".format(clamp_node), clamp[0])
cmds.setAttr("{}.maxR".format(clamp_node), clamp[1])
cmds.connectAttr(output, "{}.inputR".format(clamp_node))
output = "{}.outputR".format(clamp_node)
if multiplier is not None:
mdl = cmds.createNode("multDoubleLinear", name="{}_multiplier".format(name))
cmds.setAttr("{}.input1".format(mdl), multiplier)
cmds.connectAttr(output, "{}.input2".format(mdl))
output = "{}.output".format(mdl)
if offset:
adl = cmds.createNode("addDoubleLinear", name="{}_offset".format(name))
cmds.setAttr("{}.input1".format(adl), offset)
cmds.connectAttr(output, "{}.input2".format(adl))
output = "{}.output".format(adl)
if inverse:
pma = cmds.createNode("plusMinusAverage", name="{}_inverse".format(name))
cmds.setAttr("{}.operation".format(pma), 2) # subtract
cmds.setAttr("{}.input1D[0]".format(pma), 1)
cmds.connectAttr(output, "{}.input1D[1]".format(pma))
output = "{}.output1D".format(pma)
cmds.connectAttr(output, destination)
def freeze_to_parent_offset(node=None):
"""Transfer the local matrix of the specified node into the offsetParentMatrix
:param node: Node name or list of node names
"""
if node is None:
node = cmds.ls(sl=True)
if node is None:
return
if not isinstance(node, string_types):
for n in node:
freeze_to_parent_offset(n)
return
if cmds.about(api=True) < 20200000:
raise RuntimeError("offsetParentMatrix is only available starting in Maya 2020")
offset = local_offset(node)
cmds.setAttr("{}.offsetParentMatrix".format(node), list(offset), type="matrix")
for attr in ["jo", "ra"]:
if cmds.objExists("{}.{}".format(node, attr)):
cmds.setAttr("{}.{}".format(node, attr), 0, 0, 0)
for attr in ["{}{}".format(x, y) for x in "trs" for y in "xyz"]:
is_locked = cmds.getAttr("{}.{}".format(node, attr), lock=True)
if is_locked:
cmds.setAttr("{}.{}".format(node, attr), lock=False)
value = 1.0 if attr.startswith("s") else 0.0
cmds.setAttr("{}.{}".format(node, attr), value)
if is_locked:
cmds.setAttr("{}.{}".format(node, attr), lock=True)
def local_offset(node):
"""Get the local matrix relative to the node's parent.
This takes in to account the offsetParentMatrix
:param node: Node name
:return: MMatrix
"""
offset = OpenMaya.MMatrix(cmds.getAttr("{}.worldMatrix[0]".format(node)))
parent = cmds.listRelatives(node, parent=True, path=True)
if parent:
pinv = OpenMaya.MMatrix(
cmds.getAttr("{}.worldInverseMatrix[0]".format(parent[0]))
)
offset *= pinv
return offset
def snap_to_position(node, snap_to):
pos = cmds.xform(snap_to, q=True, ws=True, t=True)
cmds.xform(node, ws=True, t=pos)
def snap_to_orientation(node, snap_to):
r = cmds.xform(snap_to, q=True, ws=True, ro=True)
cmds.xform(node, ws=True, ro=r)
def snap_to(node, snap_to):
snap_to_position(node, snap_to)
snap_to_orientation(node, snap_to)
def align(node, target, axis, world_up):
"""Align an axis of one node to another using offsetParentMatrix.
:param node: Node to align
:param target: Node to align to
:param axis: Local axis to match
:param world_up: World up axis
"""
axis = OpenMaya.MVector(axis)
world_up = OpenMaya.MVector(world_up)
tm = OpenMaya.MMatrix(cmds.getAttr("{}.worldMatrix[0]".format(target)))
world_axis = axis * tm
world_z = world_axis ^ world_up
world_up = world_z ^ world_axis
t = cmds.xform(node, q=True, ws=True, t=True)
x = list(world_axis) + [0.0]
y = list(world_up) + [0.0]
z = list(world_z) + [0.0]
t = [t[0], t[1], t[2], 1.0]
m = OpenMaya.MMatrix(*[x + y + z + t])
parent = cmds.listRelatives(node, parent=True, path=True)
if parent:
p = OpenMaya.MMatrix(cmds.getAttr("{}.worldInverseMatrix[0]".format(parent[0])))
m *= p
cmds.setAttr("{}.offsetParentMatrix".format(node), list(m), type="matrix")
def place_pole_vector(start, mid, end, pole_vector, offset):
"""Place a pole vector along the plane of the 2 bone ik
:param start: Start joint
:param mid: Mid joint
:param end: End joint
:param pole_vector: Pole vector transform
:param offset: Scalar offset from the mid joint
"""
v1 = OpenMaya.MVector(cmds.xform(start, q=True, ws=True, t=True))
v2 = OpenMaya.MVector(cmds.xform(mid, q=True, ws=True, t=True))
v3 = OpenMaya.MVector(cmds.xform(end, q=True, ws=True, t=True))
e1 = (v3 - v1).normal()
e2 = v2 - v1
v = v1 + e1 * (e1 * e2)
pos = v2 + (v2 - v).normal() * offset
cmds.xform(pole_vector, ws=True, t=list(pos))
def opm_parent_constraint(
driver, driven, maintain_offset=False, freeze=True, segment_scale_compensate=True
):
"""Create a parent constraint effect with offsetParentMatrix.
:param driver: Target transforms
:param driven: Transform to drive
:param maintain_offset: True to maintain offset
:param freeze: True to 0 out the local xforms
:param segment_scale_compensate: True to remove the resulting scale and shear
"""
opm_constraint(
driver,
driven,
maintain_offset=maintain_offset,
freeze=freeze,
segment_scale_compensate=segment_scale_compensate,
)
def opm_point_constraint(driver, driven, maintain_offset=False, freeze=True):
"""Create a parent constraint effect with offsetParentMatrix.
:param driver: Target transforms
:param driven: Transform to drive
:param maintain_offset: True to maintain offset
:param freeze: True to 0 out the local xforms
"""
opm_constraint(
driver,
driven,
maintain_offset=maintain_offset,
freeze=freeze,
use_rotate=False,
use_scale=False,
use_shear=False,
)
def opm_constraint(
driver,
driven,
maintain_offset=False,
freeze=True,
use_translate=True,
use_rotate=True,
use_scale=True,
use_shear=True,
segment_scale_compensate=True,
):
"""Create a parent constraint effect with offsetParentMatrix.
:param driver: Target transforms
:param driven: Transform to drive
:param maintain_offset: True to maintain offset
:param freeze: True to 0 out the local xforms
:param use_translate: True to use the translation of the driver matrix
:param use_rotate: True to use the rotation of the driver matrix
:param use_scale: True to use the scale of the driver matrix
:param use_shear: True to use the shear of the driver matrix
:param segment_scale_compensate: True to remove the resulting scale and shear
"""
mult = cmds.createNode("multMatrix")
if maintain_offset:
offset = OpenMaya.MMatrix(cmds.getAttr("{}.worldMatrix[0]".format(driven)))
if not freeze:
offset *= OpenMaya.MMatrix(
cmds.getAttr("{}.matrix".format(driven))
).inverse()
offset *= OpenMaya.MMatrix(
cmds.getAttr("{}.worldInverseMatrix[0]".format(driver))
)
cmds.setAttr("{}.matrixIn[0]".format(mult), list(offset), type="matrix")
pick = cmds.createNode("pickMatrix")
cmds.connectAttr("{}.worldMatrix[0]".format(driver), "{}.inputMatrix".format(pick))
cmds.setAttr("{}.useTranslate".format(pick), use_translate)
cmds.setAttr("{}.useRotate".format(pick), use_rotate)
cmds.setAttr("{}.useScale".format(pick), use_scale)
cmds.setAttr("{}.useShear".format(pick), use_shear)
cmds.connectAttr("{}.outputMatrix".format(pick), "{}.matrixIn[1]".format(mult))
parent = cmds.listRelatives(driven, parent=True, path=True)
if parent:
cmds.connectAttr(
"{}.worldInverseMatrix[0]".format(parent[0]), "{}.matrixIn[2]".format(mult)
)
if freeze:
freeze_to_parent_offset(driven)
if segment_scale_compensate:
pick = cmds.createNode("pickMatrix")
cmds.setAttr("{}.useScale".format(pick), False)
cmds.setAttr("{}.useShear".format(pick), False)
cmds.connectAttr("{}.matrixSum".format(mult), "{}.inputMatrix".format(pick))
output = "{}.outputMatrix".format(pick)
else:
output = "{}.matrixSum".format(mult)
cmds.connectAttr(output, "{}.offsetParentMatrix".format(driven))
def opm_aim_constraint(
driver, driven, maintain_offset=False, freeze=True, aim_vector=None, up_vector=None
):
"""Create a parent constraint effect with offsetParentMatrix.
:param driver: Target transforms
:param driven: Transform to drive
:param maintain_offset: True to maintain offset
:param freeze: True to 0 out the local xforms
"""
aim_vector = aim_vector or [1.0, 0.0, 0.0]
up_vector = up_vector or [0.0, 1.0, 0.0]
aim = cmds.createNode("aimMatrix")
cmds.setAttr("{}.primary.primaryInputAxis".format(aim), *aim_vector)
cmds.setAttr("{}.secondary.secondaryInputAxis".format(aim), *up_vector)
cmds.connectAttr(
"{}.worldMatrix[0]".format(driver), "{}.primary.primaryTargetMatrix".format(aim)
)
input_mult = cmds.createNode("multMatrix")
parent = cmds.listRelatives(driven, parent=True, path=True)
m = OpenMaya.MMatrix(cmds.getAttr("{}.worldMatrix[0]".format(driven)))
if parent:
pinv = OpenMaya.MMatrix(
cmds.getAttr("{}.worldInverseMatrix[0]".format(parent[0]))
)
m = m * pinv
cmds.connectAttr(
"{}.worldMatrix[0]".format(parent[0]), "{}.matrixIn[1]".format(input_mult)
)
cmds.setAttr("{}.matrixIn[0]".format(input_mult), list(m), type="matrix")
cmds.connectAttr("{}.matrixSum".format(input_mult), "{}.inputMatrix".format(aim))
mult = cmds.createNode("multMatrix")
if maintain_offset:
offset = OpenMaya.MMatrix(cmds.getAttr("{}.worldMatrix[0]".format(driven)))
if not freeze:
offset *= OpenMaya.MMatrix(
cmds.getAttr("{}.matrix".format(driven))
).inverse()
offset *= OpenMaya.MMatrix(
cmds.getAttr("{}.worldInverseMatrix[0]".format(driver))
)
cmds.setAttr("{}.matrixIn[0]".format(mult), list(offset), type="matrix")
cmds.connectAttr("{}.outputMatrix".format(aim), "{}.matrixIn[1]".format(mult))
if parent:
cmds.connectAttr(
"{}.worldInverseMatrix[0]".format(parent[0]), "{}.matrixIn[2]".format(mult)
)
if freeze:
freeze_to_parent_offset(driven)
cmds.connectAttr(
"{}.matrixSum".format(mult), "{}.offsetParentMatrix".format(driven)
)
