def getMatrixFromVector(forward, up=None, forward_axis='z', location=None):
"""
Creates a rotation from given forward direction and up direction. Which is then used to calculate a matrix.
Args:
forward (Any): Vector that faces forward.
up (Any): Vector that faces up. If none given will use scene up axis.
forward_axis (string): What local vector will face forward in the matrix.
location (Any): Where the matrix should be in world space. If none given, will be at origin.
Returns:
(pm.nodetypes.Matrix): Matrix calculated from given forward vector.
"""
scene_up = pm.upAxis(axis=True, q=True)
scene_up = convert.axisToVector(scene_up)
up = convert.toVector(up, invalid_default=scene_up)
right = forward.cross(up).normal()
up = right.cross(forward).normal()
matrix = []
if forward_axis == 'x':
matrix = [forward.get(), up.get(), right.get()]
elif forward_axis == 'y':
matrix = [up.get(), forward.get(), right.get()]
elif forward_axis == 'z':
matrix = [(right * -1).get(), up.get(), forward.get()]
location = convert.toVector(location, invalid_default=True)
matrix.append(location)
return pm.dt.Matrix(*matrix)
def calcOutVector(start, middle, end):
'''
Given the lead joint of 3, determine the vector pointing directly away along the xz plane.
.. todo::
Gracefully handle if the ik is on the xz plane already.
'''
s = dt.Vector(xform(start, q=1, ws=1, t=1))
m = dt.Vector(xform(middle, q=1, ws=1, t=1))
e = dt.Vector(xform(end, q=1, ws=1, t=1))
up = s - e
if upAxis(q=True, ax=True) == 'y':
kneeScale = (m.y - e.y) / up.y if up.y else 0.0
else:
kneeScale = (m.z - e.z) / up.z if up.z else 0.0
modifiedUp = kneeScale * up
newPos = modifiedUp + e
outFromKnee = m - newPos
angleBetween = (m - s).angle(e - m)
log.TooStraight.check(angleBetween)
outFromKnee.normalize()
return outFromKnee
def create_rig(self, parent):
# -- We're given the skeleton component instance, so we can
# -- utilise the find method to find the joint we need to build
# -- a control against
root_joint = self.find_first('RootJoint')
# -- Create a transform to use as a control
root_control = crab.create.control(
description='Rig%s' % self.options.description,
side=self.options.side,
parent=parent,
match_to=root_joint,
shape='cog',
lock_list=self.options.lock,
hide_list=self.options.hide,
)
location_control = crab.create.control(
description='%s' % self.options.description,
side=self.options.side,
parent=root_control,
match_to=root_control,
shape='arrow_x',
lock_list=self.options.lock,
hide_list=self.options.hide,
)
print('---')
if pm.upAxis(q=True, axis=True).upper() == 'Y':
crab.utils.shapes.spin(location_control, y=-90)
# -- All joints should have a binding. The binding allows crab
# -- to know what control parent to utilise when building skeletal
# -- components.
# -- The act of binding also constrains the skeleton joint to the
# -- control
self.bind(
root_joint,
root_control,
constrain=False,
)
# -- Constrain the joint to the location
pm.parentConstraint(
location_control,
root_joint,
mo=False,
)
# -- Constrain the joint to the location
pm.scaleConstraint(
location_control,
root_joint,
mo=False,
)
# -- Select our tip joint
pm.select(root_control)
return True
def get_likely_mirror_plane(node):
"""
Looks at the worldspace transform of a node and returns a mirror
plane string of either XY, YZ or XZ
The worldspace translation of the node is used to determine this.
:param node: Node to test
:type node: pm.nt.Transform
:return: str
"""
position = [abs(n) for n in node.getTranslation(node, worldSpace=True)]
# -- We're only interested in a two dimensional plane, so pop
# -- out the Y axis
if pm.upAxis(q=True, axis=True) == 'y':
position.pop(1)
else:
position.pop(2)
# -- Of the X and Z plane, get the prominent one
prominent_axis = position.index(max(position))
if prominent_axis == 0:
return 'YZ'
else:
return 'XZ'
def refine_from_up_axis(position, up_axis='z'):
"""
This will take a position vector, and alter it if the up axis is
set to Z. This is because it is assumed that all shapes are drawn
within a Y-Up orientation.
:param position: List of length3
:return: List of length 3
"""
# -- Get the current axis setting
current_up_axis = pm.upAxis(q=True, axis=True)
# -- If we're working in the same axis space as the stored shape
# -- then we can simply return the list as it is
if current_up_axis == up_axis:
return position
# -- We now have to wrangle the data
altered_position = [
position[0],
position[2],
position[1] * -1,
]
return altered_position
def calcOutVector(start, middle, end):
'''
Given the lead joint of 3, determine the vector pointing directly away along the xz plane.
.. todo::
Gracefully handle if the ik is on the xz plane already.
'''
s = dt.Vector(xform(start, q=1, ws=1, t=1))
m = dt.Vector(xform(middle, q=1, ws=1, t=1))
e = dt.Vector(xform(end, q=1, ws=1, t=1))
up = s - e
if upAxis(q=True, ax=True) == 'y':
kneeScale = (m.y - e.y) / up.y if up.y else 0.0
else:
kneeScale = (m.z - e.z) / up.z if up.z else 0.0
modifiedUp = kneeScale * up
newPos = modifiedUp + e
outFromKnee = m - newPos
outFromKnee.normalize()
# If we are halfway to the x/z plane, lerp between the old formula and a new one
testUp = dt.Vector(up)
if testUp.y < 0:
testUp.y *= -1.0
angleToVertical = dt.Vector(0, 1, 0).angle(testUp)
if angleToVertical > _45_DEGREES:
# Calculate a point perpendicular to the line created by the start and end
# going through the middle
theta = up.angle(m - e)
distToMidpoint = math.cos(theta) * (m - e).length()
midPoint = distToMidpoint * up.normal() + e
altOutFromKnee = m - midPoint
altOutFromKnee.normalize()
# lerp between the vectors
percent = (
angleToVertical - _45_DEGREES
) / _45_DEGREES # 45 to up axis will favor old, on y axis favors new
outFromKnee = slerp(outFromKnee, altOutFromKnee, percent)
angleBetween = (m - s).angle(e - m)
log.TooStraight.check(angleBetween)
outFromKnee.normalize()
return outFromKnee
def read(node):
"""
Looks at all the NurbsCurve shape nodes under the given node
and attempts to read them
"""
shapes = list()
# -- If we have a transform, add any nurbs curves
# -- from it
for shape in node.getShapes():
if isinstance(shape, pm.nt.NurbsCurve):
shapes.append(shape)
if not shapes:
return None
# -- Define out output data. Right now we're only storing
# -- cv's, but we wrap it in a dict so we can expand it
# -- later without compatibility issues.
data = dict(
node=node.name(),
curves=list(),
up_axis=pm.upAxis(q=True, axis=True),
)
# -- Cycle the shapes and store thm
for shape in shapes:
node_data = dict(cvs=list(),
form=shape.f.get(),
degree=shape.degree(),
knots=shape.getKnots())
# -- Collect the positional data to an accuracy that is
# -- reasonable.
for cv in shape.getCVs():
node_data['cvs'].append([round(value, 5) for value in cv])
data['curves'].append(node_data)
return data
def resolve_translation(vector):
"""
This assumes a list of length 3 in the order of X, Y, Z where Y is considered the
'up axis'. If the up axis of the application is indeed Y, then the vector is returned
untouched. However, if the up-axis is Z then the vector is mutated.
:param vector: Translation vector
:type vector: list(x, y, z)
:return: list(float, float, float)
"""
if pm.upAxis(q=True, axis=True) == 'y':
return vector
return [
vector[2],
vector[0],
vector[1],
]
def getMatrixFromVector(forward, up=None, forward_axis='z', location=None):
"""
Creates a rotation from given forward direction and up direction. Which is then used to calculate a matrix.
Args:
forward (Any): Vector that faces forward.
up (Any): Vector that faces up. If none given will use scene up axis.
forward_axis (string): What local vector will face forward in the matrix.
location (Any): Where the matrix should be in world space. If none given, will be at origin.
Returns:
(pm.nodetypes.Matrix): Matrix calculated from given forward vector.
"""
if isinstance(up, (list, tuple)):
up = pm.dt.Vector(up)
elif isinstance(up, str):
up = pm.dt.Vector(convert.axisToVector(up))
elif isinstance(up, pm.dt.Vector):
pass
else:
up = pm.upAxis(axis=True, q=True)
up = pm.dt.Vector(convert.axisToVector(up))
right = forward.cross(up).normal()
up = right.cross(forward).normal()
coordinates = []
if forward_axis == 'x':
coordinates = [forward.get(), up.get(), right.get()]
elif forward_axis == 'y':
coordinates = [up.get(), forward.get(), right.get()]
elif forward_axis == 'z':
coordinates = [(right * -1).get(), up.get(), forward.get()]
location = convert.toVector(location, invalid_zero=True)
coordinates.append(location)
return pm.dt.Matrix(*coordinates)
def addObjects(self):
"""Add all the objects needed to create the component."""
self.WIP = self.options["mode"]
self.up_axis = pm.upAxis(q=True, axis=True)
self.normal = self.getNormalFromPos(self.guide.apos)
self.length0 = vector.getDistance(
self.guide.apos[0], self.guide.apos[1])
self.length1 = vector.getDistance(
self.guide.apos[1], self.guide.apos[2])
self.length2 = vector.getDistance(
self.guide.apos[2], self.guide.apos[3])
# 1 bone chain for upv ref
self.legChainUpvRef = primitive.add2DChain(
self.root,
self.getName("legUpvRef%s_jnt"),
[self.guide.apos[0], self.guide.apos[2]],
self.normal,
False,
self.WIP)
self.legChainUpvRef[1].setAttr(
"jointOrientZ",
self.legChainUpvRef[1].getAttr("jointOrientZ") * -1)
# extra neutral pose
t = transform.getTransformFromPos(self.guide.apos[0])
self.root_npo = primitive.addTransform(self.root,
self.getName("root_npo"),
t)
self.root_ctl = self.addCtl(self.root_npo,
"root_ctl",
t,
self.color_fk,
"circle",
w=self.length0 / 6,
tp=self.parentCtlTag)
# FK Controlers -----------------------------------
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
"xz",
self.negate)
if self.settings["FK_rest_T_Pose"]:
if self.negate:
x_dir = 1
else:
x_dir = -1
if self.up_axis == "y":
x = datatypes.Vector(0, x_dir, 0)
else:
x = datatypes.Vector(0, 0, x_dir)
z = datatypes.Vector(-1, 0, 0)
t_npo = transform.getRotationFromAxis(x, z, "xz", False)
t_npo = transform.setMatrixPosition(t_npo, self.guide.apos[0])
else:
t_npo = t
self.fk0_npo = primitive.addTransform(self.root_ctl,
self.getName("fk0_npo"),
t_npo)
po_vec = datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0)
self.fk0_ctl = self.addCtl(self.fk0_npo,
"fk0_ctl",
t,
self.color_fk,
"cube",
w=self.length0,
h=self.size * .1,
d=self.size * .1,
po=po_vec,
tp=self.root_ctl)
attribute.setKeyableAttributes(
self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"])
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[2],
self.normal,
"xz",
self.negate)
if self.settings["FK_rest_T_Pose"]:
t_npo = transform.setMatrixPosition(
transform.getTransform(self.fk0_ctl), self.guide.apos[1])
else:
t_npo = t
self.fk1_npo = primitive.addTransform(
self.fk0_ctl, self.getName("fk1_npo"), t_npo)
po_vec = datatypes.Vector(.5 * self.length1 * self.n_factor, 0, 0)
self.fk1_ctl = self.addCtl(self.fk1_npo,
"fk1_ctl",
t,
self.color_fk,
"cube",
w=self.length1,
h=self.size * .1,
d=self.size * .1,
po=po_vec,
tp=self.fk0_ctl)
attribute.setKeyableAttributes(
self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"])
t = transform.getTransformLookingAt(self.guide.apos[2],
self.guide.apos[3],
self.normal,
"xz",
self.negate)
if self.settings["FK_rest_T_Pose"]:
t_npo = transform.setMatrixPosition(
transform.getTransform(self.fk0_ctl), self.guide.apos[2])
else:
t_npo = t
self.fk2_npo = primitive.addTransform(
self.fk1_ctl, self.getName("fk2_npo"), t_npo)
if self.settings["FK_rest_T_Pose"]:
self.fk2_npo.rz.set(90)
po_vec = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0)
self.fk2_ctl = self.addCtl(self.fk2_npo,
"fk2_ctl",
t,
self.color_fk,
"cube",
w=self.length2,
h=self.size * .1,
d=self.size * .1,
po=po_vec,
tp=self.fk1_ctl)
attribute.setKeyableAttributes(self.fk2_ctl)
self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl]
for x in self.fk_ctl:
attribute.setInvertMirror(x, ["tx", "ty", "tz"])
# IK Controlers -----------------------------------
self.ik_cns = primitive.addTransformFromPos(self.root_ctl,
self.getName("ik_cns"),
self.guide.pos["ankle"])
self.ikcns_ctl = self.addCtl(
self.ik_cns,
"ikcns_ctl",
transform.getTransformFromPos(self.guide.pos["ankle"]),
self.color_ik,
"null",
w=self.size * .12,
tp=self.root_ctl)
attribute.setInvertMirror(self.ikcns_ctl, ["tx"])
# m = transform.getTransformLookingAt(self.guide.pos["ankle"],
# self.guide.pos["eff"],
# self.x_axis,
# "zx",
# False)
# if self.settings["FK_rest_T_Pose"]:
# t_ik = transform.getTransformLookingAt(self.guide.pos["ankle"],
# self.guide.pos["eff"],
# self.normal * -1,
# "zx",
# False)
# else:
t_ik = transform.getTransformFromPos(self.guide.pos["ankle"])
self.ik_ctl = self.addCtl(
self.ikcns_ctl,
"ik_ctl",
t_ik,
self.color_ik,
"cube",
w=self.size * .12,
h=self.size * .12,
d=self.size * .12)
attribute.setKeyableAttributes(self.ik_ctl)
attribute.setRotOrder(self.ik_ctl, "XZY")
attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
# upv
v = self.guide.apos[2] - self.guide.apos[0]
v = self.normal ^ v
v.normalize()
v *= self.size * .5
v += self.guide.apos[1]
self.upv_cns = primitive.addTransformFromPos(self.ik_ctl,
self.getName("upv_cns"),
v)
self.upv_ctl = self.addCtl(
self.upv_cns,
"upv_ctl",
transform.getTransform(self.upv_cns),
self.color_ik,
"diamond",
w=self.size * .12,
tp=self.root_ctl)
self.add_controller_tag(self.ik_ctl, self.upv_ctl)
if self.settings["mirrorMid"]:
if self.negate:
self.upv_cns.rz.set(180)
self.upv_cns.sy.set(-1)
else:
attribute.setInvertMirror(self.upv_ctl, ["tx"])
attribute.setKeyableAttributes(self.upv_ctl, self.t_params)
# References --------------------------------------
self.ik_ref = primitive.addTransform(
self.ik_ctl,
self.getName("ik_ref"),
transform.getTransform(self.ik_ctl))
self.fk_ref = primitive.addTransform(
self.fk_ctl[2],
self.getName("fk_ref"),
transform.getTransform(self.ik_ctl))
# Chain --------------------------------------------
# The outputs of the ikfk2bone solver
self.bone0 = primitive.addLocator(
self.root_ctl,
self.getName("0_bone"),
transform.getTransform(self.fk_ctl[0]))
self.bone0_shp = self.bone0.getShape()
self.bone0_shp.setAttr("localPositionX", self.n_factor * .5)
self.bone0_shp.setAttr("localScale", .5, 0, 0)
self.bone0.setAttr("sx", self.length0)
self.bone0.setAttr("visibility", False)
self.bone1 = primitive.addLocator(
self.root_ctl,
self.getName("1_bone"),
transform.getTransform(self.fk_ctl[1]))
self.bone1_shp = self.bone1.getShape()
self.bone1_shp.setAttr("localPositionX", self.n_factor * .5)
self.bone1_shp.setAttr("localScale", .5, 0, 0)
self.bone1.setAttr("sx", self.length1)
self.bone1.setAttr("visibility", False)
self.ctrn_loc = primitive.addTransformFromPos(self.root_ctl,
self.getName("ctrn_loc"),
self.guide.apos[1])
self.eff_loc = primitive.addTransformFromPos(self.root_ctl,
self.getName("eff_loc"),
self.guide.apos[2])
# tws_ref
t = transform.getRotationFromAxis(
datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["ankle"])
# addind an npo parent transform to fix flip in Maya 2018.2
self.tws_npo = primitive.addTransform(
self.eff_loc, self.getName("tws_npo"), t)
self.tws_ref = primitive.addTransform(
self.tws_npo, self.getName("tws_ref"), t)
# Mid Controler ------------------------------------
t = transform.getTransform(self.ctrn_loc)
self.mid_cns = primitive.addTransform(
self.ctrn_loc, self.getName("mid_cns"), t)
self.mid_ctl = self.addCtl(self.mid_cns,
"mid_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.root_ctl)
attribute.setKeyableAttributes(self.mid_ctl,
params=["tx", "ty", "tz",
"ro", "rx", "ry", "rz",
"sx"])
if self.settings["mirrorMid"]:
if self.negate:
self.mid_cns.rz.set(180)
self.mid_cns.sz.set(-1)
else:
attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"])
# Twist references ---------------------------------
x = datatypes.Vector(0, -1, 0)
x = x * transform.getTransform(self.eff_loc)
z = datatypes.Vector(self.normal.x, self.normal.y, self.normal.z)
z = z * transform.getTransform(self.eff_loc)
m = transform.getRotationFromAxis(x, z, "xz", self.negate)
m = transform.setMatrixPosition(
m, transform.getTranslation(self.ik_ctl))
self.rollRef = primitive.add2DChain(self.root,
self.getName("rollChain"),
self.guide.apos[:2],
self.normal,
self.negate,
self.WIP)
t = transform.getTransformLookingAt(self.guide.pos["base"],
self.guide.apos[1],
self.normal,
"xz",
self.negate)
self.tws0_loc = primitive.addTransform(
self.root_ctl,
self.getName("tws0_loc"),
t)
self.tws0_rot = primitive.addTransform(
self.tws0_loc,
self.getName("tws0_rot"),
t)
self.tws1_loc = primitive.addTransform(
self.ctrn_loc,
self.getName("tws1_loc"),
transform.getTransform(self.ctrn_loc))
self.tws1_rot = primitive.addTransform(
self.tws1_loc,
self.getName("tws1_rot"),
transform.getTransform(self.ctrn_loc))
self.tws2_loc = primitive.addTransform(
self.root_ctl,
self.getName("tws2_loc"),
transform.getTransform(self.tws_ref))
self.tws2_rot = primitive.addTransform(
self.tws2_loc,
self.getName("tws2_rot"),
transform.getTransform(self.tws_ref))
self.tws2_rot.setAttr("sx", .001)
# Divisions ----------------------------------------
self.divisions = self.settings["div0"] + self.settings["div1"] + 2
self.div_cns = []
if self.settings["extraTweak"]:
tagP = self.parentCtlTag
self.tweak_ctl = []
for i in range(self.divisions):
div_cns = primitive.addTransform(self.root_ctl,
self.getName("div%s_loc" % i))
self.div_cns.append(div_cns)
if self.settings["extraTweak"]:
t = transform.getTransform(div_cns)
tweak_ctl = self.addCtl(div_cns,
"tweak%s_ctl" % i,
t,
self.color_fk,
"square",
w=self.size * .15,
d=self.size * .15,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=tagP)
attribute.setKeyableAttributes(tweak_ctl)
tagP = tweak_ctl
self.tweak_ctl.append(tweak_ctl)
driver = tweak_ctl
else:
driver = div_cns
# setting the joints
if i == 0:
self.jnt_pos.append([driver, "thigh"])
current_parent = "root"
twist_name = "thigh_twist_"
twist_idx = 1
increment = 1
elif i == self.settings["div0"] + 1:
self.jnt_pos.append([driver, "calf", current_parent])
twist_name = "calf_twist_"
current_parent = "knee"
twist_idx = self.settings["div1"]
increment = -1
else:
self.jnt_pos.append(
[driver,
twist_name + str(twist_idx).zfill(2),
current_parent])
twist_idx += increment
# End reference ------------------------------------
# To help the deformation on the ankle
self.end_ref = primitive.addTransform(self.tws2_rot,
self.getName("end_ref"), m)
# set the offset rotation for the hand
self.end_jnt_off = primitive.addTransform(self.end_ref,
self.getName("end_off"), m)
if self.up_axis == "z":
self.end_jnt_off.rz.set(-90)
self.jnt_pos.append([self.end_jnt_off, 'foot', current_parent])
# match IK FK references
self.match_fk0_off = self.add_match_ref(self.fk_ctl[1],
self.root,
"matchFk0_npo",
False)
self.match_fk0 = self.add_match_ref(self.fk_ctl[0],
self.match_fk0_off,
"fk0_mth")
self.match_fk1_off = self.add_match_ref(self.fk_ctl[2],
self.root,
"matchFk1_npo",
False)
self.match_fk1 = self.add_match_ref(self.fk_ctl[1],
self.match_fk1_off,
"fk1_mth")
self.match_fk2 = self.add_match_ref(self.fk_ctl[2],
self.ik_ctl,
"fk2_mth")
self.match_ik = self.add_match_ref(self.ik_ctl,
self.fk2_ctl,
"ik_mth")
self.match_ikUpv = self.add_match_ref(self.upv_ctl,
self.fk0_ctl,
"upv_mth")
# add visual reference
self.line_ref = icon.connection_display_curve(
self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def addObjects(self):
"""Add all the objects needed to create the component."""
self.WIP = self.options["mode"]
self.up_axis = pm.upAxis(q=True, axis=True)
self.blade_normal = self.guide.blades["blade"].z * -1
self.blade_binormal = self.guide.blades["blade"].x
self.normal = self.getNormalFromPos(self.guide.apos)
self.binormal = self.getBiNormalFromPos(self.guide.apos)
self.length0 = vector.getDistance(
self.guide.apos[0], self.guide.apos[1]
)
self.length1 = vector.getDistance(
self.guide.apos[1], self.guide.apos[2]
)
self.length2 = vector.getDistance(
self.guide.apos[2], self.guide.apos[3]
)
# 1 bone chain for upv ref
self.armChainUpvRef = primitive.add2DChain(
self.root,
self.getName("armUpvRef%s_jnt"),
[self.guide.apos[0], self.guide.apos[2]],
self.normal,
False,
self.WIP,
)
negateOri = self.armChainUpvRef[1].getAttr("jointOrientZ") * -1
self.armChainUpvRef[1].setAttr("jointOrientZ", negateOri)
# FK Controlers -----------------------------------
t = transform.getTransformLookingAt(
self.guide.apos[0],
self.guide.apos[1],
self.normal,
"xz",
self.negate,
)
if self.settings["FK_rest_T_Pose"]:
x = datatypes.Vector(1, 0, 0)
if self.negate:
z_dir = -1
else:
z_dir = 1
if self.up_axis == "y":
z = datatypes.Vector(0, z_dir, 0)
else:
z = datatypes.Vector(0, 0, z_dir)
t_npo = transform.getRotationFromAxis(x, z, "xz", False)
t_npo = transform.setMatrixPosition(t_npo, self.guide.apos[0])
else:
t_npo = t
self.fk0_npo = primitive.addTransform(
self.root, self.getName("fk0_npo"), t_npo
)
vec_po = datatypes.Vector(0.5 * self.length0 * self.n_factor, 0, 0)
self.fk0_ctl = self.addCtl(
self.fk0_npo,
"fk0_ctl",
t,
self.color_fk,
"cube",
w=self.length0,
h=self.size * 0.1,
d=self.size * 0.1,
po=vec_po,
tp=self.parentCtlTag,
)
attribute.setKeyableAttributes(
self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]
)
t = transform.getTransformLookingAt(
self.guide.apos[1],
self.guide.apos[2],
self.normal,
"xz",
self.negate,
)
if self.settings["FK_rest_T_Pose"]:
t_npo = transform.setMatrixPosition(
transform.getTransform(self.fk0_ctl), self.guide.apos[1]
)
else:
t_npo = t
self.fk1_npo = primitive.addTransform(
self.fk0_ctl, self.getName("fk1_npo"), t_npo
)
vec_po = datatypes.Vector(0.5 * self.length1 * self.n_factor, 0, 0)
self.fk1_ctl = self.addCtl(
self.fk1_npo,
"fk1_ctl",
t,
self.color_fk,
"cube",
w=self.length1,
h=self.size * 0.1,
d=self.size * 0.1,
po=vec_po,
tp=self.fk0_ctl,
)
attribute.setKeyableAttributes(
self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]
)
if self.settings["use_blade"]:
t = transform.getTransformLookingAt(
self.guide.apos[2],
self.guide.apos[3],
self.blade_normal,
"x-z",
self.negate,
)
else:
t = transform.getTransformLookingAt(
self.guide.apos[2],
self.guide.apos[3],
self.normal,
"xz",
self.negate,
)
if self.settings["FK_rest_T_Pose"]:
t_npo = transform.setMatrixPosition(
transform.getTransform(self.fk1_ctl), self.guide.apos[2]
)
else:
t_npo = t
self.fk2_npo = primitive.addTransform(
self.fk1_ctl, self.getName("fk2_npo"), t_npo
)
vec_po = datatypes.Vector(0.5 * self.length2 * self.n_factor, 0, 0)
self.fk2_ctl = self.addCtl(
self.fk2_npo,
"fk2_ctl",
t,
self.color_fk,
"cube",
w=self.length2,
h=self.size * 0.1,
d=self.size * 0.1,
po=vec_po,
tp=self.fk1_ctl,
)
attribute.setKeyableAttributes(self.fk2_ctl)
self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl]
for x in self.fk_ctl:
attribute.setInvertMirror(x, ["tx", "ty", "tz"])
# IK upv ---------------------------------
# create tip point
self.tip_ref = primitive.addTransform(
self.armChainUpvRef[0],
self.getName("tip_ref"),
self.armChainUpvRef[0].getMatrix(worldSpace=True),
)
# create interpolate obj
self.interpolate_lvl = primitive.addTransform(
self.armChainUpvRef[0],
self.getName("int_lvl"),
self.armChainUpvRef[0].getMatrix(worldSpace=True),
)
# create roll npo and ctl
self.roll_ctl_npo = primitive.addTransform(
self.root,
self.getName("roll_ctl_npo"),
self.armChainUpvRef[0].getMatrix(worldSpace=True),
)
if self.negate:
off_x = -1.5708
else:
off_x = 1.5708
off_y = 1.5708
self.roll_ctl = self.addCtl(
self.roll_ctl_npo,
"roll_ctl",
transform.getTransform(self.roll_ctl_npo),
self.color_ik,
"compas",
w=self.size * 0.3,
ro=datatypes.Vector([off_x, off_y, 0]),
tp=self.parentCtlTag,
)
attribute.setKeyableAttributes(self.roll_ctl, ["rx"])
# create upv control
v = self.guide.apos[2] - self.guide.apos[0]
v = self.normal ^ v
v.normalize()
v *= self.size * 0.8
v += self.guide.apos[1]
self.upv_cns = primitive.addTransformFromPos(
self.root, self.getName("upv_cns"), v
)
self.upv_ctl = self.addCtl(
self.upv_cns,
"upv_ctl",
transform.getTransform(self.upv_cns),
self.color_ik,
"diamond",
w=self.size * 0.12,
tp=self.parentCtlTag,
)
if self.settings["mirrorMid"]:
if self.negate:
self.upv_cns.rz.set(180)
self.upv_cns.sy.set(-1)
else:
attribute.setInvertMirror(self.upv_ctl, ["tx"])
attribute.setKeyableAttributes(self.upv_ctl, self.t_params)
# IK Controlers -----------------------------------
self.ik_cns = primitive.addTransformFromPos(
self.root, self.getName("ik_cns"), self.guide.pos["wrist"]
)
t = transform.getTransformFromPos(self.guide.pos["wrist"])
self.ikcns_ctl = self.addCtl(
self.ik_cns,
"ikcns_ctl",
t,
self.color_ik,
"null",
w=self.size * 0.12,
tp=self.parentCtlTag,
)
attribute.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"])
if self.settings["use_blade"]:
normal = self.blade_normal
axis_ref1 = "xz"
axis_ref2 = "x-z"
else:
normal = self.normal
axis_ref1 = "x-y"
axis_ref2 = "xy"
if self.negate:
m = transform.getTransformLookingAt(
self.guide.pos["wrist"],
self.guide.pos["eff"],
normal,
axis_ref1,
True,
)
else:
m = transform.getTransformLookingAt(
self.guide.pos["wrist"],
self.guide.pos["eff"],
normal,
axis_ref2,
False,
)
self.ik_ctl = self.addCtl(
self.ikcns_ctl,
"ik_ctl",
m,
self.color_ik,
"cube",
w=self.size * 0.12,
h=self.size * 0.12,
d=self.size * 0.12,
tp=self.roll_ctl,
)
if self.settings["mirrorIK"]:
if self.negate:
self.ik_cns.sx.set(-1)
self.ik_ctl.ry.set(self.ik_ctl.ry.get() * -1)
self.ik_ctl.rz.set(self.ik_ctl.rz.get() * -1)
else:
attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
attribute.setKeyableAttributes(self.ik_ctl)
self.ik_ctl_ref = primitive.addTransform(
self.ik_ctl, self.getName("ikCtl_ref"), m
)
# IK rotation controls
if self.settings["ikTR"]:
self.ikRot_npo = primitive.addTransform(
self.root, self.getName("ikRot_npo"), m
)
self.ikRot_cns = primitive.addTransform(
self.ikRot_npo, self.getName("ikRot_cns"), m
)
self.ikRot_ctl = self.addCtl(
self.ikRot_cns,
"ikRot_ctl",
m,
self.color_ik,
"sphere",
w=self.size * 0.12,
tp=self.ik_ctl,
)
attribute.setKeyableAttributes(self.ikRot_ctl, self.r_params)
# References --------------------------------------
# Calculate again the transfor for the IK ref. This way align with FK
if self.settings["use_blade"]:
normal = self.blade_normal
axis_ref = "x-z"
else:
normal = self.normal
axis_ref = "xz"
trnIK_ref = transform.getTransformLookingAt(
self.guide.pos["wrist"],
self.guide.pos["eff"],
normal,
axis_ref,
self.negate,
)
self.ik_ref = primitive.addTransform(
self.ik_ctl_ref, self.getName("ik_ref"), trnIK_ref
)
self.fk_ref = primitive.addTransform(
self.fk_ctl[2], self.getName("fk_ref"), trnIK_ref
)
# Chain --------------------------------------------
# The outputs of the ikfk2bone solver
self.bone0 = primitive.addLocator(
self.root,
self.getName("0_bone"),
transform.getTransform(self.fk_ctl[0]),
)
self.bone0_shp = self.bone0.getShape()
self.bone0_shp.setAttr("localPositionX", self.n_factor * 0.5)
self.bone0_shp.setAttr("localScale", 0.5, 0, 0)
self.bone0.setAttr("sx", self.length0)
self.bone0.setAttr("visibility", False)
self.bone1 = primitive.addLocator(
self.root,
self.getName("1_bone"),
transform.getTransform(self.fk_ctl[1]),
)
self.bone1_shp = self.bone1.getShape()
self.bone1_shp.setAttr("localPositionX", self.n_factor * 0.5)
self.bone1_shp.setAttr("localScale", 0.5, 0, 0)
self.bone1.setAttr("sx", self.length1)
self.bone1.setAttr("visibility", False)
self.ctrn_loc = primitive.addTransformFromPos(
self.root, self.getName("ctrn_loc"), self.guide.apos[1]
)
self.eff_loc = primitive.addTransformFromPos(
self.root, self.getName("eff_loc"), self.guide.apos[2]
)
if self.settings["use_blade"]:
# set the offset rotation for the hand
self.off_t = transform.getTransformLookingAt(
self.guide.pos["wrist"],
self.guide.pos["eff"],
self.blade_normal,
axis="xy",
negate=self.negate,
)
self.eff_jnt_off = primitive.addTransform(
self.eff_loc, self.getName("eff_off"), self.off_t
)
# Mid Controler ------------------------------------
t = transform.getTransform(self.ctrn_loc)
self.mid_cns = primitive.addTransform(
self.ctrn_loc, self.getName("mid_cns"), t
)
self.mid_ctl = self.addCtl(
self.mid_cns,
"mid_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.2,
tp=self.parentCtlTag,
)
attribute.setKeyableAttributes(
self.mid_ctl,
params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"],
)
if self.settings["mirrorMid"]:
if self.negate:
self.mid_cns.rz.set(180)
self.mid_cns.sz.set(-1)
self.mid_ctl_twst_npo = primitive.addTransform(
self.mid_ctl, self.getName("mid_twst_npo"), t
)
self.mid_ctl_twst_ref = primitive.addTransform(
self.mid_ctl_twst_npo, self.getName("mid_twst_ref"), t
)
else:
self.mid_ctl_twst_ref = self.mid_ctl
attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"])
# Roll join ref
self.rollRef = primitive.add2DChain(
self.root,
self.getName("rollChain"),
self.guide.apos[:2],
self.normal,
self.negate,
)
for x in self.rollRef:
x.setAttr("visibility", False)
if self.settings["div0"]:
twst0_parent = self.rollRef[0]
else:
twst0_parent = self.root
self.tws0_loc = primitive.addTransform(
twst0_parent,
self.getName("tws0_loc"),
transform.getTransform(self.fk_ctl[0]),
)
self.tws0_rot = primitive.addTransform(
self.tws0_loc,
self.getName("tws0_rot"),
transform.getTransform(self.fk_ctl[0]),
)
self.tws1_npo = primitive.addTransform(
self.ctrn_loc,
self.getName("tws1_npo"),
transform.getTransform(self.ctrn_loc),
)
self.tws1_loc = primitive.addTransform(
self.tws1_npo,
self.getName("tws1_loc"),
transform.getTransform(self.ctrn_loc),
)
self.tws1_rot = primitive.addTransform(
self.tws1_loc,
self.getName("tws1_rot"),
transform.getTransform(self.ctrn_loc),
)
self.tws2_npo = primitive.addTransform(
self.root,
self.getName("tws2_npo"),
transform.getTransform(self.fk_ctl[2]),
)
self.tws2_loc = primitive.addTransform(
self.tws2_npo,
self.getName("tws2_loc"),
transform.getTransform(self.fk_ctl[2]),
)
self.tws2_rot = primitive.addTransform(
self.tws2_loc,
self.getName("tws2_rot"),
transform.getTransform(self.fk_ctl[2]),
)
# Divisions ----------------------------------------
self.divisions = self.settings["div0"] + self.settings["div1"] + 2
self.div_cns = []
if self.settings["extraTweak"]:
tagP = self.parentCtlTag
self.tweak_ctl = []
for i in range(self.divisions):
div_cns = primitive.addTransform(
self.root, self.getName("div%s_loc" % i)
)
self.div_cns.append(div_cns)
if self.settings["extraTweak"]:
t = transform.getTransform(div_cns)
tweak_ctl = self.addCtl(
div_cns,
"tweak%s_ctl" % i,
t,
self.color_fk,
"square",
w=self.size * 0.15,
d=self.size * 0.15,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=tagP,
)
attribute.setKeyableAttributes(tweak_ctl)
tagP = tweak_ctl
self.tweak_ctl.append(tweak_ctl)
driver = tweak_ctl
else:
driver = div_cns
# joint Description Name
jd_names = ast.literal_eval(
self.settings["jointNamesDescription_custom"]
)
jdn_upperarm = jd_names[0]
jdn_lowerarm = jd_names[1]
jdn_upperarm_twist = jd_names[2]
jdn_lowerarm_twist = jd_names[3]
jdn_hand = jd_names[4]
# setting the joints
if i == 0:
self.jnt_pos.append([driver, jdn_upperarm])
current_parent = "root"
twist_name = jdn_upperarm_twist
twist_idx = 1
increment = 1
elif i == self.settings["div0"] + 1:
self.jnt_pos.append([driver, jdn_lowerarm, current_parent])
twist_name = jdn_lowerarm_twist
current_parent = "elbow"
twist_idx = self.settings["div1"]
increment = -1
else:
self.jnt_pos.append(
[
driver,
string.replaceSharpWithPadding(twist_name, twist_idx),
current_parent,
]
)
twist_idx += increment
if self.settings["use_blade"]:
eff_loc = self.eff_jnt_off
else:
eff_loc = self.eff_loc
self.jnt_pos.append([eff_loc, jdn_hand, current_parent])
# match IK FK references
self.match_fk0_off = self.add_match_ref(
self.fk_ctl[1], self.root, "matchFk0_npo", False
)
self.match_fk0 = self.add_match_ref(
self.fk_ctl[0], self.match_fk0_off, "fk0_mth"
)
self.match_fk1_off = self.add_match_ref(
self.fk_ctl[2], self.root, "matchFk1_npo", False
)
self.match_fk1 = self.add_match_ref(
self.fk_ctl[1], self.match_fk1_off, "fk1_mth"
)
if self.settings["ikTR"]:
reference = self.ikRot_ctl
self.match_ikRot = self.add_match_ref(
self.ikRot_ctl, self.fk2_ctl, "ikRot_mth"
)
else:
reference = self.ik_ctl
self.match_fk2 = self.add_match_ref(
self.fk_ctl[2], reference, "fk2_mth"
)
self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth")
self.match_ikUpv = self.add_match_ref(
self.upv_ctl, self.fk0_ctl, "upv_mth"
)
# add visual reference
self.line_ref = icon.connection_display_curve(
self.getName("visalRef"), [self.upv_ctl, self.mid_ctl]
)
def __init__(self):
super(ShapeMirrorLeftToRightTool, self).__init__()
self.options.axis = 'X' if pm.upAxis(q=True, axis=True).upper() == 'Y' else 'Y'
self.options.selection_only = False
def addObjects(self):
"""Add all the objects needed to create the component."""
# joint Description Names
jd_names = ast.literal_eval(
self.settings["jointNamesDescription_custom"])
jdn_neck = jd_names[0]
jdn_head = jd_names[1]
self.normal = self.guide.blades["blade"].z * -1
self.up_axis = pm.upAxis(q=True, axis=True)
# Ik Controlers ------------------------------------
if self.settings["IKWorldOri"]:
t = datatypes.TransformationMatrix()
else:
t = transform.getTransformLookingAt(
self.guide.pos["tan1"],
self.guide.pos["neck"],
self.normal,
"yx",
self.negate,
)
t = transform.setMatrixPosition(t, self.guide.pos["neck"])
self.ik_off = primitive.addTransform(self.root, self.getName("ik_off"),
t)
# handle Z up orientation offset
if self.up_axis == "z" and self.settings["IKWorldOri"]:
self.ik_off.rx.set(90)
t = transform.getTransform(self.ik_off)
self.ik_cns = primitive.addTransform(self.ik_off,
self.getName("ik_cns"), t)
self.ik_ctl = self.addCtl(
self.ik_cns,
"ik_ctl",
t,
self.color_ik,
"compas",
w=self.size * 0.5,
tp=self.parentCtlTag,
)
attribute.setKeyableAttributes(self.ik_ctl, self.tr_params)
attribute.setRotOrder(self.ik_ctl, "ZXY")
attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
# Tangents -----------------------------------------
if self.settings["tangentControls"]:
t = transform.setMatrixPosition(t, self.guide.pos["tan1"])
self.tan1_loc = primitive.addTransform(self.ik_ctl,
self.getName("tan1_loc"), t)
self.tan1_ctl = self.addCtl(
self.tan1_loc,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.2,
tp=self.ik_ctl,
)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
attribute.setInvertMirror(self.tan1_ctl, ["tx"])
t = transform.getTransformLookingAt(
self.guide.pos["root"],
self.guide.pos["tan0"],
self.normal,
"yx",
self.negate,
)
t = transform.setMatrixPosition(t, self.guide.pos["tan0"])
self.tan0_loc = primitive.addTransform(self.root,
self.getName("tan0_loc"), t)
self.tan0_ctl = self.addCtl(
self.tan0_loc,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.2,
tp=self.ik_ctl,
)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
attribute.setInvertMirror(self.tan0_ctl, ["tx"])
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root,
self.getName("mst_crv"),
[self.root, self.tan0_ctl, self.tan1_ctl, self.ik_ctl],
3,
)
self.slv_crv = curve.addCurve(
self.root,
self.getName("slv_crv"),
[datatypes.Vector()] * 10,
False,
3,
)
self.mst_crv.setAttr("visibility", False)
else:
t = transform.setMatrixPosition(t, self.guide.pos["tan1"])
self.tan1_loc = primitive.addTransform(self.ik_ctl,
self.getName("tan1_loc"), t)
t = transform.getTransformLookingAt(
self.guide.pos["root"],
self.guide.pos["tan0"],
self.normal,
"yx",
self.negate,
)
t = transform.setMatrixPosition(t, self.guide.pos["tan0"])
self.tan0_loc = primitive.addTransform(self.root,
self.getName("tan0_loc"), t)
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root,
self.getName("mst_crv"),
[self.root, self.tan0_loc, self.tan1_loc, self.ik_ctl],
3,
)
self.slv_crv = curve.addCurve(
self.root,
self.getName("slv_crv"),
[datatypes.Vector()] * 10,
False,
3,
)
self.mst_crv.setAttr("visibility", False)
self.slv_crv.setAttr("visibility", False)
# Division -----------------------------------------
# The user only define how many intermediate division he wants.
# First and last divisions are an obligation.
parentdiv = self.root
parentctl = self.root
self.div_cns = []
self.fk_ctl = []
self.fk_npo = []
self.scl_npo = []
self.twister = []
self.ref_twist = []
# adding 1 for the head
self.divisions = self.settings["division"] + 1
parent_twistRef = primitive.addTransform(
self.root,
self.getName("reference"),
transform.getTransform(self.root),
)
t = transform.getTransformLookingAt(
self.guide.pos["root"],
self.guide.pos["neck"],
self.normal,
"yx",
self.negate,
)
self.intMRef = primitive.addTransform(self.root,
self.getName("intMRef"), t)
self.previousCtlTag = self.parentCtlTag
for i in range(self.divisions):
# References
div_cns = primitive.addTransform(parentdiv,
self.getName("%s_cns" % i), t)
pm.setAttr(div_cns + ".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
scl_npo = primitive.addTransform(
parentctl,
self.getName("%s_scl_npo" % i),
transform.getTransform(parentctl),
)
# Controlers (First and last one are fake)
if i in [self.divisions - 1]: # 0,
fk_ctl = primitive.addTransform(
scl_npo,
self.getName("%s_loc" % i),
transform.getTransform(parentctl),
)
fk_npo = fk_ctl
else:
fk_npo = primitive.addTransform(
scl_npo,
self.getName("fk%s_npo" % i),
transform.getTransform(parentctl),
)
fk_ctl = self.addCtl(
fk_npo,
"fk%s_ctl" % i,
transform.getTransform(parentctl),
self.color_fk,
"cube",
w=self.size * 0.2,
h=self.size * 0.05,
d=self.size * 0.2,
tp=self.previousCtlTag,
)
attribute.setKeyableAttributes(self.fk_ctl)
attribute.setRotOrder(fk_ctl, "ZXY")
self.previousCtlTag = fk_ctl
self.fk_ctl.append(fk_ctl)
self.scl_npo.append(scl_npo)
self.fk_npo.append(fk_npo)
parentctl = fk_ctl
if i != self.divisions - 1:
self.jnt_pos.append(
[fk_ctl,
string.replaceSharpWithPadding(jdn_neck, i + 1)])
t = transform.getTransformLookingAt(
self.guide.pos["root"],
self.guide.pos["neck"],
self.guide.blades["blade"].z * -1,
"yx",
self.negate,
)
twister = primitive.addTransform(parent_twistRef,
self.getName("%s_rot_ref" % i), t)
ref_twist = primitive.addTransform(parent_twistRef,
self.getName("%s_pos_ref" % i),
t)
ref_twist.setTranslation(datatypes.Vector(0.0, 0, 1.0),
space="preTransform")
self.twister.append(twister)
self.ref_twist.append(ref_twist)
for x in self.fk_ctl[:-1]:
attribute.setInvertMirror(x, ["tx", "rz", "ry"])
# Head ---------------------------------------------
t = transform.getTransformLookingAt(
self.guide.pos["head"],
self.guide.pos["eff"],
self.normal,
"yx",
self.negate,
)
self.head_cns = primitive.addTransform(self.root,
self.getName("head_cns"), t)
dist = vector.getDistance(self.guide.pos["head"],
self.guide.pos["eff"])
self.head_ctl = self.addCtl(
self.head_cns,
"head_ctl",
t,
self.color_fk,
"cube",
w=self.size * 0.5,
h=dist,
d=self.size * 0.5,
po=datatypes.Vector(0, dist * 0.5, 0),
tp=self.previousCtlTag,
)
attribute.setRotOrder(self.head_ctl, "ZXY")
attribute.setInvertMirror(self.head_ctl, ["tx", "rz", "ry"])
self.jnt_pos.append([self.head_ctl, jdn_head])
from pymel.core import createNode, group, hide, ikHandle, joint, move, rotate, select, xform, upAxis
import pdil
from ..cardRigging import MetaControl, OutputControls, colorParity
from .._core import config
from .._lib import space
from .._lib2 import controllerShape
from .. import enums
from .. import log
from .. import node
from . import _util as util
MAYA_UP = upAxis(q=True, ax=True)
@util.adds('tiptoe', 'heelRaise', 'toeTap', 'ballPivot')
@util.defaultspec(
{
'shape': 'disc',
'size': 15,
'color': 'blue 0.22',
'align': MAYA_UP
},
toeControl={
'shape': 'sphere',
'size': 10,
'color': 'blue 0.22'
},
def rig(
eyeMesh=None,
edgeLoop="",
blinkH=20,
namePrefix="eye",
offset=0.05,
rigidLoops=2,
falloffLoops=4,
headJnt=None,
doSkin=True,
parent_node=None,
ctlName="ctl",
sideRange=False,
customCorner=False,
intCorner=None,
extCorner=None,
ctlSet=None,
defSet=None,
upperVTrack=0.02,
upperHTrack=0.01,
lowerVTrack=0.02,
lowerHTrack=0.01,
aim_controller="",
deformers_group="",
everyNVertex=1,
):
"""Create eyelid and eye rig
Args:
eyeMesh (TYPE): Description
edgeLoop (TYPE): Description
blinkH (TYPE): Description
namePrefix (TYPE): Description
offset (TYPE): Description
rigidLoops (TYPE): Description
falloffLoops (TYPE): Description
headJnt (TYPE): Description
doSkin (TYPE): Description
parent_node (None, optional): Description
ctlName (str, optional): Description
sideRange (bool, optional): Description
customCorner (bool, optional): Description
intCorner (None, optional): Description
extCorner (None, optional): Description
ctlSet (None, optional): Description
defSet (None, optional): Description
upperVTrack (None, optional): Description
upperHTrack (None, optional): Description
lowerVTrack (None, optional): Description
lowerHTrack (None, optional): Description
aim_controller (None, optional): Description
deformers_group (None, optional): Description
everyNVertex (int, optional): Will create a joint every N vertex
No Longer Returned:
TYPE: Description
"""
##########################################
# INITIAL SETUP
##########################################
up_axis = pm.upAxis(q=True, axis=True)
if up_axis == "z":
z_up = True
else:
z_up = False
# getters
edgeLoopList = get_edge_loop(edgeLoop)
eyeMesh = get_eye_mesh(eyeMesh)
# checkers
if not edgeLoopList or not eyeMesh:
return
if doSkin:
if not headJnt:
pm.displayWarning("Please set the Head Jnt or unCheck "
"Compute Topological Autoskin")
return
# Convert data
blinkH = blinkH / 100.0
# Initial Data
bboxCenter = meshNavigation.bboxCenter(eyeMesh)
extr_v = meshNavigation.getExtremeVertexFromLoop(edgeLoopList, sideRange,
z_up)
upPos = extr_v[0]
lowPos = extr_v[1]
inPos = extr_v[2]
outPos = extr_v[3]
edgeList = extr_v[4]
vertexList = extr_v[5]
# Detect the side L or R from the x value
if inPos.getPosition(space="world")[0] < 0.0:
side = "R"
inPos = extr_v[3]
outPos = extr_v[2]
normalPos = outPos
npw = normalPos.getPosition(space="world")
normalVec = npw - bboxCenter
else:
side = "L"
normalPos = outPos
npw = normalPos.getPosition(space="world")
normalVec = bboxCenter - npw
# Manual Vertex corners
if customCorner:
if intCorner:
try:
if side == "R":
inPos = pm.PyNode(extCorner)
else:
inPos = pm.PyNode(intCorner)
except pm.MayaNodeError:
pm.displayWarning("%s can not be found" % intCorner)
return
else:
pm.displayWarning("Please set the internal eyelid corner")
return
if extCorner:
try:
normalPos = pm.PyNode(extCorner)
npw = normalPos.getPosition(space="world")
if side == "R":
outPos = pm.PyNode(intCorner)
normalVec = npw - bboxCenter
else:
outPos = pm.PyNode(extCorner)
normalVec = bboxCenter - npw
except pm.MayaNodeError:
pm.displayWarning("%s can not be found" % extCorner)
return
else:
pm.displayWarning("Please set the external eyelid corner")
return
# Check if we have prefix:
if namePrefix:
namePrefix = string.removeInvalidCharacter(namePrefix)
else:
pm.displayWarning("Prefix is needed")
return
def setName(name, ind=None):
namesList = [namePrefix, side, name]
if ind is not None:
namesList[1] = side + str(ind)
name = "_".join(namesList)
return name
if pm.ls(setName("root")):
pm.displayWarning("The object %s already exist in the scene. Please "
"choose another name prefix" % setName("root"))
return
##########################################
# CREATE OBJECTS
##########################################
# Eye root
eye_root = primitive.addTransform(None, setName("root"))
eyeCrv_root = primitive.addTransform(eye_root, setName("crvs"))
# Eyelid Main crvs
try:
upEyelid_edge = meshNavigation.edgeRangeInLoopFromMid(
edgeList, upPos, inPos, outPos)
up_crv = curve.createCurveFromOrderedEdges(upEyelid_edge,
inPos,
setName("upperEyelid"),
parent=eyeCrv_root)
upCtl_crv = curve.createCurveFromOrderedEdges(upEyelid_edge,
inPos,
setName("upCtl_crv"),
parent=eyeCrv_root)
pm.rebuildCurve(upCtl_crv, s=2, rt=0, rpo=True, ch=False)
lowEyelid_edge = meshNavigation.edgeRangeInLoopFromMid(
edgeList, lowPos, inPos, outPos)
low_crv = curve.createCurveFromOrderedEdges(lowEyelid_edge,
inPos,
setName("lowerEyelid"),
parent=eyeCrv_root)
lowCtl_crv = curve.createCurveFromOrderedEdges(lowEyelid_edge,
inPos,
setName("lowCtl_crv"),
parent=eyeCrv_root)
pm.rebuildCurve(lowCtl_crv, s=2, rt=0, rpo=True, ch=False)
except UnboundLocalError:
if customCorner:
pm.displayWarning("This error is maybe caused because the custom "
"Corner vertex is not part of the edge loop")
pm.displayError(traceback.format_exc())
return
# blendshape curves. All crv have 30 point to allow blendshape connect
upDriver_crv = curve.createCurveFromCurve(up_crv,
setName("upDriver_crv"),
nbPoints=30,
parent=eyeCrv_root)
upDriver_crv.attr("lineWidth").set(5)
lowDriver_crv = curve.createCurveFromCurve(low_crv,
setName("lowDriver_crv"),
nbPoints=30,
parent=eyeCrv_root)
lowDriver_crv.attr("lineWidth").set(5)
upRest_target_crv = curve.createCurveFromCurve(
up_crv, setName("upRest_target_crv"), nbPoints=30, parent=eyeCrv_root)
lowRest_target_crv = curve.createCurveFromCurve(
low_crv,
setName("lowRest_target_crv"),
nbPoints=30,
parent=eyeCrv_root)
upProfile_target_crv = curve.createCurveFromCurve(
up_crv,
setName("upProfile_target_crv"),
nbPoints=30,
parent=eyeCrv_root,
)
lowProfile_target_crv = curve.createCurveFromCurve(
low_crv,
setName("lowProfile_target_crv"),
nbPoints=30,
parent=eyeCrv_root,
)
# mid driver
midUpDriver_crv = curve.createCurveFromCurve(up_crv,
setName("midUpDriver_crv"),
nbPoints=30,
parent=eyeCrv_root)
midLowDriver_crv = curve.createCurveFromCurve(low_crv,
setName("midLowDriver_crv"),
nbPoints=30,
parent=eyeCrv_root)
# curve that define the close point of the eyelid
closeTarget_crv = curve.createCurveFromCurve(up_crv,
setName("closeTarget_crv"),
nbPoints=30,
parent=eyeCrv_root)
eyeCrv_root.attr("visibility").set(False)
# localBBOX
localBBox = eyeMesh.getBoundingBox(invisible=True, space="world")
wRadius = abs((localBBox[0][0] - localBBox[1][0]))
dRadius = abs((localBBox[0][1] - localBBox[1][1]) / 1.7)
# Groups
if not ctlSet:
ctlSet = "rig_controllers_grp"
try:
ctlSet = pm.PyNode(ctlSet)
except pm.MayaNodeError:
pm.sets(n=ctlSet, em=True)
ctlSet = pm.PyNode(ctlSet)
if not defSet:
defSet = "rig_deformers_grp"
try:
defset = pm.PyNode(defSet)
except pm.MayaNodeError:
pm.sets(n=defSet, em=True)
defset = pm.PyNode(defSet)
# Calculate center looking at
averagePosition = (upPos.getPosition(space="world") + lowPos.getPosition(
space="world") + inPos.getPosition(space="world") +
outPos.getPosition(space="world")) / 4
if z_up:
axis = "zx"
else:
axis = "z-x"
t = transform.getTransformLookingAt(bboxCenter,
averagePosition,
normalVec,
axis=axis,
negate=False)
over_npo = primitive.addTransform(eye_root, setName("center_lookatRoot"),
t)
center_lookat = primitive.addTransform(over_npo, setName("center_lookat"),
t)
if side == "R":
over_npo.attr("rx").set(over_npo.attr("rx").get() * -1)
over_npo.attr("ry").set(over_npo.attr("ry").get() + 180)
over_npo.attr("sz").set(-1)
t = transform.getTransform(over_npo)
# Tracking
# Eye aim control
t_arrow = transform.getTransformLookingAt(
bboxCenter,
averagePosition,
upPos.getPosition(space="world"),
axis="zy",
negate=False,
)
radius = abs((localBBox[0][0] - localBBox[1][0]) / 1.7)
arrow_ctl = None
arrow_npo = None
if aim_controller:
arrow_ctl = pm.PyNode(aim_controller)
else:
arrow_npo = primitive.addTransform(eye_root, setName("aim_npo"),
t_arrow)
arrow_ctl = icon.create(
arrow_npo,
setName("aim_%s" % ctlName),
t_arrow,
icon="arrow",
w=1,
po=datatypes.Vector(0, 0, radius),
color=4,
)
if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost":
pass
else:
pm.sets(ctlSet, add=arrow_ctl)
attribute.setKeyableAttributes(arrow_ctl, params=["rx", "ry", "rz"])
attribute.addAttribute(arrow_ctl, "isCtl", "bool", keyable=False)
# tracking custom trigger
if side == "R":
tt = t_arrow
else:
tt = t
aimTrigger_root = primitive.addTransform(center_lookat,
setName("aimTrigger_root"), tt)
# For some unknown reason the right side gets scewed rotation values
mgear.core.transform.resetTransform(aimTrigger_root)
aimTrigger_lvl = primitive.addTransform(aimTrigger_root,
setName("aimTrigger_lvl"), tt)
# For some unknown reason the right side gets scewed rotation values
mgear.core.transform.resetTransform(aimTrigger_lvl)
aimTrigger_lvl.attr("tz").set(1.0)
aimTrigger_ref = primitive.addTransform(aimTrigger_lvl,
setName("aimTrigger_ref"), tt)
# For some unknown reason the right side gets scewed rotation values
mgear.core.transform.resetTransform(aimTrigger_ref)
aimTrigger_ref.attr("tz").set(0.0)
# connect trigger with arrow_ctl
pm.parentConstraint(arrow_ctl, aimTrigger_ref, mo=True)
# Blink driver controls
if z_up:
trigger_axis = "tz"
ro_up = [0, 1.57079633 * 2, 1.57079633]
ro_low = [0, 0, 1.57079633]
po = [0, offset * -1, 0]
low_pos = 2 # Z
else:
trigger_axis = "ty"
ro_up = (1.57079633, 1.57079633, 0)
ro_low = [1.57079633, 1.57079633, 1.57079633 * 2]
po = [0, 0, offset]
low_pos = 1 # Y
# upper ctl
p = upRest_target_crv.getCVs(space="world")[15]
ut = transform.setMatrixPosition(datatypes.Matrix(), p)
npo = primitive.addTransform(over_npo, setName("upBlink_npo"), ut)
up_ctl = icon.create(
npo,
setName("upBlink_ctl"),
ut,
icon="arrow",
w=2.5,
d=2.5,
ro=datatypes.Vector(ro_up[0], ro_up[1], ro_up[2]),
po=datatypes.Vector(po[0], po[1], po[2]),
color=4,
)
attribute.setKeyableAttributes(up_ctl, [trigger_axis])
pm.sets(ctlSet, add=up_ctl)
# use translation of the object to drive the blink
blink_driver = primitive.addTransform(up_ctl, setName("blink_drv"), ut)
# lowe ctl
p_low = lowRest_target_crv.getCVs(space="world")[15]
p[low_pos] = p_low[low_pos]
lt = transform.setMatrixPosition(ut, p)
npo = primitive.addTransform(over_npo, setName("lowBlink_npo"), lt)
low_ctl = icon.create(
npo,
setName("lowBlink_ctl"),
lt,
icon="arrow",
w=1.5,
d=1.5,
ro=datatypes.Vector(ro_low[0], ro_low[1], ro_low[2]),
po=datatypes.Vector(po[0], po[1], po[2]),
color=4,
)
attribute.setKeyableAttributes(low_ctl, [trigger_axis])
pm.sets(ctlSet, add=low_ctl)
# Controls lists
upControls = []
trackLvl = []
track_corner_lvl = []
corner_ctl = []
ghost_ctl = []
# upper eyelid controls
upperCtlNames = ["inCorner", "upInMid", "upMid", "upOutMid", "outCorner"]
cvs = upCtl_crv.getCVs(space="world")
if side == "R" and not sideRange:
# if side == "R":
cvs = [cv for cv in reversed(cvs)]
# offset = offset * -1
for i, cv in enumerate(cvs):
if utils.is_odd(i):
color = 14
wd = 0.3
icon_shape = "circle"
params = ["tx", "ty", "tz"]
else:
color = 4
wd = 0.6
icon_shape = "circle"
params = [
"tx",
"ty",
"tz",
"ro",
"rx",
"ry",
"rz",
"sx",
"sy",
"sz",
]
t = transform.setMatrixPosition(t, cvs[i])
npo = primitive.addTransform(center_lookat,
setName("%s_npo" % upperCtlNames[i]), t)
npoBase = npo
# track for corners and mid point level
if i in [0, 2, 4]:
# we add an extra level to input the tracking ofset values
npo = primitive.addTransform(npo,
setName("%s_trk" % upperCtlNames[i]),
t)
if i == 2:
trackLvl.append(npo)
else:
track_corner_lvl.append(npo)
if i in [1, 2, 3]:
ctl = primitive.addTransform(npo,
setName("%s_loc" % upperCtlNames[i]),
t)
# ghost controls
if i == 2:
gt = transform.setMatrixPosition(
t, transform.getPositionFromMatrix(ut))
else:
gt = t
npo_g = primitive.addTransform(
up_ctl, setName("%sCtl_npo" % upperCtlNames[i]), gt)
ctl_g = icon.create(
npo_g,
setName("%s_%s" % (upperCtlNames[i], ctlName)),
gt,
icon=icon_shape,
w=wd,
d=wd,
ro=datatypes.Vector(1.57079633, 0, 0),
po=datatypes.Vector(0, 0, offset),
color=color,
)
# define the ctl_param to recive the ctl configuration
ctl_param = ctl_g
ghost_ctl.append(ctl_g)
# connect local SRT
rigbits.connectLocalTransform([ctl_g, ctl])
else:
ctl = icon.create(
npo,
setName("%s_%s" % (upperCtlNames[i], ctlName)),
t,
icon=icon_shape,
w=wd,
d=wd,
ro=datatypes.Vector(1.57079633, 0, 0),
po=datatypes.Vector(0, 0, offset),
color=color,
)
# define the ctl_param to recive the ctl configuration
ctl_param = ctl
attribute.addAttribute(ctl_param, "isCtl", "bool", keyable=False)
attribute.add_mirror_config_channels(ctl_param)
node.add_controller_tag(ctl_param, over_npo)
if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost":
pass
else:
pm.sets(ctlSet, add=ctl_param)
attribute.setKeyableAttributes(ctl_param, params)
upControls.append(ctl)
# add corner ctls to corner ctl list for tracking
if i in [0, 4]:
corner_ctl.append(ctl)
# if side == "R":
# npoBase.attr("ry").set(180)
# npoBase.attr("sz").set(-1)
# adding parent constraints to odd controls
for i, ctl in enumerate(upControls):
if utils.is_odd(i):
cns_node = pm.parentConstraint(upControls[i - 1],
upControls[i + 1],
ctl.getParent(),
mo=True)
# Make the constraint "noFlip"
cns_node.interpType.set(0)
# adding parent constraint ghost controls
cns_node = pm.parentConstraint(ghost_ctl[1],
upControls[0],
ghost_ctl[0].getParent(),
mo=True)
cns_node.interpType.set(0)
cns_node = pm.parentConstraint(ghost_ctl[1],
upControls[-1],
ghost_ctl[2].getParent(),
mo=True)
cns_node.interpType.set(0)
# lower eyelid controls
lowControls = [upControls[0]]
lowerCtlNames = [
"inCorner",
"lowInMid",
"lowMid",
"lowOutMid",
"outCorner",
]
cvs = lowCtl_crv.getCVs(space="world")
if side == "R" and not sideRange:
cvs = [cv for cv in reversed(cvs)]
for i, cv in enumerate(cvs):
# we skip the first and last point since is already in the uper eyelid
if i in [0, 4]:
continue
if utils.is_odd(i):
color = 14
wd = 0.3
icon_shape = "circle"
params = ["tx", "ty", "tz"]
else:
color = 4
wd = 0.6
icon_shape = "circle"
params = [
"tx",
"ty",
"tz",
"ro",
"rx",
"ry",
"rz",
"sx",
"sy",
"sz",
]
t = transform.setMatrixPosition(t, cvs[i])
npo = primitive.addTransform(center_lookat,
setName("%s_npo" % lowerCtlNames[i]), t)
npoBase = npo
if i in [1, 2, 3]:
if i == 2:
# we add an extra level to input the tracking ofset values
npo = primitive.addTransform(
npo, setName("%s_trk" % lowerCtlNames[i]), t)
trackLvl.append(npo)
ctl = primitive.addTransform(npo,
setName("%s_loc" % lowerCtlNames[i]),
t)
# ghost controls
if i == 2:
gt = transform.setMatrixPosition(
t, transform.getPositionFromMatrix(lt))
else:
gt = t
# ghost controls
npo_g = primitive.addTransform(
low_ctl, setName("%sCtl_npo" % lowerCtlNames[i]), gt)
ctl_g = icon.create(
npo_g,
setName("%s_%s" % (lowerCtlNames[i], ctlName)),
gt,
icon=icon_shape,
w=wd,
d=wd,
ro=datatypes.Vector(1.57079633, 0, 0),
po=datatypes.Vector(0, 0, offset),
color=color,
)
# define the ctl_param to recive the ctl configuration
ctl_param = ctl_g
ghost_ctl.append(ctl_g)
# connect local SRT
rigbits.connectLocalTransform([ctl_g, ctl])
else:
ctl = icon.create(
npo,
setName("%s_%s" % (lowerCtlNames[i], ctlName)),
t,
icon=icon_shape,
w=wd,
d=wd,
ro=datatypes.Vector(1.57079633, 0, 0),
po=datatypes.Vector(0, 0, offset),
color=color,
)
# define the ctl_param to recive the ctl configuration
ctl_param = ctl
attribute.addAttribute(ctl_param, "isCtl", "bool", keyable=False)
attribute.add_mirror_config_channels(ctl_param)
lowControls.append(ctl)
if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost":
pass
else:
pm.sets(ctlSet, add=ctl_param)
attribute.setKeyableAttributes(ctl_param, params)
# mirror behaviout on R side controls
# if side == "R":
# npoBase.attr("ry").set(180)
# npoBase.attr("sz").set(-1)
for lctl in reversed(lowControls[1:]):
node.add_controller_tag(lctl, over_npo)
lowControls.append(upControls[-1])
# adding parent constraints to odd controls
for i, ctl in enumerate(lowControls):
if utils.is_odd(i):
cns_node = pm.parentConstraint(
lowControls[i - 1],
lowControls[i + 1],
ctl.getParent(),
mo=True,
)
# Make the constraint "noFlip"
cns_node.interpType.set(0)
# adding parent constraint ghost controls
cns_node = pm.parentConstraint(ghost_ctl[4],
upControls[0],
ghost_ctl[3].getParent(),
mo=True)
cns_node.interpType.set(0)
cns_node = pm.parentConstraint(ghost_ctl[4],
upControls[-1],
ghost_ctl[5].getParent(),
mo=True)
cns_node.interpType.set(0)
##########################################
# OPERATORS
##########################################
# Connecting control crvs with controls
applyop.gear_curvecns_op(upCtl_crv, upControls)
applyop.gear_curvecns_op(lowCtl_crv, lowControls)
# adding wires
w1 = pm.wire(up_crv, w=upDriver_crv)[0]
w2 = pm.wire(low_crv, w=lowDriver_crv)[0]
w3 = pm.wire(upProfile_target_crv, w=upCtl_crv)[0]
w4 = pm.wire(lowProfile_target_crv, w=lowCtl_crv)[0]
if z_up:
trigger_axis = "tz"
else:
trigger_axis = "ty"
# connect blink driver
pm.pointConstraint(low_ctl, blink_driver, mo=False)
rest_val = blink_driver.attr(trigger_axis).get()
up_div_node = node.createDivNode(up_ctl.attr(trigger_axis), rest_val)
low_div_node = node.createDivNode(low_ctl.attr(trigger_axis),
rest_val * -1)
# contact driver
minus_node = node.createPlusMinusAverage1D(
[rest_val, blink_driver.attr(trigger_axis)], operation=2)
contact_div_node = node.createDivNode(minus_node.output1D, rest_val)
# wire tension
for w in [w1, w2, w3, w4]:
w.dropoffDistance[0].set(100)
# TODO: what is the best solution?
# trigger using proximity
# remap_node = pm.createNode("remapValue")
# contact_div_node.outputX >> remap_node.inputValue
# remap_node.value[0].value_Interp.set(2)
# remap_node.inputMin.set(0.995)
# reverse_node = node.createReverseNode(remap_node.outColorR)
# for w in [w1, w2]:
# reverse_node.outputX >> w.scale[0]
# trigger at starting movement for up and low
# up
remap_node = pm.createNode("remapValue")
up_ctl.attr(trigger_axis) >> remap_node.inputValue
remap_node.value[0].value_Interp.set(2)
remap_node.inputMax.set(rest_val / 8)
reverse_node = node.createReverseNode(remap_node.outColorR)
reverse_node.outputX >> w1.scale[0]
# low
remap_node = pm.createNode("remapValue")
low_ctl.attr(trigger_axis) >> remap_node.inputValue
remap_node.value[0].value_Interp.set(2)
remap_node.inputMin.set((rest_val / 8) * -1)
remap_node.outColorR >> w2.scale[0]
# mid position drivers blendshapes
bs_midUpDrive = pm.blendShape(
lowRest_target_crv,
upProfile_target_crv,
midUpDriver_crv,
n="midUpDriver_blendShape",
)
bs_midLowDrive = pm.blendShape(
upRest_target_crv,
lowProfile_target_crv,
midLowDriver_crv,
n="midlowDriver_blendShape",
)
bs_closeTarget = pm.blendShape(
midUpDriver_crv,
midLowDriver_crv,
closeTarget_crv,
n="closeTarget_blendShape",
)
pm.connectAttr(
up_div_node.outputX,
bs_midUpDrive[0].attr(lowRest_target_crv.name()),
)
pm.connectAttr(
low_div_node.outputX,
bs_midLowDrive[0].attr(upRest_target_crv.name()),
)
pm.setAttr(bs_closeTarget[0].attr(midUpDriver_crv.name()), 0.5)
pm.setAttr(bs_closeTarget[0].attr(midLowDriver_crv.name()), 0.5)
# Main crv drivers
bs_upBlink = pm.blendShape(
lowRest_target_crv,
closeTarget_crv,
upProfile_target_crv,
upDriver_crv,
n="upBlink_blendShape",
)
bs_lowBlink = pm.blendShape(
upRest_target_crv,
closeTarget_crv,
lowProfile_target_crv,
lowDriver_crv,
n="lowBlink_blendShape",
)
# blink contact connections
cond_node_up = node.createConditionNode(contact_div_node.outputX, 1, 3, 0,
up_div_node.outputX)
pm.connectAttr(
cond_node_up.outColorR,
bs_upBlink[0].attr(lowRest_target_crv.name()),
)
cond_node_low = node.createConditionNode(contact_div_node.outputX, 1, 3, 0,
low_div_node.outputX)
pm.connectAttr(
cond_node_low.outColorR,
bs_lowBlink[0].attr(upRest_target_crv.name()),
)
cond_node_close = node.createConditionNode(contact_div_node.outputX, 1, 2,
1, 0)
cond_node_close.colorIfFalseR.set(0)
pm.connectAttr(
cond_node_close.outColorR,
bs_upBlink[0].attr(closeTarget_crv.name()),
)
pm.connectAttr(
cond_node_close.outColorR,
bs_lowBlink[0].attr(closeTarget_crv.name()),
)
pm.setAttr(bs_upBlink[0].attr(upProfile_target_crv.name()), 1)
pm.setAttr(bs_lowBlink[0].attr(lowProfile_target_crv.name()), 1)
# joints root
jnt_root = primitive.addTransformFromPos(eye_root,
setName("joints"),
pos=bboxCenter)
if deformers_group:
deformers_group = pm.PyNode(deformers_group)
pm.parentConstraint(eye_root, jnt_root, mo=True)
pm.scaleConstraint(eye_root, jnt_root, mo=True)
deformers_group.addChild(jnt_root)
# head joint
if headJnt:
try:
headJnt = pm.PyNode(headJnt)
jnt_base = headJnt
except pm.MayaNodeError:
pm.displayWarning("Aborted can not find %s " % headJnt)
return
else:
# Eye root
jnt_base = jnt_root
eyeTargets_root = primitive.addTransform(eye_root, setName("targets"))
eyeCenter_jnt = rigbits.addJnt(arrow_ctl,
jnt_base,
grp=defset,
jntName=setName("center_jnt"))
# Upper Eyelid joints ##################################################
cvs = up_crv.getCVs(space="world")
upCrv_info = node.createCurveInfoNode(up_crv)
# aim constrain targets and joints
upperEyelid_aimTargets = []
upperEyelid_jnt = []
upperEyelid_jntRoot = []
if z_up:
axis = "zy"
wupVector = [0, 0, 1]
else:
axis = "-yz"
wupVector = [0, 1, 0]
for i, cv in enumerate(cvs):
if i % everyNVertex:
continue
# aim targets
trn = primitive.addTransformFromPos(eyeTargets_root,
setName("upEyelid_aimTarget", i),
pos=cv)
upperEyelid_aimTargets.append(trn)
# connecting positions with crv
pm.connectAttr(upCrv_info + ".controlPoints[%s]" % str(i),
trn.attr("translate"))
# joints
jntRoot = primitive.addJointFromPos(jnt_root,
setName("upEyelid_jnt_base", i),
pos=bboxCenter)
jntRoot.attr("radius").set(0.08)
jntRoot.attr("visibility").set(False)
upperEyelid_jntRoot.append(jntRoot)
applyop.aimCns(jntRoot,
trn,
axis=axis,
wupObject=jnt_root,
wupVector=wupVector)
jnt_ref = primitive.addJointFromPos(jntRoot,
setName("upEyelid_jnt_ref", i),
pos=cv)
jnt_ref.attr("radius").set(0.08)
jnt_ref.attr("visibility").set(False)
jnt = rigbits.addJnt(jnt_ref,
jnt_base,
grp=defset,
jntName=setName("upEyelid_jnt", i))
upperEyelid_jnt.append(jnt)
# Lower Eyelid joints ##################################################
cvs = low_crv.getCVs(space="world")
lowCrv_info = node.createCurveInfoNode(low_crv)
# aim constrain targets and joints
lowerEyelid_aimTargets = []
lowerEyelid_jnt = []
lowerEyelid_jntRoot = []
for i, cv in enumerate(cvs):
if i in [0, len(cvs) - 1]:
continue
if i % everyNVertex:
continue
# aim targets
trn = primitive.addTransformFromPos(eyeTargets_root,
setName("lowEyelid_aimTarget", i),
pos=cv)
lowerEyelid_aimTargets.append(trn)
# connecting positions with crv
pm.connectAttr(lowCrv_info + ".controlPoints[%s]" % str(i),
trn.attr("translate"))
# joints
jntRoot = primitive.addJointFromPos(jnt_root,
setName("lowEyelid_base", i),
pos=bboxCenter)
jntRoot.attr("radius").set(0.08)
jntRoot.attr("visibility").set(False)
lowerEyelid_jntRoot.append(jntRoot)
applyop.aimCns(jntRoot,
trn,
axis=axis,
wupObject=jnt_root,
wupVector=wupVector)
jnt_ref = primitive.addJointFromPos(jntRoot,
setName("lowEyelid_jnt_ref", i),
pos=cv)
jnt_ref.attr("radius").set(0.08)
jnt_ref.attr("visibility").set(False)
jnt = rigbits.addJnt(jnt_ref,
jnt_base,
grp=defset,
jntName=setName("lowEyelid_jnt", i))
lowerEyelid_jnt.append(jnt)
# Adding channels for eye tracking
upVTracking_att = attribute.addAttribute(up_ctl,
"vTracking",
"float",
upperVTrack,
minValue=0)
upHTracking_att = attribute.addAttribute(up_ctl,
"hTracking",
"float",
upperHTrack,
minValue=0)
lowVTracking_att = attribute.addAttribute(low_ctl,
"vTracking",
"float",
lowerVTrack,
minValue=0)
lowHTracking_att = attribute.addAttribute(low_ctl,
"hTracking",
"float",
lowerHTrack,
minValue=0)
# vertical tracking connect
up_mult_node = node.createMulNode(upVTracking_att,
aimTrigger_ref.attr("ty"))
low_mult_node = node.createMulNode(lowVTracking_att,
aimTrigger_ref.attr("ty"))
# remap to use the low or the up eyelid as driver contact base on
# the eyetrack trigger direction
uT_remap_node = pm.createNode("remapValue")
aimTrigger_ref.attr("ty") >> uT_remap_node.inputValue
uT_remap_node.inputMax.set(0.1)
uT_remap_node.inputMin.set(-0.1)
up_mult_node.outputX >> uT_remap_node.outputMax
low_mult_node.outputX >> uT_remap_node.outputMin
# up
u_remap_node = pm.createNode("remapValue")
contact_div_node.outputX >> u_remap_node.inputValue
u_remap_node.value[0].value_Interp.set(2)
u_remap_node.inputMin.set(0.9)
up_mult_node.outputX >> u_remap_node.outputMin
uT_remap_node.outColorR >> u_remap_node.outputMax
# low
l_remap_node = pm.createNode("remapValue")
contact_div_node.outputX >> l_remap_node.inputValue
l_remap_node.value[0].value_Interp.set(2)
l_remap_node.inputMin.set(0.9)
low_mult_node.outputX >> l_remap_node.outputMin
uT_remap_node.outColorR >> l_remap_node.outputMax
# up connect and turn down to low when contact
pm.connectAttr(u_remap_node.outColorR, trackLvl[0].attr("ty"))
pm.connectAttr(l_remap_node.outColorR, trackLvl[1].attr("ty"))
# horizontal tracking connect
mult_node = node.createMulNode(upHTracking_att, aimTrigger_ref.attr("tx"))
# Correct right side horizontal tracking
# if side == "R":
# mult_node = node.createMulNode(mult_node.attr("outputX"), -1)
pm.connectAttr(mult_node + ".outputX", trackLvl[0].attr("tx"))
mult_node = node.createMulNode(lowHTracking_att, aimTrigger_ref.attr("tx"))
# Correct right side horizontal tracking
# if side == "R":
# mult_node = node.createMulNode(mult_node.attr("outputX"), -1)
pm.connectAttr(mult_node + ".outputX", trackLvl[1].attr("tx"))
# adding channels for corner tracking
# track_corner_lvl
for i, ctl in enumerate(corner_ctl):
VTracking_att = attribute.addAttribute(ctl,
"vTracking",
"float",
0.1,
minValue=0)
if z_up:
mult_node = node.createMulNode(VTracking_att, up_ctl.tz)
mult_node2 = node.createMulNode(VTracking_att, low_ctl.tz)
plus_node = node.createPlusMinusAverage1D(
[mult_node.outputX, mult_node2.outputX])
mult_node3 = node.createMulNode(plus_node.output1D, -1)
pm.connectAttr(mult_node3.outputX, track_corner_lvl[i].attr("ty"))
else:
mult_node = node.createMulNode(VTracking_att, up_ctl.ty)
mult_node2 = node.createMulNode(VTracking_att, low_ctl.ty)
plus_node = node.createPlusMinusAverage1D(
[mult_node.outputX, mult_node2.outputX])
pm.connectAttr(plus_node.output1D, track_corner_lvl[i].attr("ty"))
###########################################
# Reparenting
###########################################
if parent_node:
try:
if isinstance(parent_node, string_types):
parent_node = pm.PyNode(parent_node)
parent_node.addChild(eye_root)
except pm.MayaNodeError:
pm.displayWarning("The eye rig can not be parent to: %s. Maybe "
"this object doesn't exist." % parent_node)
###########################################
# Auto Skinning
###########################################
if doSkin:
# eyelid vertex rows
totalLoops = rigidLoops + falloffLoops
vertexLoopList = meshNavigation.getConcentricVertexLoop(
vertexList, totalLoops)
vertexRowList = meshNavigation.getVertexRowsFromLoops(vertexLoopList)
# we set the first value 100% for the first initial loop
skinPercList = [1.0]
# we expect to have a regular grid topology
for r in range(rigidLoops):
for rr in range(2):
skinPercList.append(1.0)
increment = 1.0 / float(falloffLoops)
# we invert to smooth out from 100 to 0
inv = 1.0 - increment
for r in range(falloffLoops):
for rr in range(2):
if inv < 0.0:
inv = 0.0
skinPercList.append(inv)
inv -= increment
# this loop add an extra 0.0 indices to avoid errors
for r in range(10):
for rr in range(2):
skinPercList.append(0.0)
# base skin
geo = pm.listRelatives(edgeLoopList[0], parent=True)[0]
# Check if the object has a skinCluster
objName = pm.listRelatives(geo, parent=True)[0]
skinCluster = skin.getSkinCluster(objName)
if not skinCluster:
skinCluster = pm.skinCluster(headJnt,
geo,
tsb=True,
nw=2,
n="skinClsEyelid")
eyelidJoints = upperEyelid_jnt + lowerEyelid_jnt
pm.progressWindow(title="Auto skinning process",
progress=0,
max=len(eyelidJoints))
firstBoundary = False
for jnt in eyelidJoints:
pm.progressWindow(e=True, step=1, status="\nSkinning %s" % jnt)
skinCluster.addInfluence(jnt, weight=0)
v = meshNavigation.getClosestVertexFromTransform(geo, jnt)
for row in vertexRowList:
if v in row:
it = 0 # iterator
inc = 1 # increment
for i, rv in enumerate(row):
try:
perc = skinPercList[it]
t_val = [(jnt, perc), (headJnt, 1.0 - perc)]
pm.skinPercent(skinCluster,
rv,
transformValue=t_val)
if rv.isOnBoundary():
# we need to compare with the first boundary
# to check if the row have inverted direction
# and offset the value
if not firstBoundary:
firstBoundary = True
firstBoundaryValue = it
else:
if it < firstBoundaryValue:
it -= 1
elif it > firstBoundaryValue:
it += 1
inc = 2
except IndexError:
continue
it = it + inc
pm.progressWindow(e=True, endProgress=True)
# Eye Mesh skinning
skinCluster = skin.getSkinCluster(eyeMesh)
if not skinCluster:
skinCluster = pm.skinCluster(eyeCenter_jnt,
eyeMesh,
tsb=True,
nw=1,
n="skinClsEye")
def up_axis():
return pm.upAxis(q=True, axis=True)
def addObjects(self):
"""Add all the objects needed to create the component."""
self.up_axis = pm.upAxis(q=True, axis=True)
self.div_count = len(self.guide.apos) - 5
plane = [self.guide.apos[0], self.guide.apos[-4], self.guide.apos[-3]]
self.normal = self.getNormalFromPos(plane)
self.binormal = self.getBiNormalFromPos(plane)
# Heel ---------------------------------------------
# bank pivot
t = transform.getTransformLookingAt(self.guide.pos["heel"],
self.guide.apos[-4], self.normal,
"xz", self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["inpivot"])
self.in_npo = primitive.addTransform(self.root, self.getName("in_npo"),
t)
self.in_piv = primitive.addTransform(self.in_npo,
self.getName("in_piv"), t)
t = transform.setMatrixPosition(t, self.guide.pos["outpivot"])
self.out_piv = primitive.addTransform(self.in_piv,
self.getName("out_piv"), t)
# heel
t = transform.getTransformLookingAt(self.guide.pos["heel"],
self.guide.apos[-4], self.normal,
"xz", self.negate)
self.heel_loc = primitive.addTransform(self.out_piv,
self.getName("heel_loc"), t)
attribute.setRotOrder(self.heel_loc, "YZX")
self.heel_ctl = self.addCtl(self.heel_loc,
"heel_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .1,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.heel_ctl, self.r_params)
# Tip ----------------------------------------------
if self.up_axis == "y":
v = datatypes.Vector(self.guide.apos[-5].x,
self.guide.pos["heel"].y,
self.guide.apos[-5].z)
else:
v = datatypes.Vector(self.guide.apos[-5].x, self.guide.apos[-5].y,
self.guide.pos["heel"].z)
t = transform.setMatrixPosition(t, v)
self.tip_ctl = self.addCtl(self.heel_ctl,
"tip_ctl",
t,
self.color_ik,
"circle",
w=self.size,
tp=self.heel_ctl)
attribute.setKeyableAttributes(self.tip_ctl, self.r_params)
# Roll ---------------------------------------------
if self.settings["useRollCtl"]:
t = transform.getTransformLookingAt(self.guide.pos["heel"],
self.guide.apos[-4],
self.normal, "xz", self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["root"])
self.roll_np = primitive.addTransform(self.root,
self.getName("roll_npo"), t)
self.roll_ctl = self.addCtl(self.roll_np,
"roll_ctl",
t,
self.color_ik,
"cylinder",
w=self.size * .5,
h=self.size * .5,
ro=datatypes.Vector(3.1415 * .5, 0, 0),
tp=self.tip_ctl)
attribute.setKeyableAttributes(self.roll_ctl, ["rx", "rz"])
# Backward Controlers ------------------------------
bk_pos = self.guide.apos[1:-3]
bk_pos.reverse()
parent = self.tip_ctl
self.bk_ctl = []
self.bk_loc = []
self.previousTag = self.tip_ctl
for i, pos in enumerate(bk_pos):
if i == 0:
t = transform.getTransform(self.heel_ctl)
t = transform.setMatrixPosition(t, pos)
else:
direction = bk_pos[i - 1]
t = transform.getTransformLookingAt(pos, direction,
self.normal, "xz",
self.negate)
bk_loc = primitive.addTransform(parent,
self.getName("bk%s_loc" % i), t)
bk_ctl = self.addCtl(bk_loc,
"bk%s_ctl" % i,
t,
self.color_ik,
"sphere",
w=self.size * .15,
tp=self.previousTag)
attribute.setKeyableAttributes(bk_ctl, self.r_params)
self.previousTag = bk_ctl
self.bk_loc.append(bk_loc)
self.bk_ctl.append(bk_ctl)
parent = bk_ctl
# FK Reference ------------------------------------
self.fk_ref = primitive.addTransformFromPos(self.bk_ctl[-1],
self.getName("fk_ref"),
self.guide.apos[0])
self.fk_npo = primitive.addTransform(
self.fk_ref, self.getName("fk0_npo"),
transform.getTransform(self.bk_ctl[-1]))
# Forward Controlers ------------------------------
self.fk_ctl = []
self.fk_loc = []
parent = self.fk_npo
self.previousTag = self.tip_ctl
for i, bk_ctl in enumerate(reversed(self.bk_ctl[1:])):
if i == len(self.bk_ctl) - 2:
t = transform.getTransform(self.tip_ctl)
v = transform.getTranslation(bk_ctl)
t = transform.setMatrixPosition(t, v)
else:
t = transform.getTransform(bk_ctl)
dist = vector.getDistance(self.guide.apos[i + 1],
self.guide.apos[i + 2])
fk_loc = primitive.addTransform(parent,
self.getName("fk%s_loc" % i), t)
po_vec = datatypes.Vector(dist * .5 * self.n_factor, 0, 0)
fk_ctl = self.addCtl(fk_loc,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=dist,
h=self.size * .5,
d=self.size * .5,
po=po_vec,
tp=self.previousTag)
self.previousTag = fk_ctl
attribute.setKeyableAttributes(fk_ctl)
if i:
name = "ball" + str(i)
else:
name = "ball"
self.jnt_pos.append([fk_ctl, name])
parent = fk_ctl
self.fk_ctl.append(fk_ctl)
self.fk_loc.append(fk_loc)
def addObjects(self):
"""Add all the objects needed to create the component."""
self.up_axis = pm.upAxis(q=True, axis=True)
# Auto bend with position controls -------------------
if self.settings["autoBend"]:
self.autoBendChain = primitive.add2DChain(
self.root,
self.getName("autoBend%s_jnt"),
[self.guide.apos[0], self.guide.apos[-1]],
self.guide.blades["blade"].z * -1,
False,
True,
)
for j in self.autoBendChain:
j.drawStyle.set(2)
# Ik Controlers ------------------------------------
if self.settings["IKWorldOri"]:
t = datatypes.TransformationMatrix()
t = transform.setMatrixPosition(t, self.guide.apos[0])
else:
t = transform.getTransformLookingAt(
self.guide.apos[0],
self.guide.apos[-1],
self.guide.blades["blade"].z * -1,
"yx",
self.negate,
)
self.ik_off = primitive.addTransform(self.root, self.getName("ik_off"),
t)
# handle Z up orientation offset
if self.up_axis == "z" and self.settings["IKWorldOri"]:
self.ik_off.rx.set(90)
t = transform.getTransform(self.ik_off)
self.ik0_npo = primitive.addTransform(self.ik_off,
self.getName("ik0_npo"), t)
self.ik0_ctl = self.addCtl(
self.ik0_npo,
"ik0_ctl",
t,
self.color_ik,
"compas",
w=self.size,
tp=self.parentCtlTag,
)
attribute.setKeyableAttributes(self.ik0_ctl, self.tr_params)
attribute.setRotOrder(self.ik0_ctl, "ZXY")
attribute.setInvertMirror(self.ik0_ctl, ["tx", "ry", "rz"])
# hip base joint
# TODO: add option in setting for on/off
if True:
self.hip_lvl = primitive.addTransform(self.ik0_ctl,
self.getName("hip_lvl"), t)
self.jnt_pos.append([self.hip_lvl, "pelvis"])
t = transform.setMatrixPosition(t, self.guide.apos[-1])
if self.settings["autoBend"]:
self.autoBend_npo = primitive.addTransform(
self.root, self.getName("spinePosition_npo"), t)
self.autoBend_ctl = self.addCtl(
self.autoBend_npo,
"spinePosition_ctl",
t,
self.color_ik,
"square",
w=self.size,
d=0.3 * self.size,
tp=self.parentCtlTag,
)
attribute.setKeyableAttributes(self.autoBend_ctl,
["tx", "ty", "tz", "ry"])
attribute.setInvertMirror(self.autoBend_ctl, ["tx", "ry"])
self.ik1_npo = primitive.addTransform(self.autoBendChain[0],
self.getName("ik1_npo"), t)
self.ik1autoRot_lvl = primitive.addTransform(
self.ik1_npo, self.getName("ik1autoRot_lvl"), t)
self.ik1_ctl = self.addCtl(
self.ik1autoRot_lvl,
"ik1_ctl",
t,
self.color_ik,
"compas",
w=self.size,
tp=self.autoBend_ctl,
)
else:
t = transform.setMatrixPosition(t, self.guide.apos[-1])
self.ik1_npo = primitive.addTransform(self.root,
self.getName("ik1_npo"), t)
self.ik1_ctl = self.addCtl(
self.ik1_npo,
"ik1_ctl",
t,
self.color_ik,
"compas",
w=self.size,
tp=self.ik0_ctl,
)
attribute.setKeyableAttributes(self.ik1_ctl, self.tr_params)
attribute.setRotOrder(self.ik1_ctl, "ZXY")
attribute.setInvertMirror(self.ik1_ctl, ["tx", "ry", "rz"])
# Tangent controllers -------------------------------
if self.settings["centralTangent"]:
# vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
# self.guide.apos[-1],
# .33)
vec_pos = self.guide.pos["tan0"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan0_npo = primitive.addTransform(self.ik0_ctl,
self.getName("tan0_npo"), t)
self.tan0_off = primitive.addTransform(self.tan0_npo,
self.getName("tan0_off"), t)
self.tan0_ctl = self.addCtl(
self.tan0_off,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.1,
tp=self.ik0_ctl,
)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
# vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
# self.guide.apos[-1],
# .66)
vec_pos = self.guide.pos["tan1"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan1_npo = primitive.addTransform(self.ik1_ctl,
self.getName("tan1_npo"), t)
self.tan1_off = primitive.addTransform(self.tan1_npo,
self.getName("tan1_off"), t)
self.tan1_ctl = self.addCtl(
self.tan1_off,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.1,
tp=self.ik0_ctl,
)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
# Tangent mid control
vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
self.guide.apos[-1], 0.5)
t = transform.setMatrixPosition(t, vec_pos)
self.tan_npo = primitive.addTransform(self.tan0_npo,
self.getName("tan_npo"), t)
self.tan_ctl = self.addCtl(
self.tan_npo,
"tan_ctl",
t,
self.color_fk,
"sphere",
w=self.size * 0.2,
tp=self.ik1_ctl,
)
attribute.setKeyableAttributes(self.tan_ctl, self.t_params)
attribute.setInvertMirror(self.tan_ctl, ["tx"])
else:
# vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
# self.guide.apos[-1],
# .33)
vec_pos = self.guide.pos["tan0"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan0_npo = primitive.addTransform(self.ik0_ctl,
self.getName("tan0_npo"), t)
self.tan0_ctl = self.addCtl(
self.tan0_npo,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.2,
tp=self.ik0_ctl,
)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
# vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
# self.guide.apos[-1],
# .66)
vec_pos = self.guide.pos["tan1"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan1_npo = primitive.addTransform(self.ik1_ctl,
self.getName("tan1_npo"), t)
self.tan1_ctl = self.addCtl(
self.tan1_npo,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.2,
tp=self.ik1_ctl,
)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
attribute.setInvertMirror(self.tan0_ctl, ["tx"])
attribute.setInvertMirror(self.tan1_ctl, ["tx"])
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root,
self.getName("mst_crv"),
[self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl],
3,
)
self.slv_crv = curve.addCurve(
self.root,
self.getName("slv_crv"),
[datatypes.Vector()] * 10,
False,
3,
)
self.mst_crv.setAttr("visibility", False)
self.slv_crv.setAttr("visibility", False)
# Division -----------------------------------------
# The user only define how many intermediate division he wants.
# First and last divisions are an obligation.
parentdiv = self.root
parentctl = self.root
self.div_cns = []
self.fk_ctl = []
self.fk_npo = []
self.scl_transforms = []
self.twister = []
self.ref_twist = []
t = transform.getTransformLookingAt(
self.guide.apos[0],
self.guide.apos[-1],
self.guide.blades["blade"].z * -1,
"yx",
self.negate,
)
parent_twistRef = primitive.addTransform(
self.root,
self.getName("reference"),
transform.getTransform(self.root),
)
self.jointList = []
self.preiviousCtlTag = self.parentCtlTag
# handle Z up orientation offset
# parentctl = primitive.addTransform(
# parentctl,
# self.getName("fk0_off"),
# transform.getTransform(parentctl))
# if self.up_axis == "z":
# parentctl.rx.set(90)
for i in range(self.settings["division"]):
# References
div_cns = primitive.addTransform(parentdiv,
self.getName("%s_cns" % i))
pm.setAttr(div_cns + ".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
# Controlers (First and last one are fake)
# if i in [0]:
# TODO: add option setting to add or not the first and
# last controller for the fk
if i in [0, self.settings["division"] - 1] and False:
# if i in [0, self.settings["division"] - 1]:
fk_ctl = primitive.addTransform(
parentctl,
self.getName("%s_loc" % i),
transform.getTransform(parentctl),
)
fk_npo = fk_ctl
if i in [self.settings["division"] - 1]:
self.fk_ctl.append(fk_ctl)
else:
m = transform.getTransform(self.root)
t = transform.getTransform(parentctl)
m.inverse()
fk_npo = primitive.addTransform(parentctl,
self.getName("fk%s_npo" % (i)),
t)
fk_ctl = self.addCtl(
fk_npo,
"fk%s_ctl" % (i),
transform.getTransform(parentctl),
self.color_fk,
"cube",
w=self.size,
h=self.size * 0.05,
d=self.size,
tp=self.preiviousCtlTag,
)
attribute.setKeyableAttributes(self.fk_ctl)
attribute.setRotOrder(fk_ctl, "ZXY")
self.fk_ctl.append(fk_ctl)
self.preiviousCtlTag = fk_ctl
self.fk_npo.append(fk_npo)
parentctl = fk_ctl
scl_ref = primitive.addTransform(
parentctl,
self.getName("%s_scl_ref" % i),
transform.getTransform(parentctl),
)
self.scl_transforms.append(scl_ref)
# Deformers (Shadow)
# self.jnt_pos.append([scl_ref, i])
self.jnt_pos.append([scl_ref, "spine_" + str(i + 1).zfill(2)])
# Twist references (This objects will replace the spinlookup
# slerp solver behavior)
t = transform.getTransformLookingAt(
self.guide.apos[0],
self.guide.apos[-1],
self.guide.blades["blade"].z * -1,
"yx",
self.negate,
)
twister = primitive.addTransform(parent_twistRef,
self.getName("%s_rot_ref" % i), t)
ref_twist = primitive.addTransform(parent_twistRef,
self.getName("%s_pos_ref" % i),
t)
ref_twist.setTranslation(datatypes.Vector(1.0, 0, 0),
space="preTransform")
self.twister.append(twister)
self.ref_twist.append(ref_twist)
# TODO: update this part with the optiona FK controls update
for x in self.fk_ctl[:-1]:
attribute.setInvertMirror(x, ["tx", "rz", "ry"])
# Connections (Hooks) ------------------------------
self.cnx0 = primitive.addTransform(self.root, self.getName("0_cnx"))
self.cnx1 = primitive.addTransform(self.root, self.getName("1_cnx"))
def addObjects(self):
"""Add all the objects needed to create the component."""
self.up_axis = pm.upAxis(q=True, axis=True)
# joint Description Names
jd_names = ast.literal_eval(
self.settings["jointNamesDescription_custom"]
)
jdn_pelvis = jd_names[0]
jdn_spine = jd_names[1]
# Auto bend with position controls -------------------
if self.settings["autoBend"]:
self.autoBendChain = primitive.add2DChain(
self.root,
self.getName("autoBend%s_jnt"),
[self.guide.apos[1], self.guide.apos[-2]],
self.guide.blades["blade"].z * -1,
False,
True,
)
for j in self.autoBendChain:
j.drawStyle.set(2)
# Ik Controlers ------------------------------------
if self.settings["IKWorldOri"]:
t = datatypes.TransformationMatrix()
t = transform.setMatrixPosition(t, self.guide.apos[1])
else:
t = transform.getTransformLookingAt(
self.guide.apos[1],
self.guide.apos[-2],
self.guide.blades["blade"].z * -1,
"yx",
self.negate,
)
self.ik_off = primitive.addTransform(
self.root, self.getName("ik_off"), t
)
# handle Z up orientation offset
if self.up_axis == "z" and self.settings["IKWorldOri"]:
self.ik_off.rx.set(90)
t = transform.getTransform(self.ik_off)
self.ik0_npo = primitive.addTransform(
self.ik_off, self.getName("ik0_npo"), t
)
self.ik0_ctl = self.addCtl(
self.ik0_npo,
"ik0_ctl",
t,
self.color_ik,
"compas",
w=self.size,
tp=self.parentCtlTag,
)
attribute.setKeyableAttributes(self.ik0_ctl, self.tr_params)
attribute.setRotOrder(self.ik0_ctl, "ZXY")
attribute.setInvertMirror(self.ik0_ctl, ["tx", "ry", "rz"])
# pelvis
self.length0 = vector.getDistance(
self.guide.apos[0], self.guide.apos[1]
)
vec_po = datatypes.Vector(0, 0.5 * self.length0 * -1, 0)
self.pelvis_npo = primitive.addTransform(
self.ik0_ctl, self.getName("pelvis_npo"), t
)
self.pelvis_ctl = self.addCtl(
self.pelvis_npo,
"pelvis_ctl",
t,
self.color_ik,
"cube",
h=self.length0,
w=self.size * 0.1,
d=self.size * 0.1,
po=vec_po,
tp=self.parentCtlTag,
)
self.pelvis_lvl = primitive.addTransform(
self.pelvis_ctl,
self.getName("pelvis_lvl"),
transform.setMatrixPosition(t, self.guide.apos[0]),
)
self.jnt_pos.append([self.pelvis_lvl, jdn_pelvis])
t = transform.setMatrixPosition(t, self.guide.apos[-2])
if self.settings["autoBend"]:
self.autoBend_npo = primitive.addTransform(
self.root, self.getName("spinePosition_npo"), t
)
self.autoBend_ctl = self.addCtl(
self.autoBend_npo,
"spinePosition_ctl",
t,
self.color_ik,
"square",
w=self.size,
d=0.3 * self.size,
tp=self.parentCtlTag,
)
attribute.setKeyableAttributes(
self.autoBend_ctl, ["tx", "ty", "tz", "ry"]
)
attribute.setInvertMirror(self.autoBend_ctl, ["tx", "ry"])
self.ik1_npo = primitive.addTransform(
self.autoBendChain[0], self.getName("ik1_npo"), t
)
self.ik1autoRot_lvl = primitive.addTransform(
self.ik1_npo, self.getName("ik1autoRot_lvl"), t
)
self.ik1_ctl = self.addCtl(
self.ik1autoRot_lvl,
"ik1_ctl",
t,
self.color_ik,
"compas",
w=self.size,
tp=self.autoBend_ctl,
)
else:
t = transform.setMatrixPosition(t, self.guide.apos[-2])
self.ik1_npo = primitive.addTransform(
self.root, self.getName("ik1_npo"), t
)
self.ik1_ctl = self.addCtl(
self.ik1_npo,
"ik1_ctl",
t,
self.color_ik,
"compas",
w=self.size,
tp=self.ik0_ctl,
)
attribute.setKeyableAttributes(self.ik1_ctl, self.tr_params)
attribute.setRotOrder(self.ik1_ctl, "ZXY")
attribute.setInvertMirror(self.ik1_ctl, ["tx", "ry", "rz"])
# Tangent controllers -------------------------------
if self.settings["centralTangent"]:
vec_pos = self.guide.pos["tan0"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan0_npo = primitive.addTransform(
self.ik0_ctl, self.getName("tan0_npo"), t
)
self.tan0_off = primitive.addTransform(
self.tan0_npo, self.getName("tan0_off"), t
)
self.tan0_ctl = self.addCtl(
self.tan0_off,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.1,
tp=self.ik0_ctl,
)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
vec_pos = self.guide.pos["tan1"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan1_npo = primitive.addTransform(
self.ik1_ctl, self.getName("tan1_npo"), t
)
self.tan1_off = primitive.addTransform(
self.tan1_npo, self.getName("tan1_off"), t
)
self.tan1_ctl = self.addCtl(
self.tan1_off,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.1,
tp=self.ik0_ctl,
)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
# Tangent mid control
vec_pos = vector.linearlyInterpolate(
self.guide.apos[1], self.guide.apos[-2], 0.5
)
t = transform.setMatrixPosition(t, vec_pos)
self.tan_npo = primitive.addTransform(
self.tan0_npo, self.getName("tan_npo"), t
)
self.tan_ctl = self.addCtl(
self.tan_npo,
"tan_ctl",
t,
self.color_fk,
"sphere",
w=self.size * 0.2,
tp=self.ik1_ctl,
)
attribute.setKeyableAttributes(self.tan_ctl, self.t_params)
attribute.setInvertMirror(self.tan_ctl, ["tx"])
else:
vec_pos = self.guide.pos["tan0"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan0_npo = primitive.addTransform(
self.ik0_ctl, self.getName("tan0_npo"), t
)
self.tan0_ctl = self.addCtl(
self.tan0_npo,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.2,
tp=self.ik0_ctl,
)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
vec_pos = self.guide.pos["tan1"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan1_npo = primitive.addTransform(
self.ik1_ctl, self.getName("tan1_npo"), t
)
self.tan1_ctl = self.addCtl(
self.tan1_npo,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.2,
tp=self.ik1_ctl,
)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
attribute.setInvertMirror(self.tan0_ctl, ["tx"])
attribute.setInvertMirror(self.tan1_ctl, ["tx"])
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root,
self.getName("mst_crv"),
[self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl],
3,
)
self.slv_crv = curve.addCurve(
self.root,
self.getName("slv_crv"),
[datatypes.Vector()] * 10,
False,
3,
)
self.mst_crv.setAttr("visibility", False)
self.slv_crv.setAttr("visibility", False)
# Division -----------------------------------------
# The user only define how many intermediate division he wants.
# First and last divisions are an obligation.
parentdiv = self.root
parentctl = self.root
self.div_cns = []
self.fk_ctl = []
self.fk_npo = []
self.scl_transforms = []
self.twister = []
self.ref_twist = []
t = transform.getTransformLookingAt(
self.guide.apos[1],
self.guide.apos[-2],
self.guide.blades["blade"].z * -1,
"yx",
self.negate,
)
parent_twistRef = primitive.addTransform(
self.root,
self.getName("reference"),
transform.getTransform(self.root),
)
self.jointList = []
self.preiviousCtlTag = self.parentCtlTag
for i in range(self.settings["division"]):
# References
div_cns = primitive.addTransform(
parentdiv, self.getName("%s_cns" % i)
)
pm.setAttr(div_cns + ".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
t = transform.getTransform(parentctl)
fk_npo = primitive.addTransform(
parentctl, self.getName("fk%s_npo" % (i)), t
)
fk_ctl = self.addCtl(
fk_npo,
"fk%s_ctl" % (i),
transform.getTransform(parentctl),
self.color_fk,
"cube",
w=self.size,
h=self.size * 0.05,
d=self.size,
tp=self.preiviousCtlTag,
)
attribute.setKeyableAttributes(self.fk_ctl)
attribute.setRotOrder(fk_ctl, "ZXY")
self.fk_ctl.append(fk_ctl)
self.preiviousCtlTag = fk_ctl
self.fk_npo.append(fk_npo)
parentctl = fk_ctl
if i == self.settings["division"] - 1:
t = transform.getTransformLookingAt(
self.guide.pos["spineTop"],
self.guide.pos["chest"],
self.guide.blades["blade"].z * -1,
"yx",
False,
)
scl_ref_parent = self.root
else:
t = transform.getTransform(parentctl)
scl_ref_parent = parentctl
scl_ref = primitive.addTransform(
scl_ref_parent, self.getName("%s_scl_ref" % i), t
)
self.scl_transforms.append(scl_ref)
# Deformers (Shadow)
self.jnt_pos.append(
[scl_ref, string.replaceSharpWithPadding(jdn_spine, i + 1)]
)
# Twist references (This objects will replace the spinlookup
# slerp solver behavior)
t = transform.getTransformLookingAt(
self.guide.apos[0],
self.guide.apos[1],
self.guide.blades["blade"].z * -1,
"yx",
self.negate,
)
twister = primitive.addTransform(
parent_twistRef, self.getName("%s_rot_ref" % i), t
)
ref_twist = primitive.addTransform(
parent_twistRef, self.getName("%s_pos_ref" % i), t
)
ref_twist.setTranslation(
datatypes.Vector(1.0, 0, 0), space="preTransform"
)
self.twister.append(twister)
self.ref_twist.append(ref_twist)
for x in self.fk_ctl[:-1]:
attribute.setInvertMirror(x, ["tx", "rz", "ry"])
# Connections (Hooks) ------------------------------
self.cnx0 = primitive.addTransform(self.root, self.getName("0_cnx"))
self.cnx1 = primitive.addTransform(self.root, self.getName("1_cnx"))
self.jnt_pos.append(
[self.cnx1, string.replaceSharpWithPadding(jdn_spine, i + 2)]
)
