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."""
if self.settings["neutralRotation"]:
t = transform.getTransformFromPos(self.guide.pos["root"])
else:
t = self.guide.tra["root"]
if self._needToMirror():
scl = [1, 1, 1]
scl[0] = -1 if self.settings["mirrorAxisX"] else 1
scl[1] = -1 if self.settings["mirrorAxisY"] else 1
scl[2] = -1 if self.settings["mirrorAxisZ"] else 1
t = transform.setMatrixScale(t, scl)
rx = self.settings["mirrorAxisX"] * math.pi
ry = self.settings["mirrorAxisY"] * math.pi
rz = self.settings["mirrorAxisZ"] * math.pi
# t = pm.datatypes.TransformationMatrix(t)
# t.addRotation((rx, ry, rz), 'XYZ', 'object')
else:
scl = [1, 1, 1]
t = transform.setMatrixScale(t, scl)
self.ik_cns = primitive.addTransform(
self.root, self.getName("ik_cns"), t)
self.ctl = self.addCtl(self.ik_cns,
"ctl",
t,
self.color_ik,
self.settings["icon"],
w=self.settings["ctlSize"] * self.size,
h=self.settings["ctlSize"] * self.size,
d=self.settings["ctlSize"] * self.size,
tp=self.parentCtlTag)
# we need to set the rotation order before lock any rotation axis
if self.settings["k_ro"]:
rotOderList = ["XYZ", "YZX", "ZXY", "XZY", "YXZ", "ZYX"]
attribute.setRotOrder(
self.ctl, rotOderList[self.settings["default_rotorder"]])
params = [s for s in
["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"]
if self.settings["k_" + s]]
ymt_util.setKeyableAttributesDontLockVisibility(self.ctl, params)
if self.settings["joint"]:
self.jnt_pos.append([self.ctl, 0, None, self.settings["uniScale"]])
def addObjects(self):
"""Add all the objects needed to create the component."""
t = self.guide.tra["root"]
if self.settings["mirrorBehaviour"] and self.negate:
scl = [1, 1, -1]
else:
scl = [1, 1, 1]
t = transform.setMatrixScale(t, scl)
# The border needs to fit the ctl range of motion
size = self.settings["ctlSize"]
minX = -1 if self.settings["tx_negative"] else 0
maxX = 1 if self.settings["tx_positive"] else 0
minY = -1 if self.settings["ty_negative"] else 0
maxY = 1 if self.settings["ty_positive"] else 0
margin = 0.1 * self.size
border_offset = dt.Point(minX + maxX, minY + maxY) * 0.5
self.border = self.addCtl(self.root,
"border",
t,
self.color_ik,
"square",
w=size + (maxX - minX) + margin,
d=size + (maxY - minY) + margin,
tp=self.parentCtlTag,
po=border_offset,
ro=dt.Vector(math.radians(90), 0, 0))
border_shape = self.border.getShape()
border_shape.overrideDisplayType.set(2) # Set display to reference
self.ctl = self.addCtl(self.border,
"ctl",
t,
self.color_ik,
self.settings["icon"],
d=size,
h=size,
w=size,
tp=self.parentCtlTag,
ro=dt.Vector(math.radians(90), 0, 0))
self.border.scale.set([self.size, self.size, self.size])
params = [
s for s in ["tx", "ty"]
if self.settings[s + "_negative"] or self.settings[s + "_positive"]
]
attribute.setKeyableAttributes(self.ctl, params)
attribute.setKeyableAttributes(self.border, [])
tx_limit = [minX, maxX]
ty_limit = [minY, maxY]
pm.transformLimits(self.ctl, tx=tx_limit, etx=[1, 1])
pm.transformLimits(self.ctl, ty=ty_limit, ety=[1, 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_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 addObjects(self):
"""Add all the objects needed to create the component."""
if self.settings["neutralRotation"]:
t = transform.getTransformFromPos(self.guide.pos["root"])
else:
t = self.guide.tra["root"]
if self.settings["mirrorBehaviour"] and self.negate:
scl = [1, 1, -1]
else:
scl = [1, 1, 1]
t = transform.setMatrixScale(t, scl)
self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"),
t)
self.SDKctl = self.addCtl(
self.ik_cns,
"SDK_ctl",
t,
self.color_ik,
"cube",
w=self.settings["ctlSize"] * self.size * 1.35,
h=self.settings["ctlSize"] * self.size * 0.75,
d=self.settings["ctlSize"] * self.size * 0.75,
tp=self.parentCtlTag)
self.ctl = self.addCtl(self.SDKctl,
"ctl",
t,
self.color_fk,
"sphere",
w=self.settings["ctlSize"] * self.size,
h=self.settings["ctlSize"] * self.size,
d=self.settings["ctlSize"] * self.size,
tp=self.parentCtlTag)
# we need to set the rotation order before lock any rotation axis
if self.settings["k_ro"]:
rotOderList = ["XYZ", "YZX", "ZXY", "XZY", "YXZ", "ZYX"]
attribute.setRotOrder(
self.ctl, rotOderList[self.settings["default_rotorder"]])
attribute.setRotOrder(
self.SDKctl, rotOderList[self.settings["default_rotorder"]])
params = [
s for s in
["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"]
if self.settings["k_" + s]
]
attribute.setKeyableAttributes(self.ctl, params)
attribute.setKeyableAttributes(self.SDKctl, params)
if self.settings["joint"]:
self.jnt_pos.append([self.ctl, 0, None, self.settings["uniScale"]])
def addCurve(self):
t = getTransform(self.root)
scl = [1, 1, 1]
if self.negate:
scl = [-1, 1, 1]
t = transform.setMatrixScale(t, scl)
crv_root = addTransform(self.root, self.getName("crvs"), t)
plane = self.addDummyPlane()
self.addCurves(crv_root, plane)
pm.delete(pm.PyNode(plane.name()))
def addObjects(self):
"""Add all the objects needed to create the component."""
if self.settings["neutralRotation"]:
t = transform.getTransformFromPos(self.guide.pos["root"])
else:
t = self.guide.tra["root"]
if self.settings["mirrorBehaviour"] and self.negate:
scl = [1, 1, -1]
else:
scl = [1, 1, 1]
t = transform.setMatrixScale(t, scl)
if self.settings["joint"] and self.settings["leafJoint"]:
pm.displayInfo("Skipping ctl creation, just leaf joint")
self.have_ctl = False
else:
self.have_ctl = True
self.ik_cns = primitive.addTransform(self.root,
self.getName("ik_cns"), t)
self.ctl = self.addCtl(self.ik_cns,
"ctl",
t,
self.color_ik,
self.settings["icon"],
w=self.settings["ctlSize"] * self.size,
h=self.settings["ctlSize"] * self.size,
d=self.settings["ctlSize"] * self.size,
tp=self.parentCtlTag,
guide_loc_ref="root")
# we need to set the rotation order before lock any rotation axis
if self.settings["k_ro"]:
rotOderList = ["XYZ", "YZX", "ZXY", "XZY", "YXZ", "ZYX"]
attribute.setRotOrder(
self.ctl, rotOderList[self.settings["default_rotorder"]])
params = [
s for s in
["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"]
if self.settings["k_" + s]
]
attribute.setKeyableAttributes(self.ctl, params)
if self.settings["joint"]:
# TODO WIP: add new attr for seeting leaf joint + not build objcts
if self.settings["leafJoint"]:
self.jnt_pos.append([t, 0, None, self.settings["uniScale"]])
else:
self.jnt_pos.append(
[self.ctl, 0, None, self.settings["uniScale"]])
def _foreachControlOption(self, controlParentGrp, ctlOptions):
oName = ctlOptions[0]
oSide = ctlOptions[1]
o_icon = ctlOptions[2]
color = ctlOptions[3]
wd = ctlOptions[4]
oPar = ctlOptions[5]
point = ctlOptions[6]
position = transform.getTransformFromPos(point)
scl = [1, 1, 1]
if self.negate:
scl = [-1, 1, 1]
t = transform.setMatrixScale(position, scl)
npo = addTransform(controlParentGrp,
self.getName("%s_npo" % oName, oSide), t)
npoBuffer = addTransform(npo,
self.getName("%s_bufferNpo" % oName, oSide),
t)
# Create casual control
if o_icon is not "npo":
if o_icon == "sphere":
rot_offset = None
else:
rot_offset = datatypes.Vector(1.57079633, 0, 0)
ctl = self.addCtl(
npoBuffer,
"{}_ctl".format(oName),
t,
color,
o_icon,
w=wd,
d=wd,
ro=rot_offset,
po=datatypes.Vector(0, 0, 0),
)
# Create buffer node instead
else:
ctl = addTransform(npoBuffer,
self.getName("%s_HookNpo" % oName, oSide), t)
# Create up vectors for each control
upv = addTransform(ctl, self.getName("%s_upv" % oName, oSide), t)
upv.attr("tz").set(self.FRONT_OFFSET)
return ctl, upv
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 addContainers(self):
t = getTransform(self.root)
scl = [1, 1, 1]
if self.negate:
scl = [-1, 1, 1]
t = transform.setMatrixScale(t, scl)
self.crv_root = addTransform(self.root, self.getName("crvs"), t)
self.rope_root = addTransform(self.root, self.getName("ropes"), t)
self.browsHooks_root = addTransform(self.root, self.getName("hooks"),
t)
self._visi_off_lock(self.crv_root)
self._visi_off_lock(self.rope_root)
self._visi_off_lock(self.browsHooks_root)
if self.connect_surface_slider:
bt = getTransform(self.root)
self.slider_root = addTransform(self.root, self.getName("sliders"),
bt)
ymt_util.setKeyableAttributesDontLockVisibility(
self.slider_root, [])
# self.mainControlParentGrp = addTransform(self.root, self.getName("mainControls"), t)
w = (self.outPos - self.inPos).length()
d = (self.upPos - self.lowPos).length()
self.mainControlParentGrp = addTransform(self.root,
self.getName("mainControls"),
t)
self.mainControl = self.addCtl(self.mainControlParentGrp,
"main_ctl",
t,
self.color_ik,
"square",
w=w,
d=d,
ro=datatypes.Vector(1.57079633, 0, 0),
po=datatypes.Vector(0, 0, 1.0))
self.addToSubGroup(self.mainControl, self.primaryControllersGroupName)
self.secondaryControlsParentGrp = addTransform(
self.root, self.getName("secondaryControls"), t)
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.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)
self.fk0_npo = primitive.addTransform(self.root,
self.getName("fk0_npo"), t)
vec_po = 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=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)
self.fk1_npo = primitive.addTransform(self.fk0_ctl,
self.getName("fk1_npo"), t)
vec_po = 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=vec_po,
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)
# Define the wrist transform (wt)
if self.settings["guideOrientWrist"]:
wt = self.guide.tra["wrist"]
if self.settings["mirrorIK"] and self.negate:
scl = [1, 1, -1]
else:
scl = [1, 1, 1]
wt = transform.setMatrixScale(wt, scl)
t = wt
self.fk2_npo = primitive.addTransform(self.fk1_ctl,
self.getName("fk2_npo"), t)
vec_po = 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=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 * .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 * .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 * .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"])
if self.settings["guideOrientWrist"]:
t = wt
self.ik_cns.setMatrix(t)
self.ik_cns.setTranslation(self.guide.pos["wrist"], space="world")
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
t,
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)
if self.settings["guideOrientWrist"]:
m = wt
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.roll_ctl)
if self.settings["mirrorIK"]:
if self.negate:
self.ik_cns.sx.set(-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 * .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
trnIK_ref = transform.getTransformLookingAt(self.guide.pos["wrist"],
self.guide.pos["eff"],
self.normal, "xz",
self.negate)
if self.settings["guideOrientWrist"]:
trnIK_ref = wt
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 * .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])
self.eff_loc = primitive.addTransformFromPos(self.root,
self.getName("eff_loc"),
self.guide.apos[2])
# 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.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)
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_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))
# 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_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]))
# angle reader ----------------------------------------
t = transform.getTransformLookingAt(self.guide.apos[1],
self.guide.apos[2], self.normal,
"xy")
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 elbow 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,
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 wrist
self.jnt_pos.append([self.eff_loc, '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")
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 _addControls(self, crv_ctl, option, sidecut):
cvs = crv_ctl.getCVs(space="world")
pm.progressWindow(title='controls', progress=0, max=len(cvs))
v0 = transform.getTransformFromPos(cvs[0])
v1 = transform.getTransformFromPos(cvs[-1])
distSize = vector.getDistance(v0, v1) * 3
npos = []
ctls = []
upvs = []
params = ["tx", "ty", "tz", "rx", "ry", "rz"]
joints = self.upJoints + self.lowJoints
iterator = enumerate(cvs)
if sidecut:
iterator = enumerate(cvs[1:-1])
for i, cv in iterator:
pm.progressWindow(e=True,
step=1,
status='\nCreating control for%s' % cv)
t = transform.getTransformFromPos(cv)
# Get nearest joint for orientation of controls
nearest_joint = None
nearest_distance = None
for joint in joints:
distance = vector.getDistance(transform.getTranslation(joint),
cv)
if nearest_distance is None or distance < nearest_distance:
nearest_distance = distance
nearest_joint = joint
if nearest_joint:
t = transform.setMatrixPosition(
transform.getTransform(nearest_joint), cv)
temp = addTransform(self.root, self.getName("temp"), t)
# temp.rx.set(0)
t = transform.getTransform(temp)
pm.delete(temp)
# print(i, nearest_joint, temp)
oName = option[i][0]
oSide = option[i][1]
o_icon = option[i][2]
color = option[i][3]
wd = option[i][4]
oPar = option[i][5]
if oSide == "R":
scl = [1, 1, -1]
else:
scl = [1, 1, 1]
t = transform.setMatrixScale(t, scl)
npo = addTransform(self.root, self.getName("%s_npo" % oName,
oSide), t)
npos.append(npo)
ctl = self.addCtl(
npo,
self.getName("{}_{}".format(oName, self.ctlName), oSide),
t,
color,
o_icon,
w=wd * distSize,
d=wd * distSize,
ro=datatypes.Vector(1.57079633, 0, 0),
po=datatypes.Vector(0, 0, .07 * distSize),
)
ctls.append(ctl)
ymt_util.setKeyableAttributesDontLockVisibility(ctl, params + oPar)
upv = addTransform(ctl, self.getName("%s_upv" % oName, oSide), t)
upv.attr("tz").set(self.FRONT_OFFSET)
upvs.append(upv)
self.addToSubGroup(ctl, self.primaryControllersGroupName)
pm.progressWindow(e=True, endProgress=True)
return npos, ctls, upvs
def addObjects(self):
"""Add all the objects needed to create the component."""
ctlSize = vector.getDistance(self.guide.apos[0],
self.guide.apos[1]) / 3.0
t_root = self.guide.tra["root"]
t_root = transform.setMatrixScale(t_root)
self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"),
t_root)
t = transform.setMatrixPosition(t_root, self.guide.pos["top"])
self.top_npo = primitive.addTransform(self.ik_cns,
self.getName("top_npo"), t)
self.top_ctl = self.addCtl(self.top_npo,
"top_ctl",
t,
self.color_ik,
"arrow",
w=ctlSize,
ro=datatypes.Vector(1.5708, 1.5708, 0),
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.top_ctl, ["ty"])
t = transform.setMatrixPosition(t_root, self.guide.pos["bottom"])
self.bottom_npo = primitive.addTransform(self.top_npo,
self.getName("bottom_npo"), t)
self.bottom_npo.rz.set(180)
self.bottom_ctl = self.addCtl(self.bottom_npo,
"bottom_ctl",
t,
self.color_ik,
"arrow",
w=ctlSize,
ro=datatypes.Vector(1.5708, 1.5708, 0),
tp=self.parentCtlTag)
self.bottom_ctl.rz.set(0)
attribute.setKeyableAttributes(self.bottom_ctl, ["ty"])
self.bottom_pivot = primitive.addTransform(
self.bottom_npo, self.getName("bottom_pivot"),
transform.getTransform(self.top_ctl))
t = transform.setMatrixPosition(t_root, self.guide.pos["ext"])
self.ext_npo = primitive.addTransform(self.bottom_pivot,
self.getName("ext_npo"), t)
self.ext_npo.rz.set(-90)
self.ext_ctl = self.addCtl(self.ext_npo,
"ext_ctl",
t,
self.color_ik,
"arrow",
w=ctlSize,
ro=datatypes.Vector(1.5708, 1.5708, 0),
tp=self.parentCtlTag)
self.ext_ctl.rz.set(0)
attribute.setKeyableAttributes(self.ext_ctl, ["ty"])
t = transform.setMatrixPosition(t_root, self.guide.pos["int"])
self.int_npo = primitive.addTransform(self.ext_npo,
self.getName("int_npo"), t)
self.int_npo.rz.set(180)
self.int_ctl = self.addCtl(self.int_npo,
"int_ctl",
t,
self.color_ik,
"arrow",
w=ctlSize,
ro=datatypes.Vector(1.5708, 1.5708, 0),
tp=self.parentCtlTag)
self.int_ctl.rz.set(0)
attribute.setKeyableAttributes(self.int_ctl, ["ty"])
self.int_pivot = primitive.addTransform(
self.int_npo, self.getName("int_pivot"),
transform.getTransform(self.ext_ctl))
self.anchor = primitive.addTransform(
self.int_pivot, self.getName("int_npo"),
transform.getTransform(self.ik_cns))
if self.settings["joint"]:
self.jnt_pos.append([self.anchor, 0, None, False])