def addAttributes(self):
super(Component, self).addAttributes()
ref_names = self.get_valid_alias_list(
self.settings.get("fkrefarray", "").split(","))
ref_names.insert(0, "self")
if not self.settings["fkrefarray"]:
self.fkref_att = self.addAnimEnumParam("fkref", "Fk Ref", 0,
ref_names)
else:
self.fkref_att = self.addAnimEnumParam("fkref", "Fk Ref", 1,
ref_names)
for x in self.fk_ctl:
att.setInvertMirror(x, ["tx", "ty", "tz"])
att.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.length0 = vector.getDistance(self.guide.apos[0],
self.guide.apos[1])
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis="xy",
negate=self.negate)
self.npo = primitive.addTransform(self.root, self.getName("npo"), t)
self.ctl = self.addCtl(
self.npo,
"ctl",
t,
self.color_fk,
"cube",
w=self.length0,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0),
tp=self.parentCtlTag)
self.mtx = primitive.addTransform(self.npo, self.getName("mtx"), t)
t1 = transform.setMatrixPosition(t, self.guide.apos[1])
t2 = transform.getInterpolateTransformMatrix(t, t1, blend=0.98)
self.loc = primitive.addTransform(self.mtx, self.getName("loc"), t2)
self.end = primitive.addTransform(self.ctl, self.getName("end"), t1)
self.jnt_pos.append([self.mtx, "root"])
self.jnt_pos.append([self.loc, 'end'])
attribute.setKeyableAttributes(self.ctl)
attribute.setInvertMirror(self.ctl, ["tx", "ty", "tz"])
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])
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.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)
self.fk0_npo = primitive.addTransform(self.root,
self.getName("fk0_npo"), t)
vec_po = 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=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)
self.fk1_npo = primitive.addTransform(self.fk0_ctl,
self.getName("fk1_npo"), t)
vec_po = 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=vec_po,
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)
# Define the wrist transform (wt)
if self.settings["guideOrientWrist"]:
wt = self.guide.tra["wrist"]
if self.settings["mirrorIK"] and self.negate:
scl = [1, 1, -1]
else:
scl = [1, 1, 1]
wt = transform.setMatrixScale(wt, scl)
t = wt
self.fk2_npo = primitive.addTransform(self.fk1_ctl,
self.getName("fk2_npo"), t)
vec_po = 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=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 * .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 * .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 * .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"])
if self.settings["guideOrientWrist"]:
t = wt
self.ik_cns.setMatrix(t)
self.ik_cns.setTranslation(self.guide.pos["wrist"], space="world")
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
t,
self.color_ik,
"null",
w=self.size * .12,
tp=self.parentCtlTag)
attribute.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"])
if self.negate:
m = transform.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal, "x-y", True)
else:
m = transform.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal, "xy", False)
if self.settings["guideOrientWrist"]:
m = wt
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
m,
self.color_ik,
"cube",
w=self.size * .12,
h=self.size * .12,
d=self.size * .12,
tp=self.roll_ctl)
if self.settings["mirrorIK"]:
if self.negate:
self.ik_cns.sx.set(-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 * .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
trnIK_ref = transform.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal, "xz",
self.negate)
if self.settings["guideOrientWrist"]:
trnIK_ref = wt
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 * .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, 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,
self.getName("ctrn_loc"),
self.guide.apos[1])
self.eff_loc = primitive.addTransformFromPos(self.root,
self.getName("eff_loc"),
self.guide.apos[2])
# 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.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)
self.tws0_loc = primitive.addTransform(
self.rollRef[0], 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))
# thickness control
self.thick_lvl = primitive.addTransform(
self.mid_ctl, self.getName("thickness_lvl"),
transform.getTransform(self.ctrn_loc))
self.thick_ctl = self.addCtl(self.thick_lvl,
"thickness_ctl",
transform.getTransform(self.mid_ctl),
self.color_ik,
"arrow",
w=self.size * .1,
ro=datatypes.Vector([0, 1.5708, 0]),
tp=self.mid_ctl)
if self.negate and not self.settings["mirrorMid"]:
self.thick_ctl.rz.set(180)
self.thick_ctl.sz.set(-1)
attribute.setKeyableAttributes(self.thick_ctl, ["tx", "ty"])
self.tws1B_loc = primitive.addTransform(
self.ctrn_loc, self.getName("tws1B_loc"),
transform.getTransform(self.ctrn_loc))
self.tws1B_rot = primitive.addTransform(
self.tws1B_loc, self.getName("tws1B_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]))
# angle reader ----------------------------------------
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[2], self.normal,
"xy")
self.readerA = primitive.addTransform(self.root,
self.getName("readerA_loc"), t)
self.readerB = primitive.addTransform(self.readerA,
self.getName("readerB_loc"), t)
self.readerB.rotateOrder.set(2)
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for the
# elbow. + 2 for elbow angle control
if self.settings["supportJoints"]:
ej = 2
else:
ej = 0
self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + ej
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 * .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)
self.jnt_pos.append([tweak_ctl, i, None, False])
else:
self.jnt_pos.append([div_cns, i])
# End reference ------------------------------------
# To help the deformation on the wrist
self.jnt_pos.append([self.eff_loc, 'end'])
# 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 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 _addObjectsFkControl(self, i, parentdiv, parentctl, t, parent_twistRef):
# References
tm = datatypes.TransformationMatrix(t)
tm.addRotation([0., 0., math.pi / -2.], 'XYZ', om.MSpace.kObject) # TODO: align with convention
tm.addRotation([0., math.pi / -2., 0], 'XYZ', om.MSpace.kObject)
global_t = datatypes.Matrix(tm)
# global input
div_cns = addTransform(parentdiv, self.getName("%s_cns" % i))
div_cns_npo = addTransform(div_cns, self.getName("%s_cns_npo" % i))
pm.setAttr(div_cns + ".inheritsTransform", False)
div_cns.setMatrix(global_t, worldSpace=True)
self.div_cns.append(div_cns)
self.div_cns_npo.append(div_cns_npo)
parentdiv = div_cns
# t = getTransform(parentctl)
if i == 0:
p = parentctl
else:
# p = self.scl_transforms[i - 1]
p = self.fk_local_in[i - 1]
fk_npo = addTransform(p, self.getName("fk%s_npo" % (i)), global_t)
# local input
fk_local_npo = addTransform(fk_npo, self.getName("fk%s_local_npo" % i), global_t)
fk_local_in = addTransform(fk_local_npo, self.getName("fk%s_local_in" % i), global_t)
self.fk_local_in.append(fk_local_in)
if i < len(self.guide.apos) - 1:
h = (self.guide.apos[i] - self.guide.apos[i + 1]).length() * .8
else:
h = (self.guide.apos[-1] - self.guide.apos[0]).length() / (len(self.guide.apos) - 1)
# FIXME: rotate by blade
po = datatypes.Vector([0, h / 2., 0])
fk_ctl = self.addCtl(
fk_local_in,
"fk%s_ctl" % (i),
global_t,
self.color_fk,
"cube",
w=h * .66,
h=h,
d=h * 0.3,
# ro=datatypes.Vector([0, -math.pi / 2., 0]),
po=po,
tp=self.preiviousCtlTag,
mirrorConf=self.mirror_conf)
ymt_util.setKeyableAttributesDontLockVisibility(self.fk_ctl)
attribute.setRotOrder(fk_ctl, "ZXY")
self.fk_ctl.append(fk_ctl)
self.preiviousCtlTag = fk_ctl
self.fk_npo.append(fk_npo)
self.fk_local_npo.append(fk_local_npo)
parentctl = fk_ctl
scl_ref = addTransform(parentctl, self.getName("%s_scl_ref" % i), getTransform(parentctl))
self.scl_transforms.append(scl_ref)
if i == 0 and self.settings["isSplitHip"]:
t = self._getTransformWithRollByBlade(getTransform(self.guide.root))
h = (self.guide.apos[-1] - self.guide.apos[0]).length() / (len(self.guide.apos) - 1)
po = datatypes.Vector([0, self.size / len(self.guide.apos) * -.8, 0])
hip_fk_local_in = addTransform(p, self.getName("hip_fk_local_in"), t)
self.hip_fk_local_in = hip_fk_local_in
self.fk_hip_ctl = self.addCtl(
hip_fk_local_in,
"fk_hip_ctl",
t,
self.color_fk,
"cube",
w=h * .66,
h=h,
d=h * 0.3,
# ro=datatypes.Vector([0, -math.pi / 2., 0]),
po=po,
tp=self.preiviousCtlTag,
mirrorConf=self.mirror_conf)
hip_scl_ref = addTransform(self.fk_hip_ctl, self.getName("hip_scl_ref"), t)
# Deformers (Shadow)
if self.settings["addJoints"]:
if self.settings["isSplitHip"]:
if i == 0:
self.jnt_pos.append([hip_scl_ref, 0])
self.jnt_pos.append([scl_ref, i + 1])
else:
self.jnt_pos.append([scl_ref, i])
# 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 = addTransform(
parent_twistRef, self.getName("%s_rot_ref" % i), t)
ref_twist = 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:
attribute.setInvertMirror(x, ["tx", "rz", "ry"])
attribute.setInvertMirror(self.fk_hip_ctl, ["tx", "rz", "ry"])
return parentdiv, parentctl
def addObjects(self):
self.normal = self.guide.blades["blade"].z * -1.
# Ik Controlers ------------------------------------
t = tra.getTransform(self.root)
t = tra.setMatrixPosition(t, self.guide.pos["neck"])
self.neck_cns = pri.addTransform(self.root, self.getName("neck_cns"),
t)
t = tra.getTransformLookingAt(self.guide.pos["neck"],
self.guide.pos["eff0"], self.normal,
"yx", self.negate)
t = tra.setMatrixPosition(t, self.guide.pos["neck"])
self.neck_npo = pri.addTransform(self.neck_cns,
self.getName("neck_npo"), t)
w = self.size * 0.5
# for compatibility reason, this name is not neck_ctl, but ik_ctl
self.neck_ctl = self.addCtl(self.neck_npo,
"ik_ctl",
t,
self.color_ik,
"compas",
w=w)
att.setKeyableAttributes(self.neck_ctl)
att.setRotOrder(self.neck_ctl, "ZXY")
self.jnt_pos.append([self.neck_ctl, 0])
t = tra.getTransformLookingAt(self.guide.pos["head"],
self.guide.pos["eff1"], self.normal,
"yx", self.negate)
self.head_pos_ref = pri.addTransform(self.neck_ctl,
self.getName("head_pos_ref"), t)
# TODO: Division -----------------------------------------
# Head ---------------------------------------------
t = tra.getTransform(self.root)
t = tra.setMatrixPosition(t, self.guide.pos["head"])
self.head_cns = pri.addTransform(self.root, self.getName("head_cns"),
t)
t = tra.getTransformLookingAt(self.guide.pos["head"],
self.guide.pos["eff1"], self.normal,
"yx", self.negate)
self.head_npo = pri.addTransform(self.head_cns,
self.getName("head_npo"), t)
dist = vec.getDistance(self.guide.pos["head"], self.guide.pos["eff1"])
w = self.size * 0.5
h = dist
d = self.size * 0.5
po = dt.Vector(0, dist * 0.5, 0)
self.head_ctl = self.addCtl(self.head_npo,
"head_ctl",
t,
self.color_fk,
"cube",
w=w,
h=h,
d=d,
po=po)
att.setRotOrder(self.head_ctl, "ZXY")
att.setInvertMirror(self.neck_ctl, ["tx", "ry", "rz"])
att.setInvertMirror(self.head_ctl, ["tx", "ry", "rz"])
self.jnt_pos.append([self.head_ctl, "head"])
def addObjects(self):
"""Add all the objects needed to create the component."""
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])
# FK Controlers -----------------------------------
# *ms* set npo @ Tpose, to make the fk rotation work
# best with rot order"yzx"
self.fk_cns = primitive.addTransformFromPos(
self.root, self.getName("fk_cns"), self.guide.apos[0])
vec_offset = ((self.guide.apos[1] - self.guide.apos[0]) * [1, 0, 0])
tpv = self.guide.apos[0] + vec_offset
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal, "xz",
self.negate)
# *ms* add FK isolation
self.fk0_npo = primitive.addTransform(
self.fk_cns, self.getName("fk0_npo"), t)
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal, "xz",
self.negate)
po_off = datatypes.Vector(.35 * 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 * .7,
h=self.size * .1,
d=self.size * .1,
po=po_off,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.fk0_ctl)
# *ms* add fk roll control Simage style
po_off = datatypes.Vector(.85 * self.length0 * self.n_factor, 0, 0)
self.fk0_roll_ctl = self.addCtl(self.fk0_ctl,
"fk0_roll_ctl",
t, self.color_fk,
"cube", w=self.length0 * .3,
h=self.size * .1,
d=self.size * 0.1,
po=po_off,
tp=self.fk0_ctl)
attribute.setRotOrder(self.fk0_roll_ctl, "YZX")
attribute.setKeyableAttributes(self.fk0_roll_ctl, ["rx"])
self.fk0_mtx = primitive.addTransform(
self.root, self.getName("fk0_mtx"), t)
t = transform.setMatrixPosition(t, self.guide.apos[1])
self.fk1_ref = primitive.addTransform(
self.fk0_roll_ctl, self.getName("fk1_ref"), t)
self.fk1_loc = primitive.addTransform(
self.root, self.getName("fk1_loc"), t)
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[2],
self.normal,
"xz",
self.negate)
self.fk1_npo = primitive.addTransform(
self.fk1_loc, self.getName("fk1_npo"), t)
po_off = datatypes.Vector(.35 * 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 * .7,
h=self.size * .1,
d=self.size * .1,
po=po_off, tp=self.fk0_roll_ctl)
attribute.setKeyableAttributes(self.fk1_ctl)
self.fk1_mtx = primitive.addTransform(
self.fk1_ctl, self.getName("fk1_mtx"), t)
po_off = datatypes.Vector(.85 * self.length1 * self.n_factor, 0, 0)
self.fk1_roll_ctl = self.addCtl(self.fk1_ctl,
"fk1_roll_ctl",
t,
self.color_fk,
"cube",
w=self.length1 * .3,
h=self.size * .1,
d=self.size * .1,
po=po_off, tp=self.fk1_ctl)
attribute.setRotOrder(self.fk1_roll_ctl, "XYZ")
attribute.setKeyableAttributes(self.fk1_roll_ctl, ["rx"])
t = transform.getTransformLookingAt(self.guide.apos[2],
self.guide.apos[3],
self.normal,
"xz",
self.negate)
# *ms* buffer object to feed into ikfk solver for hand seperation
self.fk2_mtx = primitive.addTransform(self.fk1_roll_ctl,
self.getName("fk2_mtx"),
t)
# fk2_loc is need to take the effector position + bone1 rotation
t1 = transform.getTransformLookingAt(self.guide.apos[2],
self.guide.apos[1],
self.normal,
"-xz",
self.negate)
self.fk2_loc = primitive.addTransform(
self.root, self.getName("fk2_loc"), t1)
self.fk2_npo = primitive.addTransform(self.fk2_loc,
self.getName("fk2_npo"),
t)
po_off = 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_off,
tp=self.fk1_roll_ctl)
attribute.setKeyableAttributes(self.fk2_ctl)
self.fk_ctl = [self.fk0_roll_ctl, self.fk1_mtx, self.fk2_ctl]
self.fk_ctls = [self.fk0_ctl,
self.fk0_roll_ctl,
self.fk1_ctl,
self.fk1_roll_ctl,
self.fk2_ctl]
for x in self.fk_ctls:
attribute.setInvertMirror(x, ["tx", "ty", "tz"])
# IK Controlers -----------------------------------
self.ik_cns = primitive.addTransformFromPos(
self.root, self.getName("ik_cns"), self.guide.pos["wrist"])
self.ikcns_ctl = self.addCtl(
self.ik_cns,
"ikcns_ctl",
transform.getTransformFromPos(self.guide.pos["wrist"]),
self.color_ik,
"null",
w=self.size * .12, tp=self.parentCtlTag)
attribute.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"])
if self.negate:
m = transform.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal,
"x-y",
True)
else:
m = transform.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal,
"xy",
False)
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
m,
self.color_ik,
"cube",
w=self.size * .12,
h=self.size * .12,
d=self.size * .12,
tp=self.ikcns_ctl)
attribute.setKeyableAttributes(self.ik_ctl)
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]
# *ms* auto up vector ------------------------------
self.upv_cns = primitive.addTransformFromPos(self.root,
self.getName("upv_cns"),
self.guide.apos[0])
self.upv_auv = primitive.addTransformFromPos(self.root,
self.getName("upv_auv"),
self.guide.apos[0])
self.upv_mtx = primitive.addTransformFromPos(self.upv_cns,
self.getName("upv_mtx"),
self.guide.apos[0])
self.upv_npo = primitive.addTransformFromPos(self.upv_mtx,
self.getName("upv_npo"),
v)
self.upv_ctl = self.addCtl(self.upv_npo,
"upv_ctl",
transform.getTransform(self.upv_npo),
self.color_ik,
"diamond",
w=self.size * .12,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.upv_ctl, self.t_params)
attribute.setInvertMirror(self.upv_ctl, ["tx"])
# References --------------------------------------
# Calculate again the transfor for the IK ref. This way align with FK
trnIK_ref = transform.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal,
"xz",
self.negate)
self.ik_ref = primitive.addTransform(self.ik_ctl,
self.getName("ik_ref"),
trnIK_ref)
self.fk_ref = primitive.addTransform(self.fk_ctl[2],
self.getName("fk_ref"),
trnIK_ref)
# Chain --------------------------------------------
# take 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 * .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,
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,
self.getName("ctrn_loc"),
self.guide.apos[1])
# eff npo --- take the effector output of gear ik solver
self.eff_npo = primitive.addTransformFromPos(self.root,
self.getName("eff_npo"),
self.guide.apos[2])
# eff loc --- take the fk ik blend result
self.eff_loc = primitive.addTransformFromPos(self.eff_npo,
self.getName("eff_loc"),
self.guide.apos[2])
# Mid Controler ------------------------------------
self.mid_ctl = self.addCtl(self.ctrn_loc,
"mid_ctl",
transform.getTransform(self.ctrn_loc),
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.parentCtlTag)
attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"])
# *ms* add elbow thickness
# Roll join ref
self.tws0_npo = primitive.addTransform(
self.root,
self.getName("tws0_npo"),
transform.getTransform(self.fk_ctl[0]))
self.tws0_loc = primitive.addTransform(
self.tws0_npo,
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_loc = primitive.addTransform(
self.tws1_npo,
self.getName("tws2_loc"),
transform.getTransform(self.ctrn_loc))
self.tws2_rot = primitive.addTransform(
self.tws2_loc,
self.getName("tws2_rot"),
transform.getTransform(self.ctrn_loc))
self.tws3_npo = primitive.addTransform(
self.root,
self.getName("tws3_npo"),
transform.getTransform(self.fk_ctl[2]))
self.tws3_loc = primitive.addTransform(
self.tws3_npo,
self.getName("tws3_loc"),
transform.getTransform(self.fk_ctl[2]))
self.tws3_rot = primitive.addTransform(
self.tws3_loc,
self.getName("tws3_rot"),
transform.getTransform(self.fk_ctl[2]))
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for the
# elbow. + 2 for elbow angle control
# separate up and dn limb
self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + 2
self.divisions0 = self.settings["div0"] + 2
self.divisions1 = self.settings["div1"] + 2
self.div_cns = []
self.div_cnsUp = []
self.div_cnsDn = []
self.div_ctls = []
self.div_org = primitive.addTransform(
self.root,
self.getName("div_org"),
transform.getTransform(self.root))
self.previousTag = self.parentCtlTag
for i in range(self.divisions0):
div_cns = primitive.addTransform(
self.div_org, self.getName("div%s_loc" % i))
if self.negate:
div_ctl = self.addCtl(
div_cns,
self.getName("div%s_ctl" % i),
transform.getTransform(div_cns),
self.color_fk, "square", d=self.size * .05,
w=self.size * .1,
po=datatypes.Vector(0, self.size * -0.05, 0),
ro=datatypes.Vector(0, 0, datatypes.radians(90)),
tp=self.previousTag)
else:
div_ctl = self.addCtl(
div_cns,
self.getName("div%s_ctl" % i),
transform.getTransform(div_cns),
self.color_fk,
"square",
d=self.size * .05,
w=self.size * .1,
po=datatypes.Vector(0, self.size * 0.05, 0),
ro=datatypes.Vector(0, 0, datatypes.radians(90)),
tp=self.previousTag)
attribute.setKeyableAttributes(div_ctl)
self.previousTag = div_ctl
self.div_cns.append(div_cns)
self.div_cnsUp.append(div_cns)
self.jnt_pos.append([div_ctl, i])
self.div_ctls.append(div_ctl)
# mid division
d = self.divisions0
self.div_mid = primitive.addTransform(
self.div_org,
self.getName("div%s_loc" % d),
transform.getTransform(self.mid_ctl))
if self.negate:
self.div_mid_ctl = self.addCtl(
self.div_mid,
self.getName("div%s_ctl" % d),
transform.getTransform(self.div_mid),
self.color_fk,
"square",
d=self.size * .05,
w=self.size * .1,
po=datatypes.Vector(0, self.size * -0.05, 0),
ro=datatypes.Vector(0, 0, datatypes.radians(90)),
tp=self.previousTag)
else:
self.div_mid_ctl = self.addCtl(
self.div_mid, self.getName("div%s_ctl" % d),
transform.getTransform(self.div_mid),
self.color_fk,
"square",
d=self.size * .05,
w=self.size * .1,
po=datatypes.Vector(0, self.size * 0.05, 0),
ro=datatypes.Vector(0, 0, datatypes.radians(90)),
tp=self.previousTag)
attribute.setKeyableAttributes(self.div_mid_ctl)
self.previousTag = div_ctl
self.div_cns.append(self.div_mid)
self.jnt_pos.append([self.div_mid_ctl, self.divisions0])
self.div_ctls.append(self.div_mid_ctl)
# down division
for i in range(self.divisions1):
dd = i + self.divisions1 + 1
div_cns = primitive.addTransform(
self.div_org, self.getName("div%s_loc" % dd))
if self.negate:
div_ctl = self.addCtl(
div_cns,
self.getName("div%s_ctl" % dd),
transform.getTransform(div_cns),
self.color_fk,
"square",
d=self.size * .05,
w=self.size * .1,
po=datatypes.Vector(0, self.size * -0.05, 0),
ro=datatypes.Vector(0, 0, datatypes.radians(90)),
tp=self.previousTag)
else:
div_ctl = self.addCtl(
div_cns,
self.getName("div%s_ctl" % dd),
transform.getTransform(div_cns),
self.color_fk,
"square",
d=self.size * .05,
w=self.size * .1,
po=datatypes.Vector(0, self.size * 0.05, 0),
ro=datatypes.Vector(0, 0, datatypes.radians(90)),
tp=self.previousTag)
attribute.setKeyableAttributes(div_ctl)
self.previousTag = div_ctl
self.div_cns.append(div_cns)
self.div_cnsDn.append(div_cns)
self.jnt_pos.append([div_ctl, i + self.divisions0 + 1])
self.div_ctls.append(div_ctl)
# End reference ------------------------------------
# To help the deformation on the wrist
self.jnt_pos.append([self.eff_loc, 'end'])
# match IK FK references
self.match_fk0 = self.add_match_ref(self.fk_ctl[0],
self.root,
"fk0_mth")
self.match_fk1 = self.add_match_ref(self.fk_ctl[1],
self.root,
"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_roll_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.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)
self.fk0_npo = primitive.addTransform(self.root_ctl,
self.getName("fk0_npo"), t)
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=datatypes.Vector(
.5 * self.length0 * self.n_factor, 0,
0),
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)
self.fk1_npo = primitive.addTransform(self.fk0_ctl,
self.getName("fk1_npo"), t)
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=datatypes.Vector(
.5 * self.length1 * self.n_factor, 0,
0),
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)
self.fk2_npo = primitive.addTransform(self.fk1_ctl,
self.getName("fk2_npo"), t)
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=datatypes.Vector(
.5 * self.length2 * self.n_factor, 0,
0),
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)
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
transform.getTransformFromPos(
self.guide.pos["ankle"]),
self.color_ik,
"cube",
w=self.size * .12,
h=self.size * .12,
d=self.size * .12,
tp=self.ikcns_ctl)
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)
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)
tA = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1], self.normal,
"xz", self.negate)
tA = transform.setMatrixPosition(tA, self.guide.apos[1])
tB = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[2], self.normal,
"xz", self.negate)
t = transform.getInterpolateTransformMatrix(tA, tB)
self.ctrn_loc = primitive.addTransform(self.root,
self.getName("ctrn_loc"), t)
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"])
self.tws_ref = primitive.addTransform(self.eff_loc,
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)
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"])
attribute.setKeyableAttributes(self.mid_ctl, self.t_params)
# 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.tws0_loc = primitive.addTransform(
self.root_ctl, 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_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.tws1A_npo = primitive.addTransform(self.mid_ctl,
self.getName("tws1A_npo"), tA)
self.tws1A_loc = primitive.addTransform(self.tws1A_npo,
self.getName("tws1A_loc"), tA)
self.tws1B_npo = primitive.addTransform(self.mid_ctl,
self.getName("tws1B_npo"), tB)
self.tws1B_loc = primitive.addTransform(self.tws1B_npo,
self.getName("tws1B_loc"), tB)
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_npo, self.getName("tws2_rot"),
transform.getTransform(self.fk_ctl[2]))
# Roll twist chain ---------------------------------
# Arm
self.uplegChainPos = []
ii = 1.0 / (self.settings["div0"] + 1)
i = 0.0
for p in range(self.settings["div0"] + 2):
self.uplegChainPos.append(
vector.linearlyInterpolate(self.guide.pos["root"],
self.guide.pos["knee"],
blend=i))
i = i + ii
self.uplegTwistChain = primitive.add2DChain(
self.root, self.getName("uplegTwist%s_jnt"), self.uplegChainPos,
self.normal, False, self.WIP)
# Forearm
self.lowlegChainPos = []
ii = 1.0 / (self.settings["div1"] + 1)
i = 0.0
for p in range(self.settings["div1"] + 2):
self.lowlegChainPos.append(
vector.linearlyInterpolate(self.guide.pos["knee"],
self.guide.pos["ankle"],
blend=i))
i = i + ii
self.lowlegTwistChain = primitive.add2DChain(
self.root, self.getName("lowlegTwist%s_jnt"), self.lowlegChainPos,
self.normal, False, self.WIP)
pm.parent(self.lowlegTwistChain[0], self.mid_ctl)
# Hand Aux chain and nonroll
self.auxChainPos = []
ii = .5
i = 0.0
for p in range(3):
self.auxChainPos.append(
vector.linearlyInterpolate(self.guide.pos["ankle"],
self.guide.pos["eff"],
blend=i))
i = i + ii
t = self.root.getMatrix(worldSpace=True)
self.aux_npo = primitive.addTransform(self.root,
self.getName("aux_npo"), t)
self.auxTwistChain = primitive.add2DChain(
self.aux_npo, self.getName("auxTwist%s_jnt"),
self.lowlegChainPos[:3], self.normal, False, self.WIP)
# Non Roll join ref ---------------------------------
self.uplegRollRef = primitive.add2DChain(
self.root, self.getName("uplegRollRef%s_jnt"),
self.uplegChainPos[:2], self.normal, False, self.WIP)
self.lowlegRollRef = primitive.add2DChain(
self.aux_npo, self.getName("lowlegRollRef%s_jnt"),
self.lowlegChainPos[:2], self.normal, False, self.WIP)
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for the
# elbow. + 2 for knee angle control
self.divisions = self.settings["div0"] + self.settings["div1"] + 4
self.div_cns = []
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)
self.jnt_pos.append([div_cns, i])
# End reference ------------------------------------
# To help the deformation on the ankle
self.end_ref = primitive.addTransform(self.eff_loc,
self.getName("end_ref"), m)
for a in "xyz":
self.end_ref.attr("s%s" % a).set(1.0)
if self.negate:
self.end_ref.attr("ry").set(-180.0)
self.jnt_pos.append([self.end_ref, 'end'])
# Tangent controls
t = transform.getInterpolateTransformMatrix(self.fk_ctl[0],
self.tws1A_npo, .5)
self.uplegTangentA_loc = primitive.addTransform(
self.root_ctl, self.getName("uplegTangentA_loc"),
self.fk_ctl[0].getMatrix(worldSpace=True))
self.uplegTangentA_npo = primitive.addTransform(
self.uplegTangentA_loc, self.getName("uplegTangentA_npo"), t)
self.uplegTangentA_ctl = self.addCtl(self.uplegTangentA_npo,
"uplegTangentA_ctl",
t,
self.color_ik,
"circle",
w=self.size * .2,
ro=datatypes.Vector(
0, 0, 1.570796),
tp=self.mid_ctl)
if self.negate:
self.uplegTangentA_npo.rz.set(180)
self.uplegTangentA_npo.sz.set(-1)
attribute.setKeyableAttributes(self.uplegTangentA_ctl, self.t_params)
t = transform.getInterpolateTransformMatrix(self.fk_ctl[0],
self.tws1A_npo, .9)
self.uplegTangentB_npo = primitive.addTransform(
self.tws1A_loc, self.getName("uplegTangentB_npo"), t)
self.uplegTangentB_ctl = self.addCtl(self.uplegTangentB_npo,
"uplegTangentB_ctl",
t,
self.color_ik,
"circle",
w=self.size * .1,
ro=datatypes.Vector(
0, 0, 1.570796),
tp=self.mid_ctl)
if self.negate:
self.uplegTangentB_npo.rz.set(180)
self.uplegTangentB_npo.sz.set(-1)
attribute.setKeyableAttributes(self.uplegTangentB_ctl, self.t_params)
tC = self.tws1B_npo.getMatrix(worldSpace=True)
tC = transform.setMatrixPosition(tC, self.guide.apos[2])
t = transform.getInterpolateTransformMatrix(self.tws1B_npo, tC, .1)
self.lowlegTangentA_npo = primitive.addTransform(
self.tws1B_loc, self.getName("lowlegTangentA_npo"), t)
self.lowlegTangentA_ctl = self.addCtl(self.lowlegTangentA_npo,
"lowlegTangentA_ctl",
t,
self.color_ik,
"circle",
w=self.size * .1,
ro=datatypes.Vector(
0, 0, 1.570796),
tp=self.mid_ctl)
if self.negate:
self.lowlegTangentA_npo.rz.set(180)
self.lowlegTangentA_npo.sz.set(-1)
attribute.setKeyableAttributes(self.lowlegTangentA_ctl, self.t_params)
t = transform.getInterpolateTransformMatrix(self.tws1B_npo, tC, .5)
self.lowlegTangentB_loc = primitive.addTransform(
self.root, self.getName("lowlegTangentB_loc"), tC)
self.lowlegTangentB_npo = primitive.addTransform(
self.lowlegTangentB_loc, self.getName("lowlegTangentB_npo"), t)
self.lowlegTangentB_ctl = self.addCtl(self.lowlegTangentB_npo,
"lowlegTangentB_ctl",
t,
self.color_ik,
"circle",
w=self.size * .2,
ro=datatypes.Vector(
0, 0, 1.570796),
tp=self.mid_ctl)
if self.negate:
self.lowlegTangentB_npo.rz.set(180)
self.lowlegTangentB_npo.sz.set(-1)
attribute.setKeyableAttributes(self.lowlegTangentB_ctl, self.t_params)
t = self.mid_ctl.getMatrix(worldSpace=True)
self.kneeTangent_npo = primitive.addTransform(
self.mid_ctl, self.getName("kneeTangent_npo"), t)
self.kneeTangent_ctl = self.addCtl(self.kneeTangent_npo,
"kneeTangent_ctl",
t,
self.color_fk,
"circle",
w=self.size * .25,
ro=datatypes.Vector(0, 0, 1.570796),
tp=self.mid_ctl)
if self.negate:
self.kneeTangent_npo.rz.set(180)
self.kneeTangent_npo.sz.set(-1)
attribute.setKeyableAttributes(self.kneeTangent_ctl, self.t_params)
# 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 addOperators(self):
# Visibilities -------------------------------------
# fk
fkvis_node = nod.createReverseNode(self.blend_att)
rotspace_rev_node = nod.createReverseNode(self.rot_space_att)
for fk_ctl in self.fk_ctl:
for shp in fk_ctl.getShapes():
pm.connectAttr(fkvis_node + ".outputX", shp.attr("visibility"))
# ik
for shp in self.upv_ctl.getShapes():
pm.connectAttr(self.blend_att, shp.attr("visibility"))
for shp in self.ik_ctl.getShapes():
pm.connectAttr(self.blend_att, shp.attr("visibility"))
for shp in self.ikRot_ctl.getShapes():
pm.connectAttr(rotspace_rev_node + ".outputX",
shp.attr("visibility"))
# IK Chain -----------------------------------------
self.ikh = pri.addIkHandle(self.root, self.getName("ikh"), self.chain)
self.ikh.attr("visibility").set(False)
# Constraint and up vector
pm.pointConstraint(self.ik_ctl, self.ikh, maintainOffset=False)
pm.poleVectorConstraint(self.upv_ctl, self.ikh)
# Chain of deformers -------------------------------
for i, loc in enumerate(self.loc):
rev_node = nod.createReverseNode(self.blend_att)
# orientation
if i == len(self.loc) - 1:
cns = pm.parentConstraint(self.fk_ctl[i],
self.chain[i],
loc,
maintainOffset=True,
skipRotate=['x', 'y', 'z'])
else:
cns = pm.parentConstraint(self.fk_ctl[i],
self.chain[i],
loc,
maintainOffset=True)
weight_att = pm.parentConstraint(cns,
query=True,
weightAliasList=True)
pm.connectAttr(rev_node + ".outputX", weight_att[0])
pm.connectAttr(self.blend_att, weight_att[1])
# scaling
blend_node = pm.createNode("blendColors")
pm.connectAttr(self.chain[i].attr("scale"), blend_node + ".color1")
pm.connectAttr(self.fk_ctl[i].attr("scale"),
blend_node + ".color2")
pm.connectAttr(self.blend_att, blend_node + ".blender")
pm.connectAttr(blend_node + ".output", loc + ".scale")
# wrist rotation parent space switcher
cns = pm.parentConstraint(self.loc[-2],
self.ikRot_cns,
maintainOffset=True,
skipRotate=['x', 'y', 'z'])
cns = pm.parentConstraint(self.loc[-2],
self.ik_ctl,
self.ikRot_cns,
maintainOffset=True,
skipTranslate=['x', 'y', 'z'])
weight_att = pm.parentConstraint(cns, query=True, weightAliasList=True)
pm.connectAttr(rotspace_rev_node + ".outputX", weight_att[0])
pm.connectAttr(self.rot_space_att, weight_att[1])
# wrist position switcher
cns = pm.parentConstraint(self.fk_ctl[-1],
self.end_ref,
self.loc[-1],
maintainOffset=True,
skipTranslate=['x', 'y', 'z'])
weight_att = pm.parentConstraint(cns, query=True, weightAliasList=True)
pm.connectAttr(rev_node + ".outputX", weight_att[0])
pm.connectAttr(self.blend_att, weight_att[1])
pm.parentConstraint(self.ikRot_ctl,
self.end_ref,
maintainOffset=True,
skipTranslate=['x', 'y', 'z'])
# match IK/FK ref
pm.parentConstraint(self.chain[0], self.match_fk0_off, mo=True)
pm.parentConstraint(self.chain[1], self.match_fk1_off, mo=True)
pm.parentConstraint(self.chain[2],
self.match_fk2,
mo=True,
skipRotate=("x", "y", "z"))
pm.parentConstraint(self.ikRot_ctl,
self.match_fk2,
mo=True,
skipTranslate=("x", "y", "z"))
#
for x in self.fk_ctl:
att.setInvertMirror(x, ["tx", "ty", "tz"])
att.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
att.setInvertMirror(self.upv_ctl, ["tx"])
att.setInvertMirror(self.ikRot_ctl, ["ry", "rz"])
# 1 bone chain Upv ref ===========================
self.ikHandleUpvRef = pri.addIkHandle(
self.root, self.getName("ikHandleArmChainUpvRef"),
self.armChainUpvRef, "ikSCsolver")
pm.pointConstraint(self.ik_ctl, self.ikHandleUpvRef)
pm.parentConstraint(self.armChainUpvRef[0],
self.ik_ctl,
self.upv_cns,
mo=True)
def addObjects(self):
"""Add all the objects needed to create the component."""
self.setup = primitive.addTransformFromPos(
self.setupWS, self.getName("WS"))
attribute.lockAttribute(self.setup)
self.WIP = self.options["mode"]
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])
self.length3 = vector.getDistance(self.guide.apos[3],
self.guide.apos[4])
# 3bones chain
self.chain3bones = primitive.add2DChain(
self.setup,
self.getName("chain3bones%s_jnt"),
self.guide.apos[0:4],
self.normal,
False,
self.WIP)
# 2bones chain
self.chain2bones = primitive.add2DChain(
self.setup,
self.getName("chain2bones%s_jnt"),
self.guide.apos[0:3],
self.normal,
False,
self.WIP)
# Leg chain
self.legBones = primitive.add2DChain(
self.root,
self.getName("legBones%s_jnt"),
self.guide.apos[0:4],
self.normal,
False,
self.WIP)
# Leg chain FK ref
self.legBonesFK = primitive.add2DChain(
self.root,
self.getName("legFK%s_jnt"),
self.guide.apos[0:4],
self.normal,
False,
self.WIP)
# Leg chain IK ref
self.legBonesIK = primitive.add2DChain(
self.root,
self.getName("legIK%s_jnt"),
self.guide.apos[0:4],
self.normal,
False,
self.WIP)
# 1 bone chain for upv ref
self.legChainUpvRef = primitive.add2DChain(
self.root,
self.getName("legUpvRef%s_jnt"),
[self.guide.apos[0], self.guide.apos[3]],
self.normal,
False,
self.WIP)
# mid joints
self.mid1_jnt = primitive.addJoint(
self.legBones[0],
self.getName("mid1_jnt"),
self.legBones[1].getMatrix(worldSpace=True),
self.WIP)
self.mid1_jnt.attr("radius").set(3)
self.mid1_jnt.setAttr("jointOrient", 0, 0, 0)
self.mid2_jnt = primitive.addJoint(
self.legBones[1],
self.getName("mid2_jnt"),
self.legBones[2].getMatrix(worldSpace=True),
self.WIP)
self.mid2_jnt.attr("radius").set(3)
self.mid2_jnt.setAttr("jointOrient", 0, 0, 0)
# base Controlers -----------------------------------
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)
attribute.lockAttribute(self.root_ctl, ["sx", "sy", "sz", "v"])
# FK Controlers -----------------------------------
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
"xz",
self.negate)
self.fk0_npo = primitive.addTransform(
self.root_ctl, self.getName("fk0_npo"), t)
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=datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0),
tp=self.root_ctl)
attribute.setKeyableAttributes(self.fk0_ctl)
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[2],
self.normal,
"xz",
self.negate)
self.fk1_npo = primitive.addTransform(
self.fk0_ctl, self.getName("fk1_npo"), t)
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=datatypes.Vector(.5 * self.length1 * self.n_factor, 0, 0),
tp=self.fk0_ctl)
attribute.setKeyableAttributes(self.fk1_ctl)
t = transform.getTransformLookingAt(self.guide.apos[2],
self.guide.apos[3],
self.normal,
"xz",
self.negate)
self.fk2_npo = primitive.addTransform(
self.fk1_ctl, self.getName("fk2_npo"), t)
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=datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0),
tp=self.fk1_ctl)
attribute.setKeyableAttributes(self.fk2_ctl)
t = transform.getTransformLookingAt(self.guide.apos[3],
self.guide.apos[4],
self.normal,
"xz",
self.negate)
self.fk3_npo = primitive.addTransform(
self.fk2_ctl, self.getName("fk3_npo"), t)
self.fk3_ctl = self.addCtl(
self.fk3_npo,
"fk3_ctl",
t,
self.color_fk,
"cube",
w=self.length3,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(.5 * self.length3 * self.n_factor, 0, 0),
tp=self.fk2_ctl)
attribute.setKeyableAttributes(self.fk3_ctl)
self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl, self.fk3_ctl]
for x in self.fk_ctl:
attribute.setInvertMirror(x, ["tx", "ty", "tz"])
# Mid Controlers ------------------------------------
self.knee_lvl = primitive.addTransform(
self.root,
self.getName("knee_lvl"),
transform.getTransform(self.mid1_jnt))
self.knee_ctl = self.addCtl(
self.knee_lvl,
"knee_ctl",
transform.getTransform(self.mid1_jnt),
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.root_ctl)
attribute.setInvertMirror(self.knee_ctl, ["tx", "ty", "tz"])
attribute.lockAttribute(self.knee_ctl, ["sx", "sy", "sz", "v"])
self.ankle_lvl = primitive.addTransform(
self.root,
self.getName("ankle_lvl"),
transform.getTransform(self.mid2_jnt))
self.ankle_ctl = self.addCtl(
self.ankle_lvl,
"ankle_ctl",
transform.getTransform(self.mid2_jnt),
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.knee_ctl)
attribute.setInvertMirror(self.ankle_ctl, ["tx", "ty", "tz"])
attribute.lockAttribute(self.ankle_ctl, ["sx", "sy", "sz", "v"])
# IK controls --------------------------------------------------------
# foot IK
# "z-x",
t_align = transform.getTransformLookingAt(self.guide.apos[3],
self.guide.apos[4],
self.normal,
"zx",
False)
if self.settings["ikOri"]:
t = transform.getTransformFromPos(self.guide.pos["foot"])
# t = transform.getTransformLookingAt(self.guide.pos["foot"],
# self.guide.pos["eff"],
# self.x_axis,
# "zx",
# False)
else:
t = t_align
self.ik_cns = primitive.addTransform(
self.root_ctl, self.getName("ik_cns"), t)
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
t,
self.color_ik,
"null",
w=self.size * .12,
tp=self.ankle_ctl)
attribute.setInvertMirror(self.ikcns_ctl, ["tx"])
attribute.lockAttribute(self.ikcns_ctl, ["sx", "sy", "sz", "v"])
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
t,
self.color_ik,
"cube",
w=self.size * .12,
h=self.size * .12,
d=self.size * .12,
tp=self.ikcns_ctl)
attribute.setKeyableAttributes(self.ik_ctl)
attribute.setRotOrder(self.ik_ctl, "XZY")
attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
attribute.lockAttribute(self.ik_ctl, ["sx", "sy", "sz", "v"])
# 2 bones ik layer
self.ik2b_ikCtl_ref = primitive.addTransform(
self.ik_ctl, self.getName("ik2B_A_ref"), t_align)
self.ik2b_bone_ref = primitive.addTransform(
self.chain3bones[3], self.getName("ik2B_B_ref"), t_align)
self.ik2b_blend = primitive.addTransform(
self.ik_ctl, self.getName("ik2B_blend"), t_align)
self.roll_ctl = self.addCtl(self.ik2b_blend,
"roll_ctl",
t_align,
self.color_ik,
"crossarrow",
w=self.length2 * .5 * self.n_factor,
tp=self.ik_ctl)
self.ik2b_ik_npo = primitive.addTransform(
self.roll_ctl,
self.getName("ik2B_ik_npo"),
transform.getTransform(self.chain3bones[-1]))
self.ik2b_ik_ref = primitive.addTransformFromPos(
self.ik2b_ik_npo,
self.getName("ik2B_ik_ref"),
self.guide.pos["ankle"])
attribute.lockAttribute(
self.roll_ctl, ["tx", "ty", "tz", "sx", "sy", "sz", "v"])
# 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_lvl = primitive.addTransformFromPos(
self.root, self.getName("upv_lvl"), v)
self.upv_cns = primitive.addTransformFromPos(
self.upv_lvl, 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.ik_ctl)
attribute.setInvertMirror(self.upv_ctl, ["tx"])
attribute.setKeyableAttributes(self.upv_ctl, ["tx", "ty", "tz"])
# Soft IK objects 3 bones chain --------------------------------
t = transform.getTransformLookingAt(self.guide.pos["root"],
self.guide.pos["foot"],
self.x_axis,
"zx",
False)
self.aim_tra = primitive.addTransform(
self.root_ctl, self.getName("aimSoftIK"), t)
t = transform.getTransformFromPos(self.guide.pos["foot"])
self.wristSoftIK = primitive.addTransform(
self.aim_tra, self.getName("wristSoftIK"), t)
self.softblendLoc = primitive.addTransform(
self.root, self.getName("softblendLoc"), t)
# Soft IK objects 2 Bones chain ----------------------------
t = transform.getTransformLookingAt(self.guide.pos["root"],
self.guide.pos["ankle"],
self.x_axis,
"zx",
False)
self.aim_tra2 = primitive.addTransform(
self.root_ctl, self.getName("aimSoftIK2"), t)
t = transform.getTransformFromPos(self.guide.pos["ankle"])
self.ankleSoftIK = primitive.addTransform(
self.aim_tra2, self.getName("ankleSoftIK"), t)
self.softblendLoc2 = primitive.addTransform(
self.root, self.getName("softblendLoc2"), t)
# 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[3],
self.getName("fk_ref"),
transform.getTransform(self.ik_ctl))
# twist references --------------------------------------
self.rollRef = primitive.add2DChain(self.root,
self.getName("rollChain"),
self.guide.apos[:2],
self.normal,
False,
self.WIP)
self.tws0_loc = primitive.addTransform(
self.rollRef[0],
self.getName("tws0_loc"),
transform.getTransform(self.legBones[0]))
self.tws0_rot = primitive.addTransform(
self.tws0_loc,
self.getName("tws0_rot"),
transform.getTransform(self.legBones[0]))
self.tws0_rot.setAttr("sx", .001)
self.tws1_loc = primitive.addTransform(
self.mid1_jnt,
self.getName("tws1_loc"),
transform.getTransform(self.mid1_jnt))
self.tws1_rot = primitive.addTransform(
self.tws1_loc,
self.getName("tws1_rot"),
transform.getTransform(self.mid1_jnt))
self.tws1_rot.setAttr("sx", .001)
self.tws2_loc = primitive.addTransform(
self.mid2_jnt,
self.getName("tws2_loc"),
transform.getTransform(self.mid2_jnt))
self.tws2_rot = primitive.addTransform(
self.tws2_loc,
self.getName("tws2_rot"),
transform.getTransform(self.mid2_jnt))
self.tws2_rot.setAttr("sx", .001)
self.tws3_loc = primitive.addTransform(
self.legBones[3],
self.getName("tws3_loc"),
transform.getTransform(self.legBones[3]))
self.tws3_rot = primitive.addTransform(
self.tws3_loc,
self.getName("tws3_rot"),
transform.getTransform(self.legBones[3]))
self.tws3_rot.setAttr("sx", .001)
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for
# the knee and one ankle
o_set = self.settings
self.divisions = o_set["div0"] + o_set["div1"] + o_set["div2"] + 4
self.div_cns = []
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)
self.jnt_pos.append([div_cns, i])
# End reference ------------------------------------
# To help the deformation on the foot
self.end_ref = primitive.addTransform(
self.tws3_rot,
self.getName("end_ref"),
transform.getTransform(self.legBones[3]))
self.jnt_pos.append([self.end_ref, 'end'])
# match IK FK references
self.match_fk0_off = primitive.addTransform(
self.root,
self.getName("matchFk0_npo"),
transform.getTransform(self.fk_ctl[1]))
self.match_fk0 = primitive.addTransform(
self.match_fk0_off,
self.getName("fk0_mth"),
transform.getTransform(self.fk_ctl[0]))
self.match_fk1_off = primitive.addTransform(
self.root,
self.getName("matchFk1_npo"),
transform.getTransform(self.fk_ctl[2]))
self.match_fk1 = primitive.addTransform(
self.match_fk1_off,
self.getName("fk1_mth"),
transform.getTransform(self.fk_ctl[1]))
self.match_fk2_off = primitive.addTransform(
self.root,
self.getName("matchFk2_npo"),
transform.getTransform(self.fk_ctl[3]))
self.match_fk2 = primitive.addTransform(
self.match_fk2_off,
self.getName("fk2_mth"),
transform.getTransform(self.fk_ctl[2]))
self.match_fk3 = primitive.addTransform(
self.ik_ctl,
self.getName("fk3_mth"),
transform.getTransform(self.fk_ctl[3]))
self.match_ik = primitive.addTransform(
self.fk3_ctl,
self.getName("ik_mth"),
transform.getTransform(self.ik_ctl))
self.match_ikUpv = primitive.addTransform(
self.fk0_ctl,
self.getName("upv_mth"),
transform.getTransform(self.upv_ctl))
# add visual reference
self.line_ref = icon.connection_display_curve(
self.getName("visalRef"), [self.upv_ctl, self.knee_ctl])
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.WIP = self.options["mode"]
if self.negate and self.settings["overrideNegate"]:
self.negate = False
self.n_factor = 1
if self.settings["overrideNegate"]:
self.mirror_conf = [0, 0, 1, 1, 1, 0, 0, 0, 0]
else:
self.mirror_conf = [0, 0, 0, 0, 0, 0, 0, 0, 0]
# IK controls ---------------------------------------------
self.ik_ctl = []
# tOld = False
self.previusTag = self.parentCtlTag
for i, t in enumerate(
transform.getChainTransform2(self.guide.apos, self.normal,
self.negate)):
ik_npo = primitive.addTransform(self.root,
self.getName("ik%s_npo" % i), t)
ik_ctl = self.addCtl(ik_npo,
"ik%s_ctl" % i,
t,
self.color_ik,
"square",
w=self.size * .15,
h=self.size * .15,
d=self.size * .15,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=self.previusTag,
mirrorConf=self.mirror_conf)
attribute.setKeyableAttributes(ik_ctl, self.tr_params)
self.ik_ctl.append(ik_ctl)
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(self.root, self.getName("mst_crv"),
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_transforms = []
self.twister = []
self.ref_twist = []
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["fkNb"]):
# 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
if i in [0, self.settings["fkNb"] - 1] and False:
fk_ctl = primitive.addTransform(
parentctl, self.getName("%s_loc" % i),
transform.getTransform(parentctl))
fk_npo = fk_ctl
if i in [self.settings["fkNb"] - 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 * .1,
h=self.size * .1,
d=self.size * .1,
tp=self.preiviousCtlTag,
mirrorConf=self.mirror_conf)
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])
# 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"])
def addObjects(self):
"""Add all the objects needed to create the component."""
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.guide.blades["blade"].z * -1,
"yx", self.negate)
t2 = transform.setMatrixPosition(t, self.guide.apos[1])
int_t = t
self.preiviousCtlTag = self.parentCtlTag
# FK Controlers ------------------------------------
self.fk_ctl = []
self.fk_npo = []
parentctl = self.root
blend_increment = 1.0 / (self.settings["division"] - 1)
blend_val = 0.0
for i in range(self.settings["division"]):
fk_npo = primitive.addTransform(parentctl,
self.getName("fk%s_npo" % (i)),
int_t)
self.fk_npo.append(fk_npo)
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % (i),
int_t,
self.color_fk,
"cube",
w=self.size,
h=self.size * .05,
d=self.size,
tp=self.preiviousCtlTag)
self.fk_ctl.append(fk_ctl)
self.preiviousCtlTag = fk_ctl
parentctl = fk_ctl
blend_val = blend_val + blend_increment
int_t = transform.getInterpolateTransformMatrix(t,
t2,
blend=blend_val)
for x in self.fk_ctl:
attribute.setKeyableAttributes(x)
attribute.setRotOrder(x, "ZXY")
attribute.setInvertMirror(x, ["tx", "rz", "ry"])
# Ik Controlers ------------------------------------
self.ik0_npo = primitive.addTransform(self.fk_ctl[0],
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"])
t = transform.setMatrixPosition(t, self.guide.apos[1])
self.ik1_npo = primitive.addTransform(self.fk_ctl[-1],
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)
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 * .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)
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 * .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], .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 * .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)
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 * .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)
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 * .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.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
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
parentctl = div_cns
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])
# 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)
# 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.WIP = self.options["mode"]
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.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)
self.fk0_npo = primitive.addTransform(self.root_ctl,
self.getName("fk0_npo"), t)
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)
self.fk1_npo = primitive.addTransform(self.fk0_ctl,
self.getName("fk1_npo"), t)
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)
self.fk2_npo = primitive.addTransform(self.fk1_ctl,
self.getName("fk2_npo"), t)
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)
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
transform.getTransformFromPos(
self.guide.pos["ankle"]),
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)
self.tws0_loc = primitive.addTransform(
self.rollRef[0], 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_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))
# thickness control
self.thick_lvl = primitive.addTransform(
self.mid_ctl, self.getName("thickness_lvl"),
transform.getTransform(self.ctrn_loc))
self.thick_ctl = self.addCtl(self.thick_lvl,
"thickness_ctl",
transform.getTransform(self.mid_ctl),
self.color_ik,
"arrow",
w=self.size * .1,
ro=datatypes.Vector([0, 1.5708, 0]),
tp=self.mid_ctl)
if self.negate and not self.settings["mirrorMid"]:
self.thick_ctl.rz.set(180)
self.thick_ctl.sz.set(-1)
attribute.setKeyableAttributes(self.thick_ctl, ["tx", "ty"])
self.tws1B_loc = primitive.addTransform(
self.ctrn_loc, self.getName("tws1B_loc"),
transform.getTransform(self.ctrn_loc))
self.tws1B_rot = primitive.addTransform(
self.tws1B_loc, self.getName("tws1B_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)
# angle reader ----------------------------------------
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[0], self.binormal,
"yz")
self.readerA = primitive.addTransform(self.root,
self.getName("readerA_loc"), t)
self.readerB = primitive.addTransform(self.readerA,
self.getName("readerB_loc"), t)
self.readerB.rotateOrder.set(2)
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for
# the elbow. + 2 for knee angle control
if self.settings["supportJoints"]:
ej = 2
else:
ej = 0
self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + ej
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)
self.jnt_pos.append([tweak_ctl, i, None, False])
else:
self.jnt_pos.append([div_cns, i])
# End reference ------------------------------------
# To help the deformation on the ankle
self.end_ref = primitive.addTransform(self.tws2_rot,
self.getName("end_ref"), m)
self.jnt_pos.append([self.end_ref, 'end'])
# 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."""
if self.negate:
self.normal = self.guide.blades["blade"].z
axis = "yx"
else:
axis = "yx"
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis=axis,
negate=self.negate)
self.ctl_npo = primitive.addTransform(self.root,
self.getName("ctl_npo"), t)
self.base_ctl = self.addCtl(self.ctl_npo,
"base_ctl",
t,
self.color_ik,
"square",
w=.3,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.base_ctl, self.tr_params)
self.base_upv = primitive.addTransform(self.base_ctl,
self.getName("base_upv"), t)
self.base_upv.attr("tz").set(.01)
# tangent 0
vec_pos = self.guide.pos["tan0"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan0_npo = primitive.addTransform(self.base_ctl,
self.getName("tan0_npo"), t)
self.tan0_ctl = self.addCtl(self.tan0_npo,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=.4,
tp=self.base_ctl)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
self.tan0_upv = primitive.addTransform(self.tan0_ctl,
self.getName("tan0_upv"), t)
self.tan0_upv.attr("tz").set(.01)
t = transform.getTransformLookingAt(self.guide.apos[-2],
self.guide.apos[-1],
self.normal,
axis=axis,
negate=self.negate)
t = transform.setMatrixPosition(t, self.guide.apos[-1])
self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"),
t)
self.tip_npo = primitive.addTransform(self.ik_cns,
self.getName("tip_npo"), t)
self.tip_ctl = self.addCtl(self.tip_npo,
"tip_ctl",
t,
self.color_ik,
"square",
w=.3,
tp=self.base_ctl)
attribute.setKeyableAttributes(self.tip_ctl, self.tr_params)
self.tip_upv = primitive.addTransform(self.tip_ctl,
self.getName("tip_upv"), t)
self.tip_upv.attr("tz").set(.01)
# tangent 1
vec_pos = self.guide.pos["tan1"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan1_npo = primitive.addTransform(self.tip_ctl,
self.getName("tan1_npo"), t)
self.tan1_ctl = self.addCtl(self.tan1_npo,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=.4,
tp=self.tip_ctl)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
self.tan1_upv = primitive.addTransform(self.tan1_ctl,
self.getName("tan1_upv"), t)
self.tan1_upv.attr("tz").set(.01)
attribute.setInvertMirror(self.base_ctl, ["ty"])
attribute.setInvertMirror(self.tip_ctl, ["ty"])
attribute.setInvertMirror(self.tan0_ctl, ["ty"])
attribute.setInvertMirror(self.tan1_ctl, ["ty"])
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root, self.getName("mst_crv"),
[self.base_ctl, self.tan0_ctl, self.tan1_ctl, self.tip_ctl], 3)
self.upv_crv = curve.addCnsCurve(
self.root, self.getName("upv_crv"),
[self.base_upv, self.tan0_upv, self.tan1_upv, self.tip_upv], 3)
self.mst_crv.setAttr("visibility", False)
self.upv_crv.setAttr("visibility", False)
# Divisions
self.div_cns = []
self.upv_cns = []
tagP = self.parentCtlTag
self.extratweak_ctl = []
for i in range(self.settings["div"]):
# References
div_cns = primitive.addTransform(self.root,
self.getName("%s_cns" % i))
pm.setAttr(div_cns + ".inheritsTransform", False)
self.div_cns.append(div_cns)
upv_cns = primitive.addTransform(self.root,
self.getName("%s_upv" % i))
pm.setAttr(upv_cns + ".inheritsTransform", False)
self.upv_cns.append(upv_cns)
t = transform.getTransform(div_cns)
tweak_ctl = self.addCtl(div_cns,
"extraTweak%s_ctl" % i,
t,
self.color_fk,
"square",
w=self.size * .08,
d=self.size * .08,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=tagP)
attribute.setKeyableAttributes(tweak_ctl)
tagP = tweak_ctl
self.extratweak_ctl.append(tweak_ctl)
self.jnt_pos.append([tweak_ctl, i, None, False])
def addObjectsChainIk(self, i, crv):
cvs = crv.length()
if i == 0:
u = 0.
else:
u = crv.findParamFromLength(cvs / (self.settings["ikNb"] - 1) * i)
self.ik_uv_param.append(1. / (self.settings["ikNb"] - 1) * i)
space = om.MSpace.kWorld
pos = crv.getPointAtParam(u, space)
if i in [0, (self.settings["ikNb"] - 1)]:
t = getTransform(self.guide.root)
global_t = self._getTransformWithRollByBlade(t)
else:
u2 = crv.findParamFromLength(cvs / (self.settings["ikNb"] - 1) * i + 1)
pos2 = crv.getPointAtParam(u2, space)
t = getTransformLookingAt(pos, pos2, self.guide.blades["blade"].y, axis="yx", negate=self.negate)
# FIXME:
t = getTransform(self.guide.root)
global_t = self._getTransformWithRollByBlade(t)
global_t = setMatrixPosition(global_t, pos)
local_t = global_t
# global input
ik_global_npo = addTransform(self.root, self.getName("ik%s_global_npo" % i), global_t)
ik_global_in = addTransform(ik_global_npo, self.getName("ik%s_global_in" % i), global_t)
self.ik_global_in.append(ik_global_in)
# local input
ik_local_npo = addTransform(ik_global_in, self.getName("ik%s_local_npo" % i), local_t)
ik_local_in = addTransform(ik_local_npo, self.getName("ik%s_local_in" % i), local_t)
self.ik_local_in.append(ik_local_in)
ik_npo = addTransform(ik_local_in, self.getName("ik%s_npo" % i), local_t)
self.ik_npo.append(ik_npo)
# output
ik_global_out_npo = addTransform(self.root, self.getName("ik%s_global_out_npo" % i), global_t)
ik_global_out = addTransform(ik_global_out_npo, self.getName("ik%s_global_out" % i), global_t)
self.ik_global_out.append(ik_global_out)
# if i == 0 or i == (len(self.guide.apos) - 1):
if i == 0 or i == (self.settings["ikNb"] - 1):
ctl_form = "compas"
col = self.color_ik
size = self.size
w = size
h = size
d = size
else:
ctl_form = "compas" # TODO: set more better
col = self.color_ik
size = self.size * .85
w = size
h = size
d = size
ik_ctl = self.addCtl(
ik_npo,
"ik%s_ctl" % i,
local_t,
col,
ctl_form,
w=w,
h=h,
d=d,
# ro=datatypes.Vector([0, -math.pi / 2., 0]),
tp=self.previusTag,
mirrorConf=self.mirror_conf)
ymt_util.setKeyableAttributesDontLockVisibility(ik_ctl, self.tr_params)
self.ik_ctl.append(ik_ctl)
attribute.setInvertMirror(ik_ctl, ["tx", "rz", "ry"])
# ik global ref
ik_global_ref = primitive.addTransform(
ik_ctl,
self.getName("ik%s_global_ref" % i),
global_t)
self.ik_global_ref.append(ik_global_ref)
ymt_util.setKeyableAttributesDontLockVisibility(ik_global_ref, [])
def addObjects(self):
"""Add all the objects needed to create the component."""
# 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.ik0_npo = primitive.addTransform(self.root,
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, "hip"])
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=.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 * .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 * .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], .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 * .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 * .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 * .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
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 * .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])
# 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)
# 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, .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 * .1,
d=self.size * .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, "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=.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 * .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 * .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], .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 * .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 * .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 * .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 * .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, "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)
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, "spine_" + str(i + 2).zfill(2)])
