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):
"""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 addOperators(self):
# Tangent position ---------------------------------
# common part
d = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
dist_node = nod.createDistNode(self.ik0_ctl, self.ik1_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_npo.getAttr("ty"))
res_node = nod.createMulNode(mul_node+".outputX", div_node+".outputX")
pm.connectAttr( res_node+".outputX", self.tan0_npo.attr("ty"))
# tan1
mul_node = nod.createMulNode(self.tan1_att, self.tan1_npo.getAttr("ty"))
res_node = nod.createMulNode(mul_node+".outputX", div_node+".outputX")
pm.connectAttr( res_node+".outputX", self.tan1_npo.attr("ty"))
# Curves -------------------------------------------
op = aop.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 = 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", 0)# front axis is 'X'
# Roll
intMatrix = aop.gear_intmatrix_op(self.ik0_ctl+".worldMatrix", self.ik1_ctl+".worldMatrix", u)
dm_node = nod.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 = aop.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")
# scl compensation
if i == 0:
dm_node = nod.createDecomposeMatrixNode(self.root+".worldMatrix")
div_node = nod.createDivNode([1,1,1], [dm_node+".outputScaleX", dm_node+".outputScaleY", dm_node+".outputScaleZ"])
pm.connectAttr(div_node+".output", self.scl_npo[i]+".scale")
elif i == 1:
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"])
pm.connectAttr(div_node+".output", self.scl_npo[i]+".scale")
else:
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"])
pm.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.scl_npo[0].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")
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 == 0 :
dm_node = nod.createDecomposeMatrixNode(self.ik0_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_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 = nod.createDecomposeMatrixNode(self.ik1_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_ori1_att)
self.div_cns[i].attr("rotate").disconnect()
pm.connectAttr(blend_node+".output", self.div_cns[i]+".rotate")
# Connections (Hooks) ------------------------------
pm.pointConstraint(self.div_cns[0], self.cnx0)
pm.orientConstraint(self.div_cns[0], self.cnx0)
pm.pointConstraint(self.fk_ctl[-1], self.cnx1)
pm.orientConstraint(self.fk_ctl[-1], self.cnx1)
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)
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)