def addControllers(self):
axis = "zy"
inPos = self.guide.apos[-5]
outPos = self.guide.apos[-4]
upPos = self.guide.apos[-3]
lowPos = self.guide.apos[-2]
frontPos = self.guide.apos[-1]
self.bboxCenter = meshNavigation.bboxCenter(self.guide.eyeMesh)
averagePosition = ((upPos + lowPos + inPos + outPos) / 4)
# normalPos = outPos
normalVec = upPos - lowPos
if self.negate:
pass
# normalVec = normalVec * -1.0
t = transform.getTransformLookingAt(
self.root.getTranslation(space="world"),
# self.bboxCenter,
frontPos,
normalVec,
axis=axis,
# negate=self.negate
)
# averagePosition,
t_arrow = setMatrixPosition(t, self.bboxCenter)
scl = [1, 1, 1]
t = transform.setMatrixScale(t, scl)
bt = transform.setMatrixPosition(t, self.bboxCenter)
self.eyeTargets_root = addTransform(self.root, self.getName("targets"), t)
self.jnt_root = addTransform(self.root, self.getName("joints"), bt)
# self.jnt_root = primitive.addTransformFromPos(self.root, self.getName("joints"), pos=self.bboxCenter)
# TODO: implement later
# if deformers_group:
# deformers_group = pm.PyNode(deformers_group)
# pm.parentConstraint(self.root, jnt_root, mo=True)
# pm.scaleConstraint(self.root, jnt_root, mo=True)
# deformers_group.addChild(jnt_root)
if self.negate:
scl = [-1, 1, 1]
t = transform.setMatrixScale(t, scl)
self.addOverControllers(t)
self.addLookAtControlers(t, t_arrow)
self.addAimControllers(t)
self.addCurveControllers(t)
self.addCurveJoints(t)
self.addWires()
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.WIP = self.options["mode"]
if self.negate and self.settings["overrideNegate"]:
self.negate = False
self.n_factor = 1
if self.settings["overrideNegate"]:
self.mirror_conf = [0, 0, 1, 1, 1, 0, 0, 0, 0]
else:
self.mirror_conf = [0, 0, 0, 0, 0, 0, 0, 0, 0]
# FK controllers ------------------------------------
self.fk_npo = []
self.fk_ctl = []
t = self.guide.tra["root"]
parent = self.root
tOld = False
fk_ctl = None
self.previusTag = self.parentCtlTag
for i, t in enumerate(
transform.getChainTransform(self.guide.apos, self.normal,
self.negate)):
dist = vector.getDistance(self.guide.apos[i],
self.guide.apos[i + 1])
if self.settings["neutralpose"] or not tOld:
tnpo = t
else:
tnpo = transform.setMatrixPosition(
tOld, transform.getPositionFromMatrix(t))
fk_npo = primitive.addTransform(parent,
self.getName("fk%s_npo" % i), tnpo)
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=dist,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(dist * .5 * self.n_factor,
0, 0),
tp=self.previusTag,
mirrorConf=self.mirror_conf)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
tOld = t
self.previusTag = fk_ctl
parent = fk_ctl
if self.settings["addJoints"]:
jnt_name = "_".join([self.name, str(i + 1).zfill(2)])
self.jnt_pos.append([fk_ctl, jnt_name, None, False])
def addObjects(self):
"""Add all the objects needed to create the component."""
# self.normal = self.guide.blades["blade"].z * -1
# self.binormal = self.guide.blades["blade"].x
self.WIP = self.options["mode"]
if self.negate and self.settings["overrideNegate"]:
self.negate = False
self.n_factor = 1
if self.settings["overrideNegate"]:
self.mirror_conf = [0, 0, 1, 1, 1, 0, 0, 0, 0]
else:
self.mirror_conf = [0, 0, 0, 0, 0, 0, 0, 0, 0]
# FK controllers ------------------------------------
self.fk_npo = []
self.fk_ctl = []
t = self.guide.tra["root"]
parent = self.root
tOld = False
fk_ctl = None
self.previusTag = self.parentCtlTag
# transforms = []
# for i in range(len(self.guide.atra) - 1):
# transforms.append(transform.getTransform(self.guide.atra[i]))
for i, t in enumerate(self.guide.atra[:-1]):
# dist = vector.getDistance(self.guide.apos[i],
# self.guide.apos[i + 1])
t = transform.setMatrixScale(t)
if self.settings["neutralpose"] or not tOld:
tnpo = t
else:
tnpo = transform.setMatrixPosition(
tOld, transform.getPositionFromMatrix(t))
fk_npo = primitive.addTransform(parent,
self.getName("fk%s_npo" % i), tnpo)
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % i,
t,
self.color_fk,
"circle",
w=self.size * .4,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=self.previusTag,
mirrorConf=self.mirror_conf)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
tOld = t
self.previusTag = fk_ctl
parent = fk_ctl
if self.settings["addJoints"]:
self.jnt_pos.append([fk_ctl, i, None, False])
def getRepositionMatrix(node_matrix, orig_ref_matrix, mr_orig_ref_matrix,
closestVerts):
"""Get the delta matrix from the original position and multiply by the
new vert position. Add the rotations from the face normals.
Args:
node_matrix (pm.dt.Matrix): matrix of the guide
orig_ref_matrix (pm.dt.Matrix): matrix from the original vert position
closestVerts (str): name of the closest vert
Returns:
mmatrix: matrix of the new offset position, worldSpace
"""
current_vert = pm.PyNode(closestVerts[0])
mr_current_vert = pm.PyNode(closestVerts[1])
current_length = vector.getDistance(current_vert.getPosition("world"),
mr_current_vert.getPosition("world"))
orig_length = vector.getDistance(orig_ref_matrix.translate,
mr_orig_ref_matrix.translate)
orig_center = vector.linearlyInterpolate(orig_ref_matrix.translate,
mr_orig_ref_matrix.translate)
orig_center_matrix = pm.dt.Matrix()
# orig_center_matrix.setTranslation(orig_center, pm.dt.Space.kWorld)
orig_center_matrix = transform.setMatrixPosition(orig_center_matrix,
orig_center)
current_center = vector.linearlyInterpolate(
current_vert.getPosition("world"),
mr_current_vert.getPosition("world"))
length_percentage = 1
if current_length != 0 or orig_length != 0:
length_percentage = current_length / orig_length
# refPosition_matrix = pm.dt.TransformationMatrix()
refPosition_matrix = pm.dt.Matrix()
# refPosition_matrix.setTranslation(current_center, pm.dt.Space.kWorld)
refPosition_matrix = transform.setMatrixPosition(refPosition_matrix,
current_center)
deltaMatrix = node_matrix * orig_center_matrix.inverse()
deltaMatrix = deltaMatrix * length_percentage
deltaMatrix = transform.setMatrixScale(deltaMatrix)
refPosition_matrix = deltaMatrix * refPosition_matrix
return refPosition_matrix
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis="yx",
negate=self.negate)
self.ctl_npo = primitive.addTransform(
self.root, self.getName("ctl_npo"), t)
self.ctl = self.addCtl(self.ctl_npo,
"base_ctl",
t,
self.color_ik,
"square",
w=1.0,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.ctl, self.tr_params)
self.ref_base = primitive.addTransform(
self.ctl, self.getName("ref_base"), t)
t = transform.setMatrixPosition(t, self.guide.apos[1])
self.ik_cns = primitive.addTransform(
self.root, self.getName("ik_cns"), t)
self.tip_npo = primitive.addTransform(
self.ik_cns, self.getName("tip_npo"), t)
self.tip_ctl = self.addCtl(self.tip_npo,
"tip_ctl",
t,
self.color_ik,
"square",
w=1.0,
tp=self.ctl)
attribute.setKeyableAttributes(self.tip_ctl, self.tr_params)
self.ref_tip = primitive.addTransform(
self.tip_ctl, self.getName("ref_tip"), t)
self.div_cns = []
for i in range(self.settings["div"]):
div_cns = primitive.addTransform(self.root,
self.getName("div%s_loc" % i))
self.div_cns.append(div_cns)
self.jnt_pos.append([div_cns, i])
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis="yx",
negate=self.negate)
self.ctl_npo = primitive.addTransform(self.root,
self.getName("ctl_npo"), t)
self.ctl = self.addCtl(self.ctl_npo,
"base_ctl",
t,
self.color_ik,
"square",
w=1.0,
tp=self.parentCtlTag)
self.ref_base = primitive.addTransform(self.ctl,
self.getName("ref_base"), t)
t = transform.setMatrixPosition(t, self.guide.apos[1])
self.ik_cns = primitive.addTransform(self.ctl, self.getName("ik_cns"),
t)
self.squash_npo = primitive.addTransform(self.ik_cns,
self.getName("squash_npo"), t)
self.squash_ctl = self.addCtl(self.squash_npo,
"squash_ctl",
t,
self.color_ik,
"crossarrow",
w=1.0,
ro=dt.Vector(1.5708, 0, 0),
tp=self.ctl)
attribute.setKeyableAttributes(self.squash_ctl, ["tx", "ty", "tz"])
self.ref_squash = primitive.addTransform(self.squash_ctl,
self.getName("ref_squash"), t)
self.div_cns = []
div_cns = primitive.addTransform(self.root, self.getName("div0_loc"))
self.div_cns.append(div_cns)
self.jnt_pos.append([div_cns, 0, None, False])
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.length0 = vector.getDistance(self.guide.apos[0],
self.guide.apos[1])
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis="xy",
negate=self.negate)
self.npo = primitive.addTransform(self.root, self.getName("npo"), t)
self.ctl = self.addCtl(
self.npo,
"ctl",
t,
self.color_fk,
"cube",
w=self.length0,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0),
tp=self.parentCtlTag)
self.mtx = primitive.addTransform(self.npo, self.getName("mtx"), t)
t1 = transform.setMatrixPosition(t, self.guide.apos[1])
t2 = transform.getInterpolateTransformMatrix(t, t1, blend=0.98)
self.loc = primitive.addTransform(self.mtx, self.getName("loc"), t2)
self.end = primitive.addTransform(self.ctl, self.getName("end"), t1)
self.jnt_pos.append([self.mtx, "root"])
self.jnt_pos.append([self.loc, 'end'])
attribute.setKeyableAttributes(self.ctl)
attribute.setInvertMirror(self.ctl, ["tx", "ty", "tz"])
def _add_fk(self, i, parent, t, tOld):
dist = vec.getDistance(self.guide.apos[i], self.guide.apos[i + 1])
if self.settings["neutralpose"] or not tOld:
tnpo = t
else:
tnpo = tra.setMatrixPosition(tOld, tra.getPositionFromMatrix(t))
fk_npo = pri.addTransform(parent, self.getName("fk%s_npo" % i), tnpo)
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=dist,
h=self.size * .1,
d=self.size * .1,
po=dt.Vector(dist * .5 * self.n_factor, 0, 0))
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
return fk_ctl
def _addControlJoints(self,
crv,
name,
rope_root,
rope,
rope_upv,
skipHeadAndTail=False):
lvlType = "transform"
cvs = crv.getCVs(space="world")
local_cvs = crv.getCVs(space="object")
controls = []
t = getTransform(self.root)
icon_shape = "sphere"
color = 4
wd = .3
po = self.offset * 0.3
pm.progressWindow(title='Creating Upper Joints',
progress=0,
max=len(cvs))
for i, cv in enumerate(cvs):
if skipHeadAndTail and i == 0:
continue
if skipHeadAndTail and (i == len(cvs) - 1):
continue
pm.progressWindow(e=True,
step=1,
status='\nCreating Joint for %s' % cv)
upv = addTransform(
rope_root,
self.getName("{}LipRope_upv{}".format(name,
str(i).zfill(3))))
npo = addTransform(
rope_root,
self.getName("{}LipRope_npo{}".format(name,
str(i).zfill(3))))
oParam, oLength = curve.getCurveParamAtPosition(rope, local_cvs[i])
uLength = curve.findLenghtFromParam(rope, oParam)
u = uLength / oLength
cns = applyPathCnsLocal(upv, rope_upv, u)
cns = applyPathCnsLocal(npo, rope, u)
pm.connectAttr(upv.attr("worldMatrix[0]"),
cns.attr("worldUpMatrix"))
ctl_name = self.getName("%s_crvdetail%s_%s" %
(name, i, self.ctlName))
self.thickness = 0.0
if i == 0:
# we know the curv starts from right to left
offset = [
cv[0] + self.thickness, cv[1], cv[2] + self.thickness
]
elif i == len(cvs) - 1:
offset = [
cv[0] - self.thickness, cv[1], cv[2] + self.thickness
]
else:
offset = [cv[0], cv[1] - self.thickness, cv[2]]
# offset = [cv[0], cv[1], cv[2] - self.FRONT_OFFSET]
m = getTransform(npo)
x = datatypes.Vector(m[0][0], m[0][1], m[0][2])
y = datatypes.Vector(m[1][0], m[1][1], m[1][2])
z = datatypes.Vector(m[2][0], m[2][1], m[2][2])
rot = [x, y, z]
xform = setMatrixPosition(t, offset)
xform = setMatrixRotation(xform, rot)
# xform = setMatrixPosition(t, cv)
npo_name = self.getName("{}LipRope_jnt{}_npo".format(name, str(i)))
npo = addTransform(npo, npo_name, xform)
ctl = self.addCtl(npo,
ctl_name,
xform,
color,
icon_shape,
w=wd,
d=wd,
ro=datatypes.Vector(1.57079633, 0, 0),
po=po)
controls.append(ctl)
# getting joint parent
# jnt = rigbits.addJnt(npo, noReplace=True, parent=self.j_parent)
self.jnt_pos.append([ctl, "{}{}".format(name, i)])
self.addToSubGroup(ctl, self.detailControllersGroupName)
pm.progressWindow(e=True, endProgress=True)
return controls
def addObjects(self):
"""Add all the objects needed to create the component."""
self.WIP = self.options["mode"]
self.up_axis = pm.upAxis(q=True, axis=True)
self.blade_normal = self.guide.blades["blade"].z * -1
self.blade_binormal = self.guide.blades["blade"].x
self.normal = self.getNormalFromPos(self.guide.apos)
self.binormal = self.getBiNormalFromPos(self.guide.apos)
self.length0 = vector.getDistance(
self.guide.apos[0], self.guide.apos[1]
)
self.length1 = vector.getDistance(
self.guide.apos[1], self.guide.apos[2]
)
self.length2 = vector.getDistance(
self.guide.apos[2], self.guide.apos[3]
)
# 1 bone chain for upv ref
self.armChainUpvRef = primitive.add2DChain(
self.root,
self.getName("armUpvRef%s_jnt"),
[self.guide.apos[0], self.guide.apos[2]],
self.normal,
False,
self.WIP,
)
negateOri = self.armChainUpvRef[1].getAttr("jointOrientZ") * -1
self.armChainUpvRef[1].setAttr("jointOrientZ", negateOri)
# FK Controlers -----------------------------------
t = transform.getTransformLookingAt(
self.guide.apos[0],
self.guide.apos[1],
self.normal,
"xz",
self.negate,
)
if self.settings["FK_rest_T_Pose"]:
x = datatypes.Vector(1, 0, 0)
if self.negate:
z_dir = -1
else:
z_dir = 1
if self.up_axis == "y":
z = datatypes.Vector(0, z_dir, 0)
else:
z = datatypes.Vector(0, 0, z_dir)
t_npo = transform.getRotationFromAxis(x, z, "xz", False)
t_npo = transform.setMatrixPosition(t_npo, self.guide.apos[0])
else:
t_npo = t
self.fk0_npo = primitive.addTransform(
self.root, self.getName("fk0_npo"), t_npo
)
vec_po = datatypes.Vector(0.5 * self.length0 * self.n_factor, 0, 0)
self.fk0_ctl = self.addCtl(
self.fk0_npo,
"fk0_ctl",
t,
self.color_fk,
"cube",
w=self.length0,
h=self.size * 0.1,
d=self.size * 0.1,
po=vec_po,
tp=self.parentCtlTag,
)
attribute.setKeyableAttributes(
self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]
)
t = transform.getTransformLookingAt(
self.guide.apos[1],
self.guide.apos[2],
self.normal,
"xz",
self.negate,
)
if self.settings["FK_rest_T_Pose"]:
t_npo = transform.setMatrixPosition(
transform.getTransform(self.fk0_ctl), self.guide.apos[1]
)
else:
t_npo = t
self.fk1_npo = primitive.addTransform(
self.fk0_ctl, self.getName("fk1_npo"), t_npo
)
vec_po = datatypes.Vector(0.5 * self.length1 * self.n_factor, 0, 0)
self.fk1_ctl = self.addCtl(
self.fk1_npo,
"fk1_ctl",
t,
self.color_fk,
"cube",
w=self.length1,
h=self.size * 0.1,
d=self.size * 0.1,
po=vec_po,
tp=self.fk0_ctl,
)
attribute.setKeyableAttributes(
self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"]
)
if self.settings["use_blade"]:
t = transform.getTransformLookingAt(
self.guide.apos[2],
self.guide.apos[3],
self.blade_normal,
"x-z",
self.negate,
)
else:
t = transform.getTransformLookingAt(
self.guide.apos[2],
self.guide.apos[3],
self.normal,
"xz",
self.negate,
)
if self.settings["FK_rest_T_Pose"]:
t_npo = transform.setMatrixPosition(
transform.getTransform(self.fk1_ctl), self.guide.apos[2]
)
else:
t_npo = t
self.fk2_npo = primitive.addTransform(
self.fk1_ctl, self.getName("fk2_npo"), t_npo
)
vec_po = datatypes.Vector(0.5 * self.length2 * self.n_factor, 0, 0)
self.fk2_ctl = self.addCtl(
self.fk2_npo,
"fk2_ctl",
t,
self.color_fk,
"cube",
w=self.length2,
h=self.size * 0.1,
d=self.size * 0.1,
po=vec_po,
tp=self.fk1_ctl,
)
attribute.setKeyableAttributes(self.fk2_ctl)
self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl]
for x in self.fk_ctl:
attribute.setInvertMirror(x, ["tx", "ty", "tz"])
# IK upv ---------------------------------
# create tip point
self.tip_ref = primitive.addTransform(
self.armChainUpvRef[0],
self.getName("tip_ref"),
self.armChainUpvRef[0].getMatrix(worldSpace=True),
)
# create interpolate obj
self.interpolate_lvl = primitive.addTransform(
self.armChainUpvRef[0],
self.getName("int_lvl"),
self.armChainUpvRef[0].getMatrix(worldSpace=True),
)
# create roll npo and ctl
self.roll_ctl_npo = primitive.addTransform(
self.root,
self.getName("roll_ctl_npo"),
self.armChainUpvRef[0].getMatrix(worldSpace=True),
)
if self.negate:
off_x = -1.5708
else:
off_x = 1.5708
off_y = 1.5708
self.roll_ctl = self.addCtl(
self.roll_ctl_npo,
"roll_ctl",
transform.getTransform(self.roll_ctl_npo),
self.color_ik,
"compas",
w=self.size * 0.3,
ro=datatypes.Vector([off_x, off_y, 0]),
tp=self.parentCtlTag,
)
attribute.setKeyableAttributes(self.roll_ctl, ["rx"])
# create upv control
v = self.guide.apos[2] - self.guide.apos[0]
v = self.normal ^ v
v.normalize()
v *= self.size * 0.8
v += self.guide.apos[1]
self.upv_cns = primitive.addTransformFromPos(
self.root, self.getName("upv_cns"), v
)
self.upv_ctl = self.addCtl(
self.upv_cns,
"upv_ctl",
transform.getTransform(self.upv_cns),
self.color_ik,
"diamond",
w=self.size * 0.12,
tp=self.parentCtlTag,
)
if self.settings["mirrorMid"]:
if self.negate:
self.upv_cns.rz.set(180)
self.upv_cns.sy.set(-1)
else:
attribute.setInvertMirror(self.upv_ctl, ["tx"])
attribute.setKeyableAttributes(self.upv_ctl, self.t_params)
# IK Controlers -----------------------------------
self.ik_cns = primitive.addTransformFromPos(
self.root, self.getName("ik_cns"), self.guide.pos["wrist"]
)
t = transform.getTransformFromPos(self.guide.pos["wrist"])
self.ikcns_ctl = self.addCtl(
self.ik_cns,
"ikcns_ctl",
t,
self.color_ik,
"null",
w=self.size * 0.12,
tp=self.parentCtlTag,
)
attribute.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"])
if self.settings["use_blade"]:
normal = self.blade_normal
axis_ref1 = "xz"
axis_ref2 = "x-z"
else:
normal = self.normal
axis_ref1 = "x-y"
axis_ref2 = "xy"
if self.negate:
m = transform.getTransformLookingAt(
self.guide.pos["wrist"],
self.guide.pos["eff"],
normal,
axis_ref1,
True,
)
else:
m = transform.getTransformLookingAt(
self.guide.pos["wrist"],
self.guide.pos["eff"],
normal,
axis_ref2,
False,
)
self.ik_ctl = self.addCtl(
self.ikcns_ctl,
"ik_ctl",
m,
self.color_ik,
"cube",
w=self.size * 0.12,
h=self.size * 0.12,
d=self.size * 0.12,
tp=self.roll_ctl,
)
if self.settings["mirrorIK"]:
if self.negate:
self.ik_cns.sx.set(-1)
self.ik_ctl.ry.set(self.ik_ctl.ry.get() * -1)
self.ik_ctl.rz.set(self.ik_ctl.rz.get() * -1)
else:
attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
attribute.setKeyableAttributes(self.ik_ctl)
self.ik_ctl_ref = primitive.addTransform(
self.ik_ctl, self.getName("ikCtl_ref"), m
)
# IK rotation controls
if self.settings["ikTR"]:
self.ikRot_npo = primitive.addTransform(
self.root, self.getName("ikRot_npo"), m
)
self.ikRot_cns = primitive.addTransform(
self.ikRot_npo, self.getName("ikRot_cns"), m
)
self.ikRot_ctl = self.addCtl(
self.ikRot_cns,
"ikRot_ctl",
m,
self.color_ik,
"sphere",
w=self.size * 0.12,
tp=self.ik_ctl,
)
attribute.setKeyableAttributes(self.ikRot_ctl, self.r_params)
# References --------------------------------------
# Calculate again the transfor for the IK ref. This way align with FK
if self.settings["use_blade"]:
normal = self.blade_normal
axis_ref = "x-z"
else:
normal = self.normal
axis_ref = "xz"
trnIK_ref = transform.getTransformLookingAt(
self.guide.pos["wrist"],
self.guide.pos["eff"],
normal,
axis_ref,
self.negate,
)
self.ik_ref = primitive.addTransform(
self.ik_ctl_ref, self.getName("ik_ref"), trnIK_ref
)
self.fk_ref = primitive.addTransform(
self.fk_ctl[2], self.getName("fk_ref"), trnIK_ref
)
# Chain --------------------------------------------
# The outputs of the ikfk2bone solver
self.bone0 = primitive.addLocator(
self.root,
self.getName("0_bone"),
transform.getTransform(self.fk_ctl[0]),
)
self.bone0_shp = self.bone0.getShape()
self.bone0_shp.setAttr("localPositionX", self.n_factor * 0.5)
self.bone0_shp.setAttr("localScale", 0.5, 0, 0)
self.bone0.setAttr("sx", self.length0)
self.bone0.setAttr("visibility", False)
self.bone1 = primitive.addLocator(
self.root,
self.getName("1_bone"),
transform.getTransform(self.fk_ctl[1]),
)
self.bone1_shp = self.bone1.getShape()
self.bone1_shp.setAttr("localPositionX", self.n_factor * 0.5)
self.bone1_shp.setAttr("localScale", 0.5, 0, 0)
self.bone1.setAttr("sx", self.length1)
self.bone1.setAttr("visibility", False)
self.ctrn_loc = primitive.addTransformFromPos(
self.root, self.getName("ctrn_loc"), self.guide.apos[1]
)
self.eff_loc = primitive.addTransformFromPos(
self.root, self.getName("eff_loc"), self.guide.apos[2]
)
if self.settings["use_blade"]:
# set the offset rotation for the hand
self.off_t = transform.getTransformLookingAt(
self.guide.pos["wrist"],
self.guide.pos["eff"],
self.blade_normal,
axis="xy",
negate=self.negate,
)
self.eff_jnt_off = primitive.addTransform(
self.eff_loc, self.getName("eff_off"), self.off_t
)
# Mid Controler ------------------------------------
t = transform.getTransform(self.ctrn_loc)
self.mid_cns = primitive.addTransform(
self.ctrn_loc, self.getName("mid_cns"), t
)
self.mid_ctl = self.addCtl(
self.mid_cns,
"mid_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.2,
tp=self.parentCtlTag,
)
attribute.setKeyableAttributes(
self.mid_ctl,
params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"],
)
if self.settings["mirrorMid"]:
if self.negate:
self.mid_cns.rz.set(180)
self.mid_cns.sz.set(-1)
self.mid_ctl_twst_npo = primitive.addTransform(
self.mid_ctl, self.getName("mid_twst_npo"), t
)
self.mid_ctl_twst_ref = primitive.addTransform(
self.mid_ctl_twst_npo, self.getName("mid_twst_ref"), t
)
else:
self.mid_ctl_twst_ref = self.mid_ctl
attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"])
# Roll join ref
self.rollRef = primitive.add2DChain(
self.root,
self.getName("rollChain"),
self.guide.apos[:2],
self.normal,
self.negate,
)
for x in self.rollRef:
x.setAttr("visibility", False)
if self.settings["div0"]:
twst0_parent = self.rollRef[0]
else:
twst0_parent = self.root
self.tws0_loc = primitive.addTransform(
twst0_parent,
self.getName("tws0_loc"),
transform.getTransform(self.fk_ctl[0]),
)
self.tws0_rot = primitive.addTransform(
self.tws0_loc,
self.getName("tws0_rot"),
transform.getTransform(self.fk_ctl[0]),
)
self.tws1_npo = primitive.addTransform(
self.ctrn_loc,
self.getName("tws1_npo"),
transform.getTransform(self.ctrn_loc),
)
self.tws1_loc = primitive.addTransform(
self.tws1_npo,
self.getName("tws1_loc"),
transform.getTransform(self.ctrn_loc),
)
self.tws1_rot = primitive.addTransform(
self.tws1_loc,
self.getName("tws1_rot"),
transform.getTransform(self.ctrn_loc),
)
self.tws2_npo = primitive.addTransform(
self.root,
self.getName("tws2_npo"),
transform.getTransform(self.fk_ctl[2]),
)
self.tws2_loc = primitive.addTransform(
self.tws2_npo,
self.getName("tws2_loc"),
transform.getTransform(self.fk_ctl[2]),
)
self.tws2_rot = primitive.addTransform(
self.tws2_loc,
self.getName("tws2_rot"),
transform.getTransform(self.fk_ctl[2]),
)
# Divisions ----------------------------------------
self.divisions = self.settings["div0"] + self.settings["div1"] + 2
self.div_cns = []
if self.settings["extraTweak"]:
tagP = self.parentCtlTag
self.tweak_ctl = []
for i in range(self.divisions):
div_cns = primitive.addTransform(
self.root, self.getName("div%s_loc" % i)
)
self.div_cns.append(div_cns)
if self.settings["extraTweak"]:
t = transform.getTransform(div_cns)
tweak_ctl = self.addCtl(
div_cns,
"tweak%s_ctl" % i,
t,
self.color_fk,
"square",
w=self.size * 0.15,
d=self.size * 0.15,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=tagP,
)
attribute.setKeyableAttributes(tweak_ctl)
tagP = tweak_ctl
self.tweak_ctl.append(tweak_ctl)
driver = tweak_ctl
else:
driver = div_cns
# joint Description Name
jd_names = ast.literal_eval(
self.settings["jointNamesDescription_custom"]
)
jdn_upperarm = jd_names[0]
jdn_lowerarm = jd_names[1]
jdn_upperarm_twist = jd_names[2]
jdn_lowerarm_twist = jd_names[3]
jdn_hand = jd_names[4]
# setting the joints
if i == 0:
self.jnt_pos.append([driver, jdn_upperarm])
current_parent = "root"
twist_name = jdn_upperarm_twist
twist_idx = 1
increment = 1
elif i == self.settings["div0"] + 1:
self.jnt_pos.append([driver, jdn_lowerarm, current_parent])
twist_name = jdn_lowerarm_twist
current_parent = "elbow"
twist_idx = self.settings["div1"]
increment = -1
else:
self.jnt_pos.append(
[
driver,
string.replaceSharpWithPadding(twist_name, twist_idx),
current_parent,
]
)
twist_idx += increment
if self.settings["use_blade"]:
eff_loc = self.eff_jnt_off
else:
eff_loc = self.eff_loc
self.jnt_pos.append([eff_loc, jdn_hand, current_parent])
# match IK FK references
self.match_fk0_off = self.add_match_ref(
self.fk_ctl[1], self.root, "matchFk0_npo", False
)
self.match_fk0 = self.add_match_ref(
self.fk_ctl[0], self.match_fk0_off, "fk0_mth"
)
self.match_fk1_off = self.add_match_ref(
self.fk_ctl[2], self.root, "matchFk1_npo", False
)
self.match_fk1 = self.add_match_ref(
self.fk_ctl[1], self.match_fk1_off, "fk1_mth"
)
if self.settings["ikTR"]:
reference = self.ikRot_ctl
self.match_ikRot = self.add_match_ref(
self.ikRot_ctl, self.fk2_ctl, "ikRot_mth"
)
else:
reference = self.ik_ctl
self.match_fk2 = self.add_match_ref(
self.fk_ctl[2], reference, "fk2_mth"
)
self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth")
self.match_ikUpv = self.add_match_ref(
self.upv_ctl, self.fk0_ctl, "upv_mth"
)
# add visual reference
self.line_ref = icon.connection_display_curve(
self.getName("visalRef"), [self.upv_ctl, self.mid_ctl]
)
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.isFk = self.settings["mode"] != 1
self.isIk = self.settings["mode"] != 0
self.isFkIk = self.settings["mode"] == 2
self.WIP = self.options["mode"]
# FK controllers ------------------------------------
if self.isFk:
self.fk_npo = []
self.fk_ctl = []
self.fk_ref = []
self.fk_off = []
t = self.guide.tra["root"]
self.ik_cns = primitive.addTransform(self.root,
self.getName("ik_cns"), t)
parent = self.ik_cns
tOld = False
fk_ctl = None
self.previousTag = self.parentCtlTag
for i, t in enumerate(
transform.getChainTransform(self.guide.apos, self.normal,
self.negate)):
dist = vector.getDistance(self.guide.apos[i],
self.guide.apos[i + 1])
if self.settings["neutralpose"] or not tOld:
tnpo = t
else:
tnpo = transform.setMatrixPosition(
tOld, transform.getPositionFromMatrix(t))
if i:
tref = transform.setMatrixPosition(
tOld, transform.getPositionFromMatrix(t))
fk_ref = primitive.addTransform(
fk_ctl, self.getName("fk%s_ref" % i), tref)
self.fk_ref.append(fk_ref)
else:
tref = t
fk_off = primitive.addTransform(parent,
self.getName("fk%s_off" % i),
tref)
fk_npo = primitive.addTransform(fk_off,
self.getName("fk%s_npo" % i),
tnpo)
# ro is rotation offset. Yup. They coded it in radians... 1.5708 rad is 90 deg :\
fk_ctl = self.addCtl(
fk_npo,
"fk%s_ctl" % i,
t,
self.color_fk,
"compas",
w=dist,
po=datatypes.Vector(0, 0, 0),
ro=datatypes.Vector(-1.5708, 0 - 1.5708),
tp=self.previousTag,
)
# lock vis
attribute.lockAttribute(fk_ctl, attributes=['v'])
# set rotateOrder to xzy. "Barrel roll" rotx remains stable. Spread roty stays on plane of hands.
fk_ctl.rotateOrder.set(3)
self.fk_off.append(fk_off)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
tOld = t
self.previousTag = fk_ctl
# IK controllers ------------------------------------
if self.isIk:
normal = vector.getTransposedVector(
self.normal, [self.guide.apos[0], self.guide.apos[1]],
[self.guide.apos[-2], self.guide.apos[-1]])
t = transform.getTransformLookingAt(self.guide.apos[-2],
self.guide.apos[-1], normal,
"xy", self.negate)
t = transform.setMatrixPosition(t, self.guide.apos[-1])
self.ik_cns = primitive.addTransform(self.root,
self.getName("ik_cns"), t)
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
t,
self.color_ik,
"null",
w=self.size,
tp=self.parentCtlTag)
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
t,
self.color_ik,
"cube",
w=self.size * .3,
h=self.size * .3,
d=self.size * .3,
tp=self.ikcns_ctl)
attribute.setKeyableAttributes(self.ik_ctl, self.t_params)
attribute.lockAttribute(self.ik_ctl, attributes=['v'])
v = self.guide.apos[-1] - self.guide.apos[0]
v = v ^ self.normal
v.normalize()
v *= self.size
v += self.guide.apos[1]
self.upv_cns = primitive.addTransformFromPos(
self.root, self.getName("upv_cns"), v)
self.upv_ctl = self.addCtl(self.upv_cns,
"upv_ctl",
transform.getTransform(self.upv_cns),
self.color_ik,
"diamond",
w=self.size * .1,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.upv_ctl, self.t_params)
# Chain
self.chain = primitive.add2DChain(self.root, self.getName("chain"),
self.guide.apos, self.normal,
self.negate)
self.chain[0].attr("visibility").set(self.WIP)
# Chain of deformers -------------------------------
self.loc = []
parent = self.root
for i, t in enumerate(
transform.getChainTransform(self.guide.apos, self.normal,
self.negate)):
loc = primitive.addTransform(parent, self.getName("%s_loc" % i), t)
self.loc.append(loc)
self.jnt_pos.append([loc, i, None, False])
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.getNormalFromPos(self.guide.apos)
self.binormal = self.getBiNormalFromPos(self.guide.apos)
self.length0 = vector.getDistance(
self.guide.apos[0], self.guide.apos[1])
self.length1 = vector.getDistance(
self.guide.apos[1], self.guide.apos[2])
self.length2 = vector.getDistance(
self.guide.apos[2], self.guide.apos[3])
# FK Controlers -----------------------------------
# *ms* set npo @ Tpose, to make the fk rotation work
# best with rot order"yzx"
self.fk_cns = primitive.addTransformFromPos(
self.root, self.getName("fk_cns"), self.guide.apos[0])
vec_offset = ((self.guide.apos[1] - self.guide.apos[0]) * [1, 0, 0])
tpv = self.guide.apos[0] + vec_offset
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal, "xz",
self.negate)
# *ms* add FK isolation
self.fk0_npo = primitive.addTransform(
self.fk_cns, self.getName("fk0_npo"), t)
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal, "xz",
self.negate)
po_off = datatypes.Vector(.35 * self.length0 * self.n_factor, 0, 0)
self.fk0_ctl = self.addCtl(self.fk0_npo,
"fk0_ctl",
t,
self.color_fk,
"cube",
w=self.length0 * .7,
h=self.size * .1,
d=self.size * .1,
po=po_off,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.fk0_ctl)
# *ms* add fk roll control Simage style
po_off = datatypes.Vector(.85 * self.length0 * self.n_factor, 0, 0)
self.fk0_roll_ctl = self.addCtl(self.fk0_ctl,
"fk0_roll_ctl",
t, self.color_fk,
"cube", w=self.length0 * .3,
h=self.size * .1,
d=self.size * 0.1,
po=po_off,
tp=self.fk0_ctl)
attribute.setRotOrder(self.fk0_roll_ctl, "YZX")
attribute.setKeyableAttributes(self.fk0_roll_ctl, ["rx"])
self.fk0_mtx = primitive.addTransform(
self.root, self.getName("fk0_mtx"), t)
t = transform.setMatrixPosition(t, self.guide.apos[1])
self.fk1_ref = primitive.addTransform(
self.fk0_roll_ctl, self.getName("fk1_ref"), t)
self.fk1_loc = primitive.addTransform(
self.root, self.getName("fk1_loc"), t)
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[2],
self.normal,
"xz",
self.negate)
self.fk1_npo = primitive.addTransform(
self.fk1_loc, self.getName("fk1_npo"), t)
po_off = datatypes.Vector(.35 * self.length1 * self.n_factor, 0, 0)
self.fk1_ctl = self.addCtl(self.fk1_npo,
"fk1_ctl",
t,
self.color_fk,
"cube",
w=self.length1 * .7,
h=self.size * .1,
d=self.size * .1,
po=po_off, tp=self.fk0_roll_ctl)
attribute.setKeyableAttributes(self.fk1_ctl)
self.fk1_mtx = primitive.addTransform(
self.fk1_ctl, self.getName("fk1_mtx"), t)
po_off = datatypes.Vector(.85 * self.length1 * self.n_factor, 0, 0)
self.fk1_roll_ctl = self.addCtl(self.fk1_ctl,
"fk1_roll_ctl",
t,
self.color_fk,
"cube",
w=self.length1 * .3,
h=self.size * .1,
d=self.size * .1,
po=po_off, tp=self.fk1_ctl)
attribute.setRotOrder(self.fk1_roll_ctl, "XYZ")
attribute.setKeyableAttributes(self.fk1_roll_ctl, ["rx"])
t = transform.getTransformLookingAt(self.guide.apos[2],
self.guide.apos[3],
self.normal,
"xz",
self.negate)
# *ms* buffer object to feed into ikfk solver for hand seperation
self.fk2_mtx = primitive.addTransform(self.fk1_roll_ctl,
self.getName("fk2_mtx"),
t)
# fk2_loc is need to take the effector position + bone1 rotation
t1 = transform.getTransformLookingAt(self.guide.apos[2],
self.guide.apos[1],
self.normal,
"-xz",
self.negate)
self.fk2_loc = primitive.addTransform(
self.root, self.getName("fk2_loc"), t1)
self.fk2_npo = primitive.addTransform(self.fk2_loc,
self.getName("fk2_npo"),
t)
po_off = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0)
self.fk2_ctl = self.addCtl(self.fk2_npo,
"fk2_ctl",
t,
self.color_fk,
"cube",
w=self.length2,
h=self.size * .1,
d=self.size * .1,
po=po_off,
tp=self.fk1_roll_ctl)
attribute.setKeyableAttributes(self.fk2_ctl)
self.fk_ctl = [self.fk0_roll_ctl, self.fk1_mtx, self.fk2_ctl]
self.fk_ctls = [self.fk0_ctl,
self.fk0_roll_ctl,
self.fk1_ctl,
self.fk1_roll_ctl,
self.fk2_ctl]
for x in self.fk_ctls:
attribute.setInvertMirror(x, ["tx", "ty", "tz"])
# IK Controlers -----------------------------------
self.ik_cns = primitive.addTransformFromPos(
self.root, self.getName("ik_cns"), self.guide.pos["wrist"])
self.ikcns_ctl = self.addCtl(
self.ik_cns,
"ikcns_ctl",
transform.getTransformFromPos(self.guide.pos["wrist"]),
self.color_ik,
"null",
w=self.size * .12, tp=self.parentCtlTag)
attribute.setInvertMirror(self.ikcns_ctl, ["tx", "ty", "tz"])
if self.negate:
m = transform.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal,
"x-y",
True)
else:
m = transform.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal,
"xy",
False)
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
m,
self.color_ik,
"cube",
w=self.size * .12,
h=self.size * .12,
d=self.size * .12,
tp=self.ikcns_ctl)
attribute.setKeyableAttributes(self.ik_ctl)
attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
# upv
v = self.guide.apos[2] - self.guide.apos[0]
v = self.normal ^ v
v.normalize()
v *= self.size * .5
v += self.guide.apos[1]
# *ms* auto up vector ------------------------------
self.upv_cns = primitive.addTransformFromPos(self.root,
self.getName("upv_cns"),
self.guide.apos[0])
self.upv_auv = primitive.addTransformFromPos(self.root,
self.getName("upv_auv"),
self.guide.apos[0])
self.upv_mtx = primitive.addTransformFromPos(self.upv_cns,
self.getName("upv_mtx"),
self.guide.apos[0])
self.upv_npo = primitive.addTransformFromPos(self.upv_mtx,
self.getName("upv_npo"),
v)
self.upv_ctl = self.addCtl(self.upv_npo,
"upv_ctl",
transform.getTransform(self.upv_npo),
self.color_ik,
"diamond",
w=self.size * .12,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.upv_ctl, self.t_params)
attribute.setInvertMirror(self.upv_ctl, ["tx"])
# References --------------------------------------
# Calculate again the transfor for the IK ref. This way align with FK
trnIK_ref = transform.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal,
"xz",
self.negate)
self.ik_ref = primitive.addTransform(self.ik_ctl,
self.getName("ik_ref"),
trnIK_ref)
self.fk_ref = primitive.addTransform(self.fk_ctl[2],
self.getName("fk_ref"),
trnIK_ref)
# Chain --------------------------------------------
# take outputs of the ikfk2bone solver
self.bone0 = primitive.addLocator(
self.root,
self.getName("0_bone"),
transform.getTransform(self.fk_ctl[0]))
self.bone0_shp = self.bone0.getShape()
self.bone0_shp.setAttr("localPositionX", self.n_factor * .5)
self.bone0_shp.setAttr("localScale", .5, 0, 0)
self.bone0.setAttr("sx", self.length0)
self.bone0.setAttr("visibility", False)
self.bone1 = primitive.addLocator(
self.root,
self.getName("1_bone"),
transform.getTransform(self.fk_ctl[1]))
self.bone1_shp = self.bone1.getShape()
self.bone1_shp.setAttr("localPositionX", self.n_factor * .5)
self.bone1_shp.setAttr("localScale", .5, 0, 0)
self.bone1.setAttr("sx", self.length1)
self.bone1.setAttr("visibility", False)
self.ctrn_loc = primitive.addTransformFromPos(self.root,
self.getName("ctrn_loc"),
self.guide.apos[1])
# eff npo --- take the effector output of gear ik solver
self.eff_npo = primitive.addTransformFromPos(self.root,
self.getName("eff_npo"),
self.guide.apos[2])
# eff loc --- take the fk ik blend result
self.eff_loc = primitive.addTransformFromPos(self.eff_npo,
self.getName("eff_loc"),
self.guide.apos[2])
# Mid Controler ------------------------------------
self.mid_ctl = self.addCtl(self.ctrn_loc,
"mid_ctl",
transform.getTransform(self.ctrn_loc),
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.parentCtlTag)
attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"])
# *ms* add elbow thickness
# Roll join ref
self.tws0_npo = primitive.addTransform(
self.root,
self.getName("tws0_npo"),
transform.getTransform(self.fk_ctl[0]))
self.tws0_loc = primitive.addTransform(
self.tws0_npo,
self.getName("tws0_loc"),
transform.getTransform(self.fk_ctl[0]))
self.tws0_rot = primitive.addTransform(
self.tws0_loc,
self.getName("tws0_rot"),
transform.getTransform(self.fk_ctl[0]))
self.tws1_npo = primitive.addTransform(
self.ctrn_loc,
self.getName("tws1_npo"),
transform.getTransform(self.ctrn_loc))
self.tws1_loc = primitive.addTransform(
self.tws1_npo,
self.getName("tws1_loc"),
transform.getTransform(self.ctrn_loc))
self.tws1_rot = primitive.addTransform(
self.tws1_loc,
self.getName("tws1_rot"),
transform.getTransform(self.ctrn_loc))
self.tws2_loc = primitive.addTransform(
self.tws1_npo,
self.getName("tws2_loc"),
transform.getTransform(self.ctrn_loc))
self.tws2_rot = primitive.addTransform(
self.tws2_loc,
self.getName("tws2_rot"),
transform.getTransform(self.ctrn_loc))
self.tws3_npo = primitive.addTransform(
self.root,
self.getName("tws3_npo"),
transform.getTransform(self.fk_ctl[2]))
self.tws3_loc = primitive.addTransform(
self.tws3_npo,
self.getName("tws3_loc"),
transform.getTransform(self.fk_ctl[2]))
self.tws3_rot = primitive.addTransform(
self.tws3_loc,
self.getName("tws3_rot"),
transform.getTransform(self.fk_ctl[2]))
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for the
# elbow. + 2 for elbow angle control
# separate up and dn limb
self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + 2
self.divisions0 = self.settings["div0"] + 2
self.divisions1 = self.settings["div1"] + 2
self.div_cns = []
self.div_cnsUp = []
self.div_cnsDn = []
self.div_ctls = []
self.div_org = primitive.addTransform(
self.root,
self.getName("div_org"),
transform.getTransform(self.root))
self.previousTag = self.parentCtlTag
for i in range(self.divisions0):
div_cns = primitive.addTransform(
self.div_org, self.getName("div%s_loc" % i))
if self.negate:
div_ctl = self.addCtl(
div_cns,
self.getName("div%s_ctl" % i),
transform.getTransform(div_cns),
self.color_fk, "square", d=self.size * .05,
w=self.size * .1,
po=datatypes.Vector(0, self.size * -0.05, 0),
ro=datatypes.Vector(0, 0, datatypes.radians(90)),
tp=self.previousTag)
else:
div_ctl = self.addCtl(
div_cns,
self.getName("div%s_ctl" % i),
transform.getTransform(div_cns),
self.color_fk,
"square",
d=self.size * .05,
w=self.size * .1,
po=datatypes.Vector(0, self.size * 0.05, 0),
ro=datatypes.Vector(0, 0, datatypes.radians(90)),
tp=self.previousTag)
attribute.setKeyableAttributes(div_ctl)
self.previousTag = div_ctl
self.div_cns.append(div_cns)
self.div_cnsUp.append(div_cns)
self.jnt_pos.append([div_ctl, i])
self.div_ctls.append(div_ctl)
# mid division
d = self.divisions0
self.div_mid = primitive.addTransform(
self.div_org,
self.getName("div%s_loc" % d),
transform.getTransform(self.mid_ctl))
if self.negate:
self.div_mid_ctl = self.addCtl(
self.div_mid,
self.getName("div%s_ctl" % d),
transform.getTransform(self.div_mid),
self.color_fk,
"square",
d=self.size * .05,
w=self.size * .1,
po=datatypes.Vector(0, self.size * -0.05, 0),
ro=datatypes.Vector(0, 0, datatypes.radians(90)),
tp=self.previousTag)
else:
self.div_mid_ctl = self.addCtl(
self.div_mid, self.getName("div%s_ctl" % d),
transform.getTransform(self.div_mid),
self.color_fk,
"square",
d=self.size * .05,
w=self.size * .1,
po=datatypes.Vector(0, self.size * 0.05, 0),
ro=datatypes.Vector(0, 0, datatypes.radians(90)),
tp=self.previousTag)
attribute.setKeyableAttributes(self.div_mid_ctl)
self.previousTag = div_ctl
self.div_cns.append(self.div_mid)
self.jnt_pos.append([self.div_mid_ctl, self.divisions0])
self.div_ctls.append(self.div_mid_ctl)
# down division
for i in range(self.divisions1):
dd = i + self.divisions1 + 1
div_cns = primitive.addTransform(
self.div_org, self.getName("div%s_loc" % dd))
if self.negate:
div_ctl = self.addCtl(
div_cns,
self.getName("div%s_ctl" % dd),
transform.getTransform(div_cns),
self.color_fk,
"square",
d=self.size * .05,
w=self.size * .1,
po=datatypes.Vector(0, self.size * -0.05, 0),
ro=datatypes.Vector(0, 0, datatypes.radians(90)),
tp=self.previousTag)
else:
div_ctl = self.addCtl(
div_cns,
self.getName("div%s_ctl" % dd),
transform.getTransform(div_cns),
self.color_fk,
"square",
d=self.size * .05,
w=self.size * .1,
po=datatypes.Vector(0, self.size * 0.05, 0),
ro=datatypes.Vector(0, 0, datatypes.radians(90)),
tp=self.previousTag)
attribute.setKeyableAttributes(div_ctl)
self.previousTag = div_ctl
self.div_cns.append(div_cns)
self.div_cnsDn.append(div_cns)
self.jnt_pos.append([div_ctl, i + self.divisions0 + 1])
self.div_ctls.append(div_ctl)
# End reference ------------------------------------
# To help the deformation on the wrist
self.jnt_pos.append([self.eff_loc, 'end'])
# match IK FK references
self.match_fk0 = self.add_match_ref(self.fk_ctl[0],
self.root,
"fk0_mth")
self.match_fk1 = self.add_match_ref(self.fk_ctl[1],
self.root,
"fk1_mth")
self.match_fk2 = self.add_match_ref(self.fk_ctl[2],
self.ik_ctl,
"fk2_mth")
self.match_ik = self.add_match_ref(self.ik_ctl,
self.fk2_ctl,
"ik_mth")
self.match_ikUpv = self.add_match_ref(self.upv_ctl,
self.fk0_roll_ctl,
"upv_mth")
# add visual reference
self.line_ref = icon.connection_display_curve(
self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def addObjects(self):
"""Add all the objects needed to create the component."""
self.WIP = self.options["mode"]
self.normal = self.getNormalFromPos(self.guide.apos)
self.binormal = self.getBiNormalFromPos(self.guide.apos)
self.length0 = vector.getDistance(self.guide.apos[0],
self.guide.apos[1])
self.length1 = vector.getDistance(self.guide.apos[1],
self.guide.apos[2])
self.length2 = vector.getDistance(self.guide.apos[2],
self.guide.apos[3])
# 1 bone chain for upv ref
self.legChainUpvRef = primitive.add2DChain(
self.root, self.getName("legUpvRef%s_jnt"),
[self.guide.apos[0], self.guide.apos[2]], self.normal, False,
self.WIP)
self.legChainUpvRef[1].setAttr(
"jointOrientZ",
self.legChainUpvRef[1].getAttr("jointOrientZ") * -1)
# extra neutral pose
t = transform.getTransformFromPos(self.guide.apos[0])
self.root_npo = primitive.addTransform(self.root,
self.getName("root_npo"), t)
self.root_ctl = self.addCtl(self.root_npo,
"root_ctl",
t,
self.color_fk,
"circle",
w=self.length0 / 6,
tp=self.parentCtlTag)
# FK Controlers -----------------------------------
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1], self.normal,
"xz", self.negate)
self.fk0_npo = primitive.addTransform(self.root_ctl,
self.getName("fk0_npo"), t)
po_vec = datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0)
self.fk0_ctl = self.addCtl(self.fk0_npo,
"fk0_ctl",
t,
self.color_fk,
"cube",
w=self.length0,
h=self.size * .1,
d=self.size * .1,
po=po_vec,
tp=self.root_ctl)
attribute.setKeyableAttributes(
self.fk0_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"])
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[2], self.normal,
"xz", self.negate)
self.fk1_npo = primitive.addTransform(self.fk0_ctl,
self.getName("fk1_npo"), t)
po_vec = datatypes.Vector(.5 * self.length1 * self.n_factor, 0, 0)
self.fk1_ctl = self.addCtl(self.fk1_npo,
"fk1_ctl",
t,
self.color_fk,
"cube",
w=self.length1,
h=self.size * .1,
d=self.size * .1,
po=po_vec,
tp=self.fk0_ctl)
attribute.setKeyableAttributes(
self.fk1_ctl, ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"])
t = transform.getTransformLookingAt(self.guide.apos[2],
self.guide.apos[3], self.normal,
"xz", self.negate)
self.fk2_npo = primitive.addTransform(self.fk1_ctl,
self.getName("fk2_npo"), t)
po_vec = datatypes.Vector(.5 * self.length2 * self.n_factor, 0, 0)
self.fk2_ctl = self.addCtl(self.fk2_npo,
"fk2_ctl",
t,
self.color_fk,
"cube",
w=self.length2,
h=self.size * .1,
d=self.size * .1,
po=po_vec,
tp=self.fk1_ctl)
attribute.setKeyableAttributes(self.fk2_ctl)
self.fk_ctl = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl]
for x in self.fk_ctl:
attribute.setInvertMirror(x, ["tx", "ty", "tz"])
# IK Controlers -----------------------------------
self.ik_cns = primitive.addTransformFromPos(self.root_ctl,
self.getName("ik_cns"),
self.guide.pos["ankle"])
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
transform.getTransformFromPos(
self.guide.pos["ankle"]),
self.color_ik,
"null",
w=self.size * .12,
tp=self.root_ctl)
attribute.setInvertMirror(self.ikcns_ctl, ["tx"])
m = transform.getTransformLookingAt(self.guide.pos["ankle"],
self.guide.pos["eff"], self.x_axis,
"zx", False)
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
transform.getTransformFromPos(
self.guide.pos["ankle"]),
self.color_ik,
"cube",
w=self.size * .12,
h=self.size * .12,
d=self.size * .12)
attribute.setKeyableAttributes(self.ik_ctl)
attribute.setRotOrder(self.ik_ctl, "XZY")
attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
# upv
v = self.guide.apos[2] - self.guide.apos[0]
v = self.normal ^ v
v.normalize()
v *= self.size * .5
v += self.guide.apos[1]
self.upv_cns = primitive.addTransformFromPos(self.ik_ctl,
self.getName("upv_cns"),
v)
self.upv_ctl = self.addCtl(self.upv_cns,
"upv_ctl",
transform.getTransform(self.upv_cns),
self.color_ik,
"diamond",
w=self.size * .12,
tp=self.root_ctl)
self.add_controller_tag(self.ik_ctl, self.upv_ctl)
if self.settings["mirrorMid"]:
if self.negate:
self.upv_cns.rz.set(180)
self.upv_cns.sy.set(-1)
else:
attribute.setInvertMirror(self.upv_ctl, ["tx"])
attribute.setKeyableAttributes(self.upv_ctl, self.t_params)
# References --------------------------------------
self.ik_ref = primitive.addTransform(
self.ik_ctl, self.getName("ik_ref"),
transform.getTransform(self.ik_ctl))
self.fk_ref = primitive.addTransform(
self.fk_ctl[2], self.getName("fk_ref"),
transform.getTransform(self.ik_ctl))
# Chain --------------------------------------------
# The outputs of the ikfk2bone solver
self.bone0 = primitive.addLocator(
self.root_ctl, self.getName("0_bone"),
transform.getTransform(self.fk_ctl[0]))
self.bone0_shp = self.bone0.getShape()
self.bone0_shp.setAttr("localPositionX", self.n_factor * .5)
self.bone0_shp.setAttr("localScale", .5, 0, 0)
self.bone0.setAttr("sx", self.length0)
self.bone0.setAttr("visibility", False)
self.bone1 = primitive.addLocator(
self.root_ctl, self.getName("1_bone"),
transform.getTransform(self.fk_ctl[1]))
self.bone1_shp = self.bone1.getShape()
self.bone1_shp.setAttr("localPositionX", self.n_factor * .5)
self.bone1_shp.setAttr("localScale", .5, 0, 0)
self.bone1.setAttr("sx", self.length1)
self.bone1.setAttr("visibility", False)
self.ctrn_loc = primitive.addTransformFromPos(self.root_ctl,
self.getName("ctrn_loc"),
self.guide.apos[1])
self.eff_loc = primitive.addTransformFromPos(self.root_ctl,
self.getName("eff_loc"),
self.guide.apos[2])
# tws_ref
t = transform.getRotationFromAxis(datatypes.Vector(0, -1, 0),
self.normal, "xz", self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["ankle"])
# addind an npo parent transform to fix flip in Maya 2018.2
self.tws_npo = primitive.addTransform(self.eff_loc,
self.getName("tws_npo"), t)
self.tws_ref = primitive.addTransform(self.tws_npo,
self.getName("tws_ref"), t)
# Mid Controler ------------------------------------
t = transform.getTransform(self.ctrn_loc)
self.mid_cns = primitive.addTransform(self.ctrn_loc,
self.getName("mid_cns"), t)
self.mid_ctl = self.addCtl(self.mid_cns,
"mid_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.root_ctl)
attribute.setKeyableAttributes(
self.mid_ctl,
params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx"])
if self.settings["mirrorMid"]:
if self.negate:
self.mid_cns.rz.set(180)
self.mid_cns.sz.set(-1)
else:
attribute.setInvertMirror(self.mid_ctl, ["tx", "ty", "tz"])
# Twist references ---------------------------------
x = datatypes.Vector(0, -1, 0)
x = x * transform.getTransform(self.eff_loc)
z = datatypes.Vector(self.normal.x, self.normal.y, self.normal.z)
z = z * transform.getTransform(self.eff_loc)
m = transform.getRotationFromAxis(x, z, "xz", self.negate)
m = transform.setMatrixPosition(m,
transform.getTranslation(self.ik_ctl))
self.rollRef = primitive.add2DChain(self.root,
self.getName("rollChain"),
self.guide.apos[:2], self.normal,
self.negate, self.WIP)
self.tws0_loc = primitive.addTransform(
self.rollRef[0], self.getName("tws0_loc"),
transform.getTransform(self.fk_ctl[0]))
self.tws0_rot = primitive.addTransform(
self.tws0_loc, self.getName("tws0_rot"),
transform.getTransform(self.fk_ctl[0]))
self.tws1_loc = primitive.addTransform(
self.ctrn_loc, self.getName("tws1_loc"),
transform.getTransform(self.ctrn_loc))
self.tws1_rot = primitive.addTransform(
self.tws1_loc, self.getName("tws1_rot"),
transform.getTransform(self.ctrn_loc))
# thickness control
self.thick_lvl = primitive.addTransform(
self.mid_ctl, self.getName("thickness_lvl"),
transform.getTransform(self.ctrn_loc))
self.thick_ctl = self.addCtl(self.thick_lvl,
"thickness_ctl",
transform.getTransform(self.mid_ctl),
self.color_ik,
"arrow",
w=self.size * .1,
ro=datatypes.Vector([0, 1.5708, 0]),
tp=self.mid_ctl)
if self.negate and not self.settings["mirrorMid"]:
self.thick_ctl.rz.set(180)
self.thick_ctl.sz.set(-1)
attribute.setKeyableAttributes(self.thick_ctl, ["tx", "ty"])
self.tws1B_loc = primitive.addTransform(
self.ctrn_loc, self.getName("tws1B_loc"),
transform.getTransform(self.ctrn_loc))
self.tws1B_rot = primitive.addTransform(
self.tws1B_loc, self.getName("tws1B_rot"),
transform.getTransform(self.ctrn_loc))
self.tws2_loc = primitive.addTransform(
self.root_ctl, self.getName("tws2_loc"),
transform.getTransform(self.tws_ref))
self.tws2_rot = primitive.addTransform(
self.tws2_loc, self.getName("tws2_rot"),
transform.getTransform(self.tws_ref))
self.tws2_rot.setAttr("sx", .001)
# angle reader ----------------------------------------
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[0], self.binormal,
"yz")
self.readerA = primitive.addTransform(self.root,
self.getName("readerA_loc"), t)
self.readerB = primitive.addTransform(self.readerA,
self.getName("readerB_loc"), t)
self.readerB.rotateOrder.set(2)
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for
# the elbow. + 2 for knee angle control
if self.settings["supportJoints"]:
ej = 2
else:
ej = 0
self.divisions = self.settings["div0"] + self.settings["div1"] + 3 + ej
self.div_cns = []
if self.settings["extraTweak"]:
tagP = self.parentCtlTag
self.tweak_ctl = []
for i in range(self.divisions):
div_cns = primitive.addTransform(self.root_ctl,
self.getName("div%s_loc" % i))
self.div_cns.append(div_cns)
if self.settings["extraTweak"]:
t = transform.getTransform(div_cns)
tweak_ctl = self.addCtl(div_cns,
"tweak%s_ctl" % i,
t,
self.color_fk,
"square",
w=self.size * .15,
d=self.size * .15,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=tagP)
attribute.setKeyableAttributes(tweak_ctl)
tagP = tweak_ctl
self.tweak_ctl.append(tweak_ctl)
self.jnt_pos.append([tweak_ctl, i, None, False])
else:
self.jnt_pos.append([div_cns, i])
# End reference ------------------------------------
# To help the deformation on the ankle
self.end_ref = primitive.addTransform(self.tws2_rot,
self.getName("end_ref"), m)
self.jnt_pos.append([self.end_ref, 'end'])
# match IK FK references
self.match_fk0_off = self.add_match_ref(self.fk_ctl[1], self.root,
"matchFk0_npo", False)
self.match_fk0 = self.add_match_ref(self.fk_ctl[0], self.match_fk0_off,
"fk0_mth")
self.match_fk1_off = self.add_match_ref(self.fk_ctl[2], self.root,
"matchFk1_npo", False)
self.match_fk1 = self.add_match_ref(self.fk_ctl[1], self.match_fk1_off,
"fk1_mth")
self.match_fk2 = self.add_match_ref(self.fk_ctl[2], self.ik_ctl,
"fk2_mth")
self.match_ik = self.add_match_ref(self.ik_ctl, self.fk2_ctl, "ik_mth")
self.match_ikUpv = self.add_match_ref(self.upv_ctl, self.fk0_ctl,
"upv_mth")
# add visual reference
self.line_ref = icon.connection_display_curve(
self.getName("visalRef"), [self.upv_ctl, self.mid_ctl])
def addObjects(self):
"""Add all the objects needed to create the component."""
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)
ymt_util.setKeyableAttributesDontLockVisibility(self.heel_ctl, self.r_params)
# Tip ----------------------------------------------
v = datatypes.Vector(self.guide.apos[1].x,
self.guide.apos[-1].y,
self.guide.apos[1].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)
ymt_util.setKeyableAttributesDontLockVisibility(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)
ymt_util.setKeyableAttributesDontLockVisibility(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
def _add_loc_ctl(i, t, parent):
loc = primitive.addTransform(parent, self.getName("bk%s_loc" % i), t)
self.bk_loc.append(loc)
if 0 < i:
return loc
ctl = self.addCtl(loc,
"bk%s_ctl" % i,
t,
self.color_ik,
"sphere",
w=self.size * .15,
tp=self.previousTag)
ymt_util.setKeyableAttributesDontLockVisibility(ctl, self.r_params)
self.previousTag = ctl
self.bk_ctl.append(ctl)
return ctl
for i, pos in enumerate(bk_pos):
if i == 0:
t = transform.getTransform(self.heel_ctl)
t = transform.setMatrixPosition(t, bk_pos[0])
else:
dir = bk_pos[i - 1]
t = transform.getTransformLookingAt(
pos, dir, self.normal, "xz", self.negate)
parent = _add_loc_ctl(i, t, parent)
# FK Reference ------------------------------------
self.fk_ref = primitive.addTransformFromPos(self.bk_loc[-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_loc[-1]))
# Forward Controlers ------------------------------
self.fk_ctl = []
self.fk_loc = []
parent = self.fk_npo
self.previousTag = self.tip_ctl
for i, bk_loc in enumerate(reversed(self.bk_loc[2:])):
t = transform.getTransform(bk_loc)
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
ymt_util.setKeyableAttributesDontLockVisibility(fk_ctl)
self.jnt_pos.append([fk_ctl, i])
parent = fk_ctl
self.fk_ctl.append(fk_ctl)
self.fk_loc.append(fk_loc)
def addObjects(self):
"""Add all the objects needed to create the component."""
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 _addCurveControllers(self, t, crv, ctlNames, inCtl=None, outCtl=None):
cvs = crv.getCVs(space="world")
if self.negate:
# cvs = [cv for cv in reversed(cvs)]
pass
ctls = []
for i, cv in enumerate(cvs):
if inCtl is not None and i == 0:
ctls.append(inCtl)
continue
if outCtl is not None and (i == len(cvs) - 1):
ctls.append(outCtl)
continue
if utils.is_odd(i):
color = 14
wd = .5
offset = self.offset * 1.1
icon_shape = "circle"
params = ["tx", "ty", "tz"]
else:
color = 4
wd = .7
offset = self.offset * 1.3
icon_shape = "square"
params = ["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"]
t = setMatrixPosition(t, cvs[i])
npo = addTransform(self.center_lookat, self.getName("%s_npo" % ctlNames[i]), t)
npoBase = npo
if i == 2:
# we add an extra level to input the tracking ofset values
npo = addTransform(npo, self.getName("%s_trk" % ctlNames[i]), t)
self.trackLvl.append(npo)
ctl = self.addCtl(npo,
"%s_%s" % (ctlNames[i], self.ctlName),
t,
color,
icon_shape,
w=wd,
d=wd,
ro=datatypes.Vector(1.57079633, 0, 0),
po=offset
)
self.addToSubGroup(self.over_ctl, self.primaryControllersGroupName)
ymt_util.setKeyableAttributesDontLockVisibility(ctl, params)
ctls.append(ctl)
# adding parent average contrains to odd controls
for i, ctl in enumerate(ctls):
if utils.is_odd(i):
s = ctls[i - 1]
d = ctls[i + 1]
pm.parentConstraint(s, d, ctl.getParent(), mo=True)
applyop.gear_curvecns_op(crv, ctls)
return ctls
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 addObjects(self):
"""Add all the objects needed to create the component."""
# joint Description Names
jd_names = ast.literal_eval(
self.settings["jointNamesDescription_custom"])
jdn_section = jd_names[0]
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis="yx",
negate=self.negate)
self.ctl_npo = primitive.addTransform(self.root,
self.getName("ctl_npo"), t)
self.ctl = self.addCtl(self.ctl_npo,
"base_ctl",
t,
self.color_ik,
"square",
w=1.0,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.ctl, self.tr_params)
self.ref_base = primitive.addTransform(self.ctl,
self.getName("ref_base"), t)
t = transform.setMatrixPosition(t, self.guide.apos[1])
self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"),
t)
self.tip_npo = primitive.addTransform(self.ik_cns,
self.getName("tip_npo"), t)
self.tip_ctl = self.addCtl(self.tip_npo,
"tip_ctl",
t,
self.color_ik,
"square",
w=1.0,
tp=self.ctl)
attribute.setKeyableAttributes(self.tip_ctl, self.tr_params)
self.ref_tip = primitive.addTransform(self.tip_ctl,
self.getName("ref_tip"), t)
self.div_cns = []
for i in range(self.settings["div"]):
div_cns = primitive.addTransform(self.root,
self.getName("div%s_loc" % i))
self.div_cns.append(div_cns)
self.jnt_pos.append(
[div_cns,
string.replaceSharpWithPadding(jdn_section, i + 1)])
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.WIP = self.options["mode"]
if self.negate and self.settings["overrideNegate"]:
self.negate = False
self.n_factor = 1
if self.settings["overrideNegate"]:
self.mirror_conf = [0, 0, 1,
1, 1, 0,
0, 0, 0]
else:
self.mirror_conf = [0, 0, 0,
0, 0, 0,
0, 0, 0]
# FK controllers ------------------------------------
self.fk_npo = []
self.fk_global_in = []
self.fk_local_in = []
self.fk_local_out = []
self.fk_global_out = []
self.fk_global_ref = []
self.fk_ctl = []
self.tweak_ctl = []
self.upv_curv_lvl = []
t = self.guide.tra["root"]
parent = self.root
tOld = False
fk_ctl = None
self.previusTag = self.parentCtlTag
for i, t in enumerate(transform.getChainTransform(self.guide.apos,
self.normal,
self.negate)):
self.dist = vector.getDistance(self.guide.apos[i],
self.guide.apos[i + 1])
if self.settings["neutralpose"] or not tOld:
tnpo = t
else:
tnpo = transform.setMatrixPosition(
tOld,
transform.getPositionFromMatrix(t))
# global input
global_t = transform.setMatrixPosition(
datatypes.Matrix(),
transform.getPositionFromMatrix(t))
fk_global_npo = primitive.addTransform(
parent, self.getName("fk%s_global_npo" % i), global_t)
fk_global_in = primitive.addTransform(
fk_global_npo, self.getName("fk%s_global_in" % i), global_t)
self.fk_global_in.append(fk_global_in)
# local input
fk_local_npo = primitive.addTransform(
fk_global_in, self.getName("fk%s_local_npo" % i), tnpo)
fk_local_in = primitive.addTransform(
fk_local_npo, self.getName("fk%s_local_in" % i), tnpo)
self.fk_local_in.append(fk_local_in)
# output
fk_global_out_npo = primitive.addTransform(
parent, self.getName("fk%s_global_out_npo" % i), global_t)
fk_global_out = primitive.addTransform(
fk_global_out_npo,
self.getName("fk%s_global_out" % i),
global_t)
self.fk_global_out.append(fk_global_out)
fk_local_out_npo = primitive.addTransform(
parent, self.getName("fk%s_local_out_npo" % i), tnpo)
fk_local_out = primitive.addTransform(
fk_local_out_npo, self.getName("fk%s_local_out" % i), tnpo)
self.fk_local_out.append(fk_local_out)
# fk npo
fk_npo = primitive.addTransform(
fk_local_in, self.getName("fk%s_npo" % i), tnpo)
self.fk_npo.append(fk_npo)
# ctl
fk_ctl = self.addCtl(
fk_npo,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=self.dist,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(self.dist * .5 * self.n_factor, 0, 0),
tp=self.previusTag,
mirrorConf=self.mirror_conf)
self.fk_ctl.append(fk_ctl)
# fk global ref
fk_global_ref = primitive.addTransform(
fk_ctl,
self.getName("fk%s_global_ref" % i),
global_t)
self.fk_global_ref.append(fk_global_ref)
attribute.setKeyableAttributes(fk_global_ref, [])
parent = fk_ctl
self.previusTag = fk_ctl
if self.settings["addJoints"]:
self.jnt_pos.append([fk_ctl, i, None, False])
def eyeRig(eyeMesh,
edgeLoop,
blinkH,
namePrefix,
offset,
rigidLoops,
falloffLoops,
headJnt,
doSkin,
parent=None,
ctlName="ctl",
sideRange=False,
customCorner=False,
intCorner=None,
extCorner=None,
ctlGrp=None,
defGrp=None):
"""Create eyelid and eye rig
Args:
eyeMesh (TYPE): Description
edgeLoop (TYPE): Description
blinkH (TYPE): Description
namePrefix (TYPE): Description
offset (TYPE): Description
rigidLoops (TYPE): Description
falloffLoops (TYPE): Description
headJnt (TYPE): Description
doSkin (TYPE): Description
parent (None, optional): Description
ctlName (str, optional): Description
sideRange (bool, optional): Description
customCorner (bool, optional): Description
intCorner (None, optional): Description
extCorner (None, optional): Description
ctlGrp (None, optional): Description
defGrp (None, optional): Description
Returns:
TYPE: Description
"""
# Checkers
if edgeLoop:
edgeLoopList = [pm.PyNode(e) for e in edgeLoop.split(",")]
else:
pm.displayWarning("Please set the edge loop first")
return
if eyeMesh:
try:
eyeMesh = pm.PyNode(eyeMesh)
except pm.MayaNodeError:
pm.displayWarning("The object %s can not be found in the "
"scene" % (eyeMesh))
return
else:
pm.displayWarning("Please set the eye mesh first")
if doSkin:
if not headJnt:
pm.displayWarning("Please set the Head Jnt or unCheck "
"Compute Topological Autoskin")
return
# Initial Data
bboxCenter = meshNavigation.bboxCenter(eyeMesh)
extr_v = meshNavigation.getExtremeVertexFromLoop(edgeLoopList, sideRange)
upPos = extr_v[0]
lowPos = extr_v[1]
inPos = extr_v[2]
outPos = extr_v[3]
edgeList = extr_v[4]
vertexList = extr_v[5]
# Detect the side L or R from the x value
if inPos.getPosition(space='world')[0] < 0.0:
side = "R"
inPos = extr_v[3]
outPos = extr_v[2]
normalPos = outPos
npw = normalPos.getPosition(space='world')
normalVec = npw - bboxCenter
else:
side = "L"
normalPos = outPos
npw = normalPos.getPosition(space='world')
normalVec = bboxCenter - npw
# Manual Vertex corners
if customCorner:
if intCorner:
try:
if side == "R":
inPos = pm.PyNode(extCorner)
else:
inPos = pm.PyNode(intCorner)
except pm.MayaNodeError:
pm.displayWarning("%s can not be found" % intCorner)
return
else:
pm.displayWarning("Please set the internal eyelid corner")
return
if extCorner:
try:
normalPos = pm.PyNode(extCorner)
npw = normalPos.getPosition(space='world')
if side == "R":
outPos = pm.PyNode(intCorner)
normalVec = npw - bboxCenter
else:
outPos = pm.PyNode(extCorner)
normalVec = bboxCenter - npw
except pm.MayaNodeError:
pm.displayWarning("%s can not be found" % extCorner)
return
else:
pm.displayWarning("Please set the external eyelid corner")
return
# Check if we have prefix:
if namePrefix:
namePrefix = string.removeInvalidCharacter(namePrefix)
else:
pm.displayWarning("Prefix is needed")
return
def setName(name, ind=None):
namesList = [namePrefix, side, name]
if ind is not None:
namesList[1] = side + str(ind)
name = "_".join(namesList)
return name
if pm.ls(setName("root")):
pm.displayWarning("The object %s already exist in the scene. Please "
"choose another name prefix" % setName("root"))
return
# Eye root
eye_root = primitive.addTransform(None, setName("root"))
eyeCrv_root = primitive.addTransform(eye_root, setName("crvs"))
# Eyelid Main crvs
try:
upEyelid = meshNavigation.edgeRangeInLoopFromMid(
edgeList, upPos, inPos, outPos)
upCrv = curve.createCurveFromOrderedEdges(upEyelid,
inPos,
setName("upperEyelid"),
parent=eyeCrv_root)
upCrv_ctl = curve.createCurveFromOrderedEdges(upEyelid,
inPos,
setName("upCtl_crv"),
parent=eyeCrv_root)
pm.rebuildCurve(upCrv_ctl, s=2, rt=0, rpo=True, ch=False)
lowEyelid = meshNavigation.edgeRangeInLoopFromMid(
edgeList, lowPos, inPos, outPos)
lowCrv = curve.createCurveFromOrderedEdges(lowEyelid,
inPos,
setName("lowerEyelid"),
parent=eyeCrv_root)
lowCrv_ctl = curve.createCurveFromOrderedEdges(lowEyelid,
inPos,
setName("lowCtl_crv"),
parent=eyeCrv_root)
pm.rebuildCurve(lowCrv_ctl, s=2, rt=0, rpo=True, ch=False)
except UnboundLocalError:
if customCorner:
pm.displayWarning("This error is maybe caused because the custom "
"Corner vertex is not part of the edge loop")
pm.displayError(traceback.format_exc())
return
upBlink = curve.createCurveFromCurve(upCrv,
setName("upblink_crv"),
nbPoints=30,
parent=eyeCrv_root)
lowBlink = curve.createCurveFromCurve(lowCrv,
setName("lowBlink_crv"),
nbPoints=30,
parent=eyeCrv_root)
upTarget = curve.createCurveFromCurve(upCrv,
setName("upblink_target"),
nbPoints=30,
parent=eyeCrv_root)
lowTarget = curve.createCurveFromCurve(lowCrv,
setName("lowBlink_target"),
nbPoints=30,
parent=eyeCrv_root)
midTarget = curve.createCurveFromCurve(lowCrv,
setName("midBlink_target"),
nbPoints=30,
parent=eyeCrv_root)
rigCrvs = [
upCrv, lowCrv, upCrv_ctl, lowCrv_ctl, upBlink, lowBlink, upTarget,
lowTarget, midTarget
]
for crv in rigCrvs:
crv.attr("visibility").set(False)
# localBBOX
localBBox = eyeMesh.getBoundingBox(invisible=True, space='world')
wRadius = abs((localBBox[0][0] - localBBox[1][0]))
dRadius = abs((localBBox[0][1] - localBBox[1][1]) / 1.7)
# Groups
if not ctlGrp:
ctlGrp = "rig_controllers_grp"
try:
ctlSet = pm.PyNode(ctlGrp)
except pm.MayaNodeError:
pm.sets(n=ctlGrp, em=True)
ctlSet = pm.PyNode(ctlGrp)
if not defGrp:
defGrp = "rig_deformers_grp"
try:
defset = pm.PyNode(defGrp)
except pm.MayaNodeError:
pm.sets(n=defGrp, em=True)
defset = pm.PyNode(defGrp)
# Calculate center looking at
averagePosition = (
(upPos.getPosition(space='world') + lowPos.getPosition(space='world') +
inPos.getPosition(space='world') + outPos.getPosition(space='world'))
/ 4)
if side == "R":
negate = False
offset = offset
over_offset = dRadius
else:
negate = False
over_offset = dRadius
if side == "R" and sideRange or side == "R" and customCorner:
axis = "z-x"
# axis = "zx"
else:
axis = "z-x"
t = transform.getTransformLookingAt(bboxCenter,
averagePosition,
normalVec,
axis=axis,
negate=negate)
over_npo = primitive.addTransform(eye_root, setName("center_lookatRoot"),
t)
over_ctl = icon.create(over_npo,
setName("over_%s" % ctlName),
t,
icon="square",
w=wRadius,
d=dRadius,
ro=datatypes.Vector(1.57079633, 0, 0),
po=datatypes.Vector(0, 0, over_offset),
color=4)
node.add_controller_tag(over_ctl)
attribute.add_mirror_config_channels(over_ctl)
attribute.setKeyableAttributes(
over_ctl,
params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"])
if side == "R":
over_npo.attr("rx").set(over_npo.attr("rx").get() * -1)
over_npo.attr("ry").set(over_npo.attr("ry").get() + 180)
over_npo.attr("sz").set(-1)
if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost":
pass
else:
pm.sets(ctlSet, add=over_ctl)
center_lookat = primitive.addTransform(over_ctl, setName("center_lookat"),
t)
# Tracking
# Eye aim control
t_arrow = transform.getTransformLookingAt(bboxCenter,
averagePosition,
upPos.getPosition(space='world'),
axis="zy",
negate=False)
radius = abs((localBBox[0][0] - localBBox[1][0]) / 1.7)
arrow_npo = primitive.addTransform(eye_root, setName("aim_npo"), t_arrow)
arrow_ctl = icon.create(arrow_npo,
setName("aim_%s" % ctlName),
t_arrow,
icon="arrow",
w=1,
po=datatypes.Vector(0, 0, radius),
color=4)
if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost":
pass
else:
pm.sets(ctlSet, add=arrow_ctl)
attribute.setKeyableAttributes(arrow_ctl, params=["rx", "ry", "rz"])
# tracking custom trigger
if side == "R":
tt = t_arrow
else:
tt = t
aimTrigger_root = primitive.addTransform(center_lookat,
setName("aimTrigger_root"), tt)
aimTrigger_lvl = primitive.addTransform(aimTrigger_root,
setName("aimTrigger_lvl"), tt)
aimTrigger_lvl.attr("tz").set(1.0)
aimTrigger_ref = primitive.addTransform(aimTrigger_lvl,
setName("aimTrigger_ref"), tt)
aimTrigger_ref.attr("tz").set(0.0)
# connect trigger with arrow_ctl
pm.parentConstraint(arrow_ctl, aimTrigger_ref, mo=True)
# Controls lists
upControls = []
trackLvl = []
# upper eyelid controls
upperCtlNames = ["inCorner", "upInMid", "upMid", "upOutMid", "outCorner"]
cvs = upCrv_ctl.getCVs(space="world")
if side == "R" and not sideRange:
# if side == "R":
cvs = [cv for cv in reversed(cvs)]
for i, cv in enumerate(cvs):
if utils.is_odd(i):
color = 14
wd = .5
icon_shape = "circle"
params = ["tx", "ty", "tz"]
else:
color = 4
wd = .7
icon_shape = "square"
params = [
"tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"
]
t = transform.setMatrixPosition(t, cvs[i])
npo = primitive.addTransform(center_lookat,
setName("%s_npo" % upperCtlNames[i]), t)
npoBase = npo
if i == 2:
# we add an extra level to input the tracking ofset values
npo = primitive.addTransform(npo,
setName("%s_trk" % upperCtlNames[i]),
t)
trackLvl.append(npo)
ctl = icon.create(npo,
setName("%s_%s" % (upperCtlNames[i], ctlName)),
t,
icon=icon_shape,
w=wd,
d=wd,
ro=datatypes.Vector(1.57079633, 0, 0),
po=datatypes.Vector(0, 0, offset),
color=color)
attribute.add_mirror_config_channels(ctl)
node.add_controller_tag(ctl, over_ctl)
upControls.append(ctl)
if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost":
pass
else:
pm.sets(ctlSet, add=ctl)
attribute.setKeyableAttributes(ctl, params)
if side == "R":
npoBase.attr("ry").set(180)
npoBase.attr("sz").set(-1)
# adding parent average contrains to odd controls
for i, ctl in enumerate(upControls):
if utils.is_odd(i):
cns_node = pm.parentConstraint(upControls[i - 1],
upControls[i + 1],
ctl.getParent(),
mo=True)
# Make the constraint "noFlip"
cns_node.interpType.set(0)
# lower eyelid controls
lowControls = [upControls[0]]
lowerCtlNames = [
"inCorner", "lowInMid", "lowMid", "lowOutMid", "outCorner"
]
cvs = lowCrv_ctl.getCVs(space="world")
if side == "R" and not sideRange:
cvs = [cv for cv in reversed(cvs)]
for i, cv in enumerate(cvs):
# we skip the first and last point since is already in the uper eyelid
if i in [0, 4]:
continue
if utils.is_odd(i):
color = 14
wd = .5
icon_shape = "circle"
params = ["tx", "ty", "tz"]
else:
color = 4
wd = .7
icon_shape = "square"
params = [
"tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"
]
t = transform.setMatrixPosition(t, cvs[i])
npo = primitive.addTransform(center_lookat,
setName("%s_npo" % lowerCtlNames[i]), t)
npoBase = npo
if i == 2:
# we add an extra level to input the tracking ofset values
npo = primitive.addTransform(npo,
setName("%s_trk" % lowerCtlNames[i]),
t)
trackLvl.append(npo)
ctl = icon.create(npo,
setName("%s_%s" % (lowerCtlNames[i], ctlName)),
t,
icon=icon_shape,
w=wd,
d=wd,
ro=datatypes.Vector(1.57079633, 0, 0),
po=datatypes.Vector(0, 0, offset),
color=color)
attribute.add_mirror_config_channels(ctl)
lowControls.append(ctl)
if len(ctlName.split("_")) == 2 and ctlName.split("_")[-1] == "ghost":
pass
else:
pm.sets(ctlSet, add=ctl)
attribute.setKeyableAttributes(ctl, params)
# mirror behaviout on R side controls
if side == "R":
npoBase.attr("ry").set(180)
npoBase.attr("sz").set(-1)
for lctl in reversed(lowControls[1:]):
node.add_controller_tag(lctl, over_ctl)
lowControls.append(upControls[-1])
# adding parent average contrains to odd controls
for i, ctl in enumerate(lowControls):
if utils.is_odd(i):
cns_node = pm.parentConstraint(lowControls[i - 1],
lowControls[i + 1],
ctl.getParent(),
mo=True)
# Make the constraint "noFlip"
cns_node.interpType.set(0)
# Connecting control crvs with controls
applyop.gear_curvecns_op(upCrv_ctl, upControls)
applyop.gear_curvecns_op(lowCrv_ctl, lowControls)
# adding wires
w1 = pm.wire(upCrv, w=upBlink)[0]
w2 = pm.wire(lowCrv, w=lowBlink)[0]
w3 = pm.wire(upTarget, w=upCrv_ctl)[0]
w4 = pm.wire(lowTarget, w=lowCrv_ctl)[0]
# adding blendshapes
bs_upBlink = pm.blendShape(upTarget,
midTarget,
upBlink,
n="blendShapeUpBlink")
bs_lowBlink = pm.blendShape(lowTarget,
midTarget,
lowBlink,
n="blendShapeLowBlink")
bs_mid = pm.blendShape(lowTarget,
upTarget,
midTarget,
n="blendShapeLowBlink")
# setting blendshape reverse connections
rev_node = pm.createNode("reverse")
pm.connectAttr(bs_upBlink[0].attr(midTarget.name()), rev_node + ".inputX")
pm.connectAttr(rev_node + ".outputX", bs_upBlink[0].attr(upTarget.name()))
rev_node = pm.createNode("reverse")
pm.connectAttr(bs_lowBlink[0].attr(midTarget.name()), rev_node + ".inputX")
pm.connectAttr(rev_node + ".outputX",
bs_lowBlink[0].attr(lowTarget.name()))
rev_node = pm.createNode("reverse")
pm.connectAttr(bs_mid[0].attr(upTarget.name()), rev_node + ".inputX")
pm.connectAttr(rev_node + ".outputX", bs_mid[0].attr(lowTarget.name()))
# setting default values
bs_mid[0].attr(upTarget.name()).set(blinkH)
# joints root
jnt_root = primitive.addTransformFromPos(eye_root,
setName("joints"),
pos=bboxCenter)
# head joint
if headJnt:
try:
headJnt = pm.PyNode(headJnt)
jnt_base = headJnt
except pm.MayaNodeError:
pm.displayWarning("Aborted can not find %s " % headJnt)
return
else:
# Eye root
jnt_base = jnt_root
eyeTargets_root = primitive.addTransform(eye_root, setName("targets"))
eyeCenter_jnt = rigbits.addJnt(arrow_ctl,
jnt_base,
grp=defset,
jntName=setName("center_jnt"))
# Upper Eyelid joints ##################################################
cvs = upCrv.getCVs(space="world")
upCrv_info = node.createCurveInfoNode(upCrv)
# aim constrain targets and joints
upperEyelid_aimTargets = []
upperEyelid_jnt = []
upperEyelid_jntRoot = []
for i, cv in enumerate(cvs):
# aim targets
trn = primitive.addTransformFromPos(eyeTargets_root,
setName("upEyelid_aimTarget", i),
pos=cv)
upperEyelid_aimTargets.append(trn)
# connecting positions with crv
pm.connectAttr(upCrv_info + ".controlPoints[%s]" % str(i),
trn.attr("translate"))
# joints
jntRoot = primitive.addJointFromPos(jnt_root,
setName("upEyelid_jnt_base", i),
pos=bboxCenter)
jntRoot.attr("radius").set(.08)
jntRoot.attr("visibility").set(False)
upperEyelid_jntRoot.append(jntRoot)
applyop.aimCns(jntRoot, trn, axis="zy", wupObject=jnt_root)
jnt_ref = primitive.addJointFromPos(jntRoot,
setName("upEyelid_jnt_ref", i),
pos=cv)
jnt_ref.attr("radius").set(.08)
jnt_ref.attr("visibility").set(False)
jnt = rigbits.addJnt(jnt_ref,
jnt_base,
grp=defset,
jntName=setName("upEyelid_jnt", i))
upperEyelid_jnt.append(jnt)
# Lower Eyelid joints ##################################################
cvs = lowCrv.getCVs(space="world")
lowCrv_info = node.createCurveInfoNode(lowCrv)
# aim constrain targets and joints
lowerEyelid_aimTargets = []
lowerEyelid_jnt = []
lowerEyelid_jntRoot = []
for i, cv in enumerate(cvs):
if i in [0, len(cvs) - 1]:
continue
# aim targets
trn = primitive.addTransformFromPos(eyeTargets_root,
setName("lowEyelid_aimTarget", i),
pos=cv)
lowerEyelid_aimTargets.append(trn)
# connecting positions with crv
pm.connectAttr(lowCrv_info + ".controlPoints[%s]" % str(i),
trn.attr("translate"))
# joints
jntRoot = primitive.addJointFromPos(jnt_root,
setName("lowEyelid_base", i),
pos=bboxCenter)
jntRoot.attr("radius").set(.08)
jntRoot.attr("visibility").set(False)
lowerEyelid_jntRoot.append(jntRoot)
applyop.aimCns(jntRoot, trn, axis="zy", wupObject=jnt_root)
jnt_ref = primitive.addJointFromPos(jntRoot,
setName("lowEyelid_jnt_ref", i),
pos=cv)
jnt_ref.attr("radius").set(.08)
jnt_ref.attr("visibility").set(False)
jnt = rigbits.addJnt(jnt_ref,
jnt_base,
grp=defset,
jntName=setName("lowEyelid_jnt", i))
lowerEyelid_jnt.append(jnt)
# Channels
# Adding and connecting attributes for the blink
up_ctl = upControls[2]
blink_att = attribute.addAttribute(over_ctl,
"blink",
"float",
0,
minValue=0,
maxValue=1)
blinkMult_att = attribute.addAttribute(over_ctl,
"blinkMult",
"float",
1,
minValue=1,
maxValue=2)
midBlinkH_att = attribute.addAttribute(over_ctl,
"blinkHeight",
"float",
blinkH,
minValue=0,
maxValue=1)
mult_node = node.createMulNode(blink_att, blinkMult_att)
pm.connectAttr(mult_node + ".outputX",
bs_upBlink[0].attr(midTarget.name()))
pm.connectAttr(mult_node + ".outputX",
bs_lowBlink[0].attr(midTarget.name()))
pm.connectAttr(midBlinkH_att, bs_mid[0].attr(upTarget.name()))
low_ctl = lowControls[2]
# Adding channels for eye tracking
upVTracking_att = attribute.addAttribute(up_ctl,
"vTracking",
"float",
.02,
minValue=0,
maxValue=1,
keyable=False,
channelBox=True)
upHTracking_att = attribute.addAttribute(up_ctl,
"hTracking",
"float",
.01,
minValue=0,
maxValue=1,
keyable=False,
channelBox=True)
lowVTracking_att = attribute.addAttribute(low_ctl,
"vTracking",
"float",
.01,
minValue=0,
maxValue=1,
keyable=False,
channelBox=True)
lowHTracking_att = attribute.addAttribute(low_ctl,
"hTracking",
"float",
.01,
minValue=0,
maxValue=1,
keyable=False,
channelBox=True)
mult_node = node.createMulNode(upVTracking_att, aimTrigger_ref.attr("ty"))
pm.connectAttr(mult_node + ".outputX", trackLvl[0].attr("ty"))
mult_node = node.createMulNode(upHTracking_att, aimTrigger_ref.attr("tx"))
pm.connectAttr(mult_node + ".outputX", trackLvl[0].attr("tx"))
mult_node = node.createMulNode(lowVTracking_att, aimTrigger_ref.attr("ty"))
pm.connectAttr(mult_node + ".outputX", trackLvl[1].attr("ty"))
mult_node = node.createMulNode(lowHTracking_att, aimTrigger_ref.attr("tx"))
pm.connectAttr(mult_node + ".outputX", trackLvl[1].attr("tx"))
# Tension on blink
node.createReverseNode(blink_att, w1.scale[0])
node.createReverseNode(blink_att, w3.scale[0])
node.createReverseNode(blink_att, w2.scale[0])
node.createReverseNode(blink_att, w4.scale[0])
###########################################
# Reparenting
###########################################
if parent:
try:
if isinstance(parent, basestring):
parent = pm.PyNode(parent)
parent.addChild(eye_root)
except pm.MayaNodeError:
pm.displayWarning("The eye rig can not be parent to: %s. Maybe "
"this object doesn't exist." % parent)
###########################################
# Auto Skinning
###########################################
if doSkin:
# eyelid vertex rows
totalLoops = rigidLoops + falloffLoops
vertexLoopList = meshNavigation.getConcentricVertexLoop(
vertexList, totalLoops)
vertexRowList = meshNavigation.getVertexRowsFromLoops(vertexLoopList)
# we set the first value 100% for the first initial loop
skinPercList = [1.0]
# we expect to have a regular grid topology
for r in range(rigidLoops):
for rr in range(2):
skinPercList.append(1.0)
increment = 1.0 / float(falloffLoops)
# we invert to smooth out from 100 to 0
inv = 1.0 - increment
for r in range(falloffLoops):
for rr in range(2):
if inv < 0.0:
inv = 0.0
skinPercList.append(inv)
inv -= increment
# this loop add an extra 0.0 indices to avoid errors
for r in range(10):
for rr in range(2):
skinPercList.append(0.0)
# base skin
geo = pm.listRelatives(edgeLoopList[0], parent=True)[0]
# Check if the object has a skinCluster
objName = pm.listRelatives(geo, parent=True)[0]
skinCluster = skin.getSkinCluster(objName)
if not skinCluster:
skinCluster = pm.skinCluster(headJnt,
geo,
tsb=True,
nw=2,
n='skinClsEyelid')
eyelidJoints = upperEyelid_jnt + lowerEyelid_jnt
pm.progressWindow(title='Auto skinning process',
progress=0,
max=len(eyelidJoints))
firstBoundary = False
for jnt in eyelidJoints:
pm.progressWindow(e=True, step=1, status='\nSkinning %s' % jnt)
skinCluster.addInfluence(jnt, weight=0)
v = meshNavigation.getClosestVertexFromTransform(geo, jnt)
for row in vertexRowList:
if v in row:
it = 0 # iterator
inc = 1 # increment
for i, rv in enumerate(row):
try:
perc = skinPercList[it]
t_val = [(jnt, perc), (headJnt, 1.0 - perc)]
pm.skinPercent(skinCluster,
rv,
transformValue=t_val)
if rv.isOnBoundary():
# we need to compare with the first boundary
# to check if the row have inverted direction
# and offset the value
if not firstBoundary:
firstBoundary = True
firstBoundaryValue = it
else:
if it < firstBoundaryValue:
it -= 1
elif it > firstBoundaryValue:
it += 1
inc = 2
except IndexError:
continue
it = it + inc
pm.progressWindow(e=True, endProgress=True)
# Eye Mesh skinning
skinCluster = skin.getSkinCluster(eyeMesh)
if not skinCluster:
skinCluster = pm.skinCluster(eyeCenter_jnt,
eyeMesh,
tsb=True,
nw=1,
n='skinClsEye')
def _addCurveDetailControllers(self, t, crv, name, skipHeadAndTail=False):
controls = []
cvs = crv.getCVs(space="world")
crv_info = node.createCurveInfoNode(crv)
if self.negate:
pass
# cvs = [cv for cv in reversed(cvs)]
# aim constrain targets and joints
icon_shape = "sphere"
color = 4
wd = .3
offset = self.offset * 0.3
for i, cv in enumerate(cvs):
if skipHeadAndTail and i == 0:
continue
if skipHeadAndTail and (i == len(cvs) - 1):
continue
# aim targets
trn_name = self.getName("{}_aimTarget{}".format(name, i))
trn = primitive.addTransformFromPos(self.eyeTargets_root, trn_name, pos=cv)
# connecting positions with crv
pm.connectAttr(crv_info + ".controlPoints[%s]" % str(i), trn.attr("translate"))
# joints
xform = setMatrixPosition(t, self.bboxCenter)
npo_name = self.getName("{}_jnt_base{}".format(name, str(i)))
npo = addTransform(self.jnt_root, npo_name, xform)
applyop.aimCns(npo, trn, axis="zy", wupObject=self.jnt_root)
xform = setMatrixPosition(t, cv)
npo_name = self.getName("{}_jnt{}_npo".format(name, str(i)))
npo = addTransform(npo, npo_name, xform)
ctl_name = "%s_crvdetail%s_%s" % (name, i, self.ctlName)
ctl = self.addCtl(
npo,
ctl_name,
xform,
color,
icon_shape,
w=wd,
d=wd,
ro=datatypes.Vector(1.57079633, 0, 0),
po=offset
)
self.addToSubGroup(ctl, self.detailControllersGroupName)
controls.append(ctl)
jnt_name = "{}{}".format(name, i)
self.jnt_pos.append([ctl, jnt_name])
return controls
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 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.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 addObjects(self):
"""Add all the objects needed to create the component."""
# joint Description Names
jd_names = ast.literal_eval(
self.settings["jointNamesDescription_custom"])
jdn_neck = jd_names[0]
jdn_head = jd_names[1]
self.normal = self.guide.blades["blade"].z * -1
self.up_axis = pm.upAxis(q=True, axis=True)
# Ik Controlers ------------------------------------
if self.settings["IKWorldOri"]:
t = datatypes.TransformationMatrix()
else:
t = transform.getTransformLookingAt(
self.guide.pos["tan1"],
self.guide.pos["neck"],
self.normal,
"yx",
self.negate,
)
t = transform.setMatrixPosition(t, self.guide.pos["neck"])
self.ik_off = primitive.addTransform(self.root, self.getName("ik_off"),
t)
# handle Z up orientation offset
if self.up_axis == "z" and self.settings["IKWorldOri"]:
self.ik_off.rx.set(90)
t = transform.getTransform(self.ik_off)
self.ik_cns = primitive.addTransform(self.ik_off,
self.getName("ik_cns"), t)
self.ik_ctl = self.addCtl(
self.ik_cns,
"ik_ctl",
t,
self.color_ik,
"compas",
w=self.size * 0.5,
tp=self.parentCtlTag,
)
attribute.setKeyableAttributes(self.ik_ctl, self.tr_params)
attribute.setRotOrder(self.ik_ctl, "ZXY")
attribute.setInvertMirror(self.ik_ctl, ["tx", "ry", "rz"])
# Tangents -----------------------------------------
if self.settings["tangentControls"]:
t = transform.setMatrixPosition(t, self.guide.pos["tan1"])
self.tan1_loc = primitive.addTransform(self.ik_ctl,
self.getName("tan1_loc"), t)
self.tan1_ctl = self.addCtl(
self.tan1_loc,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.2,
tp=self.ik_ctl,
)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
attribute.setInvertMirror(self.tan1_ctl, ["tx"])
t = transform.getTransformLookingAt(
self.guide.pos["root"],
self.guide.pos["tan0"],
self.normal,
"yx",
self.negate,
)
t = transform.setMatrixPosition(t, self.guide.pos["tan0"])
self.tan0_loc = primitive.addTransform(self.root,
self.getName("tan0_loc"), t)
self.tan0_ctl = self.addCtl(
self.tan0_loc,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=self.size * 0.2,
tp=self.ik_ctl,
)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
attribute.setInvertMirror(self.tan0_ctl, ["tx"])
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root,
self.getName("mst_crv"),
[self.root, self.tan0_ctl, self.tan1_ctl, self.ik_ctl],
3,
)
self.slv_crv = curve.addCurve(
self.root,
self.getName("slv_crv"),
[datatypes.Vector()] * 10,
False,
3,
)
self.mst_crv.setAttr("visibility", False)
else:
t = transform.setMatrixPosition(t, self.guide.pos["tan1"])
self.tan1_loc = primitive.addTransform(self.ik_ctl,
self.getName("tan1_loc"), t)
t = transform.getTransformLookingAt(
self.guide.pos["root"],
self.guide.pos["tan0"],
self.normal,
"yx",
self.negate,
)
t = transform.setMatrixPosition(t, self.guide.pos["tan0"])
self.tan0_loc = primitive.addTransform(self.root,
self.getName("tan0_loc"), t)
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root,
self.getName("mst_crv"),
[self.root, self.tan0_loc, self.tan1_loc, self.ik_ctl],
3,
)
self.slv_crv = curve.addCurve(
self.root,
self.getName("slv_crv"),
[datatypes.Vector()] * 10,
False,
3,
)
self.mst_crv.setAttr("visibility", False)
self.slv_crv.setAttr("visibility", False)
# Division -----------------------------------------
# The user only define how many intermediate division he wants.
# First and last divisions are an obligation.
parentdiv = self.root
parentctl = self.root
self.div_cns = []
self.fk_ctl = []
self.fk_npo = []
self.scl_npo = []
self.twister = []
self.ref_twist = []
# adding 1 for the head
self.divisions = self.settings["division"] + 1
parent_twistRef = primitive.addTransform(
self.root,
self.getName("reference"),
transform.getTransform(self.root),
)
t = transform.getTransformLookingAt(
self.guide.pos["root"],
self.guide.pos["neck"],
self.normal,
"yx",
self.negate,
)
self.intMRef = primitive.addTransform(self.root,
self.getName("intMRef"), t)
self.previousCtlTag = self.parentCtlTag
for i in range(self.divisions):
# References
div_cns = primitive.addTransform(parentdiv,
self.getName("%s_cns" % i), t)
pm.setAttr(div_cns + ".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
scl_npo = primitive.addTransform(
parentctl,
self.getName("%s_scl_npo" % i),
transform.getTransform(parentctl),
)
# Controlers (First and last one are fake)
if i in [self.divisions - 1]: # 0,
fk_ctl = primitive.addTransform(
scl_npo,
self.getName("%s_loc" % i),
transform.getTransform(parentctl),
)
fk_npo = fk_ctl
else:
fk_npo = primitive.addTransform(
scl_npo,
self.getName("fk%s_npo" % i),
transform.getTransform(parentctl),
)
fk_ctl = self.addCtl(
fk_npo,
"fk%s_ctl" % i,
transform.getTransform(parentctl),
self.color_fk,
"cube",
w=self.size * 0.2,
h=self.size * 0.05,
d=self.size * 0.2,
tp=self.previousCtlTag,
)
attribute.setKeyableAttributes(self.fk_ctl)
attribute.setRotOrder(fk_ctl, "ZXY")
self.previousCtlTag = fk_ctl
self.fk_ctl.append(fk_ctl)
self.scl_npo.append(scl_npo)
self.fk_npo.append(fk_npo)
parentctl = fk_ctl
if i != self.divisions - 1:
self.jnt_pos.append(
[fk_ctl,
string.replaceSharpWithPadding(jdn_neck, i + 1)])
t = transform.getTransformLookingAt(
self.guide.pos["root"],
self.guide.pos["neck"],
self.guide.blades["blade"].z * -1,
"yx",
self.negate,
)
twister = primitive.addTransform(parent_twistRef,
self.getName("%s_rot_ref" % i), t)
ref_twist = primitive.addTransform(parent_twistRef,
self.getName("%s_pos_ref" % i),
t)
ref_twist.setTranslation(datatypes.Vector(0.0, 0, 1.0),
space="preTransform")
self.twister.append(twister)
self.ref_twist.append(ref_twist)
for x in self.fk_ctl[:-1]:
attribute.setInvertMirror(x, ["tx", "rz", "ry"])
# Head ---------------------------------------------
t = transform.getTransformLookingAt(
self.guide.pos["head"],
self.guide.pos["eff"],
self.normal,
"yx",
self.negate,
)
self.head_cns = primitive.addTransform(self.root,
self.getName("head_cns"), t)
dist = vector.getDistance(self.guide.pos["head"],
self.guide.pos["eff"])
self.head_ctl = self.addCtl(
self.head_cns,
"head_ctl",
t,
self.color_fk,
"cube",
w=self.size * 0.5,
h=dist,
d=self.size * 0.5,
po=datatypes.Vector(0, dist * 0.5, 0),
tp=self.previousCtlTag,
)
attribute.setRotOrder(self.head_ctl, "ZXY")
attribute.setInvertMirror(self.head_ctl, ["tx", "rz", "ry"])
self.jnt_pos.append([self.head_ctl, jdn_head])
def addObjectsChainIk(self, i, crv):
cvs = crv.length()
if i == 0:
u = 0.
else:
u = crv.findParamFromLength(cvs / (self.settings["ikNb"] - 1) * i)
self.ik_uv_param.append(1. / (self.settings["ikNb"] - 1) * i)
space = om.MSpace.kWorld
pos = crv.getPointAtParam(u, space)
if i in [0, (self.settings["ikNb"] - 1)]:
t = getTransform(self.guide.root)
global_t = self._getTransformWithRollByBlade(t)
else:
u2 = crv.findParamFromLength(cvs / (self.settings["ikNb"] - 1) * i + 1)
pos2 = crv.getPointAtParam(u2, space)
t = getTransformLookingAt(pos, pos2, self.guide.blades["blade"].y, axis="yx", negate=self.negate)
# FIXME:
t = getTransform(self.guide.root)
global_t = self._getTransformWithRollByBlade(t)
global_t = setMatrixPosition(global_t, pos)
local_t = global_t
# global input
ik_global_npo = addTransform(self.root, self.getName("ik%s_global_npo" % i), global_t)
ik_global_in = addTransform(ik_global_npo, self.getName("ik%s_global_in" % i), global_t)
self.ik_global_in.append(ik_global_in)
# local input
ik_local_npo = addTransform(ik_global_in, self.getName("ik%s_local_npo" % i), local_t)
ik_local_in = addTransform(ik_local_npo, self.getName("ik%s_local_in" % i), local_t)
self.ik_local_in.append(ik_local_in)
ik_npo = addTransform(ik_local_in, self.getName("ik%s_npo" % i), local_t)
self.ik_npo.append(ik_npo)
# output
ik_global_out_npo = addTransform(self.root, self.getName("ik%s_global_out_npo" % i), global_t)
ik_global_out = addTransform(ik_global_out_npo, self.getName("ik%s_global_out" % i), global_t)
self.ik_global_out.append(ik_global_out)
# if i == 0 or i == (len(self.guide.apos) - 1):
if i == 0 or i == (self.settings["ikNb"] - 1):
ctl_form = "compas"
col = self.color_ik
size = self.size
w = size
h = size
d = size
else:
ctl_form = "compas" # TODO: set more better
col = self.color_ik
size = self.size * .85
w = size
h = size
d = size
ik_ctl = self.addCtl(
ik_npo,
"ik%s_ctl" % i,
local_t,
col,
ctl_form,
w=w,
h=h,
d=d,
# ro=datatypes.Vector([0, -math.pi / 2., 0]),
tp=self.previusTag,
mirrorConf=self.mirror_conf)
ymt_util.setKeyableAttributesDontLockVisibility(ik_ctl, self.tr_params)
self.ik_ctl.append(ik_ctl)
attribute.setInvertMirror(ik_ctl, ["tx", "rz", "ry"])
# ik global ref
ik_global_ref = primitive.addTransform(
ik_ctl,
self.getName("ik%s_global_ref" % i),
global_t)
self.ik_global_ref.append(ik_global_ref)
ymt_util.setKeyableAttributesDontLockVisibility(ik_global_ref, [])
def addObjects(self):
"""Add all the objects needed to create the component."""
if self.negate:
self.normal = self.guide.blades["blade"].z
axis = "yx"
else:
axis = "yx"
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis=axis,
negate=self.negate)
self.ctl_npo = primitive.addTransform(self.root,
self.getName("ctl_npo"), t)
self.base_ctl = self.addCtl(self.ctl_npo,
"base_ctl",
t,
self.color_ik,
"square",
w=.3,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.base_ctl, self.tr_params)
self.base_upv = primitive.addTransform(self.base_ctl,
self.getName("base_upv"), t)
self.base_upv.attr("tz").set(.01)
# tangent 0
vec_pos = self.guide.pos["tan0"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan0_npo = primitive.addTransform(self.base_ctl,
self.getName("tan0_npo"), t)
self.tan0_ctl = self.addCtl(self.tan0_npo,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=.4,
tp=self.base_ctl)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
self.tan0_upv = primitive.addTransform(self.tan0_ctl,
self.getName("tan0_upv"), t)
self.tan0_upv.attr("tz").set(.01)
t = transform.getTransformLookingAt(self.guide.apos[-2],
self.guide.apos[-1],
self.normal,
axis=axis,
negate=self.negate)
t = transform.setMatrixPosition(t, self.guide.apos[-1])
self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"),
t)
self.tip_npo = primitive.addTransform(self.ik_cns,
self.getName("tip_npo"), t)
self.tip_ctl = self.addCtl(self.tip_npo,
"tip_ctl",
t,
self.color_ik,
"square",
w=.3,
tp=self.base_ctl)
attribute.setKeyableAttributes(self.tip_ctl, self.tr_params)
self.tip_upv = primitive.addTransform(self.tip_ctl,
self.getName("tip_upv"), t)
self.tip_upv.attr("tz").set(.01)
# tangent 1
vec_pos = self.guide.pos["tan1"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan1_npo = primitive.addTransform(self.tip_ctl,
self.getName("tan1_npo"), t)
self.tan1_ctl = self.addCtl(self.tan1_npo,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=.4,
tp=self.tip_ctl)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
self.tan1_upv = primitive.addTransform(self.tan1_ctl,
self.getName("tan1_upv"), t)
self.tan1_upv.attr("tz").set(.01)
attribute.setInvertMirror(self.base_ctl, ["ty"])
attribute.setInvertMirror(self.tip_ctl, ["ty"])
attribute.setInvertMirror(self.tan0_ctl, ["ty"])
attribute.setInvertMirror(self.tan1_ctl, ["ty"])
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root, self.getName("mst_crv"),
[self.base_ctl, self.tan0_ctl, self.tan1_ctl, self.tip_ctl], 3)
self.upv_crv = curve.addCnsCurve(
self.root, self.getName("upv_crv"),
[self.base_upv, self.tan0_upv, self.tan1_upv, self.tip_upv], 3)
self.mst_crv.setAttr("visibility", False)
self.upv_crv.setAttr("visibility", False)
# Divisions
self.div_cns = []
self.upv_cns = []
tagP = self.parentCtlTag
self.extratweak_ctl = []
for i in range(self.settings["div"]):
# References
div_cns = primitive.addTransform(self.root,
self.getName("%s_cns" % i))
pm.setAttr(div_cns + ".inheritsTransform", False)
self.div_cns.append(div_cns)
upv_cns = primitive.addTransform(self.root,
self.getName("%s_upv" % i))
pm.setAttr(upv_cns + ".inheritsTransform", False)
self.upv_cns.append(upv_cns)
t = transform.getTransform(div_cns)
tweak_ctl = self.addCtl(div_cns,
"extraTweak%s_ctl" % i,
t,
self.color_fk,
"square",
w=self.size * .08,
d=self.size * .08,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=tagP)
attribute.setKeyableAttributes(tweak_ctl)
tagP = tweak_ctl
self.extratweak_ctl.append(tweak_ctl)
self.jnt_pos.append([tweak_ctl, i, None, False])
def addObjects(self):
"""Add all the objects needed to create the component."""
self.div_count = len(self.guide.apos) - 5
plane = [self.guide.apos[0], self.guide.apos[-4], self.guide.apos[-3]]
self.normal = self.getNormalFromPos(plane)
self.binormal = self.getBiNormalFromPos(plane)
# Heel ---------------------------------------------
# bank pivot
# Aim the heel towards the first locator, but flat to the world.
# So get the y component from itself.
#TODO: Try to see if the self.normal and self.binormal can be used to do this more intelligently.
heelLook = [
self.guide.apos[-4][0], self.guide.pos["heel"][1],
self.guide.apos[-4][2]
]
t = transform.getTransformLookingAt(self.guide.pos["heel"], heelLook,
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"], heelLook,
self.normal, "xz", self.negate)
self.heel_loc = primitive.addTransform(self.out_piv,
self.getName("heel_loc"), t)
attribute.setRotOrder(self.heel_loc, "YZX")
self.heel_ctl = self.addCtl(self.heel_loc,
"heel_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .1,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.heel_ctl, self.r_params)
# Tip ----------------------------------------------
v = datatypes.Vector(self.guide.apos[-5].x, self.guide.apos[-1].y,
self.guide.apos[-5].z)
t = transform.setMatrixPosition(t, v)
self.tip_ctl = self.addCtl(self.heel_ctl,
"tip_ctl",
t,
self.color_ik,
"circle",
w=self.size,
tp=self.heel_ctl)
attribute.setKeyableAttributes(self.tip_ctl, self.r_params)
# Roll ---------------------------------------------
if self.settings["useRollCtl"]:
t = transform.getTransformLookingAt(self.guide.pos["heel"],
heelLook, self.normal, "xz",
self.negate)
t = transform.setMatrixPosition(t, self.guide.pos["root"])
self.roll_np = primitive.addTransform(self.root,
self.getName("roll_npo"), t)
self.roll_ctl = self.addCtl(self.roll_np,
"roll_ctl",
t,
self.color_ik,
"cylinder",
w=self.size * .5,
h=self.size * .5,
ro=datatypes.Vector(3.1415 * .5, 0, 0),
tp=self.tip_ctl)
attribute.setKeyableAttributes(self.roll_ctl, ["rx", "rz"])
# Backward Controlers ------------------------------
bk_pos = self.guide.apos[1:-3]
bk_pos.reverse()
parent = self.tip_ctl
self.bk_ctl = []
self.bk_loc = []
self.previousTag = self.tip_ctl
for i, pos in enumerate(bk_pos):
if i == 0:
t = transform.getTransform(self.heel_ctl)
t = transform.setMatrixPosition(t, pos)
else:
dir = bk_pos[i - 1]
t = transform.getTransformLookingAt(pos, dir, self.normal,
"xz", self.negate)
bk_loc = primitive.addTransform(parent,
self.getName("bk%s_loc" % i), t)
bk_ctl = self.addCtl(bk_loc,
"bk%s_ctl" % i,
t,
self.color_ik,
"sphere",
w=self.size * .15,
tp=self.previousTag)
attribute.setKeyableAttributes(bk_ctl, self.r_params)
self.previousTag = bk_ctl
self.bk_loc.append(bk_loc)
self.bk_ctl.append(bk_ctl)
parent = bk_ctl
# FK Reference ------------------------------------
self.fk_ref = primitive.addTransformFromPos(self.bk_ctl[-1],
self.getName("fk_ref"),
self.guide.apos[0])
self.fk_npo = primitive.addTransform(
self.fk_ref, self.getName("fk0_npo"),
transform.getTransform(self.bk_ctl[-1]))
# Forward Controlers ------------------------------
self.fk_ctl = []
self.fk_loc = []
parent = self.fk_npo
self.previousTag = self.tip_ctl
for i, bk_ctl in enumerate(reversed(self.bk_ctl[1:])):
t = transform.getTransform(bk_ctl)
dist = vector.getDistance(self.guide.apos[i + 1],
self.guide.apos[i + 2])
fk_loc = primitive.addTransform(parent,
self.getName("fk%s_loc" % i), t)
po_vec = datatypes.Vector(dist * .5 * self.n_factor, 0, 0)
fk_ctl = self.addCtl(fk_loc,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=dist,
h=self.size * .5,
d=self.size * .5,
po=po_vec,
tp=self.previousTag)
self.previousTag = fk_ctl
attribute.setKeyableAttributes(fk_ctl)
self.jnt_pos.append([fk_ctl, i])
parent = fk_ctl
self.fk_ctl.append(fk_ctl)
self.fk_loc.append(fk_loc)
def addObjects(self):
"""Add all the objects needed to create the component."""
# Auto bend with position controls -------------------
if self.settings["autoBend"]:
self.autoBendChain = primitive.add2DChain(
self.root, self.getName("autoBend%s_jnt"),
[self.guide.apos[0], self.guide.apos[-1]],
self.guide.blades["blade"].z * -1, False, True)
for j in self.autoBendChain:
j.drawStyle.set(2)
# Ik Controlers ------------------------------------
if self.settings["IKWorldOri"]:
t = datatypes.TransformationMatrix()
t = transform.setMatrixPosition(t, self.guide.apos[0])
else:
t = transform.getTransformLookingAt(
self.guide.apos[0], self.guide.apos[-1],
self.guide.blades["blade"].z * -1, "yx", self.negate)
self.ik0_npo = primitive.addTransform(self.root,
self.getName("ik0_npo"), t)
self.ik0_ctl = self.addCtl(self.ik0_npo,
"ik0_ctl",
t,
self.color_ik,
"compas",
w=self.size,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.ik0_ctl, self.tr_params)
attribute.setRotOrder(self.ik0_ctl, "ZXY")
attribute.setInvertMirror(self.ik0_ctl, ["tx", "ry", "rz"])
# hip base joint
# TODO: add option in setting for on/off
if True:
self.hip_lvl = primitive.addTransform(self.ik0_ctl,
self.getName("hip_lvl"), t)
self.jnt_pos.append([self.hip_lvl, "hip"])
t = transform.setMatrixPosition(t, self.guide.apos[-1])
if self.settings["autoBend"]:
self.autoBend_npo = primitive.addTransform(
self.root, self.getName("spinePosition_npo"), t)
self.autoBend_ctl = self.addCtl(self.autoBend_npo,
"spinePosition_ctl",
t,
self.color_ik,
"square",
w=self.size,
d=.3 * self.size,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.autoBend_ctl,
["tx", "ty", "tz", "ry"])
attribute.setInvertMirror(self.autoBend_ctl, ["tx", "ry"])
self.ik1_npo = primitive.addTransform(self.autoBendChain[0],
self.getName("ik1_npo"), t)
self.ik1autoRot_lvl = primitive.addTransform(
self.ik1_npo, self.getName("ik1autoRot_lvl"), t)
self.ik1_ctl = self.addCtl(self.ik1autoRot_lvl,
"ik1_ctl",
t,
self.color_ik,
"compas",
w=self.size,
tp=self.autoBend_ctl)
else:
t = transform.setMatrixPosition(t, self.guide.apos[-1])
self.ik1_npo = primitive.addTransform(self.root,
self.getName("ik1_npo"), t)
self.ik1_ctl = self.addCtl(self.ik1_npo,
"ik1_ctl",
t,
self.color_ik,
"compas",
w=self.size,
tp=self.ik0_ctl)
attribute.setKeyableAttributes(self.ik1_ctl, self.tr_params)
attribute.setRotOrder(self.ik1_ctl, "ZXY")
attribute.setInvertMirror(self.ik1_ctl, ["tx", "ry", "rz"])
# Tangent controllers -------------------------------
if self.settings["centralTangent"]:
# vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
# self.guide.apos[-1],
# .33)
vec_pos = self.guide.pos["tan0"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan0_npo = primitive.addTransform(self.ik0_ctl,
self.getName("tan0_npo"), t)
self.tan0_off = primitive.addTransform(self.tan0_npo,
self.getName("tan0_off"), t)
self.tan0_ctl = self.addCtl(self.tan0_off,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .1,
tp=self.ik0_ctl)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
# vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
# self.guide.apos[-1],
# .66)
vec_pos = self.guide.pos["tan1"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan1_npo = primitive.addTransform(self.ik1_ctl,
self.getName("tan1_npo"), t)
self.tan1_off = primitive.addTransform(self.tan1_npo,
self.getName("tan1_off"), t)
self.tan1_ctl = self.addCtl(self.tan1_off,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .1,
tp=self.ik0_ctl)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
# Tangent mid control
vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
self.guide.apos[-1], .5)
t = transform.setMatrixPosition(t, vec_pos)
self.tan_npo = primitive.addTransform(self.tan0_npo,
self.getName("tan_npo"), t)
self.tan_ctl = self.addCtl(self.tan_npo,
"tan_ctl",
t,
self.color_fk,
"sphere",
w=self.size * .2,
tp=self.ik1_ctl)
attribute.setKeyableAttributes(self.tan_ctl, self.t_params)
attribute.setInvertMirror(self.tan_ctl, ["tx"])
else:
# vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
# self.guide.apos[-1],
# .33)
vec_pos = self.guide.pos["tan0"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan0_npo = primitive.addTransform(self.ik0_ctl,
self.getName("tan0_npo"), t)
self.tan0_ctl = self.addCtl(self.tan0_npo,
"tan0_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.ik0_ctl)
attribute.setKeyableAttributes(self.tan0_ctl, self.t_params)
# vec_pos = vector.linearlyInterpolate(self.guide.apos[0],
# self.guide.apos[-1],
# .66)
vec_pos = self.guide.pos["tan1"]
t = transform.setMatrixPosition(t, vec_pos)
self.tan1_npo = primitive.addTransform(self.ik1_ctl,
self.getName("tan1_npo"), t)
self.tan1_ctl = self.addCtl(self.tan1_npo,
"tan1_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .2,
tp=self.ik1_ctl)
attribute.setKeyableAttributes(self.tan1_ctl, self.t_params)
attribute.setInvertMirror(self.tan0_ctl, ["tx"])
attribute.setInvertMirror(self.tan1_ctl, ["tx"])
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root, self.getName("mst_crv"),
[self.ik0_ctl, self.tan0_ctl, self.tan1_ctl, self.ik1_ctl], 3)
self.slv_crv = curve.addCurve(self.root, self.getName("slv_crv"),
[datatypes.Vector()] * 10, False, 3)
self.mst_crv.setAttr("visibility", False)
self.slv_crv.setAttr("visibility", False)
# Division -----------------------------------------
# The user only define how many intermediate division he wants.
# First and last divisions are an obligation.
parentdiv = self.root
parentctl = self.root
self.div_cns = []
self.fk_ctl = []
self.fk_npo = []
self.scl_transforms = []
self.twister = []
self.ref_twist = []
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[-1],
self.guide.blades["blade"].z * -1,
"yx", self.negate)
parent_twistRef = primitive.addTransform(
self.root, self.getName("reference"),
transform.getTransform(self.root))
self.jointList = []
self.preiviousCtlTag = self.parentCtlTag
for i in range(self.settings["division"]):
# References
div_cns = primitive.addTransform(parentdiv,
self.getName("%s_cns" % i))
pm.setAttr(div_cns + ".inheritsTransform", False)
self.div_cns.append(div_cns)
parentdiv = div_cns
# Controlers (First and last one are fake)
# if i in [0]:
# TODO: add option setting to add or not the first and
# last controller for the fk
if i in [0, self.settings["division"] - 1] and False:
# if i in [0, self.settings["division"] - 1]:
fk_ctl = primitive.addTransform(
parentctl, self.getName("%s_loc" % i),
transform.getTransform(parentctl))
fk_npo = fk_ctl
if i in [self.settings["division"] - 1]:
self.fk_ctl.append(fk_ctl)
else:
m = transform.getTransform(self.root)
t = transform.getTransform(parentctl)
m.inverse()
fk_npo = primitive.addTransform(parentctl,
self.getName("fk%s_npo" % (i)),
t)
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % (i),
transform.getTransform(parentctl),
self.color_fk,
"cube",
w=self.size,
h=self.size * .05,
d=self.size,
tp=self.preiviousCtlTag)
attribute.setKeyableAttributes(self.fk_ctl)
attribute.setRotOrder(fk_ctl, "ZXY")
self.fk_ctl.append(fk_ctl)
self.preiviousCtlTag = fk_ctl
self.fk_npo.append(fk_npo)
parentctl = fk_ctl
scl_ref = primitive.addTransform(parentctl,
self.getName("%s_scl_ref" % i),
transform.getTransform(parentctl))
self.scl_transforms.append(scl_ref)
# Deformers (Shadow)
self.jnt_pos.append([scl_ref, i])
# Twist references (This objects will replace the spinlookup
# slerp solver behavior)
t = transform.getTransformLookingAt(
self.guide.apos[0], self.guide.apos[-1],
self.guide.blades["blade"].z * -1, "yx", self.negate)
twister = primitive.addTransform(parent_twistRef,
self.getName("%s_rot_ref" % i), t)
ref_twist = primitive.addTransform(parent_twistRef,
self.getName("%s_pos_ref" % i),
t)
ref_twist.setTranslation(datatypes.Vector(1.0, 0, 0),
space="preTransform")
self.twister.append(twister)
self.ref_twist.append(ref_twist)
# TODO: update this part with the optiona FK controls update
for x in self.fk_ctl[:-1]:
attribute.setInvertMirror(x, ["tx", "rz", "ry"])
# Connections (Hooks) ------------------------------
self.cnx0 = primitive.addTransform(self.root, self.getName("0_cnx"))
self.cnx1 = primitive.addTransform(self.root, self.getName("1_cnx"))
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.WIP = self.options["mode"]
if self.negate and self.settings["overrideNegate"]:
self.negate = False
self.n_factor = 1
if self.settings["overrideNegate"]:
self.mirror_conf = [0, 0, 1, 1, 1, 0, 0, 0, 0]
else:
self.mirror_conf = [0, 0, 0, 0, 0, 0, 0, 0, 0]
# FK controllers ------------------------------------
self.fk_npo = []
self.fk_global_in = []
self.fk_local_in = []
self.fk_local_out = []
self.fk_global_out = []
self.fk_global_ref = []
self.fk_ctl = []
self.tweak_ctl = []
self.upv_curv_lvl = []
t = self.guide.tra["root"]
parent = self.root
tOld = False
fk_ctl = None
self.previusTag = self.parentCtlTag
for i, t in enumerate(
transform.getChainTransform(self.guide.apos, self.normal,
self.negate)):
self.dist = vector.getDistance(self.guide.apos[i],
self.guide.apos[i + 1])
if self.settings["neutralpose"] or not tOld:
tnpo = t
else:
tnpo = transform.setMatrixPosition(
tOld, transform.getPositionFromMatrix(t))
# global input
global_t = transform.setMatrixPosition(
datatypes.Matrix(), transform.getPositionFromMatrix(t))
fk_global_npo = primitive.addTransform(
parent, self.getName("fk%s_global_npo" % i), global_t)
fk_global_in = primitive.addTransform(
fk_global_npo, self.getName("fk%s_global_in" % i), global_t)
self.fk_global_in.append(fk_global_in)
# local input
fk_local_npo = primitive.addTransform(
fk_global_in, self.getName("fk%s_local_npo" % i), tnpo)
fk_local_in = primitive.addTransform(
fk_local_npo, self.getName("fk%s_local_in" % i), tnpo)
self.fk_local_in.append(fk_local_in)
# output
fk_global_out_npo = primitive.addTransform(
parent, self.getName("fk%s_global_out_npo" % i), global_t)
fk_global_out = primitive.addTransform(
fk_global_out_npo, self.getName("fk%s_global_out" % i),
global_t)
self.fk_global_out.append(fk_global_out)
fk_local_out_npo = primitive.addTransform(
parent, self.getName("fk%s_local_out_npo" % i), tnpo)
fk_local_out = primitive.addTransform(
fk_local_out_npo, self.getName("fk%s_local_out" % i), tnpo)
self.fk_local_out.append(fk_local_out)
# fk npo
fk_npo = primitive.addTransform(fk_local_in,
self.getName("fk%s_npo" % i), tnpo)
self.fk_npo.append(fk_npo)
# ctl
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=self.dist,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(
self.dist * .5 * self.n_factor, 0, 0),
tp=self.previusTag,
mirrorConf=self.mirror_conf)
self.fk_ctl.append(fk_ctl)
# fk global ref
fk_global_ref = primitive.addTransform(
fk_ctl, self.getName("fk%s_global_ref" % i), global_t)
self.fk_global_ref.append(fk_global_ref)
attribute.setKeyableAttributes(fk_global_ref, [])
parent = fk_ctl
if not self.settings["simpleFK"]:
tweak_ctl = self.addCtl(fk_ctl,
"tweak%s_ctl" % i,
t,
self.color_ik,
"square",
w=self.size * .15,
h=self.size * .15,
d=self.size * .15,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=self.previusTag,
mirrorConf=self.mirror_conf)
upv_curv_lvl = primitive.addTransform(
tweak_ctl, self.getName("upv%s_lvl" % i), t)
upv_curv_lvl.attr("tz").set(.01)
self.tweak_ctl.append(tweak_ctl)
self.upv_curv_lvl.append(upv_curv_lvl)
tOld = t
self.previusTag = fk_ctl
if not self.settings["simpleFK"]:
# add end control
tweak_npo = primitive.addTransform(fk_ctl,
self.getName("tweakEnd_npo"), t)
tweak_ctl = self.addCtl(tweak_npo,
"tweakEnd_ctl",
t,
self.color_ik,
"square",
w=self.size * .15,
h=self.size * .15,
d=self.size * .15,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=self.previusTag,
mirrorConf=self.mirror_conf)
upv_curv_lvl = primitive.addTransform(tweak_ctl,
self.getName("upvEnd_lvl"),
t)
upv_curv_lvl.attr("tz").set(.01)
if self.negate:
self.off_dist = self.dist * -1
else:
self.off_dist = self.dist
tweak_npo.attr("tx").set(self.off_dist)
self.tweak_ctl.append(tweak_ctl)
self.upv_curv_lvl.append(upv_curv_lvl)
# add length offset control if keep length
# This option will be added only if keep length is active
if self.settings["keepLength"]:
self.tweakTip_npo = primitive.addTransform(
tweak_ctl, self.getName("tweakTip_npo"), t)
tweak_ctl = self.addCtl(self.tweakTip_npo,
"tweakTip_ctl",
t,
self.color_fk,
"square",
w=self.size * .1,
h=self.size * .1,
d=self.size * .1,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=self.previusTag,
mirrorConf=self.mirror_conf)
upv_curv_lvl = primitive.addTransform(
tweak_ctl, self.getName("upvTip_lvl"), t)
upv_curv_lvl.attr("tz").set(.01)
# move to align with the parent
self.tweakTip_npo.attr("tx").set(0)
self.tweak_ctl.append(tweak_ctl)
self.upv_curv_lvl.append(upv_curv_lvl)
# add visual reference
self.line_ref = icon.connection_display_curve(
self.getName("visualRef"),
[self.tweakTip_npo.getParent(), tweak_ctl])
# set keyable attr for tweak controls
[
attribute.setKeyableAttributes(t_ctl, ["tx", "ty", "tz", "rx"])
for t_ctl in self.tweak_ctl
]
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(self.root,
self.getName("mst_crv"),
self.tweak_ctl[:], 3)
self.upv_crv = curve.addCnsCurve(self.root,
self.getName("upv_crv"),
self.upv_curv_lvl, 3)
self.mst_crv.setAttr("visibility", False)
self.upv_crv.setAttr("visibility", False)
# Divisions
self.div_cns = []
self.upv_cns = []
if self.settings["overrideJntNb"]:
self.def_number = self.settings["jntNb"]
else:
self.def_number = len(self.guide.apos)
if self.settings["extraTweak"]:
tagP = self.parentCtlTag
self.extratweak_ctl = []
for i in range(self.def_number):
# References
div_cns = primitive.addTransform(self.root,
self.getName("%s_cns" % i))
pm.setAttr(div_cns + ".inheritsTransform", False)
self.div_cns.append(div_cns)
upv_cns = primitive.addTransform(self.root,
self.getName("%s_upv" % i))
pm.setAttr(upv_cns + ".inheritsTransform", False)
self.upv_cns.append(upv_cns)
# self.jnt_pos.append([div_cns, i])
if self.settings["extraTweak"]:
t = transform.getTransform(div_cns)
ro_vector = datatypes.Vector([0, 0, 1.5708])
tweak_ctl = self.addCtl(div_cns,
"extraTweak%s_ctl" % i,
t,
self.color_fk,
"square",
w=self.size * .08,
d=self.size * .08,
ro=ro_vector,
tp=tagP)
attribute.setKeyableAttributes(tweak_ctl)
tagP = tweak_ctl
self.extratweak_ctl.append(tweak_ctl)
self.jnt_pos.append([tweak_ctl, i, None, False])
else:
self.jnt_pos.append([div_cns, i])
