def add_arm_connection_object(self, arm_comp):
t = tra.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis="xy",
negate=self.negate)
self.arm_npo = pri.addTransform(self.ctl_npo,
self.getName("dummy_npo"), t)
pm.connectAttr("{}.rotate".format(self.ctl),
"{}.rotate".format(self.arm_npo))
self.arm_npo.addChild(arm_comp.dummy_chain[0])
self.arm_npo.addChild(arm_comp.dummy_chain_npo)
self.arm_npo.addChild(arm_comp.dummy_ikh)
self.shoulder_npo = pri.addTransform(self.ctl_npo,
self.getName("dummy_npo2"), t)
self.shoulder_npo.addChild(self.ctl)
fk_quat = self.decompose_rotate(
arm_comp.fk_ctl[0], smooth_step=arm_comp.settings["smoothStep"])
ik_quat = self.decompose_rotate(
arm_comp.dummy_chain_npo,
smooth_step=arm_comp.settings["smoothStep"])
slerp = pm.createNode("quatSlerp")
pm.connectAttr("{}.outputQuat".format(fk_quat),
"{}.input1Quat".format(slerp))
pm.connectAttr("{}.outputQuat".format(ik_quat),
"{}.input2Quat".format(slerp))
pm.connectAttr(arm_comp.blend_att, "{}.inputT".format(slerp))
quat2euler = pm.createNode("quatToEuler")
pm.connectAttr(slerp + ".outputQuat", quat2euler + ".inputQuat")
pm.connectAttr(quat2euler + ".outputRotate",
self.shoulder_npo + ".rotate")
def addLookAtControlers(self, t_root, t_look):
# Tracking
# Eye aim control
self.center_lookat = addTransform(self.over_ctl, self.getName("center_lookat"), t_root)
radius = abs(self.getBboxRadius()[0] / 1.7)
if True or not self.negate:
ro = datatypes.Vector(0, 0, 0)
po = datatypes.Vector(0, 0, radius) + self.offset
else:
ro = datatypes.Vector(math.pi, 0, 0)
po = datatypes.Vector(0, 0, radius * -1.0) + self.offset
self.arrow_npo = addTransform(self.root, self.getName("aim_npo"), t_look)
self.arrow_ctl = self.addCtl(
self.arrow_npo,
"aim_%s" % self.ctlName,
t_look,
self.color_ik,
"arrow",
w=1,
ro=ro,
po=po,
)
self.addToSubGroup(self.over_ctl, self.primaryControllersGroupName)
ymt_util.setKeyableAttributesDontLockVisibility(self.arrow_ctl, params=["rx", "ry", "rz"])
def addObjects(self):
po = dt.Vector(self.settings["ctlOffsetPosX"],
self.settings["ctlOffsetPosY"],
self.settings["ctlOffsetPosZ"])
so = dt.Vector(self.settings["ctlOffsetSclX"],
self.settings["ctlOffsetSclY"],
self.settings["ctlOffsetSclZ"])
ro = [
self.settings["ctlOffsetRotX"], self.settings["ctlOffsetRotY"],
self.settings["ctlOffsetRotZ"]
]
ro = set(map(lambda x: math.radians(x), ro))
ro = dt.Vector(*ro)
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
t = tra.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis="xy",
negate=self.negate)
self.ctl_npo = pri.addTransform(self.root, self.getName("ctl_npo"), t)
self.ctl = self.addCtl(
self.ctl_npo,
"ctl",
t,
self.color_fk,
"cube",
w=(self.length0 * so.x),
h=(self.size * .1 * so.y),
d=(self.size * .1 * so.z),
po=(dt.Vector(.5 * self.length0 * self.n_factor, 0, 0) + po))
t = tra.getTransformFromPos(self.guide.apos[0])
self.orbit_ref1 = pri.addTransform(self.root,
self.getName("orbit_ref1"), t)
t = tra.getTransformFromPos(self.guide.apos[1])
self.orbit_ref2 = pri.addTransform(self.root,
self.getName("orbit_ref2"), t)
self.orbit_cns = pri.addTransform(self.ctl, self.getName("orbit_cns"),
t)
self.orbit_npo = pri.addTransform(self.orbit_cns,
self.getName("orbit_npo"), t)
self.orbit_ctl = self.addCtl(self.orbit_npo,
"orbit_ctl",
t,
self.color_fk,
"sphere",
w=self.length0 / 4)
self.jnt_pos.append([self.ctl, "shoulder"])
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 addLengthCtrl(self, crv):
t = getTransform(self.guide.root)
t = self._getTransformWithRollByBlade(t)
cvs = crv.length()
tm = datatypes.TransformationMatrix(t)
tm.addTranslation([0.0, cvs * 0.01, cvs * 1.4], om.MSpace.kObject)
local_t = datatypes.Matrix(tm)
self.length_npo = addTransform(self.aim_npo, self.getName("length_npo"), local_t)
self.length_in = addTransform(self.length_npo, self.getName("sacle_in"), local_t)
size = self.size
w = size
h = size
d = size
self.length_ctl = self.addCtl(
self.length_in,
"length_ctl",
local_t,
self.color_ik,
"arrow",
w=w,
h=h,
d=d,
ro=datatypes.Vector([-math.pi / 2., math.pi / 2., 0.])
)
self.fk_upvectors = []
chain = getChainTransform2(self.guide.apos, self.normal, self.negate)
for i, t in enumerate(chain):
upv_npo = addTransform(self.length_in, self.getName("%s_fkupv_npo" % i), t)
self.fk_upvectors.append(upv_npo)
# global input
self.scale_npo = addTransform(self.root, self.getName("scale_npo"), local_t)
self.scale_in = addTransform(self.scale_npo, self.getName("sacle_in"), local_t)
self.scale_ctl = self.addCtl(
self.scale_in,
"scale_ctl",
local_t,
self.color_ik,
"cube",
w=w*.2,
h=h*.2,
d=d*.2,
ro=datatypes.Vector([-math.pi / 2., 0., 0.])
)
ymt_util.setKeyableAttributesDontLockVisibility(self.scale_ctl, self.s_params)
ymt_util.setKeyableAttributesDontLockVisibility(self.length_ctl, ["tx", "ty", "tz"])
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 addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.length0 = vector.getDistance(self.guide.apos[0],
self.guide.apos[1])
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis="xy",
negate=self.negate)
self.ctl_npo = primitive.addTransform(self.root,
self.getName("ctl_npo"), t)
self.ctl = self.addCtl(self.ctl_npo,
"ctl",
t,
self.color_fk,
"cube",
w=self.length0,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(
.5 * self.length0 * self.n_factor, 0, 0),
tp=self.parentCtlTag)
t = transform.getTransformFromPos(self.guide.apos[1])
self.orbit_ref1 = primitive.addTransform(self.ctl,
self.getName("orbit_ref1"), t)
self.orbit_ref2 = primitive.addTransform(self.root,
self.getName("orbit_ref2"), t)
self.orbit_cns = primitive.addTransform(self.ctl,
self.getName("orbit_cns"), t)
self.orbit_npo = primitive.addTransform(self.orbit_cns,
self.getName("orbit_npo"), t)
self.orbit_ctl = self.addCtl(self.orbit_npo,
"orbit_ctl",
t,
self.color_fk,
"sphere",
w=self.length0 / 4,
tp=self.ctl)
self.jnt_pos.append([self.ctl, "shoulder"])
def addObjects(self):
"""Add all the objects needed to create the component."""
t = transform.getTransformFromPos(self.guide.pos["root"])
self.eyeOver_npo = primitive.addTransform(self.root,
self.getName("eyeOver_npo"),
t)
self.eyeOver_ctl = self.addCtl(self.eyeOver_npo,
"Over_ctl",
t,
self.color_fk,
"sphere",
w=1 * self.size,
tp=self.parentCtlTag,
guide_loc_ref="root")
self.eye_npo = primitive.addTransform(self.eyeOver_ctl,
self.getName("eye_npo"), t)
self.eyeFK_ctl = self.addCtl(self.eye_npo,
"fk_ctl",
t,
self.color_fk,
"arrow",
w=1 * self.size,
tp=self.eyeOver_ctl)
# look at
t = transform.getTransformFromPos(self.guide.pos["look"])
self.ik_cns = primitive.addTransform(self.root, self.getName("ik_cns"),
t)
self.eyeIK_npo = primitive.addTransform(self.ik_cns,
self.getName("ik_npo"), t)
self.eyeIK_ctl = self.addCtl(self.eyeIK_npo,
"ik_ctl",
t,
self.color_fk,
"circle",
w=.5 * self.size,
tp=self.eyeFK_ctl,
ro=datatypes.Vector([1.5708, 0, 0]),
guide_loc_ref="look")
attribute.setKeyableAttributes(self.eyeIK_ctl, self.t_params)
self.jnt_pos.append([self.eyeFK_ctl, "eye", "parent_relative_jnt"])
self.jnt_pos.append(
[self.eyeOver_ctl, "eyeOver", "parent_relative_jnt", False])
def initialHierarchy(self):
"""
Create the inital structure for the rig.
"""
# Root
self.root = primitive.addTransformFromPos(
self.model, self.getName("root"), self.guide.pos["root"])
self.addToGroup(self.root, names=["componentsRoots"])
# infos
attribute.addAttribute(self.root, "componentType",
"string", self.guide.compType)
attribute.addAttribute(self.root, "componentName",
"string", self.guide.compName)
attribute.addAttribute(self.root, "componentVersion",
"string", str(self.guide.version)[1:-1])
attribute.addAttribute(self.root, "componentAuthor",
"string", self.guide.author)
attribute.addAttribute(self.root, "componentURL",
"string", self.guide.url)
attribute.addAttribute(self.root, "componentEmail",
"string", self.guide.email)
# joint --------------------------------
if self.options["joint_rig"]:
self.component_jnt_org = primitive.addTransform(
self.rig.jnt_org, self.getName("jnt_org"))
# The initial assigment of the active jnt and the parent relative
# jnt is the same, later will be updated base in the user options
self.active_jnt = self.component_jnt_org
self.parent_relative_jnt = self.component_jnt_org
return
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.WIP = self.options["mode"]
if self.negate and self.settings["overrideNegate"]:
self.negate = False
self.n_factor = 1
if self.settings["overrideNegate"]:
self.mirror_conf = [0, 0, 1, 1, 1, 0, 0, 0, 0]
else:
self.mirror_conf = [0, 0, 0, 0, 0, 0, 0, 0, 0]
# FK controllers ------------------------------------
self.fk_npo = []
self.fk_ctl = []
t = self.guide.tra["root"]
parent = self.root
tOld = False
fk_ctl = None
self.previusTag = self.parentCtlTag
for i, t in enumerate(
transform.getChainTransform(self.guide.apos, self.normal,
self.negate)):
dist = vector.getDistance(self.guide.apos[i],
self.guide.apos[i + 1])
if self.settings["neutralpose"] or not tOld:
tnpo = t
else:
tnpo = transform.setMatrixPosition(
tOld, transform.getPositionFromMatrix(t))
fk_npo = primitive.addTransform(parent,
self.getName("fk%s_npo" % i), tnpo)
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=dist,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(dist * .5 * self.n_factor,
0, 0),
tp=self.previusTag,
mirrorConf=self.mirror_conf)
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
tOld = t
self.previusTag = fk_ctl
parent = fk_ctl
if self.settings["addJoints"]:
jnt_name = "_".join([self.name, str(i + 1).zfill(2)])
self.jnt_pos.append([fk_ctl, jnt_name, None, False])
def insert_dummy_arm(self, arm_comp):
# IK dummy Chain -----------------------------------------
chain_pos = [
self.guide.apos[0], arm_comp.guide.apos[1], arm_comp.guide.apos[2]
]
arm_comp.dummy_chain = pri.add2DChain(arm_comp.root,
arm_comp.getName("dummy_chain"),
chain_pos, arm_comp.normal,
arm_comp.negate)
arm_comp.dummy_chain[0].attr("visibility").set(arm_comp.WIP)
arm_comp.dummy_ikh = pri.addIkHandle(arm_comp.root,
arm_comp.getName("dummy_ikh"),
arm_comp.dummy_chain)
arm_comp.dummy_ikh.attr("visibility").set(False)
pm.poleVectorConstraint(arm_comp.upv_ctl, arm_comp.dummy_ikh)
pm.makeIdentity(arm_comp.dummy_chain[0], a=1, t=1, r=1, s=1)
t = tra.getTransform(arm_comp.dummy_chain[0])
arm_comp.dummy_chain_npo = pri.addTransform(
arm_comp.dummy_chain[0], self.getName("dummychain_npo"), t)
arm_comp.dummy_chain_offset = pm.createNode("math_MatrixFromRotation")
mult = pm.createNode("multMatrix")
pm.connectAttr("{}.matrix".format(arm_comp.dummy_chain[0]),
"{}.matrixIn[0]".format(mult))
pm.connectAttr("{}.output".format(arm_comp.dummy_chain_offset),
"{}.matrixIn[1]".format(mult))
rot = pm.createNode("math_RotationFromMatrix")
cmds.setAttr(
"{}.rotationOrder".format(rot),
cmds.getAttr("{}.rotateOrder".format(arm_comp.dummy_chain[0])))
pm.connectAttr("{}.matrixSum".format(mult), "{}.input".format(rot))
pm.connectAttr("{}.output".format(rot),
"{}.rotate".format(arm_comp.dummy_chain_npo))
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 addAimControllers(self, t):
# tracking custom trigger
aimTrigger_root = addTransform(self.center_lookat, self.getName("aimTrigger_root"), t)
# For some unknown reason the right side gets scewed rotation values
resetTransform(aimTrigger_root)
aimTrigger_lvl = addTransform(aimTrigger_root, self.getName("aimTrigger_lvl"), t)
# For some unknown reason the right side gets scewed rotation values
resetTransform(aimTrigger_lvl)
aimTrigger_lvl.attr("tz").set(1.0)
self.aimTrigger_ref = addTransform(aimTrigger_lvl, self.getName("self.aimTrigger_ref"), t)
# For some unknown reason the right side gets scewed rotation values
resetTransform(self.aimTrigger_ref)
self.aimTrigger_ref.attr("tz").set(0.0)
# connect trigger with arrow_ctl
pm.parentConstraint(self.arrow_ctl, self.aimTrigger_ref, mo=True)
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 addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
self.length0 = vector.getDistance(self.guide.apos[0],
self.guide.apos[1])
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis="xy",
negate=self.negate)
self.npo = primitive.addTransform(self.root, self.getName("npo"), t)
self.ctl = self.addCtl(
self.npo,
"ctl",
t,
self.color_fk,
"cube",
w=self.length0,
h=self.size * .1,
d=self.size * .1,
po=datatypes.Vector(.5 * self.length0 * self.n_factor, 0, 0),
tp=self.parentCtlTag)
self.mtx = primitive.addTransform(self.npo, self.getName("mtx"), t)
t1 = transform.setMatrixPosition(t, self.guide.apos[1])
t2 = transform.getInterpolateTransformMatrix(t, t1, blend=0.98)
self.loc = primitive.addTransform(self.mtx, self.getName("loc"), t2)
self.end = primitive.addTransform(self.ctl, self.getName("end"), t1)
self.jnt_pos.append([self.mtx, "root"])
self.jnt_pos.append([self.loc, 'end'])
attribute.setKeyableAttributes(self.ctl)
attribute.setInvertMirror(self.ctl, ["tx", "ty", "tz"])
def 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 addObjectsFkControl(self):
parentdiv = self.root
parentctl = self.root
parent_twistRef = addTransform(self.root, self.getName("reference"),
getTransform(self.root))
self.jointList = []
self.preiviousCtlTag = self.parentCtlTag
chain = getChainTransform2(self.guide.apos, self.normal, self.negate)
for i, t in enumerate(chain):
parentdiv, parentctl = self._addObjectsFkControl(
i, parentdiv, parentctl, t, parent_twistRef)
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."""
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 spaceJump(ref=None, space=None, *args):
"""Space Jump gimmick
This function create a local reference space from another space in the
hierarchy
Args:
ref (None, optional): Transform reference
space (None, optional): Space reference
*args: Maya dummy
Returns:
pyNode: Transform
"""
if not ref and not space:
if len(pm.selected()) == 2:
ref = pm.selected()[0]
space = pm.selected()[1]
else:
pm.displayWarning("Please select 2 objects. Reference Space "
"and Jump Space")
return
refLocal = primitive.addTransform(ref,
ref.name() + "_SPACE_" + space.name(),
space.getMatrix(worldSpace=True))
spaceLocal = primitive.addTransform(space,
ref.name() + "_JUMP_" + space.name(),
space.getMatrix(worldSpace=True))
applyop.gear_mulmatrix_op(refLocal.attr("worldMatrix"),
spaceLocal.attr("parentInverseMatrix[0]"),
spaceLocal)
pm.displayInfo("Jump Space for local space: " + space.name() + "created")
return spaceLocal
def addCtl(self, parent, name, m, color, iconShape, **kwargs):
"""Create the control and apply the shape, if this is alrealdy stored
in the guide controllers grp.
Args:
parent (dagNode): The control parent
name (str): The control name.
m (matrix): The transfromation matrix for the control.
color (int or list of float): The color for the control in index
or RGB.
iconShape (str): The controls default shape.
kwargs (variant): Other arguments for the iconShape type variations
Returns:
dagNode: The Control.
"""
if "degree" not in kwargs.keys():
kwargs["degree"] = 1
bufferName = name + "_controlBuffer"
if bufferName in self.guide.controllers.keys():
ctl_ref = self.guide.controllers[bufferName]
ctl = primitive.addTransform(parent, name, m)
for shape in ctl_ref.getShapes():
ctl.addChild(shape, shape=True, add=True)
pm.rename(shape, name + "Shape")
else:
ctl = icon.create(parent, name, m, color, iconShape, **kwargs)
self.addToGroup(ctl, "controllers")
# Set the control shapes isHistoricallyInteresting
for oShape in ctl.getShapes():
oShape.isHistoricallyInteresting.set(False)
# connecting the always draw shapes on top to global attribute
if versions.current() >= 20220000:
pm.connectAttr(
self.ctlXRay_att, oShape.attr("alwaysDrawOnTop")
)
# set controller tag
if versions.current() >= 201650:
pm.controller(ctl)
self.add_controller_tag(ctl, None)
attribute.addAttribute(ctl, "isCtl", "bool", keyable=False)
return ctl
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z
self.binormal = self.guide.blades["blade"].x
# Chain of deformers -------------------------------
self.locList = []
self.npoList = []
parent = self.root
self.jointList = []
for i, t in enumerate(
transform.getChainTransform2(self.guide.apos, self.normal,
self.negate)):
lvl = primitive.addTransform(parent, self.getName("%s_lvl" % i), t)
npo = primitive.addTransform(lvl, self.getName("%s_npo" % i), t)
loc = primitive.addTransform(npo, self.getName("%s_loc" % i), t)
self.jnt_pos.append([loc, i])
self.locList.append(loc)
self.npoList.append(npo)
if i == len(self.guide.apos) - 1:
ctl_npo = primitive.addTransform(self.root,
self.getName("ctl_npo"), t)
self.meta_ctl = self.addCtl(ctl_npo,
"ctl",
t,
self.color_fk,
"cube",
w=self.size * .5,
h=self.size * .5,
d=self.size * .5,
tp=self.parentCtlTag)
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis="yx",
negate=self.negate)
self.ctl_npo = primitive.addTransform(
self.root, self.getName("ctl_npo"), t)
self.ctl = self.addCtl(self.ctl_npo,
"base_ctl",
t,
self.color_ik,
"square",
w=1.0,
tp=self.parentCtlTag)
attribute.setKeyableAttributes(self.ctl, self.tr_params)
self.ref_base = primitive.addTransform(
self.ctl, self.getName("ref_base"), t)
t = transform.setMatrixPosition(t, self.guide.apos[1])
self.ik_cns = primitive.addTransform(
self.root, self.getName("ik_cns"), t)
self.tip_npo = primitive.addTransform(
self.ik_cns, self.getName("tip_npo"), t)
self.tip_ctl = self.addCtl(self.tip_npo,
"tip_ctl",
t,
self.color_ik,
"square",
w=1.0,
tp=self.ctl)
attribute.setKeyableAttributes(self.tip_ctl, self.tr_params)
self.ref_tip = primitive.addTransform(
self.tip_ctl, self.getName("ref_tip"), t)
self.div_cns = []
for i in range(self.settings["div"]):
div_cns = primitive.addTransform(self.root,
self.getName("div%s_loc" % i))
self.div_cns.append(div_cns)
self.jnt_pos.append([div_cns, i])
def addOverControllers(self, t):
self.over_npo = addTransform(self.root, self.getName("center_lookatRoot"), t)
self.over_ctl = self.addCtl(self.over_npo,
"over_%s" % self.ctlName,
t,
self.color_ik,
"square",
w=self.getBboxRadius()[0],
d=self.getBboxRadius()[1],
ro=datatypes.Vector(1.57079633, 0, 0),
po=self.offset,
)
self.addToSubGroup(self.over_ctl, self.primaryControllersGroupName)
ymt_util.setKeyableAttributesDontLockVisibility(
self.over_ctl,
params=["tx", "ty", "tz", "ro", "rx", "ry", "rz", "sx", "sy", "sz"])
def addObjectsFkControl(self):
parentdiv = self.root
parentctl = self.root
parent_twistRef = addTransform(
self.root,
self.getName("reference"),
getTransform(self.root))
self.jointList = []
self.preiviousCtlTag = self.parentCtlTag
chain = getChainTransform2(self.guide.apos, self.normal, self.negate)
for i, t in enumerate(chain):
parentdiv, parentctl = self._addObjectsFkControl(i, parentdiv, parentctl, t, parent_twistRef)
# add visual reference
icon.connection_display_curve(self.getName("visualFKRef"), self.fk_ctl)
def addObjects(self):
"""Add all the objects needed to create the component."""
self.normal = self.guide.blades["blade"].z * -1
self.binormal = self.guide.blades["blade"].x
t = transform.getTransformLookingAt(self.guide.apos[0],
self.guide.apos[1],
self.normal,
axis="yx",
negate=self.negate)
self.ctl_npo = primitive.addTransform(self.root,
self.getName("ctl_npo"), t)
self.ctl = self.addCtl(self.ctl_npo,
"base_ctl",
t,
self.color_ik,
"square",
w=1.0,
tp=self.parentCtlTag)
self.ref_base = primitive.addTransform(self.ctl,
self.getName("ref_base"), t)
t = transform.setMatrixPosition(t, self.guide.apos[1])
self.ik_cns = primitive.addTransform(self.ctl, self.getName("ik_cns"),
t)
self.squash_npo = primitive.addTransform(self.ik_cns,
self.getName("squash_npo"), t)
self.squash_ctl = self.addCtl(self.squash_npo,
"squash_ctl",
t,
self.color_ik,
"crossarrow",
w=1.0,
ro=dt.Vector(1.5708, 0, 0),
tp=self.ctl)
attribute.setKeyableAttributes(self.squash_ctl, ["tx", "ty", "tz"])
self.ref_squash = primitive.addTransform(self.squash_ctl,
self.getName("ref_squash"), t)
self.div_cns = []
div_cns = primitive.addTransform(self.root, self.getName("div0_loc"))
self.div_cns.append(div_cns)
self.jnt_pos.append([div_cns, 0, None, False])
def createInterpolateTransform(objects=None, blend=.5, *args):
"""
Create space locator and apply gear_intmatrix_op, to interpolate the his
pose between 2 selected objects.
Args:
objects (None or list of 2 dagNode, optional): The 2 dagNode to
interpolate the transform.
blend (float, optional): The interpolation blend factor.
*args: Maya's dummy
Returns:
pyNode: The new transformation witht the interpolate matrix o_node
applied.
"""
if objects or len(pm.selected()) >= 2:
if objects:
refA = objects[0]
refB = objects[1]
else:
refA = pm.selected()[0]
refB = pm.selected()[1]
intMatrix = applyop.gear_intmatrix_op(refA.attr("worldMatrix"),
refB.attr("worldMatrix"), blend)
intTrans = primitive.addTransform(
refA,
refA.name() + "_INTER_" + refB.name(), datatypes.Matrix())
applyop.gear_mulmatrix_op(intMatrix.attr("output"),
intTrans.attr("parentInverseMatrix[0]"),
intTrans)
pm.displayInfo("Interpolated Transform: " + intTrans.name() +
" created")
else:
pm.displayWarning("Please select 2 objects. ")
return
return intTrans
def addObjects(self):
"""Add all the objects needed to create the component."""
t = self.guide.tra["root"]
# The border needs to fit the ctl range of motion
size = self.settings["ctlSize"]
margin = self.settings["margin"]
self.ctl = None
if self.settings["addController"]:
self.ctl = self.addCtl(self.root,
"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.ctl.scale.set([self.size, self.size, self.size])
attribute.setKeyableAttributes(
self.ctl,
["tx", "ty", "tz", "rx", "ry", "rz", "sx", "sy", "sz"])
else:
self.ctl = primitive.addTransform(self.root, self.getName("cns"),
t)
self.ctl.scale.set([self.size, self.size, self.size])
attribute.setKeyableAttributes(self.ctl, [])
self.border = self.addCtl(self.ctl,
"border",
t,
self.color_ik,
"square",
w=size + margin,
d=size + margin,
tp=self.parentCtlTag,
ro=dt.Vector(math.radians(90), 0, 0))
border_shape = self.border.getShape()
border_shape.overrideDisplayType.set(2) # Set display to reference
attribute.setKeyableAttributes(self.border, [])
def _add_loc_ctl(i, t, parent):
loc = primitive.addTransform(parent, self.getName("bk%s_loc" % i), t)
self.bk_loc.append(loc)
if 0 < i:
return loc
ctl = self.addCtl(loc,
"bk%s_ctl" % i,
t,
self.color_ik,
"sphere",
w=self.size * .15,
tp=self.previousTag)
ymt_util.setKeyableAttributesDontLockVisibility(ctl, self.r_params)
self.previousTag = ctl
self.bk_ctl.append(ctl)
return ctl
def _add_fk(self, i, parent, t, tOld):
dist = vec.getDistance(self.guide.apos[i], self.guide.apos[i + 1])
if self.settings["neutralpose"] or not tOld:
tnpo = t
else:
tnpo = tra.setMatrixPosition(tOld, tra.getPositionFromMatrix(t))
fk_npo = pri.addTransform(parent, self.getName("fk%s_npo" % i), tnpo)
fk_ctl = self.addCtl(fk_npo,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=dist,
h=self.size * .1,
d=self.size * .1,
po=dt.Vector(dist * .5 * self.n_factor, 0, 0))
self.fk_npo.append(fk_npo)
self.fk_ctl.append(fk_ctl)
return fk_ctl
