def create_interface(self):
super(CtrlModelCalibratable, self).create_interface()
# Add sensitivity attributes on the ctrl.
# The values will be adjusted on calibration.
libAttr.addAttr_separator(
self.grp_rig,
"ctrlCalibration"
)
self.attr_sensitivity_tx = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TX,
defaultValue=1.0
)
self.attr_sensitivity_ty = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TY,
defaultValue=1.0
)
self.attr_sensitivity_tz = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TZ,
defaultValue=1.0
)
self.attr_sensitivity_tx.set(channelBox=True)
self.attr_sensitivity_ty.set(channelBox=True)
self.attr_sensitivity_tz.set(channelBox=True)
def _get_follicle_absolute_uv_attr(self, mult_u=1.0, mult_v=1.0):
"""
Resolve the absolute parameterU and parameterV that will be sent to the follicles.
:param mult_u: Custom multiplier
:param mult_v:
:return: A tuple containing two pymel.Attribute: the absolute parameterU and relative parameterV.
"""
# TODO: Move attribute definition outside this function.
attr_u_inn = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_U)
attr_v_inn = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_V)
attr_u_relative, attr_v_relative = self._get_follicle_relative_uv_attr(
mult_u=mult_u, mult_v=mult_v)
# Add base parameterU & parameterV
attr_u_cur = libRigging.create_utility_node(
'addDoubleLinear',
input1=self._attr_u_base,
input2=attr_u_relative).output
attr_v_cur = libRigging.create_utility_node(
'addDoubleLinear',
input1=self._attr_v_base,
input2=attr_v_relative).output
# TODO: Move attribute connection outside of this function.
pymel.connectAttr(attr_u_cur, attr_u_inn)
pymel.connectAttr(attr_v_cur, attr_v_inn)
return attr_u_inn, attr_v_inn
def create_interface(self):
super(ModelInteractiveCtrl, self).create_interface()
# The values will be computed when attach_ctrl will be called
libAttr.addAttr_separator(
self.grp_rig,
"ctrlCalibration"
)
self.attr_sensitivity_tx = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TX,
defaultValue=1.0
)
self.attr_sensitivity_ty = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TY,
defaultValue=1.0
)
self.attr_sensitivity_tz = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TZ,
defaultValue=1.0
)
self.attr_sensitivity_tx.set(channelBox=True)
self.attr_sensitivity_ty.set(channelBox=True)
self.attr_sensitivity_tz.set(channelBox=True)
def _get_follicle_absolute_uv_attr(self, mult_u=1.0, mult_v=1.0):
"""
Resolve the absolute parameterU and parameterV that will be sent to the follicles.
:param mult_u: Custom multiplier
:param mult_v:
:return: A tuple containing two pymel.Attribute: the absolute parameterU and relative parameterV.
"""
# TODO: Move attribute definition outside this function.
attr_u_inn = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_U)
attr_v_inn = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_V)
attr_u_relative, attr_v_relative = self._get_follicle_relative_uv_attr(mult_u=mult_u, mult_v=mult_v)
# Add base parameterU & parameterV
attr_u_cur = libRigging.create_utility_node(
'addDoubleLinear',
input1=self._attr_u_base,
input2=attr_u_relative
).output
attr_v_cur = libRigging.create_utility_node(
'addDoubleLinear',
input1=self._attr_v_base,
input2=attr_v_relative
).output
# TODO: Move attribute connection outside of this function.
pymel.connectAttr(attr_u_cur, attr_u_inn)
pymel.connectAttr(attr_v_cur, attr_v_inn)
return attr_u_inn, attr_v_inn
def add_avar(self, attr_holder, name):
"""
Add an avar in the internal avars network.
An attribute will also be created on the grp_rig node.
"""
attr_rig = libAttr.addAttr(attr_holder, longName=name, k=True)
return attr_rig
def add_avar(self, attr_holder, name, defaultValue=0.0):
"""
Add an avar in the internal avars network.
An attribute will also be created on the grp_rig node.
"""
attr_rig = libAttr.addAttr(attr_holder, longName=name, k=True, defaultValue=defaultValue)
return attr_rig
def post_buid_module(self, module):
super(RigSqueeze, self).post_buid_module(module)
#
# Connect all IK/FK attributes
# TODO: Ensure all attributes are correctly transfered
#
if isinstance(module, rigLimb.Limb):
# Inverse IK/FK state.
# At Squeeze, 0 is IK and 1 is FK, strange.
module.STATE_IK = 0.0
module.STATE_FK = 1.0
pymel.delete(module.ctrl_attrs)
module.ctrl_attrs = None
# Resolve name
# TODO: Handle name conflict
nomenclature_anm = module.get_nomenclature_anm(self)
nomenclature_attr = self.nomenclature(tokens=[module.__class__.__name__], side=nomenclature_anm.side)
attr_src_name = nomenclature_attr.resolve()
attr_dst = module.grp_rig.attr(module.kAttrName_State)
if not self.grp_anm.hasAttr(self.GROUP_NAME_IKFK, checkShape=False):
libAttr.addAttr_separator(self.grp_anm, self.GROUP_NAME_IKFK)
attr_src = None
if not self.grp_anm.hasAttr(attr_src_name, checkShape=False):
attr_src = libAttr.addAttr(self.grp_anm, longName=attr_src_name, at='short', k=True,
hasMinValue=True, hasMaxValue=True, minValue=0, maxValue=1, defaultValue=0)
else:
attr_src = self.grp_anm.attr(attr_src_name)
# Note that at Squeeze, 0 is for IK and 1 is for FK so we'll need to reverse it.
attr_src_inv = libRigging.create_utility_node('reverse', inputX=attr_src).outputX
pymel.connectAttr(attr_src_inv, attr_dst)
#
# Set ctrls colors
#
color_by_side = {
self.nomenclature.SIDE_L: 13, # Red
self.nomenclature.SIDE_R: 6 # Blue
}
epsilon = 0.1
if module.grp_anm:
nomenclature_anm = module.get_nomenclature_anm(self)
for ctrl in module.get_ctrls(recursive=True):
nomenclature_ctrl = nomenclature_anm.rebuild(ctrl.name())
side = nomenclature_ctrl.side
color = color_by_side.get(side, None)
if color:
ctrl.drawOverride.overrideEnabled.set(1)
ctrl.drawOverride.overrideColor.set(color)
def create_stacks(self):
super(FaceLipsAvar, self).create_stacks()
nomenclature_rig = self.get_nomenclature_rig()
jnt_jaw = self.get_jaw_jnt()
jaw_module = self.get_jaw_module()
#
# Create additional attributes to control the jaw layer
#
libAttr.addAttr_separator(self.grp_rig, 'jawLayer')
self._attr_inn_jaw_ratio_default = libAttr.addAttr(
self.grp_rig,
'jawRatioDefault',
defaultValue=0.5,
hasMinValue=True,
hasMaxValue=True,
minValue=0,
maxValue=1,
k=True
)
self._attr_bypass_splitter = libAttr.addAttr(
self.grp_rig,
'jawSplitterBypass',
defaultValue=0.0,
hasMinValue=True,
hasMaxValue=True,
minValue=0,
maxValue=1,
k=True
)
# self._target_jaw_bindpose = self._parent_module._ref_jaw_predeform
# self._attr_jaw_pitch = self._parent_module._attr_jaw_pt
# Variable shared with the AvarInflModel
self._attr_jaw_bind_tm = self._parent_module._ref_jaw_predeform.matrix
self._attr_jaw_pitch = self._parent_module._attr_jaw_pt
def create_spaceswitch(self, rig, module, parent, add_default=True, default_name=None, add_world=False, **kwargs):
# TODO: Handle when parent is None?
nomenclature = rig.nomenclature
if parent is None:
log.warning("Can't add space switch on {0}. No parent found!".format(self.node.__melobject__()))
return
# Resolve spaceswitch targets
targets, labels = self.get_spaceswitch_targets(rig, module, parent, add_world=add_world)
if not targets:
log.warning("Can't add space switch on {0}. No targets found!".format(self.node.__melobject__()))
return
if default_name is None:
default_name = 'Local'
# Resolve the niceName of the targets
for i in range(len(targets)):
target = targets[i]
label = labels[i]
if label is None:
name = nomenclature(target.name())
name.remove_extra_tokens()
labels[i] = name.resolve()
offset = 0
if add_default:
offset += 1
labels.insert(0, default_name)
layer_spaceSwitch = self.add_layer('spaceSwitch')
parent_constraint = pymel.parentConstraint(targets, layer_spaceSwitch, maintainOffset=True, **kwargs)
attr_space = libAttr.addAttr(self.node, 'space', at='enum', enumName=':'.join(labels), k=True)
atts_weights = parent_constraint.getWeightAliasList()
for i, att_weight in enumerate(atts_weights):
index_to_match = i + offset
att_enabled = libRigging.create_utility_node( #Equal
'condition',
firstTerm=attr_space,
secondTerm=index_to_match,
colorIfTrueR=1,
colorIfFalseR=0
).outColorR
pymel.connectAttr(att_enabled, att_weight)
def _create_interface(self):
super(AvarSurfaceLipModel, self)._create_interface()
self._attr_inn_jaw_bindpose = libAttr.addAttr(self.grp_rig, 'innJawBindPose', dataType='matrix')
self._attr_inn_jaw_pitch = libAttr.addAttr(self.grp_rig, 'innJawPitch', defaultValue=0)
self._attr_inn_jaw_ratio_default = libAttr.addAttr(self.grp_rig, 'innJawRatioDefault', defaultValue=0)
self._attr_inn_bypass_splitter = libAttr.addAttr(self.grp_rig, 'innBypassSplitter')
self._attr_inn_ud_bypass = libAttr.addAttr(self.grp_rig, 'innBypassUD')
# self._attr_inn_surface_length_u = libAttr.addAttr(self.grp_rig, 'innSurfaceLengthU', defaultValue=0)
# self._attr_inn_surface_length_v = libAttr.addAttr(self.grp_rig, 'innSurfaceLengthV', defaultValue=0)
self._attr_out_jaw_ratio = libAttr.addAttr(self.grp_rig, 'outJawRatio')
def _init_attr(self, obj, longName, attributeType, **kwargs):
"""
Create an attribute if missing or invalid while preserving output connections.
:param obj: The object that hold the attribute.
:param longName: The longName (identifier) of the attribute.
:param at: The attributeType to use. Please don't provide the short form 'at'.
:param kwargs: Any additional keyword argument is redirected to pymel.addAttr.
:return: A pymel.Attribute instance.
"""
attr = obj.attr(longName) if obj.hasAttr(longName) else None
need_update = attr is None or attr.type() != attributeType
if need_update:
connections = None
if attr is not None:
connections = libAttr.hold_connections([attr], hold_inputs=False, hold_outputs=True)
attr.delete()
attr = libAttr.addAttr(
self.grp_anm, longName=longName, at=attributeType, **kwargs
)
if connections:
libAttr.fetch_connections(connections)
return attr
def build(self, module, ref, ref_tm=None, grp_rig=None, obj_mesh=None, u_coord=None, v_coord=None, flip_lr=False, follow_mesh=True, **kwargs):
"""
Create an Interactive controller that follow a geometry.
:param module: ???
:param ref:
:param ref_tm:
:param grp_rig:
:param obj_mesh:
:param u_coord:
:param v_coord:
:param kwargs:
:return:
"""
# HACK: Ensure flipped shapes are correctly restaured...
# This is necessary since when holded, the scale of the ctrl is set to identity.
# However ctrl from the right side have an inverted scale on the x axis. -_-
if flip_lr and libPymel.is_valid_PyNode(self.shapes):
self.shapes.sx.set(-1)
pymel.makeIdentity(self.shapes, rotate=True, scale=True, apply=True)
# todo: Simplify the setup, too many nodes
super(InteractiveCtrl, self).build(**kwargs)
#nomenclature_anm = self.get_nomenclature_anm(parent)
nomenclature_rig = module.rig.nomenclature(suffix=module.rig.nomenclature.type_rig)
#nomenclature_rig = self.get_nomenclature_rig(parent)
# TODO: Only use position instead of PyNode or Matrix?
if ref_tm is None:
ref_tm = ref.getMatrix(worldSpace=True)
pos_ref = ref_tm.translate
# Resolve u and v coordinates
# todo: check if we really want to resolve the u and v ourself since it's now connected.
if obj_mesh is None:
# We'll scan all available geometries and use the one with the shortest distance.
meshes = libRigging.get_affected_geometries(ref)
meshes = list(set(meshes) & set(module.rig.get_meshes()))
obj_mesh, _, out_u, out_v = libRigging.get_closest_point_on_shapes(meshes, pos_ref)
else:
_, out_u, out_v = libRigging.get_closest_point_on_shape(obj_mesh, pos_ref)
if u_coord is None:
u_coord = out_u
if v_coord is None:
v_coord = out_v
if obj_mesh is None:
raise Exception("Can't find mesh affected by {0}. Skipping doritos ctrl setup.")
if self.jnt:
module.debug('Creating doritos on {0} using {1} as reference'.format(obj_mesh, self.jnt))
else:
module.debug('Creating doritos on {0}'.format(obj_mesh))
# Initialize external stack
# Normally this would be hidden from animators.
stack_name = nomenclature_rig.resolve('doritosStack')
stack = classNode.Node(self)
stack.build(name=stack_name)
stack.setTranslation(pos_ref)
# Add sensibility attributes
# The values will be computed when attach_ctrl will be called
libAttr.addAttr_separator(
module.grp_rig,
"ctrlCalibration"
)
self.attr_sensitivity_tx = libAttr.addAttr(
module.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TX,
defaultValue=1.0
)
self.attr_sensitivity_ty = libAttr.addAttr(
module.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TY,
defaultValue=1.0
)
self.attr_sensitivity_tz = libAttr.addAttr(
module.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TZ,
defaultValue=1.0
)
self.attr_sensitivity_tx.set(channelBox=True)
self.attr_sensitivity_ty.set(channelBox=True)
self.attr_sensitivity_tz.set(channelBox=True)
# Note that to only check in the Z axis, we'll do a raycast first.
# If we success this will become our reference position.
'''
pos = pos_ref
pos.z = 999
dir = pymel.datatypes.Point(0,0,-1)
result = next(iter(libRigging.ray_cast(pos, dir, [obj_mesh])), None)
if result:
pos_ref = result
ctrl_tm.translate = result
'''
# Create the layer_fol that will follow the geometry
layer_fol_name = nomenclature_rig.resolve('doritosFol')
layer_fol = stack.append_layer()
layer_fol.rename(layer_fol_name)
#layer_fol.setParent(self.grp_rig)
# TODO: Validate that we don't need to inverse the rotation separately.
fol_mesh = None
if follow_mesh:
fol_name = nomenclature_rig.resolve('doritosFollicle')
fol_shape = libRigging.create_follicle2(obj_mesh, u=u_coord, v=v_coord)
fol_mesh = fol_shape.getParent()
self.follicle = fol_mesh
fol_mesh.rename(fol_name)
pymel.parentConstraint(fol_mesh, layer_fol, maintainOffset=True)
fol_mesh.setParent(self.grp_rig)
# HACK: Fix rotation issues.
# The doritos setup can be hard to control when the rotation of the controller depend on the layer_fol since
# any deformation can affect the normal of the faces.
jnt_head = module.rig.get_head_jnt()
if jnt_head:
pymel.disconnectAttr(layer_fol.rx)
pymel.disconnectAttr(layer_fol.ry)
pymel.disconnectAttr(layer_fol.rz)
pymel.orientConstraint(jnt_head, layer_fol, maintainOffset=True)
else:
self.follicle = layer_fol
pymel.parentConstraint(ref, layer_fol, maintainOffset=True)
#
# Constraint a specic controller to the avar doritos stack.
# Call this method after connecting the ctrl to the necessary avars.
# The sensibility of the doritos will be automatically computed in this step if necessary.
#
# Create inverted attributes for sensibility
util_sensitivity_inv = libRigging.create_utility_node('multiplyDivide', operation=2,
input1X=1.0, input1Y=1.0, input1Z=1.0,
input2X=self.attr_sensitivity_tx,
input2Y=self.attr_sensitivity_ty,
input2Z=self.attr_sensitivity_tz
)
attr_sensibility_lr_inv = util_sensitivity_inv.outputX
attr_sensibility_ud_inv = util_sensitivity_inv.outputY
attr_sensibility_fb_inv = util_sensitivity_inv.outputZ
# Add an inverse node that will counter animate the position of the ctrl.
# TODO: Rename
layer_doritos_name = nomenclature_rig.resolve('doritosInv')
layer_doritos = pymel.createNode('transform', name=layer_doritos_name)
layer_doritos.setParent(stack.node)
# Create inverse attributes for the ctrl
attr_ctrl_inv_t = libRigging.create_utility_node('multiplyDivide', input1=self.node.t, input2=[-1, -1, -1]).output
attr_ctrl_inv_r = libRigging.create_utility_node('multiplyDivide', input1=self.node.r, input2=[-1, -1, -1]).output
attr_ctrl_inv_t = libRigging.create_utility_node('multiplyDivide',
input1=attr_ctrl_inv_t,
input2X=self.attr_sensitivity_tx,
input2Y=self.attr_sensitivity_ty,
input2Z=self.attr_sensitivity_tz
).output
if flip_lr:
attr_doritos_tx = libRigging.create_utility_node('multiplyDivide',
input1X=attr_ctrl_inv_t.outputX,
input2X=-1
).outputX
else:
attr_doritos_tx = attr_ctrl_inv_t.outputX
attr_doritos_ty = attr_ctrl_inv_t.outputY
attr_doritos_tz = attr_ctrl_inv_t.outputZ
pymel.connectAttr(attr_doritos_tx, layer_doritos.tx)
pymel.connectAttr(attr_doritos_ty, layer_doritos.ty)
pymel.connectAttr(attr_doritos_tz, layer_doritos.tz)
pymel.connectAttr(attr_ctrl_inv_r, layer_doritos.r)
# Apply scaling on the ctrl parent.
# This is were the 'black magic' happen.
if flip_lr:
attr_ctrl_offset_sx_inn = libRigging.create_utility_node('multiplyDivide',
input1X=self.attr_sensitivity_tx,
input2X=-1
).outputX
else:
attr_ctrl_offset_sx_inn = self.attr_sensitivity_tx
attr_ctrl_offset_sy_inn = self.attr_sensitivity_ty
attr_ctrl_offset_sz_inn = self.attr_sensitivity_tz
pymel.connectAttr(attr_ctrl_offset_sx_inn, self.offset.scaleX)
pymel.connectAttr(attr_ctrl_offset_sy_inn, self.offset.scaleY)
pymel.connectAttr(attr_ctrl_offset_sz_inn, self.offset.scaleZ)
# Apply sensibility on the ctrl shape
ctrl_shape = self.node.getShape()
tmp = pymel.duplicate(self.node.getShape())[0]
ctrl_shape_orig = tmp.getShape()
ctrl_shape_orig.setParent(self.node, relative=True, shape=True)
ctrl_shape_orig.rename('{0}Orig'.format(ctrl_shape.name()))
pymel.delete(tmp)
ctrl_shape_orig.intermediateObject.set(True)
for cp in ctrl_shape.cp:
cp.set(0,0,0)
# Counter-scale the shape
attr_adjustement_sx_inn = attr_sensibility_lr_inv
attr_adjustement_sy_inn = attr_sensibility_ud_inv
attr_adjustement_sz_inn = attr_sensibility_fb_inv
attr_adjustement_scale = libRigging.create_utility_node('composeMatrix',
inputScaleX=attr_adjustement_sx_inn,
inputScaleY=attr_adjustement_sy_inn,
inputScaleZ=attr_adjustement_sz_inn
).outputMatrix
attr_adjustement_rot = libRigging.create_utility_node('composeMatrix',
inputRotateX=self.node.rotateX,
inputRotateY=self.node.rotateY,
inputRotateZ=self.node.rotateZ
).outputMatrix
attr_adjustement_rot_inv = libRigging.create_utility_node('inverseMatrix', inputMatrix=attr_adjustement_rot).outputMatrix
attr_adjustement_tm = libRigging.create_utility_node('multMatrix', matrixIn=[
attr_adjustement_rot,
attr_adjustement_scale,
attr_adjustement_rot_inv
]).matrixSum
attr_transform_geometry = libRigging.create_utility_node('transformGeometry', transform=attr_adjustement_tm,
inputGeometry=ctrl_shape_orig.local).outputGeometry
pymel.connectAttr(attr_transform_geometry, ctrl_shape.create, force=True)
# Constraint ctrl
pymel.parentConstraint(layer_doritos, self.offset, maintainOffset=False, skipRotate=['x', 'y', 'z'])
pymel.orientConstraint(layer_doritos.getParent(), self.offset, maintainOffset=True)
# Clean dag junk
if grp_rig:
stack.setParent(grp_rig)
if fol_mesh:
fol_mesh.setParent(grp_rig)
def create_spaceswitch(self, module, parent, add_default=True, default_name=None, add_world=False, **kwargs):
"""
Create the space switch attribute on the controller using a list of target found from it's module hierarchy
:param module: The module on which we want to process space switch targets
:param parent: The parent used as the default (local) target
:param add_default: Is the default target will be added to the list of targets
:param default_name: The name of the default target
:param add_world: Is the world will be added as a target
:param kwargs: Additional parameters
:return: None
"""
# TODO: Handle when parent is None?
nomenclature = module.rig.nomenclature
# Resolve spaceswitch targets
targets, labels, indexes = self.get_spaceswitch_targets(module, parent,
add_world=add_world, add_local=add_default)
if not targets:
module.warning("Can't add space switch on {0}. No targets found!".format(self.node.__melobject__()))
return
if default_name is None:
default_name = 'Local'
# Resolve the niceName of the targets
for i in range(len(targets)):
target = targets[i]
label = labels[i]
if label is None and target is not None:
name = nomenclature(target.name())
name.remove_extra_tokens()
labels[i] = name.resolve()
# Create the parent constraint before adding the local since local target will be set to itself
# to keep a serialized link to the local target
layer_space_switch = self.append_layer('spaceSwitch')
parent_constraint = pymel.parentConstraint(targets, layer_space_switch, maintainOffset=True, **kwargs)
# Build the enum string from the information we got
enum_string = ""
# Add the local option if needed
if add_default:
# We cannot self referencing since it will break maya deletion mechanism
# targets.append(self)
# indexes.append(default_index)
# labels.append(default_name)
enum_string += default_name + "=" + \
str(self.local_index)
# The enum string will skip index if needed
for label, index in zip(labels, indexes):
if enum_string:
enum_string += ":"
enum_string += label + "=" + str(index)
# Update the serialized variable to make sure everything is up to date
for i, target in enumerate(targets):
if target not in self.targets:
self.targets.append(target)
if indexes[i] in self.targets_indexes:
log.warning("Index ({0}) is already used for space switch on ctrl {1}. "
"Strange behavior could happen".format(indexes[i], self.name()))
self.targets_indexes.append(indexes[i])
attr_space = libAttr.addAttr(self.node, 'space', at='enum', enumName=enum_string, k=True)
atts_weights = parent_constraint.getWeightAliasList()
for i, att_weight in enumerate(atts_weights):
index_to_match = indexes[i]
att_enabled = libRigging.create_utility_node( #Equal
'condition',
firstTerm=attr_space,
secondTerm=index_to_match,
colorIfTrueR=1,
colorIfFalseR=0
).outColorR
pymel.connectAttr(att_enabled, att_weight)
# By Default, the active space will be local, else root and finally fallback on the first index found
if add_default:
self.node.space.set(default_name)
elif self._reserved_idx['root'] in self.targets_indexes:
self.node.space.set(self._reserved_idx['root'])
else:
if self.targets_indexes:
self.node.space.set(self.targets_indexes[0])
def build(self, constraint=True, constraint_handle=True, setup_softik=True, **kwargs):
"""
:param constraint: Bool to tell if we will constraint the chain bone on the ikchain
:param constraint_handle: Bool to tell if we will contraint the handle on the ik ctrl
:param setup_softik: Bool to tell if we setup the soft ik system
:param kwargs: More kwargs passed to the superclass
:return: Nothing
"""
# Build the softik node after the setup for the quadruped
super(LegIkQuad, self).build(constraint=False, constraint_handle=False, setup_softik=False, **kwargs)
nomenclature_rig = self.get_nomenclature_rig()
quad_swivel_pos = self.calc_swivel_pos(start_index=1, end_index=3)
heel_idx = self.iCtrlIndex - 1
# Hack: Re-parent ehe ik chain as a workaround for the spring ik solver bug.
# Otherwise the current parent (which is constrained) will trigger and old sprint ik solver bug
# that will result in double rotation.
# src: http://forums.cgsociety.org/showthread.php?t=936724
ik_chain_start = self._chain_ik[0]
ik_chain_start.setParent(self.grp_rig)
pymel.parentConstraint(self._ikChainGrp, ik_chain_start, maintainOffset=True, skipRotate=['x', 'y', 'z'])
# Create a second ik chain for the quadruped setup
self._chain_quad_ik = self.chain.duplicate()
for i, oIk in enumerate(self._chain_quad_ik):
oIk.rename(nomenclature_rig.resolve('QuadChain{0:02}'.format(i)))
# Constraint the bones after the iCtrlIdx to the first ik chain to make the foot roll work correctly
if i > self.iCtrlIndex:
pymel.parentConstraint(self._chain_ik[i], self._chain_quad_ik[i])
self._chain_quad_ik[0].setParent(self._chain_ik[0])
# Hack: Since we are using direct connection on the first joint of the quad_ik chain,
# there might be situation where Maya will give an initial rotation of (180, 180, 180) instead of (0, 0, 0).
# To prevent this we'll manually make sure that the rotation is zeroed out.
self._chain_quad_ik[0].r.set(0, 0, 0)
obj_e_ik = self._chain_ik[self.iCtrlIndex]
obj_e_quadik = self._chain_quad_ik[self.iCtrlIndex]
# We need a second ik solver for the quad chain
ik_solver_quad_name = nomenclature_rig.resolve('quadIkHandle')
ik_effector_quad_name = nomenclature_rig.resolve('quadIkEffector')
self._ik_handle_quad, _ik_effector = pymel.ikHandle(startJoint=self._chain_quad_ik[1],
endEffector=obj_e_quadik,
solver='ikRPsolver')
self._ik_handle_quad.rename(ik_solver_quad_name)
_ik_effector.rename(ik_effector_quad_name)
self._ik_handle_quad.setParent(self._ik_handle)
#
# Create softIk node and connect user accessible attributes to it.
#
if setup_softik:
self.setup_softik([self._ik_handle, self._ik_handle_quad], [self._chain_ik, self._chain_quad_ik])
# Create another swivel handle node for the quad chain setup
self.ctrl_swivel_quad = self.setup_swivel_ctrl(self.ctrl_swivel_quad, self._chain_quad_ik[heel_idx],
quad_swivel_pos, self._ik_handle_quad, name='swivelQuad',
mirror_setup=False, adjust_ik_handle_twist=False)
# self.quad_swivel_distance = self.chain_length # Used in ik/fk switch
# Set by default the space to calf
if self.ctrl_swivel_quad.space:
enum = self.ctrl_swivel_quad.space.getEnums()
calf_idx = enum.get('Calf', None)
if calf_idx:
self.ctrl_swivel_quad.space.set(calf_idx)
# Expose 'pitch' Quadruped-specific attribute.
attr_holder = self.ctrl_ik
libAttr.addAttr_separator(attr_holder, 'Quadruped', niceName='Quadruped')
attr_pitch = libAttr.addAttr(attr_holder, longName='pitch', k=True)
pymel.connectAttr(attr_pitch, self._chain_quad_ik[0].rotateZ)
pymel.orientConstraint(obj_e_ik, obj_e_quadik, maintainOffset=True)
if constraint:
for source, target in zip(self._chain_quad_ik, self.chain):
# Note that maintainOffset should not be necessary, however in some rare case even after all the
# adjustments we do, the rotation of the influence might be flipped for no particular reasons.
# (see Task #70938).
pymel.parentConstraint(source, target, maintainOffset=True)
def build_stack(self, rig, stack, mult_u=1.0, mult_v=1.0):
"""
The dag stack is a stock of dagnode that act as additive deformer to controler the final position of
the drived joint.
"""
# TODO: Maybe use sub-classing to differenciate when we need to use a surface or not.
nomenclature_rig = self.get_nomenclature_rig(rig)
#
# Create follicle setup
# The setup is composed of two follicles.
# One for the "bind pose" and one "driven" by the avars..
# The delta between the "bind pose" and the "driven" follicles is then applied to the influence.
#
# Determine the follicle U and V on the reference nurbsSurface.
# jnt_pos = self.jnt.getTranslation(space='world')
# fol_pos, fol_u, fol_v = libRigging.get_closest_point_on_surface(self.surface, jnt_pos)
fol_u, fol_v = self.get_base_uv()
# Create and connect follicle-related parameters
u_base = fol_u # fol_influence.parameterU.get()
v_base = 0.5 # fol_influence.parameterV.get()
# Resolve the length of each axis of the surface
self._attr_length_u, self._attr_length_v, arcdimension_shape = libRigging.create_arclengthdimension_for_nurbsplane(self.surface)
arcdimension_transform = arcdimension_shape.getParent()
arcdimension_transform.rename(nomenclature_rig.resolve('arcdimension'))
arcdimension_transform.setParent(self.grp_rig)
# Create the bind pose follicle
offset_name = nomenclature_rig.resolve('bindPoseRef')
obj_offset = pymel.createNode('transform', name=offset_name)
obj_offset.setParent(stack._layers[0])
fol_offset_name = nomenclature_rig.resolve('bindPoseFollicle')
# fol_offset = libRigging.create_follicle(obj_offset, self.surface, name=fol_offset_name)
fol_offset_shape = libRigging.create_follicle2(self.surface, u=fol_u, v=fol_v)
fol_offset = fol_offset_shape.getParent()
fol_offset.rename(fol_offset_name)
pymel.parentConstraint(fol_offset, obj_offset, maintainOffset=False)
fol_offset.setParent(self.grp_rig)
# Create the influence follicle
influence_name = nomenclature_rig.resolve('influenceRef')
influence = pymel.createNode('transform', name=influence_name)
influence.setParent(stack._layers[0])
fol_influence_name = nomenclature_rig.resolve('influenceFollicle')
fol_influence_shape = libRigging.create_follicle2(self.surface, u=fol_u, v=fol_v)
fol_influence = fol_influence_shape.getParent()
fol_influence.rename(fol_influence_name)
pymel.parentConstraint(fol_influence, influence, maintainOffset=False)
fol_influence.setParent(self.grp_rig)
#
# Extract the delta of the influence follicle and it's initial pose follicle
#
attr_localTM = libRigging.create_utility_node('multMatrix', matrixIn=[
influence.worldMatrix,
obj_offset.worldInverseMatrix
]).matrixSum
# Since we are extracting the delta between the influence and the bindpose matrix, the rotation of the surface
# is not taken in consideration wich make things less intuitive for the rigger.
# So we'll add an adjustement matrix so the rotation of the surface is taken in consideration.
util_decomposeTM_bindPose = libRigging.create_utility_node('decomposeMatrix',
inputMatrix=obj_offset.worldMatrix
)
attr_translateTM = libRigging.create_utility_node('composeMatrix',
inputTranslate=util_decomposeTM_bindPose.outputTranslate
).outputMatrix
attr_translateTM_inv = libRigging.create_utility_node('inverseMatrix',
inputMatrix=attr_translateTM,
).outputMatrix
attr_rotateTM = libRigging.create_utility_node('multMatrix',
matrixIn=[obj_offset.worldMatrix, attr_translateTM_inv]
).matrixSum
attr_rotateTM_inv = libRigging.create_utility_node('inverseMatrix',
inputMatrix=attr_rotateTM
).outputMatrix
attr_finalTM = libRigging.create_utility_node('multMatrix',
matrixIn=[attr_rotateTM_inv,
attr_localTM,
attr_rotateTM]
).matrixSum
util_decomposeTM = libRigging.create_utility_node('decomposeMatrix',
inputMatrix=attr_finalTM
)
layer_follicle = stack.add_layer('follicleLayer')
pymel.connectAttr(util_decomposeTM.outputTranslate, layer_follicle.translate)
pymel.connectAttr(util_decomposeTM.outputRotate, layer_follicle.rotate)
self._attr_u_base = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_U_BASE, defaultValue=u_base)
self._attr_v_base = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_V_BASE, defaultValue=v_base)
attr_u_inn = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_U)
attr_v_inn = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_V)
self._attr_u_mult_inn = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_U_MULT, defaultValue=mult_u)
self._attr_v_mult_inn = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_V_MULT, defaultValue=mult_v)
# Connect UD to V
attr_get_v_offset = libRigging.create_utility_node('multiplyDivide',
input1X=self.attr_ud,
input2X=0.5
).outputX
attr_get_v_multiplied = libRigging.create_utility_node('multiplyDivide',
input1X=attr_get_v_offset,
input2X=self._attr_v_mult_inn).outputX
attr_v_cur = libRigging.create_utility_node('addDoubleLinear',
input1=self._attr_v_base,
input2=attr_get_v_multiplied
).output
pymel.connectAttr(attr_v_cur, attr_v_inn)
# Connect LR to U
attr_get_u_offset = libRigging.create_utility_node('multiplyDivide',
input1X=self.attr_lr,
input2X=0.5
).outputX
attr_get_u_multiplied = libRigging.create_utility_node('multiplyDivide',
input1X=attr_get_u_offset,
input2X=self._attr_u_mult_inn).outputX
attr_u_cur = libRigging.create_utility_node('addDoubleLinear',
input1=self._attr_u_base,
input2=attr_get_u_multiplied
).output
pymel.connectAttr(attr_u_cur, attr_u_inn)
pymel.connectAttr(attr_u_inn, fol_influence.parameterU)
pymel.connectAttr(attr_v_inn, fol_influence.parameterV)
pymel.connectAttr(self._attr_u_base, fol_offset.parameterU)
pymel.connectAttr(self._attr_v_base, fol_offset.parameterV)
#
# The OOB layer (out-of-bound) allow the follicle to go outside it's original plane.
# HACK: If the UD value is out the nurbsPlane UV range (0-1), ie 1.1, we'll want to still offset the follicle.
# For that we'll compute a delta between a small increment (0.99 and 1.0) and multiply it.
#
nomenclature_rig = self.get_nomenclature_rig(rig)
oob_step_size = 0.001 # TODO: Expose a Maya attribute?
jnt_tm = self.jnt.getMatrix(worldSpace=True)
'''
inf_clamped_v_name= nomenclature_rig.resolve('influenceClampedVRef')
inf_clamped_v = pymel.createNode('transform', name=inf_clamped_v_name)
inf_clamped_v.setParent(stack._layers[0])
inf_clamped_u_name= nomenclature_rig.resolve('influenceClampedURef')
inf_clamped_u = pymel.createNode('transform', name=inf_clamped_u_name)
inf_clamped_u.setParent(stack._layers[0])
'''
fol_clamped_v_name = nomenclature_rig.resolve('influenceClampedV')
fol_clamped_v_shape = libRigging.create_follicle2(self.surface, u=fol_u, v=fol_v)
fol_clamped_v = fol_clamped_v_shape.getParent()
fol_clamped_v.rename(fol_clamped_v_name)
fol_clamped_v.setParent(self.grp_rig)
fol_clamped_u_name = nomenclature_rig.resolve('influenceClampedU')
fol_clamped_u_shape = libRigging.create_follicle2(self.surface, u=fol_u, v=fol_v)
fol_clamped_u = fol_clamped_u_shape.getParent()
fol_clamped_u.rename(fol_clamped_u_name)
fol_clamped_u.setParent(self.grp_rig)
# Clamp the values so they never fully reach 0 or 1 for U and V.
util_clamp_uv = libRigging.create_utility_node('clamp',
inputR=attr_u_cur,
inputG=attr_v_cur,
minR=oob_step_size,
minG=oob_step_size,
maxR=1.0 - oob_step_size,
maxG=1.0 - oob_step_size)
clamped_u = util_clamp_uv.outputR
clamped_v = util_clamp_uv.outputG
pymel.connectAttr(clamped_v, fol_clamped_v.parameterV)
pymel.connectAttr(attr_u_cur, fol_clamped_v.parameterU)
pymel.connectAttr(attr_v_cur, fol_clamped_u.parameterV)
pymel.connectAttr(clamped_u, fol_clamped_u.parameterU)
# Compute the direction to add for U and V if we are out-of-bound.
dir_oob_u = libRigging.create_utility_node('plusMinusAverage',
operation=2,
input3D=[
fol_influence.translate,
fol_clamped_u.translate
]).output3D
dir_oob_v = libRigging.create_utility_node('plusMinusAverage',
operation=2,
input3D=[
fol_influence.translate,
fol_clamped_v.translate
]).output3D
# Compute the offset to add for U and V
condition_oob_u_neg = libRigging.create_utility_node('condition',
operation=4, # less than
firstTerm=attr_u_cur,
secondTerm=0.0,
colorIfTrueR=1.0,
colorIfFalseR=0.0,
).outColorR
condition_oob_u_pos = libRigging.create_utility_node('condition', # greater than
operation=2,
firstTerm=attr_u_cur,
secondTerm=1.0,
colorIfTrueR=1.0,
colorIfFalseR=0.0,
).outColorR
condition_oob_v_neg = libRigging.create_utility_node('condition',
operation=4, # less than
firstTerm=attr_v_cur,
secondTerm=0.0,
colorIfTrueR=1.0,
colorIfFalseR=0.0,
).outColorR
condition_oob_v_pos = libRigging.create_utility_node('condition', # greater than
operation=2,
firstTerm=attr_v_cur,
secondTerm=1.0,
colorIfTrueR=1.0,
colorIfFalseR=0.0,
).outColorR
# Compute the amount of oob
oob_val_u_pos = libRigging.create_utility_node('plusMinusAverage', operation=2,
input1D=[attr_u_cur, 1.0]).output1D
oob_val_u_neg = libRigging.create_utility_node('multiplyDivide', input1X=attr_u_cur, input2X=-1.0).outputX
oob_val_v_pos = libRigging.create_utility_node('plusMinusAverage', operation=2,
input1D=[attr_v_cur, 1.0]).output1D
oob_val_v_neg = libRigging.create_utility_node('multiplyDivide', input1X=attr_v_cur, input2X=-1.0).outputX
oob_val_u = libRigging.create_utility_node('condition', operation=0, firstTerm=condition_oob_u_pos,
secondTerm=1.0, colorIfTrueR=oob_val_u_pos,
colorIfFalseR=oob_val_u_neg).outColorR
oob_val_v = libRigging.create_utility_node('condition', operation=0, firstTerm=condition_oob_v_pos,
secondTerm=1.0, colorIfTrueR=oob_val_v_pos,
colorIfFalseR=oob_val_v_neg).outColorR
oob_amount_u = libRigging.create_utility_node('multiplyDivide', operation=2, input1X=oob_val_u,
input2X=oob_step_size).outputX
oob_amount_v = libRigging.create_utility_node('multiplyDivide', operation=2, input1X=oob_val_v,
input2X=oob_step_size).outputX
oob_offset_u = libRigging.create_utility_node('multiplyDivide', input1X=oob_amount_u, input1Y=oob_amount_u,
input1Z=oob_amount_u, input2=dir_oob_u).output
oob_offset_v = libRigging.create_utility_node('multiplyDivide', input1X=oob_amount_v, input1Y=oob_amount_v,
input1Z=oob_amount_v, input2=dir_oob_v).output
# Add the U out-of-bound-offset only if the U is between 0.0 and 1.0
oob_u_condition_1 = condition_oob_u_neg
oob_u_condition_2 = condition_oob_u_pos
oob_u_condition_added = libRigging.create_utility_node('addDoubleLinear',
input1=oob_u_condition_1,
input2=oob_u_condition_2
).output
oob_u_condition_out = libRigging.create_utility_node('condition',
operation=0, # equal
firstTerm=oob_u_condition_added,
secondTerm=1.0,
colorIfTrue=oob_offset_u,
colorIfFalse=[0, 0, 0]
).outColor
# Add the V out-of-bound-offset only if the V is between 0.0 and 1.0
oob_v_condition_1 = condition_oob_v_neg
oob_v_condition_2 = condition_oob_v_pos
oob_v_condition_added = libRigging.create_utility_node('addDoubleLinear',
input1=oob_v_condition_1,
input2=oob_v_condition_2
).output
oob_v_condition_out = libRigging.create_utility_node('condition',
operation=0, # equal
firstTerm=oob_v_condition_added,
secondTerm=1.0,
colorIfTrue=oob_offset_v,
colorIfFalse=[0, 0, 0]
).outColor
oob_offset = libRigging.create_utility_node('plusMinusAverage',
input3D=[oob_u_condition_out, oob_v_condition_out]).output3D
layer_oob = stack.add_layer('oobLayer')
pymel.connectAttr(oob_offset, layer_oob.t)
#
# Build Front/Back setup
#
layer_fb = stack.add_layer('fbLayer')
attr_get_fb = libRigging.create_utility_node('multiplyDivide',
input1X=self.attr_fb,
input2X=self._attr_length_u).outputX
attr_get_fb_adjusted = libRigging.create_utility_node('multiplyDivide',
input1X=attr_get_fb,
input2X=0.1).outputX
pymel.connectAttr(attr_get_fb_adjusted, layer_fb.translateZ)
#
# Create a layer before the ctrl to apply the YW, PT and RL avar.
#
nomenclature_rig = self.get_nomenclature_rig(rig)
layer_rot = stack.add_layer('rotLayer')
pymel.connectAttr(self.attr_yw, layer_rot.rotateY)
pymel.connectAttr(self.attr_pt, layer_rot.rotateX)
pymel.connectAttr(self.attr_rl, layer_rot.rotateZ)
return stack
def build(self, constraint=True, constraint_handle=True, setup_softik=True, **kwargs):
"""
:param constraint: Bool to tell if we will constraint the chain bone on the ikchain
:param constraint_handle: Bool to tell if we will contraint the handle on the ik ctrl
:param setup_softik: Bool to tell if we setup the soft ik system
:param kwargs: More kwargs passed to the superclass
:return: Nothing
"""
# Build the softik node after the setup for the quadruped
super(LegIkQuad, self).build(constraint=False, constraint_handle=False, setup_softik=False, **kwargs)
nomenclature_rig = self.get_nomenclature_rig()
quad_swivel_pos = self.calc_swivel_pos(start_index=1, end_index=3)
heel_idx = self.iCtrlIndex - 1
# Create a second ik chain for the quadruped setup
self._chain_quad_ik = self.chain.duplicate()
for i, oIk in enumerate(self._chain_quad_ik):
oIk.rename(nomenclature_rig.resolve('QuadChain{0:02}'.format(i)))
# Constraint the bones after the iCtrlIdx to the first ik chain to make the foot roll work correctly
if i > self.iCtrlIndex:
pymel.parentConstraint(self._chain_ik[i], self._chain_quad_ik[i])
self._chain_quad_ik[0].setParent(self._chain_ik[0])
obj_e = self._chain_quad_ik[self.iCtrlIndex]
# We need a second ik solver for the quad chain
ik_solver_quad_name = nomenclature_rig.resolve('quadIkHandle')
ik_effector_quad_name = nomenclature_rig.resolve('quadIkEffector')
self._ik_handle_quad, _ik_effector = pymel.ikHandle(startJoint=self._chain_quad_ik[1],
endEffector=obj_e,
solver='ikRPsolver')
self._ik_handle_quad.rename(ik_solver_quad_name)
_ik_effector.rename(ik_effector_quad_name)
self._ik_handle_quad.setParent(self._ik_handle)
#
# Create softIk node and connect user accessible attributes to it.
#
if setup_softik:
self.setup_softik([self._ik_handle, self._ik_handle_quad], self._chain_quad_ik)
# Create another swivel handle node for the quad chain setup
self.ctrl_swivel_quad = self.setup_swivel_ctrl(self.ctrl_swivel_quad, self._chain_quad_ik[heel_idx],
quad_swivel_pos, self._ik_handle_quad, name='swivelQuad', mirror_setup=False)
self.quad_swivel_distance = self.chain_length # Used in ik/fk switch
# Set by default the space to calf
if self.ctrl_swivel_quad.space:
enum = self.ctrl_swivel_quad.space.getEnums()
calf_idx = enum.get('Calf', None)
if calf_idx:
self.ctrl_swivel_quad.space.set(calf_idx)
attr_holder = self.ctrl_ik
libAttr.addAttr_separator(attr_holder, 'Quadruped', niceName='Quadruped')
attr_pitch = libAttr.addAttr(attr_holder, longName='pitch', k=True)
pymel.connectAttr(attr_pitch, self._chain_quad_ik[0].rotateZ)
pymel.orientConstraint(self.ctrl_ik, obj_e, maintainOffset=True)
if constraint:
for source, target in zip(self._chain_quad_ik, self.chain):
pymel.parentConstraint(source, target)
def build(self, avar, ref=None, ref_tm=None, grp_rig=None, obj_mesh=None, u_coord=None, v_coord=None,
flip_lr=False, follow_mesh=True, ctrl_tm=None, ctrl_size=1.0, parent_pos=None,
parent_rot=None, parent_scl=None, constraint=False, cancel_t=True, cancel_r=True, attr_bind_tm=None,
**kwargs):
# todo: get rid of the u_coods, v_coods etc, we should rely on the bind
super(ModelCtrlLinear, self).build(avar, ctrl_size=ctrl_size, **kwargs)
nomenclature_rig = self.get_nomenclature_rig()
#
# Resolve necessary informations
#
# Resolve which object will the InteractiveCtrl track.
# If we don't want to follow a particular geometry, we'll use the end of the stack.
# Otherwise the influence will be used (to also resolve the geometry).
# todo: it could be better to resolve the geometry ourself
if ref is None:
ref = self.jnt
# Resolve the ctrl default tm
if ctrl_tm is None:
ctrl_tm = self.get_default_tm_ctrl()
if ctrl_tm is None:
raise Exception("Cannot resolve ctrl transformation matrix!")
# By default, we expect the rigger to mirror the face joints using the 'behavior' mode.
if flip_lr:
ctrl_tm = pymel.datatypes.Matrix(
1.0, 0.0, 0.0, 0.0,
0.0, -1.0, 0.0, 0.0,
0.0, 0.0, -1.0, 0.0,
0.0, 0.0, 0.0, 1.0) * ctrl_tm
self._grp_bind_ctrl = pymel.createNode(
'transform',
name=nomenclature_rig.resolve('ctrlBindTm'),
parent=self.grp_rig,
)
self._grp_bind_ctrl.setMatrix(ctrl_tm)
# Resolve the influence bind tm
# Create an offset node to easily change it.
self._grp_bind_infl = pymel.createNode('transform', name=nomenclature_rig.resolve('bind'), parent=self.grp_rig)
if attr_bind_tm:
util_decompose_bind = libRigging.create_utility_node(
'decomposeMatrix',
inputMatrix=attr_bind_tm,
)
pymel.connectAttr(util_decompose_bind.outputTranslate, self._grp_bind_infl.translate)
pymel.connectAttr(util_decompose_bind.outputRotate, self._grp_bind_infl.rotate)
pymel.connectAttr(util_decompose_bind.outputScale, self._grp_bind_infl.scale)
else: # todo: deprecate this?
self._grp_bind_infl.setTranslation(ctrl_tm.translate)
# Create a follicle, this will be used for calibration purpose.
# If this affect performance we can create it only when necessary, however being able to
# see it help with debugging.
follicle_transform, follicle_shape = self._create_follicle(
ctrl_tm,
ref,
obj_mesh=obj_mesh,
u_coord=u_coord,
v_coord=v_coord,
)
self.follicle = follicle_transform
#
# Add calibration-related attribute
#
# The values will be computed when attach_ctrl will be called
libAttr.addAttr_separator(
self.grp_rig,
"ctrlCalibration"
)
self.attr_sensitivity_tx = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TX,
defaultValue=1.0
)
self.attr_sensitivity_ty = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TY,
defaultValue=1.0
)
self.attr_sensitivity_tz = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TZ,
defaultValue=1.0
)
self.attr_sensitivity_tx.set(channelBox=True)
self.attr_sensitivity_ty.set(channelBox=True)
self.attr_sensitivity_tz.set(channelBox=True)
# Hack: Since there's scaling on the ctrl so the left and right side ctrl channels matches, we need to flip the ctrl shapes.
if flip_lr:
self.ctrl.scaleX.set(-1)
libPymel.makeIdentity_safe(self.ctrl, rotate=True, scale=True, apply=True)
grp_output = pymel.createNode(
'transform',
name=nomenclature_rig.resolve('output'),
parent=self.grp_rig
)
attr_output_tm = libRigging.create_utility_node(
'multMatrix',
matrixIn=(
self._grp_bind_ctrl.matrix,
self._attr_inn_parent_tm,
self.rig.grp_anm.worldInverseMatrix
)
).matrixSum
libRigging.connect_matrix_to_node(attr_output_tm, grp_output)
# Create inverted attributes for sensibility
util_sensitivity_inv = libRigging.create_utility_node(
'multiplyDivide', operation=2,
input1X=1.0, input1Y=1.0, input1Z=1.0,
input2X=self.attr_sensitivity_tx,
input2Y=self.attr_sensitivity_ty,
input2Z=self.attr_sensitivity_tz
)
attr_sensibility_lr_inv = util_sensitivity_inv.outputX
attr_sensibility_ud_inv = util_sensitivity_inv.outputY
attr_sensibility_fb_inv = util_sensitivity_inv.outputZ
attr_ctrl_offset_sx_inn = self.attr_sensitivity_tx
attr_ctrl_offset_sy_inn = self.attr_sensitivity_ty
attr_ctrl_offset_sz_inn = self.attr_sensitivity_tz
# Connect any additionel scale source.
if parent_scl:
u = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getAbsoluteCtrlOffsetScale'),
input1X=attr_ctrl_offset_sx_inn,
input1Y=attr_ctrl_offset_sy_inn,
input1Z=attr_ctrl_offset_sz_inn,
input2X=parent_scl.scaleX,
input2Y=parent_scl.scaleY,
input2Z=parent_scl.scaleZ
)
attr_ctrl_offset_sx_inn, attr_ctrl_offset_sy_inn, attr_ctrl_offset_sz_inn = u.outputX, u.outputY, u.outputZ
# Ensure the scaling of the parent is taken in account.
attr_calibration_scale_tm = libRigging.create_utility_node(
'composeMatrix',
name=nomenclature_rig.resolve('composeCalibrationScaleTm'),
inputScaleX=attr_ctrl_offset_sx_inn,
inputScaleY=attr_ctrl_offset_sy_inn,
inputScaleZ=attr_ctrl_offset_sz_inn,
).outputMatrix
attr_ctrl_offset_scale_tm = libRigging.create_utility_node(
'multMatrix',
name=nomenclature_rig.resolve('getCtrlOffsetScaleTm'),
matrixIn=(
attr_calibration_scale_tm,
self._attr_inn_parent_tm,
self.rig.grp_anm.worldInverseMatrix,
)
).matrixSum
attr_ctrl_offset_scale = libRigging.create_utility_node(
'decomposeMatrix',
inputMatrix=attr_ctrl_offset_scale_tm
).outputScale
# Flip the x axis if we are on the right side of the face.
# We need to do it as the last step since this will result in a right-handed matrix
# which will be canceled out if we feed it into multMatrix or other maya nodes.
if flip_lr:
attr_ctrl_offset_scale = libRigging.create_utility_node(
'multiplyDivide',
input1=attr_ctrl_offset_scale,
input2X=-1.0,
input2Y=1.0,
input2Z=1.0,
).output
pymel.connectAttr(attr_ctrl_offset_scale, self.ctrl.offset.scale)
# Apply sensibility on the ctrl shape
ctrl_shape = self.ctrl.node.getShape()
tmp = pymel.duplicate(self.ctrl.node.getShape())[0]
ctrl_shape_orig = tmp.getShape()
ctrl_shape_orig.setParent(self.ctrl.node, relative=True, shape=True)
ctrl_shape_orig.rename('{0}Orig'.format(ctrl_shape.name()))
pymel.delete(tmp)
ctrl_shape_orig.intermediateObject.set(True)
for cp in ctrl_shape.cp:
cp.set(0, 0, 0)
# Counter-scale the shape
attr_adjustement_sx_inn = attr_sensibility_lr_inv
attr_adjustement_sy_inn = attr_sensibility_ud_inv
attr_adjustement_sz_inn = attr_sensibility_fb_inv
attr_adjustement_scale = libRigging.create_utility_node(
'composeMatrix',
inputScaleX=attr_adjustement_sx_inn,
inputScaleY=attr_adjustement_sy_inn,
inputScaleZ=attr_adjustement_sz_inn
).outputMatrix
attr_adjustement_rot = libRigging.create_utility_node(
'composeMatrix',
inputRotateX=self.ctrl.node.rotateX,
inputRotateY=self.ctrl.node.rotateY,
inputRotateZ=self.ctrl.node.rotateZ
).outputMatrix
attr_adjustement_rot_inv = libRigging.create_utility_node(
'inverseMatrix',
inputMatrix=attr_adjustement_rot
).outputMatrix
attr_adjustement_tm = libRigging.create_utility_node(
'multMatrix', matrixIn=[
attr_adjustement_rot,
attr_adjustement_scale,
attr_adjustement_rot_inv
]
).matrixSum
attr_transform_geometry = libRigging.create_utility_node(
'transformGeometry',
transform=attr_adjustement_tm,
inputGeometry=ctrl_shape_orig.local
).outputGeometry
pymel.connectAttr(attr_transform_geometry, ctrl_shape.create, force=True)
pymel.connectAttr(grp_output.translate, self.ctrl.offset.translate)
pymel.connectAttr(grp_output.rotate, self.ctrl.offset.rotate)
if constraint and self.jnt:
pymel.parentConstraint(self.ctrl.node, self.jnt, maintainOffset=True)
def build_stack(self, stack, **kwargs):
nomenclature_rig = self.get_nomenclature_rig()
jnt_head = self.rig.get_head_jnt()
jnt_jaw = self.rig.get_jaw_jnt()
#
# Create additional attributes to control the jaw layer
#
libAttr.addAttr_separator(self.grp_rig, 'jawLayer')
self._attr_inn_jaw_ratio_default = libAttr.addAttr(
self.grp_rig,
'jawRatioDefault',
defaultValue=0.5,
hasMinValue=True,
hasMaxValue=True,
minValue=0,
maxValue=1,
k=True
)
self._attr_bypass_splitter = libAttr.addAttr(
self.grp_rig,
'jawSplitterBypass',
defaultValue=0.0,
hasMinValue=True,
hasMaxValue=True,
minValue=0,
maxValue=1,
k=True
)
#
# Create reference objects used for calculations.
#
# Create a reference node that follow the head
self._target_head = pymel.createNode(
'transform',
name=nomenclature_rig.resolve('innHead'),
parent=self.grp_rig
)
self._target_head.setTranslation(jnt_head.getTranslation(space='world'))
pymel.parentConstraint(jnt_head, self._target_head, maintainOffset=True)
pymel.scaleConstraint(jnt_head, self._target_head, maintainOffset=True)
# Create a reference node that follow the jaw initial position
jaw_pos = jnt_jaw.getTranslation(space='world')
self._target_jaw_bindpose = pymel.createNode(
'transform',
name=nomenclature_rig.resolve('innJawBindPose'),
parent=self.grp_rig
)
self._target_jaw_bindpose.setTranslation(jaw_pos)
# Create a reference node that follow the jaw
self._target_jaw = pymel.createNode(
'transform',
name=nomenclature_rig.resolve('innJaw'),
parent=self._target_jaw_bindpose
)
self._target_jaw.t.set(0,0,0)
pymel.parentConstraint(jnt_jaw, self._target_jaw, maintainOffset=True)
pymel.scaleConstraint(jnt_jaw, self._target_jaw, maintainOffset=True)
# Create a node that contain the out jaw influence.
# Note that the out jaw influence can be modified by the splitter node.
grp_parent_pos = self._grp_parent.getTranslation(space='world') # grp_offset is always in world coordinates
self._jaw_ref = pymel.createNode(
'transform',
name=nomenclature_rig.resolve('outJawInfluence'),
parent=self.grp_rig
)
self._jaw_ref.t.set(grp_parent_pos)
pymel.parentConstraint(self._target_jaw, self._jaw_ref, maintainOffset=True)
# Extract jaw influence
attr_delta_tm = libRigging.create_utility_node('multMatrix', matrixIn=[
self._jaw_ref.worldMatrix,
self._grp_parent.worldInverseMatrix
]).matrixSum
util_extract_jaw = libRigging.create_utility_node(
'decomposeMatrix',
name=nomenclature_rig.resolve('getJawRotation'),
inputMatrix=attr_delta_tm
)
super(FaceLipsAvar, self).build_stack(stack, **kwargs)
#
# Create jaw influence layer
# Create a reference object to extract the jaw displacement.
#
# Add the jaw influence as a new stack layer.
layer_jaw_r = stack.prepend_layer(name='jawRotate')
layer_jaw_t = stack.prepend_layer(name='jawTranslate')
pymel.connectAttr(util_extract_jaw.outputTranslate, layer_jaw_t.t)
pymel.connectAttr(util_extract_jaw.outputRotate, layer_jaw_r.r)
def build(self, parent, ref, ref_tm=None, grp_rig=None, obj_mesh=None, **kwargs):
# todo: Simplify the setup, too many nodes
# Resolve geometry to attach to
if obj_mesh is None:
obj_mesh = parent.get_farest_affected_mesh(ref)
if obj_mesh is None:
raise Exception("Can't find mesh affected by {0}. Skipping doritos ctrl setup.")
super(InteractiveCtrl, self).build(parent, **kwargs)
#nomenclature_anm = self.get_nomenclature_anm(parent)
nomenclature_rig = parent.nomenclature(suffix=parent.nomenclature.type_rig)
#nomenclature_rig = self.get_nomenclature_rig(parent)
# TODO: Only use position instead of PyNode or Matrix?
if ref_tm is None:
ref_tm = ref.getMatrix(worldSpace=True)
need_flip = ref_tm.translate.x < 0
# Initialize external stack
# Normally this would be hidden from animators.
stack_name = nomenclature_rig.resolve('doritosStack')
stack = classNode.Node(self)
stack.build(name=stack_name)
stack.setMatrix(ref_tm )
# Add sensibility attributes
# The values will be computed when attach_ctrl will be called
self.attr_sensitivity_tx = libAttr.addAttr(stack, longName=self._ATTR_NAME_SENSITIVITY_TX,
defaultValue=1.0)
self.attr_sensitivity_ty = libAttr.addAttr(stack, longName=self._ATTR_NAME_SENSITIVITY_TY,
defaultValue=1.0)
self.attr_sensitivity_tz = libAttr.addAttr(stack, longName=self._ATTR_NAME_SENSITIVITY_TZ,
defaultValue=1.0)
log.info('Creating doritos setup from {0} to {1}'.format(self.jnt, obj_mesh))
# Resolve the doritos location
'''
if ctrl_tm is None:
ctrl_tm = self.jnt.getMatrix(worldSpace=True)
'''
# Find the closest point on the surface.
pos_ref = ref_tm.translate
# Note that to only check in the Z axis, we'll do a raycast first.
# If we success this will become our reference position.
'''
pos = pos_ref
pos.z = 999
dir = pymel.datatypes.Point(0,0,-1)
result = next(iter(libRigging.ray_cast(pos, dir, [obj_mesh])), None)
if result:
pos_ref = result
ctrl_tm.translate = result
'''
# Create the layer_fol that will follow the geometry
layer_fol_name = nomenclature_rig.resolve('doritosFol')
layer_fol = stack.add_layer()
layer_fol.rename(layer_fol_name)
#layer_fol.setParent(self.grp_rig)
fol_pos, fol_u, fol_v = libRigging.get_closest_point_on_mesh(obj_mesh, pos_ref)
# TODO: Validate that we don't need to inverse the rotation separately.
fol_name = nomenclature_rig.resolve('doritosFollicle')
fol_shape = libRigging.create_follicle2(obj_mesh, u=fol_u, v=fol_v)
fol = fol_shape.getParent()
fol.rename(fol_name)
pymel.parentConstraint(fol, layer_fol, maintainOffset=True)
fol = fol_shape.getParent()
fol.setParent(self.grp_rig)
# HACK: Fix rotation issues.
# The doritos setup can be hard to control when the rotation of the controller depend on the layer_fol since
# any deformation can affect the normal of the faces.
jnt_head = parent.get_head_jnt()
if jnt_head:
pymel.disconnectAttr(layer_fol.rx)
pymel.disconnectAttr(layer_fol.ry)
pymel.disconnectAttr(layer_fol.rz)
pymel.orientConstraint(jnt_head, layer_fol, maintainOffset=True)
#
# Constraint a specic controller to the avar doritos stack.
# Call this method after connecting the ctrl to the necessary avars.
# The sensibility of the doritos will be automatically computed in this step if necessary.
#
# Create inverted attributes for sensibility
util_sensitivity_inv = libRigging.create_utility_node('multiplyDivide', operation=2,
input1X=1.0, input1Y=1.0, input1Z=1.0,
input2X=self.attr_sensitivity_tx,
input2Y=self.attr_sensitivity_ty,
input2Z=self.attr_sensitivity_tz
)
attr_sensibility_lr_inv = util_sensitivity_inv.outputX
attr_sensibility_ud_inv = util_sensitivity_inv.outputY
attr_sensibility_fb_inv = util_sensitivity_inv.outputZ
# Add an inverse node that will counter animate the position of the ctrl.
# TODO: Rename
layer_doritos_name = nomenclature_rig.resolve('doritosInv')
layer_doritos = pymel.createNode('transform', name=layer_doritos_name)
layer_doritos.setParent(stack.node)
# Create inverse attributes for the ctrl
attr_ctrl_inv_t = libRigging.create_utility_node('multiplyDivide', input1=self.node.t, input2=[-1, -1, -1]).output
attr_ctrl_inv_r = libRigging.create_utility_node('multiplyDivide', input1=self.node.r, input2=[-1, -1, -1]).output
attr_ctrl_inv_t = libRigging.create_utility_node('multiplyDivide',
input1=attr_ctrl_inv_t,
input2X=self.attr_sensitivity_tx,
input2Y=self.attr_sensitivity_ty,
input2Z=self.attr_sensitivity_tz
).output
if need_flip:
attr_doritos_tx = libRigging.create_utility_node('multiplyDivide',
input1X=attr_ctrl_inv_t.outputX,
input2X=-1
).outputX
else:
attr_doritos_tx = attr_ctrl_inv_t.outputX
attr_doritos_ty = attr_ctrl_inv_t.outputY
attr_doritos_tz = attr_ctrl_inv_t.outputZ
pymel.connectAttr(attr_doritos_tx, layer_doritos.tx)
pymel.connectAttr(attr_doritos_ty, layer_doritos.ty)
pymel.connectAttr(attr_doritos_tz, layer_doritos.tz)
pymel.connectAttr(attr_ctrl_inv_r, layer_doritos.r)
# Apply scaling on the ctrl parent.
# This is were the 'black magic' happen.
if need_flip:
attr_ctrl_offset_sx_inn = libRigging.create_utility_node('multiplyDivide',
input1X=self.attr_sensitivity_tx,
input2X=-1
).outputX
else:
attr_ctrl_offset_sx_inn = self.attr_sensitivity_tx
attr_ctrl_offset_sy_inn = self.attr_sensitivity_ty
attr_ctrl_offset_sz_inn = self.attr_sensitivity_tz
pymel.connectAttr(attr_ctrl_offset_sx_inn, self.offset.scaleX)
pymel.connectAttr(attr_ctrl_offset_sy_inn, self.offset.scaleY)
pymel.connectAttr(attr_ctrl_offset_sz_inn, self.offset.scaleZ)
# Apply sensibility on the ctrl shape
ctrl_shape = self.node.getShape()
tmp = pymel.duplicate(self.node.getShape())[0]
ctrl_shape_orig = tmp.getShape()
ctrl_shape_orig.setParent(self.node, relative=True, shape=True)
ctrl_shape_orig.rename('{0}Orig'.format(ctrl_shape.name()))
pymel.delete(tmp)
ctrl_shape_orig.intermediateObject.set(True)
for cp in ctrl_shape.cp:
cp.set(0,0,0)
# Counter-scale the shape
'''
if need_flip:
attr_adjustement_sx_inn = libRigging.create_utility_node('multiplyDivide', input1X=attr_sensibility_lr_inv, input2X=-1).outputX
else:
attr_adjustement_sx_inn = attr_sensibility_lr_inv
'''
attr_adjustement_sx_inn = attr_sensibility_lr_inv
attr_adjustement_sy_inn = attr_sensibility_ud_inv
attr_adjustement_sz_inn = attr_sensibility_fb_inv
attr_adjustement_scale = libRigging.create_utility_node('composeMatrix',
inputScaleX=attr_adjustement_sx_inn,
inputScaleY=attr_adjustement_sy_inn,
inputScaleZ=attr_adjustement_sz_inn
).outputMatrix
attr_adjustement_rot = libRigging.create_utility_node('composeMatrix',
inputRotateX=self.node.rotateX,
inputRotateY=self.node.rotateY,
inputRotateZ=self.node.rotateZ
).outputMatrix
attr_adjustement_rot_inv = libRigging.create_utility_node('inverseMatrix', inputMatrix=attr_adjustement_rot).outputMatrix
attr_adjustement_tm = libRigging.create_utility_node('multMatrix', matrixIn=[
attr_adjustement_rot,
attr_adjustement_scale,
attr_adjustement_rot_inv
]).matrixSum
attr_transform_geometry = libRigging.create_utility_node('transformGeometry', transform=attr_adjustement_tm,
inputGeometry=ctrl_shape_orig.local).outputGeometry
pymel.connectAttr(attr_transform_geometry, ctrl_shape.create, force=True)
# Constraint ctrl
pymel.parentConstraint(layer_doritos, self.offset, maintainOffset=False, skipRotate=['x', 'y', 'z'])
pymel.orientConstraint(layer_doritos.getParent(), self.offset, maintainOffset=True)
# Clean dag junk
if grp_rig:
stack.setParent(grp_rig)
fol.setParent(grp_rig)
def build(self,
module,
ref,
ref_tm=None,
grp_rig=None,
obj_mesh=None,
u_coord=None,
v_coord=None,
flip_lr=False,
follow_mesh=True,
**kwargs):
"""
Create an Interactive controller that follow a geometry.
:param module: ???
:param ref:
:param ref_tm:
:param grp_rig:
:param obj_mesh:
:param u_coord:
:param v_coord:
:param kwargs:
:return:
"""
# HACK: Ensure flipped shapes are correctly restaured...
# This is necessary since when holded, the scale of the ctrl is set to identity.
# However ctrl from the right side have an inverted scale on the x axis. -_-
if flip_lr and libPymel.is_valid_PyNode(self.shapes):
self.shapes.sx.set(-1)
pymel.makeIdentity(self.shapes,
rotate=True,
scale=True,
apply=True)
# todo: Simplify the setup, too many nodes
super(InteractiveCtrl, self).build(**kwargs)
#nomenclature_anm = self.get_nomenclature_anm(parent)
nomenclature_rig = module.rig.nomenclature(
suffix=module.rig.nomenclature.type_rig)
#nomenclature_rig = self.get_nomenclature_rig(parent)
# TODO: Only use position instead of PyNode or Matrix?
if ref_tm is None:
ref_tm = ref.getMatrix(worldSpace=True)
pos_ref = ref_tm.translate
# Resolve u and v coordinates
# todo: check if we really want to resolve the u and v ourself since it's now connected.
if obj_mesh is None:
# We'll scan all available geometries and use the one with the shortest distance.
meshes = libRigging.get_affected_geometries(ref)
meshes = list(set(meshes) & set(module.rig.get_meshes()))
obj_mesh, _, out_u, out_v = libRigging.get_closest_point_on_shapes(
meshes, pos_ref)
else:
_, out_u, out_v = libRigging.get_closest_point_on_shape(
obj_mesh, pos_ref)
if u_coord is None:
u_coord = out_u
if v_coord is None:
v_coord = out_v
if obj_mesh is None:
raise Exception(
"Can't find mesh affected by {0}. Skipping doritos ctrl setup."
)
if self.jnt:
module.debug(
'Creating doritos on {0} using {1} as reference'.format(
obj_mesh, self.jnt))
else:
module.debug('Creating doritos on {0}'.format(obj_mesh))
# Initialize external stack
# Normally this would be hidden from animators.
stack_name = nomenclature_rig.resolve('doritosStack')
stack = classNode.Node(self)
stack.build(name=stack_name)
stack.setTranslation(pos_ref)
# Add sensibility attributes
# The values will be computed when attach_ctrl will be called
libAttr.addAttr_separator(module.grp_rig, "ctrlCalibration")
self.attr_sensitivity_tx = libAttr.addAttr(
module.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TX,
defaultValue=1.0)
self.attr_sensitivity_ty = libAttr.addAttr(
module.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TY,
defaultValue=1.0)
self.attr_sensitivity_tz = libAttr.addAttr(
module.grp_rig,
longName=self._ATTR_NAME_SENSITIVITY_TZ,
defaultValue=1.0)
self.attr_sensitivity_tx.set(channelBox=True)
self.attr_sensitivity_ty.set(channelBox=True)
self.attr_sensitivity_tz.set(channelBox=True)
# Note that to only check in the Z axis, we'll do a raycast first.
# If we success this will become our reference position.
'''
pos = pos_ref
pos.z = 999
dir = pymel.datatypes.Point(0,0,-1)
result = next(iter(libRigging.ray_cast(pos, dir, [obj_mesh])), None)
if result:
pos_ref = result
ctrl_tm.translate = result
'''
# Create the layer_fol that will follow the geometry
layer_fol_name = nomenclature_rig.resolve('doritosFol')
layer_fol = stack.append_layer()
layer_fol.rename(layer_fol_name)
#layer_fol.setParent(self.grp_rig)
# TODO: Validate that we don't need to inverse the rotation separately.
fol_mesh = None
if follow_mesh:
fol_name = nomenclature_rig.resolve('doritosFollicle')
fol_shape = libRigging.create_follicle2(obj_mesh,
u=u_coord,
v=v_coord)
fol_mesh = fol_shape.getParent()
self.follicle = fol_mesh
fol_mesh.rename(fol_name)
pymel.parentConstraint(fol_mesh, layer_fol, maintainOffset=True)
fol_mesh.setParent(self.grp_rig)
# HACK: Fix rotation issues.
# The doritos setup can be hard to control when the rotation of the controller depend on the layer_fol since
# any deformation can affect the normal of the faces.
jnt_head = module.rig.get_head_jnt()
if jnt_head:
pymel.disconnectAttr(layer_fol.rx)
pymel.disconnectAttr(layer_fol.ry)
pymel.disconnectAttr(layer_fol.rz)
pymel.orientConstraint(jnt_head,
layer_fol,
maintainOffset=True)
else:
self.follicle = layer_fol
pymel.parentConstraint(ref, layer_fol, maintainOffset=True)
#
# Constraint a specic controller to the avar doritos stack.
# Call this method after connecting the ctrl to the necessary avars.
# The sensibility of the doritos will be automatically computed in this step if necessary.
#
# Create inverted attributes for sensibility
util_sensitivity_inv = libRigging.create_utility_node(
'multiplyDivide',
operation=2,
input1X=1.0,
input1Y=1.0,
input1Z=1.0,
input2X=self.attr_sensitivity_tx,
input2Y=self.attr_sensitivity_ty,
input2Z=self.attr_sensitivity_tz)
attr_sensibility_lr_inv = util_sensitivity_inv.outputX
attr_sensibility_ud_inv = util_sensitivity_inv.outputY
attr_sensibility_fb_inv = util_sensitivity_inv.outputZ
# Add an inverse node that will counter animate the position of the ctrl.
# TODO: Rename
layer_doritos_name = nomenclature_rig.resolve('doritosInv')
layer_doritos = pymel.createNode('transform', name=layer_doritos_name)
layer_doritos.setParent(stack.node)
# Create inverse attributes for the ctrl
attr_ctrl_inv_t = libRigging.create_utility_node('multiplyDivide',
input1=self.node.t,
input2=[-1, -1,
-1]).output
attr_ctrl_inv_r = libRigging.create_utility_node('multiplyDivide',
input1=self.node.r,
input2=[-1, -1,
-1]).output
attr_ctrl_inv_t = libRigging.create_utility_node(
'multiplyDivide',
input1=attr_ctrl_inv_t,
input2X=self.attr_sensitivity_tx,
input2Y=self.attr_sensitivity_ty,
input2Z=self.attr_sensitivity_tz).output
if flip_lr:
attr_doritos_tx = libRigging.create_utility_node(
'multiplyDivide', input1X=attr_ctrl_inv_t.outputX,
input2X=-1).outputX
else:
attr_doritos_tx = attr_ctrl_inv_t.outputX
attr_doritos_ty = attr_ctrl_inv_t.outputY
attr_doritos_tz = attr_ctrl_inv_t.outputZ
pymel.connectAttr(attr_doritos_tx, layer_doritos.tx)
pymel.connectAttr(attr_doritos_ty, layer_doritos.ty)
pymel.connectAttr(attr_doritos_tz, layer_doritos.tz)
pymel.connectAttr(attr_ctrl_inv_r, layer_doritos.r)
# Apply scaling on the ctrl parent.
# This is were the 'black magic' happen.
if flip_lr:
attr_ctrl_offset_sx_inn = libRigging.create_utility_node(
'multiplyDivide', input1X=self.attr_sensitivity_tx,
input2X=-1).outputX
else:
attr_ctrl_offset_sx_inn = self.attr_sensitivity_tx
attr_ctrl_offset_sy_inn = self.attr_sensitivity_ty
attr_ctrl_offset_sz_inn = self.attr_sensitivity_tz
pymel.connectAttr(attr_ctrl_offset_sx_inn, self.offset.scaleX)
pymel.connectAttr(attr_ctrl_offset_sy_inn, self.offset.scaleY)
pymel.connectAttr(attr_ctrl_offset_sz_inn, self.offset.scaleZ)
# Apply sensibility on the ctrl shape
ctrl_shape = self.node.getShape()
tmp = pymel.duplicate(self.node.getShape())[0]
ctrl_shape_orig = tmp.getShape()
ctrl_shape_orig.setParent(self.node, relative=True, shape=True)
ctrl_shape_orig.rename('{0}Orig'.format(ctrl_shape.name()))
pymel.delete(tmp)
ctrl_shape_orig.intermediateObject.set(True)
for cp in ctrl_shape.cp:
cp.set(0, 0, 0)
# Counter-scale the shape
attr_adjustement_sx_inn = attr_sensibility_lr_inv
attr_adjustement_sy_inn = attr_sensibility_ud_inv
attr_adjustement_sz_inn = attr_sensibility_fb_inv
attr_adjustement_scale = libRigging.create_utility_node(
'composeMatrix',
inputScaleX=attr_adjustement_sx_inn,
inputScaleY=attr_adjustement_sy_inn,
inputScaleZ=attr_adjustement_sz_inn).outputMatrix
attr_adjustement_rot = libRigging.create_utility_node(
'composeMatrix',
inputRotateX=self.node.rotateX,
inputRotateY=self.node.rotateY,
inputRotateZ=self.node.rotateZ).outputMatrix
attr_adjustement_rot_inv = libRigging.create_utility_node(
'inverseMatrix', inputMatrix=attr_adjustement_rot).outputMatrix
attr_adjustement_tm = libRigging.create_utility_node(
'multMatrix',
matrixIn=[
attr_adjustement_rot, attr_adjustement_scale,
attr_adjustement_rot_inv
]).matrixSum
attr_transform_geometry = libRigging.create_utility_node(
'transformGeometry',
transform=attr_adjustement_tm,
inputGeometry=ctrl_shape_orig.local).outputGeometry
pymel.connectAttr(attr_transform_geometry,
ctrl_shape.create,
force=True)
# Constraint ctrl
pymel.parentConstraint(layer_doritos,
self.offset,
maintainOffset=False,
skipRotate=['x', 'y', 'z'])
pymel.orientConstraint(layer_doritos.getParent(),
self.offset,
maintainOffset=True)
# Clean dag junk
if grp_rig:
stack.setParent(grp_rig)
if fol_mesh:
fol_mesh.setParent(grp_rig)
def create_spaceswitch(self,
module,
parent,
add_default=True,
default_name=None,
add_world=False,
**kwargs):
"""
Create the space switch attribute on the controller using a list of target found from it's module hierarchy
:param module: The module on which we want to process space switch targets
:param parent: The parent used as the default (local) target
:param add_default: Is the default target will be added to the list of targets
:param default_name: The name of the default target
:param add_world: Is the world will be added as a target
:param kwargs: Additional parameters
:return: None
"""
# TODO: Handle when parent is None?
nomenclature = module.rig.nomenclature
# Resolve spaceswitch targets
targets, labels, indexes = self.get_spaceswitch_targets(
module, parent, add_world=add_world, add_local=add_default)
if not targets:
module.warning(
"Can't add space switch on {0}. No targets found!".format(
self.node.__melobject__()))
return
if default_name is None:
default_name = 'Local'
# Resolve the niceName of the targets
for i in range(len(targets)):
target = targets[i]
label = labels[i]
if label is None and target is not None:
name = nomenclature(target.name())
name.remove_extra_tokens()
labels[i] = name.resolve()
# Create the parent constraint before adding the local since local target will be set to itself
# to keep a serialized link to the local target
layer_space_switch = self.append_layer('spaceSwitch')
parent_constraint = pymel.parentConstraint(targets,
layer_space_switch,
maintainOffset=True,
**kwargs)
# Build the enum string from the information we got
enum_string = ""
# Add the local option if needed
if add_default:
# We cannot self referencing since it will break maya deletion mechanism
# targets.append(self)
# indexes.append(default_index)
# labels.append(default_name)
enum_string += default_name + "=" + \
str(self.local_index)
# The enum string will skip index if needed
for label, index in zip(labels, indexes):
if enum_string:
enum_string += ":"
enum_string += label + "=" + str(index)
# Update the serialized variable to make sure everything is up to date
for i, target in enumerate(targets):
if target not in self.targets:
self.targets.append(target)
if indexes[i] in self.targets_indexes:
log.warning(
"Index ({0}) is already used for space switch on ctrl {1}. "
"Strange behavior could happen".format(
indexes[i], self.name()))
self.targets_indexes.append(indexes[i])
attr_space = libAttr.addAttr(self.node,
'space',
at='enum',
enumName=enum_string,
k=True)
atts_weights = parent_constraint.getWeightAliasList()
for i, att_weight in enumerate(atts_weights):
index_to_match = indexes[i]
att_enabled = libRigging.create_utility_node( #Equal
'condition',
firstTerm=attr_space,
secondTerm=index_to_match,
colorIfTrueR=1,
colorIfFalseR=0).outColorR
pymel.connectAttr(att_enabled, att_weight)
# By Default, the active space will be local, else root and finally fallback on the first index found
if add_default:
self.node.space.set(default_name)
elif self._reserved_idx['root'] in self.targets_indexes:
self.node.space.set(self._reserved_idx['root'])
else:
if self.targets_indexes:
self.node.space.set(self.targets_indexes[0])
def create_interface(self):
"""
Define the input and output of the module.
The goal is to a a kind of component approach.
"""
self._attr_inn_parent_tm = libAttr.addAttr(self.grp_rig, longName='innParentTm', dt='matrix')
def create_spaceswitch(self, module, parent, add_local=True, local_label=None, local_target=None, add_world=False,
**kwargs):
"""
Create the space switch attribute on the controller using a list of target found from it's module hierarchy.
:param module: The module on which we want to process space switch targets
:param parent: The parent used as the default (local) target
:param add_local: If True, a 'local' target will be used. Local is generally the absence of any constraint and always have the same index.
:param local_label: The name of the 'local' target
:param local_target: The objects to use as the local target. This is only used to cheat (see the FaceEyes module).
:param add_world: Is the world will be added as a target
:param kwargs: Additional parameters
:return: None
"""
# TODO: Handle when parent is None?
nomenclature = module.rig.nomenclature
# Basically we resolve 3 list:
# - targets: Contain the space switch targets.
# - labels: Contain the visible text for each targets
# - indexes: Contain the stored logical index for each targets. Note that some indexes are reserved.
targets, labels, indexes = self.get_spaceswitch_targets(module, parent,
add_world=add_world, add_local=add_local)
if not targets:
module.warning("Can't add space switch on {0}. No targets found!".format(self.node.__melobject__()))
return
if local_label is None:
local_label = 'Local'
# Resolve the niceName of the targets
for i in range(len(targets)):
target = targets[i]
label = labels[i]
if label is None and target is not None:
name = nomenclature(target.name())
name.remove_extra_tokens()
labels[i] = name.resolve()
# Build the enum string from the information we got
enum_string = ""
# Add the local option if needed
if add_local:
# We cannot self referencing since it will break maya deletion mechanism
# targets.append(self)
# indexes.append(default_index)
# labels.append(default_name)
# In some case the user might have provided what we should use as the local target.
# This is used to cheat, for exemple the FaceEye module ctrl are parented to the world,
# however it make sense that their 'local' space is still the head.
if local_target:
# If the local_target exist in the list, we'll want to remove it.
if local_target in targets:
index = targets.index(local_target)
targets.pop(index)
labels.pop(index)
indexes.pop(index)
targets.append(local_target)
indexes.append(constants.SpaceSwitchReservedIndex.local)
labels.append(local_label)
else:
enum_string += local_label + "=" + \
str(self.local_index)
# The enum string will skip index if needed
for label, index in zip(labels, indexes):
if enum_string:
enum_string += ":"
enum_string += label + "=" + str(index)
# Update the serialized variable to make sure everything is up to date
for i, target in enumerate(targets):
if target not in self.targets:
self.targets.append(target)
if indexes[i] in self.targets_indexes:
log.warning("Index ({0}) is already used for space switch on ctrl {1}. "
"Strange behavior could happen".format(indexes[i], self.name()))
self.targets_indexes.append(indexes[i])
# Create the parent constraint before adding the local since local target will be set to itself
# to keep a serialized link to the local target
layer_space_switch = self.append_layer('spaceSwitch')
parent_constraint = pymel.parentConstraint(targets, layer_space_switch, maintainOffset=True, **kwargs)
attr_space = libAttr.addAttr(self.node, 'space', at='enum', enumName=enum_string, k=True)
atts_weights = parent_constraint.getWeightAliasList()
for i, att_weight in enumerate(atts_weights):
index_to_match = indexes[i]
att_enabled = libRigging.create_utility_node( # Equal
'condition',
firstTerm=attr_space,
secondTerm=index_to_match,
colorIfTrueR=1,
colorIfFalseR=0
).outColorR
pymel.connectAttr(att_enabled, att_weight)
# By Default, the active space will be local, else root and finally fallback on the first index found
if add_local:
self.node.space.set(local_label)
elif constants.SpaceSwitchReservedIndex.root in self.targets_indexes:
self.node.space.set(constants.SpaceSwitchReservedIndex.root)
else:
if self.targets_indexes:
self.node.space.set(self.targets_indexes[0])
# Sometimes Maya will be drunk and set a bad 'restRotate'.
# We'll want to ensure ourself that there's no rest offset. (see Task #70729)
parent_constraint.restTranslateX.set(0)
parent_constraint.restTranslateY.set(0)
parent_constraint.restTranslateZ.set(0)
parent_constraint.restRotateX.set(0)
parent_constraint.restRotateY.set(0)
parent_constraint.restRotateZ.set(0)
def build(self,
constraint=True,
constraint_handle=True,
setup_softik=True,
**kwargs):
"""
:param constraint: Bool to tell if we will constraint the chain bone on the ikchain
:param constraint_handle: Bool to tell if we will contraint the handle on the ik ctrl
:param setup_softik: Bool to tell if we setup the soft ik system
:param kwargs: More kwargs passed to the superclass
:return: Nothing
"""
# Build the softik node after the setup for the quadruped
super(LegIkQuad, self).build(constraint=False,
constraint_handle=False,
setup_softik=False,
**kwargs)
nomenclature_rig = self.get_nomenclature_rig()
quad_swivel_pos = self.calc_swivel_pos(start_index=1, end_index=3)
heel_idx = self.iCtrlIndex - 1
# Create a second ik chain for the quadruped setup
self._chain_quad_ik = self.chain.duplicate()
for i, oIk in enumerate(self._chain_quad_ik):
oIk.rename(nomenclature_rig.resolve('QuadChain{0:02}'.format(i)))
# Constraint the bones after the iCtrlIdx to the first ik chain to make the foot roll work correctly
if i > self.iCtrlIndex:
pymel.parentConstraint(self._chain_ik[i],
self._chain_quad_ik[i])
self._chain_quad_ik[0].setParent(self._chain_ik[0])
obj_e = self._chain_quad_ik[self.iCtrlIndex]
# We need a second ik solver for the quad chain
ik_solver_quad_name = nomenclature_rig.resolve('quadIkHandle')
ik_effector_quad_name = nomenclature_rig.resolve('quadIkEffector')
self._ik_handle_quad, _ik_effector = pymel.ikHandle(
startJoint=self._chain_quad_ik[1],
endEffector=obj_e,
solver='ikRPsolver')
self._ik_handle_quad.rename(ik_solver_quad_name)
_ik_effector.rename(ik_effector_quad_name)
self._ik_handle_quad.setParent(self._ik_handle)
#
# Create softIk node and connect user accessible attributes to it.
#
if setup_softik:
self.setup_softik([self._ik_handle, self._ik_handle_quad],
self._chain_quad_ik)
# Create another swivel handle node for the quad chain setup
self.ctrl_swivel_quad = self.setup_swivel_ctrl(
self.ctrl_swivel_quad,
self._chain_quad_ik[heel_idx],
quad_swivel_pos,
self._ik_handle_quad,
name='swivelQuad',
mirror_setup=False)
self.quad_swivel_distance = self.chain_length # Used in ik/fk switch
# Set by default the space to calf
if self.ctrl_swivel_quad.space:
enum = self.ctrl_swivel_quad.space.getEnums()
calf_idx = enum.get('Calf', None)
if calf_idx:
self.ctrl_swivel_quad.space.set(calf_idx)
attr_holder = self.ctrl_ik
libAttr.addAttr_separator(attr_holder,
'Quadruped',
niceName='Quadruped')
attr_pitch = libAttr.addAttr(attr_holder, longName='pitch', k=True)
pymel.connectAttr(attr_pitch, self._chain_quad_ik[0].rotateZ)
pymel.orientConstraint(self.ctrl_ik, obj_e, maintainOffset=True)
if constraint:
for source, target in zip(self._chain_quad_ik, self.chain):
pymel.parentConstraint(source, target)
def build(self,
calibrate=True,
use_football_interpolation=False,
**kwargs):
"""
:param calibrate:
:param use_football_interpolation: If True, the resolved influence of the jaw on
each lips avar will give a 'football' shape. It is False by default since we take
in consideration that the weightmaps follow the 'Art of Moving Points' theory and
already result in a football shape if they are uniformly translated.
:param kwargs:
:return:
"""
super(FaceLips, self).build(calibrate=False, **kwargs)
if not self.preDeform:
# Resolve the head influence
jnt_head = self.rig.get_head_jnt()
if not jnt_head:
self.error("Failed parenting avars, no head influence found!")
return
jnt_jaw = self.rig.get_jaw_jnt()
if not jnt_jaw:
self.error("Failed parenting avars, no jaw influence found!")
return
nomenclature_rig = self.get_nomenclature_rig()
# Note #2: A common target for the head
target_head_name = nomenclature_rig.resolve('targetHead')
target_head = pymel.createNode('transform', name=target_head_name)
target_head.setTranslation(jnt_head.getTranslation(space='world'))
target_head.setParent(self.grp_rig)
pymel.parentConstraint(jnt_head, target_head, maintainOffset=True)
pymel.scaleConstraint(jnt_head, target_head, maintainOffset=True)
# Note #3: A common target for the jaw
target_jaw_name = nomenclature_rig.resolve('targetJaw')
target_jaw = pymel.createNode('transform', name=target_jaw_name)
target_jaw.setTranslation(jnt_jaw.getTranslation(space='world'))
target_jaw.setParent(self.grp_rig)
pymel.parentConstraint(jnt_jaw, target_jaw, maintainOffset=True)
pymel.scaleConstraint(jnt_jaw, target_jaw, maintainOffset=True)
attr_bypass = libAttr.addAttr(self.grp_rig, 'bypassSplitter')
# For each avars, create an extractor node and extract the delta from the bind pose.
# We'll then feed this into the stack layers.
# This will apply jaw deformation to the rig.
# Moving the lips when they are influenced by the jaw is a hard task.
# This is because the jaw introduce movement in 'jaw' space while the
# standard avars introduce movement in 'surface' space.
# This mean that if we try to affect a deformation occuring in 'jaw' space
# with the 'surface' space (ex: moving the lips corners up when the jaw is open)
# this will not result in perfect results.
# To prevent this situation, taking in consideration that there's a one on one correlation
# between the lips and jaw deformation (ex: the football shape created by the jaw at 1.0
# is the same as if upp and low lips are set at 0.5 each), we'll always use the jaw space
# before using the lips space.
min_x, max_x = self._get_mouth_width()
mouth_width = max_x - min_x
def connect_avar(avar, ratio):
avar._attr_inn_jaw_ratio_default.set(ratio)
#pymel.connectAttr(self._attr_inn_jaw_range, avar._attr_inn_jaw_range)
#pymel.connectAttr(self._attr_length_v, avar._attr_inn_jaw_range)
for avar in self.get_avars_corners():
connect_avar(avar, 0.5)
for avar in self.get_avars_upp():
if use_football_interpolation:
avar_pos_x = avar._grp_offset.tx.get()
ratio = abs(avar_pos_x - min_x / mouth_width)
ratio = max(min(ratio, 1.0), 0.0) # keep ratio in range
ratio = libRigging.interp_football(
ratio) # apply football shape
else:
ratio = 0.0
connect_avar(avar, ratio)
for avar in self.get_avars_low():
if use_football_interpolation:
avar_pos_x = avar._grp_offset.tx.get()
ratio = abs(avar_pos_x - min_x / mouth_width)
ratio = max(min(ratio, 1.0), 0.0) # keep ratio in range
ratio = 1.0 - libRigging.interp_football(
ratio) # apply football shape
else:
ratio = 1.0
connect_avar(avar, ratio)
# Calibration is done manually since we need to setup the jaw influence.
if calibrate:
self.calibrate()
def build(self, calibrate=True, use_football_interpolation=False, **kwargs):
"""
:param calibrate:
:param use_football_interpolation: If True, the resolved influence of the jaw on
each lips avar will give a 'football' shape. It is False by default since we take
in consideration that the weightmaps follow the 'Art of Moving Points' theory and
already result in a football shape if they are uniformly translated.
:param kwargs:
:return:
"""
super(FaceLips, self).build(calibrate=False, **kwargs)
if not self.preDeform:
# Resolve the head influence
jnt_head = self.rig.get_head_jnt()
if not jnt_head:
self.error("Failed parenting avars, no head influence found!")
return
jnt_jaw = self.rig.get_jaw_jnt()
if not jnt_jaw:
self.error("Failed parenting avars, no jaw influence found!")
return
nomenclature_rig = self.get_nomenclature_rig()
# Note #2: A common target for the head
target_head_name = nomenclature_rig.resolve('targetHead')
target_head = pymel.createNode('transform', name=target_head_name)
target_head.setTranslation(jnt_head.getTranslation(space='world'))
target_head.setParent(self.grp_rig)
pymel.parentConstraint(jnt_head, target_head, maintainOffset=True)
pymel.scaleConstraint(jnt_head, target_head, maintainOffset=True)
# Note #3: A common target for the jaw
target_jaw_name = nomenclature_rig.resolve('targetJaw')
target_jaw = pymel.createNode('transform', name=target_jaw_name)
target_jaw.setTranslation(jnt_jaw.getTranslation(space='world'))
target_jaw.setParent(self.grp_rig)
pymel.parentConstraint(jnt_jaw, target_jaw, maintainOffset=True)
pymel.scaleConstraint(jnt_jaw, target_jaw, maintainOffset=True)
attr_bypass = libAttr.addAttr(self.grp_rig, 'bypassSplitter')
# For each avars, create an extractor node and extract the delta from the bind pose.
# We'll then feed this into the stack layers.
# This will apply jaw deformation to the rig.
# Moving the lips when they are influenced by the jaw is a hard task.
# This is because the jaw introduce movement in 'jaw' space while the
# standard avars introduce movement in 'surface' space.
# This mean that if we try to affect a deformation occuring in 'jaw' space
# with the 'surface' space (ex: moving the lips corners up when the jaw is open)
# this will not result in perfect results.
# To prevent this situation, taking in consideration that there's a one on one correlation
# between the lips and jaw deformation (ex: the football shape created by the jaw at 1.0
# is the same as if upp and low lips are set at 0.5 each), we'll always use the jaw space
# before using the lips space.
min_x, max_x = self._get_mouth_width()
mouth_width = max_x - min_x
def connect_avar(avar, ratio):
avar._attr_inn_jaw_ratio_default.set(ratio)
#pymel.connectAttr(self._attr_inn_jaw_range, avar._attr_inn_jaw_range)
#pymel.connectAttr(self._attr_length_v, avar._attr_inn_jaw_range)
for avar in self.get_avars_corners():
connect_avar(avar, 0.5)
for avar in self.get_avars_upp():
if use_football_interpolation:
avar_pos_x = avar._grp_offset.tx.get()
ratio = abs(avar_pos_x - min_x / mouth_width)
ratio = max(min(ratio, 1.0), 0.0) # keep ratio in range
ratio = libRigging.interp_football(ratio) # apply football shape
else:
ratio = 0.0
connect_avar(avar, ratio)
for avar in self.get_avars_low():
if use_football_interpolation:
avar_pos_x = avar._grp_offset.tx.get()
ratio = abs(avar_pos_x - min_x / mouth_width)
ratio = max(min(ratio, 1.0), 0.0) # keep ratio in range
ratio = 1.0 - libRigging.interp_football(ratio) # apply football shape
else:
ratio = 1.0
connect_avar(avar, ratio)
# Calibration is done manually since we need to setup the jaw influence.
if calibrate:
self.calibrate()
def build(self, nomenclature_rig, **kwargs):
super(SplitterNode, self).build(**kwargs)
#
# Create inn and out attributes.
#
grp_splitter_inn = pymel.createNode(
'network', name=nomenclature_rig.resolve('udSplitterInn'))
# The jaw opening amount in degree.
self.attr_inn_jaw_pt = libAttr.addAttr(grp_splitter_inn, 'innJawOpen')
# The relative uv coordinates normally sent to the follicles.
# Note that this value is expected to change at the output of the SplitterNode (see outSurfaceU and outSurfaceV)
self.attr_inn_surface_u = libAttr.addAttr(grp_splitter_inn,
'innSurfaceU')
self.attr_inn_surface_v = libAttr.addAttr(grp_splitter_inn,
'innSurfaceV')
# Use this switch to disable completely the splitter.
self.attr_inn_bypass = libAttr.addAttr(grp_splitter_inn,
'innBypassAmount')
# The arc length in world space of the surface controlling the follicles.
self.attr_inn_surface_range_v = libAttr.addAttr(
grp_splitter_inn, 'innSurfaceRangeV'
) # How many degree does take the jaw to create 1 unit of surface deformation? (ex: 20)
# How much inn percent is the lips following the jaw by default.
# Note that this value is expected to change at the output of the SplitterNode (see attr_out_jaw_ratio)
self.attr_inn_jaw_default_ratio = libAttr.addAttr(
grp_splitter_inn, 'jawDefaultRatio')
# The radius of the influence circle normally resolved by using the distance between the jaw and the avar as radius.
self.attr_inn_jaw_radius = libAttr.addAttr(grp_splitter_inn,
'jawRadius')
grp_splitter_out = pymel.createNode(
'network', name=nomenclature_rig.resolve('udSplitterOut'))
self.attr_out_surface_u = libAttr.addAttr(grp_splitter_out,
'outSurfaceU')
self.attr_out_surface_v = libAttr.addAttr(grp_splitter_out,
'outSurfaceV')
self.attr_out_jaw_ratio = libAttr.addAttr(
grp_splitter_out, 'outJawRatio'
) # How much percent this influence follow the jaw after cancellation.
#
# Connect inn and out network nodes so they can easily be found from the SplitterNode.
#
attr_inn = libAttr.addAttr(grp_splitter_inn,
longName='inn',
attributeType='message')
attr_out = libAttr.addAttr(grp_splitter_out,
longName='out',
attributeType='message')
pymel.connectAttr(self.node.message, attr_inn)
pymel.connectAttr(self.node.message, attr_out)
#
# Create node networks
# Step 1: Get the jaw displacement in uv space (parameterV only).
#
attr_jaw_circumference = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getJawCircumference'),
input1X=self.attr_inn_jaw_radius,
input2X=(math.pi * 2.0)).outputX
attr_jaw_open_circle_ratio = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getJawOpenCircleRatio'),
operation=2, # divide
input1X=self.attr_inn_jaw_pt,
input2X=360.0).outputX
attr_jaw_active_circumference = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getJawActiveCircumference'),
input1X=attr_jaw_circumference,
input2X=attr_jaw_open_circle_ratio).outputX
# We need this adjustment since we cheat the influence of the avar with the plane uvs.
# see AvarFollicle._get_follicle_relative_uv_attr for more information.
# attr_jaw_radius_demi = libRigging.create_utility_node(
# 'multiplyDivide',
# name=nomenclature_rig.resolve('getJawRangeVRange'),
# input1X=self.attr_inn_surface_range_v,
# input2X=2.0
# ).outputX
attr_jaw_v_range = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getActiveJawRangeInSurfaceSpace'),
operation=2, # divide
input1X=attr_jaw_active_circumference,
input2X=self.attr_inn_surface_range_v).outputX
#
# Step 2: Resolve attr_out_jaw_ratio
#
# Convert attr_jaw_default_ratio in uv space.
attr_jaw_default_ratio_v = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getJawDefaultRatioUvSpace'),
input1X=self.attr_inn_jaw_default_ratio,
input2X=attr_jaw_v_range).outputX
attr_jaw_uv_pos = libRigging.create_utility_node(
'plusMinusAverage',
name=nomenclature_rig.resolve('getCurrentJawUvPos'),
operation=2, # substraction
input1D=(attr_jaw_default_ratio_v,
self.attr_inn_surface_v)).output1D
attr_jaw_ratio_out = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getJawRatioOut'),
operation=2, # division
input1X=attr_jaw_uv_pos,
input2X=attr_jaw_v_range).outputX
attr_jaw_ratio_out_limited = libRigging.create_utility_node(
'clamp',
name=nomenclature_rig.resolve('getLimitedJawRatioOut'),
inputR=attr_jaw_ratio_out,
minR=0.0,
maxR=1.0).outputR
# Prevent division by zero
attr_jaw_ratio_out_limited_safe = libRigging.create_utility_node(
'condition',
name=nomenclature_rig.resolve('getSafeJawRatioOut'),
operation=1, # not equal
firstTerm=self.attr_inn_jaw_pt,
secondTerm=0,
colorIfTrueR=attr_jaw_ratio_out_limited,
colorIfFalseR=self.attr_inn_jaw_default_ratio).outColorR
#
# Step 3: Resolve attr_out_surface_u & attr_out_surface_v
#
attr_inn_jaw_default_ratio_inv = libRigging.create_utility_node(
'reverse',
name=nomenclature_rig.resolve('getJawDefaultRatioInv'),
inputX=self.attr_inn_jaw_default_ratio).outputX
util_jaw_uv_default_ratio = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getJawDefaultRatioUvSpace'),
input1X=self.attr_inn_jaw_default_ratio,
input1Y=attr_inn_jaw_default_ratio_inv,
input2X=attr_jaw_v_range,
input2Y=attr_jaw_v_range)
attr_jaw_uv_default_ratio = util_jaw_uv_default_ratio.outputX
attr_jaw_uv_default_ratio_inv = util_jaw_uv_default_ratio.outputY
attr_jaw_uv_limit_max = libRigging.create_utility_node(
'plusMinusAverage',
name=nomenclature_rig.resolve('getJawSurfaceLimitMax'),
operation=2, # substract
input1D=(attr_jaw_v_range, attr_jaw_uv_default_ratio_inv)).output1D
attr_jaw_uv_limit_min = libRigging.create_utility_node(
'plusMinusAverage',
name=nomenclature_rig.resolve('getJawSurfaceLimitMin'),
operation=2, # substract
input1D=(attr_jaw_uv_default_ratio, attr_jaw_v_range)).output1D
attr_jaw_cancel_range = libRigging.create_utility_node(
'clamp',
name=nomenclature_rig.resolve('getJawCancelRange'),
inputR=self.attr_inn_surface_v,
minR=attr_jaw_uv_limit_min,
maxR=attr_jaw_uv_limit_max).outputR
attr_out_surface_v_cancelled = libRigging.create_utility_node(
'plusMinusAverage',
name=nomenclature_rig.resolve('getCanceledUv'),
operation=2, # substraction
input1D=(self.attr_inn_surface_v, attr_jaw_cancel_range)).output1D
#
# Connect output attributes
#
attr_inn_bypass_inv = libRigging.create_utility_node(
'reverse',
name=nomenclature_rig.resolve('getBypassInv'),
inputX=self.attr_inn_bypass).outputX
# Connect output jaw_ratio
attr_output_jaw_ratio = libRigging.create_utility_node(
'blendWeighted',
input=(attr_jaw_ratio_out_limited_safe,
self.attr_inn_jaw_default_ratio),
weight=(attr_inn_bypass_inv, self.attr_inn_bypass)).output
pymel.connectAttr(attr_output_jaw_ratio, self.attr_out_jaw_ratio)
# Connect output surface u
pymel.connectAttr(self.attr_inn_surface_u, self.attr_out_surface_u)
# Connect output surface_v
attr_output_surface_v = libRigging.create_utility_node(
'blendWeighted',
input=(attr_out_surface_v_cancelled, self.attr_inn_surface_v),
weight=(attr_inn_bypass_inv, self.attr_inn_bypass)).output
pymel.connectAttr(attr_output_surface_v, self.attr_out_surface_v)
def build(self, constraint=True, ctrl_size=1.0, ctrl_tm=None, jnt_tm=None, obj_mesh=None, follow_mesh=True,
**kwargs):
"""
:param constraint:
:param ctrl_size: DEPRECATED, PLEASE MOVE TO ._create_ctrl
:param ctrl_tm: DEPRECATED, PLEASE MOVE TO ._create_ctrl
:param jnt_tm:
:param obj_mesh: DEPRECATED, PLEASE MOVE TO ._create_ctrl
:param follow_mesh: DEPRECATED, PLEASE MOVE TO ._create_ctrl
:param kwargs:
:return:
"""
super(AvarSimple, self).build(parent=False)
_avar_filter_kwargs = {
'defaultValue': 1.0,
'hasMinValue': True,
'hasMaxValue': True,
'minValue': 0.0,
'maxValue': 1.0,
'keyable': True
}
self.affect_tx = libAttr.addAttr(self.grp_rig, longName='affectTx', **_avar_filter_kwargs)
self.affect_ty = libAttr.addAttr(self.grp_rig, longName='affectTy', **_avar_filter_kwargs)
self.affect_tz = libAttr.addAttr(self.grp_rig, longName='affectTz', **_avar_filter_kwargs)
self.affect_rx = libAttr.addAttr(self.grp_rig, longName='affectRx', **_avar_filter_kwargs)
self.affect_ry = libAttr.addAttr(self.grp_rig, longName='affectRy', **_avar_filter_kwargs)
self.affect_rz = libAttr.addAttr(self.grp_rig, longName='affectRz', **_avar_filter_kwargs)
self.affect_sx = libAttr.addAttr(self.grp_rig, longName='affectSx', **_avar_filter_kwargs)
self.affect_sy = libAttr.addAttr(self.grp_rig, longName='affectSy', **_avar_filter_kwargs)
self.affect_sz = libAttr.addAttr(self.grp_rig, longName='affectSz', **_avar_filter_kwargs)
nomenclature_rig = self.get_nomenclature_rig()
# Resolve influence matrix
if jnt_tm is None:
jnt_tm = self.get_jnt_tm()
jnt_pos = jnt_tm.translate
# Create an offset layer that define the starting point of the Avar.
# It is important that the offset is in this specific node since it will serve as
# a reference to re-computer the base u and v parameter if the rigger change the
# size of the surface when the system is build.
grp_offset_name = nomenclature_rig.resolve('offset')
self.grp_offset = pymel.createNode('transform', name=grp_offset_name)
self.grp_offset.rename(grp_offset_name)
self.grp_offset.setParent(self.grp_rig)
# Create a parent layer for constraining.
# Do not use dual constraint here since it can result in flipping issues.
self._grp_parent = pymel.createNode(
'transform',
name=nomenclature_rig.resolve('parent'),
parent=self.grp_rig,
)
self._grp_output = pymel.createNode(
'transform',
name=nomenclature_rig.resolve('output'),
parent=self.grp_rig
)
# We expect the right-side influence to be mirrored in behavior.
# However we still need consistency when moving left and right side controller together.
# So under the hood, add an offset matrix so they are aligned together.
if self.need_flip_lr() and self.jnt:
jnt_tm = pymel.datatypes.Matrix(
1.0, 0.0, 0.0, 0.0,
0.0, -1.0, 0.0, 0.0,
0.0, 0.0, -1.0, 0.0,
0.0, 0.0, 0.0, 1.0) * jnt_tm
self.grp_offset.setMatrix(jnt_tm)
self.model_infl = self.init_module(self._CLS_MODEL_INFL, self.model_infl, suffix='avarModel')
# self.model_infl = model_avar_surface.AvarSurfaceModel(self.input, rig=self.rig, name=infl_model_name)
self.model_infl.build()
self.model_infl.grp_rig.setParent(self.grp_rig)
self.create_stacks()
self.model_infl.connect_avar(self)
# ---------------------------------------------
# We connect the joint before creating the controllers.
# This allow our doritos to work out of the box and allow us to compute their sensibility automatically.
if self.jnt and constraint:
# Ensure that Maya will be able to add the constraint.
# This could fail if the object is already connected to something else (ex: an animCurve).
# For this reason we'll force a disconnection if necessary.
attrs_to_disconnect = ['t', 'tx', 'ty', 'tz', 'r', 'rx', 'ry', 'rz', 's', 'sx', 'sy', 'sz']
for attr_name in attrs_to_disconnect:
attr = self.jnt.attr(attr_name)
if attr.isDestination():
log.warning('{0}.{1} need to be connected but already have connections. Connection broken.'.format(
self.jnt.nodeName(), attr_name
))
pymel.disconnectAttr(attr.inputs(plugs=True)[0], attr)
if attr.isLocked():
log.warning('{0}.{1} need to be connected but was locked. Lock removed.')
attr.unlock()
pymel.parentConstraint(self._grp_output, self.jnt, maintainOffset=True)
pymel.scaleConstraint(self._grp_output, self.jnt, maintainOffset=True)
def build_stack(self, stack, mult_u=1.0, mult_v=1.0):
"""
The dag stack is a chain of transform nodes daisy chained together that computer the final transformation of the influence.
The decision of using transforms instead of multMatrix nodes is for clarity.
Note also that because of it's parent (the offset node) the stack relative to the influence original translation.
"""
# TODO: Maybe use sub-classing to differenciate when we need to use a surface or not.
nomenclature_rig = self.get_nomenclature_rig()
#
# Extract the base U and V of the base influence using the stack parent. (the 'offset' node)
#
surface_shape = self.surface.getShape()
util_get_base_uv_absolute = libRigging.create_utility_node(
'closestPointOnSurface',
inPosition=self._grp_offset.t,
inputSurface=surface_shape.worldSpace)
util_get_base_uv_normalized = libRigging.create_utility_node(
'setRange',
oldMinX=surface_shape.minValueU,
oldMaxX=surface_shape.maxValueU,
oldMinY=surface_shape.minValueV,
oldMaxY=surface_shape.maxValueV,
minX=0,
maxX=1,
minY=0,
maxY=1,
valueX=util_get_base_uv_absolute.parameterU,
valueY=util_get_base_uv_absolute.parameterV)
attr_base_u_normalized = util_get_base_uv_normalized.outValueX
attr_base_v_normalized = util_get_base_uv_normalized.outValueY
self._attr_u_base = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_U_BASE,
defaultValue=attr_base_u_normalized.get())
self._attr_v_base = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_V_BASE,
defaultValue=attr_base_v_normalized.get())
pymel.connectAttr(attr_base_u_normalized,
self.grp_rig.attr(self._ATTR_NAME_U_BASE))
pymel.connectAttr(attr_base_v_normalized,
self.grp_rig.attr(self._ATTR_NAME_V_BASE))
#
# Create follicle setup
# The setup is composed of two follicles.
# One for the "bind pose" and one "driven" by the avars..
# The delta between the "bind pose" and the "driven" follicles is then applied to the influence.
#
# Determine the follicle U and V on the reference nurbsSurface.
# jnt_pos = self.jnt.getTranslation(space='world')
# fol_pos, fol_u, fol_v = libRigging.get_closest_point_on_surface(self.surface, jnt_pos)
base_u_val = self._attr_u_base.get()
base_v_val = self._attr_v_base.get()
# Resolve the length of each axis of the surface
self._attr_length_u, self._attr_length_v, arcdimension_shape = libRigging.create_arclengthdimension_for_nurbsplane(
self.surface)
arcdimension_transform = arcdimension_shape.getParent()
arcdimension_transform.rename(nomenclature_rig.resolve('arcdimension'))
arcdimension_transform.setParent(self.grp_rig)
#
# Create two follicle.
# - influenceFollicle: Affected by the ud and lr Avar
# - bindPoseFollicle: A follicle that stay in place and keep track of the original position.
# We'll then compute the delta of the position of the two follicles.
# This allow us to move or resize the plane without affecting the built rig. (if the rig is in neutral pose)
#
offset_name = nomenclature_rig.resolve('bindPoseRef')
obj_offset = pymel.createNode('transform', name=offset_name)
obj_offset.setParent(self._grp_offset)
fol_offset_name = nomenclature_rig.resolve('bindPoseFollicle')
# fol_offset = libRigging.create_follicle(obj_offset, self.surface, name=fol_offset_name)
fol_offset_shape = libRigging.create_follicle2(self.surface,
u=base_u_val,
v=base_v_val)
fol_offset = fol_offset_shape.getParent()
fol_offset.rename(fol_offset_name)
pymel.parentConstraint(fol_offset, obj_offset, maintainOffset=False)
fol_offset.setParent(self.grp_rig)
# Create the influence follicle
influence_name = nomenclature_rig.resolve('influenceRef')
influence = pymel.createNode('transform', name=influence_name)
influence.setParent(self._grp_offset)
fol_influence_name = nomenclature_rig.resolve('influenceFollicle')
fol_influence_shape = libRigging.create_follicle2(self.surface,
u=base_u_val,
v=base_v_val)
fol_influence = fol_influence_shape.getParent()
fol_influence.rename(fol_influence_name)
pymel.parentConstraint(fol_influence, influence, maintainOffset=False)
fol_influence.setParent(self.grp_rig)
#
# Extract the delta of the influence follicle and it's initial pose follicle
#
attr_localTM = libRigging.create_utility_node(
'multMatrix',
matrixIn=[influence.worldMatrix,
obj_offset.worldInverseMatrix]).matrixSum
# Since we are extracting the delta between the influence and the bindpose matrix, the rotation of the surface
# is not taken in consideration wich make things less intuitive for the rigger.
# So we'll add an adjustement matrix so the rotation of the surface is taken in consideration.
util_decomposeTM_bindPose = libRigging.create_utility_node(
'decomposeMatrix', inputMatrix=obj_offset.worldMatrix)
attr_translateTM = libRigging.create_utility_node(
'composeMatrix',
inputTranslate=util_decomposeTM_bindPose.outputTranslate
).outputMatrix
attr_translateTM_inv = libRigging.create_utility_node(
'inverseMatrix',
inputMatrix=attr_translateTM,
).outputMatrix
attr_rotateTM = libRigging.create_utility_node(
'multMatrix',
matrixIn=[obj_offset.worldMatrix, attr_translateTM_inv]).matrixSum
attr_rotateTM_inv = libRigging.create_utility_node(
'inverseMatrix', inputMatrix=attr_rotateTM).outputMatrix
attr_finalTM = libRigging.create_utility_node(
'multMatrix',
matrixIn=[attr_rotateTM_inv, attr_localTM,
attr_rotateTM]).matrixSum
util_decomposeTM = libRigging.create_utility_node(
'decomposeMatrix', inputMatrix=attr_finalTM)
#
# Resolve the parameterU and parameterV
#
self._attr_u_mult_inn = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_U_MULT,
defaultValue=self._AVAR_DEFAULT_MULTIPLIER_U)
self._attr_v_mult_inn = libAttr.addAttr(
self.grp_rig,
longName=self._ATTR_NAME_V_MULT,
defaultValue=self._AVAR_DEFAULT_MULTIPLIER_V)
attr_u_inn, attr_v_inn = self._get_follicle_absolute_uv_attr()
#
# Create the 1st (follicleLayer) that will contain the extracted position from the ud and lr Avar.
#
layer_follicle = stack.append_layer('follicleLayer')
pymel.connectAttr(util_decomposeTM.outputTranslate,
layer_follicle.translate)
pymel.connectAttr(attr_u_inn, fol_influence.parameterU)
pymel.connectAttr(attr_v_inn, fol_influence.parameterV)
pymel.connectAttr(self._attr_u_base, fol_offset.parameterU)
pymel.connectAttr(self._attr_v_base, fol_offset.parameterV)
#
# The second layer (oobLayer for out-of-bound) that allow the follicle to go outside it's original plane.
# If the UD value is out the nurbsPlane UV range (0-1), ie 1.1, we'll want to still offset the follicle.
# For that we'll compute a delta between a small increment (0.99 and 1.0) and multiply it.
#
nomenclature_rig = self.get_nomenclature_rig()
oob_step_size = 0.001 # TODO: Expose a Maya attribute?
fol_clamped_v_name = nomenclature_rig.resolve('influenceClampedV')
fol_clamped_v_shape = libRigging.create_follicle2(self.surface,
u=base_u_val,
v=base_v_val)
fol_clamped_v = fol_clamped_v_shape.getParent()
fol_clamped_v.rename(fol_clamped_v_name)
fol_clamped_v.setParent(self.grp_rig)
fol_clamped_u_name = nomenclature_rig.resolve('influenceClampedU')
fol_clamped_u_shape = libRigging.create_follicle2(self.surface,
u=base_u_val,
v=base_v_val)
fol_clamped_u = fol_clamped_u_shape.getParent()
fol_clamped_u.rename(fol_clamped_u_name)
fol_clamped_u.setParent(self.grp_rig)
# Clamp the values so they never fully reach 0 or 1 for U and V.
util_clamp_uv = libRigging.create_utility_node(
'clamp',
inputR=attr_u_inn,
inputG=attr_v_inn,
minR=oob_step_size,
minG=oob_step_size,
maxR=1.0 - oob_step_size,
maxG=1.0 - oob_step_size)
clamped_u = util_clamp_uv.outputR
clamped_v = util_clamp_uv.outputG
pymel.connectAttr(clamped_v, fol_clamped_v.parameterV)
pymel.connectAttr(attr_u_inn, fol_clamped_v.parameterU)
pymel.connectAttr(attr_v_inn, fol_clamped_u.parameterV)
pymel.connectAttr(clamped_u, fol_clamped_u.parameterU)
# Compute the direction to add for U and V if we are out-of-bound.
dir_oob_u = libRigging.create_utility_node(
'plusMinusAverage',
operation=2,
input3D=[fol_influence.translate,
fol_clamped_u.translate]).output3D
dir_oob_v = libRigging.create_utility_node(
'plusMinusAverage',
operation=2,
input3D=[fol_influence.translate,
fol_clamped_v.translate]).output3D
# Compute the offset to add for U and V
condition_oob_u_neg = libRigging.create_utility_node(
'condition',
operation=4, # less than
firstTerm=attr_u_inn,
secondTerm=0.0,
colorIfTrueR=1.0,
colorIfFalseR=0.0,
).outColorR
condition_oob_u_pos = libRigging.create_utility_node(
'condition', # greater than
operation=2,
firstTerm=attr_u_inn,
secondTerm=1.0,
colorIfTrueR=1.0,
colorIfFalseR=0.0,
).outColorR
condition_oob_v_neg = libRigging.create_utility_node(
'condition',
operation=4, # less than
firstTerm=attr_v_inn,
secondTerm=0.0,
colorIfTrueR=1.0,
colorIfFalseR=0.0,
).outColorR
condition_oob_v_pos = libRigging.create_utility_node(
'condition', # greater than
operation=2,
firstTerm=attr_v_inn,
secondTerm=1.0,
colorIfTrueR=1.0,
colorIfFalseR=0.0,
).outColorR
# Compute the amount of oob
oob_val_u_pos = libRigging.create_utility_node(
'plusMinusAverage', operation=2, input1D=[attr_u_inn,
1.0]).output1D
oob_val_u_neg = libRigging.create_utility_node('multiplyDivide',
input1X=attr_u_inn,
input2X=-1.0).outputX
oob_val_v_pos = libRigging.create_utility_node(
'plusMinusAverage', operation=2, input1D=[attr_v_inn,
1.0]).output1D
oob_val_v_neg = libRigging.create_utility_node('multiplyDivide',
input1X=attr_v_inn,
input2X=-1.0).outputX
oob_val_u = libRigging.create_utility_node(
'condition',
operation=0,
firstTerm=condition_oob_u_pos,
secondTerm=1.0,
colorIfTrueR=oob_val_u_pos,
colorIfFalseR=oob_val_u_neg).outColorR
oob_val_v = libRigging.create_utility_node(
'condition',
operation=0,
firstTerm=condition_oob_v_pos,
secondTerm=1.0,
colorIfTrueR=oob_val_v_pos,
colorIfFalseR=oob_val_v_neg).outColorR
oob_amount_u = libRigging.create_utility_node(
'multiplyDivide',
operation=2,
input1X=oob_val_u,
input2X=oob_step_size).outputX
oob_amount_v = libRigging.create_utility_node(
'multiplyDivide',
operation=2,
input1X=oob_val_v,
input2X=oob_step_size).outputX
oob_offset_u = libRigging.create_utility_node('multiplyDivide',
input1X=oob_amount_u,
input1Y=oob_amount_u,
input1Z=oob_amount_u,
input2=dir_oob_u).output
oob_offset_v = libRigging.create_utility_node('multiplyDivide',
input1X=oob_amount_v,
input1Y=oob_amount_v,
input1Z=oob_amount_v,
input2=dir_oob_v).output
# Add the U out-of-bound-offset only if the U is between 0.0 and 1.0
oob_u_condition_1 = condition_oob_u_neg
oob_u_condition_2 = condition_oob_u_pos
oob_u_condition_added = libRigging.create_utility_node(
'addDoubleLinear',
input1=oob_u_condition_1,
input2=oob_u_condition_2).output
oob_u_condition_out = libRigging.create_utility_node(
'condition',
operation=0, # equal
firstTerm=oob_u_condition_added,
secondTerm=1.0,
colorIfTrue=oob_offset_u,
colorIfFalse=[0, 0, 0]).outColor
# Add the V out-of-bound-offset only if the V is between 0.0 and 1.0
oob_v_condition_1 = condition_oob_v_neg
oob_v_condition_2 = condition_oob_v_pos
oob_v_condition_added = libRigging.create_utility_node(
'addDoubleLinear',
input1=oob_v_condition_1,
input2=oob_v_condition_2).output
oob_v_condition_out = libRigging.create_utility_node(
'condition',
operation=0, # equal
firstTerm=oob_v_condition_added,
secondTerm=1.0,
colorIfTrue=oob_offset_v,
colorIfFalse=[0, 0, 0]).outColor
oob_offset = libRigging.create_utility_node(
'plusMinusAverage',
input3D=[oob_u_condition_out, oob_v_condition_out]).output3D
layer_oob = stack.append_layer('oobLayer')
pymel.connectAttr(oob_offset, layer_oob.t)
#
# Create the third layer that apply the translation provided by the fb Avar.
#
layer_fb = stack.append_layer('fbLayer')
attr_get_fb = libRigging.create_utility_node(
'multiplyDivide',
input1X=self.attr_fb,
input2X=self._attr_length_u).outputX
attr_get_fb_adjusted = libRigging.create_utility_node(
'multiplyDivide', input1X=attr_get_fb, input2X=0.1).outputX
pymel.connectAttr(attr_get_fb_adjusted, layer_fb.translateZ)
#
# Create the 4th layer (folRot) that apply the rotation provided by the follicle controlled by the ud and lr Avar.
# This is necessary since we don't want to rotation to affect the oobLayer and fbLayer.
#
layer_follicle_rot = stack.append_layer('folRot')
pymel.connectAttr(util_decomposeTM.outputRotate,
layer_follicle_rot.rotate)
#
# Create a 5th layer that apply the yw, pt, rl and Avar.
#
layer_rot = stack.append_layer('rotLayer')
pymel.connectAttr(self.attr_yw, layer_rot.rotateY)
pymel.connectAttr(self.attr_pt, layer_rot.rotateX)
pymel.connectAttr(self.attr_rl, layer_rot.rotateZ)
return stack
def _create_interface(self):
# Create avar inputs
self._attr_inn_lr = libAttr.addAttr(self.grp_rig, 'innAvarLr')
self._attr_inn_ud = libAttr.addAttr(self.grp_rig, 'innAvarUd')
self._attr_inn_fb = libAttr.addAttr(self.grp_rig, 'innAvarFb')
self._attr_inn_yw = libAttr.addAttr(self.grp_rig, 'innAvarYw')
self._attr_inn_pt = libAttr.addAttr(self.grp_rig, 'innAvarPt')
self._attr_inn_rl = libAttr.addAttr(self.grp_rig, 'innAvarRl')
self._attr_inn_sx = libAttr.addAttr(self.grp_rig, 'innAvarSx')
self._attr_inn_sy = libAttr.addAttr(self.grp_rig, 'innAvarSy')
self._attr_inn_sz = libAttr.addAttr(self.grp_rig, 'innAvarSz')
self.multiplier_lr = libAttr.addAttr(self.grp_rig, 'innMultiplierLr', defaultValue=self.multiplier_lr)
self.multiplier_ud = libAttr.addAttr(self.grp_rig, 'innMultiplierUd', defaultValue=self.multiplier_ud)
self.multiplier_fb = libAttr.addAttr(self.grp_rig, 'innMultiplierFb', defaultValue=self.multiplier_fb)
# Create influences
_avar_filter_kwargs = {
'hasMinValue': True,
'hasMaxValue': True,
'minValue': 0.0,
'maxValue': 1.0,
'keyable': True
}
self._attr_inn_offset_tm = libAttr.addAttr(self.grp_rig, 'innOffset', dt='matrix')
self._attr_out_tm = libAttr.addAttr(self.grp_rig, 'outTm', dataType='matrix')
def build_stack(self, stack, **kwargs):
nomenclature_rig = self.get_nomenclature_rig()
jnt_head = self.rig.get_head_jnt()
jnt_jaw = self.rig.get_jaw_jnt()
#
# Create additional attributes to control the jaw layer
#
libAttr.addAttr_separator(self.grp_rig, 'jawLayer')
self._attr_inn_jaw_ratio_default = libAttr.addAttr(self.grp_rig,
'jawRatioDefault',
defaultValue=0.5,
hasMinValue=True,
hasMaxValue=True,
minValue=0,
maxValue=1,
k=True)
self._attr_bypass_splitter = libAttr.addAttr(self.grp_rig,
'jawSplitterBypass',
defaultValue=0.0,
hasMinValue=True,
hasMaxValue=True,
minValue=0,
maxValue=1,
k=True)
#
# Create reference objects used for calculations.
#
# Create a reference node that follow the head
self._target_head = pymel.createNode(
'transform',
name=nomenclature_rig.resolve('innHead'),
parent=self.grp_rig)
self._target_head.setTranslation(
jnt_head.getTranslation(space='world'))
pymel.parentConstraint(jnt_head,
self._target_head,
maintainOffset=True)
pymel.scaleConstraint(jnt_head, self._target_head, maintainOffset=True)
# Create a reference node that follow the jaw initial position
jaw_pos = jnt_jaw.getTranslation(space='world')
self._target_jaw_bindpose = pymel.createNode(
'transform',
name=nomenclature_rig.resolve('innJawBindPose'),
parent=self.grp_rig)
self._target_jaw_bindpose.setTranslation(jaw_pos)
# Create a reference node that follow the jaw
self._target_jaw = pymel.createNode(
'transform',
name=nomenclature_rig.resolve('innJaw'),
parent=self._target_jaw_bindpose)
self._target_jaw.t.set(0, 0, 0)
pymel.parentConstraint(jnt_jaw, self._target_jaw, maintainOffset=True)
pymel.scaleConstraint(jnt_jaw, self._target_jaw, maintainOffset=True)
# Create a node that contain the out jaw influence.
# Note that the out jaw influence can be modified by the splitter node.
grp_parent_pos = self._grp_parent.getTranslation(
space='world') # grp_offset is always in world coordinates
self._jaw_ref = pymel.createNode(
'transform',
name=nomenclature_rig.resolve('outJawInfluence'),
parent=self.grp_rig)
self._jaw_ref.t.set(grp_parent_pos)
pymel.parentConstraint(self._target_jaw,
self._jaw_ref,
maintainOffset=True)
# Extract jaw influence
attr_delta_tm = libRigging.create_utility_node(
'multMatrix',
matrixIn=[
self._jaw_ref.worldMatrix, self._grp_parent.worldInverseMatrix
]).matrixSum
util_extract_jaw = libRigging.create_utility_node(
'decomposeMatrix',
name=nomenclature_rig.resolve('getJawRotation'),
inputMatrix=attr_delta_tm)
super(FaceLipsAvar, self).build_stack(stack, **kwargs)
#
# Create jaw influence layer
# Create a reference object to extract the jaw displacement.
#
# Add the jaw influence as a new stack layer.
layer_jaw_r = stack.prepend_layer(name='jawRotate')
layer_jaw_t = stack.prepend_layer(name='jawTranslate')
pymel.connectAttr(util_extract_jaw.outputTranslate, layer_jaw_t.t)
pymel.connectAttr(util_extract_jaw.outputRotate, layer_jaw_r.r)
def pre_build(self):
super(RigSqueeze, self).pre_build(create_master_grp=False)
#
# Create specific group related to squeeze rig convention
#
all_geos = libPymel.ls_root_geos()
# Build All_Grp
self.grp_master = self.build_grp(classRig.RigGrp, self.grp_master, self.nomenclature.root_all_name)
self.grp_model = self.build_grp(classRig.RigGrp, self.grp_model, self.nomenclature.root_model_name)
self.grp_proxy = self.build_grp(classRig.RigGrp, self.grp_proxy, self.nomenclature.root_proxy_name)
self.grp_fx = self.build_grp(classRig.RigGrp, self.grp_fx, self.nomenclature.root_fx_name)
# Parent all groups in the main grp_master
pymel.parent(self.grp_anm, self.grp_master) # grp_anm is not a Node, but a Ctrl
self.grp_rig.setParent(self.grp_master)
self.grp_fx.setParent(self.grp_master)
self.grp_model.setParent(self.grp_master)
self.grp_proxy.setParent(self.grp_master)
self.grp_geo.setParent(self.grp_master)
'''
if self.grp_jnt.getParent() is None:
self.grp_jnt.setParent(self.grp_master)
'''
# Lock and hide all attributes we don't want the animator to play with
libAttr.lock_hide_trs(self.grp_master)
libAttr.lock_hide_trs(self.grp_rig)
libAttr.lock_hide_trs(self.grp_fx)
libAttr.lock_hide_trs(self.grp_model)
libAttr.lock_hide_trs(self.grp_proxy)
libAttr.lock_hide_trs(self.grp_geo)
libAttr.hide_scale(self.grp_anm)
# Hide some group
# self.grp_jnt.visibility.set(False)
self.grp_rig.visibility.set(False)
self.grp_fx.visibility.set(False)
self.grp_model.visibility.set(False)
#
# Add root ctrl attributes specific to squeeze
#
if not self.grp_anm.hasAttr(self.GROUP_NAME_DISPLAY, checkShape=False):
libAttr.addAttr_separator(self.grp_anm, self.GROUP_NAME_DISPLAY)
# Display Mesh
if not self.grp_anm.hasAttr(self.ATTR_NAME_DISPLAY_MESH, checkShape=False):
attr_displayMesh = libAttr.addAttr(self.grp_anm, longName=self.ATTR_NAME_DISPLAY_MESH, at='short', k=True,
hasMinValue=True, hasMaxValue=True, minValue=0, maxValue=1, defaultValue=1)
else:
attr_displayMesh = self.grp_anm.attr(self.ATTR_NAME_DISPLAY_MESH)
# Display Ctrl
if not self.grp_anm.hasAttr(self.ATTR_NAME_DISPLAY_CTRL, checkShape=False):
attr_displayCtrl = libAttr.addAttr(self.grp_anm, longName=self.ATTR_NAME_DISPLAY_CTRL, at='short', k=True,
hasMinValue=True, hasMaxValue=True, minValue=0, maxValue=1, defaultValue=1)
else:
attr_displayCtrl = self.grp_anm.attr(self.ATTR_NAME_DISPLAY_CTRL)
# Display Proxy
if not self.grp_anm.hasAttr(self.ATTR_NAME_DISPLAY_PROXY, checkShape=False):
attr_displayProxy = libAttr.addAttr(self.grp_anm, longName=self.ATTR_NAME_DISPLAY_PROXY, at='short', k=True,
hasMinValue=True, hasMaxValue=True, minValue=0, maxValue=1, defaultValue=0)
else:
attr_displayProxy = self.grp_anm.attr(self.ATTR_NAME_DISPLAY_PROXY)
pymel.connectAttr(attr_displayMesh, self.grp_geo.visibility, force=True)
pymel.connectAttr(attr_displayProxy, self.grp_proxy.visibility, force=True)
for child in self.grp_anm.getChildren():
pymel.connectAttr(attr_displayCtrl, child.visibility, force=True)
def build(self, nomenclature_rig, **kwargs):
super(SplitterNode, self).build(**kwargs)
#
# Create inn and out attributes.
#
grp_splitter_inn = pymel.createNode(
'network',
name=nomenclature_rig.resolve('udSplitterInn')
)
# The jaw opening amount in degree.
self.attr_inn_jaw_pt = libAttr.addAttr(grp_splitter_inn, 'innJawOpen')
# The relative uv coordinates normally sent to the follicles.
# Note that this value is expected to change at the output of the SplitterNode (see outSurfaceU and outSurfaceV)
self.attr_inn_surface_u = libAttr.addAttr(grp_splitter_inn, 'innSurfaceU')
self.attr_inn_surface_v = libAttr.addAttr(grp_splitter_inn, 'innSurfaceV')
# Use this switch to disable completely the splitter.
self.attr_inn_bypass = libAttr.addAttr(grp_splitter_inn, 'innBypassAmount')
# The arc length in world space of the surface controlling the follicles.
self.attr_inn_surface_range_v = libAttr.addAttr(grp_splitter_inn,
'innSurfaceRangeV') # How many degree does take the jaw to create 1 unit of surface deformation? (ex: 20)
# How much inn percent is the lips following the jaw by default.
# Note that this value is expected to change at the output of the SplitterNode (see attr_out_jaw_ratio)
self.attr_inn_jaw_default_ratio = libAttr.addAttr(grp_splitter_inn, 'jawDefaultRatio')
# The radius of the influence circle normally resolved by using the distance between the jaw and the avar as radius.
self.attr_inn_jaw_radius = libAttr.addAttr(grp_splitter_inn, 'jawRadius')
grp_splitter_out = pymel.createNode(
'network',
name=nomenclature_rig.resolve('udSplitterOut')
)
self.attr_out_surface_u = libAttr.addAttr(grp_splitter_out, 'outSurfaceU')
self.attr_out_surface_v = libAttr.addAttr(grp_splitter_out, 'outSurfaceV')
self.attr_out_jaw_ratio = libAttr.addAttr(grp_splitter_out,
'outJawRatio') # How much percent this influence follow the jaw after cancellation.
#
# Connect inn and out network nodes so they can easily be found from the SplitterNode.
#
attr_inn = libAttr.addAttr(grp_splitter_inn, longName='inn', attributeType='message')
attr_out = libAttr.addAttr(grp_splitter_out, longName='out', attributeType='message')
pymel.connectAttr(self.node.message, attr_inn)
pymel.connectAttr(self.node.message, attr_out)
#
# Create node networks
# Step 1: Get the jaw displacement in uv space (parameterV only).
#
attr_jaw_circumference = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getJawCircumference'),
input1X=self.attr_inn_jaw_radius,
input2X=(math.pi * 2.0)
).outputX
attr_jaw_open_circle_ratio = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getJawOpenCircleRatio'),
operation=2, # divide
input1X=self.attr_inn_jaw_pt,
input2X=360.0
).outputX
attr_jaw_active_circumference = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getJawActiveCircumference'),
input1X=attr_jaw_circumference,
input2X=attr_jaw_open_circle_ratio
).outputX
attr_jaw_v_range = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getActiveJawRangeInSurfaceSpace'),
operation=2, # divide
input1X=attr_jaw_active_circumference,
input2X=self.attr_inn_surface_range_v
).outputX
#
# Step 2: Resolve the output jaw_ratio
#
# Note that this can throw a zero division warning in Maya.
# To prevent that we'll use some black-magic-ugly-ass-trick.
attr_jaw_ratio_cancelation = libRigging.create_safe_division(
self.attr_inn_surface_v,
attr_jaw_v_range,
nomenclature_rig,
'getJawRatioCancellation'
)
attr_jaw_ratio_out_raw = libRigging.create_utility_node(
'plusMinusAverage',
name=nomenclature_rig.resolve('getJawRatioOutUnlimited'),
operation=2, # substraction,
input1D=(
self.attr_inn_jaw_default_ratio,
attr_jaw_ratio_cancelation
)
).output1D
attr_jaw_ratio_out_limited = libRigging.create_utility_node(
'clamp',
name=nomenclature_rig.resolve('getJawRatioOutLimited'),
inputR=attr_jaw_ratio_out_raw,
minR=0.0,
maxR=1.0
).outputR
#
# Step 3: Resolve attr_out_surface_u & attr_out_surface_v
#
attr_inn_jaw_default_ratio_inv = libRigging.create_utility_node(
'reverse',
name=nomenclature_rig.resolve('getJawDefaultRatioInv'),
inputX=self.attr_inn_jaw_default_ratio
).outputX
util_jaw_uv_default_ratio = libRigging.create_utility_node(
'multiplyDivide',
name=nomenclature_rig.resolve('getJawDefaultRatioUvSpace'),
input1X=self.attr_inn_jaw_default_ratio,
input1Y=attr_inn_jaw_default_ratio_inv,
input2X=attr_jaw_v_range,
input2Y=attr_jaw_v_range
)
attr_jaw_uv_default_ratio = util_jaw_uv_default_ratio.outputX
attr_jaw_uv_default_ratio_inv = util_jaw_uv_default_ratio.outputY
attr_jaw_uv_limit_max = libRigging.create_utility_node(
'plusMinusAverage',
name=nomenclature_rig.resolve('getJawSurfaceLimitMax'),
operation=2, # substract
input1D=(attr_jaw_v_range, attr_jaw_uv_default_ratio_inv)
).output1D
attr_jaw_uv_limit_min = libRigging.create_utility_node(
'plusMinusAverage',
name=nomenclature_rig.resolve('getJawSurfaceLimitMin'),
operation=2, # substract
input1D=(attr_jaw_uv_default_ratio, attr_jaw_v_range)
).output1D
attr_jaw_cancel_range = libRigging.create_utility_node(
'clamp',
name=nomenclature_rig.resolve('getJawCancelRange'),
inputR=self.attr_inn_surface_v,
minR=attr_jaw_uv_limit_min,
maxR=attr_jaw_uv_limit_max
).outputR
attr_out_surface_v_cancelled = libRigging.create_utility_node(
'plusMinusAverage',
name=nomenclature_rig.resolve('getCanceledUv'),
operation=2, # substraction
input1D=(self.attr_inn_surface_v, attr_jaw_cancel_range)
).output1D
#
# Connect output attributes
#
attr_inn_bypass_inv = libRigging.create_utility_node(
'reverse',
name=nomenclature_rig.resolve('getBypassInv'),
inputX=self.attr_inn_bypass
).outputX
# Connect output jaw_ratio
attr_output_jaw_ratio = libRigging.create_utility_node(
'blendWeighted',
input=(attr_jaw_ratio_out_limited, self.attr_inn_jaw_default_ratio),
weight=(attr_inn_bypass_inv, self.attr_inn_bypass)
).output
pymel.connectAttr(attr_output_jaw_ratio, self.attr_out_jaw_ratio)
# Connect output surface u
pymel.connectAttr(self.attr_inn_surface_u, self.attr_out_surface_u)
# Connect output surface_v
attr_output_surface_v = libRigging.create_utility_node(
'blendWeighted',
input=(attr_out_surface_v_cancelled, self.attr_inn_surface_v),
weight=(attr_inn_bypass_inv, self.attr_inn_bypass)
).output
pymel.connectAttr(attr_output_surface_v, self.attr_out_surface_v)
def build(self, attr_holder=None, constraint_handle=False, setup_softik=True, **kwargs):
"""
Build the LegIk system
:param attr_holder: The attribute holder object for all the footroll params
:param kwargs: More kwargs pass to the superclass
:return: Nothing
"""
# Compute ctrl_ik orientation
# Hack: Bypass pymel bug (see https://github.com/LumaPictures/pymel/issues/355)
ctrl_ik_orientation = pymel.datatypes.TransformationMatrix(self._get_reference_plane()).rotate
super(LegIk, self).build(ctrl_ik_orientation=ctrl_ik_orientation, constraint_handle=constraint_handle, setup_softik=setup_softik, **kwargs)
nomenclature_rig = self.get_nomenclature_rig()
jnts = self._chain_ik[self.iCtrlIndex:]
num_jnts = len(jnts)
if num_jnts == 4:
jnt_foot, jnt_heel, jnt_toes, jnt_tip = jnts
elif num_jnts == 3:
jnt_foot, jnt_toes, jnt_tip = jnts
jnt_heel = None
else:
raise Exception("Unexpected number of joints after the limb. Expected 3 or 4, got {0}".format(num_jnts))
# Create FootRoll (chain?)
pos_foot = pymel.datatypes.Point(jnt_foot.getTranslation(space='world'))
pos_heel = pymel.datatypes.Point(jnt_heel.getTranslation(space='world')) if jnt_heel else None
pos_toes = pymel.datatypes.Point(jnt_toes.getTranslation(space='world'))
pos_tip = pymel.datatypes.Point(jnt_tip.getTranslation(space='world'))
# Resolve pivot locations
tm_ref = self._get_reference_plane()
tm_ref_dir = pymel.datatypes.Matrix( # Used to compute raycast directions
tm_ref.a00, tm_ref.a01, tm_ref.a02, tm_ref.a03,
tm_ref.a10, tm_ref.a11, tm_ref.a12, tm_ref.a13,
tm_ref.a20, tm_ref.a21, tm_ref.a22, tm_ref.a23,
0, 0, 0, 1
)
#
# Resolve pivot positions
#
geometries = self.rig.get_meshes()
# Resolve pivot inn
if self.pivot_foot_inn_pos:
pos_pivot_inn = pymel.datatypes.Point(self.pivot_foot_inn_pos) * tm_ref
else:
pos_pivot_inn = self._get_recommended_pivot_bank(geometries, tm_ref, tm_ref_dir, pos_toes, direction=-1)
# Resolve pivot bank out
if self.pivot_foot_out_pos:
pos_pivot_out = pymel.datatypes.Point(self.pivot_foot_out_pos) * tm_ref
else:
pos_pivot_out = self._get_recommended_pivot_bank(geometries, tm_ref, tm_ref_dir, pos_toes, direction=1)
# Resolve pivot Back
if self.pivot_foot_back_pos:
pos_pivot_back = pymel.datatypes.Point(self.pivot_foot_back_pos) * tm_ref
else:
pos_pivot_back = self._get_recommended_pivot_back(geometries, tm_ref, tm_ref_dir, pos_toes)
# Set pivot Front
if self.pivot_foot_front_pos:
pos_pivot_front = pymel.datatypes.Point(self.pivot_foot_front_pos) * tm_ref
else:
pos_pivot_front = self._get_recommended_pivot_front(geometries, tm_ref, tm_ref_dir, pos_toes, pos_tip)
# Set pivot Ankle
if self.pivot_toes_ankle_pos:
pos_pivot_ankle = pymel.datatypes.Point(self.pivot_toes_ankle_pos) * tm_ref
else:
pos_pivot_ankle = pos_toes
# Set pivot Heel floor
if self.pivot_toes_heel_pos:
pos_pivot_heel = pymel.datatypes.Point(self.pivot_toes_heel_pos) * tm_ref
else:
if jnt_heel:
pos_pivot_heel = pos_heel
else:
pos_pivot_heel = pymel.datatypes.Point(pos_foot)
pos_pivot_heel.y = 0
#
# Build Setup
#
root_footRoll = pymel.createNode('transform', name=nomenclature_rig.resolve('footRoll'))
# Align all pivots to the reference plane
root_footRoll.setMatrix(tm_ref)
# Create pivots hierarchy
self.pivot_toes_heel = pymel.spaceLocator(name=nomenclature_rig.resolve('pivotToesHeel'))
self.pivot_toes_ankle = pymel.spaceLocator(name=nomenclature_rig.resolve('pivotToesAnkle'))
self.pivot_foot_ankle = pymel.spaceLocator(name=nomenclature_rig.resolve('pivotFootAnkle'))
self.pivot_foot_front = pymel.spaceLocator(name=nomenclature_rig.resolve('pivotFootFront'))
self.pivot_foot_back = pymel.spaceLocator(name=nomenclature_rig.resolve('pivotFootBack'))
self.pivot_foot_inn = pymel.spaceLocator(name=nomenclature_rig.resolve('pivotFootBankInn'))
self.pivot_foot_out = pymel.spaceLocator(name=nomenclature_rig.resolve('pivotFootBankOut'))
self.pivot_foot_heel = pymel.spaceLocator(name=nomenclature_rig.resolve('pivotFootHeel'))
self.pivot_foot_toes_fk = pymel.spaceLocator(name=nomenclature_rig.resolve('pivotToesFkRoll'))
chain_footroll = [
root_footRoll,
self.pivot_foot_ankle,
self.pivot_foot_inn,
self.pivot_foot_out,
self.pivot_foot_back,
self.pivot_foot_heel,
self.pivot_foot_front,
self.pivot_toes_ankle,
self.pivot_toes_heel
]
libRigging.create_hyerarchy(chain_footroll)
chain_footroll[0].setParent(self.grp_rig)
self.pivot_foot_toes_fk.setParent(self.pivot_foot_heel)
self.pivot_foot_ankle.setTranslation(pos_pivot_ankle, space='world')
self.pivot_foot_inn.setTranslation(pos_pivot_inn, space='world')
self.pivot_foot_out.setTranslation(pos_pivot_out, space='world')
self.pivot_foot_back.setTranslation(pos_pivot_back, space='world')
self.pivot_foot_heel.setTranslation(pos_pivot_heel, space='world')
self.pivot_foot_front.setTranslation(pos_pivot_front, space='world')
self.pivot_toes_ankle.setTranslation(pos_pivot_ankle, space='world')
self.pivot_foot_toes_fk.setTranslation(pos_pivot_ankle, space='world')
self.pivot_toes_heel.setTranslation(pos_pivot_heel, space='world')
# Create attributes
attr_holder = self.ctrl_ik
libAttr.addAttr_separator(attr_holder, 'footRoll', niceName='Foot Roll')
attr_inn_roll_auto = libAttr.addAttr(attr_holder, longName='rollAuto', k=True)
attr_inn_roll_auto_threshold = libAttr.addAttr(attr_holder, longName='rollAutoThreshold', k=True, defaultValue=25)
attr_inn_bank = libAttr.addAttr(attr_holder, longName='bank', k=True)
attr_inn_ankle_rotz = libAttr.addAttr(attr_holder, longName=self.ANKLE_ROTZ_LONGNAME, niceName=self.ANKLE_ROTZ_NICENAME, k=True, hasMinValue=True, hasMaxValue=True, minValue=-90, maxValue=90)
attr_inn_back_rotx = libAttr.addAttr(attr_holder, longName=self.BACK_ROTX_LONGNAME, niceName=self.BACK_ROTX_NICENAME, k=True, hasMinValue=True, hasMaxValue=True, minValue=-90, maxValue=0)
attr_inn_ankle_rotx = libAttr.addAttr(attr_holder, longName=self.ANKLE_ROTX_LONGNAME, niceName=self.ANKLE_ROTX_NICENAME, k=True, hasMinValue=True, hasMaxValue=True, minValue=0, maxValue=90)
attr_inn_front_rotx = libAttr.addAttr(attr_holder, longName=self.FRONT_ROTX_LONGNAME, niceName=self.FRONT_ROTX_NICENAME, k=True, hasMinValue=True, hasMaxValue=True, minValue=0, maxValue=90)
attr_inn_back_roty = libAttr.addAttr(attr_holder, longName=self.BACK_ROTY_LONGNAME, niceName=self.BACK_ROTY_NICENAME, k=True, hasMinValue=True, hasMaxValue=True, minValue=-90, maxValue=90)
attr_inn_heel_roty = libAttr.addAttr(attr_holder, longName=self.HEEL_ROTY_LONGNAME, niceName=self.HEEL_ROTY_NICENAME, k=True, hasMinValue=True, hasMaxValue=True, minValue=-90, maxValue=90)
attr_inn_toes_roty = libAttr.addAttr(attr_holder, longName=self.TOES_ROTY_LONGNAME, niceName=self.TOES_ROTY_NICENAME, k=True, hasMinValue=True, hasMaxValue=True, minValue=-90, maxValue=90)
attr_inn_front_roty = libAttr.addAttr(attr_holder, longName=self.FRONT_ROTY_LONGNAME, niceName=self.FRONT_ROTY_NICENAME, k=True, hasMinValue=True, hasMaxValue=True, minValue=-90, maxValue=90)
attr_inn_toes_fk_rotx = libAttr.addAttr(attr_holder, longName=self.TOESFK_ROTX_LONGNAME, niceName=self.TOESFK_ROTX_NICENAME, k=True, hasMinValue=True, hasMaxValue=True, minValue=-90, maxValue=90)
attr_roll_auto_pos = libRigging.create_utility_node('condition', operation=2, firstTerm=attr_inn_roll_auto,
secondTerm=0,
colorIfTrueR=attr_inn_roll_auto,
colorIfFalseR=0.0).outColorR # Greater
attr_roll_auto_f = libRigging.create_utility_node('condition', operation=2,
firstTerm=attr_inn_roll_auto,
secondTerm=attr_inn_roll_auto_threshold,
colorIfFalseR=0,
colorIfTrueR=(
libRigging.create_utility_node('plusMinusAverage',
operation=2,
input1D=[
attr_inn_roll_auto,
attr_inn_roll_auto_threshold]).output1D)
).outColorR # Substract
attr_roll_auto_b = libRigging.create_utility_node('condition', operation=2, firstTerm=attr_inn_roll_auto,
secondTerm=0.0,
colorIfTrueR=0, colorIfFalseR=attr_inn_roll_auto
).outColorR # Greater
attr_roll_m = libRigging.create_utility_node('addDoubleLinear', input1=attr_roll_auto_pos,
input2=attr_inn_ankle_rotx).output
attr_roll_f = libRigging.create_utility_node('addDoubleLinear', input1=attr_roll_auto_f,
input2=attr_inn_front_rotx).output
attr_roll_b = libRigging.create_utility_node('addDoubleLinear', input1=attr_roll_auto_b,
input2=attr_inn_back_rotx).output
attr_bank_inn = libRigging.create_utility_node('condition', operation=2,
firstTerm=attr_inn_bank, secondTerm=0,
colorIfTrueR=attr_inn_bank,
colorIfFalseR=0.0
).outColorR # Greater
attr_bank_out = libRigging.create_utility_node('condition', operation=4,
firstTerm=attr_inn_bank, secondTerm=0,
colorIfTrueR=attr_inn_bank,
colorIfFalseR=0.0).outColorR # Less
pymel.connectAttr(attr_roll_m, self.pivot_toes_ankle.rotateX)
pymel.connectAttr(attr_roll_f, self.pivot_foot_front.rotateX)
pymel.connectAttr(attr_roll_b, self.pivot_foot_back.rotateX)
pymel.connectAttr(attr_bank_inn, self.pivot_foot_inn.rotateZ)
pymel.connectAttr(attr_bank_out, self.pivot_foot_out.rotateZ)
pymel.connectAttr(attr_inn_heel_roty, self.pivot_foot_heel.rotateY)
pymel.connectAttr(attr_inn_front_roty, self.pivot_foot_front.rotateY)
pymel.connectAttr(attr_inn_back_roty, self.pivot_foot_back.rotateY)
pymel.connectAttr(attr_inn_ankle_rotz, self.pivot_toes_heel.rotateZ)
pymel.connectAttr(attr_inn_toes_roty, self.pivot_foot_ankle.rotateY)
pymel.connectAttr(attr_inn_toes_fk_rotx, self.pivot_foot_toes_fk.rotateX)
# Create ikHandles and parent them
# Note that we are directly parenting them so the 'Preserve Child Transform' of the translate tool still work.
if jnt_heel:
ikHandle_foot, ikEffector_foot = pymel.ikHandle(startJoint=jnt_foot, endEffector=jnt_heel, solver='ikSCsolver')
else:
ikHandle_foot, ikEffector_foot = pymel.ikHandle(startJoint=jnt_foot, endEffector=jnt_toes, solver='ikSCsolver')
ikHandle_foot.rename(nomenclature_rig.resolve('ikHandle', 'foot'))
ikHandle_foot.setParent(self.grp_rig)
ikHandle_foot.setParent(self.pivot_toes_heel)
if jnt_heel:
ikHandle_heel, ikEffector_foot = pymel.ikHandle(startJoint=jnt_heel, endEffector=jnt_toes, solver='ikSCsolver')
ikHandle_heel.rename(nomenclature_rig.resolve('ikHandle', 'heel'))
ikHandle_heel.setParent(self.grp_rig)
ikHandle_heel.setParent(self.pivot_foot_front)
ikHandle_toes, ikEffector_toes = pymel.ikHandle(startJoint=jnt_toes, endEffector=jnt_tip, solver='ikSCsolver')
ikHandle_toes.rename(nomenclature_rig.resolve('ikHandle', 'toes'))
ikHandle_toes.setParent(self.grp_rig)
ikHandle_toes.setParent(self.pivot_foot_toes_fk)
# Hack: Re-constraint foot ikhandle
# todo: cleaner!
pymel.parentConstraint(self.ctrl_ik, root_footRoll, maintainOffset=True)
# Connect the footroll to the main ikHandle
# Note that we also need to hijack the softik network.
fn_can_delete = lambda x: isinstance(x, pymel.nodetypes.Constraint) and \
not isinstance(x, pymel.nodetypes.PoleVectorConstraint)
pymel.delete(filter(fn_can_delete, self._ik_handle_target.getChildren()))
if jnt_heel:
pymel.parentConstraint(self.pivot_toes_heel, self._ik_handle_target, maintainOffset=True)
else:
pymel.parentConstraint(self.pivot_toes_ankle, self._ik_handle_target, maintainOffset=True)
'''
# Constraint swivel to ctrl_ik
pymel.parentConstraint(self.ctrl_ik, self.ctrl_swivel,
maintainOffset=True) # TODO: Implement SpaceSwitch
'''
# Handle globalScale
pymel.connectAttr(self.grp_rig.globalScale, root_footRoll.scaleX)
pymel.connectAttr(self.grp_rig.globalScale, root_footRoll.scaleY)
pymel.connectAttr(self.grp_rig.globalScale, root_footRoll.scaleZ)
def build_stack(self, stack, mult_u=1.0, mult_v=1.0):
"""
The dag stack is a chain of transform nodes daisy chained together that computer the final transformation of the influence.
The decision of using transforms instead of multMatrix nodes is for clarity.
Note also that because of it's parent (the offset node) the stack relative to the influence original translation.
"""
# TODO: Maybe use sub-classing to differenciate when we need to use a surface or not.
nomenclature_rig = self.get_nomenclature_rig()
#
# Extract the base U and V of the base influence using the stack parent. (the 'offset' node)
#
surface_shape = self.surface.getShape()
util_get_base_uv_absolute = libRigging.create_utility_node(
'closestPointOnSurface',
inPosition=self._grp_offset.t,
inputSurface=surface_shape.worldSpace
)
util_get_base_uv_normalized = libRigging.create_utility_node(
'setRange',
oldMinX=surface_shape.minValueU,
oldMaxX=surface_shape.maxValueU,
oldMinY=surface_shape.minValueV,
oldMaxY=surface_shape.maxValueV,
minX=0,
maxX=1,
minY=0,
maxY=1,
valueX=util_get_base_uv_absolute.parameterU,
valueY=util_get_base_uv_absolute.parameterV
)
attr_base_u_normalized = util_get_base_uv_normalized.outValueX
attr_base_v_normalized = util_get_base_uv_normalized.outValueY
self._attr_u_base = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_U_BASE, defaultValue=attr_base_u_normalized.get())
self._attr_v_base = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_V_BASE, defaultValue=attr_base_v_normalized.get())
pymel.connectAttr(attr_base_u_normalized, self.grp_rig.attr(self._ATTR_NAME_U_BASE))
pymel.connectAttr(attr_base_v_normalized, self.grp_rig.attr(self._ATTR_NAME_V_BASE))
#
# Create follicle setup
# The setup is composed of two follicles.
# One for the "bind pose" and one "driven" by the avars..
# The delta between the "bind pose" and the "driven" follicles is then applied to the influence.
#
# Determine the follicle U and V on the reference nurbsSurface.
# jnt_pos = self.jnt.getTranslation(space='world')
# fol_pos, fol_u, fol_v = libRigging.get_closest_point_on_surface(self.surface, jnt_pos)
base_u_val = self._attr_u_base.get()
base_v_val = self._attr_v_base.get()
# Resolve the length of each axis of the surface
self._attr_length_u, self._attr_length_v, arcdimension_shape = libRigging.create_arclengthdimension_for_nurbsplane(self.surface)
arcdimension_transform = arcdimension_shape.getParent()
arcdimension_transform.rename(nomenclature_rig.resolve('arcdimension'))
arcdimension_transform.setParent(self.grp_rig)
#
# Create two follicle.
# - influenceFollicle: Affected by the ud and lr Avar
# - bindPoseFollicle: A follicle that stay in place and keep track of the original position.
# We'll then compute the delta of the position of the two follicles.
# This allow us to move or resize the plane without affecting the built rig. (if the rig is in neutral pose)
#
offset_name = nomenclature_rig.resolve('bindPoseRef')
obj_offset = pymel.createNode('transform', name=offset_name)
obj_offset.setParent(self._grp_offset)
fol_offset_name = nomenclature_rig.resolve('bindPoseFollicle')
# fol_offset = libRigging.create_follicle(obj_offset, self.surface, name=fol_offset_name)
fol_offset_shape = libRigging.create_follicle2(self.surface, u=base_u_val, v=base_v_val)
fol_offset = fol_offset_shape.getParent()
fol_offset.rename(fol_offset_name)
pymel.parentConstraint(fol_offset, obj_offset, maintainOffset=False)
fol_offset.setParent(self.grp_rig)
# Create the influence follicle
influence_name = nomenclature_rig.resolve('influenceRef')
influence = pymel.createNode('transform', name=influence_name)
influence.setParent(self._grp_offset)
fol_influence_name = nomenclature_rig.resolve('influenceFollicle')
fol_influence_shape = libRigging.create_follicle2(self.surface, u=base_u_val, v=base_v_val)
fol_influence = fol_influence_shape.getParent()
fol_influence.rename(fol_influence_name)
pymel.parentConstraint(fol_influence, influence, maintainOffset=False)
fol_influence.setParent(self.grp_rig)
#
# Extract the delta of the influence follicle and it's initial pose follicle
#
attr_localTM = libRigging.create_utility_node('multMatrix', matrixIn=[
influence.worldMatrix,
obj_offset.worldInverseMatrix
]).matrixSum
# Since we are extracting the delta between the influence and the bindpose matrix, the rotation of the surface
# is not taken in consideration wich make things less intuitive for the rigger.
# So we'll add an adjustement matrix so the rotation of the surface is taken in consideration.
util_decomposeTM_bindPose = libRigging.create_utility_node('decomposeMatrix',
inputMatrix=obj_offset.worldMatrix
)
attr_translateTM = libRigging.create_utility_node('composeMatrix',
inputTranslate=util_decomposeTM_bindPose.outputTranslate
).outputMatrix
attr_translateTM_inv = libRigging.create_utility_node('inverseMatrix',
inputMatrix=attr_translateTM,
).outputMatrix
attr_rotateTM = libRigging.create_utility_node('multMatrix',
matrixIn=[obj_offset.worldMatrix, attr_translateTM_inv]
).matrixSum
attr_rotateTM_inv = libRigging.create_utility_node('inverseMatrix',
inputMatrix=attr_rotateTM
).outputMatrix
attr_finalTM = libRigging.create_utility_node('multMatrix',
matrixIn=[attr_rotateTM_inv,
attr_localTM,
attr_rotateTM]
).matrixSum
util_decomposeTM = libRigging.create_utility_node('decomposeMatrix',
inputMatrix=attr_finalTM
)
#
# Resolve the parameterU and parameterV
#
self._attr_u_mult_inn = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_U_MULT, defaultValue=self._AVAR_DEFAULT_MULTIPLIER_U)
self._attr_v_mult_inn = libAttr.addAttr(self.grp_rig, longName=self._ATTR_NAME_V_MULT, defaultValue=self._AVAR_DEFAULT_MULTIPLIER_V)
attr_u_inn, attr_v_inn = self._get_follicle_absolute_uv_attr()
#
# Create the 1st (follicleLayer) that will contain the extracted position from the ud and lr Avar.
#
layer_follicle = stack.append_layer('follicleLayer')
pymel.connectAttr(util_decomposeTM.outputTranslate, layer_follicle.translate)
pymel.connectAttr(attr_u_inn, fol_influence.parameterU)
pymel.connectAttr(attr_v_inn, fol_influence.parameterV)
pymel.connectAttr(self._attr_u_base, fol_offset.parameterU)
pymel.connectAttr(self._attr_v_base, fol_offset.parameterV)
#
# The second layer (oobLayer for out-of-bound) that allow the follicle to go outside it's original plane.
# If the UD value is out the nurbsPlane UV range (0-1), ie 1.1, we'll want to still offset the follicle.
# For that we'll compute a delta between a small increment (0.99 and 1.0) and multiply it.
#
nomenclature_rig = self.get_nomenclature_rig()
oob_step_size = 0.001 # TODO: Expose a Maya attribute?
fol_clamped_v_name = nomenclature_rig.resolve('influenceClampedV')
fol_clamped_v_shape = libRigging.create_follicle2(self.surface, u=base_u_val, v=base_v_val)
fol_clamped_v = fol_clamped_v_shape.getParent()
fol_clamped_v.rename(fol_clamped_v_name)
fol_clamped_v.setParent(self.grp_rig)
fol_clamped_u_name = nomenclature_rig.resolve('influenceClampedU')
fol_clamped_u_shape = libRigging.create_follicle2(self.surface, u=base_u_val, v=base_v_val)
fol_clamped_u = fol_clamped_u_shape.getParent()
fol_clamped_u.rename(fol_clamped_u_name)
fol_clamped_u.setParent(self.grp_rig)
# Clamp the values so they never fully reach 0 or 1 for U and V.
util_clamp_uv = libRigging.create_utility_node('clamp',
inputR=attr_u_inn,
inputG=attr_v_inn,
minR=oob_step_size,
minG=oob_step_size,
maxR=1.0 - oob_step_size,
maxG=1.0 - oob_step_size)
clamped_u = util_clamp_uv.outputR
clamped_v = util_clamp_uv.outputG
pymel.connectAttr(clamped_v, fol_clamped_v.parameterV)
pymel.connectAttr(attr_u_inn, fol_clamped_v.parameterU)
pymel.connectAttr(attr_v_inn, fol_clamped_u.parameterV)
pymel.connectAttr(clamped_u, fol_clamped_u.parameterU)
# Compute the direction to add for U and V if we are out-of-bound.
dir_oob_u = libRigging.create_utility_node('plusMinusAverage',
operation=2,
input3D=[
fol_influence.translate,
fol_clamped_u.translate
]).output3D
dir_oob_v = libRigging.create_utility_node('plusMinusAverage',
operation=2,
input3D=[
fol_influence.translate,
fol_clamped_v.translate
]).output3D
# Compute the offset to add for U and V
condition_oob_u_neg = libRigging.create_utility_node('condition',
operation=4, # less than
firstTerm=attr_u_inn,
secondTerm=0.0,
colorIfTrueR=1.0,
colorIfFalseR=0.0,
).outColorR
condition_oob_u_pos = libRigging.create_utility_node('condition', # greater than
operation=2,
firstTerm=attr_u_inn,
secondTerm=1.0,
colorIfTrueR=1.0,
colorIfFalseR=0.0,
).outColorR
condition_oob_v_neg = libRigging.create_utility_node('condition',
operation=4, # less than
firstTerm=attr_v_inn,
secondTerm=0.0,
colorIfTrueR=1.0,
colorIfFalseR=0.0,
).outColorR
condition_oob_v_pos = libRigging.create_utility_node('condition', # greater than
operation=2,
firstTerm=attr_v_inn,
secondTerm=1.0,
colorIfTrueR=1.0,
colorIfFalseR=0.0,
).outColorR
# Compute the amount of oob
oob_val_u_pos = libRigging.create_utility_node('plusMinusAverage', operation=2,
input1D=[attr_u_inn, 1.0]).output1D
oob_val_u_neg = libRigging.create_utility_node('multiplyDivide', input1X=attr_u_inn, input2X=-1.0).outputX
oob_val_v_pos = libRigging.create_utility_node('plusMinusAverage', operation=2,
input1D=[attr_v_inn, 1.0]).output1D
oob_val_v_neg = libRigging.create_utility_node('multiplyDivide', input1X=attr_v_inn, input2X=-1.0).outputX
oob_val_u = libRigging.create_utility_node('condition', operation=0, firstTerm=condition_oob_u_pos,
secondTerm=1.0, colorIfTrueR=oob_val_u_pos,
colorIfFalseR=oob_val_u_neg).outColorR
oob_val_v = libRigging.create_utility_node('condition', operation=0, firstTerm=condition_oob_v_pos,
secondTerm=1.0, colorIfTrueR=oob_val_v_pos,
colorIfFalseR=oob_val_v_neg).outColorR
oob_amount_u = libRigging.create_utility_node('multiplyDivide', operation=2, input1X=oob_val_u,
input2X=oob_step_size).outputX
oob_amount_v = libRigging.create_utility_node('multiplyDivide', operation=2, input1X=oob_val_v,
input2X=oob_step_size).outputX
oob_offset_u = libRigging.create_utility_node('multiplyDivide', input1X=oob_amount_u, input1Y=oob_amount_u,
input1Z=oob_amount_u, input2=dir_oob_u).output
oob_offset_v = libRigging.create_utility_node('multiplyDivide', input1X=oob_amount_v, input1Y=oob_amount_v,
input1Z=oob_amount_v, input2=dir_oob_v).output
# Add the U out-of-bound-offset only if the U is between 0.0 and 1.0
oob_u_condition_1 = condition_oob_u_neg
oob_u_condition_2 = condition_oob_u_pos
oob_u_condition_added = libRigging.create_utility_node('addDoubleLinear',
input1=oob_u_condition_1,
input2=oob_u_condition_2
).output
oob_u_condition_out = libRigging.create_utility_node('condition',
operation=0, # equal
firstTerm=oob_u_condition_added,
secondTerm=1.0,
colorIfTrue=oob_offset_u,
colorIfFalse=[0, 0, 0]
).outColor
# Add the V out-of-bound-offset only if the V is between 0.0 and 1.0
oob_v_condition_1 = condition_oob_v_neg
oob_v_condition_2 = condition_oob_v_pos
oob_v_condition_added = libRigging.create_utility_node('addDoubleLinear',
input1=oob_v_condition_1,
input2=oob_v_condition_2
).output
oob_v_condition_out = libRigging.create_utility_node('condition',
operation=0, # equal
firstTerm=oob_v_condition_added,
secondTerm=1.0,
colorIfTrue=oob_offset_v,
colorIfFalse=[0, 0, 0]
).outColor
oob_offset = libRigging.create_utility_node('plusMinusAverage',
input3D=[oob_u_condition_out, oob_v_condition_out]).output3D
layer_oob = stack.append_layer('oobLayer')
pymel.connectAttr(oob_offset, layer_oob.t)
#
# Create the third layer that apply the translation provided by the fb Avar.
#
layer_fb = stack.append_layer('fbLayer')
attr_get_fb = libRigging.create_utility_node('multiplyDivide',
input1X=self.attr_fb,
input2X=self._attr_length_u).outputX
attr_get_fb_adjusted = libRigging.create_utility_node('multiplyDivide',
input1X=attr_get_fb,
input2X=0.1).outputX
pymel.connectAttr(attr_get_fb_adjusted, layer_fb.translateZ)
#
# Create the 4th layer (folRot) that apply the rotation provided by the follicle controlled by the ud and lr Avar.
# This is necessary since we don't want to rotation to affect the oobLayer and fbLayer.
#
layer_follicle_rot = stack.append_layer('folRot')
pymel.connectAttr(util_decomposeTM.outputRotate, layer_follicle_rot.rotate)
#
# Create a 5th layer that apply the yw, pt, rl and Avar.
#
layer_rot = stack.append_layer('rotLayer')
pymel.connectAttr(self.attr_yw, layer_rot.rotateY)
pymel.connectAttr(self.attr_pt, layer_rot.rotateX)
pymel.connectAttr(self.attr_rl, layer_rot.rotateZ)
return stack