def connect_leg_2jnt_01(self):
"""Connector for leg 2jnt"""
# If the parent component hasn't been generated we skip the connection
if self.parent_comp is None:
return
pm.connectAttr(self.parent_comp.blend_att, self.blend_att)
pm.parent(self.root, self.parent_comp.ik_ctl)
pm.parent(self.parent_comp.ik_ref, self.bk_loc[-1])
pm.parentConstraint(self.parent_comp.tws2_rot, self.fk_ref, maintainOffset=True)
pm.parent(self.parent_comp.match_fk2, self.fk_ref)
heel_t = transform.getTranslation(self.heel_ctl)
ik_t = transform.getTranslation(self.parent_comp.ik_ctl)
offset_y = heel_t.y - ik_t.y
ik_shapes = self.parent_comp.ik_ctl.getShapes()
for shape in ik_shapes:
points = []
for cv in shape.getCVs():
x = cv[0] * 2.
y = cv[1] * 0.4 + offset_y
z = cv[2] * 3.
points.append(datatypes.Point((x, y, z)))
shape.setCVs(points)
shape.updateCurve()
def gen2(crv, name, nbPoints, tobe_offset):
t = getTransform(self.root)
new_crv = curve.createCurveFromCurve(crv,
self.getName(name),
nbPoints=nbPoints,
parent=crv_root,
m=t)
new_crv.attr("visibility").set(False)
# double translation denial
cvs = new_crv.getCVs(space="world")
for i, cv in enumerate(cvs):
x, y, z = transform.getTranslation(new_crv)
offset = [cv[0] - x, cv[1] - y, cv[2] - z]
new_crv.setCV(i, offset, space='world')
if not tobe_offset:
return new_crv
cvs = new_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] + self.FRONT_OFFSET]
new_crv.setCV(i, offset, space='world')
return new_crv
def addObjects(self):
self.root = self.addRoot()
vTemp = transform.getOffsetPosition(self.root, [0, 0, 1])
self.sizeRef = self.addLoc("sizeRef", self.root, vTemp)
pm.delete(self.sizeRef.getShapes())
attribute.lockAttribute(self.sizeRef)
self.lookat = self.addLoc("lookat", self.root, vTemp)
v = transform.getTranslation(self.root)
self.sliding_surface = self.addSliderSurface("sliding_surface",
self.root, v)
def addObjects(self):
"""Add the Guide Root, blade and locators"""
self.root = self.addRoot()
self.uplocs = self.addLocMulti("#_uploc", self.root)
v = transform.getOffsetPosition(self.root, [0., 1.0, 0.0])
self.upPos = self.addLoc("uploc", self.root, v)
v = transform.getOffsetPosition(self.root, [0., -0.1, 0.0])
self.lowPos = self.addLoc("lowloc", self.root, v)
v = transform.getOffsetPosition(self.root, [0, 0.0000001, 2.5])
self.tan = self.addLoc("tan", self.root, v)
self.blade = self.addBlade("blade", self.root, self.tan)
v = transform.getTranslation(self.root)
self.sliding_surface = self.addSliderSurface("sliding_surface",
self.root, v)
def addObjects(self):
"""Add the Guide Root, blade and locators"""
self.root = self.addRoot()
self.uplocs = self.addLocMulti("#_uploc", self.root)
self.lowlocs = self.addLocMulti("#_lowloc", self.root)
v = transform.getOffsetPosition(self.root, [-1, 0.0, 0.0])
self.inPos = self.addLoc("inloc", self.root, v)
v = transform.getOffsetPosition(self.root, [1., 0.0, 0.0])
self.outPos = self.addLoc("outloc", self.root, v)
v = transform.getOffsetPosition(self.root, [0., 1.0, 0.0])
self.upPos = self.addLoc("uploc", self.root, v)
v = transform.getOffsetPosition(self.root, [0., -1.0, 0.0])
self.lowPos = self.addLoc("lowloc", self.root, v)
centers = [self.inPos]
centers.extend(self.uplocs)
centers.append(self.outPos)
self.dispcrv = self.addDispCurve("crv", centers)
self.addDispCurve("crvRef", centers, 3)
centers = [self.inPos]
centers.extend(self.lowlocs)
centers.append(self.outPos)
self.dispcrv = self.addDispCurve("crv", centers)
self.addDispCurve("crvRef", centers, 3)
v = transform.getTranslation(self.root)
self.eyeMesh = self.addEyeMesh("eyeMesh", self.root, v)
v = transform.getOffsetPosition(self.root, [0, 0.0000001, 2.5])
self.tan = self.addLoc("tan", self.root, v)
self.blade = self.addBlade("blade", self.root, self.tan)
def addObjects(self):
"""Add all the objects needed to create the component."""
self.WIP = self.options["mode"]
self.normal = self.getNormalFromPos(self.guide.apos)
self.binormal = self.getBiNormalFromPos(self.guide.apos)
self.length0 = vector.getDistance(self.guide.apos[0],
self.guide.apos[1])
self.length1 = vector.getDistance(self.guide.apos[1],
self.guide.apos[2])
self.length2 = vector.getDistance(self.guide.apos[2],
self.guide.apos[3])
# 1 bone chain for upv ref
self.legChainUpvRef = primitive.add2DChain(
self.root, self.getName("legUpvRef%s_jnt"),
[self.guide.apos[0], self.guide.apos[2]], self.normal, False,
self.WIP)
self.legChainUpvRef[1].setAttr(
"jointOrientZ",
self.legChainUpvRef[1].getAttr("jointOrientZ") * -1)
# extra neutral pose
t = transform.getTransformFromPos(self.guide.apos[0])
self.root_npo = primitive.addTransform(self.root,
self.getName("root_npo"), t)
self.root_ctl = self.addCtl(self.root_npo,
"root_ctl",
t,
self.color_fk,
"circle",
w=self.length0 / 6,
tp=self.parentCtlTag)
# FK Controlers -----------------------------------
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1], self.normal,
"xz", self.negate)
self.fk0_npo = primitive.addTransform(self.root_ctl,
self.getName("fk0_npo"), t)
po_vec = datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0)
self.fk0_ctl = self.addCtl(self.fk0_npo,
"fk0_ctl",
t,
self.color_fk,
"cube",
w=self.length0,
h=self.size * .1,
d=self.size * .1,
po=po_vec,
tp=self.root_ctl)
attribute.setKeyableAttributes(
self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"])
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[2], self.normal,
"xz", self.negate)
self.fk1_npo = primitive.addTransform(self.fk0_ctl,
self.getName("fk1_npo"), t)
po_vec = datatypes.Vector(.5 * self.length1 * self.n_factor, 0, 0)
self.fk1_ctl = self.addCtl(self.fk1_npo,
"fk1_ctl",
t,
self.color_fk,
"cube",
w=self.length1,
h=self.size * .1,
d=self.size * .1,
po=po_vec,
tp=self.fk0_ctl)
attribute.setKeyableAttributes(
self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"])
t = transform.getTransformLookingAt(self.guide.apos[2],
self.guide.apos[3], self.normal,
"xz", self.negate)
self.fk2_npo = primitive.addTransform(self.fk1_ctl,
self.getName("fk2_npo"), t)
po_vec = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0)
self.fk2_ctl = self.addCtl(self.fk2_npo,
"fk2_ctl",
t,
self.color_fk,
"cube",
w=self.length2,
h=self.size * .1,
d=self.size * .1,
po=po_vec,
tp=self.fk1_ctl)
attribute.setKeyableAttributes(self.fk2_ctl)
self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl]
for x in self.fk_ctl:
attribute.setInvertMirror(x, ["tx", "ty", "tz"])
# IK Controlers -----------------------------------
self.ik_cns = primitive.addTransformFromPos(self.root_ctl,
self.getName("ik_cns"),
self.guide.pos["ankle"])
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
transform.getTransformFromPos(
self.guide.pos["ankle"]),
self.color_ik,
"null",
w=self.size * .12,
tp=self.root_ctl)
attribute.setInvertMirror(self.ikcns_ctl, ["tx"])
m = transform.getTransformLookingAt(self.guide.pos["ankle"],
self.guide.pos["eff"], self.x_axis,
"zx", False)
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
transform.getTransformFromPos(
self.guide.pos["ankle"]),
self.color_ik,
"cube",
w=self.size * .12,
h=self.size * .12,
d=self.size * .12)
attribute.setKeyableAttributes(self.ik_ctl)
attribute.setRotOrder(self.ik_ctl, "XZY")
attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
# upv
v = self.guide.apos[2] - self.guide.apos[0]
v = self.normal ^ v
v.normalize()
v *= self.size * .5
v += self.guide.apos[1]
self.upv_cns = primitive.addTransformFromPos(self.ik_ctl,
self.getName("upv_cns"),
v)
self.upv_ctl = self.addCtl(self.upv_cns,
"upv_ctl",
transform.getTransform(self.upv_cns),
self.color_ik,
"diamond",
w=self.size * .12,
tp=self.root_ctl)
self.add_controller_tag(self.ik_ctl, self.upv_ctl)
if self.settings["mirrorMid"]:
if self.negate:
self.upv_cns.rz.set(180)
self.upv_cns.sy.set(-1)
else:
attribute.setInvertMirror(self.upv_ctl, ["tx"])
attribute.setKeyableAttributes(self.upv_ctl, self.t_params)
# References --------------------------------------
self.ik_ref = primitive.addTransform(
self.ik_ctl, self.getName("ik_ref"),
transform.getTransform(self.ik_ctl))
self.fk_ref = primitive.addTransform(
self.fk_ctl[2], self.getName("fk_ref"),
transform.getTransform(self.ik_ctl))
# Chain --------------------------------------------
# The outputs of the ikfk2bone solver
self.bone0 = primitive.addLocator(
self.root_ctl, self.getName("0_bone"),
transform.getTransform(self.fk_ctl[0]))
self.bone0_shp = self.bone0.getShape()
self.bone0_shp.setAttr("localPositionX", self.n_factor * .5)
self.bone0_shp.setAttr("localScale", .5, 0, 0)
self.bone0.setAttr("sx", self.length0)
self.bone0.setAttr("visibility", False)
self.bone1 = primitive.addLocator(
self.root_ctl, self.getName("1_bone"),
transform.getTransform(self.fk_ctl[1]))
self.bone1_shp = self.bone1.getShape()
self.bone1_shp.setAttr("localPositionX", self.n_factor * .5)
self.bone1_shp.setAttr("localScale", .5, 0, 0)
self.bone1.setAttr("sx", self.length1)
self.bone1.setAttr("visibility", False)
self.ctrn_loc = primitive.addTransformFromPos(self.root_ctl,
self.getName("ctrn_loc"),
self.guide.apos[1])
self.eff_loc = primitive.addTransformFromPos(self.root_ctl,
self.getName("eff_loc"),
self.guide.apos[2])
# tws_ref
t = transform.getRotationFromAxis(datatypes.Vector(0, -1, 0),
self.normal, "xz", self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["ankle"])
# addind an npo parent transform to fix flip in Maya 2018.2
self.tws_npo = primitive.addTransform(self.eff_loc,
self.getName("tws_npo"), t)
self.tws_ref = primitive.addTransform(self.tws_npo,
self.getName("tws_ref"), t)
# Mid Controler ------------------------------------
t = transform.getTransform(self.ctrn_loc)
self.mid_cns = primitive.addTransform(self.ctrn_loc,
self.getName("mid_cns"), t)
self.mid_ctl = self.addCtl(self.mid_cns,
"mid_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.root_ctl)
attribute.setKeyableAttributes(
self.mid_ctl,
params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"])
if self.settings["mirrorMid"]:
if self.negate:
self.mid_cns.rz.set(180)
self.mid_cns.sz.set(-1)
else:
attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"])
# Twist references ---------------------------------
x = datatypes.Vector(0, -1, 0)
x = x * transform.getTransform(self.eff_loc)
z = datatypes.Vector(self.normal.x, self.normal.y, self.normal.z)
z = z * transform.getTransform(self.eff_loc)
m = transform.getRotationFromAxis(x, z, "xz", self.negate)
m = transform.setMatrixPosition(m,
transform.getTranslation(self.ik_ctl))
self.rollRef = primitive.add2DChain(self.root,
self.getName("rollChain"),
self.guide.apos[:2], self.normal,
self.negate, self.WIP)
self.tws0_loc = primitive.addTransform(
self.rollRef[0], self.getName("tws0_loc"),
transform.getTransform(self.fk_ctl[0]))
self.tws0_rot = primitive.addTransform(
self.tws0_loc, self.getName("tws0_rot"),
transform.getTransform(self.fk_ctl[0]))
self.tws1_loc = primitive.addTransform(
self.ctrn_loc, self.getName("tws1_loc"),
transform.getTransform(self.ctrn_loc))
self.tws1_rot = primitive.addTransform(
self.tws1_loc, self.getName("tws1_rot"),
transform.getTransform(self.ctrn_loc))
# thickness control
self.thick_lvl = primitive.addTransform(
self.mid_ctl, self.getName("thickness_lvl"),
transform.getTransform(self.ctrn_loc))
self.thick_ctl = self.addCtl(self.thick_lvl,
"thickness_ctl",
transform.getTransform(self.mid_ctl),
self.color_ik,
"arrow",
w=self.size * .1,
ro=datatypes.Vector([0, 1.5708, 0]),
tp=self.mid_ctl)
if self.negate and not self.settings["mirrorMid"]:
self.thick_ctl.rz.set(180)
self.thick_ctl.sz.set(-1)
attribute.setKeyableAttributes(self.thick_ctl, ["tx", "ty"])
self.tws1B_loc = primitive.addTransform(
self.ctrn_loc, self.getName("tws1B_loc"),
transform.getTransform(self.ctrn_loc))
self.tws1B_rot = primitive.addTransform(
self.tws1B_loc, self.getName("tws1B_rot"),
transform.getTransform(self.ctrn_loc))
self.tws2_loc = primitive.addTransform(
self.root_ctl, self.getName("tws2_loc"),
transform.getTransform(self.tws_ref))
self.tws2_rot = primitive.addTransform(
self.tws2_loc, self.getName("tws2_rot"),
transform.getTransform(self.tws_ref))
self.tws2_rot.setAttr("sx", .001)
# angle reader ----------------------------------------
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[0], self.binormal,
"yz")
self.readerA = primitive.addTransform(self.root,
self.getName("readerA_loc"), t)
self.readerB = primitive.addTransform(self.readerA,
self.getName("readerB_loc"), t)
self.readerB.rotateOrder.set(2)
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for
# the elbow. + 2 for knee angle control
if self.settings["supportJoints"]:
ej = 2
else:
ej = 0
self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + ej
self.div_cns = []
if self.settings["extraTweak"]:
tagP = self.parentCtlTag
self.tweak_ctl = []
for i in range(self.divisions):
div_cns = primitive.addTransform(self.root_ctl,
self.getName("div%s_loc" % i))
self.div_cns.append(div_cns)
if self.settings["extraTweak"]:
t = transform.getTransform(div_cns)
tweak_ctl = self.addCtl(div_cns,
"tweak%s_ctl" % i,
t,
self.color_fk,
"square",
w=self.size * .15,
d=self.size * .15,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=tagP)
attribute.setKeyableAttributes(tweak_ctl)
tagP = tweak_ctl
self.tweak_ctl.append(tweak_ctl)
self.jnt_pos.append([tweak_ctl, i, None, False])
else:
self.jnt_pos.append([div_cns, i])
# End reference ------------------------------------
# To help the deformation on the ankle
self.end_ref = primitive.addTransform(self.tws2_rot,
self.getName("end_ref"), m)
self.jnt_pos.append([self.end_ref, 'end'])
# match IK FK references
self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], self.root,
"matchFk0_npo", False)
self.match_fk0 = self.add_match_ref(self.fk_ctl[0], self.match_fk0_off,
"fk0_mth")
self.match_fk1_off = self.add_match_ref(self.fk_ctl[2], self.root,
"matchFk1_npo", False)
self.match_fk1 = self.add_match_ref(self.fk_ctl[1], self.match_fk1_off,
"fk1_mth")
self.match_fk2 = self.add_match_ref(self.fk_ctl[2], self.ik_ctl,
"fk2_mth")
self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth")
self.match_ikUpv = self.add_match_ref(self.upv_ctl, self.fk0_ctl,
"upv_mth")
# add visual reference
self.line_ref = icon.connection_display_curve(
self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def rig(edge_loop="",
up_vertex="",
low_vertex="",
name_prefix="",
thickness=0.3,
do_skin=True,
rigid_loops=5,
falloff_loops=8,
head_joint=None,
jaw_joint=None,
parent_node=None,
control_name="ctl",
upper_lip_ctl=None,
lower_lip_ctl=None):
######
# Var
######
FRONT_OFFSET = .02
NB_ROPE = 15
##################
# Helper functions
##################
def setName(name, side="C", idx=None):
namesList = [name_prefix, side, name]
if idx is not None:
namesList[1] = side + str(idx)
name = "_".join(namesList)
return name
###############
# Checkers
##############
# Loop
if edge_loop:
try:
edge_loop = [pm.PyNode(e) for e in edge_loop.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 up_vertex:
try:
up_vertex = pm.PyNode(up_vertex)
except pm.MayaNodeError:
pm.displayWarning("%s can not be found" % up_vertex)
return
else:
pm.displayWarning("Please set the upper lip central vertex")
return
if low_vertex:
try:
low_vertex = pm.PyNode(low_vertex)
except pm.MayaNodeError:
pm.displayWarning("%s can not be found" % low_vertex)
return
else:
pm.displayWarning("Please set the lower lip central vertex")
return
# skinnign data
if do_skin:
if not head_joint:
pm.displayWarning("Please set the Head Jnt or unCheck Compute "
"Topological Autoskin")
return
else:
try:
head_joint = pm.PyNode(head_joint)
except pm.MayaNodeError:
pm.displayWarning(
"Head Joint: %s can not be found" % head_joint
)
return
if not jaw_joint:
pm.displayWarning("Please set the Jaw Jnt or unCheck Compute "
"Topological Autoskin")
return
else:
try:
jaw_joint = pm.PyNode(jaw_joint)
except pm.MayaNodeError:
pm.displayWarning("Jaw Joint: %s can not be found" % jaw_joint)
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(edge_loop[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(edge_loop)
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 = up_vertex
lowPos = low_vertex
# 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("upCtl_crv"),
nbPoints=7,
parent=lipsCrv_root)
lowCrv_ctl = curve.createCurveFromCurve(lowCrv,
setName("lowCtl_crv"),
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)
##################
# 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 head_joint and isinstance(head_joint, (str, string_types)):
try:
j_parent = pm.PyNode(head_joint)
except pm.MayaNodeError:
j_parent = False
elif head_joint and isinstance(head_joint, pm.PyNode):
j_parent = head_joint
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 jaw_joint and isinstance(jaw_joint, (str, string_types)):
try:
j_parent = pm.PyNode(jaw_joint)
except pm.MayaNodeError:
pass
elif jaw_joint and isinstance(jaw_joint, pm.PyNode):
j_parent = jaw_joint
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)
##################
# Controls
##################
# Controls lists
upControls = []
upVec = []
upNpo = []
lowControls = []
lowVec = []
lowNpo = []
# controls options
axis_list = ["sx", "sy", "sz", "ro"]
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", "rx", "ry", "rz"]
# 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
for i, cv in enumerate(cvs):
pm.progressWindow(e=True,
step=1,
status='\nCreating control for%s' % cv)
t = transform.getTransformFromPos(cv)
# Get nearest joint for orientation of controls
joints = upperJoints + lowerJoints
nearest_joint = None
nearest_distance = None
for joint in joints:
distance = vector.getDistance(
transform.getTranslation(joint),
cv
)
if nearest_distance is None or distance < nearest_distance:
nearest_distance = distance
nearest_joint = joint
if nearest_joint:
t = transform.setMatrixPosition(
transform.getTransform(nearest_joint), cv
)
temp = primitive.addTransform(
lips_root, setName("temp"), t
)
temp.rx.set(0)
t = transform.getTransform(temp)
pm.delete(temp)
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, control_name), 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)
name_split = control_name.split("_")
if len(name_split) == 2 and name_split[-1] == "ghost":
pass
else:
pm.sets(ctlSet, add=ctl)
attribute.addAttribute(ctl, "isCtl", "bool", keyable=False)
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)
# Get nearest joint for orientation of controls
joints = upperJoints + lowerJoints
nearest_joint = None
nearest_distance = None
for joint in joints:
distance = vector.getDistance(
transform.getTranslation(joint),
cv
)
if nearest_distance is None or distance < nearest_distance:
nearest_distance = distance
nearest_joint = joint
if nearest_joint:
t = transform.setMatrixPosition(
transform.getTransform(nearest_joint), cv
)
temp = primitive.addTransform(
lips_root, setName("temp"), t
)
temp.rx.set(0)
t = transform.getTransform(temp)
pm.delete(temp)
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, control_name), 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)
name_split = control_name.split("_")
if len(name_split) == 2 and control_name.split("_")[-1] == "ghost":
pass
else:
pm.sets(ctlSet, add=ctl)
attribute.addAttribute(ctl, "isCtl", "bool", keyable=False)
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, dropoffDistance=[0, 1000])
pm.wire(lowCrv, w=lowCrv_ctl, dropoffDistance=[0, 1000])
pm.wire(upRope, w=upCrv_ctl, dropoffDistance=[0, 1000])
pm.wire(lowRope, w=lowCrv_ctl, dropoffDistance=[0, 1000])
pm.wire(upRope_upv, w=upCrv_upv, dropoffDistance=[0, 1000])
pm.wire(lowRope_upv, w=lowCrv_upv, dropoffDistance=[0, 1000])
# 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.interpType.set(0) # noFlip
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.interpType.set(0) # noFlip
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.interpType.set(0) # noFlip
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)
cns_node.interpType.set(0) # noFlip
# 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.interpType.set(0) # noFlip
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.interpType.set(0) # noFlip
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.interpType.set(0) # noFlip
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)
cns_node.interpType.set(0) # noFlip
###########################################
# Connecting rig
###########################################
if parent_node:
try:
if isinstance(parent_node, string_types):
parent_node = pm.PyNode(parent_node)
parent_node.addChild(lips_root)
except pm.MayaNodeError:
pm.displayWarning("The Lips rig can not be parent to: %s. Maybe "
"this object doesn't exist." % parent_node)
if head_joint and jaw_joint:
try:
if isinstance(head_joint, string_types):
head_joint = pm.PyNode(head_joint)
except pm.MayaNodeError:
pm.displayWarning("Head Joint or Upper Lip Joint %s. Can not be "
"fount in the scene" % head_joint)
return
try:
if isinstance(jaw_joint, string_types):
jaw_joint = pm.PyNode(jaw_joint)
except pm.MayaNodeError:
pm.displayWarning("Jaw Joint or Lower Lip Joint %s. Can not be "
"fount in the scene" % jaw_joint)
return
ref_ctls = [head_joint, jaw_joint]
if upper_lip_ctl and lower_lip_ctl:
try:
if isinstance(upper_lip_ctl, string_types):
upper_lip_ctl = pm.PyNode(upper_lip_ctl)
except pm.MayaNodeError:
pm.displayWarning("Upper Lip Ctl %s. Can not be "
"fount in the scene" % upper_lip_ctl)
return
try:
if isinstance(lower_lip_ctl, string_types):
lower_lip_ctl = pm.PyNode(lower_lip_ctl)
except pm.MayaNodeError:
pm.displayWarning("Lower Lip Ctl %s. Can not be "
"fount in the scene" % lower_lip_ctl)
return
ref_ctls = [upper_lip_ctl, lower_lip_ctl]
# in order to avoid flips lets create a reference transform
# also to avoid flips, set any multi target parentConstraint to noFlip
ref_cns_list = []
print (ref_ctls)
for cns_ref in ref_ctls:
t = transform.getTransformFromPos(
cns_ref.getTranslation(space='world'))
ref = pm.createNode("transform",
n=cns_ref.name() + "_cns",
p=cns_ref,
ss=True)
ref.setMatrix(t, worldSpace=True)
ref_cns_list.append(ref)
# right corner connection
cns_node = pm.parentConstraint(ref_cns_list[0],
ref_cns_list[1],
upControls[0].getParent(),
mo=True)
cns_node.interpType.set(0) # noFlip
# left corner connection
cns_node = pm.parentConstraint(ref_cns_list[0],
ref_cns_list[1],
upControls[-1].getParent(),
mo=True)
cns_node.interpType.set(0) # noFlip
# up control connection
cns_node = pm.parentConstraint(ref_cns_list[0],
upControls[3].getParent(),
mo=True)
# low control connection
cns_node = pm.parentConstraint(ref_cns_list[1],
lowControls[2].getParent(),
mo=True)
###########################################
# Auto Skinning
###########################################
if do_skin:
# eyelid vertex rows
totalLoops = rigid_loops + falloff_loops
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(rigid_loops):
for rr in range(2):
skinPercList.append(1.0)
increment = 1.0 / float(falloff_loops)
# we invert to smooth out from 100 to 0
inv = 1.0 - increment
for r in range(falloff_loops):
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 head_joint:
try:
head_joint = pm.PyNode(head_joint)
except pm.MayaNodeError:
pm.displayWarning(
"Auto skin aborted can not find %s " % head_joint)
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(head_joint,
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):
"""Add all the objects needed to create the component."""
self.WIP = self.options["mode"]
self.up_axis = pm.upAxis(q=True, axis=True)
self.normal = self.getNormalFromPos(self.guide.apos)
self.length0 = vector.getDistance(
self.guide.apos[0], self.guide.apos[1])
self.length1 = vector.getDistance(
self.guide.apos[1], self.guide.apos[2])
self.length2 = vector.getDistance(
self.guide.apos[2], self.guide.apos[3])
# 1 bone chain for upv ref
self.legChainUpvRef = primitive.add2DChain(
self.root,
self.getName("legUpvRef%s_jnt"),
[self.guide.apos[0], self.guide.apos[2]],
self.normal,
False,
self.WIP)
self.legChainUpvRef[1].setAttr(
"jointOrientZ",
self.legChainUpvRef[1].getAttr("jointOrientZ") * -1)
# extra neutral pose
t = transform.getTransformFromPos(self.guide.apos[0])
self.root_npo = primitive.addTransform(self.root,
self.getName("root_npo"),
t)
self.root_ctl = self.addCtl(self.root_npo,
"root_ctl",
t,
self.color_fk,
"circle",
w=self.length0 / 6,
tp=self.parentCtlTag)
# FK Controlers -----------------------------------
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
"xz",
self.negate)
if self.settings["FK_rest_T_Pose"]:
if self.negate:
x_dir = 1
else:
x_dir = -1
if self.up_axis == "y":
x = datatypes.Vector(0, x_dir, 0)
else:
x = datatypes.Vector(0, 0, x_dir)
z = datatypes.Vector(-1, 0, 0)
t_npo = transform.getRotationFromAxis(x, z, "xz", False)
t_npo = transform.setMatrixPosition(t_npo, self.guide.apos[0])
else:
t_npo = t
self.fk0_npo = primitive.addTransform(self.root_ctl,
self.getName("fk0_npo"),
t_npo)
po_vec = datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0)
self.fk0_ctl = self.addCtl(self.fk0_npo,
"fk0_ctl",
t,
self.color_fk,
"cube",
w=self.length0,
h=self.size * .1,
d=self.size * .1,
po=po_vec,
tp=self.root_ctl)
attribute.setKeyableAttributes(
self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"])
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[2],
self.normal,
"xz",
self.negate)
if self.settings["FK_rest_T_Pose"]:
t_npo = transform.setMatrixPosition(
transform.getTransform(self.fk0_ctl), self.guide.apos[1])
else:
t_npo = t
self.fk1_npo = primitive.addTransform(
self.fk0_ctl, self.getName("fk1_npo"), t_npo)
po_vec = datatypes.Vector(.5 * self.length1 * self.n_factor, 0, 0)
self.fk1_ctl = self.addCtl(self.fk1_npo,
"fk1_ctl",
t,
self.color_fk,
"cube",
w=self.length1,
h=self.size * .1,
d=self.size * .1,
po=po_vec,
tp=self.fk0_ctl)
attribute.setKeyableAttributes(
self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"])
t = transform.getTransformLookingAt(self.guide.apos[2],
self.guide.apos[3],
self.normal,
"xz",
self.negate)
if self.settings["FK_rest_T_Pose"]:
t_npo = transform.setMatrixPosition(
transform.getTransform(self.fk0_ctl), self.guide.apos[2])
else:
t_npo = t
self.fk2_npo = primitive.addTransform(
self.fk1_ctl, self.getName("fk2_npo"), t_npo)
if self.settings["FK_rest_T_Pose"]:
self.fk2_npo.rz.set(90)
po_vec = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0)
self.fk2_ctl = self.addCtl(self.fk2_npo,
"fk2_ctl",
t,
self.color_fk,
"cube",
w=self.length2,
h=self.size * .1,
d=self.size * .1,
po=po_vec,
tp=self.fk1_ctl)
attribute.setKeyableAttributes(self.fk2_ctl)
self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl]
for x in self.fk_ctl:
attribute.setInvertMirror(x, ["tx", "ty", "tz"])
# IK Controlers -----------------------------------
self.ik_cns = primitive.addTransformFromPos(self.root_ctl,
self.getName("ik_cns"),
self.guide.pos["ankle"])
self.ikcns_ctl = self.addCtl(
self.ik_cns,
"ikcns_ctl",
transform.getTransformFromPos(self.guide.pos["ankle"]),
self.color_ik,
"null",
w=self.size * .12,
tp=self.root_ctl)
attribute.setInvertMirror(self.ikcns_ctl, ["tx"])
# m = transform.getTransformLookingAt(self.guide.pos["ankle"],
# self.guide.pos["eff"],
# self.x_axis,
# "zx",
# False)
# if self.settings["FK_rest_T_Pose"]:
# t_ik = transform.getTransformLookingAt(self.guide.pos["ankle"],
# self.guide.pos["eff"],
# self.normal * -1,
# "zx",
# False)
# else:
t_ik = transform.getTransformFromPos(self.guide.pos["ankle"])
self.ik_ctl = self.addCtl(
self.ikcns_ctl,
"ik_ctl",
t_ik,
self.color_ik,
"cube",
w=self.size * .12,
h=self.size * .12,
d=self.size * .12)
attribute.setKeyableAttributes(self.ik_ctl)
attribute.setRotOrder(self.ik_ctl, "XZY")
attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
# upv
v = self.guide.apos[2] - self.guide.apos[0]
v = self.normal ^ v
v.normalize()
v *= self.size * .5
v += self.guide.apos[1]
self.upv_cns = primitive.addTransformFromPos(self.ik_ctl,
self.getName("upv_cns"),
v)
self.upv_ctl = self.addCtl(
self.upv_cns,
"upv_ctl",
transform.getTransform(self.upv_cns),
self.color_ik,
"diamond",
w=self.size * .12,
tp=self.root_ctl)
self.add_controller_tag(self.ik_ctl, self.upv_ctl)
if self.settings["mirrorMid"]:
if self.negate:
self.upv_cns.rz.set(180)
self.upv_cns.sy.set(-1)
else:
attribute.setInvertMirror(self.upv_ctl, ["tx"])
attribute.setKeyableAttributes(self.upv_ctl, self.t_params)
# References --------------------------------------
self.ik_ref = primitive.addTransform(
self.ik_ctl,
self.getName("ik_ref"),
transform.getTransform(self.ik_ctl))
self.fk_ref = primitive.addTransform(
self.fk_ctl[2],
self.getName("fk_ref"),
transform.getTransform(self.ik_ctl))
# Chain --------------------------------------------
# The outputs of the ikfk2bone solver
self.bone0 = primitive.addLocator(
self.root_ctl,
self.getName("0_bone"),
transform.getTransform(self.fk_ctl[0]))
self.bone0_shp = self.bone0.getShape()
self.bone0_shp.setAttr("localPositionX", self.n_factor * .5)
self.bone0_shp.setAttr("localScale", .5, 0, 0)
self.bone0.setAttr("sx", self.length0)
self.bone0.setAttr("visibility", False)
self.bone1 = primitive.addLocator(
self.root_ctl,
self.getName("1_bone"),
transform.getTransform(self.fk_ctl[1]))
self.bone1_shp = self.bone1.getShape()
self.bone1_shp.setAttr("localPositionX", self.n_factor * .5)
self.bone1_shp.setAttr("localScale", .5, 0, 0)
self.bone1.setAttr("sx", self.length1)
self.bone1.setAttr("visibility", False)
self.ctrn_loc = primitive.addTransformFromPos(self.root_ctl,
self.getName("ctrn_loc"),
self.guide.apos[1])
self.eff_loc = primitive.addTransformFromPos(self.root_ctl,
self.getName("eff_loc"),
self.guide.apos[2])
# tws_ref
t = transform.getRotationFromAxis(
datatypes.Vector(0, -1, 0), self.normal, "xz", self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["ankle"])
# addind an npo parent transform to fix flip in Maya 2018.2
self.tws_npo = primitive.addTransform(
self.eff_loc, self.getName("tws_npo"), t)
self.tws_ref = primitive.addTransform(
self.tws_npo, self.getName("tws_ref"), t)
# Mid Controler ------------------------------------
t = transform.getTransform(self.ctrn_loc)
self.mid_cns = primitive.addTransform(
self.ctrn_loc, self.getName("mid_cns"), t)
self.mid_ctl = self.addCtl(self.mid_cns,
"mid_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.root_ctl)
attribute.setKeyableAttributes(self.mid_ctl,
params=["tx", "ty", "tz",
"ro", "rx", "ry", "rz",
"sx"])
if self.settings["mirrorMid"]:
if self.negate:
self.mid_cns.rz.set(180)
self.mid_cns.sz.set(-1)
else:
attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"])
# Twist references ---------------------------------
x = datatypes.Vector(0, -1, 0)
x = x * transform.getTransform(self.eff_loc)
z = datatypes.Vector(self.normal.x, self.normal.y, self.normal.z)
z = z * transform.getTransform(self.eff_loc)
m = transform.getRotationFromAxis(x, z, "xz", self.negate)
m = transform.setMatrixPosition(
m, transform.getTranslation(self.ik_ctl))
self.rollRef = primitive.add2DChain(self.root,
self.getName("rollChain"),
self.guide.apos[:2],
self.normal,
self.negate,
self.WIP)
t = transform.getTransformLookingAt(self.guide.pos["base"],
self.guide.apos[1],
self.normal,
"xz",
self.negate)
self.tws0_loc = primitive.addTransform(
self.root_ctl,
self.getName("tws0_loc"),
t)
self.tws0_rot = primitive.addTransform(
self.tws0_loc,
self.getName("tws0_rot"),
t)
self.tws1_loc = primitive.addTransform(
self.ctrn_loc,
self.getName("tws1_loc"),
transform.getTransform(self.ctrn_loc))
self.tws1_rot = primitive.addTransform(
self.tws1_loc,
self.getName("tws1_rot"),
transform.getTransform(self.ctrn_loc))
self.tws2_loc = primitive.addTransform(
self.root_ctl,
self.getName("tws2_loc"),
transform.getTransform(self.tws_ref))
self.tws2_rot = primitive.addTransform(
self.tws2_loc,
self.getName("tws2_rot"),
transform.getTransform(self.tws_ref))
self.tws2_rot.setAttr("sx", .001)
# Divisions ----------------------------------------
self.divisions = self.settings["div0"] + self.settings["div1"] + 2
self.div_cns = []
if self.settings["extraTweak"]:
tagP = self.parentCtlTag
self.tweak_ctl = []
for i in range(self.divisions):
div_cns = primitive.addTransform(self.root_ctl,
self.getName("div%s_loc" % i))
self.div_cns.append(div_cns)
if self.settings["extraTweak"]:
t = transform.getTransform(div_cns)
tweak_ctl = self.addCtl(div_cns,
"tweak%s_ctl" % i,
t,
self.color_fk,
"square",
w=self.size * .15,
d=self.size * .15,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=tagP)
attribute.setKeyableAttributes(tweak_ctl)
tagP = tweak_ctl
self.tweak_ctl.append(tweak_ctl)
driver = tweak_ctl
else:
driver = div_cns
# setting the joints
if i == 0:
self.jnt_pos.append([driver, "thigh"])
current_parent = "root"
twist_name = "thigh_twist_"
twist_idx = 1
increment = 1
elif i == self.settings["div0"] + 1:
self.jnt_pos.append([driver, "calf", current_parent])
twist_name = "calf_twist_"
current_parent = "knee"
twist_idx = self.settings["div1"]
increment = -1
else:
self.jnt_pos.append(
[driver,
twist_name + str(twist_idx).zfill(2),
current_parent])
twist_idx += increment
# End reference ------------------------------------
# To help the deformation on the ankle
self.end_ref = primitive.addTransform(self.tws2_rot,
self.getName("end_ref"), m)
# set the offset rotation for the hand
self.end_jnt_off = primitive.addTransform(self.end_ref,
self.getName("end_off"), m)
if self.up_axis == "z":
self.end_jnt_off.rz.set(-90)
self.jnt_pos.append([self.end_jnt_off, 'foot', current_parent])
# match IK FK references
self.match_fk0_off = self.add_match_ref(self.fk_ctl[1],
self.root,
"matchFk0_npo",
False)
self.match_fk0 = self.add_match_ref(self.fk_ctl[0],
self.match_fk0_off,
"fk0_mth")
self.match_fk1_off = self.add_match_ref(self.fk_ctl[2],
self.root,
"matchFk1_npo",
False)
self.match_fk1 = self.add_match_ref(self.fk_ctl[1],
self.match_fk1_off,
"fk1_mth")
self.match_fk2 = self.add_match_ref(self.fk_ctl[2],
self.ik_ctl,
"fk2_mth")
self.match_ik = self.add_match_ref(self.ik_ctl,
self.fk2_ctl,
"ik_mth")
self.match_ikUpv = self.add_match_ref(self.upv_ctl,
self.fk0_ctl,
"upv_mth")
# add visual reference
self.line_ref = icon.connection_display_curve(
self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def 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.
"""
# Visibilities -------------------------------------
if self.isFkIk:
# fk
fkvis_node = node.createReverseNode(self.blend_att)
for fk_ctl in self.fk_ctl:
for shp in fk_ctl.getShapes():
pm.connectAttr(fkvis_node + ".outputX",
shp.attr("visibility"))
# ik
for shp in self.upv_ctl.getShapes():
pm.connectAttr(self.blend_att, shp.attr("visibility"))
for shp in self.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"))
# FK Chain -----------------------------------------
if self.isFk:
for off, ref in zip(self.fk_off[1:], self.fk_ref):
applyop.gear_mulmatrix_op(ref.worldMatrix,
off.parentInverseMatrix, off, "rt")
# IK Chain -----------------------------------------
if self.isIk:
self.ikh = primitive.addIkHandle(self.root, self.getName("ikh"),
self.chain)
self.ikh.attr("visibility").set(False)
# Constraint and up vector
pm.pointConstraint(self.ik_ctl, self.ikh, maintainOffset=False)
pm.poleVectorConstraint(self.upv_ctl, self.ikh)
# TwistTest
o_list = [round(elem, 4) for elem
in transform.getTranslation(self.chain[1])] \
!= [round(elem, 4) for elem in self.guide.apos[1]]
if o_list:
add_nodeTwist = node.createAddNode(180.0, self.roll_att)
pm.connectAttr(add_nodeTwist + ".output",
self.ikh.attr("twist"))
else:
pm.connectAttr(self.roll_att, self.ikh.attr("twist"))
# Chain of deformers -------------------------------
if self.settings["mode"] == 0: # fk only
# Loop until the last one and connect aim constraints from index+1
for i, loc in enumerate(self.loc[0:-1]):
pm.pointConstraint(self.fk_ctl[i], loc, maintainOffset=False)
pm.connectAttr(self.fk_ctl[i] + ".scale", loc + ".scale")
pm.aimConstraint(
self.fk_ctl[i + 1],
loc,
maintainOffset=False,
aimVector=(1, 0, 0),
upVector=(0, 1, 0),
worldUpType='none',
)
oRoot = rigbits.addNPO(loc)[0]
pm.parentConstraint(self.fk_ctl[i], oRoot, mo=True)
attribute.lockAttribute(oRoot)
# Then connect the last in the chain as a parent constraint
pm.parentConstraint(self.fk_ctl[-1],
self.loc[-1],
maintainOffset=False)
pm.connectAttr(self.fk_ctl[-1] + ".scale", self.loc[-1] + ".scale")
def addObjects(self):
"""Add all the objects needed to create the component."""
self.up_axis = pm.upAxis(q=True, axis=True)
self.div_count = len(self.guide.apos) - 5
plane = [self.guide.apos[0], self.guide.apos[-4], self.guide.apos[-3]]
self.normal = self.getNormalFromPos(plane)
self.binormal = self.getBiNormalFromPos(plane)
# Heel ---------------------------------------------
# bank pivot
t = transform.getTransformLookingAt(self.guide.pos["heel"],
self.guide.apos[-4], self.normal,
"xz", self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["inpivot"])
self.in_npo = primitive.addTransform(self.root, self.getName("in_npo"),
t)
self.in_piv = primitive.addTransform(self.in_npo,
self.getName("in_piv"), t)
t = transform.setMatrixPosition(t, self.guide.pos["outpivot"])
self.out_piv = primitive.addTransform(self.in_piv,
self.getName("out_piv"), t)
# heel
t = transform.getTransformLookingAt(self.guide.pos["heel"],
self.guide.apos[-4], self.normal,
"xz", self.negate)
self.heel_loc = primitive.addTransform(self.out_piv,
self.getName("heel_loc"), t)
attribute.setRotOrder(self.heel_loc, "YZX")
self.heel_ctl = self.addCtl(self.heel_loc,
"heel_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .1,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.heel_ctl, self.r_params)
# Tip ----------------------------------------------
if self.up_axis == "y":
v = datatypes.Vector(self.guide.apos[-5].x,
self.guide.pos["heel"].y,
self.guide.apos[-5].z)
else:
v = datatypes.Vector(self.guide.apos[-5].x, self.guide.apos[-5].y,
self.guide.pos["heel"].z)
t = transform.setMatrixPosition(t, v)
self.tip_ctl = self.addCtl(self.heel_ctl,
"tip_ctl",
t,
self.color_ik,
"circle",
w=self.size,
tp=self.heel_ctl)
attribute.setKeyableAttributes(self.tip_ctl, self.r_params)
# Roll ---------------------------------------------
if self.settings["useRollCtl"]:
t = transform.getTransformLookingAt(self.guide.pos["heel"],
self.guide.apos[-4],
self.normal, "xz", self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["root"])
self.roll_np = primitive.addTransform(self.root,
self.getName("roll_npo"), t)
self.roll_ctl = self.addCtl(self.roll_np,
"roll_ctl",
t,
self.color_ik,
"cylinder",
w=self.size * .5,
h=self.size * .5,
ro=datatypes.Vector(3.1415 * .5, 0, 0),
tp=self.tip_ctl)
attribute.setKeyableAttributes(self.roll_ctl, ["rx", "rz"])
# Backward Controlers ------------------------------
bk_pos = self.guide.apos[1:-3]
bk_pos.reverse()
parent = self.tip_ctl
self.bk_ctl = []
self.bk_loc = []
self.previousTag = self.tip_ctl
for i, pos in enumerate(bk_pos):
if i == 0:
t = transform.getTransform(self.heel_ctl)
t = transform.setMatrixPosition(t, pos)
else:
direction = bk_pos[i - 1]
t = transform.getTransformLookingAt(pos, direction,
self.normal, "xz",
self.negate)
bk_loc = primitive.addTransform(parent,
self.getName("bk%s_loc" % i), t)
bk_ctl = self.addCtl(bk_loc,
"bk%s_ctl" % i,
t,
self.color_ik,
"sphere",
w=self.size * .15,
tp=self.previousTag)
attribute.setKeyableAttributes(bk_ctl, self.r_params)
self.previousTag = bk_ctl
self.bk_loc.append(bk_loc)
self.bk_ctl.append(bk_ctl)
parent = bk_ctl
# FK Reference ------------------------------------
self.fk_ref = primitive.addTransformFromPos(self.bk_ctl[-1],
self.getName("fk_ref"),
self.guide.apos[0])
self.fk_npo = primitive.addTransform(
self.fk_ref, self.getName("fk0_npo"),
transform.getTransform(self.bk_ctl[-1]))
# Forward Controlers ------------------------------
self.fk_ctl = []
self.fk_loc = []
parent = self.fk_npo
self.previousTag = self.tip_ctl
for i, bk_ctl in enumerate(reversed(self.bk_ctl[1:])):
if i == len(self.bk_ctl) - 2:
t = transform.getTransform(self.tip_ctl)
v = transform.getTranslation(bk_ctl)
t = transform.setMatrixPosition(t, v)
else:
t = transform.getTransform(bk_ctl)
dist = vector.getDistance(self.guide.apos[i + 1],
self.guide.apos[i + 2])
fk_loc = primitive.addTransform(parent,
self.getName("fk%s_loc" % i), t)
po_vec = datatypes.Vector(dist * .5 * self.n_factor, 0, 0)
fk_ctl = self.addCtl(fk_loc,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=dist,
h=self.size * .5,
d=self.size * .5,
po=po_vec,
tp=self.previousTag)
self.previousTag = fk_ctl
attribute.setKeyableAttributes(fk_ctl)
if i:
name = "ball" + str(i)
else:
name = "ball"
self.jnt_pos.append([fk_ctl, name])
parent = fk_ctl
self.fk_ctl.append(fk_ctl)
self.fk_loc.append(fk_loc)
def _addControls(self, crv_ctl, option, sidecut):
cvs = crv_ctl.getCVs(space="world")
pm.progressWindow(title='controls', progress=0, max=len(cvs))
v0 = transform.getTransformFromPos(cvs[0])
v1 = transform.getTransformFromPos(cvs[-1])
distSize = vector.getDistance(v0, v1) * 3
npos = []
ctls = []
upvs = []
params = ["tx", "ty", "tz", "rx", "ry", "rz"]
joints = self.upJoints + self.lowJoints
iterator = enumerate(cvs)
if sidecut:
iterator = enumerate(cvs[1:-1])
for i, cv in iterator:
pm.progressWindow(e=True,
step=1,
status='\nCreating control for%s' % cv)
t = transform.getTransformFromPos(cv)
# Get nearest joint for orientation of controls
nearest_joint = None
nearest_distance = None
for joint in joints:
distance = vector.getDistance(transform.getTranslation(joint),
cv)
if nearest_distance is None or distance < nearest_distance:
nearest_distance = distance
nearest_joint = joint
if nearest_joint:
t = transform.setMatrixPosition(
transform.getTransform(nearest_joint), cv)
temp = addTransform(self.root, self.getName("temp"), t)
# temp.rx.set(0)
t = transform.getTransform(temp)
pm.delete(temp)
# print(i, nearest_joint, temp)
oName = option[i][0]
oSide = option[i][1]
o_icon = option[i][2]
color = option[i][3]
wd = option[i][4]
oPar = option[i][5]
if oSide == "R":
scl = [1, 1, -1]
else:
scl = [1, 1, 1]
t = transform.setMatrixScale(t, scl)
npo = addTransform(self.root, self.getName("%s_npo" % oName,
oSide), t)
npos.append(npo)
ctl = self.addCtl(
npo,
self.getName("{}_{}".format(oName, self.ctlName), oSide),
t,
color,
o_icon,
w=wd * distSize,
d=wd * distSize,
ro=datatypes.Vector(1.57079633, 0, 0),
po=datatypes.Vector(0, 0, .07 * distSize),
)
ctls.append(ctl)
ymt_util.setKeyableAttributesDontLockVisibility(ctl, params + oPar)
upv = addTransform(ctl, self.getName("%s_upv" % oName, oSide), t)
upv.attr("tz").set(self.FRONT_OFFSET)
upvs.append(upv)
self.addToSubGroup(ctl, self.primaryControllersGroupName)
pm.progressWindow(e=True, endProgress=True)
return npos, ctls, upvs
def addObjects(self):
"""Add all the objects needed to create the component."""
self.WIP = self.options["mode"]
self.normal = self.getNormalFromPos(self.guide.apos)
self.length0 = vector.getDistance(self.guide.apos[0],
self.guide.apos[1])
self.length1 = vector.getDistance(self.guide.apos[1],
self.guide.apos[2])
self.length2 = vector.getDistance(self.guide.apos[2],
self.guide.apos[3])
# 1 bone chain for upv ref
self.legChainUpvRef = primitive.add2DChain(
self.root, self.getName("legUpvRef%s_jnt"),
[self.guide.apos[0], self.guide.apos[2]], self.normal, False,
self.WIP)
self.legChainUpvRef[1].setAttr(
"jointOrientZ",
self.legChainUpvRef[1].getAttr("jointOrientZ") * -1)
# extra neutral pose
t = transform.getTransformFromPos(self.guide.apos[0])
self.root_npo = primitive.addTransform(self.root,
self.getName("root_npo"), t)
self.root_ctl = self.addCtl(self.root_npo,
"root_ctl",
t,
self.color_fk,
"circle",
w=self.length0 / 6,
tp=self.parentCtlTag)
# FK Controlers -----------------------------------
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1], self.normal,
"xz", self.negate)
self.fk0_npo = primitive.addTransform(self.root_ctl,
self.getName("fk0_npo"), t)
self.fk0_ctl = self.addCtl(self.fk0_npo,
"fk0_ctl",
t,
self.color_fk,
"cube",
w=self.length0,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(
.5 * self.length0 * self.n_factor, 0,
0),
tp=self.root_ctl)
attribute.setKeyableAttributes(
self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"])
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[2], self.normal,
"xz", self.negate)
self.fk1_npo = primitive.addTransform(self.fk0_ctl,
self.getName("fk1_npo"), t)
self.fk1_ctl = self.addCtl(self.fk1_npo,
"fk1_ctl",
t,
self.color_fk,
"cube",
w=self.length1,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(
.5 * self.length1 * self.n_factor, 0,
0),
tp=self.fk0_ctl)
attribute.setKeyableAttributes(
self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"])
t = transform.getTransformLookingAt(self.guide.apos[2],
self.guide.apos[3], self.normal,
"xz", self.negate)
self.fk2_npo = primitive.addTransform(self.fk1_ctl,
self.getName("fk2_npo"), t)
self.fk2_ctl = self.addCtl(self.fk2_npo,
"fk2_ctl",
t,
self.color_fk,
"cube",
w=self.length2,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(
.5 * self.length2 * self.n_factor, 0,
0),
tp=self.fk1_ctl)
attribute.setKeyableAttributes(self.fk2_ctl)
self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl]
for x in self.fk_ctl:
attribute.setInvertMirror(x, ["tx", "ty", "tz"])
# IK Controlers -----------------------------------
self.ik_cns = primitive.addTransformFromPos(self.root_ctl,
self.getName("ik_cns"),
self.guide.pos["ankle"])
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
transform.getTransformFromPos(
self.guide.pos["ankle"]),
self.color_ik,
"null",
w=self.size * .12,
tp=self.root_ctl)
attribute.setInvertMirror(self.ikcns_ctl, ["tx"])
m = transform.getTransformLookingAt(self.guide.pos["ankle"],
self.guide.pos["eff"], self.x_axis,
"zx", False)
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
transform.getTransformFromPos(
self.guide.pos["ankle"]),
self.color_ik,
"cube",
w=self.size * .12,
h=self.size * .12,
d=self.size * .12,
tp=self.ikcns_ctl)
attribute.setKeyableAttributes(self.ik_ctl)
attribute.setRotOrder(self.ik_ctl, "XZY")
attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
# upv
v = self.guide.apos[2] - self.guide.apos[0]
v = self.normal ^ v
v.normalize()
v *= self.size * .5
v += self.guide.apos[1]
self.upv_cns = primitive.addTransformFromPos(self.ik_ctl,
self.getName("upv_cns"),
v)
self.upv_ctl = self.addCtl(self.upv_cns,
"upv_ctl",
transform.getTransform(self.upv_cns),
self.color_ik,
"diamond",
w=self.size * .12,
tp=self.root_ctl)
if self.settings["mirrorMid"]:
if self.negate:
self.upv_cns.rz.set(180)
self.upv_cns.sy.set(-1)
else:
attribute.setInvertMirror(self.upv_ctl, ["tx"])
attribute.setKeyableAttributes(self.upv_ctl, self.t_params)
# References --------------------------------------
self.ik_ref = primitive.addTransform(
self.ik_ctl, self.getName("ik_ref"),
transform.getTransform(self.ik_ctl))
self.fk_ref = primitive.addTransform(
self.fk_ctl[2], self.getName("fk_ref"),
transform.getTransform(self.ik_ctl))
# Chain --------------------------------------------
# The outputs of the ikfk2bone solver
self.bone0 = primitive.addLocator(
self.root_ctl, self.getName("0_bone"),
transform.getTransform(self.fk_ctl[0]))
self.bone0_shp = self.bone0.getShape()
self.bone0_shp.setAttr("localPositionX", self.n_factor * .5)
self.bone0_shp.setAttr("localScale", .5, 0, 0)
self.bone0.setAttr("sx", self.length0)
self.bone0.setAttr("visibility", False)
self.bone1 = primitive.addLocator(
self.root_ctl, self.getName("1_bone"),
transform.getTransform(self.fk_ctl[1]))
self.bone1_shp = self.bone1.getShape()
self.bone1_shp.setAttr("localPositionX", self.n_factor * .5)
self.bone1_shp.setAttr("localScale", .5, 0, 0)
self.bone1.setAttr("sx", self.length1)
self.bone1.setAttr("visibility", False)
tA = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1], self.normal,
"xz", self.negate)
tA = transform.setMatrixPosition(tA, self.guide.apos[1])
tB = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[2], self.normal,
"xz", self.negate)
t = transform.getInterpolateTransformMatrix(tA, tB)
self.ctrn_loc = primitive.addTransform(self.root,
self.getName("ctrn_loc"), t)
self.eff_loc = primitive.addTransformFromPos(self.root_ctl,
self.getName("eff_loc"),
self.guide.apos[2])
# tws_ref
t = transform.getRotationFromAxis(datatypes.Vector(0, -1, 0),
self.normal, "xz", self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["ankle"])
self.tws_ref = primitive.addTransform(self.eff_loc,
self.getName("tws_ref"), t)
# Mid Controler ------------------------------------
t = transform.getTransform(self.ctrn_loc)
self.mid_cns = primitive.addTransform(self.ctrn_loc,
self.getName("mid_cns"), t)
self.mid_ctl = self.addCtl(self.mid_cns,
"mid_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.root_ctl)
if self.settings["mirrorMid"]:
if self.negate:
self.mid_cns.rz.set(180)
self.mid_cns.sz.set(-1)
else:
attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"])
attribute.setKeyableAttributes(self.mid_ctl, self.t_params)
# Twist references ---------------------------------
x = datatypes.Vector(0, -1, 0)
x = x * transform.getTransform(self.eff_loc)
z = datatypes.Vector(self.normal.x, self.normal.y, self.normal.z)
z = z * transform.getTransform(self.eff_loc)
m = transform.getRotationFromAxis(x, z, "xz", self.negate)
m = transform.setMatrixPosition(m,
transform.getTranslation(self.ik_ctl))
self.tws0_loc = primitive.addTransform(
self.root_ctl, self.getName("tws0_loc"),
transform.getTransform(self.fk_ctl[0]))
self.tws0_rot = primitive.addTransform(
self.tws0_loc, self.getName("tws0_rot"),
transform.getTransform(self.fk_ctl[0]))
self.tws1_loc = primitive.addTransform(
self.ctrn_loc, self.getName("tws1_loc"),
transform.getTransform(self.ctrn_loc))
self.tws1_rot = primitive.addTransform(
self.tws1_loc, self.getName("tws1_rot"),
transform.getTransform(self.ctrn_loc))
self.tws1A_npo = primitive.addTransform(self.mid_ctl,
self.getName("tws1A_npo"), tA)
self.tws1A_loc = primitive.addTransform(self.tws1A_npo,
self.getName("tws1A_loc"), tA)
self.tws1B_npo = primitive.addTransform(self.mid_ctl,
self.getName("tws1B_npo"), tB)
self.tws1B_loc = primitive.addTransform(self.tws1B_npo,
self.getName("tws1B_loc"), tB)
self.tws2_npo = primitive.addTransform(
self.root, self.getName("tws2_npo"),
transform.getTransform(self.fk_ctl[2]))
self.tws2_loc = primitive.addTransform(
self.tws2_npo, self.getName("tws2_loc"),
transform.getTransform(self.fk_ctl[2]))
self.tws2_rot = primitive.addTransform(
self.tws2_npo, self.getName("tws2_rot"),
transform.getTransform(self.fk_ctl[2]))
# Roll twist chain ---------------------------------
# Arm
self.uplegChainPos = []
ii = 1.0 / (self.settings["div0"] + 1)
i = 0.0
for p in range(self.settings["div0"] + 2):
self.uplegChainPos.append(
vector.linearlyInterpolate(self.guide.pos["root"],
self.guide.pos["knee"],
blend=i))
i = i + ii
self.uplegTwistChain = primitive.add2DChain(
self.root, self.getName("uplegTwist%s_jnt"), self.uplegChainPos,
self.normal, False, self.WIP)
# Forearm
self.lowlegChainPos = []
ii = 1.0 / (self.settings["div1"] + 1)
i = 0.0
for p in range(self.settings["div1"] + 2):
self.lowlegChainPos.append(
vector.linearlyInterpolate(self.guide.pos["knee"],
self.guide.pos["ankle"],
blend=i))
i = i + ii
self.lowlegTwistChain = primitive.add2DChain(
self.root, self.getName("lowlegTwist%s_jnt"), self.lowlegChainPos,
self.normal, False, self.WIP)
pm.parent(self.lowlegTwistChain[0], self.mid_ctl)
# Hand Aux chain and nonroll
self.auxChainPos = []
ii = .5
i = 0.0
for p in range(3):
self.auxChainPos.append(
vector.linearlyInterpolate(self.guide.pos["ankle"],
self.guide.pos["eff"],
blend=i))
i = i + ii
t = self.root.getMatrix(worldSpace=True)
self.aux_npo = primitive.addTransform(self.root,
self.getName("aux_npo"), t)
self.auxTwistChain = primitive.add2DChain(
self.aux_npo, self.getName("auxTwist%s_jnt"),
self.lowlegChainPos[:3], self.normal, False, self.WIP)
# Non Roll join ref ---------------------------------
self.uplegRollRef = primitive.add2DChain(
self.root, self.getName("uplegRollRef%s_jnt"),
self.uplegChainPos[:2], self.normal, False, self.WIP)
self.lowlegRollRef = primitive.add2DChain(
self.aux_npo, self.getName("lowlegRollRef%s_jnt"),
self.lowlegChainPos[:2], self.normal, False, self.WIP)
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for the
# elbow. + 2 for knee angle control
self.divisions = self.settings["div0"] + self.settings["div1"] + 4
self.div_cns = []
for i in range(self.divisions):
div_cns = primitive.addTransform(self.root_ctl,
self.getName("div%s_loc" % i))
self.div_cns.append(div_cns)
self.jnt_pos.append([div_cns, i])
# End reference ------------------------------------
# To help the deformation on the ankle
self.end_ref = primitive.addTransform(self.eff_loc,
self.getName("end_ref"), m)
for a in "xyz":
self.end_ref.attr("s%s" % a).set(1.0)
if self.negate:
self.end_ref.attr("ry").set(-180.0)
self.jnt_pos.append([self.end_ref, 'end'])
# Tangent controls
t = transform.getInterpolateTransformMatrix(self.fk_ctl[0],
self.tws1A_npo, .5)
self.uplegTangentA_loc = primitive.addTransform(
self.root_ctl, self.getName("uplegTangentA_loc"),
self.fk_ctl[0].getMatrix(worldSpace=True))
self.uplegTangentA_npo = primitive.addTransform(
self.uplegTangentA_loc, self.getName("uplegTangentA_npo"), t)
self.uplegTangentA_ctl = self.addCtl(self.uplegTangentA_npo,
"uplegTangentA_ctl",
t,
self.color_ik,
"circle",
w=self.size * .2,
ro=datatypes.Vector(
0, 0, 1.570796),
tp=self.mid_ctl)
if self.negate:
self.uplegTangentA_npo.rz.set(180)
self.uplegTangentA_npo.sz.set(-1)
attribute.setKeyableAttributes(self.uplegTangentA_ctl, self.t_params)
t = transform.getInterpolateTransformMatrix(self.fk_ctl[0],
self.tws1A_npo, .9)
self.uplegTangentB_npo = primitive.addTransform(
self.tws1A_loc, self.getName("uplegTangentB_npo"), t)
self.uplegTangentB_ctl = self.addCtl(self.uplegTangentB_npo,
"uplegTangentB_ctl",
t,
self.color_ik,
"circle",
w=self.size * .1,
ro=datatypes.Vector(
0, 0, 1.570796),
tp=self.mid_ctl)
if self.negate:
self.uplegTangentB_npo.rz.set(180)
self.uplegTangentB_npo.sz.set(-1)
attribute.setKeyableAttributes(self.uplegTangentB_ctl, self.t_params)
tC = self.tws1B_npo.getMatrix(worldSpace=True)
tC = transform.setMatrixPosition(tC, self.guide.apos[2])
t = transform.getInterpolateTransformMatrix(self.tws1B_npo, tC, .1)
self.lowlegTangentA_npo = primitive.addTransform(
self.tws1B_loc, self.getName("lowlegTangentA_npo"), t)
self.lowlegTangentA_ctl = self.addCtl(self.lowlegTangentA_npo,
"lowlegTangentA_ctl",
t,
self.color_ik,
"circle",
w=self.size * .1,
ro=datatypes.Vector(
0, 0, 1.570796),
tp=self.mid_ctl)
if self.negate:
self.lowlegTangentA_npo.rz.set(180)
self.lowlegTangentA_npo.sz.set(-1)
attribute.setKeyableAttributes(self.lowlegTangentA_ctl, self.t_params)
t = transform.getInterpolateTransformMatrix(self.tws1B_npo, tC, .5)
self.lowlegTangentB_loc = primitive.addTransform(
self.root, self.getName("lowlegTangentB_loc"), tC)
self.lowlegTangentB_npo = primitive.addTransform(
self.lowlegTangentB_loc, self.getName("lowlegTangentB_npo"), t)
self.lowlegTangentB_ctl = self.addCtl(self.lowlegTangentB_npo,
"lowlegTangentB_ctl",
t,
self.color_ik,
"circle",
w=self.size * .2,
ro=datatypes.Vector(
0, 0, 1.570796),
tp=self.mid_ctl)
if self.negate:
self.lowlegTangentB_npo.rz.set(180)
self.lowlegTangentB_npo.sz.set(-1)
attribute.setKeyableAttributes(self.lowlegTangentB_ctl, self.t_params)
t = self.mid_ctl.getMatrix(worldSpace=True)
self.kneeTangent_npo = primitive.addTransform(
self.mid_ctl, self.getName("kneeTangent_npo"), t)
self.kneeTangent_ctl = self.addCtl(self.kneeTangent_npo,
"kneeTangent_ctl",
t,
self.color_fk,
"circle",
w=self.size * .25,
ro=datatypes.Vector(0, 0, 1.570796),
tp=self.mid_ctl)
if self.negate:
self.kneeTangent_npo.rz.set(180)
self.kneeTangent_npo.sz.set(-1)
attribute.setKeyableAttributes(self.kneeTangent_ctl, self.t_params)
# match IK FK references
self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], self.root,
"matchFk0_npo", False)
self.match_fk0 = self.add_match_ref(self.fk_ctl[0], self.match_fk0_off,
"fk0_mth")
self.match_fk1_off = self.add_match_ref(self.fk_ctl[2], self.root,
"matchFk1_npo", False)
self.match_fk1 = self.add_match_ref(self.fk_ctl[1], self.match_fk1_off,
"fk1_mth")
self.match_fk2 = self.add_match_ref(self.fk_ctl[2], self.ik_ctl,
"fk2_mth")
self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth")
self.match_ikUpv = self.add_match_ref(self.upv_ctl, self.fk0_ctl,
"upv_mth")
# add visual reference
self.line_ref = icon.connection_display_curve(
self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def addOperators(self):
"""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.
"""
# Visibilities -------------------------------------
if self.isFkIk:
# fk
fkvis_node = node.createReverseNode(self.blend_att)
for fk_ctl in self.fk_ctl:
for shp in fk_ctl.getShapes():
pm.connectAttr(fkvis_node + ".outputX",
shp.attr("visibility"))
# ik
for shp in self.upv_ctl.getShapes():
pm.connectAttr(self.blend_att, shp.attr("visibility"))
for shp in self.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"))
# FK Chain -----------------------------------------
if self.isFk:
for off, ref in zip(self.fk_off[1:], self.fk_ref):
applyop.gear_mulmatrix_op(
ref.worldMatrix, off.parentInverseMatrix, off, "rt")
# IK Chain -----------------------------------------
if self.isIk:
self.ikh = primitive.addIkHandle(
self.root, self.getName("ikh"), self.chain)
self.ikh.attr("visibility").set(False)
# Constraint and up vector
pm.pointConstraint(self.ik_ctl, self.ikh, maintainOffset=False)
pm.poleVectorConstraint(self.upv_ctl, self.ikh)
# TwistTest
o_list = [round(elem, 4) for elem
in transform.getTranslation(self.chain[1])] \
!= [round(elem, 4) for elem in self.guide.apos[1]]
if o_list:
add_nodeTwist = node.createAddNode(180.0, self.roll_att)
pm.connectAttr(add_nodeTwist + ".output",
self.ikh.attr("twist"))
else:
pm.connectAttr(self.roll_att, self.ikh.attr("twist"))
# Chain of deformers -------------------------------
for i, loc in enumerate(self.loc):
if self.settings["mode"] == 0: # fk only
pm.parentConstraint(self.fk_ctl[i], loc, maintainOffset=False)
pm.connectAttr(self.fk_ctl[i] + ".scale", loc + ".scale")
elif self.settings["mode"] == 1: # ik only
pm.parentConstraint(self.chain[i], loc, maintainOffset=False)
elif self.settings["mode"] == 2: # fk/ik
rev_node = node.createReverseNode(self.blend_att)
# orientation
cns = pm.parentConstraint(
self.fk_ctl[i], self.chain[i], loc, maintainOffset=False)
cns.interpType.set(0)
weight_att = pm.parentConstraint(
cns, query=True, weightAliasList=True)
pm.connectAttr(rev_node + ".outputX", weight_att[0])
pm.connectAttr(self.blend_att, weight_att[1])
# scaling
blend_node = pm.createNode("blendColors")
pm.connectAttr(self.chain[i].attr("scale"),
blend_node + ".color1")
pm.connectAttr(self.fk_ctl[i].attr("scale"),
blend_node + ".color2")
pm.connectAttr(self.blend_att, blend_node + ".blender")
pm.connectAttr(blend_node + ".output", loc + ".scale")
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.
"""
# Soft condition
soft_cond_node = node.createConditionNode(
self.soft_attr,
0.0001,
4,
0.0001,
self.soft_attr)
self.soft_attr_cond = soft_cond_node.outColorR
if self.settings["ikSolver"]:
self.ikSolver = "ikRPsolver"
else:
pm.mel.eval("ikSpringSolver;")
self.ikSolver = "ikSpringSolver"
# 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.upv_cns, mo=True)
# mid joints ================================================
for xjnt, midJ in zip(self.legBones[1:3],
[self.mid1_jnt, self.mid2_jnt]):
node.createPairBlend(None, xjnt, .5, 1, midJ)
pm.connectAttr(xjnt + ".translate", midJ + ".translate", f=True)
pm.parentConstraint(self.mid1_jnt, self.knee_lvl)
pm.parentConstraint(self.mid2_jnt, self.ankle_lvl)
# joint length multiply
multJnt1_node = node.createMulNode(self.boneALenght_attr,
self.boneALenghtMult_attr)
multJnt2_node = node.createMulNode(self.boneBLenght_attr,
self.boneBLenghtMult_attr)
multJnt3_node = node.createMulNode(self.boneCLenght_attr,
self.boneCLenghtMult_attr)
# # IK 3 bones ===============================================
self.ikHandle = primitive.addIkHandle(self.softblendLoc,
self.getName("ik3BonesHandle"),
self.chain3bones,
self.ikSolver,
self.upv_ctl)
# TwistTest
if [round(elem, 4)
for elem in transform.getTranslation(self.chain3bones[1])] \
!= [round(elem, 4) for elem in self.guide.apos[1]]:
add_nodeTwist = node.createAddNode(180.0, self.roll_att)
else:
add_nodeTwist = node.createAddNode(0, self.roll_att)
if self.negate:
mulVal = 1
else:
mulVal = -1
node.createMulNode(
add_nodeTwist + ".output", mulVal, self.ikHandle.attr("twist"))
# stable spring solver doble rotation
pm.pointConstraint(self.root_ctl, self.chain3bones[0])
# softIK 3 bones operators
applyop.aimCns(self.aim_tra,
self.ik_ref,
axis="zx",
wupType=4,
wupVector=[1, 0, 0],
wupObject=self.root_ctl,
maintainOffset=False)
plusTotalLength_node = node.createPlusMinusAverage1D(
[multJnt1_node.attr("outputX"),
multJnt2_node.attr("outputX"),
multJnt3_node.attr("outputX")])
subtract1_node = node.createPlusMinusAverage1D(
[plusTotalLength_node.attr("output1D"), self.soft_attr_cond], 2)
distance1_node = node.createDistNode(self.ik_ref, self.aim_tra)
div1_node = node.createDivNode(1.0, self.rig.global_ctl + ".sx")
mult1_node = node.createMulNode(distance1_node + ".distance",
div1_node + ".outputX")
subtract2_node = node.createPlusMinusAverage1D(
[mult1_node.attr("outputX"), subtract1_node.attr("output1D")], 2)
div2_node = node.createDivNode(subtract2_node + ".output1D",
self.soft_attr_cond)
mult2_node = node.createMulNode(-1, div2_node + ".outputX")
power_node = node.createPowNode(self.softSpeed_attr,
mult2_node + ".outputX")
mult3_node = node.createMulNode(self.soft_attr_cond,
power_node + ".outputX")
subtract3_node = node.createPlusMinusAverage1D(
[plusTotalLength_node.attr("output1D"),
mult3_node.attr("outputX")],
2)
cond1_node = node.createConditionNode(
self.soft_attr_cond,
0,
2,
subtract3_node + ".output1D",
plusTotalLength_node + ".output1D")
cond2_node = node.createConditionNode(mult1_node + ".outputX",
subtract1_node + ".output1D",
2, cond1_node + ".outColorR",
mult1_node + ".outputX")
pm.connectAttr(cond2_node + ".outColorR", self.wristSoftIK + ".tz")
# soft blend
pc_node = pm.pointConstraint(self.wristSoftIK,
self.ik_ref,
self.softblendLoc)
node.createReverseNode(self.stretch_attr,
pc_node + ".target[0].targetWeight")
pm.connectAttr(self.stretch_attr,
pc_node + ".target[1].targetWeight",
f=True)
# Stretch
distance2_node = node.createDistNode(self.softblendLoc,
self.wristSoftIK)
mult4_node = node.createMulNode(distance2_node + ".distance",
div1_node + ".outputX")
# bones
for i, mulNode in enumerate([multJnt1_node,
multJnt2_node,
multJnt3_node]):
div3_node = node.createDivNode(mulNode + ".outputX",
plusTotalLength_node + ".output1D")
mult5_node = node.createMulNode(mult4_node + ".outputX",
div3_node + ".outputX")
mult6_node = node.createMulNode(self.stretch_attr,
mult5_node + ".outputX")
node.createPlusMinusAverage1D(
[mulNode.attr("outputX"), mult6_node.attr("outputX")],
1,
self.chain3bones[i + 1] + ".tx")
# IK 2 bones ===============================================
self.ikHandle2 = primitive.addIkHandle(self.softblendLoc2,
self.getName("ik2BonesHandle"),
self.chain2bones,
self.ikSolver,
self.upv_ctl)
node.createMulNode(self.roll_att, mulVal, self.ikHandle2.attr("twist"))
# stable spring solver doble rotation
pm.pointConstraint(self.root_ctl, self.chain2bones[0])
parentc_node = pm.parentConstraint(
self.ik2b_ikCtl_ref, self.ik2b_bone_ref, self.ik2b_blend)
node.createReverseNode(self.fullIK_attr,
parentc_node + ".target[0].targetWeight")
pm.connectAttr(self.fullIK_attr,
parentc_node + ".target[1].targetWeight", f=True)
# softIK 2 bones operators
applyop.aimCns(self.aim_tra2,
self.ik2b_ik_ref,
axis="zx",
wupType=4,
wupVector=[1, 0, 0],
wupObject=self.root_ctl,
maintainOffset=False)
plusTotalLength_node = node.createPlusMinusAverage1D(
[multJnt1_node.attr("outputX"), multJnt2_node.attr("outputX")])
subtract1_node = node.createPlusMinusAverage1D(
[plusTotalLength_node.attr("output1D"), self.soft_attr_cond], 2)
distance1_node = node.createDistNode(self.ik2b_ik_ref, self.aim_tra2)
div1_node = node.createDivNode(1, self.rig.global_ctl + ".sx")
mult1_node = node.createMulNode(distance1_node + ".distance",
div1_node + ".outputX")
subtract2_node = node.createPlusMinusAverage1D(
[mult1_node.attr("outputX"), subtract1_node.attr("output1D")], 2)
div2_node = node.createDivNode(subtract2_node + ".output1D",
self.soft_attr_cond)
mult2_node = node.createMulNode(-1, div2_node + ".outputX")
power_node = node.createPowNode(self.softSpeed_attr,
mult2_node + ".outputX")
mult3_node = node.createMulNode(self.soft_attr_cond,
power_node + ".outputX")
subtract3_node = node.createPlusMinusAverage1D(
[plusTotalLength_node.attr("output1D"),
mult3_node.attr("outputX")],
2)
cond1_node = node.createConditionNode(
self.soft_attr_cond,
0,
2,
subtract3_node + ".output1D",
plusTotalLength_node + ".output1D")
cond2_node = node.createConditionNode(mult1_node + ".outputX",
subtract1_node + ".output1D",
2,
cond1_node + ".outColorR",
mult1_node + ".outputX")
pm.connectAttr(cond2_node + ".outColorR", self.ankleSoftIK + ".tz")
# soft blend
pc_node = pm.pointConstraint(self.ankleSoftIK,
self.ik2b_ik_ref,
self.softblendLoc2)
node.createReverseNode(self.stretch_attr,
pc_node + ".target[0].targetWeight")
pm.connectAttr(self.stretch_attr,
pc_node + ".target[1].targetWeight",
f=True)
# Stretch
distance2_node = node.createDistNode(self.softblendLoc2,
self.ankleSoftIK)
mult4_node = node.createMulNode(distance2_node + ".distance",
div1_node + ".outputX")
for i, mulNode in enumerate([multJnt1_node, multJnt2_node]):
div3_node = node.createDivNode(mulNode + ".outputX",
plusTotalLength_node + ".output1D")
mult5_node = node.createMulNode(mult4_node + ".outputX",
div3_node + ".outputX")
mult6_node = node.createMulNode(self.stretch_attr,
mult5_node + ".outputX")
node.createPlusMinusAverage1D([mulNode.attr("outputX"),
mult6_node.attr("outputX")],
1,
self.chain2bones[i + 1] + ".tx")
# IK/FK connections
for i, x in enumerate(self.fk_ctl):
pm.parentConstraint(x, self.legBonesFK[i], mo=True)
for i, x in enumerate([self.chain2bones[0], self.chain2bones[1]]):
pm.parentConstraint(x, self.legBonesIK[i], mo=True)
pm.pointConstraint(self.ik2b_ik_ref, self.legBonesIK[2])
applyop.aimCns(self.legBonesIK[2],
self.roll_ctl,
axis="xy",
wupType=4,
wupVector=[0, 1, 0],
wupObject=self.legBonesIK[1],
maintainOffset=False)
pm.connectAttr(self.chain3bones[-1].attr("tx"),
self.legBonesIK[-1].attr("tx"))
# foot twist roll
pm.orientConstraint(self.ik_ref, self.legBonesIK[-1], mo=True)
node.createMulNode(
-1, self.chain3bones[-1].attr("tx"), self.ik2b_ik_ref.attr("tx"))
for i, x in enumerate(self.legBones):
node.createPairBlend(
self.legBonesFK[i], self.legBonesIK[i], self.blend_att, 1, x)
# Twist references ----------------------------------------
self.ikhArmRef, self.tmpCrv = applyop.splineIK(
self.getName("legRollRef"),
self.rollRef,
parent=self.root,
cParent=self.legBones[0])
initRound = .001
multVal = 1
multTangent_node = node.createMulNode(self.roundnessKnee_att, multVal)
add_node = node.createAddNode(multTangent_node + ".outputX", initRound)
pm.connectAttr(add_node + ".output", self.tws1_rot.attr("sx"))
for x in ["translate"]:
pm.connectAttr(self.knee_ctl.attr(x), self.tws1_loc.attr(x))
for x in "xy":
pm.connectAttr(self.knee_ctl.attr("r" + x),
self.tws1_loc.attr("r" + x))
multTangent_node = node.createMulNode(self.roundnessAnkle_att, multVal)
add_node = node.createAddNode(multTangent_node + ".outputX", initRound)
pm.connectAttr(add_node + ".output", self.tws2_rot.attr("sx"))
for x in ["translate"]:
pm.connectAttr(self.ankle_ctl.attr(x), self.tws2_loc.attr(x))
for x in "xy":
pm.connectAttr(self.ankle_ctl.attr("r" + x),
self.tws2_loc.attr("r" + x))
# Volume -------------------------------------------
distA_node = node.createDistNode(self.tws0_loc, self.tws1_loc)
distB_node = node.createDistNode(self.tws1_loc, self.tws2_loc)
distC_node = node.createDistNode(self.tws2_loc, self.tws3_loc)
add_node = node.createAddNode(distA_node + ".distance",
distB_node + ".distance")
add_node2 = node.createAddNode(distC_node + ".distance",
add_node + ".output")
div_node = node.createDivNode(add_node2 + ".output",
self.root_ctl.attr("sx"))
# comp scaling
dm_node = node.createDecomposeMatrixNode(self.root.attr("worldMatrix"))
div_node2 = node.createDivNode(div_node + ".outputX",
dm_node + ".outputScaleX")
self.volDriver_att = div_node2 + ".outputX"
# Flip Offset ----------------------------------------
pm.connectAttr(self.ankleFlipOffset_att, self.tws2_loc.attr("rz"))
pm.connectAttr(self.kneeFlipOffset_att, self.tws1_loc.attr("rz"))
# 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 = 45
if i < (self.settings["div0"] + 1):
perc = i * .333 / (self.settings["div0"] + 1.0)
elif i < (self.settings["div0"] + self.settings["div1"] + 2):
perc = i * .333 / (self.settings["div0"] + 1.0)
else:
perc = (.5
+ (i - self.settings["div0"] - 3.0)
* .5
/ (self.settings["div1"] + 1.0))
if i < (self.settings["div0"] + 2):
perc = i * .333 / (self.settings["div0"] + 1.0)
elif i < (self.settings["div0"] + self.settings["div1"] + 3):
perc = (.333
+ (i - self.settings["div0"] - 1)
* .333
/ (self.settings["div1"] + 1.0))
else:
perc = (.666
+ (i
- self.settings["div1"]
- self.settings["div0"]
- 2.0)
* .333
/ (self.settings["div2"] + 1.0))
# we neet to offset the ankle and knee point to force the bone
# orientation to the nex bone span
if perc == .333:
perc = .3338
elif perc == .666:
perc = .6669
perc = max(.001, min(.999, perc))
# Roll
cts = [self.tws0_rot, self.tws1_rot, self.tws2_rot, self.tws3_rot]
o_node = applyop.gear_rollsplinekine_op(div_cns, cts, 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")
# Visibilities -------------------------------------
# fk
fkvis_node = node.createReverseNode(self.blend_att)
for ctrl in self.fk_ctl:
for shp in ctrl.getShapes():
pm.connectAttr(fkvis_node + ".outputX", shp.attr("visibility"))
# ik
for ctrl in [self.ik_ctl, self.roll_ctl, self.upv_ctl, self.line_ref]:
for shp in ctrl.getShapes():
pm.connectAttr(self.blend_att, shp.attr("visibility"))
# setup leg o_node scale compensate
pm.connectAttr(self.rig.global_ctl + ".scale", self.setup + ".scale")
# match IK/FK ref
pm.parentConstraint(self.legBones[0], self.match_fk0_off, mo=True)
pm.parentConstraint(self.legBones[1], self.match_fk1_off, mo=True)
pm.parentConstraint(self.legBones[2], self.match_fk2_off, mo=True)
return
def add2DChain(parent, name, positions, normal, negate=False, vis=True):
"""Create a 2D joint chain. Like Softimage 2D chain.
Warning:
This function will create un expected results if all the
positions are not in the same 2D plane.
Arguments:
parent (dagNode): The parent for the chain.
name (str): The node name.
positions(list of vectors): the positons to define the chain.
normal (vector): The normal vector to define the direction of
the chain.
negate (bool): If True will negate the direction of the chain
Returns;
list of dagNodes: The list containg all the joints of the chain
>>> self.rollRef = pri.add2DChain(
self.root,
self.getName("rollChain"),
self.guide.apos[:2],
self.normal,
self.negate)
"""
if "%s" not in name:
name += "%s"
transforms = transform.getChainTransform(positions, normal, negate)
t = transform.setMatrixPosition(transforms[-1], positions[-1])
transforms.append(t)
chain = []
for i, t in enumerate(transforms):
node = addJoint(parent, name % i, t, vis)
chain.append(node)
parent = node
# moving rotation value to joint orient
for i, jnt in enumerate(chain):
if i == 0:
jnt.setAttr("jointOrient", jnt.getAttr("rotate"))
jnt.setAttr("rotate", 0, 0, 0)
elif i == len(chain) - 1:
jnt.setAttr("jointOrient", 0, 0, 0)
jnt.setAttr("rotate", 0, 0, 0)
else:
# This will fail if chain is not always oriented the same
# way (like X chain)
v0 = positions[i] - positions[i - 1]
v1 = positions[i + 1] - positions[i]
angle = datatypes.degrees(v0.angle(v1))
jnt.setAttr("rotate", 0, 0, 0)
jnt.setAttr("jointOrient", 0, 0, angle)
# check if we have to negate Z angle by comparing the guide
# position and the resulting position.
if i >= 1:
# round the position values to 6 decimals precission
# TODO: test with less precision and new check after apply
# Ik solver
if ([round(elem, 4) for elem in transform.getTranslation(jnt)] !=
[round(elem, 4) for elem in positions[i]]):
jp = jnt.getParent()
# Aviod intermediate e.g. `transform3` groups that can appear
# between joints due to basic moving around.
while jp.type() == "transform":
jp = jp.getParent()
jp.setAttr("jointOrient", 0, 0,
jp.attr("jointOrient").get()[2] * -1)
jnt.setAttr("radius", 1.5)
return chain
