def addOperators(self):
"""Create operators and set the relations for the component rig
Apply operators, constraints, expressions to the hierarchy.
In order to keep the code clean and easier to debug,
we shouldn't create any new object in this method.
"""
pairs = [[self.top_ctl, self.bottom_npo, 1, 2],
[self.bottom_ctl, self.bottom_pivot, 2, 1],
[self.ext_ctl, self.int_npo, 3, 4],
[self.int_ctl, self.int_pivot, 4, 3]]
for pair in pairs:
d = vector.getDistance(self.guide.apos[pair[2]],
self.guide.apos[pair[3]])
sum_node = node.createPlusMinusAverage1D([d, pair[0].ty])
mul_node = node.createMulNode(pair[0].ty, self.volume_att)
sum2_node = node.createPlusMinusAverage1D([d, mul_node.outputX])
mul2_node = node.createDivNode(
[sum2_node.output1D, sum_node.output1D, sum2_node.output1D],
[d, d, d])
sum3D_node = pm.createNode("plusMinusAverage")
sum3D_node.attr("operation").set(2)
sum3D_node.input3D[0].input3Dx.set(2)
sum3D_node.input3D[0].input3Dz.set(2)
mul2_node.outputX >> sum3D_node.input3D[1].input3Dx
mul2_node.outputZ >> sum3D_node.input3D[1].input3Dz
sum3D_node.output3D.output3Dx >> pair[1].sx
mul2_node.outputY >> pair[1].sy
sum3D_node.output3D.output3Dx >> pair[1].sz
def getSize(self):
# size
size = .01
for pos in self.apos:
d = vec.getDistance(self.pos["root"], pos)
size = max(size, d)
size = max(size, .01)
return size
def getSize(self):
# size
size = .01
for pos in self.apos:
d = vec.getDistance(self.pos["root"], pos)
size = max(size, d)
size = max(size, .01)
return size
def addObjects(self):
# blades computation
self.normal = self.guide.blades["blade"].z
self.binormal = self.guide.blades["blade"].x
self.fk_npo = []
self.fk_ctl = []
self.spring_cns = []
self.spring_aim = []
self.spring_lvl = []
self.spring_ref = []
self.spring_npo = []
self.spring_target = []
parent = self.root
self.previousTag = self.parentCtlTag
for i, t in enumerate(tra.getChainTransform(self.guide.apos, self.normal, self.negate)):
dist = vec.getDistance(self.guide.apos[i], self.guide.apos[i+1])
fk_npo = pri.addTransform(parent, self.getName("fk%s_npo"%i), t)
spring_aim = pri.addTransform(fk_npo, self.getName("spring%s_aim"%i), t)
spring_cns = pri.addTransform(fk_npo, self.getName("spring%s_cns"%i), t)
fk_ctl = self.addCtl(spring_cns, "fk%s_ctl"%i, t, self.color_fk, "cube", w=dist, h=self.size*.1, d=self.size*.1, po=dt.Vector(dist*.5*self.n_factor,0,0), tp=self.previousTag)
self.previousTag = fk_ctl
t = tra.getTransformFromPos(self.guide.apos[i+1])
spring_npo = pri.addTransform(parent, self.getName("spring%s_npo"%i), t)
spring_target = pri.addTransform(spring_npo, self.getName("spring%s"%i), t)
parent = fk_ctl
self.spring_cns.append(spring_cns)
self.spring_aim.append(spring_aim)
self.addToGroup(spring_cns, "PLOT")
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
att.setKeyableAttributes(self.fk_ctl, self.tr_params)
self.spring_target.append(spring_target)
# Chain of deformers -------------------------------
self.loc = []
parent = self.root
for i, t in enumerate(tra.getChainTransform(self.guide.apos, self.normal, self.negate)):
loc = pri.addTransform(parent, self.getName("%s_loc"%i), t)
self.loc.append(loc)
self.jnt_pos.append([loc, i])
parent = loc
def addObjects(self):
self.normal = self.guide.blades["blade"].z
self.binormal = self.guide.blades["blade"].x
self.isFk = self.settings["mode"] != 1
self.isIk = self.settings["mode"] != 0
self.isFkIk = self.settings["mode"] == 2
# FK controlers ------------------------------------
if self.isFk:
self.fk_npo = []
self.fk_ctl = []
parent = self.root
for i, t in enumerate(tra.getChainTransform(self.guide.apos, self.normal, self.negate)):
dist = vec.getDistance(self.guide.apos[i], self.guide.apos[i+1])
fk_npo = pri.addTransform(parent, self.getName("fk%s_npo"%i), t)
fk_ctl = self.addCtl(fk_npo, "fk%s_ctl"%i, t, self.color_fk, "cube", w=dist, h=self.size*.1, d=self.size*.1, po=dt.Vector(dist*.5*self.n_factor,0,0))
parent = fk_ctl
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
# IK controlers ------------------------------------
if self.isIk:
normal = vec.getTransposedVector(self.normal, [self.guide.apos[0], self.guide.apos[1]], [self.guide.apos[-2], self.guide.apos[-1]])
t = tra.getTransformLookingAt(self.guide.apos[-2], self.guide.apos[-1], normal, "xy", self.negate)
t = tra.setMatrixPosition(t, self.guide.apos[-1])
self.ik_cns = pri.addTransform(self.root, self.getName("ik_cns"), t)
self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", t, self.color_ik, "null", w=self.size)
self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", t, self.color_ik, "cube", w=self.size*.3, h=self.size*.3, d=self.size*.3)
v = self.guide.apos[-1] - self.guide.apos[0]
v = v ^ self.normal
v.normalize()
v *= self.size
v += self.guide.apos[1]
self.upv_cns = pri.addTransformFromPos(self.root, self.getName("upv_cns"), v)
self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", tra.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size*.1)
# Chain
self.chain = pri.add2DChain(self.root, self.getName("chain"), self.guide.apos, self.normal, self.negate)
self.ikh = pri.addIkHandle(self.root, self.getName("ikh"), self.chain)
# Chain of deformers -------------------------------
self.loc = []
parent = self.root
for i, t in enumerate(tra.getChainTransform(self.guide.apos, self.normal, self.negate)):
loc = pri.addTransform(parent, self.getName("%s_loc"%i), t)
self.addShadow(loc, i)
self.loc.append(loc)
parent = loc
def addOperators(self):
"""Create operators and set the relations for the component rig
Apply operators/Solvers, constraints, expressions to the hierarchy.
In order to keep the code clean and easier to debug,
we shouldn't create any new object in this method.
"""
applyop.aimCns(self.ref_base,
self.squash_ctl,
axis="yx",
wupType=2,
wupVector=[1, 0, 0],
wupObject=self.ctl,
maintainOffset=False)
applyop.aimCns(self.ref_squash,
self.ctl,
axis="-yx",
wupType=2,
wupVector=[1, 0, 0],
wupObject=self.squash_ctl,
maintainOffset=False)
bIncrement = 1.0
blend = 0
for i, div_cns in enumerate(self.div_cns):
intMatrix = applyop.gear_intmatrix_op(
self.ref_base.attr("worldMatrix"),
self.ref_squash.attr("worldMatrix"), blend)
applyop.gear_mulmatrix_op(intMatrix.attr("output"),
div_cns.attr("parentInverseMatrix[0]"),
div_cns)
blend = blend + bIncrement
d = vector.getDistance(self.guide.apos[0], self.guide.apos[1])
dist_node = node.createDistNode(self.squash_ctl, self.ctl)
rootWorld_node = node.createDecomposeMatrixNode(
self.ctl.attr("worldMatrix"))
div_node = node.createDivNode(dist_node + ".distance",
rootWorld_node + ".outputScaleY")
div_node = node.createDivNode(div_node + ".outputX", d)
rev_node = node.createReverseNode(div_node + ".outputX")
add_node = pm.createNode("plusMinusAverage")
add_node.input1D[0].set(1.0)
rev_node.outputX >> add_node.input1D[1]
div_node.outputX >> self.ref_base.scaleY
add_node.output1D >> self.ref_base.scaleX
add_node.output1D >> self.ref_base.scaleZ
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
# FK controllers ------------------------------------
self.fk_npo = []
self.fk_ctl = []
t = self.guide.tra["root"]
parent = self.root
tOld = False
fk_ctl = None
self.previusTag = self.parentCtlTag
for i, t in enumerate(
transform.getChainTransform(self.guide.apos, self.normal,
self.negate)):
dist = vector.getDistance(self.guide.apos[i],
self.guide.apos[i + 1])
if self.settings["neutralpose"] or not tOld:
tnpo = t
else:
tnpo = transform.setMatrixPosition(
tOld, transform.getPositionFromMatrix(t))
fk_npo = primitive.addTransform(parent,
self.getName("fk%s_npo" % i), tnpo)
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=dist,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(dist * .5 * self.n_factor,
0, 0),
tp=self.previusTag)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
tOld = t
self.previusTag = fk_ctl
parent = fk_ctl
self.jnt_pos.append([fk_ctl, i, None, False])
def getSize(self):
"""
Get the size of the component.
Returns:
float: the size
"""
size = .01
for pos in self.apos:
d = vec.getDistance(self.pos["root"], pos)
size = max(size, d)
size = max(size, .01)
return size
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.ctl_npo = primitive.addTransform(self.root,
self.getName("ctl_npo"), t)
self.ctl = self.addCtl(self.ctl_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)
t = transform.getTransformFromPos(self.guide.apos[1])
self.orbit_ref1 = primitive.addTransform(self.ctl,
self.getName("orbit_ref1"), t)
self.orbit_ref2 = primitive.addTransform(self.root,
self.getName("orbit_ref2"), t)
self.orbit_cns = primitive.addTransform(self.ctl,
self.getName("orbit_cns"), t)
self.orbit_npo = primitive.addTransform(self.orbit_cns,
self.getName("orbit_npo"), t)
self.orbit_ctl = self.addCtl(self.orbit_npo,
"orbit_ctl",
t,
self.color_fk,
"sphere",
w=self.length0 / 4,
tp=self.ctl)
self.jnt_pos.append([self.ctl, "shoulder"])
def addOptionsValues(self):
# Convert color sliders to list
# for s in "RCL":
# self.values[s+"_color_fk"] = [self.values[s+"_color_fk_r"],self.values[s+"_color_fk_g"],self.values[s+"_color_fk_b"]]
# self.values[s+"_color_ik"] = [self.values[s+"_color_ik_r"],self.values[s+"_color_ik_g"],self.values[s+"_color_ik_b"]]
# Get rig size to adapt size of object to the scale of the character
maximum = 1
v = dt.Vector()
for comp in self.components.values():
for pos in comp.apos:
d = vec.getDistance(v, pos)
maximum = max(d, maximum)
self.values["size"] = max(maximum * .05, .1)
def addOptionsValues(self):
# Convert color sliders to list
# for s in "RCL":
# self.values[s+"_color_fk"] = [self.values[s+"_color_fk_r"],self.values[s+"_color_fk_g"],self.values[s+"_color_fk_b"]]
# self.values[s+"_color_ik"] = [self.values[s+"_color_ik_r"],self.values[s+"_color_ik_g"],self.values[s+"_color_ik_b"]]
# Get rig size to adapt size of object to the scale of the character
maximum = 1
v = dt.Vector()
for comp in self.components.values():
for pos in comp.apos:
d = vec.getDistance(v, pos)
maximum = max(d, maximum)
self.values["size"] = max(maximum * .05, .1)
def addOperators(self):
aop.aimCns(self.ref_base,
self.squash_ctl,
axis="yx",
wupType=2,
wupVector=[1, 0, 0],
wupObject=self.ctl,
maintainOffset=False)
aop.aimCns(self.ref_squash,
self.ctl,
axis="-yx",
wupType=2,
wupVector=[1, 0, 0],
wupObject=self.squash_ctl,
maintainOffset=False)
bIncrement = 1.0
blend = 0
for i, div_cns in enumerate(self.div_cns):
intMatrix = aop.gear_intmatrix_op(
self.ref_base.attr("worldMatrix"),
self.ref_squash.attr("worldMatrix"), blend)
aop.gear_mulmatrix_op(intMatrix.attr("output"),
div_cns.attr("parentInverseMatrix[0]"),
div_cns)
blend = blend + bIncrement
d = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
dist_node = nod.createDistNode(self.squash_ctl, self.ctl)
rootWorld_node = nod.createDecomposeMatrixNode(
self.ctl.attr("worldMatrix"))
div_node = nod.createDivNode(dist_node + ".distance",
rootWorld_node + ".outputScaleY")
div_node = nod.createDivNode(div_node + ".outputX", d)
rev_node = nod.createReverseNode(div_node + ".outputX")
add_node = pm.createNode("plusMinusAverage")
add_node.input1D[0].set(1.0)
rev_node.outputX >> add_node.input1D[1]
div_node.outputX >> self.ref_base.scaleY
add_node.output1D >> self.ref_base.scaleX
add_node.output1D >> self.ref_base.scaleZ
def addObjects(self):
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
t = tra.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis="xy",
negate=self.negate)
self.ctl_npo = pri.addTransform(self.root, self.getName("ctl_npo"), t)
self.ctl = self.addCtl(self.ctl_npo,
"ctl",
t,
self.color_fk,
"cube",
w=self.length0,
h=self.size * .1,
d=self.size * .1,
po=dt.Vector(.5 * self.length0 * self.n_factor,
0, 0))
t = tra.getTransformFromPos(self.guide.apos[1])
self.orbit_ref1 = pri.addTransform(self.ctl,
self.getName("orbit_ref1"), t)
self.orbit_ref2 = pri.addTransform(self.root,
self.getName("orbit_ref2"), t)
self.orbit_cns = pri.addTransform(self.ctl, self.getName("orbit_cns"),
t)
self.orbit_npo = pri.addTransform(self.orbit_cns,
self.getName("orbit_npo"), t)
self.orbit_ctl = self.addCtl(self.orbit_npo,
"orbit_ctl",
t,
self.color_fk,
"sphere",
w=self.length0 / 4)
self.jnt_pos.append([self.ctl, "shoulder"])
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 addOperators(self):
pairs = [[self.top_ctl, self.bottom_npo, 1, 2],
[self.bottom_ctl, self.bottom_pivot, 2, 1],
[self.ext_ctl, self.int_npo, 3, 4],
[self.int_ctl, self.int_pivot, 4, 3]]
for pair in pairs:
d = vec.getDistance(self.guide.apos[pair[2]],
self.guide.apos[pair[3]])
sum_node = nod.createPlusMinusAverage1D([d, pair[0].ty])
mul_node = nod.createMulNode(pair[0].ty, self.volume_att)
sum2_node = nod.createPlusMinusAverage1D([d, mul_node.outputX])
mul2_node = nod.createDivNode(
[sum2_node.output1D, sum_node.output1D, sum2_node.output1D],
[d, d, d])
sum3D_node = pm.createNode("plusMinusAverage")
sum3D_node.attr("operation").set(2)
sum3D_node.input3D[0].input3Dx.set(2)
sum3D_node.input3D[0].input3Dz.set(2)
mul2_node.outputX >> sum3D_node.input3D[1].input3Dx
mul2_node.outputZ >> sum3D_node.input3D[1].input3Dz
sum3D_node.output3D.output3Dx >> pair[1].sx
mul2_node.outputY >> pair[1].sy
sum3D_node.output3D.output3Dx >> pair[1].sz
def addObjects(self):
self.normal = self.getNormalFromPos(self.guide.apos)
self.binormal = self.getBiNormalFromPos(self.guide.apos)
self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2])
self.length2 = vec.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 = pri.addTransformFromPos(self.root,
self.getName("fk_cns"),
self.guide.apos[0])
tpv = self.guide.apos[0] + (
(self.guide.apos[1] - self.guide.apos[0]) * [1, 0, 0])
t = tra.getTransformLookingAt(self.guide.apos[0], tpv, self.normal,
"xz", self.negate)
# *ms* add FK isolation
self.fk0_npo = pri.addTransform(self.fk_cns, self.getName("fk0_npo"),
t)
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1],
self.normal, "xz", self.negate)
self.fk0_ctl = self.addCtl(self.fk0_npo,
"fk0_ctl",
t,
self.color_fk,
"cube",
w=self.length0 * .55,
h=self.size * .1,
d=self.size * .1,
po=dt.Vector(
.35 * self.length0 * self.n_factor, 0,
0))
att.setKeyableAttributes(self.fk0_ctl)
# *ms* add fk roll control Simage style
self.fk0_roll_ctl = self.addCtl(self.fk0_ctl,
"fk0_roll_ctl",
t,
self.color_fk,
"cube",
w=self.length0 * .45,
h=self.size * .1,
d=self.size * .1,
po=dt.Vector(
.85 * self.length0 * self.n_factor,
0, 0))
att.setKeyableAttributes(self.fk0_roll_ctl)
t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2],
self.normal, "xz", self.negate)
self.fk1_npo = pri.addTransform(self.fk0_roll_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=dt.Vector(
.5 * self.length1 * self.n_factor, 0,
0))
att.setKeyableAttributes(self.fk1_ctl)
t = tra.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 = pri.addTransform(self.fk1_ctl, self.getName("fk2_mtx"),
t)
# fk2_npo is need to take the effector position
self.fk2_npo = pri.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=dt.Vector(
.5 * self.length2 * self.n_factor, 0,
0))
att.setKeyableAttributes(self.fk2_ctl)
self.fk_ctl = [self.fk0_roll_ctl, self.fk1_ctl, self.fk2_ctl]
for x in self.fk_ctl:
att.setInvertMirror(x, ["tx", "ty", "tz"])
# IK Controlers -----------------------------------
self.ik_cns = pri.addTransformFromPos(self.root,
self.getName("ik_cns"),
self.guide.pos["wrist"])
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
tra.getTransformFromPos(
self.guide.pos["wrist"]),
self.color_ik,
"null",
w=self.size * .12)
att.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"])
if self.negate:
m = tra.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"], self.normal,
"x-y", True)
else:
m = tra.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)
att.setKeyableAttributes(self.ik_ctl)
att.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 = pri.addTransformFromPos(self.root,
self.getName("upv_cns"),
self.guide.apos[0])
self.upv_auv = pri.addTransformFromPos(self.upv_cns,
self.getName("upv_auv"),
self.guide.apos[0])
self.upv_mtx = pri.addTransformFromPos(self.upv_cns,
self.getName("upv_mtx"),
self.guide.apos[0])
self.upv_npo = pri.addTransformFromPos(self.upv_mtx,
self.getName("upv_npo"), v)
self.upv_ctl = self.addCtl(self.upv_npo,
"upv_ctl",
tra.getTransform(self.upv_npo),
self.color_ik,
"diamond",
w=self.size * .12)
att.setKeyableAttributes(self.upv_ctl, self.t_params)
att.setInvertMirror(self.upv_ctl, ["tx"])
# References --------------------------------------
# Calculate again the transfor for the IK ref. This way align with FK
trnIK_ref = tra.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal, "xz", self.negate)
self.ik_ref = pri.addTransform(self.ik_ctl, self.getName("ik_ref"),
trnIK_ref)
self.fk_ref = pri.addTransform(self.fk_ctl[2], self.getName("fk_ref"),
trnIK_ref)
# Chain --------------------------------------------
# The outputs of the ikfk2bone solver
self.bone0 = pri.addLocator(self.root, self.getName("0_bone"),
tra.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 = pri.addLocator(self.root, self.getName("1_bone"),
tra.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 = pri.addTransformFromPos(self.root,
self.getName("ctrn_loc"),
self.guide.apos[1])
self.eff_npo = pri.addTransformFromPos(self.root,
self.getName("eff_npo"),
self.guide.apos[2])
self.eff_loc = pri.addTransformFromPos(self.eff_npo,
self.getName("eff_loc"),
self.guide.apos[2])
# Mid Controler ------------------------------------
self.mid_ctl = self.addCtl(self.ctrn_loc,
"mid_ctl",
tra.getTransform(self.ctrn_loc),
self.color_ik,
"sphere",
w=self.size * .2)
att.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"])
# *ms* add elbow thickness
# # Twist references ---------------------------------
# x = dt.Vector(0,-1,0)
# x = x * tra.getTransform(self.eff_loc)
# z = dt.Vector(self.normal.x,self.normal.y,self.normal.z)
# z = z * tra.getTransform(self.eff_loc)
# m = tra.getRotationFromAxis(x, z, "xz", self.negate)
# m = tra.setMatrixPosition(m, tra.getTranslation(self.ik_ctl))
#Roll join ref
#self.rollRef = pri.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_npo = pri.addTransform(self.root, self.getName("tws0_npo"),
tra.getTransform(self.fk_ctl[0]))
self.tws0_loc = pri.addTransform(self.tws0_npo,
self.getName("tws0_loc"),
tra.getTransform(self.fk_ctl[0]))
self.tws0_rot = pri.addTransform(self.tws0_loc,
self.getName("tws0_rot"),
tra.getTransform(self.fk_ctl[0]))
self.tws1_npo = pri.addTransform(self.ctrn_loc,
self.getName("tws1_npo"),
tra.getTransform(self.ctrn_loc))
self.tws1_loc = pri.addTransform(self.tws1_npo,
self.getName("tws1_loc"),
tra.getTransform(self.ctrn_loc))
self.tws1_rot = pri.addTransform(self.tws1_loc,
self.getName("tws1_rot"),
tra.getTransform(self.ctrn_loc))
self.tws2_npo = pri.addTransform(self.root, self.getName("tws2_npo"),
tra.getTransform(self.fk_ctl[2]))
self.tws2_loc = pri.addTransform(self.tws2_npo,
self.getName("tws2_loc"),
tra.getTransform(self.fk_ctl[2]))
self.tws2_rot = pri.addTransform(self.tws2_loc,
self.getName("tws2_rot"),
tra.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
self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + 2
self.div_cns = []
for i in range(self.divisions):
div_cns = pri.addTransform(self.root,
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 wrist
self.jnt_pos.append([self.eff_loc, 'end'])
# self.end_ref = pri.addTransform(self.eff_loc, self.getName("end_ref"), m)
# for a in "xyz":
# self.end_ref.attr("s%s"%a).set(1.0)
# self.end_ref.attr("r%s"%a).set(0.0)
# self.jnt_pos.append([self.end_ref, 'end'])
#match IK FK references
self.match_fk0_off = pri.addTransform(self.root,
self.getName("matchFk0_npo"),
tra.getTransform(self.fk_ctl[1]))
# self.match_fk0_off.attr("tx").set(1.0)
self.match_fk0 = pri.addTransform(self.match_fk0_off,
self.getName("fk0_mth"),
tra.getTransform(self.fk_ctl[0]))
self.match_fk1_off = pri.addTransform(self.root,
self.getName("matchFk1_npo"),
tra.getTransform(self.fk_ctl[2]))
# self.match_fk1_off.attr("tx").set(1.0)
self.match_fk1 = pri.addTransform(self.match_fk1_off,
self.getName("fk1_mth"),
tra.getTransform(self.fk_ctl[1]))
self.match_fk2 = pri.addTransform(self.ik_ctl, self.getName("fk2_mth"),
tra.getTransform(self.fk_ctl[2]))
self.match_ik = pri.addTransform(self.fk2_ctl, self.getName("ik_mth"),
tra.getTransform(self.ik_ctl))
self.match_ikUpv = pri.addTransform(self.fk0_ctl,
self.getName("upv_mth"),
tra.getTransform(self.upv_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)
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,
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)
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"])
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"])
# 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))
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 ----------------------------------------
# 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"] + 3 + 2
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.tws2_rot,
self.getName("end_ref"), m)
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 = primitive.addTransform(
self.ik_ctl, self.getName("fk2_mth"),
transform.getTransform(self.fk_ctl[2]))
self.match_ik = primitive.addTransform(
self.fk2_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))
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], tpv,
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 = primitive.addTransform(
self.root, self.getName("fk0_mth"),
transform.getTransform(self.fk_ctl[0]))
self.match_fk1 = primitive.addTransform(
self.root, self.getName("fk1_mth"),
transform.getTransform(self.fk_ctl[1]))
self.match_fk2 = primitive.addTransform(
self.ik_ctl, self.getName("fk2_mth"),
transform.getTransform(self.fk_ctl[2]))
self.match_ik = primitive.addTransform(
self.fk2_ctl, self.getName("ik_mth"),
transform.getTransform(self.ik_ctl))
self.match_ikUpv = primitive.addTransform(
self.fk0_roll_ctl, self.getName("upv_mth"),
transform.getTransform(self.upv_ctl))
def addOperators(self):
"""Create operators and set the relations for the component rig
Apply operators, constraints, expressions to the hierarchy.
In order to keep the code clean and easier to debug,
we shouldn't create any new object in this method.
"""
# Auto bend ----------------------------
if self.settings["autoBend"]:
mul_node = node.createMulNode(
[self.autoBendChain[0].ry, self.autoBendChain[0].rz],
[self.sideBend_att, self.frontBend_att])
mul_node.outputX >> self.ik1autoRot_lvl.rz
mul_node.outputY >> self.ik1autoRot_lvl.rx
self.ikHandleAutoBend = primitive.addIkHandle(
self.autoBend_ctl,
self.getName("ikHandleAutoBend"),
self.autoBendChain, "ikSCsolver")
# Tangent position ---------------------------------
# common part
d = vector.getDistance(self.guide.apos[0], self.guide.apos[1])
dist_node = node.createDistNode(self.ik0_ctl, self.ik1_ctl)
rootWorld_node = node.createDecomposeMatrixNode(
self.root.attr("worldMatrix"))
div_node = node.createDivNode(dist_node + ".distance",
rootWorld_node + ".outputScaleX")
div_node = node.createDivNode(div_node + ".outputX", d)
# tan0
mul_node = node.createMulNode(self.tan0_att,
self.tan0_npo.getAttr("ty"))
res_node = node.createMulNode(mul_node + ".outputX",
div_node + ".outputX")
pm.connectAttr(res_node + ".outputX",
self.tan0_npo.attr("ty"))
# tan1
mul_node = node.createMulNode(self.tan1_att,
self.tan1_npo.getAttr("ty"))
res_node = node.createMulNode(mul_node + ".outputX",
div_node + ".outputX")
pm.connectAttr(res_node + ".outputX", self.tan1_npo.attr("ty"))
# Tangent Mid --------------------------------------
if self.settings["centralTangent"]:
tanIntMat = applyop.gear_intmatrix_op(
self.tan0_npo.attr("worldMatrix"),
self.tan1_npo.attr("worldMatrix"),
.5)
applyop.gear_mulmatrix_op(
tanIntMat.attr("output"),
self.tan_npo.attr("parentInverseMatrix[0]"),
self.tan_npo)
pm.connectAttr(self.tan_ctl.attr("translate"),
self.tan0_off.attr("translate"))
pm.connectAttr(self.tan_ctl.attr("translate"),
self.tan1_off.attr("translate"))
# Curves -------------------------------------------
op = applyop.gear_curveslide2_op(
self.slv_crv, self.mst_crv, 0, 1.5, .5, .5)
pm.connectAttr(self.position_att, op + ".position")
pm.connectAttr(self.maxstretch_att, op + ".maxstretch")
pm.connectAttr(self.maxsquash_att, op + ".maxsquash")
pm.connectAttr(self.softness_att, op + ".softness")
# Volume driver ------------------------------------
crv_node = node.createCurveInfoNode(self.slv_crv)
# Division -----------------------------------------
for i in range(self.settings["division"]):
# References
u = i / (self.settings["division"] - 1.0)
cns = applyop.pathCns(
self.div_cns[i], self.slv_crv, False, u, True)
cns.setAttr("frontAxis", 1) # front axis is 'Y'
cns.setAttr("upAxis", 0) # front axis is 'X'
# Roll
intMatrix = applyop.gear_intmatrix_op(
self.ik0_ctl + ".worldMatrix",
self.ik1_ctl + ".worldMatrix",
u)
dm_node = node.createDecomposeMatrixNode(intMatrix + ".output")
pm.connectAttr(dm_node + ".outputRotate",
self.twister[i].attr("rotate"))
pm.parentConstraint(self.twister[i],
self.ref_twist[i],
maintainOffset=True)
pm.connectAttr(self.ref_twist[i] + ".translate",
cns + ".worldUpVector")
# compensate scale reference
div_node = node.createDivNode([1, 1, 1],
[rootWorld_node + ".outputScaleX",
rootWorld_node + ".outputScaleY",
rootWorld_node + ".outputScaleZ"])
# Squash n Stretch
op = applyop.gear_squashstretch2_op(
self.scl_transforms[i],
self.root,
pm.arclen(self.slv_crv),
"y",
div_node + ".output")
pm.connectAttr(self.volume_att, op + ".blend")
pm.connectAttr(crv_node + ".arcLength", op + ".driver")
pm.connectAttr(self.st_att[i], op + ".stretch")
pm.connectAttr(self.sq_att[i], op + ".squash")
# Controlers
if i == 0:
mulmat_node = applyop.gear_mulmatrix_op(
self.div_cns[i].attr("worldMatrix"),
self.root.attr("worldInverseMatrix"))
dm_node = node.createDecomposeMatrixNode(
mulmat_node + ".output")
pm.connectAttr(dm_node + ".outputTranslate",
self.fk_npo[i].attr("t"))
else:
mulmat_node = applyop.gear_mulmatrix_op(
self.div_cns[i].attr("worldMatrix"),
self.div_cns[i - 1].attr("worldInverseMatrix"))
dm_node = node.createDecomposeMatrixNode(
mulmat_node + ".output")
mul_node = node.createMulNode(div_node + ".output",
dm_node + ".outputTranslate")
pm.connectAttr(mul_node + ".output",
self.fk_npo[i].attr("t"))
pm.connectAttr(dm_node + ".outputRotate", self.fk_npo[i].attr("r"))
# Orientation Lock
if i == 0:
dm_node = node.createDecomposeMatrixNode(
self.ik0_ctl + ".worldMatrix")
blend_node = node.createBlendNode(
[dm_node + ".outputRotate%s" % s for s in "XYZ"],
[cns + ".rotate%s" % s for s in "XYZ"],
self.lock_ori0_att)
self.div_cns[i].attr("rotate").disconnect()
pm.connectAttr(blend_node + ".output",
self.div_cns[i] + ".rotate")
elif i == self.settings["division"] - 1:
dm_node = node.createDecomposeMatrixNode(
self.ik1_ctl + ".worldMatrix")
blend_node = node.createBlendNode(
[dm_node + ".outputRotate%s" % s for s in "XYZ"],
[cns + ".rotate%s" % s for s in "XYZ"],
self.lock_ori1_att)
self.div_cns[i].attr("rotate").disconnect()
pm.connectAttr(blend_node + ".output",
self.div_cns[i] + ".rotate")
# Connections (Hooks) ------------------------------
pm.parentConstraint(self.scl_transforms[0], self.cnx0)
pm.scaleConstraint(self.scl_transforms[0], self.cnx0)
pm.parentConstraint(self.scl_transforms[-1], self.cnx1)
pm.scaleConstraint(self.scl_transforms[-1], self.cnx1)
def addObjects(self):
self.WIP = self.options["mode"]
self.normal = self.getNormalFromPos(self.guide.apos)
self.binormal = self.getBiNormalFromPos(self.guide.apos)
self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2])
self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3])
# FK Controlers -----------------------------------
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1],
self.normal, "xz", self.negate)
self.fk0_npo = pri.addTransform(self.root, 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=dt.Vector(
.5 * self.length0 * self.n_factor, 0,
0))
att.setKeyableAttributes(self.fk0_ctl)
t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2],
self.normal, "xz", self.negate)
self.fk1_npo = pri.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=dt.Vector(
.5 * self.length1 * self.n_factor, 0,
0))
att.setKeyableAttributes(self.fk1_ctl)
t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3],
self.normal, "xz", self.negate)
self.fk2_npo = pri.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=dt.Vector(
.5 * self.length2 * self.n_factor, 0,
0))
att.setKeyableAttributes(self.fk2_ctl)
self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl]
for x in self.fk_ctl:
att.setInvertMirror(x, ["tx", "ty", "tz"])
# IK Controlers -----------------------------------
self.ik_cns = pri.addTransformFromPos(self.root,
self.getName("ik_cns"),
self.guide.pos["wrist"])
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
tra.getTransformFromPos(
self.guide.pos["wrist"]),
self.color_ik,
"null",
w=self.size * .12)
att.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"])
if self.negate:
m = tra.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"], self.normal,
"x-y", True)
else:
m = tra.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)
att.setKeyableAttributes(self.ik_ctl)
att.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 = pri.addTransformFromPos(self.root,
self.getName("upv_cns"), v)
self.upv_ctl = self.addCtl(self.upv_cns,
"upv_ctl",
tra.getTransform(self.upv_cns),
self.color_ik,
"diamond",
w=self.size * .12)
att.setInvertMirror(self.upv_ctl, ["tx"])
# References --------------------------------------
# Calculate again the transfor for the IK ref. This way align with FK
trnIK_ref = tra.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal, "xz", self.negate)
self.ik_ref = pri.addTransform(self.ik_ctl, self.getName("ik_ref"),
trnIK_ref)
self.fk_ref = pri.addTransform(self.fk_ctl[2], self.getName("fk_ref"),
trnIK_ref)
# Chain --------------------------------------------
# The outputs of the ikfk2bone solver
self.bone0 = pri.addLocator(self.root, self.getName("0_bone"),
tra.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)
bShape = self.bone0.getShape()
bShape.setAttr("visibility", False)
self.bone1 = pri.addLocator(self.root, self.getName("1_bone"),
tra.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)
bShape = self.bone1.getShape()
bShape.setAttr("visibility", False)
#Elbow control
tA = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1],
self.normal, "xz", self.negate)
tA = tra.setMatrixPosition(tA, self.guide.apos[1])
tB = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2],
self.normal, "xz", self.negate)
t = tra.getInterpolateTransformMatrix(tA, tB)
self.ctrn_loc = pri.addTransform(self.root, self.getName("ctrn_loc"),
t)
#match IK FK references
self.match_fk0_off = pri.addTransform(self.root,
self.getName("matchFk0_npo"),
tra.getTransform(self.fk_ctl[1]))
# self.match_fk0_off.attr("tx").set(1.0)
self.match_fk0 = pri.addTransform(self.match_fk0_off,
self.getName("fk0_mth"),
tra.getTransform(self.fk_ctl[0]))
self.match_fk1_off = pri.addTransform(self.root,
self.getName("matchFk1_npo"),
tra.getTransform(self.fk_ctl[2]))
# self.match_fk1_off.attr("tx").set(1.0)
self.match_fk1 = pri.addTransform(self.match_fk1_off,
self.getName("fk1_mth"),
tra.getTransform(self.fk_ctl[1]))
self.match_fk2 = pri.addTransform(self.ik_ctl, self.getName("fk2_mth"),
tra.getTransform(self.fk_ctl[2]))
self.match_ik = pri.addTransform(self.fk2_ctl, self.getName("ik_mth"),
tra.getTransform(self.ik_ctl))
self.match_ikUpv = pri.addTransform(self.fk0_ctl,
self.getName("upv_mth"),
tra.getTransform(self.upv_ctl))
# Eff locator
self.eff_loc = pri.addTransformFromPos(self.root,
self.getName("eff_loc"),
self.guide.apos[2])
# Mid Controler ------------------------------------
self.mid_ctl = self.addCtl(self.ctrn_loc,
"mid_ctl",
tra.getTransform(self.ctrn_loc),
self.color_ik,
"sphere",
w=self.size * .2)
att.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"])
#Roll join ref---------------------------------
self.tws0_loc = pri.addTransform(self.root, self.getName("tws0_loc"),
tra.getTransform(self.fk_ctl[0]))
self.tws1_npo = pri.addTransform(self.ctrn_loc,
self.getName("tws1_npo"),
tra.getTransform(self.ctrn_loc))
self.tws1_loc = pri.addTransform(self.tws1_npo,
self.getName("tws1_loc"),
tra.getTransform(self.ctrn_loc))
self.tws1A_npo = pri.addTransform(self.mid_ctl,
self.getName("tws1A_npo"), tA)
self.tws1A_loc = pri.addTransform(self.tws1A_npo,
self.getName("tws1A_loc"), tA)
self.tws1B_npo = pri.addTransform(self.mid_ctl,
self.getName("tws1B_npo"), tB)
self.tws1B_loc = pri.addTransform(self.tws1B_npo,
self.getName("tws1B_loc"), tB)
self.tws2_npo = pri.addTransform(self.root, self.getName("tws2_npo"),
tra.getTransform(self.fk_ctl[2]))
self.tws2_loc = pri.addTransform(self.tws2_npo,
self.getName("tws2_loc"),
tra.getTransform(self.fk_ctl[2]))
# Roll twist chain ---------------------------------
#Arm
self.armChainPos = []
ii = 1.0 / (self.settings["div0"] + 1)
i = 0.0
for p in range(self.settings["div0"] + 2):
self.armChainPos.append(
vec.linearlyInterpolate(self.guide.pos["root"],
self.guide.pos["elbow"],
blend=i))
i = i + ii
self.armTwistChain = pri.add2DChain(self.root,
self.getName("armTwist%s_jnt"),
self.armChainPos, self.normal,
False, self.WIP)
#Forearm
self.forearmChainPos = []
ii = 1.0 / (self.settings["div1"] + 1)
i = 0.0
for p in range(self.settings["div1"] + 2):
self.forearmChainPos.append(
vec.linearlyInterpolate(self.guide.pos["elbow"],
self.guide.pos["wrist"],
blend=i))
i = i + ii
self.forearmTwistChain = pri.add2DChain(
self.root, self.getName("forearmTwist%s_jnt"),
self.forearmChainPos, self.normal, False, self.WIP)
pm.parent(self.forearmTwistChain[0], self.mid_ctl)
#Hand Aux chain and nonroll
self.auxChainPos = []
ii = .5
i = 0.0
for p in range(3):
self.auxChainPos.append(
vec.linearlyInterpolate(self.guide.pos["wrist"],
self.guide.pos["eff"],
blend=i))
i = i + ii
t = self.root.getMatrix(worldSpace=True)
self.aux_npo = pri.addTransform(self.root, self.getName("aux_npo"), t)
self.auxTwistChain = pri.add2DChain(self.aux_npo,
self.getName("auxTwist%s_jnt"),
self.auxChainPos, self.normal,
False, self.WIP)
#Non Roll join ref ---------------------------------
self.armRollRef = pri.add2DChain(self.root,
self.getName("armRollRef%s_jnt"),
self.armChainPos[:2], self.normal,
False, self.WIP)
self.forearmRollRef = pri.add2DChain(
self.aux_npo, self.getName("forearmRollRef%s_jnt"),
self.auxChainPos[: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 elbow angle control
self.divisions = self.settings["div0"] + self.settings["div1"] + 4
self.div_cns = []
for i in range(self.divisions):
div_cns = pri.addTransform(self.root,
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 wrist
self.end_ref = pri.addTransform(self.eff_loc, self.getName("end_ref"),
tra.getTransform(self.eff_loc))
if self.negate:
self.end_ref.attr("rz").set(180.0)
self.jnt_pos.append([self.end_ref, "end"])
# Tangent controls
t = tra.getInterpolateTransformMatrix(self.fk_ctl[0], self.tws1A_npo,
.3333)
self.armTangentA_loc = pri.addTransform(
self.root, self.getName("armTangentA_loc"),
self.fk_ctl[0].getMatrix(worldSpace=True))
self.armTangentA_npo = pri.addTransform(
self.armTangentA_loc, self.getName("armTangentA_npo"), t)
self.armTangentA_ctl = self.addCtl(self.armTangentA_npo,
"armTangentA_ctl",
t,
self.color_ik,
"circle",
w=self.size * .2,
ro=dt.Vector(0, 0, 1.570796))
t = tra.getInterpolateTransformMatrix(self.fk_ctl[0], self.tws1A_npo,
.6666)
self.armTangentB_npo = pri.addTransform(
self.tws1A_loc, self.getName("armTangentB_npo"), t)
self.armTangentB_ctl = self.addCtl(self.armTangentB_npo,
"armTangentB_ctl",
t,
self.color_ik,
"circle",
w=self.size * .2,
ro=dt.Vector(0, 0, 1.570796))
tC = self.tws1B_npo.getMatrix(worldSpace=True)
tC = tra.setMatrixPosition(tC, self.guide.apos[2])
t = tra.getInterpolateTransformMatrix(self.tws1B_npo, tC, .3333)
self.forearmTangentA_npo = pri.addTransform(
self.tws1B_loc, self.getName("forearmTangentA_npo"), t)
self.forearmTangentA_ctl = self.addCtl(self.forearmTangentA_npo,
"forearmTangentA_ctl",
t,
self.color_ik,
"circle",
w=self.size * .2,
ro=dt.Vector(0, 0, 1.570796))
t = tra.getInterpolateTransformMatrix(self.tws1B_npo, tC, .6666)
self.forearmTangentB_loc = pri.addTransform(
self.root, self.getName("forearmTangentB_loc"), tC)
self.forearmTangentB_npo = pri.addTransform(
self.forearmTangentB_loc, self.getName("forearmTangentB_npo"), t)
self.forearmTangentB_ctl = self.addCtl(self.forearmTangentB_npo,
"forearmTangentB_ctl",
t,
self.color_ik,
"circle",
w=self.size * .2,
ro=dt.Vector(0, 0, 1.570796))
t = self.mid_ctl.getMatrix(worldSpace=True)
self.elbowTangent_npo = pri.addTransform(
self.mid_ctl, self.getName("elbowTangent_npo"), t)
self.elbowTangent_ctl = self.addCtl(self.elbowTangent_npo,
"elbowTangent_ctl",
t,
self.color_fk,
"circle",
w=self.size * .25,
ro=dt.Vector(0, 0, 1.570796))
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
if self.settings["ikOri"]:
t = transform.getTransformLookingAt(self.guide.pos["foot"],
self.guide.pos["eff"],
self.x_axis, "zx", False)
else:
t = transform.getTransformLookingAt(self.guide.apos[3],
self.guide.apos[4],
self.normal, "z-x", False)
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)
self.ik2b_bone_ref = primitive.addTransform(self.chain3bones[3],
self.getName("ik2B_B_ref"),
t)
self.ik2b_blend = primitive.addTransform(self.ik_ctl,
self.getName("ik2B_blend"), t)
self.roll_ctl = self.addCtl(self.ik2b_blend,
"roll_ctl",
t,
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'])
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
# Ik Controlers ------------------------------------
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_cns = primitive.addTransform(self.root, self.getName("ik_cns"),
t)
self.ik_ctl = self.addCtl(self.ik_cns,
"ik_ctl",
t,
self.color_ik,
"compas",
w=self.size * .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 * .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 * .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 = []
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.settings["division"]):
# 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.settings["division"] - 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 * .2,
h=self.size * .05,
d=self.size * .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
self.jnt_pos.append([fk_ctl, i])
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 * .5,
h=dist,
d=self.size * .5,
po=datatypes.Vector(0, dist * .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, "head"])
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.isFk = self.settings["mode"] != 1
self.isIk = self.settings["mode"] != 0
self.isFkIk = self.settings["mode"] == 2
self.WIP = self.options["mode"]
# FK controllers ------------------------------------
if self.isFk:
self.fk_npo = []
self.fk_ctl = []
self.fk_ref = []
self.fk_off = []
t = self.guide.tra["root"]
self.ik_cns = primitive.addTransform(self.root,
self.getName("ik_cns"), t)
parent = self.ik_cns
tOld = False
fk_ctl = None
self.previusTag = self.parentCtlTag
for i, t in enumerate(
transform.getChainTransform(self.guide.apos, self.normal,
self.negate)):
dist = vector.getDistance(self.guide.apos[i],
self.guide.apos[i + 1])
if self.settings["neutralpose"] or not tOld:
tnpo = t
else:
tnpo = transform.setMatrixPosition(
tOld, transform.getPositionFromMatrix(t))
if i:
tref = transform.setMatrixPosition(
tOld, transform.getPositionFromMatrix(t))
fk_ref = primitive.addTransform(
fk_ctl, self.getName("fk%s_ref" % i), tref)
self.fk_ref.append(fk_ref)
else:
tref = t
fk_off = primitive.addTransform(parent,
self.getName("fk%s_off" % i),
tref)
fk_npo = primitive.addTransform(fk_off,
self.getName("fk%s_npo" % i),
tnpo)
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=dist,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(
dist * .5 * self.n_factor, 0, 0),
tp=self.previusTag)
self.fk_off.append(fk_off)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
tOld = t
self.previusTag = fk_ctl
# IK controllers ------------------------------------
if self.isIk:
normal = vector.getTransposedVector(
self.normal, [self.guide.apos[0], self.guide.apos[1]],
[self.guide.apos[-2], self.guide.apos[-1]])
t = transform.getTransformLookingAt(self.guide.apos[-2],
self.guide.apos[-1], normal,
"xy", self.negate)
t = transform.setMatrixPosition(t, self.guide.apos[-1])
self.ik_cns = primitive.addTransform(self.root,
self.getName("ik_cns"), t)
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
t,
self.color_ik,
"null",
w=self.size,
tp=self.parentCtlTag)
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
t,
self.color_ik,
"cube",
w=self.size * .3,
h=self.size * .3,
d=self.size * .3,
tp=self.ikcns_ctl)
attribute.setKeyableAttributes(self.ik_ctl, self.t_params)
v = self.guide.apos[-1] - self.guide.apos[0]
v = v ^ self.normal
v.normalize()
v *= self.size
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 * .1,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.upv_ctl, self.t_params)
# Chain
self.chain = primitive.add2DChain(self.root, self.getName("chain"),
self.guide.apos, self.normal,
self.negate)
self.chain[0].attr("visibility").set(self.WIP)
# Chain of deformers -------------------------------
self.loc = []
parent = self.root
for i, t in enumerate(
transform.getChainTransform(self.guide.apos, self.normal,
self.negate)):
loc = primitive.addTransform(parent, self.getName("%s_loc" % i), t)
self.loc.append(loc)
self.jnt_pos.append([loc, i, None, False])
def addObjects(self):
"""Add all the objects needed to create the component."""
self.div_count = len(self.guide.apos) - 5
plane = [self.guide.apos[0], self.guide.apos[-4], self.guide.apos[-3]]
self.normal = self.getNormalFromPos(plane)
self.binormal = self.getBiNormalFromPos(plane)
# Heel ---------------------------------------------
# bank pivot
t = transform.getTransformLookingAt(self.guide.pos["heel"],
self.guide.apos[-4],
self.normal,
"xz",
self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["inpivot"])
self.in_npo = primitive.addTransform(
self.root, self.getName("in_npo"), t)
self.in_piv = primitive.addTransform(
self.in_npo, self.getName("in_piv"), t)
t = transform.setMatrixPosition(t, self.guide.pos["outpivot"])
self.out_piv = primitive.addTransform(
self.in_piv, self.getName("out_piv"), t)
# heel
t = transform.getTransformLookingAt(self.guide.pos["heel"],
self.guide.apos[-4],
self.normal,
"xz",
self.negate)
self.heel_loc = primitive.addTransform(
self.out_piv, self.getName("heel_loc"), t)
attribute.setRotOrder(self.heel_loc, "YZX")
self.heel_ctl = self.addCtl(self.heel_loc,
"heel_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .1,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.heel_ctl, self.r_params)
# Tip ----------------------------------------------
v = datatypes.Vector(self.guide.apos[-5].x,
self.guide.apos[-1].y,
self.guide.apos[-5].z)
t = transform.setMatrixPosition(t, v)
self.tip_ctl = self.addCtl(self.heel_ctl,
"tip_ctl",
t,
self.color_ik,
"circle",
w=self.size,
tp=self.heel_ctl)
attribute.setKeyableAttributes(self.tip_ctl, self.r_params)
# Roll ---------------------------------------------
if self.settings["useRollCtl"]:
t = transform.getTransformLookingAt(self.guide.pos["heel"],
self.guide.apos[-4],
self.normal,
"xz",
self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["root"])
self.roll_np = primitive.addTransform(
self.root, self.getName("roll_npo"), t)
self.roll_ctl = self.addCtl(self.roll_np,
"roll_ctl",
t,
self.color_ik,
"cylinder",
w=self.size * .5,
h=self.size * .5,
ro=datatypes.Vector(3.1415 * .5, 0, 0),
tp=self.tip_ctl)
attribute.setKeyableAttributes(self.roll_ctl, ["rx", "rz"])
# Backward Controlers ------------------------------
bk_pos = self.guide.apos[1:-3]
bk_pos.reverse()
parent = self.tip_ctl
self.bk_ctl = []
self.bk_loc = []
self.previousTag = self.tip_ctl
for i, pos in enumerate(bk_pos):
if i == 0:
t = transform.getTransform(self.heel_ctl)
t = transform.setMatrixPosition(t, pos)
else:
dir = bk_pos[i - 1]
t = transform.getTransformLookingAt(
pos, dir, self.normal, "xz", self.negate)
bk_loc = primitive.addTransform(
parent, self.getName("bk%s_loc" % i), t)
bk_ctl = self.addCtl(bk_loc,
"bk%s_ctl" % i,
t,
self.color_ik,
"sphere",
w=self.size * .15,
tp=self.previousTag)
attribute.setKeyableAttributes(bk_ctl, self.r_params)
self.previousTag = bk_ctl
self.bk_loc.append(bk_loc)
self.bk_ctl.append(bk_ctl)
parent = bk_ctl
# FK Reference ------------------------------------
self.fk_ref = primitive.addTransformFromPos(self.bk_ctl[-1],
self.getName("fk_ref"),
self.guide.apos[0])
self.fk_npo = primitive.addTransform(
self.fk_ref,
self.getName("fk0_npo"),
transform.getTransform(self.bk_ctl[-1]))
# Forward Controlers ------------------------------
self.fk_ctl = []
self.fk_loc = []
parent = self.fk_npo
self.previousTag = self.tip_ctl
for i, bk_ctl in enumerate(reversed(self.bk_ctl[1:])):
t = transform.getTransform(bk_ctl)
dist = vector.getDistance(self.guide.apos[i + 1],
self.guide.apos[i + 2])
fk_loc = primitive.addTransform(
parent, self.getName("fk%s_loc" % i), t)
po_vec = datatypes.Vector(dist * .5 * self.n_factor, 0, 0)
fk_ctl = self.addCtl(fk_loc,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=dist,
h=self.size * .5,
d=self.size * .5,
po=po_vec,
tp=self.previousTag)
self.previousTag = fk_ctl
attribute.setKeyableAttributes(fk_ctl)
self.jnt_pos.append([fk_ctl, i])
parent = fk_ctl
self.fk_ctl.append(fk_ctl)
self.fk_loc.append(fk_loc)
def addObjects(self):
"""Add all the objects needed to create the component."""
ctlSize = vector.getDistance(self.guide.apos[0],
self.guide.apos[1]) / 3.0
t_root = self.guide.tra["root"]
t_root = transform.setMatrixScale(t_root)
self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"),
t_root)
t = transform.setMatrixPosition(t_root, self.guide.pos["top"])
self.top_npo = primitive.addTransform(self.ik_cns,
self.getName("top_npo"), t)
self.top_ctl = self.addCtl(self.top_npo,
"top_ctl",
t,
self.color_ik,
"arrow",
w=ctlSize,
ro=datatypes.Vector(1.5708, 1.5708, 0),
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.top_ctl, ["ty"])
t = transform.setMatrixPosition(t_root, self.guide.pos["bottom"])
self.bottom_npo = primitive.addTransform(self.top_npo,
self.getName("bottom_npo"), t)
self.bottom_npo.rz.set(180)
self.bottom_ctl = self.addCtl(self.bottom_npo,
"bottom_ctl",
t,
self.color_ik,
"arrow",
w=ctlSize,
ro=datatypes.Vector(1.5708, 1.5708, 0),
tp=self.parentCtlTag)
self.bottom_ctl.rz.set(0)
attribute.setKeyableAttributes(self.bottom_ctl, ["ty"])
self.bottom_pivot = primitive.addTransform(
self.bottom_npo, self.getName("bottom_pivot"),
transform.getTransform(self.top_ctl))
t = transform.setMatrixPosition(t_root, self.guide.pos["ext"])
self.ext_npo = primitive.addTransform(self.bottom_pivot,
self.getName("ext_npo"), t)
self.ext_npo.rz.set(-90)
self.ext_ctl = self.addCtl(self.ext_npo,
"ext_ctl",
t,
self.color_ik,
"arrow",
w=ctlSize,
ro=datatypes.Vector(1.5708, 1.5708, 0),
tp=self.parentCtlTag)
self.ext_ctl.rz.set(0)
attribute.setKeyableAttributes(self.ext_ctl, ["ty"])
t = transform.setMatrixPosition(t_root, self.guide.pos["int"])
self.int_npo = primitive.addTransform(self.ext_npo,
self.getName("int_npo"), t)
self.int_npo.rz.set(180)
self.int_ctl = self.addCtl(self.int_npo,
"int_ctl",
t,
self.color_ik,
"arrow",
w=ctlSize,
ro=datatypes.Vector(1.5708, 1.5708, 0),
tp=self.parentCtlTag)
self.int_ctl.rz.set(0)
attribute.setKeyableAttributes(self.int_ctl, ["ty"])
self.int_pivot = primitive.addTransform(
self.int_npo, self.getName("int_pivot"),
transform.getTransform(self.ext_ctl))
self.anchor = primitive.addTransform(
self.int_pivot, self.getName("int_npo"),
transform.getTransform(self.ik_cns))
if self.settings["joint"]:
self.jnt_pos.append([self.anchor, 0, None, False])
def addObjects(self):
# Ik Controlers ------------------------------------
t = tra.getTransformLookingAt(self.guide.pos["tan1"], self.guide.pos["neck"], self.guide.blades["blade"].z, "yx", self.negate)
t = tra.setMatrixPosition(t, self.guide.pos["neck"])
self.ik_cns = pri.addTransform(self.root, self.getName("ik_cns"), t)
self.ik_ctl = self.addCtl(self.ik_cns, "ik_ctl", t, self.color_ik, "compas", w=self.size*.5)
att.setKeyableAttributes(self.ik_ctl)
att.setRotOrder(self.ik_ctl, "XZY")
# Tangents -----------------------------------------
t = tra.setMatrixPosition(t, self.guide.pos["tan1"])
self.tan1_loc = pri.addTransform(self.ik_ctl, self.getName("tan1_loc"), t)
t = tra.getTransformLookingAt(self.guide.pos["root"], self.guide.pos["tan0"], self.guide.blades["blade"].z, "yx", self.negate)
t = tra.setMatrixPosition(t, self.guide.pos["tan0"])
self.tan0_loc = pri.addTransform(self.root, self.getName("tan0_loc"), t)
# Curves -------------------------------------------
self.mst_crv = cur.addCnsCurve(self.root, self.getName("mst_crv"), [self.root, self.tan0_loc, self.tan1_loc, self.ik_ctl], 3)
self.slv_crv = cur.addCurve(self.root, self.getName("slv_crv"), [dt.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 = []
for i in range(self.settings["division"]):
# References
div_cns = pri.addTransform(parentdiv, self.getName("%s_cns"%i))
setAttr(div_cns+".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
scl_npo = pri.addTransform(parentctl, self.getName("%s_scl_npo"%i), tra.getTransform(parentctl))
# Controlers (First and last one are fake)
if i in [0, self.settings["division"] - 1]:
fk_ctl = pri.addTransform(scl_npo, self.getName("%s_loc"%i), tra.getTransform(parentctl))
fk_npo = fk_ctl
else:
fk_npo = pri.addTransform(scl_npo, self.getName("fk%s_npo"%(i-1)), tra.getTransform(parentctl))
fk_ctl = self.addCtl(fk_npo, "fk%s_ctl"%(i-1), tra.getTransform(parentctl), self.color_fk, "cube", w=self.size*.2, h=self.size*.05, d=self.size*.2)
att.setKeyableAttributes(self.fk_ctl)
att.setRotOrder(fk_ctl, "XZY")
# setAttr(fk_npo+".inheritsTransform", False)
self.scl_npo.append(scl_npo)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
parentctl = fk_ctl
# Deformers (Shadow)
self.addShadow(fk_ctl, i)
# Head ---------------------------------------------
t = tra.getTransformLookingAt(self.guide.pos["head"], self.guide.pos["eff"], self.guide.blades["blade"].z, "yx", self.negate)
self.head_cns = pri.addTransform(self.root, self.getName("head_cns"), t)
dist = vec.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*.5, h=dist, d=self.size*.5, po=dt.Vector(0,dist*.5,0))
att.setRotOrder(self.head_ctl, "XZY")
self.addShadow(self.head_ctl, "head")
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)
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 ---------------------------------
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.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"])
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)
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.upv_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)
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))
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 ----------------------------------------
# We have at least one division at the start, the end and one for the
# elbow. + 2 for elbow angle control
self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + 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 * .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 = 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]))
if self.settings["ikTR"]:
reference = self.ikRot_ctl
self.match_ikRot = primitive.addTransform(
self.fk2_ctl,
self.getName("ikRot_mth"),
transform.getTransform(self.ikRot_ctl))
else:
reference = self.ik_ctl
self.match_fk2 = primitive.addTransform(
reference,
self.getName("fk2_mth"),
transform.getTransform(self.fk_ctl[2]))
self.match_ik = primitive.addTransform(
self.fk2_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))
def addObjects(self):
self.div_count = len(self.guide.apos) - 5
plane = [self.guide.apos[0], self.guide.apos[-4], self.guide.apos[-3]]
self.normal = self.getNormalFromPos(plane)
self.binormal = self.getBiNormalFromPos(plane)
# Heel ---------------------------------------------
# bank pivot
t = tra.getTransformLookingAt(self.guide.pos["heel"], self.guide.apos[-4], self.normal, "xz", self.negate)
t = tra.setMatrixPosition(t, self.guide.pos["inpivot"])
self.in_piv = pri.addTransform(self.root, self.getName("in_piv"), t)
t = tra.setMatrixPosition(t, self.guide.pos["outpivot"])
self.out_piv = pri.addTransform(self.in_piv, self.getName("out_piv"), t)
# heel
t = tra.getTransformLookingAt(self.guide.pos["heel"], self.guide.apos[-4], self.normal, "xz", self.negate)
self.heel_loc = pri.addTransform(self.out_piv, self.getName("heel_loc"), t)
att.setRotOrder(self.heel_loc, "YZX")
self.heel_ctl = self.addCtl(self.heel_loc, "heel_ctl", t, self.color_ik, "sphere", w=self.size*.1)
att.setKeyableAttributes(self.heel_ctl, self.r_params)
# Tip ----------------------------------------------
v = dt.Vector(self.guide.apos[-5].x,self.guide.apos[-1].y,self.guide.apos[-5].z)
t = tra.setMatrixPosition(t, v)
self.tip_ctl = self.addCtl(self.heel_ctl, "tip_ctl", t, self.color_ik, "circle", w=self.size)
att.setKeyableAttributes(self.tip_ctl, self.r_params)
# Roll ---------------------------------------------
if self.settings["roll"] == 0:
t = tra.getRotationFromAxis(self.y_axis, self.normal, "yz", self.negate)
t = tra.setMatrixPosition(t, self.guide.pos["root"])
self.roll_np = pri.addTransform(self.root, self.getName("roll_np"), t)
self.roll_ctl = self.addCtl(self.roll_np, "roll_ctl", t, self.color_ik, "cylinder", w=self.size*.5, h=self.size*.5, ro=dt.Vector(3.1415*.5,0,0))
att.setKeyableAttributes(self.roll_ctl, ["rx", "rz"])
# Backward Controlers ------------------------------
bk_pos = self.guide.apos[1:-3]
bk_pos.reverse()
parent = self.tip_ctl
self.bk_ctl = []
self.bk_loc = []
for i, pos in enumerate(bk_pos):
if i == 0:
t = tra.getTransform(self.heel_ctl)
t = tra.setMatrixPosition(t, pos)
else:
dir = bk_pos[i-1]
t = tra.getTransformLookingAt(pos, dir, self.normal, "xz", self.negate)
bk_loc = pri.addTransform(parent, self.getName("bk%s_loc"%i), t)
bk_ctl = self.addCtl(bk_loc, "bk%s_ctl"%i, t, self.color_ik, "sphere", w=self.size*.15)
att.setKeyableAttributes(bk_ctl, self.r_params)
self.bk_loc.append(bk_loc)
self.bk_ctl.append(bk_ctl)
parent = bk_ctl
# FK Reference ------------------------------------
self.fk_ref = pri.addTransformFromPos(self.bk_ctl[-1], self.getName("fk_ref"), self.guide.apos[0])
self.fk_npo = pri.addTransform(self.fk_ref, self.getName("fk0_npo"), tra.getTransform(self.bk_ctl[-1]))
# Forward Controlers ------------------------------
self.fk_ctl = []
self.fk_loc = []
parent = self.fk_npo
for i, bk_ctl in enumerate(reversed(self.bk_ctl[1:])):
t = tra.getTransform(bk_ctl)
dist = vec.getDistance(self.guide.apos[i+1], self.guide.apos[i+2])
# fk_npo = pri.addTransform(parent, self.getName("fk%s_npo"%i), t)
fk_loc = pri.addTransform(parent, self.getName("fk%s_loc"%i), t)
fk_ctl = self.addCtl(fk_loc, "fk%s_ctl"%i, t, self.color_fk, "cube", w=dist, h=self.size*.5, d=self.size*.5, po=dt.Vector(dist*.5*self.n_factor,0,0))
att.setKeyableAttributes(fk_ctl)
self.addShadow(fk_ctl, i)
parent = fk_ctl
self.fk_ctl.append(fk_ctl)
self.fk_loc.append(fk_loc)
def addObjects(self):
"""
"""
self.WIP = self.options["mode"]
self.normal = self.getNormalFromPos(self.guide.apos)
self.binormal = self.getBiNormalFromPos(self.guide.apos)
self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2])
self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3])
# 1 bone chain for upv ref
self.armChainUpvRef = pri.add2DChain(
self.root, self.getName("armUpvRef%s_jnt"),
[self.guide.apos[0], self.guide.apos[2]], self.normal, False,
self.WIP)
self.armChainUpvRef[1].setAttr(
"jointOrientZ",
self.armChainUpvRef[1].getAttr("jointOrientZ") * -1)
# FK Controlers -----------------------------------
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1],
self.normal, "xz", self.negate)
self.fk0_npo = pri.addTransform(self.root, 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=dt.Vector(
.5 * self.length0 * self.n_factor, 0,
0))
att.setKeyableAttributes(self.fk0_ctl)
t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2],
self.normal, "xz", self.negate)
self.fk1_npo = pri.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=dt.Vector(
.5 * self.length1 * self.n_factor, 0,
0))
att.setKeyableAttributes(self.fk1_ctl)
t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3],
self.normal, "xz", self.negate)
self.fk2_npo = pri.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=dt.Vector(
.5 * self.length2 * self.n_factor, 0,
0))
att.setKeyableAttributes(self.fk2_ctl)
self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl]
for x in self.fk_ctl:
att.setInvertMirror(x, ["tx", "ty", "tz"])
# IK Controlers -----------------------------------
self.ik_cns = pri.addTransformFromPos(self.root,
self.getName("ik_cns"),
self.guide.pos["wrist"])
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
tra.getTransformFromPos(
self.guide.pos["wrist"]),
self.color_ik,
"null",
w=self.size * .12)
att.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"])
if self.negate:
m = tra.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"], self.normal,
"x-y", True)
else:
m = tra.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)
att.setKeyableAttributes(self.ik_ctl)
att.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 = pri.addTransformFromPos(self.root,
self.getName("upv_cns"), v)
self.upv_ctl = self.addCtl(self.upv_cns,
"upv_ctl",
tra.getTransform(self.upv_cns),
self.color_ik,
"diamond",
w=self.size * .12)
att.setKeyableAttributes(self.upv_ctl, self.t_params)
att.setInvertMirror(self.upv_ctl, ["tx"])
#IK rotation controls
if self.settings["ikTR"]:
self.ikRot_npo = pri.addTransform(self.root,
self.getName("ikRot_npo"), m)
self.ikRot_cns = pri.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)
att.setKeyableAttributes(self.ikRot_ctl, ["rx", "ry", "rz"])
# References --------------------------------------
# Calculate again the transfor for the IK ref. This way align with FK
trnIK_ref = tra.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal, "xz", self.negate)
self.ik_ref = pri.addTransform(self.ik_ctl, self.getName("ik_ref"),
trnIK_ref)
self.fk_ref = pri.addTransform(self.fk_ctl[2], self.getName("fk_ref"),
trnIK_ref)
# Chain --------------------------------------------
# The outputs of the ikfk2bone solver
self.bone0 = pri.addLocator(self.root, self.getName("0_bone"),
tra.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 = pri.addLocator(self.root, self.getName("1_bone"),
tra.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 = pri.addTransformFromPos(self.root,
self.getName("ctrn_loc"),
self.guide.apos[1])
self.eff_loc = pri.addTransformFromPos(self.root,
self.getName("eff_loc"),
self.guide.apos[2])
# Mid Controler ------------------------------------
self.mid_ctl = self.addCtl(self.ctrn_loc,
"mid_ctl",
tra.getTransform(self.ctrn_loc),
self.color_ik,
"sphere",
w=self.size * .2)
att.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"])
#Roll join ref
self.rollRef = pri.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 = pri.addTransform(self.rollRef[0],
self.getName("tws0_loc"),
tra.getTransform(self.fk_ctl[0]))
self.tws0_rot = pri.addTransform(self.tws0_loc,
self.getName("tws0_rot"),
tra.getTransform(self.fk_ctl[0]))
self.tws1_npo = pri.addTransform(self.ctrn_loc,
self.getName("tws1_npo"),
tra.getTransform(self.ctrn_loc))
self.tws1_loc = pri.addTransform(self.tws1_npo,
self.getName("tws1_loc"),
tra.getTransform(self.ctrn_loc))
self.tws1_rot = pri.addTransform(self.tws1_loc,
self.getName("tws1_rot"),
tra.getTransform(self.ctrn_loc))
self.tws2_npo = pri.addTransform(self.root, self.getName("tws2_npo"),
tra.getTransform(self.fk_ctl[2]))
self.tws2_loc = pri.addTransform(self.tws2_npo,
self.getName("tws2_loc"),
tra.getTransform(self.fk_ctl[2]))
self.tws2_rot = pri.addTransform(self.tws2_loc,
self.getName("tws2_rot"),
tra.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
self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + 2
self.div_cns = []
for i in range(self.divisions):
div_cns = pri.addTransform(self.root,
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 wrist
self.jnt_pos.append([self.eff_loc, 'end'])
#match IK FK references
self.match_fk0_off = pri.addTransform(self.root,
self.getName("matchFk0_npo"),
tra.getTransform(self.fk_ctl[1]))
# self.match_fk0_off.attr("tx").set(1.0)
self.match_fk0 = pri.addTransform(self.match_fk0_off,
self.getName("fk0_mth"),
tra.getTransform(self.fk_ctl[0]))
self.match_fk1_off = pri.addTransform(self.root,
self.getName("matchFk1_npo"),
tra.getTransform(self.fk_ctl[2]))
# self.match_fk1_off.attr("tx").set(1.0)
self.match_fk1 = pri.addTransform(self.match_fk1_off,
self.getName("fk1_mth"),
tra.getTransform(self.fk_ctl[1]))
self.match_fk2 = pri.addTransform(self.ik_ctl, self.getName("fk2_mth"),
tra.getTransform(self.fk_ctl[2]))
self.match_ik = pri.addTransform(self.fk2_ctl, self.getName("ik_mth"),
tra.getTransform(self.ik_ctl))
self.match_ikUpv = pri.addTransform(self.fk0_ctl,
self.getName("upv_mth"),
tra.getTransform(self.upv_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 = 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 = primitive.addTransform(
self.ik_ctl, self.getName("fk2_mth"),
transform.getTransform(self.fk_ctl[2]))
self.match_ik = primitive.addTransform(
self.fk2_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.mid_ctl])
def lipsRig(eLoop,
upVertex,
lowVertex,
namePrefix,
thickness,
doSkin,
rigidLoops,
falloffLoops,
headJnt=None,
jawJnt=None,
parent=None,
ctlName="ctl"):
######
# Var
######
FRONT_OFFSET = .02
NB_ROPE = 15
##################
# Helper functions
##################
def setName(name, side="C", idx=None):
namesList = [namePrefix, side, name]
if idx is not None:
namesList[1] = side + str(idx)
name = "_".join(namesList)
return name
###############
# Checkers
##############
# Loop
if eLoop:
try:
eLoop = [pm.PyNode(e) for e in eLoop.split(",")]
except pm.MayaNodeError:
pm.displayWarning(
"Some of the edges listed in edge loop can not be found")
return
else:
pm.displayWarning("Please set the edge loop first")
return
# Vertex
if upVertex:
try:
upVertex = pm.PyNode(upVertex)
except pm.MayaNodeError:
pm.displayWarning("%s can not be found" % upVertex)
return
else:
pm.displayWarning("Please set the upper lip central vertex")
return
if lowVertex:
try:
lowVertex = pm.PyNode(lowVertex)
except pm.MayaNodeError:
pm.displayWarning("%s can not be found" % lowVertex)
return
else:
pm.displayWarning("Please set the lower lip central vertex")
return
# skinnign data
if doSkin:
if not headJnt:
pm.displayWarning("Please set the Head Jnt or unCheck Compute "
"Topological Autoskin")
return
else:
try:
headJnt = pm.PyNode(headJnt)
except pm.MayaNodeError:
pm.displayWarning("Head Joint: %s can not be found" % headJnt)
return
if not jawJnt:
pm.displayWarning("Please set the Jaw Jnt or unCheck Compute "
"Topological Autoskin")
return
else:
try:
jawJnt = pm.PyNode(jawJnt)
except pm.MayaNodeError:
pm.displayWarning("Jaw Joint: %s can not be found" % jawJnt)
return
# check if the rig already exist in the current scene
if pm.ls(setName("root")):
pm.displayWarning("The object %s already exist in the scene. Please "
"choose another name prefix" % setName("root"))
return
#####################
# Root creation
#####################
lips_root = primitive.addTransform(None, setName("root"))
lipsCrv_root = primitive.addTransform(lips_root, setName("crvs"))
lipsRope_root = primitive.addTransform(lips_root, setName("rope"))
#####################
# Geometry
#####################
geo = pm.listRelatives(eLoop[0], parent=True)[0]
#####################
# Groups
#####################
try:
ctlSet = pm.PyNode("rig_controllers_grp")
except pm.MayaNodeError:
pm.sets(n="rig_controllers_grp", em=True)
ctlSet = pm.PyNode("rig_controllers_grp")
try:
defset = pm.PyNode("rig_deformers_grp")
except pm.MayaNodeError:
pm.sets(n="rig_deformers_grp", em=True)
defset = pm.PyNode("rig_deformers_grp")
#####################
# Curves creation
#####################
# get extreme position using the outer loop
extr_v = meshNavigation.getExtremeVertexFromLoop(eLoop)
upPos = extr_v[0]
lowPos = extr_v[1]
inPos = extr_v[2]
outPos = extr_v[3]
edgeList = extr_v[4]
vertexList = extr_v[5]
upPos = upVertex
lowPos = lowVertex
# upper crv
upLip_edgeRange = meshNavigation.edgeRangeInLoopFromMid(
edgeList, upPos, inPos, outPos)
upCrv = curve.createCuveFromEdges(upLip_edgeRange,
setName("upperLip"),
parent=lipsCrv_root)
# store the closest vertex by curv cv index. To be use fo the auto skining
upLip_closestVtxList = []
# offset upper lip Curve
cvs = upCrv.getCVs(space="world")
for i, cv in enumerate(cvs):
closestVtx = meshNavigation.getClosestVertexFromTransform(geo, cv)
upLip_closestVtxList.append(closestVtx)
if i == 0:
# we know the curv starts from right to left
offset = [cv[0] - thickness, cv[1], cv[2] - thickness]
elif i == len(cvs) - 1:
offset = [cv[0] + thickness, cv[1], cv[2] - thickness]
else:
offset = [cv[0], cv[1] + thickness, cv[2]]
upCrv.setCV(i, offset, space='world')
# lower crv
lowLip_edgeRange = meshNavigation.edgeRangeInLoopFromMid(
edgeList, lowPos, inPos, outPos)
lowCrv = curve.createCuveFromEdges(lowLip_edgeRange,
setName("lowerLip"),
parent=lipsCrv_root)
lowLip_closestVtxList = []
# offset lower lip Curve
cvs = lowCrv.getCVs(space="world")
for i, cv in enumerate(cvs):
closestVtx = meshNavigation.getClosestVertexFromTransform(geo, cv)
lowLip_closestVtxList.append(closestVtx)
if i == 0:
# we know the curv starts from right to left
offset = [cv[0] - thickness, cv[1], cv[2] - thickness]
elif i == len(cvs) - 1:
offset = [cv[0] + thickness, cv[1], cv[2] - thickness]
else:
# we populate the closest vertext list here to skipt the first
# and latest point
offset = [cv[0], cv[1] - thickness, cv[2]]
lowCrv.setCV(i, offset, space='world')
upCrv_ctl = curve.createCurveFromCurve(upCrv,
setName("upCrv_%s" % ctlName),
nbPoints=7,
parent=lipsCrv_root)
lowCrv_ctl = curve.createCurveFromCurve(lowCrv,
setName("lowCrv_%s" % ctlName),
nbPoints=7,
parent=lipsCrv_root)
upRope = curve.createCurveFromCurve(upCrv,
setName("upRope_crv"),
nbPoints=NB_ROPE,
parent=lipsCrv_root)
lowRope = curve.createCurveFromCurve(lowCrv,
setName("lowRope_crv"),
nbPoints=NB_ROPE,
parent=lipsCrv_root)
upCrv_upv = curve.createCurveFromCurve(upCrv,
setName("upCrv_upv"),
nbPoints=7,
parent=lipsCrv_root)
lowCrv_upv = curve.createCurveFromCurve(lowCrv,
setName("lowCrv_upv"),
nbPoints=7,
parent=lipsCrv_root)
upRope_upv = curve.createCurveFromCurve(upCrv,
setName("upRope_upv"),
nbPoints=NB_ROPE,
parent=lipsCrv_root)
lowRope_upv = curve.createCurveFromCurve(lowCrv,
setName("lowRope_upv"),
nbPoints=NB_ROPE,
parent=lipsCrv_root)
# offset upv curves
for crv in [upCrv_upv, lowCrv_upv, upRope_upv, lowRope_upv]:
cvs = crv.getCVs(space="world")
for i, cv in enumerate(cvs):
# we populate the closest vertext list here to skipt the first
# and latest point
offset = [cv[0], cv[1], cv[2] + FRONT_OFFSET]
crv.setCV(i, offset, space='world')
rigCrvs = [
upCrv, lowCrv, upCrv_ctl, lowCrv_ctl, upRope, lowRope, upCrv_upv,
lowCrv_upv, upRope_upv, lowRope_upv
]
for crv in rigCrvs:
crv.attr("visibility").set(False)
##################
# Controls
##################
# Controls lists
upControls = []
upVec = []
upNpo = []
lowControls = []
lowVec = []
lowNpo = []
# controls options
axis_list = ["sx", "sy", "sz", "ro", "rx", "ry", "rz"]
upCtlOptions = [["corner", "R", "square", 4, .05, axis_list],
["upOuter", "R", "circle", 14, .03, []],
["upInner", "R", "circle", 14, .03, []],
["upper", "C", "square", 4, .05, axis_list],
["upInner", "L", "circle", 14, .03, []],
["upOuter", "L", "circle", 14, .03, []],
["corner", "L", "square", 4, .05, axis_list]]
lowCtlOptions = [["lowOuter", "R", "circle", 14, .03, []],
["lowInner", "R", "circle", 14, .03, []],
["lower", "C", "square", 4, .05, axis_list],
["lowInner", "L", "circle", 14, .03, []],
["lowOuter", "L", "circle", 14, .03, []]]
params = ["tx", "ty", "tz"]
# upper controls
cvs = upCrv_ctl.getCVs(space="world")
pm.progressWindow(title='Upper controls', progress=0, max=len(cvs))
v0 = transform.getTransformFromPos(cvs[0])
v1 = transform.getTransformFromPos(cvs[-1])
distSize = vector.getDistance(v0, v1) * 3
# print distSize
for i, cv in enumerate(cvs):
pm.progressWindow(e=True,
step=1,
status='\nCreating control for%s' % cv)
t = transform.getTransformFromPos(cv)
oName = upCtlOptions[i][0]
oSide = upCtlOptions[i][1]
o_icon = upCtlOptions[i][2]
color = upCtlOptions[i][3]
wd = upCtlOptions[i][4]
oPar = upCtlOptions[i][5]
npo = primitive.addTransform(lips_root,
setName("%s_npo" % oName, oSide), t)
upNpo.append(npo)
ctl = icon.create(npo,
setName("%s_%s" % (oName, ctlName), oSide),
t,
icon=o_icon,
w=wd * distSize,
d=wd * distSize,
ro=datatypes.Vector(1.57079633, 0, 0),
po=datatypes.Vector(0, 0, .07 * distSize),
color=color)
upControls.append(ctl)
if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost":
pass
else:
pm.sets(ctlSet, add=ctl)
attribute.setKeyableAttributes(ctl, params + oPar)
upv = primitive.addTransform(ctl, setName("%s_upv" % oName, oSide), t)
upv.attr("tz").set(FRONT_OFFSET)
upVec.append(upv)
if oSide == "R":
npo.attr("sx").set(-1)
pm.progressWindow(e=True, endProgress=True)
# lower controls
cvs = lowCrv_ctl.getCVs(space="world")
pm.progressWindow(title='Lower controls', progress=0, max=len(cvs))
for i, cv in enumerate(cvs[1:-1]):
pm.progressWindow(e=True,
step=1,
status='\nCreating control for%s' % cv)
t = transform.getTransformFromPos(cv)
oName = lowCtlOptions[i][0]
oSide = lowCtlOptions[i][1]
o_icon = lowCtlOptions[i][2]
color = lowCtlOptions[i][3]
wd = lowCtlOptions[i][4]
oPar = lowCtlOptions[i][5]
npo = primitive.addTransform(lips_root,
setName("%s_npo" % oName, oSide), t)
lowNpo.append(npo)
ctl = icon.create(npo,
setName("%s_%s" % (oName, ctlName), oSide),
t,
icon=o_icon,
w=wd * distSize,
d=wd * distSize,
ro=datatypes.Vector(1.57079633, 0, 0),
po=datatypes.Vector(0, 0, .07 * distSize),
color=color)
lowControls.append(ctl)
if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost":
pass
else:
pm.sets(ctlSet, add=ctl)
attribute.setKeyableAttributes(ctl, params + oPar)
upv = primitive.addTransform(ctl, setName("%s_upv" % oName, oSide), t)
upv.attr("tz").set(FRONT_OFFSET)
lowVec.append(upv)
if oSide == "R":
npo.attr("sx").set(-1)
pm.progressWindow(e=True, endProgress=True)
# reparentig controls
pm.parent(upNpo[1], lowNpo[0], upControls[0])
pm.parent(upNpo[2], upNpo[4], upControls[3])
pm.parent(upNpo[-2], lowNpo[-1], upControls[-1])
pm.parent(lowNpo[1], lowNpo[3], lowControls[2])
# Connecting control crvs with controls
applyop.gear_curvecns_op(upCrv_ctl, upControls)
applyop.gear_curvecns_op(lowCrv_ctl,
[upControls[0]] + lowControls + [upControls[-1]])
applyop.gear_curvecns_op(upCrv_upv, upVec)
applyop.gear_curvecns_op(lowCrv_upv, [upVec[0]] + lowVec + [upVec[-1]])
# adding wires
pm.wire(upCrv, w=upCrv_ctl)
pm.wire(lowCrv, w=lowCrv_ctl)
pm.wire(upRope, w=upCrv_ctl)
pm.wire(lowRope, w=lowCrv_ctl)
pm.wire(upRope_upv, w=upCrv_upv)
pm.wire(lowRope_upv, w=lowCrv_upv)
# setting constrains
# up
cns_node = pm.parentConstraint(upControls[0],
upControls[3],
upControls[1].getParent(),
mo=True,
skipRotate=["x", "y", "z"])
cns_node.attr(upControls[0].name() + "W0").set(.75)
cns_node.attr(upControls[3].name() + "W1").set(.25)
cns_node = pm.parentConstraint(upControls[0],
upControls[3],
upControls[2].getParent(),
mo=True,
skipRotate=["x", "y", "z"])
cns_node.attr(upControls[0].name() + "W0").set(.25)
cns_node.attr(upControls[3].name() + "W1").set(.75)
cns_node = pm.parentConstraint(upControls[3],
upControls[6],
upControls[4].getParent(),
mo=True,
skipRotate=["x", "y", "z"])
cns_node.attr(upControls[3].name() + "W0").set(.75)
cns_node.attr(upControls[6].name() + "W1").set(.25)
cns_node = pm.parentConstraint(upControls[3],
upControls[6],
upControls[5].getParent(),
mo=True,
skipRotate=["x", "y", "z"])
cns_node.attr(upControls[3].name() + "W0").set(.25)
cns_node.attr(upControls[6].name() + "W1").set(.75)
# low
cns_node = pm.parentConstraint(upControls[0],
lowControls[2],
lowControls[0].getParent(),
mo=True,
skipRotate=["x", "y", "z"])
cns_node.attr(upControls[0].name() + "W0").set(.75)
cns_node.attr(lowControls[2].name() + "W1").set(.25)
cns_node = pm.parentConstraint(upControls[0],
lowControls[2],
lowControls[1].getParent(),
mo=True,
skipRotate=["x", "y", "z"])
cns_node.attr(upControls[0].name() + "W0").set(.25)
cns_node.attr(lowControls[2].name() + "W1").set(.75)
cns_node = pm.parentConstraint(lowControls[2],
upControls[6],
lowControls[3].getParent(),
mo=True,
skipRotate=["x", "y", "z"])
cns_node.attr(lowControls[2].name() + "W0").set(.75)
cns_node.attr(upControls[6].name() + "W1").set(.25)
cns_node = pm.parentConstraint(lowControls[2],
upControls[6],
lowControls[4].getParent(),
mo=True,
skipRotate=["x", "y", "z"])
cns_node.attr(lowControls[2].name() + "W0").set(.25)
cns_node.attr(upControls[6].name() + "W1").set(.75)
##################
# Joints
##################
lvlType = "transform"
# upper joints
upperJoints = []
cvs = upCrv.getCVs(space="world")
pm.progressWindow(title='Creating Upper Joints', progress=0, max=len(cvs))
for i, cv in enumerate(cvs):
pm.progressWindow(e=True,
step=1,
status='\nCreating Joint for %s' % cv)
oTransUpV = pm.PyNode(
pm.createNode(lvlType,
n=setName("upLipRopeUpv", idx=str(i).zfill(3)),
p=lipsRope_root,
ss=True))
oTrans = pm.PyNode(
pm.createNode(lvlType,
n=setName("upLipRope", idx=str(i).zfill(3)),
p=lipsRope_root,
ss=True))
oParam, oLength = curve.getCurveParamAtPosition(upRope, cv)
uLength = curve.findLenghtFromParam(upRope, oParam)
u = uLength / oLength
applyop.pathCns(oTransUpV,
upRope_upv,
cnsType=False,
u=u,
tangent=False)
cns = applyop.pathCns(oTrans,
upRope,
cnsType=False,
u=u,
tangent=False)
cns.setAttr("worldUpType", 1)
cns.setAttr("frontAxis", 0)
cns.setAttr("upAxis", 1)
pm.connectAttr(oTransUpV.attr("worldMatrix[0]"),
cns.attr("worldUpMatrix"))
# getting joint parent
if headJnt and isinstance(headJnt, str):
try:
j_parent = pm.PyNode(headJnt)
except pm.MayaNodeError:
j_parent = False
elif headJnt and isinstance(headJnt, pm.PyNode):
j_parent = headJnt
else:
j_parent = False
jnt = rigbits.addJnt(oTrans, noReplace=True, parent=j_parent)
upperJoints.append(jnt)
pm.sets(defset, add=jnt)
pm.progressWindow(e=True, endProgress=True)
# lower joints
lowerJoints = []
cvs = lowCrv.getCVs(space="world")
pm.progressWindow(title='Creating Lower Joints', progress=0, max=len(cvs))
for i, cv in enumerate(cvs):
pm.progressWindow(e=True,
step=1,
status='\nCreating Joint for %s' % cv)
oTransUpV = pm.PyNode(
pm.createNode(lvlType,
n=setName("lowLipRopeUpv", idx=str(i).zfill(3)),
p=lipsRope_root,
ss=True))
oTrans = pm.PyNode(
pm.createNode(lvlType,
n=setName("lowLipRope", idx=str(i).zfill(3)),
p=lipsRope_root,
ss=True))
oParam, oLength = curve.getCurveParamAtPosition(lowRope, cv)
uLength = curve.findLenghtFromParam(lowRope, oParam)
u = uLength / oLength
applyop.pathCns(oTransUpV,
lowRope_upv,
cnsType=False,
u=u,
tangent=False)
cns = applyop.pathCns(oTrans,
lowRope,
cnsType=False,
u=u,
tangent=False)
cns.setAttr("worldUpType", 1)
cns.setAttr("frontAxis", 0)
cns.setAttr("upAxis", 1)
pm.connectAttr(oTransUpV.attr("worldMatrix[0]"),
cns.attr("worldUpMatrix"))
# getting joint parent
if jawJnt and isinstance(jawJnt, str):
try:
j_parent = pm.PyNode(jawJnt)
except pm.MayaNodeError:
pass
elif jawJnt and isinstance(jawJnt, pm.PyNode):
j_parent = jawJnt
else:
j_parent = False
jnt = rigbits.addJnt(oTrans, noReplace=True, parent=j_parent)
lowerJoints.append(jnt)
pm.sets(defset, add=jnt)
pm.progressWindow(e=True, endProgress=True)
###########################################
# Connecting rig
###########################################
if parent:
try:
if isinstance(parent, basestring):
parent = pm.PyNode(parent)
parent.addChild(lips_root)
except pm.MayaNodeError:
pm.displayWarning("The Lips rig can not be parent to: %s. Maybe "
"this object doesn't exist." % parent)
if headJnt and jawJnt:
try:
if isinstance(headJnt, basestring):
headJnt = pm.PyNode(headJnt)
except pm.MayaNodeError:
pm.displayWarning("Head Joint or Upper Lip Joint %s. Can not be "
"fount in the scene" % headJnt)
return
try:
if isinstance(jawJnt, basestring):
jawJnt = pm.PyNode(jawJnt)
except pm.MayaNodeError:
pm.displayWarning("Jaw Joint or Lower Lip Joint %s. Can not be "
"fount in the scene" % jawJnt)
return
# right corner connection
pm.parentConstraint(headJnt,
jawJnt,
upControls[0].getParent(),
mo=True)
# left corner connection
pm.parentConstraint(headJnt,
jawJnt,
upControls[-1].getParent(),
mo=True)
# up control connection
pm.parentConstraint(headJnt, upControls[3].getParent(), mo=True)
# low control connection
pm.parentConstraint(jawJnt, lowControls[2].getParent(), mo=True)
###########################################
# Auto Skinning
###########################################
if doSkin:
# eyelid vertex rows
totalLoops = rigidLoops + falloffLoops
vertexLoopList = meshNavigation.getConcentricVertexLoop(
vertexList, totalLoops)
vertexRowList = meshNavigation.getVertexRowsFromLoops(vertexLoopList)
# we set the first value 100% for the first initial loop
skinPercList = [1.0]
# we expect to have a regular grid topology
for r in range(rigidLoops):
for rr in range(2):
skinPercList.append(1.0)
increment = 1.0 / float(falloffLoops)
# we invert to smooth out from 100 to 0
inv = 1.0 - increment
for r in range(falloffLoops):
for rr in range(2):
if inv < 0.0:
inv = 0.0
skinPercList.append(inv)
inv -= increment
# this loop add an extra 0.0 indices to avoid errors
for r in range(10):
for rr in range(2):
skinPercList.append(0.0)
# base skin
if headJnt:
try:
headJnt = pm.PyNode(headJnt)
except pm.MayaNodeError:
pm.displayWarning("Auto skin aborted can not find %s " %
headJnt)
return
# Check if the object has a skinCluster
objName = pm.listRelatives(geo, parent=True)[0]
skinCluster = skin.getSkinCluster(objName)
if not skinCluster:
skinCluster = pm.skinCluster(headJnt,
geo,
tsb=True,
nw=2,
n='skinClsEyelid')
lipsJoints = upperJoints + lowerJoints
closestVtxList = upLip_closestVtxList + lowLip_closestVtxList
pm.progressWindow(title='Auto skinning process',
progress=0,
max=len(lipsJoints))
for i, jnt in enumerate(lipsJoints):
pm.progressWindow(e=True, step=1, status='\nSkinning %s' % jnt)
skinCluster.addInfluence(jnt, weight=0)
v = closestVtxList[i]
for row in vertexRowList:
if v in row:
for i, rv in enumerate(row):
# find the deformer with max value for each vertex
w = pm.skinPercent(skinCluster,
rv,
query=True,
value=True)
transJoint = pm.skinPercent(skinCluster,
rv,
query=True,
t=None)
max_value = max(w)
max_index = w.index(max_value)
perc = skinPercList[i]
t_value = [(jnt, perc),
(transJoint[max_index], 1.0 - perc)]
pm.skinPercent(skinCluster, rv, transformValue=t_value)
pm.progressWindow(e=True, endProgress=True)
def addObjects(self):
self.normal = self.getNormalFromPos(self.guide.apos)
self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2])
self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3])
# FK Controlers -----------------------------------
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1],
self.normal, "xz", self.negate)
### FK NEUTRAL POSE IS DIFFERENT
self.fk0_npo = pri.addTransform(self.root, 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=dt.Vector(
.5 * self.length0 * self.n_factor, 0,
0))
t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2],
self.normal, "xz", self.negate)
self.fk1_ctl = self.addCtl(self.fk0_ctl,
"fk1_ctl",
t,
self.color_fk,
"cube",
w=self.length1,
h=self.size * .1,
d=self.size * .1,
po=dt.Vector(
.5 * self.length1 * self.n_factor, 0,
0))
t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3],
self.normal, "xz", self.negate)
self.fk2_ctl = self.addCtl(self.fk1_ctl,
"fk2_ctl",
t,
self.color_fk,
"cube",
w=self.length2,
h=self.size * .1,
d=self.size * .1,
po=dt.Vector(
.5 * self.length2 * self.n_factor, 0,
0))
self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl]
# IK Controlers -----------------------------------
self.ik_cns = pri.addTransformFromPos(self.root,
self.getName("ik_cns"),
self.guide.pos["wrist"])
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
tra.getTransformFromPos(
self.guide.pos["wrist"]),
self.color_ik,
"null",
w=self.size * .12)
### IK CONTROLER POSE IS DIFFERENT
m = tra.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"], self.normal, "xz",
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)
# 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 = pri.addTransformFromPos(self.root,
self.getName("upv_cns"), v)
self.upv_ctl = self.addCtl(self.upv_cns,
"upv_ctl",
tra.getTransform(self.upv_cns),
self.color_ik,
"diamond",
w=self.size * .12)
att.setKeyableAttributes(self.upv_ctl, self.t_params)
# References --------------------------------------
self.ik_ref = pri.addTransform(self.ik_ctl, self.getName("ik_ref"),
tra.getTransform(self.ik_ctl))
self.fk_ref = pri.addTransform(self.fk_ctl[2], self.getName("fk_ref"),
tra.getTransform(self.ik_ctl))
# Chain --------------------------------------------
# The outputs of the ikfk2bone solver
self.bone0 = pri.addLocator(self.root, self.getName("0_jnt"),
tra.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 = pri.addLocator(self.root, self.getName("1_jnt"),
tra.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 = pri.addTransformFromPos(self.root,
self.getName("ctrn_loc"),
self.guide.apos[1])
self.eff_loc = pri.addTransformFromPos(self.root,
self.getName("eff_loc"),
self.guide.apos[2])
# Mid Controler ------------------------------------
self.mid_ctl = self.addCtl(self.ctrn_loc,
"mid_ctl",
tra.getTransform(self.ctrn_loc),
self.color_ik,
"sphere",
w=self.size * .2)
# Twist references ---------------------------------
x = dt.Vector(0, -1, 0)
x = x * tra.getTransform(self.eff_loc)
z = dt.Vector(self.normal.x, self.normal.y, self.normal.z)
z = z * tra.getTransform(self.eff_loc)
m = tra.getRotationFromAxis(x, z, "xz", self.negate)
m = tra.setMatrixPosition(m, tra.getTranslation(self.ik_ctl))
self.tws0_loc = pri.addTransform(self.root, self.getName("tws0_loc"),
tra.getTransform(self.fk_ctl[0]))
self.tws0_rot = pri.addTransform(self.tws0_loc,
self.getName("tws0_rot"),
tra.getTransform(self.fk_ctl[0]))
self.tws1_loc = pri.addTransform(self.ctrn_loc,
self.getName("tws1_loc"),
tra.getTransform(self.ctrn_loc))
self.tws1_rot = pri.addTransform(self.tws1_loc,
self.getName("tws1_rot"),
tra.getTransform(self.ctrn_loc))
self.tws2_loc = pri.addTransform(self.root, self.getName("tws2_loc"),
tra.getTransform(self.fk_ctl[2]))
self.tws2_rot = pri.addTransform(self.tws2_loc,
self.getName("tws2_rot"),
tra.getTransform(self.fk_ctl[2]))
self.tws2_rot.setAttr("sx", .001)
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for the elbow.
self.divisions = self.settings["div0"] + self.settings["div1"] + 3
self.div_cns = []
for i in range(self.divisions):
div_cns = pri.addTransform(self.root,
self.getName("div%s_loc" % i))
self.div_cns.append(div_cns)
self.addShadow(div_cns, i)
# End reference ------------------------------------
# To help the deformation on the wrist
self.end_ref = pri.addTransform(self.tws2_rot, self.getName("end_ref"),
m)
self.addShadow(self.end_ref, "end")
def addObjects(self):
self.normal = self.getNormalFromPos(self.guide.apos)
self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2])
self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3])
# FK Controlers -----------------------------------
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate)
### FK NEUTRAL POSE IS DIFFERENT
self.fk0_npo = pri.addTransform(self.root, 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=dt.Vector(.5*self.length0*self.n_factor,0,0))
t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate)
self.fk1_ctl = self.addCtl(self.fk0_ctl, "fk1_ctl", t, self.color_fk, "cube", w=self.length1, h=self.size*.1, d=self.size*.1, po=dt.Vector(.5*self.length1*self.n_factor,0,0))
t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate)
self.fk2_ctl = self.addCtl(self.fk1_ctl, "fk2_ctl", t, self.color_fk, "cube", w=self.length2, h=self.size*.1, d=self.size*.1, po=dt.Vector(.5*self.length2*self.n_factor,0,0))
self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl]
# IK Controlers -----------------------------------
self.ik_cns = pri.addTransformFromPos(self.root, self.getName("ik_cns"), self.guide.pos["wrist"])
self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", tra.getTransformFromPos(self.guide.pos["wrist"]), self.color_ik, "null", w=self.size*.12)
### IK CONTROLER POSE IS DIFFERENT
m = tra.getTransformLookingAt(self.guide.pos["wrist"], self.guide.pos["eff"], self.normal, "xz", 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)
# 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 = pri.addTransformFromPos(self.root, self.getName("upv_cns"), v)
self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", tra.getTransform(self.upv_cns), self.color_ik, "diamond", w=self.size*.12)
att.setKeyableAttributes(self.upv_ctl, self.t_params)
# References --------------------------------------
self.ik_ref = pri.addTransform(self.ik_ctl, self.getName("ik_ref"), tra.getTransform(self.ik_ctl))
self.fk_ref = pri.addTransform(self.fk_ctl[2], self.getName("fk_ref"), tra.getTransform(self.ik_ctl))
# Chain --------------------------------------------
# The outputs of the ikfk2bone solver
self.bone0 = pri.addLocator(self.root, self.getName("0_jnt"), tra.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 = pri.addLocator(self.root, self.getName("1_jnt"), tra.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 = pri.addTransformFromPos(self.root, self.getName("ctrn_loc"), self.guide.apos[1])
self.eff_loc = pri.addTransformFromPos(self.root, self.getName("eff_loc"), self.guide.apos[2])
# Mid Controler ------------------------------------
self.mid_ctl = self.addCtl(self.ctrn_loc, "mid_ctl", tra.getTransform(self.ctrn_loc), self.color_ik, "sphere", w=self.size*.2)
# Twist references ---------------------------------
x = dt.Vector(0,-1,0)
x = x * tra.getTransform(self.eff_loc)
z = dt.Vector(self.normal.x,self.normal.y,self.normal.z)
z = z * tra.getTransform(self.eff_loc)
m = tra.getRotationFromAxis(x, z, "xz", self.negate)
m = tra.setMatrixPosition(m, tra.getTranslation(self.ik_ctl))
self.tws0_loc = pri.addTransform(self.root, self.getName("tws0_loc"), tra.getTransform(self.fk_ctl[0]))
self.tws0_rot = pri.addTransform(self.tws0_loc, self.getName("tws0_rot"), tra.getTransform(self.fk_ctl[0]))
self.tws1_loc = pri.addTransform(self.ctrn_loc, self.getName("tws1_loc"), tra.getTransform(self.ctrn_loc))
self.tws1_rot = pri.addTransform(self.tws1_loc, self.getName("tws1_rot"), tra.getTransform(self.ctrn_loc))
self.tws2_loc = pri.addTransform(self.root, self.getName("tws2_loc"), tra.getTransform(self.fk_ctl[2]))
self.tws2_rot = pri.addTransform(self.tws2_loc, self.getName("tws2_rot"), tra.getTransform(self.fk_ctl[2]))
self.tws2_rot.setAttr("sx", .001)
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for the elbow.
self.divisions = self.settings["div0"] + self.settings["div1"] + 3
self.div_cns = []
for i in range(self.divisions):
div_cns = pri.addTransform(self.root, self.getName("div%s_loc" % i))
self.div_cns.append(div_cns)
self.addShadow(div_cns, i)
# End reference ------------------------------------
# To help the deformation on the wrist
self.end_ref = pri.addTransform(self.tws2_rot, self.getName("end_ref"), m)
self.addShadow(self.end_ref, "end")
def addOperators(self):
"""Create operators and set the relations for the component rig
Apply operators, constraints, expressions to the hierarchy.
In order to keep the code clean and easier to debug,
we shouldn't create any new object in this method.
"""
# Tangent position ---------------------------------
# common part
d = vector.getDistance(self.guide.pos["root"], self.guide.pos["neck"])
dist_node = node.createDistNode(self.root, self.ik_ctl)
rootWorld_node = node.createDecomposeMatrixNode(
self.root.attr("worldMatrix"))
div_node = node.createDivNode(dist_node + ".distance",
rootWorld_node + ".outputScaleX")
div_node = node.createDivNode(div_node + ".outputX", d)
# tan0
mul_node = node.createMulNode(self.tan0_att,
self.tan0_loc.getAttr("ty"))
res_node = node.createMulNode(mul_node + ".outputX",
div_node + ".outputX")
pm.connectAttr(res_node + ".outputX", self.tan0_loc + ".ty")
# tan1
mul_node = node.createMulNode(self.tan1_att,
self.tan1_loc.getAttr("ty"))
res_node = node.createMulNode(mul_node + ".outputX",
div_node + ".outputX")
pm.connectAttr(res_node + ".outputX", self.tan1_loc.attr("ty"))
# Curves -------------------------------------------
op = applyop.gear_curveslide2_op(self.slv_crv, self.mst_crv, 0, 1.5,
.5, .5)
pm.connectAttr(self.maxstretch_att, op + ".maxstretch")
pm.connectAttr(self.maxsquash_att, op + ".maxsquash")
pm.connectAttr(self.softness_att, op + ".softness")
# Volume driver ------------------------------------
crv_node = node.createCurveInfoNode(self.slv_crv)
# Division -----------------------------------------
for i in range(self.settings["division"]):
# References
u = i / (self.settings["division"] - 1.0)
cns = applyop.pathCns(self.div_cns[i], self.slv_crv, False, u,
True)
cns.setAttr("frontAxis", 1) # front axis is 'Y'
cns.setAttr("upAxis", 2) # front axis is 'Z'
# Roll
intMatrix = applyop.gear_intmatrix_op(
self.intMRef + ".worldMatrix", self.ik_ctl + ".worldMatrix", u)
dm_node = node.createDecomposeMatrixNode(intMatrix + ".output")
pm.connectAttr(dm_node + ".outputRotate",
self.twister[i].attr("rotate"))
pm.parentConstraint(self.twister[i],
self.ref_twist[i],
maintainOffset=True)
pm.connectAttr(self.ref_twist[i] + ".translate",
cns + ".worldUpVector")
# Squash n Stretch
op = applyop.gear_squashstretch2_op(self.fk_npo[i], self.root,
pm.arclen(self.slv_crv), "y")
pm.connectAttr(self.volume_att, op + ".blend")
pm.connectAttr(crv_node + ".arcLength", op + ".driver")
pm.connectAttr(self.st_att[i], op + ".stretch")
pm.connectAttr(self.sq_att[i], op + ".squash")
op.setAttr("driver_min", .1)
# scl compas
if i != 0:
div_node = node.createDivNode([1, 1, 1], [
self.fk_npo[i - 1] + ".sx", self.fk_npo[i - 1] + ".sy",
self.fk_npo[i - 1] + ".sz"
])
pm.connectAttr(div_node + ".output",
self.scl_npo[i] + ".scale")
# Controlers
if i == 0:
mulmat_node = applyop.gear_mulmatrix_op(
self.div_cns[i].attr("worldMatrix"),
self.root.attr("worldInverseMatrix"))
else:
mulmat_node = applyop.gear_mulmatrix_op(
self.div_cns[i].attr("worldMatrix"),
self.div_cns[i - 1].attr("worldInverseMatrix"))
dm_node = node.createDecomposeMatrixNode(mulmat_node + ".output")
pm.connectAttr(dm_node + ".outputTranslate",
self.fk_npo[i].attr("t"))
pm.connectAttr(dm_node + ".outputRotate", self.fk_npo[i].attr("r"))
# Orientation Lock
if i == self.settings["division"] - 1:
dm_node = node.createDecomposeMatrixNode(self.ik_ctl +
".worldMatrix")
blend_node = node.createBlendNode(
[dm_node + ".outputRotate%s" % s for s in "XYZ"],
[cns + ".rotate%s" % s for s in "XYZ"], self.lock_ori_att)
self.div_cns[i].attr("rotate").disconnect()
pm.connectAttr(blend_node + ".output",
self.div_cns[i] + ".rotate")
# Head ---------------------------------------------
self.fk_ctl[-1].addChild(self.head_cns)
# scale compensation
dm_node = node.createDecomposeMatrixNode(self.scl_npo[0] +
".parentInverseMatrix")
pm.connectAttr(dm_node + ".outputScale", self.scl_npo[0] + ".scale")
def addOperators(self):
# Tangent position ---------------------------------
# common part
d = vec.getDistance(self.guide.pos["root"], self.guide.pos["neck"])
dist_node = nod.createDistNode(self.root, self.ik_ctl)
rootWorld_node = nod.createDecomposeMatrixNode(self.root.attr("worldMatrix"))
div_node = nod.createDivNode(dist_node+".distance", rootWorld_node+".outputScaleX")
div_node = nod.createDivNode(div_node+".outputX", d)
# tan0
mul_node = nod.createMulNode(self.tan0_att, self.tan0_loc.getAttr("ty"))
res_node = nod.createMulNode(mul_node+".outputX", div_node+".outputX")
connectAttr( res_node+".outputX", self.tan0_loc+".ty")
# tan1
mul_node = nod.createMulNode(self.tan1_att, self.tan1_loc.getAttr("ty"))
res_node = nod.createMulNode(mul_node+".outputX", div_node+".outputX")
connectAttr( res_node+".outputX", self.tan1_loc.attr("ty"))
# Curves -------------------------------------------
op = aop.gear_curveslide2_op(self.slv_crv, self.mst_crv, 0, 1.5, .5, .5)
connectAttr(self.maxstretch_att, op+".maxstretch")
connectAttr(self.maxsquash_att, op+".maxsquash")
connectAttr(self.softness_att, op+".softness")
# Volume driver ------------------------------------
crv_node = nod.createCurveInfoNode(self.slv_crv)
# Division -----------------------------------------
for i in range(self.settings["division"]):
# References
u = i / (self.settings["division"] - 1.0)
cns = aop.pathCns(self.div_cns[i], self.slv_crv, False, u, True)
cns.setAttr("frontAxis", 1)# front axis is 'Y'
cns.setAttr("upAxis", 2)# front axis is 'Z'
# Roll
aop.gear_spinePointAtOp(cns, self.root, self.ik_ctl, u, "Z")
# Squash n Stretch
op = aop.gear_squashstretch2_op(self.fk_npo[i], self.root, arclen(self.slv_crv), "y")
connectAttr(self.volume_att, op+".blend")
connectAttr(crv_node+".arcLength", op+".driver")
connectAttr(self.st_att[i], op+".stretch")
connectAttr(self.sq_att[i], op+".squash")
# scl compas
if i != 0:
div_node = nod.createDivNode([1,1,1], [self.fk_npo[i-1]+".sx", self.fk_npo[i-1]+".sy", self.fk_npo[i-1]+".sz"])
connectAttr(div_node+".output", self.scl_npo[i]+".scale")
# Controlers
if i == 0:
mulmat_node = aop.gear_mulmatrix_op(self.div_cns[i].attr("worldMatrix"), self.root.attr("worldInverseMatrix"))
else:
mulmat_node = aop.gear_mulmatrix_op(self.div_cns[i].attr("worldMatrix"), self.div_cns[i-1].attr("worldInverseMatrix"))
dm_node = nod.createDecomposeMatrixNode(mulmat_node+".output")
connectAttr(dm_node+".outputTranslate", self.fk_npo[i].attr("t"))
connectAttr(dm_node+".outputRotate", self.fk_npo[i].attr("r"))
#connectAttr(dm_node+".outputScale", self.fk_npo[i].attr("s"))
# Orientation Lock
if i == self.settings["division"] - 1 :
dm_node = nod.createDecomposeMatrixNode(self.ik_ctl+".worldMatrix")
blend_node = nod.createBlendNode([dm_node+".outputRotate%s"%s for s in "XYZ"], [cns+".rotate%s"%s for s in "XYZ"], self.lock_ori_att)
self.div_cns[i].attr("rotate").disconnect()
connectAttr(blend_node+".output", self.div_cns[i]+".rotate")
# Head ---------------------------------------------
self.fk_ctl[-1].addChild(self.head_cns)
