def addOperators(self):
# Chain of deformers -------------------------------
for i, loc in enumerate(self.loc):
pm.parentConstraint(self.fk_ctl[i], loc, maintainOffset=False)
# spring operators
#settings aim contraints
for i, tranCns in enumerate(self.spring_aim):
if self.negate:
aimAxis = "-xy"
else:
aimAxis = "xy"
aop.aimCns(tranCns, self.spring_target[i], aimAxis, 2, [0,1,0], self.fk_npo[i], False)
aop.oriCns(tranCns, self.spring_cns[i])
springOP = aop.gear_spring_op(self.spring_target[i])
pm.connectAttr(self.aSpring_intensity, springOP+".intensity")
pm.connectAttr(self.aDamping[i], springOP+".damping")
pm.connectAttr(self.aStiffness[i], springOP+".stiffness")
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.
"""
# Chain of deformers -------------------------------
for i, loc in enumerate(self.loc):
pm.parentConstraint(self.fk_ctl[i], loc, maintainOffset=False)
# spring operators
# settings aim contraints
for i, tranCns in enumerate(self.spring_aim):
if self.negate:
aimAxis = "-xy"
else:
aimAxis = "xy"
applyop.aimCns(tranCns, self.spring_target[i], aimAxis, 2,
[0, 1, 0], self.fk_npo[i], False)
ori_cns = applyop.oriCns(tranCns, self.spring_cns[i])
springOP = applyop.gear_spring_op(self.spring_target[i])
blend_node = pm.createNode("pairBlend")
pm.connectAttr(ori_cns.constraintRotate, blend_node.inRotate2)
pm.connectAttr(self.aSpring_intensity, blend_node.weight)
pm.disconnectAttr(ori_cns.constraintRotate,
self.spring_cns[i].rotate)
pm.connectAttr(blend_node.outRotateX, self.spring_cns[i].rotateX)
pm.connectAttr(blend_node.outRotateY, self.spring_cns[i].rotateY)
pm.connectAttr(blend_node.outRotateZ, self.spring_cns[i].rotateZ)
pm.connectAttr(self.aSpring_intensity, springOP + ".intensity")
pm.connectAttr(self.aDamping[i], springOP + ".damping")
pm.connectAttr(self.aStiffness[i], springOP + ".stiffness")
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.
"""
# 1 bone chain Upv ref ===========================
self.ikHandleUpvRef = primitive.addIkHandle(
self.root, self.getName("ikHandleLegChainUpvRef"),
self.legChainUpvRef, "ikSCsolver")
pm.pointConstraint(self.ik_ctl, self.ikHandleUpvRef)
pm.parentConstraint(self.legChainUpvRef[0],
self.ik_ctl,
self.upv_cns,
mo=True)
# Visibilities -------------------------------------
# shape.dispGeometry
# fk
fkvis_node = node.createReverseNode(self.blend_att)
for shp in self.fk0_ctl.getShapes():
pm.connectAttr(fkvis_node + ".outputX", shp.attr("visibility"))
for shp in self.fk1_ctl.getShapes():
pm.connectAttr(fkvis_node + ".outputX", shp.attr("visibility"))
for shp in self.fk2_ctl.getShapes():
pm.connectAttr(fkvis_node + ".outputX", shp.attr("visibility"))
# ik
for shp in self.upv_ctl.getShapes():
pm.connectAttr(self.blend_att, shp.attr("visibility"))
for shp in self.ikcns_ctl.getShapes():
pm.connectAttr(self.blend_att, shp.attr("visibility"))
for shp in self.ik_ctl.getShapes():
pm.connectAttr(self.blend_att, shp.attr("visibility"))
# IK Solver -----------------------------------------
out = [self.bone0, self.bone1, self.ctrn_loc, self.eff_loc]
o_node = applyop.gear_ikfk2bone_op(out, self.root_ctl, self.ik_ref,
self.upv_ctl, self.fk_ctl[0],
self.fk_ctl[1], self.fk_ref,
self.length0, self.length1,
self.negate)
pm.connectAttr(self.blend_att, o_node + ".blend")
if self.negate:
mulVal = -1
else:
mulVal = 1
node.createMulNode(self.roll_att, mulVal, o_node + ".roll")
pm.connectAttr(self.scale_att, o_node + ".scaleA")
pm.connectAttr(self.scale_att, o_node + ".scaleB")
pm.connectAttr(self.maxstretch_att, o_node + ".maxstretch")
pm.connectAttr(self.slide_att, o_node + ".slide")
pm.connectAttr(self.softness_att, o_node + ".softness")
pm.connectAttr(self.reverse_att, o_node + ".reverse")
# Twist references ---------------------------------
self.ikhArmRef, self.tmpCrv = applyop.splineIK(
self.getName("legRollRef"),
self.rollRef,
parent=self.root,
cParent=self.bone0)
pm.pointConstraint(self.mid_ctl, self.tws1_loc, maintainOffset=False)
pm.scaleConstraint(self.mid_ctl, self.tws1_loc, maintainOffset=False)
applyop.oriCns(self.mid_ctl, self.tws1_rot, maintainOffset=False)
pm.pointConstraint(self.eff_loc, self.tws2_loc, maintainOffset=False)
pm.scaleConstraint(self.eff_loc, self.tws2_loc, maintainOffset=False)
applyop.oriCns(self.bone1, self.tws2_loc, maintainOffset=False)
applyop.oriCns(self.tws_ref, self.tws2_rot)
self.tws0_loc.setAttr("sx", .001)
self.tws2_loc.setAttr("sx", .001)
add_node = node.createAddNode(self.roundness_att, .001)
pm.connectAttr(add_node + ".output", self.tws1_rot.attr("sx"))
# Volume -------------------------------------------
distA_node = node.createDistNode(self.tws0_loc, self.tws1_loc)
distB_node = node.createDistNode(self.tws1_loc, self.tws2_loc)
add_node = node.createAddNode(distA_node + ".distance",
distB_node + ".distance")
div_node = node.createDivNode(add_node + ".output",
self.root_ctl.attr("sx"))
# comp scaling issue
dm_node = pm.createNode("decomposeMatrix")
pm.connectAttr(self.root.attr("worldMatrix"), dm_node + ".inputMatrix")
div_node2 = node.createDivNode(div_node + ".outputX",
dm_node + ".outputScaleX")
self.volDriver_att = div_node2 + ".outputX"
# Divisions ----------------------------------------
# at 0 or 1 the division will follow exactly the rotation of the
# controler.. and we wont have this nice tangent + roll
for i, div_cns in enumerate(self.div_cns):
subdiv = False
if i == len(self.div_cns) - 1 or i == 0:
subdiv = 45
else:
subdiv = 10
if i < (self.settings["div0"] + 1):
perc = i * .5 / (self.settings["div0"] + 1.0)
elif i < (self.settings["div0"] + 2):
perc = .49
subdiv = 45
elif i < (self.settings["div0"] + 3):
perc = .50
subdiv = 45
elif i < (self.settings["div0"] + 4):
perc = .51
subdiv = 45
else:
perc = (.5 + (i - self.settings["div0"] - 3.0) * .5 /
(self.settings["div1"] + 1.0))
perc = max(.001, min(.999, perc))
# Roll
if self.negate:
o_node = applyop.gear_rollsplinekine_op(
div_cns, [self.tws2_rot, self.tws1_rot, self.tws0_rot],
1 - perc, subdiv)
else:
o_node = applyop.gear_rollsplinekine_op(
div_cns, [self.tws0_rot, self.tws1_rot, self.tws2_rot],
perc, subdiv)
pm.connectAttr(self.resample_att, o_node + ".resample")
pm.connectAttr(self.absolute_att, o_node + ".absolute")
# Squash n Stretch
o_node = applyop.gear_squashstretch2_op(
div_cns, None, pm.getAttr(self.volDriver_att), "x")
pm.connectAttr(self.volume_att, o_node + ".blend")
pm.connectAttr(self.volDriver_att, o_node + ".driver")
pm.connectAttr(self.st_att[i], o_node + ".stretch")
pm.connectAttr(self.sq_att[i], o_node + ".squash")
# NOTE: next line fix the issue on meters.
# This is special case becasuse the IK solver from mGear use
# the scale as lenght and we have shear
# TODO: check for a more clean and elegant solution instead of
# re-match the world matrix again
# transform.matchWorldTransform(self.fk_ctl[0], self.match_fk0_off)
# transform.matchWorldTransform(self.fk_ctl[1], self.match_fk1_off)
# transform.matchWorldTransform(self.fk_ctl[0], self.match_fk0)
# transform.matchWorldTransform(self.fk_ctl[1], self.match_fk1)
# match IK/FK ref
pm.parentConstraint(self.bone0, self.match_fk0_off, mo=True)
pm.parentConstraint(self.bone1, self.match_fk1_off, mo=True)
return
