def null(parent=None,
name="null",
width=1,
color=[0, 0, 0],
m=datatypes.Matrix(),
pos_offset=None,
rot_offset=None):
"""Create a curve with a NULL shape.
Arguments:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from
its center.
rot_offset (vector): The xyz rotation offset of the curve from
its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * .5
v0 = datatypes.Vector(dlen, 0, 0)
v1 = datatypes.Vector(-dlen, 0, 0)
v2 = datatypes.Vector(0, dlen, 0)
v3 = datatypes.Vector(0, -dlen, 0)
v4 = datatypes.Vector(0, 0, dlen)
v5 = datatypes.Vector(0, 0, -dlen)
points = getPointArrayWithOffset([v0, v1], pos_offset, rot_offset)
node = curve.addCurve(parent, name, points, False, 1, m)
points = getPointArrayWithOffset([v2, v3], pos_offset, rot_offset)
crv_0 = curve.addCurve(parent, name, points, False, 1, m)
points = getPointArrayWithOffset([v4, v5], pos_offset, rot_offset)
crv_1 = curve.addCurve(parent, name, points, False, 1, m)
for crv in [crv_0, crv_1]:
for shp in crv.listRelatives(shapes=True):
node.addChild(shp, add=True, shape=True)
pm.delete(crv)
setcolor(node, color)
return node
def addCnsCurve(parent, name, centers, degree=1):
"""Create a curve attached to given centers. One point per center
Return gear curvecns node.
Arguments:
parent (dagNode): Parent object.
name (str): Name
centers (list of dagNode): Object that will drive the curve.
degree (int): 1 for linear curve, 3 for Cubic.
Returns:
dagNode: The newly created curve.
"""
# rebuild list to avoid input list modification
centers = centers[:]
if degree == 3:
if len(centers) == 2:
centers.insert(0, centers[0])
centers.append(centers[-1])
elif len(centers) == 3:
centers.append(centers[-1])
points = [datatypes.Vector() for center in centers]
node = curve.addCurve(parent, name, points, False, degree)
gearNode = applyop.gear_curvecns_op(node, centers)
return node, gearNode
def create_guide_rig(name,
pos,
scalp,
sections,
length,
thickness):
global COLOR
if pos:
face = transform.getClosestPolygonFromTransform(
pm.PyNode(scalp), pos)[0]
rot = transform.get_orientation_from_polygon(face)
# section distance
sd = length / (sections - 1)
points = []
x = 0.0
for s in range(sections):
p = [x, 0, 0]
points.append(p)
x += sd
# create curve
crv = curve.addCurve(None, name, points)
crv.rotate.set(rot)
crv.translate.set(pos)
# lock first point in the curve
curve.lock_first_point(crv)
# set color and thickness
curve.set_color(crv, COLOR)
curve.set_thickness(crv, thickness)
return crv
def cross(parent=None,
name="cross",
width=1,
color=[0, 0, 0],
m=datatypes.Matrix(),
pos_offset=None,
rot_offset=None):
"""Create a curve with a CROSS shape.
Arguments:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from
its center.
rot_offset (vector): The xyz rotation offset of the curve from
its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
width = width * 0.35
offset1 = width * .5
offset2 = width * 1.5
v0 = datatypes.Vector(width, offset2, 0)
v1 = datatypes.Vector(offset2, width, 0)
v2 = datatypes.Vector(offset1, 0, 0)
v3 = datatypes.Vector(offset2, -width, 0)
v4 = datatypes.Vector(width, -offset2, 0)
v5 = datatypes.Vector(0, -offset1, 0)
v6 = datatypes.Vector(-width, -offset2, 0)
v7 = datatypes.Vector(-offset2, -width, 0)
v8 = datatypes.Vector(-offset1, 0, 0)
v9 = datatypes.Vector(-offset2, width, 0)
v10 = datatypes.Vector(-width, offset2, 0)
v11 = datatypes.Vector(0, offset1, 0)
points = getPointArrayWithOffset(
[v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11], pos_offset,
rot_offset)
node = curve.addCurve(parent, name, points, True, 1, m)
setcolor(node, color)
return node
def cube(parent=None,
name="cube",
width=1,
height=1,
depth=1,
color=[0, 0, 0],
m=datatypes.Matrix(),
pos_offset=None,
rot_offset=None):
"""Create a curve with a CUBE shape.
Arguments:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
height (float): Height of the shape.
depth (float): Depth of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve
from its center.
rot_offset (vector): The xyz rotation offset of the curve
from its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
lenX = width * 0.5
lenY = height * 0.5
lenZ = depth * 0.5
# p is positive, N is negative
ppp = datatypes.Vector(lenX, lenY, lenZ)
ppN = datatypes.Vector(lenX, lenY, lenZ * -1)
pNp = datatypes.Vector(lenX, lenY * -1, lenZ)
Npp = datatypes.Vector(lenX * -1, lenY, lenZ)
pNN = datatypes.Vector(lenX, lenY * -1, lenZ * -1)
NNp = datatypes.Vector(lenX * -1, lenY * -1, lenZ)
NpN = datatypes.Vector(lenX * -1, lenY, lenZ * -1)
NNN = datatypes.Vector(lenX * -1, lenY * -1, lenZ * -1)
v_array = [
ppp, ppN, NpN, NNN, NNp, Npp, NpN, Npp, ppp, pNp, NNp, pNp, pNN, ppN,
pNN, NNN
]
points = getPointArrayWithOffset(v_array, pos_offset, rot_offset)
node = curve.addCurve(parent, name, points, False, 1, m)
setcolor(node, color)
return node
def guideBladeIcon(parent=None,
name="blade",
lenX=1.0,
color=[0, 0, 0],
m=datatypes.Matrix(),
pos_offset=None,
rot_offset=None):
"""Create a curve with a BLADE GUIDE shape.
Note:
This icon is specially design for **Shifter** blade guides
Arguments:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
lenX (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from
its center.
rot_offset (vector): The xyz rotation offset of the curve from
its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
v0 = datatypes.Vector(0, 0, 0)
v1 = datatypes.Vector(lenX / 2, 0, 0)
v2 = datatypes.Vector(lenX, lenX / 4, 0)
v3 = datatypes.Vector(lenX / 2, lenX / 2, 0)
v4 = datatypes.Vector(0, lenX / 2, 0)
points = getPointArrayWithOffset([v0, v1, v2, v3, v4], pos_offset,
rot_offset)
bladeIco = curve.addCurve(parent, name, points, True, 1, m)
setcolor(bladeIco, color)
attribute.setNotKeyableAttributes(bladeIco)
attribute.unlockAttribute(bladeIco,
attributes=[
"tx", "ty", "tz", "rx", "ry", "rz", "sx",
"sy", "sz", "v", "ro"
])
# bladeIco.scale.set(1, 1, 1)
# Set the control shapes isHistoricallyInteresting
for oShape in bladeIco.getShapes():
oShape.isHistoricallyInteresting.set(False)
return bladeIco
def cubewithpeak(parent=None,
name="cubewithpeak",
width=1,
color=[0, 0, 0],
m=datatypes.Matrix(),
pos_offset=None,
rot_offset=None):
"""Create a curve with a CUBE WITH PEAK shape.
Arguments:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from
its center.
rot_offset (vector): The xyz rotation offset of the curve from
its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * 0.5
peak = datatypes.Vector(0, width, 0)
ppp = datatypes.Vector(dlen, dlen, dlen)
ppN = datatypes.Vector(dlen, dlen, dlen * -1)
pNp = datatypes.Vector(dlen, 0, dlen)
Npp = datatypes.Vector(dlen * -1, dlen, dlen)
pNN = datatypes.Vector(dlen, 0, dlen * -1)
NNp = datatypes.Vector(dlen * -1, 0, dlen)
NpN = datatypes.Vector(dlen * -1, dlen, dlen * -1)
NNN = datatypes.Vector(dlen * -1, 0, dlen * -1)
v_array = [
peak, ppp, ppN, peak, NpN, ppN, NpN, peak, Npp, NpN, NNN, NNp, Npp,
NpN, Npp, ppp, pNp, NNp, pNp, pNN, ppN, pNN, NNN
]
points = getPointArrayWithOffset(v_array, pos_offset, rot_offset)
node = curve.addCurve(parent, name, points, False, 1, m)
setcolor(node, color)
return node
def diamond(parent=None,
name="diamond",
width=1,
color=[0, 0, 0],
m=datatypes.Matrix(),
pos_offset=None,
rot_offset=None):
"""Create a curve with a DIAMOND shape.
Arguments:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
height (float): Height of the shape.
depth (float): Depth of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from
its center.
rot_offset (vector): The xyz rotation offset of the curve from
its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * 0.5
top = datatypes.Vector(0, dlen, 0)
pp = datatypes.Vector(dlen, 0, dlen)
pN = datatypes.Vector(dlen, 0, dlen * -1)
Np = datatypes.Vector(dlen * -1, 0, dlen)
NN = datatypes.Vector(dlen * -1, 0, dlen * -1)
bottom = (0, -dlen, 0)
v_array = [
pp, top, pN, pp, Np, top, NN, Np, NN, pN, bottom, NN, bottom, Np,
bottom, pp
]
points = getPointArrayWithOffset(v_array, pos_offset, rot_offset)
node = curve.addCurve(parent, name, points, False, 1, m)
setcolor(node, color)
return node
def compas(parent=None,
name="compas",
width=1,
color=[0, 0, 0],
m=datatypes.Matrix(),
pos_offset=None,
rot_offset=None,
degree=3):
"""Create a curve with a COMPAS shape.
Arguments:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from
its center.
rot_offset (vector): The xyz rotation offset of the curve from
its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * 0.5
division = 24
point_pos = []
v = datatypes.Vector(0, 0, dlen)
for i in range(division):
if i == division / 2:
w = datatypes.Vector(v.x, v.y, v.z - dlen * .4)
else:
w = datatypes.Vector(v.x, v.y, v.z)
point_pos.append(w)
v = v.rotateBy((0, (2 * pmu.math.pi) / (division + 0.0), 0))
points = getPointArrayWithOffset(point_pos, pos_offset, rot_offset)
node = curve.addCurve(parent, name, points, True, degree, m)
setcolor(node, color)
return node
def circle(parent=None,
name="circle",
width=1,
color=[0, 0, 0],
m=datatypes.Matrix(),
pos_offset=None,
rot_offset=None,
degree=3):
"""Create a curve with a CIRCLE shape.
Arguments:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from
its center.
rot_offset (vector): The xyz rotation offset of the curve from
its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * 0.5
v0 = datatypes.Vector(0, 0, -dlen * 1.108)
v1 = datatypes.Vector(dlen * .78, 0, -dlen * .78)
v2 = datatypes.Vector(dlen * 1.108, 0, 0)
v3 = datatypes.Vector(dlen * .78, 0, dlen * .78)
v4 = datatypes.Vector(0, 0, dlen * 1.108)
v5 = datatypes.Vector(-dlen * .78, 0, dlen * .78)
v6 = datatypes.Vector(-dlen * 1.108, 0, 0)
v7 = datatypes.Vector(-dlen * .78, 0, -dlen * .78)
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7],
pos_offset, rot_offset)
node = curve.addCurve(parent, name, points, True, degree, m)
setcolor(node, color)
return node
def addCurve(parent, name, centers, degree=1):
"""Create a curve based on given centers. One point per center
"""
# rebuild list to avoid input list modification
centers = centers[:]
if degree == 3:
if len(centers) == 2:
centers.insert(0, centers[0])
centers.append(centers[-1])
elif len(centers) == 3:
centers.append(centers[-1])
# points = [datatypes.Vector() for center in centers]
points = []
for center in centers:
points.append(center.getTranslation(space="world"))
node = curve.addCurve(parent, name, points, False, degree)
return node
def square(parent=None,
name="square",
width=1,
depth=1,
color=[0, 0, 0],
m=datatypes.Matrix(),
pos_offset=None,
rot_offset=None):
"""Create a curve with a SQUARE shape.
Arguments:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
depth (float): Depth of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from
its center.
rot_offset (vector): The xyz rotation offset of the curve from
its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
lenX = width * 0.5
lenZ = depth * 0.5
v0 = datatypes.Vector(lenX, 0, lenZ)
v1 = datatypes.Vector(lenX, 0, lenZ * -1)
v2 = datatypes.Vector(lenX * -1, 0, lenZ * -1)
v3 = datatypes.Vector(lenX * -1, 0, lenZ)
points = getPointArrayWithOffset([v0, v1, v2, v3], pos_offset, rot_offset)
node = curve.addCurve(parent, name, points, True, 1, m)
setcolor(node, color)
return node
def addTCurve(self, name, rotation=None, parent=None):
"""Creates a T shape to show the boundaries of the slider.
"""
points = [
datatypes.Vector(0, 0, 0),
datatypes.Vector(0, 1, 0),
datatypes.Vector(0.2, 1, 0),
datatypes.Vector(-0.2, 1, 0)
]
if rotation:
rot_offset = datatypes.Vector(math.radians(rotation.x),
math.radians(rotation.y),
math.radians(rotation.z))
points = icon.getPointArrayWithOffset(points,
rot_offset=rot_offset)
t_curve = curve.addCurve(parent=parent,
name=name,
points=points,
degree=1)
return t_curve
def addObjects(self):
"""Add all the objects needed to create the component."""
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.guide.blades["blade"].z * -1,
"yx", self.negate)
t2 = transform.setMatrixPosition(t, self.guide.apos[1])
int_t = t
self.preiviousCtlTag = self.parentCtlTag
# FK Controlers ------------------------------------
self.fk_ctl = []
self.fk_npo = []
parentctl = self.root
blend_increment = 1.0 / (self.settings["division"] - 1)
blend_val = 0.0
for i in range(self.settings["division"]):
fk_npo = primitive.addTransform(parentctl,
self.getName("fk%s_npo" % (i)),
int_t)
self.fk_npo.append(fk_npo)
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % (i),
int_t,
self.color_fk,
"cube",
w=self.size,
h=self.size * .05,
d=self.size,
tp=self.preiviousCtlTag)
self.fk_ctl.append(fk_ctl)
self.preiviousCtlTag = fk_ctl
parentctl = fk_ctl
blend_val = blend_val + blend_increment
int_t = transform.getInterpolateTransformMatrix(t,
t2,
blend=blend_val)
for x in self.fk_ctl:
attribute.setKeyableAttributes(x)
attribute.setRotOrder(x, "ZXY")
attribute.setInvertMirror(x, ["tx", "rz", "ry"])
# Ik Controlers ------------------------------------
self.ik0_npo = primitive.addTransform(self.fk_ctl[0],
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"])
t = transform.setMatrixPosition(t, self.guide.apos[1])
self.ik1_npo = primitive.addTransform(self.fk_ctl[-1],
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)
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)
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)
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)
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.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
parentctl = div_cns
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)
# 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]
# IK controls ---------------------------------------------
self.ik_ctl = []
# tOld = False
self.previusTag = self.parentCtlTag
for i, t in enumerate(
transform.getChainTransform2(self.guide.apos, self.normal,
self.negate)):
ik_npo = primitive.addTransform(self.root,
self.getName("ik%s_npo" % i), t)
ik_ctl = self.addCtl(ik_npo,
"ik%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)
attribute.setKeyableAttributes(ik_ctl, self.tr_params)
self.ik_ctl.append(ik_ctl)
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(self.root, self.getName("mst_crv"),
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_transforms = []
self.twister = []
self.ref_twist = []
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["fkNb"]):
# 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
if i in [0, self.settings["fkNb"] - 1] and False:
fk_ctl = primitive.addTransform(
parentctl, self.getName("%s_loc" % i),
transform.getTransform(parentctl))
fk_npo = fk_ctl
if i in [self.settings["fkNb"] - 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 * .1,
h=self.size * .1,
d=self.size * .1,
tp=self.preiviousCtlTag,
mirrorConf=self.mirror_conf)
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)
for x in self.fk_ctl[:-1]:
attribute.setInvertMirror(x, ["tx", "rz", "ry"])
def crossarrow(parent=None,
name="crossArrow",
width=1,
color=[0, 0, 0],
m=datatypes.Matrix(),
pos_offset=None,
rot_offset=None):
"""Create a curve with a CROSS ARROW shape.
Arguments:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from
its center.
rot_offset (vector): The xyz rotation offset of the curve from
its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * 0.5
v0 = datatypes.Vector(0.2 * dlen, 0, 0.2 * dlen)
v1 = datatypes.Vector(0.2 * dlen, 0, 0.6 * dlen)
v2 = datatypes.Vector(0.4 * dlen, 0, 0.6 * dlen)
v3 = datatypes.Vector(0, 0, dlen)
v4 = datatypes.Vector(-0.4 * dlen, 0, 0.6 * dlen)
v5 = datatypes.Vector(-0.2 * dlen, 0, 0.6 * dlen)
v6 = datatypes.Vector(-0.2 * dlen, 0, 0.2 * dlen)
v7 = datatypes.Vector(-0.6 * dlen, 0, 0.2 * dlen)
v8 = datatypes.Vector(-0.6 * dlen, 0, 0.4 * dlen)
v9 = datatypes.Vector(-dlen, 0, 0)
v10 = datatypes.Vector(-0.6 * dlen, 0, -0.4 * dlen)
v11 = datatypes.Vector(-0.6 * dlen, 0, -0.2 * dlen)
v12 = datatypes.Vector(-0.2 * dlen, 0, -0.2 * dlen)
v13 = datatypes.Vector(-0.2 * dlen, 0, -0.6 * dlen)
v14 = datatypes.Vector(-0.4 * dlen, 0, -0.6 * dlen)
v15 = datatypes.Vector(0, 0, -dlen)
v16 = datatypes.Vector(0.4 * dlen, 0, -0.6 * dlen)
v17 = datatypes.Vector(0.2 * dlen, 0, -0.6 * dlen)
v18 = datatypes.Vector(0.2 * dlen, 0, -0.2 * dlen)
v19 = datatypes.Vector(0.6 * dlen, 0, -0.2 * dlen)
v20 = datatypes.Vector(0.6 * dlen, 0, -0.4 * dlen)
v21 = datatypes.Vector(dlen, 0, 0)
v22 = datatypes.Vector(0.6 * dlen, 0, 0.4 * dlen)
v23 = datatypes.Vector(0.6 * dlen, 0, 0.2 * dlen)
v_array = [
v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,
v16, v17, v18, v19, v20, v21, v22, v23
]
points = getPointArrayWithOffset(v_array, pos_offset, rot_offset)
node = curve.addCurve(parent, name, points, True, 1, m)
setcolor(node, color)
return node
def sphere(parent=None,
name="sphere",
width=1,
color=[0, 0, 0],
m=datatypes.Matrix(),
pos_offset=None,
rot_offset=None,
degree=3):
"""Create a curve with a SPHERE shape.
Arguments:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from
its center.
rot_offset (vector): The xyz rotation offset of the curve from
its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * .5
v0 = datatypes.Vector(0, 0, -dlen * 1.108)
v1 = datatypes.Vector(dlen * .78, 0, -dlen * .78)
v2 = datatypes.Vector(dlen * 1.108, 0, 0)
v3 = datatypes.Vector(dlen * .78, 0, dlen * .78)
v4 = datatypes.Vector(0, 0, dlen * 1.108)
v5 = datatypes.Vector(-dlen * .78, 0, dlen * .78)
v6 = datatypes.Vector(-dlen * 1.108, 0, 0)
v7 = datatypes.Vector(-dlen * .78, 0, -dlen * .78)
ro = datatypes.Vector([1.5708, 0, 0])
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7],
pos_offset, rot_offset)
node = curve.addCurve(parent, name, points, True, degree, m)
if rot_offset:
rot_offset += ro
else:
rot_offset = ro
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7],
pos_offset, rot_offset)
crv_0 = curve.addCurve(parent, node + "_0crv", points, True, degree, m)
ro = datatypes.Vector([1.5708, 0, 1.5708])
if rot_offset:
rot_offset += ro
else:
rot_offset = ro
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7],
pos_offset, rot_offset + ro + ro)
crv_1 = curve.addCurve(parent, node + "_1crv", points, True, degree, m)
for crv in [crv_0, crv_1]:
for shp in crv.listRelatives(shapes=True):
node.addChild(shp, add=True, shape=True)
pm.delete(crv)
setcolor(node, color)
return node
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.WIP = self.options["mode"]
if self.negate and self.settings["overrideNegate"]:
self.negate = False
self.n_factor = 1
# FK controllers ------------------------------------
self.fk_npo = []
self.fk_ctl = []
self.tweak_npo = []
self.tweak_ctl = []
self.curv_pos = []
self.upv_curv_pos = []
self.upv_curv_lvl = []
self.tangentsCtl = []
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))
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=self.dist,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(self.dist * .5 * self.n_factor, 0, 0),
tp=self.previusTag)
tweak_npo = primitive.addTransform(
parent, self.getName("tweak%s_npo" % i), tnpo)
self.tweak_npo.append(tweak_npo)
tweak_ctl = self.addCtl(
tweak_npo,
"tweak%s_ctl" % i,
t,
self.color_ik,
"cube",
w=self.size * .15,
h=self.size * .05,
d=self.size * .15,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=self.previusTag)
upv_curv_lvl = primitive.addTransform(
tweak_ctl, self.getName("upv%s_lvl" % i), t)
upv_curv_lvl.attr("tz").set(.01)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
self.tweak_ctl.append(tweak_ctl)
self.upv_curv_lvl.append(upv_curv_lvl)
tOld = t
self.previusTag = fk_ctl
parent = fk_ctl
# TANGENTS
tangents = []
tangents_npo = []
tangents_upv = []
if not i:
letters = "A"
else:
letters = "AB"
for tang in letters:
tang_npo = primitive.addTransform(
tweak_ctl,
self.getName("tng{}{}_npo".format(tang, str(i))),
t)
tangents_npo.append(tang_npo)
tang_ctl = self.addCtl(
tang_npo,
"tng{}{}_ctl".format(tang, str(i)),
t,
self.color_ik,
"square",
w=self.size * .07,
h=self.size * .07,
d=self.size * .07,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=self.previusTag)
upv_tang_curv_lvl = primitive.addTransform(
tang_ctl,
self.getName("tngUpv{}{}_lvl".format(tang, str(i))),
t)
upv_tang_curv_lvl.attr("tz").set(.01)
tangents_upv.append(upv_tang_curv_lvl)
tangents.append(tang_ctl)
tangents_npo[0].attr("tx").set(self.dist * .3333)
# delete the first B tangent
if not i:
self.curv_pos.append(tweak_ctl)
self.curv_pos.append(tangents[0])
self.upv_curv_pos.append(upv_curv_lvl)
self.upv_curv_pos.append(tangents_upv[0])
else:
self.curv_pos.append(tangents[1])
self.curv_pos.append(tweak_ctl)
self.curv_pos.append(tangents[0])
self.upv_curv_pos.append(tangents_upv[1])
self.upv_curv_pos.append(upv_curv_lvl)
self.upv_curv_pos.append(tangents_upv[0])
tangents_npo[1].attr("tx").set(self.dist * -.3333)
self.tangentsCtl.extend(tangents)
# ==========
# self.jnt_pos.append([fk_ctl, i, None, False])
# 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,
"cube",
w=self.size * .15,
h=self.size * .05,
d=self.size * .15,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=self.previusTag)
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)
# tangent END
tang_npo = primitive.addTransform(
tweak_ctl,
self.getName("tngEnd{}_npo".format(tang, str(i))),
t)
tang_ctl = self.addCtl(
tang_npo,
"tngEnd{}_ctl".format(tang, str(i)),
t,
self.color_ik,
"square",
w=self.size * .07,
h=self.size * .07,
d=self.size * .07,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=self.previusTag)
upv_tang_curv_lvl = primitive.addTransform(
tang_ctl,
self.getName("tngUpv{}{}_lvl".format(tang, str(i))),
t)
upv_tang_curv_lvl.attr("tz").set(.01)
tangents_upv.append(upv_tang_curv_lvl)
tang_npo.attr("tx").set(self.dist * -.3333)
self.curv_pos.append(tang_ctl)
self.curv_pos.append(tweak_ctl)
self.upv_curv_pos.append(tang_ctl)
self.upv_curv_pos.append(upv_curv_lvl)
self.tangentsCtl.append(tang_ctl)
# 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)
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])
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(self.root,
self.getName("mst_crv"),
self.curv_pos,
3)
self.slv_crv = curve.addCurve(self.root, self.getName("slv_crv"),
[datatypes.Vector()] * 32,
False,
3)
self.upv_crv = curve.addCnsCurve(self.root,
self.getName("upv_crv"),
self.upv_curv_pos,
3)
self.slv_upv_crv = curve.addCurve(self.root,
self.getName("slv_upv_crv"),
[datatypes.Vector()] * 32,
False,
3)
self.mst_crv.setAttr("template", True)
self.slv_crv.setAttr("visibility", False)
self.upv_crv.setAttr("visibility", False)
self.slv_upv_crv.setAttr("visibility", False)
# Divisions
self.div_cns = []
self.upv_cns = []
tagP = self.parentCtlTag
self.Extra_tweak_npo = []
self.Extra_tweak_ctl = []
if self.settings["overrideJntNb"]:
self.def_number = self.settings["jntNb"]
else:
self.def_number = len(self.guide.apos)
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)
t = transform.getTransform(div_cns)
extraTweak_npo = primitive.addTransform(
div_cns,
self.getName("extraTweak{}_npo".format(tang, str(i))),
t)
self.Extra_tweak_npo.append(extraTweak_npo)
Extra_tweak_ctl = self.addCtl(extraTweak_npo,
"extraTweak%s_ctl" % i,
t,
self.color_fk,
"circle",
w=self.size * .15,
d=self.size * .15,
ro=datatypes.Vector([0, 0, 1.5708]),
tp=tagP)
attribute.setKeyableAttributes(Extra_tweak_ctl)
self.Extra_tweak_ctl.append(Extra_tweak_ctl)
self.jnt_pos.append([Extra_tweak_ctl, i])
def addObjects(self):
"""Add all the objects needed to create the component."""
# FIXME: remove unneccessary guide.tan
self.guide.apos.pop()
self.divisions = len(self.guide.apos)
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]
# --------------------------------------------------------
self.ik_ctl = []
self.ik_npo = []
self.ik_global_in = []
self.ik_local_in = []
self.ik_global_out = []
self.ik_global_ref = []
self.ik_uv_param = []
self.previusTag = self.parentCtlTag
self.div_cns = []
self.div_cns_npo = []
self.fk_ctl = []
self.fk_npo = []
self.fk_local_npo = []
self.scl_transforms = []
self.twister = []
self.ref_twist = []
self.fk_global_in = []
self.fk_local_in = []
self.fk_global_out = []
self.fk_global_ref = []
self.fk_uv_param = []
# IK controls ---------------------------------------------
self.dummy_crv = curve.addCurve(
self.root,
self.getName("dummy_crv"),
self.guide.apos,
close=False,
degree=min([len(self.guide.apos) - 1, 3])
)
for i in range(self.settings["ikNb"]):
self.addObjectsChainIk(i, self.dummy_crv)
pm.delete(self.dummy_crv)
# Curves -------------------------------------------
self.mst_crv = curve.addCnsCurve(
self.root,
self.getName("mst_crv"),
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)
icon.connection_display_curve(self.getName("visualIKRef"), self.ik_ctl)
if self.settings["isGlobalMaster"]:
return
else:
self.addObjectsFkControl()
def cylinder(parent=None,
name="cylinder",
width=1,
heigth=1,
color=[0, 0, 0],
m=datatypes.Matrix(),
pos_offset=None,
rot_offset=None,
degree=3):
"""Create a curve with a CYLINDER shape.
Arguments:
parent (dagNode): The parent object of the newly created curve.
name (str): Name of the curve.
width (float): Width of the shape.
height (float): Height of the shape.
color (int or list of float): The color in index base or RGB.
m (matrix): The global transformation of the curve.
pos_offset (vector): The xyz position offset of the curve from
its center.
rot_offset (vector): The xyz rotation offset of the curve from
its center. xyz in radians
Returns:
dagNode: The newly created icon.
"""
dlen = width * .5
dhei = heigth * .5
if degree == 3:
offsetMult = 1
else:
offsetMult = 1.108
# upper circle
v0 = datatypes.Vector(0, dhei, -dlen * 1.108)
v1 = datatypes.Vector(dlen * .78, dhei, -dlen * .78)
v2 = datatypes.Vector(dlen * 1.108, dhei, 0)
v3 = datatypes.Vector(dlen * .78, dhei, dlen * .78)
v4 = datatypes.Vector(0, dhei, dlen * 1.108)
v5 = datatypes.Vector(-dlen * .78, dhei, dlen * .78)
v6 = datatypes.Vector(-dlen * 1.108, dhei, 0)
v7 = datatypes.Vector(-dlen * .78, dhei, -dlen * .78)
# lower circle
v8 = datatypes.Vector(0, -dhei, -dlen * 1.108)
v9 = datatypes.Vector(dlen * .78, -dhei, -dlen * .78)
v10 = datatypes.Vector(dlen * 1.108, -dhei, 0)
v11 = datatypes.Vector(dlen * .78, -dhei, dlen * .78)
v12 = datatypes.Vector(0, -dhei, dlen * 1.108)
v13 = datatypes.Vector(-dlen * .78, -dhei, dlen * .78)
v14 = datatypes.Vector(-dlen * 1.108, -dhei, 0)
v15 = datatypes.Vector(-dlen * .78, -dhei, -dlen * .78)
# curves
v16 = datatypes.Vector(0, dhei, -dlen * offsetMult)
v17 = datatypes.Vector(0, -dhei, -dlen * offsetMult)
v18 = datatypes.Vector(0, -dhei, dlen * offsetMult)
v19 = datatypes.Vector(0, dhei, dlen * offsetMult)
v20 = datatypes.Vector(dlen * offsetMult, dhei, 0)
v21 = datatypes.Vector(dlen * offsetMult, -dhei, 0)
v22 = datatypes.Vector(-dlen * offsetMult, -dhei, 0)
v23 = datatypes.Vector(-dlen * offsetMult, dhei, 0)
points = getPointArrayWithOffset([v0, v1, v2, v3, v4, v5, v6, v7],
pos_offset, rot_offset)
node = curve.addCurve(parent, name, points, True, degree, m)
points = getPointArrayWithOffset([v8, v9, v10, v11, v12, v13, v14, v15],
pos_offset, rot_offset)
crv_0 = curve.addCurve(parent, node + "_0crv", points, True, degree, m)
points = getPointArrayWithOffset([v16, v17], pos_offset, rot_offset)
crv_1 = curve.addCurve(parent, node + "_1crv", points, True, 1, m)
points = getPointArrayWithOffset([v18, v19], pos_offset, rot_offset)
crv_2 = curve.addCurve(parent, node + "_2crv", points, True, 1, m)
points = getPointArrayWithOffset([v20, v21], pos_offset, rot_offset)
crv_3 = curve.addCurve(parent, node + "_3crv", points, True, 1, m)
points = getPointArrayWithOffset([v22, v23], pos_offset, rot_offset)
crv_4 = curve.addCurve(parent, node + "_4crv", points, True, 1, m)
for crv in [crv_0, crv_1, crv_2, crv_3, crv_4]:
for shp in crv.listRelatives(shapes=True):
node.addChild(shp, add=True, shape=True)
pm.delete(crv)
setcolor(node, color)
return node
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 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.up_axis = pm.upAxis(q=True, axis=True)
# Auto bend with position controls -------------------
if self.settings["autoBend"]:
self.autoBendChain = primitive.add2DChain(
self.root, self.getName("autoBend%s_jnt"),
[self.guide.apos[1], self.guide.apos[-2]],
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[1])
else:
t = transform.getTransformLookingAt(
self.guide.apos[1], self.guide.apos[-2],
self.guide.blades["blade"].z * -1, "yx", self.negate)
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.ik0_npo = primitive.addTransform(self.ik_off,
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"])
# pelvis
self.length0 = vector.getDistance(self.guide.apos[0],
self.guide.apos[1])
vec_po = datatypes.Vector(0, .5 * self.length0 * -1, 0)
self.pelvis_npo = primitive.addTransform(self.ik0_ctl,
self.getName("pelvis_npo"), t)
self.pelvis_ctl = self.addCtl(self.pelvis_npo,
"pelvis_ctl",
t,
self.color_ik,
"cube",
h=self.length0,
w=self.size * .1,
d=self.size * .1,
po=vec_po,
tp=self.parentCtlTag)
self.pelvis_lvl = primitive.addTransform(
self.pelvis_ctl, self.getName("pelvis_lvl"),
transform.setMatrixPosition(t, self.guide.apos[0]))
self.jnt_pos.append([self.pelvis_lvl, "pelvis"])
t = transform.setMatrixPosition(t, self.guide.apos[-2])
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[-2])
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 = 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 = 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[1],
self.guide.apos[-2], .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 = 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 = 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[1],
self.guide.apos[-2],
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
t = transform.getTransform(parentctl)
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
if i == self.settings["division"] - 1:
t = transform.getTransformLookingAt(
self.guide.pos["spineTop"], self.guide.pos["chest"],
self.guide.blades["blade"].z * -1, "yx", False)
scl_ref_parent = self.root
else:
t = transform.getTransform(parentctl)
scl_ref_parent = parentctl
scl_ref = primitive.addTransform(scl_ref_parent,
self.getName("%s_scl_ref" % i), t)
self.scl_transforms.append(scl_ref)
# Deformers (Shadow)
self.jnt_pos.append([scl_ref, "spine_" + str(i + 1).zfill(2)])
# 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)
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"))
self.jnt_pos.append([self.cnx1, "spine_" + str(i + 2).zfill(2)])
