def switchToFk(self):
# Match Rotation
tra.matchGlobalTransform(self.fk0, self.jnt0, False, True, True)
tra.matchGlobalTransform(self.fk1, self.jnt1, False, True, True)
# Scale
self.scale.Value = (self.length0 + self.length1) / self.rest
# Switch to FK
self.blend.Value = 0
if self.isleg:
x = XSIMath.CreateVector3(0, 0, 1)
y = XSIMath.CreateVector3(0, 1, 0)
if self.negate:
x.NegateInPlace()
y.NegateInPlace()
x.MulByRotationInPlace(
self.ik.Kinematics.Global.Transform.Rotation)
y.MulByRotationInPlace(
self.ik.Kinematics.Global.Transform.Rotation)
t = self.ik.Kinematics.Global.Transform
t.SetRotation(tra.getRotationFromAxis(x, y, "xy"))
self.fk2.Kinematics.Global.Transform = t
else:
tra.matchGlobalTransform(self.fk2, self.ik, False, True, True)
def switchToFk(self):
# Match Rotation
tra.matchGlobalTransform(self.fk0, self.jnt0, False, True, True)
tra.matchGlobalTransform(self.fk1, self.jnt1, False, True, True)
# Scale
self.scale.Value = (self.length0 + self.length1) / self.rest
# Switch to FK
self.blend.Value = 0
if self.isleg:
x = XSIMath.CreateVector3(0,0,1)
y = XSIMath.CreateVector3(0,1,0)
if self.negate:
x.NegateInPlace()
y.NegateInPlace()
x.MulByRotationInPlace(self.ik.Kinematics.Global.Transform.Rotation)
y.MulByRotationInPlace(self.ik.Kinematics.Global.Transform.Rotation)
t = self.ik.Kinematics.Global.Transform
t.SetRotation(tra.getRotationFromAxis(x, y, "xy"))
self.fk2.Kinematics.Global.Transform = t
else:
tra.matchGlobalTransform(self.fk2, self.ik, False, True, True)
def switchToIk(self):
# Get the distance between Root and effector and compare it to bones total length to define if the chain is bend or not
vRootEff = XSIMath.CreateVector3()
vRootEff.Sub(self.jnt0.kinematics.Global.Transform.Translation,
self.ik.kinematics.Global.Transform.Translation)
# We get an approximation of the length otherwise it's sometimes tricky to compare distance
r = 100000
dRootEffLength = round((vRootEff.Length() * r)) / r
dBonesLength = round(((self.length0 + self.length1) * r)) / r
# xsi.MatchTransform(self.ik, self.eff, c.siRT, None)
# tra.matchGlobalTransform(self.eff, self.ik, True, True, False)
tra.matchGlobalTransform(self.ik, self.fk2, True, True, True)
self.blend.Value = 1
# tra.matchGlobalTransform(self.fk2, self.ik, False, True, False)
# Compute Roll
if dRootEffLength < dBonesLength:
# Get Vectors to built the plane
vFKChain0 = XSIMath.CreateVector3()
vIKChain0 = XSIMath.CreateVector3()
vRootEff = XSIMath.CreateVector3()
vFKChain0.Sub(self.fk0.kinematics.Global.Transform.Translation,
self.fk1.kinematics.Global.Transform.Translation)
vIKChain0.Sub(self.jnt0.kinematics.Global.Transform.Translation,
self.jnt1.kinematics.Global.Transform.Translation)
vRootEff.Sub(self.jnt0.kinematics.Global.Transform.Translation,
self.ik.kinematics.Global.Transform.Translation)
# vFKChain0.NormalizeInPlace()
# vIKChain0.NormalizeInPlace()
# vRootEff.NormalizeInPlace()
# Get Plane's Normal
vNormFKPlane = XSIMath.CreateVector3()
vNormIKPlane = XSIMath.CreateVector3()
vNormFKPlane.Cross(vFKChain0, vRootEff)
vNormIKPlane.Cross(vIKChain0, vRootEff)
# vNormFKPlane.NormalizeInPlace()
# vNormIKPlane.NormalizeInPlace()
# Get the Angle between the two planess
dAngle = XSIMath.RadiansToDegrees(vNormFKPlane.Angle(vNormIKPlane))
# Check if we have to remove or add the angle
vCrossPlane = XSIMath.CreateVector3()
vCrossPlane.Cross(vNormFKPlane, vNormIKPlane)
# vCrossPlane.NormalizeInPlace()
dDirectionDot = vCrossPlane.Dot(vRootEff)
# Set the new roll Value
a = self.roll.Value + (dDirectionDot / abs(dDirectionDot)) * dAngle
# Set the angle in a -180 / 180 range
if abs(a) > 180:
a = a % ((-a / abs(a)) * 360)
# [OLD WAY ]Set the new roll Value --
# Check if the bone is negated or not
## dNegate = self.jnt1.kinematics.Local.posx.Value + self.jnt1.kinematics.Local.nposx.Value
#dNegate = 1
# oldAngle = self.roll.Value
# if (dDirectionDot * dNegate) < 0:
# newAngle = oldAngle - dAngle
# else:
# newAngle = oldAngle + dAngle
# if newAngle > 180:
# newAngle -= 360
# elif newAngle < -180:
# newAngle += 360
# [END OLD WAY ] -------------------
self.roll.Value = a
# Match Scale Value
# We remove Soft distances
self.softik.Value = 0
if dRootEffLength > dBonesLength:
if self.scale.Value > self.maxstretch.Value:
self.maxstretch.Value = self.scale.Value
self.scale.Value = 1
if self.isleg:
z = XSIMath.CreateVector3(1, 0, 0)
y = XSIMath.CreateVector3(0, 1, 0)
if self.negate:
z.NegateInPlace()
y.NegateInPlace()
z.MulByRotationInPlace(
self.fk2.Kinematics.Global.Transform.Rotation)
y.MulByRotationInPlace(
self.fk2.Kinematics.Global.Transform.Rotation)
t = self.fk2.Kinematics.Global.Transform
t.SetRotation(tra.getRotationFromAxis(z, y, "zy"))
self.ik.Kinematics.Global.Transform = t
else:
tra.matchGlobalTransform(self.ik, self.fk2, False, True, True)
def addObjects(self):
self.normal = self.getNormalFromPos(self.guide.apos)
self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2])
self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3])
# FK Controlers ------------------------------------
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1],
self.normal, "xz", self.negate)
self.fk0_ctl = self.addCtl(self.root,
"fk0_ctl",
t,
self.color_fk,
"cube",
h=self.size * .1,
w=1,
d=self.size * .1,
po=XSIMath.CreateVector3(
.5 * self.n_factor, 0, 0))
self.fk0_ctl.Parameters("SclX").Value = self.length0
xsi.SetNeutralPose(self.fk0_ctl)
par.setKeyableParameters(self.fk0_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk0_ctl,
["posx", "posy", "posz"])
t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2],
self.normal, "xz", self.negate)
self.fk1_ctl = self.addCtl(self.fk0_ctl,
"fk1_ctl",
t,
self.color_fk,
"cube",
h=self.size * .1,
w=1,
d=self.size * .1,
po=XSIMath.CreateVector3(
.5 * self.n_factor, 0, 0))
self.fk1_ctl.Parameters("SclX").Value = self.length1 / self.length0
xsi.SetNeutralPose(self.fk1_ctl, c.siST)
par.setKeyableParameters(self.fk1_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk1_ctl,
["posx", "posy", "posz"])
t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3],
self.normal, "xz", self.negate)
self.fk2_ctl = self.addCtl(self.fk1_ctl,
"fk2_ctl",
t,
self.color_fk,
"cube",
h=self.size * .1,
w=self.length2,
d=self.size * .1,
po=XSIMath.CreateVector3(
self.length2 * .5 * self.n_factor, 0,
0))
xsi.SetNeutralPose(self.fk2_ctl, c.siST)
par.setKeyableParameters(self.fk2_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk2_ctl,
["posx", "posy", "posz"])
# IK Controlers ------------------------------------
self.ik_cns = pri.addNullFromPos(self.root, self.getName("ik_cns"),
self.guide.apos[2], self.size * .02)
self.addToGroup(self.ik_cns, "hidden")
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
self.ik_cns.Kinematics.Global.Transform,
self.color_ik,
"null",
h=self.size * .2)
par.setKeyableParameters(self.ikcns_ctl)
par.addLocalParamToCollection(self.inv_params, self.ikcns_ctl,
["posx", "rotx", "rotz"])
t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3],
self.x_axis, "zx", False)
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
t,
self.color_ik,
"cube",
h=self.size * .12,
w=self.length2,
d=self.size * .12,
po=XSIMath.CreateVector3(
0, 0, self.length2 * .5))
self.addToCtlGroup(self.ik_ctl)
par.setKeyableParameters(self.ik_ctl)
par.addLocalParamToCollection(self.inv_params, self.ik_ctl, ["posx"])
# IK and FK references
self.ik_ref = pri.addNull(self.ik_ctl, self.getName("ik_ref"),
self.ik_ctl.Kinematics.Global.Transform,
self.size * .1)
self.addToGroup(self.ik_ref, "hidden")
self.fk_ref = pri.addNull(self.fk2_ctl, self.getName("fk_ref"),
self.ik_ref.Kinematics.Global.Transform,
self.size * .1)
self.addToGroup(self.fk_ref, "hidden")
v = XSIMath.CreateVector3()
v.Sub(self.guide.apos[2], self.guide.apos[0])
v.Cross(self.normal, v)
v.NormalizeInPlace()
v.ScaleInPlace(self.size * .5)
v.AddInPlace(self.guide.apos[1])
self.upv_cns = pri.addNullFromPos(self.root, self.getName("upv_cns"),
v, self.size * .02)
self.addToGroup(self.upv_cns, "hidden")
self.upv_ctl = self.addCtl(self.upv_cns,
"upv_ctl",
self.upv_cns.Kinematics.Global.Transform,
self.color_ik,
"leash",
h=self.size * .05,
ap=self.guide.apos[1])
par.setKeyableParameters(self.upv_ctl, self.t_params)
par.addLocalParamToCollection(self.inv_params, self.upv_ctl, ["posx"])
# Chain --------------------------------------------
self.bone0 = pri.addNull(self.root, self.getName("0_jnt"),
self.fk0_ctl.Kinematics.Global.Transform)
pri.setNullDisplay(self.bone0, 0, 1, 4, self.n_factor * .5, 0, 0, 1,
self.size * .01, self.size * .01)
self.bone0.Kinematics.Global.Parameters("sclx").Value = self.length0
self.bone1 = pri.addNull(self.bone0, self.getName("1_jnt"),
self.fk1_ctl.Kinematics.Global.Transform)
pri.setNullDisplay(self.bone1, 0, 1, 4, self.n_factor * .5, 0, 0, 1,
self.size * .01, self.size * .01)
self.bone1.Kinematics.Global.Parameters("sclx").Value = self.length1
self.ctrn_loc = pri.addNullFromPos(self.bone0,
self.getName("ctrn_loc"),
self.guide.apos[1], self.size * .05)
self.eff_loc = pri.addNullFromPos(self.root, self.getName("eff_loc"),
self.guide.apos[2], self.size * .05)
x = XSIMath.CreateVector3(0, -1, 0)
x.MulByRotationInPlace(
self.eff_loc.Kinematics.Global.Transform.Rotation)
import gear.xsi.log as log
xsi.LogMessage("HEEEEYYYYYY")
log.logVector(self.normal)
z = XSIMath.CreateVector3(self.normal.X, self.normal.Y, self.normal.Z)
z.MulByRotationInPlace(
self.eff_loc.Kinematics.Global.Transform.Rotation)
xsi.LogMessage("POUET")
xsi.LogMessage("POUET2")
r = tra.getRotationFromAxis(x, z, "xz", self.negate)
t = self.ik_ctl.Kinematics.Global.Transform
t.SetRotation(r)
self.tws_ref = pri.addNull(self.eff_loc, self.getName("tws_ref"), t,
self.size * .1)
self.addToGroup([
self.bone0, self.bone1, self.ctrn_loc, self.eff_loc, self.tws_ref
], "hidden")
# Mid Controler ------------------------------------
self.mid_ctl = self.addCtl(self.ctrn_loc,
"mid_ctl",
self.ctrn_loc.Kinematics.Global.Transform,
self.color_ik,
"sphere",
h=self.size * .2)
par.addLocalParamToCollection(self.inv_params, self.mid_ctl,
["posx", "posy", "posz"])
# Twist references ---------------------------------
t = tra.getFilteredTransform(self.fk0_ctl.Kinematics.Global.Transform,
True, True, False)
self.tws0_loc = pri.addNull(self.root, self.getName("tws0_loc"), t,
self.size * .05)
self.tws0_rot = pri.addNull(self.tws0_loc, self.getName("tws0_rot"), t)
pri.setNullDisplay(self.tws0_rot, 0, self.size * .05, 2, 0, 0, 0,
self.size * .01)
self.tws1_loc = pri.addNull(self.ctrn_loc, self.getName("tws1_loc"),
self.ctrn_loc.Kinematics.Global.Transform,
self.size * .05)
self.tws1_rot = pri.addNull(self.tws1_loc, self.getName("tws1_rot"),
self.ctrn_loc.Kinematics.Global.Transform)
pri.setNullDisplay(self.tws1_rot, 0, self.size * .05, 2, 0, 0, 0,
self.size * .01)
t = tra.getFilteredTransform(self.bone1.Kinematics.Global.Transform,
True, True, False)
t.SetTranslation(self.guide.apos[2])
self.tws2_loc = pri.addNull(self.bone1, self.getName("tws2_loc"), t,
self.size * .05)
self.tws2_rot = pri.addNull(self.tws2_loc, self.getName("tws2_rot"), t)
self.tws2_rot.Kinematics.Global.Parameters("SclX").Value = .001
pri.setNullDisplay(self.tws2_rot, 0, self.size * .05, 2, 0, 0, 0,
self.size * .01)
self.addToGroup([
self.tws0_loc, self.tws0_rot, self.tws1_loc, self.tws1_rot,
self.tws2_loc, self.tws2_rot
], "hidden")
# End reference ------------------------------------
t = tra.getFilteredTransform(self.tws2_rot.Kinematics.Global.Transform,
True, True, False)
self.end_ref = pri.addNull(self.tws2_rot, self.getName("end_ref"), t,
self.size * .2)
self.addToGroup(self.end_ref, "hidden")
self.addShadow(self.end_ref, "end")
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for the elbow.
self.divisions = self.settings["div0"] + self.settings["div1"] + 3
self.div_cns = []
for i in range(self.divisions):
div_cns = pri.addNull(self.tws0_loc, self.getName("div%s_loc" % i),
XSIMath.CreateTransform())
pri.setNullDisplay(div_cns, 1, self.size * .02, 10, 0, 0, 0, 1, 1,
2)
self.addToGroup(div_cns, "hidden")
self.div_cns.append(div_cns)
self.addShadow(div_cns, i)
def addObjects(self):
self.div_count = len(self.guide.apos) - 5
plane = [self.guide.apos[0], self.guide.apos[-4], self.guide.apos[-3]]
self.normal = self.getNormalFromPos(plane)
self.binormal = self.getBiNormalFromPos(plane)
# Heel ---------------------------------------------
t = tra.getTransformLookingAt(self.guide.pos["heel"], self.guide.apos[-4], self.normal, "xz", self.negate)
self.heel_loc = pri.addNull(self.root, self.getName("heel_loc"), t, self.size*.15)
xsi.SetNeutralPose(self.heel_loc)
self.addToGroup(self.heel_loc, "hidden")
self.heel_ctl = self.addCtl(self.heel_loc, "heel_ctl", t, self.color_ik, "sphere", w=self.size*.1)
xsi.SetNeutralPose(self.heel_ctl)
par.setKeyableParameters(self.heel_ctl, self.r_params)
# Tip ----------------------------------------------
v = XSIMath.CreateVector3(self.guide.apos[-5].X,self.guide.apos[-1].Y,self.guide.apos[-5].Z)
t.SetTranslation(v)
self.tip_ctl = self.addCtl(self.heel_ctl, "tip_ctl", t, self.color_ik, "circle", w=self.size*.5)
xsi.SetNeutralPose(self.tip_ctl)
par.setKeyableParameters(self.heel_ctl, self.r_params)
# Roll ---------------------------------------------
if self.settings["roll"] == 0:
t = tra.getTransformFromPosition(self.guide.pos["root"])
t.SetRotation(tra.getRotationFromAxis(self.y_axis, self.normal, "yz", self.negate))
self.roll_ctl = self.addCtl(self.root, "roll_ctl", t, self.color_ik, "cylinder", w=self.size*.5, h=self.size*.5, ro=XSIMath.CreateRotation(3.1415*.5,0,0))
xsi.SetNeutralPose(self.roll_ctl)
par.setKeyableParameters(self.roll_ctl, ["rotx", "rotz"])
# Backward Controlers ------------------------------
bk_pos = self.guide.apos[1:-3]
bk_pos.reverse()
parent = self.tip_ctl
self.bk_ctl = []
for i, pos in enumerate(bk_pos):
if i == 0:
t = self.heel_loc.Kinematics.Global.Transform
t.SetTranslation(pos)
else:
dir = bk_pos[i-1]
t = tra.getTransformLookingAt(pos, dir, self.normal, "xz", self.negate)
bk_ctl = self.addCtl(parent, "bk%s_ctl"%i, t, self.color_ik, "sphere", w=self.size*.15)
xsi.SetNeutralPose(bk_ctl)
par.setKeyableParameters(bk_ctl, self.r_params)
self.bk_ctl.append(bk_ctl)
parent = bk_ctl
# Forward Controlers ------------------------------
self.fk_ref = pri.addNullFromPos(self.bk_ctl[-1], self.getName("fk_ref"), self.guide.apos[0], self.size*.5)
self.addToGroup(self.fk_ref, "hidden")
self.fk_ctl = []
parent = self.fk_ref
for i, bk_ctl in enumerate(reversed(self.bk_ctl[1:])):
t = bk_ctl.Kinematics.Global.Transform
dist = vec.getDistance(self.guide.apos[i+1], self.guide.apos[i+2])
fk_ctl = self.addCtl(parent, "fk%s_ctl"%i, t, self.color_fk, "cube", w=dist, h=self.size*.5, d=self.size*.5, po=XSIMath.CreateVector3(dist*.5*self.n_factor,0,0))
xsi.SetNeutralPose(fk_ctl)
par.setKeyableParameters(fk_ctl)
self.addShadow(fk_ctl, i)
parent = fk_ctl
self.fk_ctl.append(fk_ctl)
def addObjects(self):
self.div_count = len(self.guide.apos) - 5
plane = [self.guide.apos[0], self.guide.apos[-4], self.guide.apos[-3]]
self.normal = self.getNormalFromPos(plane)
self.binormal = self.getBiNormalFromPos(plane)
# Heel ---------------------------------------------
t = tra.getTransformLookingAt(self.guide.pos["heel"],
self.guide.apos[-4], self.normal, "xz",
self.negate)
self.heel_loc = pri.addNull(self.root, self.getName("heel_loc"), t,
self.size * .15)
xsi.SetNeutralPose(self.heel_loc)
self.addToGroup(self.heel_loc, "hidden")
self.heel_ctl = self.addCtl(self.heel_loc,
"heel_ctl",
t,
self.color_ik,
"sphere",
w=self.size * .1)
xsi.SetNeutralPose(self.heel_ctl)
par.setKeyableParameters(self.heel_ctl, self.r_params)
# Tip ----------------------------------------------
v = XSIMath.CreateVector3(self.guide.apos[-5].X, self.guide.apos[-1].Y,
self.guide.apos[-5].Z)
t.SetTranslation(v)
self.tip_ctl = self.addCtl(self.heel_ctl,
"tip_ctl",
t,
self.color_ik,
"circle",
w=self.size * .5)
xsi.SetNeutralPose(self.tip_ctl)
par.setKeyableParameters(self.heel_ctl, self.r_params)
# Roll ---------------------------------------------
if self.settings["roll"] == 0:
t = tra.getTransformFromPosition(self.guide.pos["root"])
t.SetRotation(
tra.getRotationFromAxis(self.y_axis, self.normal, "yz",
self.negate))
self.roll_ctl = self.addCtl(self.root,
"roll_ctl",
t,
self.color_ik,
"cylinder",
w=self.size * .5,
h=self.size * .5,
ro=XSIMath.CreateRotation(
3.1415 * .5, 0, 0))
xsi.SetNeutralPose(self.roll_ctl)
par.setKeyableParameters(self.roll_ctl, ["rotx", "rotz"])
# Backward Controlers ------------------------------
bk_pos = self.guide.apos[1:-3]
bk_pos.reverse()
parent = self.tip_ctl
self.bk_ctl = []
for i, pos in enumerate(bk_pos):
if i == 0:
t = self.heel_loc.Kinematics.Global.Transform
t.SetTranslation(pos)
else:
dir = bk_pos[i - 1]
t = tra.getTransformLookingAt(pos, dir, self.normal, "xz",
self.negate)
bk_ctl = self.addCtl(parent,
"bk%s_ctl" % i,
t,
self.color_ik,
"sphere",
w=self.size * .15)
xsi.SetNeutralPose(bk_ctl)
par.setKeyableParameters(bk_ctl, self.r_params)
self.bk_ctl.append(bk_ctl)
parent = bk_ctl
# Forward Controlers ------------------------------
self.fk_ref = pri.addNullFromPos(self.bk_ctl[-1],
self.getName("fk_ref"),
self.guide.apos[0], self.size * .5)
self.addToGroup(self.fk_ref, "hidden")
self.fk_ctl = []
parent = self.fk_ref
for i, bk_ctl in enumerate(reversed(self.bk_ctl[1:])):
t = bk_ctl.Kinematics.Global.Transform
dist = vec.getDistance(self.guide.apos[i + 1],
self.guide.apos[i + 2])
fk_ctl = self.addCtl(parent,
"fk%s_ctl" % i,
t,
self.color_fk,
"cube",
w=dist,
h=self.size * .5,
d=self.size * .5,
po=XSIMath.CreateVector3(
dist * .5 * self.n_factor, 0, 0))
xsi.SetNeutralPose(fk_ctl)
par.setKeyableParameters(fk_ctl)
self.addShadow(fk_ctl, i)
parent = fk_ctl
self.fk_ctl.append(fk_ctl)
def addObjects(self):
self.normal = self.getNormalFromPos(self.guide.apos[1:])
self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2])
self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3])
self.length3 = vec.getDistance(self.guide.apos[3], self.guide.apos[4])
# FK Controlers ------------------------------------
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate)
self.fk0_ctl = self.addCtl(self.root, "fk0_ctl", t, self.color_fk, "cube", w=1, h=self.size*.1, d=self.size*.1, po=XSIMath.CreateVector3(.5*self.n_factor,0,0))
self.fk0_ctl.Kinematics.Global.Parameters("SclX").Value = self.length0
xsi.SetNeutralPose(self.fk0_ctl)
par.setKeyableParameters(self.fk0_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk0_ctl, ["posx", "posy", "posz"])
t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate)
self.fk1_ctl = self.addCtl(self.fk0_ctl, "fk1_ctl", t, self.color_fk, "cube", w=1, h=self.size*.1, d=self.size*.1, po=XSIMath.CreateVector3(.5*self.n_factor,0,0))
self.fk1_ctl.Kinematics.Global.Parameters("SclX").Value = self.length1
xsi.SetNeutralPose(self.fk1_ctl, c.siST)
par.setKeyableParameters(self.fk1_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk1_ctl, ["posx", "posy", "posz"])
t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate)
self.fk2_ctl = self.addCtl(self.fk1_ctl, "fk2_ctl", t, self.color_fk, "cube", w=1, h=self.size*.1, d=self.size*.1, po=XSIMath.CreateVector3(.5*self.n_factor,0,0))
self.fk2_ctl.Kinematics.Global.Parameters("SclX").Value = self.length2
xsi.SetNeutralPose(self.fk2_ctl, c.siST)
par.setKeyableParameters(self.fk2_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk2_ctl, ["posx", "posy", "posz"])
t = tra.getTransformLookingAt(self.guide.apos[3], self.guide.apos[4], self.normal, "xz", self.negate)
self.fk3_ctl = self.addCtl(self.fk2_ctl, "fk3_ctl", t, self.color_fk, "cube", w=self.length3, h=self.size*.1, d=self.size*.1, po=XSIMath.CreateVector3(self.length3*.5*self.n_factor,0,0))
xsi.SetNeutralPose(self.fk3_ctl, c.siST)
par.setKeyableParameters(self.fk3_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk3_ctl, ["posx", "posy", "posz"])
# IK Controlers ------------------------------------
self.ik_cns = pri.addNullFromPos(self.root, self.getName("ik_cns"), self.guide.apos[3], self.size * .02)
self.addToGroup(self.ik_cns, "hidden")
self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", self.ik_cns.Kinematics.Global.Transform, self.color_ik, "null", h=self.size*.2)
self.addToCtlGroup(self.ikcns_ctl)
par.setKeyableParameters(self.ikcns_ctl)
par.addLocalParamToCollection(self.inv_params, self.ikcns_ctl, ["posx", "rotx", "rotz"])
t = tra.getTransformLookingAt(self.guide.apos[3], self.guide.apos[4], self.x_axis, "zx", False)
self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", t, self.color_ik, "cube", h=self.size*.12, w=self.size*.12, d=self.length2, po=XSIMath.CreateVector3(0,0,self.length2*.5))
par.setKeyableParameters(self.ik_ctl)
par.addLocalParamToCollection(self.inv_params, self.ik_ctl, ["posx"])
# Upv
v = XSIMath.CreateVector3()
v.Sub(self.guide.apos[2], self.guide.apos[0])
v.Cross(self.normal, v)
v.NormalizeInPlace()
v.ScaleInPlace(self.size * -.5)
v.AddInPlace(self.guide.apos[1])
self.upv_cns = pri.addNullFromPos(self.root, self.getName("upv_cns"), v, self.size*.02)
self.addToGroup(self.upv_cns, "hidden")
self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", self.upv_cns.Kinematics.Global.Transform, self.color_ik, "leash", h=self.size*.05, ap=self.guide.apos[1])
par.setKeyableParameters(self.upv_ctl, self.t_params)
par.addLocalParamToCollection(self.inv_params, self.upv_ctl, ["posx"])
# References ---------------------------------------
x = XSIMath.CreateVector3(0,-1,0)
x.MulByRotationInPlace(self.ik_ctl.Kinematics.Global.Transform.Rotation)
z = XSIMath.CreateVector3(1,0,0)
z.MulByRotationInPlace(self.ik_ctl.Kinematics.Global.Transform.Rotation)
r = tra.getRotationFromAxis(x, z, "xz", self.negate)
t = self.ik_ctl.Kinematics.Global.Transform
t.SetRotation(r)
# Ik ref
self.ik_ref = pri.addNull(self.ik_ctl, self.getName("ik_ref"), t, self.size * .1)
self.addToGroup(self.ik_ref, "hidden")
# Fk ref
self.fk_ref = pri.addNull(self.fk3_ctl, self.getName("fk_ref"), t, self.size * .1)
self.addToGroup(self.fk_ref, "hidden")
# Roll Controler -----------------------------------
if self.settings["roll"] == 0: # Roll with a controler
self.roll_ctl = self.addCtl(self.root, "roll_ctl", self.ik_ctl.Kinematics.Global.Transform, self.color_ik, "bendedarrow2", w=self.length2*.5*self.n_factor, po=XSIMath.CreateVector3(0,self.length2*.5*self.n_factor,0))
if self.negate:
self.roll_ctl.Kinematics.Local.Parameters("rotx").Value = 180
xsi.SetNeutralPose(self.roll_ctl)
par.setKeyableParameters(self.roll_ctl, self.r_params)
# Chain --------------------------------------------
self.ref_chn = pri.add2DChain(self.root, self.getName("ref"), self.guide.apos[:3], self.normal, self.negate, self.size*.1, True)
self.addToGroup(self.ref_chn.all, "hidden")
self.end_chn = pri.add2DChain(self.ref_chn.bones[-1], self.getName("end"), self.guide.apos[2:4], self.normal, self.negate, self.size*.1, True)
self.addToGroup(self.end_chn.all, "hidden")
# Reference Nulls ---------------------------------
self.ref_loc = []
parent = self.root
for i, ref in enumerate([self.fk0_ctl, self.fk1_ctl, self.fk2_ctl, self.fk_ref]):
t = tra.getFilteredTransform(ref.Kinematics.Global.Transform, True, True, False)
ref_loc = pri.addNull(parent, self.getName("ref%s_loc"%i), t, self.size*.1)
self.addToGroup(ref_loc, "hidden")
self.ref_loc.append(ref_loc)
parent = ref_loc
# Mid Controler ------------------------------------
self.ctrn0_loc = pri.addNullFromPos(self.ref_loc[0], self.getName("ctrn0_loc"), self.guide.apos[1], self.size*.05)
self.ctrn1_loc = pri.addNullFromPos(self.ref_loc[1], self.getName("ctrn1_loc"), self.guide.apos[2], self.size*.05)
self.addToGroup([self.ctrn0_loc, self.ctrn1_loc], "hidden")
self.mid0_ctl = self.addCtl(self.ctrn0_loc, "mid0_ctl", self.ctrn0_loc.Kinematics.Global.Transform, self.color_ik, "sphere", h=self.size*.1)
par.addLocalParamToCollection(self.inv_params, self.mid0_ctl, ["posx", "posy", "posz"])
self.mid1_ctl = self.addCtl(self.ctrn1_loc, "mid1_ctl", self.ctrn1_loc.Kinematics.Global.Transform, self.color_ik, "sphere", h=self.size*.1)
par.addLocalParamToCollection(self.inv_params, self.mid1_ctl, ["posx", "posy", "posz"])
# Twist references ---------------------------------
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate)
self.tws0_loc = pri.addNull(self.root, self.getName("tws0_loc"), t, self.size*.05)
self.tws0_rot = pri.addNull(self.tws0_loc, self.getName("tws0_rot"), t)
pri.setNullDisplay(self.tws0_rot, 0, self.size*.05, 2, 0, 0, 0, self.size*.01)
self.tws1_loc = pri.addNull(self.ctrn0_loc, self.getName("tws1_loc"), self.ctrn0_loc.Kinematics.Global.Transform, self.size*.05)
self.tws1_rot = pri.addNull(self.tws1_loc, self.getName("tws1_rot"), self.ctrn0_loc.Kinematics.Global.Transform)
pri.setNullDisplay(self.tws1_rot, 0, self.size*.05, 2, 0, 0, 0, self.size*.01)
self.tws2_loc = pri.addNull(self.ctrn1_loc, self.getName("tws2_loc"), self.ctrn1_loc.Kinematics.Global.Transform, self.size*.05)
self.tws2_rot = pri.addNull(self.tws2_loc, self.getName("tws2_rot"), self.ctrn1_loc.Kinematics.Global.Transform)
pri.setNullDisplay(self.tws2_rot, 0, self.size*.05, 2, 0, 0, 0, self.size*.01)
t = tra.getFilteredTransform(self.ref_loc[-2].Kinematics.Global.Transform, True, True, False)
t.SetTranslation(self.guide.apos[3])
self.tws3_loc = pri.addNull(self.ref_loc[-2], self.getName("tws3_loc"), t, self.size*.05)
self.tws3_rot = pri.addNull(self.tws3_loc, self.getName("tws3_rot"),t)
self.tws3_rot.Kinematics.Global.Parameters("SclX").Value = .001
pri.setNullDisplay(self.tws3_rot, 0, self.size*.05, 2, 0, 0, 0, self.size*.01)
self.addToGroup([self.tws0_loc, self.tws0_rot, self.tws1_loc, self.tws1_rot, self.tws2_loc, self.tws2_rot, self.tws3_loc, self.tws3_rot], "hidden")
# End reference ------------------------------------
t = tra.getFilteredTransform(self.tws3_rot.Kinematics.Global.Transform, True, True, False)
self.end_ref = pri.addNull(self.tws3_rot, self.getName("end_ref"), t, self.size*.2)
self.addToGroup(self.end_ref, "hidden")
self.addShadow(self.end_ref, "end")
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for the elbow.
self.divisions = self.settings["div0"] + self.settings["div1"] + self.settings["div2"] + 4
self.div_cns = []
for i in range(self.divisions):
div_cns = pri.addNull(self.tws0_loc, self.getName("div%s_loc"%i), XSIMath.CreateTransform())
pri.setNullDisplay(div_cns, 1, self.size*.02, 10, 0, 0, 0, 1, 1, 2)
self.addToGroup(div_cns, "hidden")
self.div_cns.append(div_cns)
self.addShadow(div_cns, i)
def switchToIk(self):
# Get the distance between Root and effector and compare it to bones total length to define if the chain is bend or not
vRootEff = XSIMath.CreateVector3()
vRootEff.Sub(self.jnt0.kinematics.Global.Transform.Translation, self.ik.kinematics.Global.Transform.Translation)
# We get an approximation of the length otherwise it's sometimes tricky to compare distance
r = 100000
dRootEffLength = round((vRootEff.Length()*r)) / r
dBonesLength = round(((self.length0 + self.length1)*r)) / r
# xsi.MatchTransform(self.ik, self.eff, c.siRT, None)
# tra.matchGlobalTransform(self.eff, self.ik, True, True, False)
tra.matchGlobalTransform(self.ik, self.fk2, True, True, True)
self.blend.Value = 1
# tra.matchGlobalTransform(self.fk2, self.ik, False, True, False)
# Compute Roll
if dRootEffLength < dBonesLength:
# Get Vectors to built the plane
vFKChain0 = XSIMath.CreateVector3()
vIKChain0 = XSIMath.CreateVector3()
vRootEff = XSIMath.CreateVector3()
vFKChain0.Sub(self.fk0.kinematics.Global.Transform.Translation, self.fk1.kinematics.Global.Transform.Translation)
vIKChain0.Sub(self.jnt0.kinematics.Global.Transform.Translation , self.jnt1.kinematics.Global.Transform.Translation)
vRootEff.Sub(self.jnt0.kinematics.Global.Transform.Translation, self.ik.kinematics.Global.Transform.Translation)
# vFKChain0.NormalizeInPlace()
# vIKChain0.NormalizeInPlace()
# vRootEff.NormalizeInPlace()
# Get Plane's Normal
vNormFKPlane = XSIMath.CreateVector3()
vNormIKPlane = XSIMath.CreateVector3()
vNormFKPlane.Cross(vFKChain0, vRootEff)
vNormIKPlane.Cross(vIKChain0, vRootEff)
# vNormFKPlane.NormalizeInPlace()
# vNormIKPlane.NormalizeInPlace()
# Get the Angle between the two planess
dAngle = XSIMath.RadiansToDegrees(vNormFKPlane.Angle(vNormIKPlane))
# Check if we have to remove or add the angle
vCrossPlane = XSIMath.CreateVector3()
vCrossPlane.Cross(vNormFKPlane, vNormIKPlane)
# vCrossPlane.NormalizeInPlace()
dDirectionDot = vCrossPlane.Dot(vRootEff)
# Set the new roll Value
a = self.roll.Value + (dDirectionDot/abs(dDirectionDot)) * dAngle
# Set the angle in a -180 / 180 range
if abs(a) > 180:
a = a%((-a /abs(a))*360)
# [OLD WAY ]Set the new roll Value --
# Check if the bone is negated or not
## dNegate = self.jnt1.kinematics.Local.posx.Value + self.jnt1.kinematics.Local.nposx.Value
#dNegate = 1
# oldAngle = self.roll.Value
# if (dDirectionDot * dNegate) < 0:
# newAngle = oldAngle - dAngle
# else:
# newAngle = oldAngle + dAngle
# if newAngle > 180:
# newAngle -= 360
# elif newAngle < -180:
# newAngle += 360
# [END OLD WAY ] -------------------
self.roll.Value = a
# Match Scale Value
# We remove Soft distances
self.softik.Value = 0
if dRootEffLength > dBonesLength:
if self.scale.Value > self.maxstretch.Value:
self.maxstretch.Value = self.scale.Value
self.scale.Value = 1
if self.isleg:
z = XSIMath.CreateVector3(1,0,0)
y = XSIMath.CreateVector3(0,1,0)
if self.negate:
z.NegateInPlace()
y.NegateInPlace()
z.MulByRotationInPlace(self.fk2.Kinematics.Global.Transform.Rotation)
y.MulByRotationInPlace(self.fk2.Kinematics.Global.Transform.Rotation)
t = self.fk2.Kinematics.Global.Transform
t.SetRotation(tra.getRotationFromAxis(z, y, "zy"))
self.ik.Kinematics.Global.Transform = t
else:
tra.matchGlobalTransform(self.ik, self.fk2, False, True, True)
def addObjects(self):
self.normal = self.getNormalFromPos(self.guide.apos)
self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2])
self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3])
# FK Controlers ------------------------------------
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1], self.normal, "xz", self.negate)
self.fk0_ctl = self.addCtl(self.root, "fk0_ctl", t, self.color_fk, "cube", h=self.size*.1, w=1, d=self.size*.1, po=XSIMath.CreateVector3(.5*self.n_factor,0,0))
self.fk0_ctl.Parameters("SclX").Value = self.length0
xsi.SetNeutralPose(self.fk0_ctl)
par.setKeyableParameters(self.fk0_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk0_ctl, ["posx", "posy", "posz"])
t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2], self.normal, "xz", self.negate)
self.fk1_ctl = self.addCtl(self.fk0_ctl, "fk1_ctl", t, self.color_fk, "cube", h=self.size*.1, w=1, d=self.size*.1, po=XSIMath.CreateVector3(.5*self.n_factor,0,0))
self.fk1_ctl.Parameters("SclX").Value = self.length1/self.length0
xsi.SetNeutralPose(self.fk1_ctl, c.siST)
par.setKeyableParameters(self.fk1_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk1_ctl, ["posx", "posy", "posz"])
t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.normal, "xz", self.negate)
self.fk2_ctl = self.addCtl(self.fk1_ctl, "fk2_ctl", t, self.color_fk, "cube", h=self.size*.1, w=self.length2, d=self.size*.1, po=XSIMath.CreateVector3(self.length2*.5*self.n_factor,0,0))
xsi.SetNeutralPose(self.fk2_ctl, c.siST)
par.setKeyableParameters(self.fk2_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk2_ctl, ["posx", "posy", "posz"])
# IK Controlers ------------------------------------
self.ik_cns = pri.addNullFromPos(self.root, self.getName("ik_cns"), self.guide.apos[2], self.size*.02)
self.addToGroup(self.ik_cns, "hidden")
self.ikcns_ctl = self.addCtl(self.ik_cns, "ikcns_ctl", self.ik_cns.Kinematics.Global.Transform, self.color_ik, "null", h=self.size*.2)
par.setKeyableParameters(self.ikcns_ctl)
par.addLocalParamToCollection(self.inv_params, self.ikcns_ctl, ["posx", "rotx", "rotz"])
t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3], self.x_axis, "zx", False)
self.ik_ctl = self.addCtl(self.ikcns_ctl, "ik_ctl", t, self.color_ik, "cube", h=self.size*.12, w=self.length2, d=self.size*.12, po=XSIMath.CreateVector3(0,0,self.length2*.5))
self.addToCtlGroup(self.ik_ctl)
par.setKeyableParameters(self.ik_ctl)
par.addLocalParamToCollection(self.inv_params, self.ik_ctl, ["posx"])
# IK and FK references
self.ik_ref = pri.addNull(self.ik_ctl, self.getName("ik_ref"), self.ik_ctl.Kinematics.Global.Transform, self.size * .1)
self.addToGroup(self.ik_ref, "hidden")
self.fk_ref = pri.addNull(self.fk2_ctl, self.getName("fk_ref"), self.ik_ref.Kinematics.Global.Transform, self.size * .1)
self.addToGroup(self.fk_ref, "hidden")
v = XSIMath.CreateVector3()
v.Sub(self.guide.apos[2], self.guide.apos[0])
v.Cross(self.normal, v)
v.NormalizeInPlace()
v.ScaleInPlace(self.size*.5)
v.AddInPlace(self.guide.apos[1])
self.upv_cns = pri.addNullFromPos(self.root, self.getName("upv_cns"), v, self.size*.02)
self.addToGroup(self.upv_cns, "hidden")
self.upv_ctl = self.addCtl(self.upv_cns, "upv_ctl", self.upv_cns.Kinematics.Global.Transform, self.color_ik, "leash", h=self.size*.05, ap=self.guide.apos[1])
par.setKeyableParameters(self.upv_ctl, self.t_params)
par.addLocalParamToCollection(self.inv_params, self.upv_ctl, ["posx"])
# Chain --------------------------------------------
self.bone0 = pri.addNull(self.root, self.getName("0_jnt"), self.fk0_ctl.Kinematics.Global.Transform)
pri.setNullDisplay(self.bone0, 0, 1, 4, self.n_factor*.5, 0, 0, 1, self.size*.01, self.size*.01)
self.bone0.Kinematics.Global.Parameters("sclx").Value = self.length0
self.bone1 = pri.addNull(self.bone0, self.getName("1_jnt"), self.fk1_ctl.Kinematics.Global.Transform)
pri.setNullDisplay(self.bone1, 0, 1, 4, self.n_factor*.5, 0, 0, 1, self.size*.01, self.size*.01)
self.bone1.Kinematics.Global.Parameters("sclx").Value = self.length1
self.ctrn_loc = pri.addNullFromPos(self.bone0, self.getName("ctrn_loc"), self.guide.apos[1], self.size*.05)
self.eff_loc = pri.addNullFromPos(self.root, self.getName("eff_loc"), self.guide.apos[2], self.size*.05)
x = XSIMath.CreateVector3(0,-1,0)
x.MulByRotationInPlace(self.eff_loc.Kinematics.Global.Transform.Rotation)
z = XSIMath.CreateVector3(self.normal.X,self.normal.Y,self.normal.Z)
z.MulByRotationInPlace(self.eff_loc.Kinematics.Global.Transform.Rotation)
r = tra.getRotationFromAxis(x, z, "xz", self.negate)
t = self.ik_ctl.Kinematics.Global.Transform
t.SetRotation(r)
self.tws_ref = pri.addNull(self.eff_loc, self.getName("tws_ref"), t, self.size * .1)
self.addToGroup([self.bone0, self.bone1, self.ctrn_loc, self.eff_loc, self.tws_ref], "hidden")
# Mid Controler ------------------------------------
self.mid_ctl = self.addCtl(self.ctrn_loc, "mid_ctl", self.ctrn_loc.Kinematics.Global.Transform, self.color_ik, "sphere", h=self.size*.2)
par.addLocalParamToCollection(self.inv_params, self.mid_ctl, ["posx", "posy", "posz"])
# Twist references ---------------------------------
t = tra.getFilteredTransform(self.fk0_ctl.Kinematics.Global.Transform, True, True, False)
self.tws0_loc = pri.addNull(self.root, self.getName("tws0_loc"), t, self.size*.05)
self.tws0_rot = pri.addNull(self.tws0_loc, self.getName("tws0_rot"), t)
pri.setNullDisplay(self.tws0_rot, 0, self.size*.05, 2, 0, 0, 0, self.size*.01)
self.tws1_loc = pri.addNull(self.ctrn_loc, self.getName("tws1_loc"), self.ctrn_loc.Kinematics.Global.Transform, self.size*.05)
self.tws1_rot = pri.addNull(self.tws1_loc, self.getName("tws1_rot"), self.ctrn_loc.Kinematics.Global.Transform)
pri.setNullDisplay(self.tws1_rot, 0, self.size*.05, 2, 0, 0, 0, self.size*.01)
t = tra.getFilteredTransform(self.bone1.Kinematics.Global.Transform, True, True, False)
t.SetTranslation(self.guide.apos[2])
self.tws2_loc = pri.addNull(self.bone1, self.getName("tws2_loc"), t, self.size*.05)
self.tws2_rot = pri.addNull(self.tws2_loc, self.getName("tws2_rot"),t)
self.tws2_rot.Kinematics.Global.Parameters("SclX").Value = .001
pri.setNullDisplay(self.tws2_rot, 0, self.size*.05, 2, 0, 0, 0, self.size*.01)
self.addToGroup([self.tws0_loc, self.tws0_rot, self.tws1_loc, self.tws1_rot, self.tws2_loc, self.tws2_rot], "hidden")
# End reference ------------------------------------
t = tra.getFilteredTransform(self.tws2_rot.Kinematics.Global.Transform, True, True, False)
self.end_ref = pri.addNull(self.tws2_rot, self.getName("end_ref"), t, self.size*.2)
self.addToGroup(self.end_ref, "hidden")
self.addShadow(self.end_ref, "end")
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for the elbow.
self.divisions = self.settings["div0"] + self.settings["div1"] + 3
self.div_cns = []
for i in range(self.divisions):
div_cns = pri.addNull(self.tws0_loc, self.getName("div%s_loc"%i), XSIMath.CreateTransform())
pri.setNullDisplay(div_cns, 1, self.size*.02, 10, 0, 0, 0, 1, 1, 2)
self.addToGroup(div_cns, "hidden")
self.div_cns.append(div_cns)
self.addShadow(div_cns, i)
def addObjects(self):
self.normal = self.getNormalFromPos(self.guide.apos[1:])
self.length0 = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
self.length1 = vec.getDistance(self.guide.apos[1], self.guide.apos[2])
self.length2 = vec.getDistance(self.guide.apos[2], self.guide.apos[3])
self.length3 = vec.getDistance(self.guide.apos[3], self.guide.apos[4])
# FK Controlers ------------------------------------
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1],
self.normal, "xz", self.negate)
self.fk0_ctl = self.addCtl(self.root,
"fk0_ctl",
t,
self.color_fk,
"cube",
w=1,
h=self.size * .1,
d=self.size * .1,
po=XSIMath.CreateVector3(
.5 * self.n_factor, 0, 0))
self.fk0_ctl.Kinematics.Global.Parameters("SclX").Value = self.length0
xsi.SetNeutralPose(self.fk0_ctl)
par.setKeyableParameters(self.fk0_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk0_ctl,
["posx", "posy", "posz"])
t = tra.getTransformLookingAt(self.guide.apos[1], self.guide.apos[2],
self.normal, "xz", self.negate)
self.fk1_ctl = self.addCtl(self.fk0_ctl,
"fk1_ctl",
t,
self.color_fk,
"cube",
w=1,
h=self.size * .1,
d=self.size * .1,
po=XSIMath.CreateVector3(
.5 * self.n_factor, 0, 0))
self.fk1_ctl.Kinematics.Global.Parameters("SclX").Value = self.length1
xsi.SetNeutralPose(self.fk1_ctl, c.siST)
par.setKeyableParameters(self.fk1_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk1_ctl,
["posx", "posy", "posz"])
t = tra.getTransformLookingAt(self.guide.apos[2], self.guide.apos[3],
self.normal, "xz", self.negate)
self.fk2_ctl = self.addCtl(self.fk1_ctl,
"fk2_ctl",
t,
self.color_fk,
"cube",
w=1,
h=self.size * .1,
d=self.size * .1,
po=XSIMath.CreateVector3(
.5 * self.n_factor, 0, 0))
self.fk2_ctl.Kinematics.Global.Parameters("SclX").Value = self.length2
xsi.SetNeutralPose(self.fk2_ctl, c.siST)
par.setKeyableParameters(self.fk2_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk2_ctl,
["posx", "posy", "posz"])
t = tra.getTransformLookingAt(self.guide.apos[3], self.guide.apos[4],
self.normal, "xz", self.negate)
self.fk3_ctl = self.addCtl(self.fk2_ctl,
"fk3_ctl",
t,
self.color_fk,
"cube",
w=self.length3,
h=self.size * .1,
d=self.size * .1,
po=XSIMath.CreateVector3(
self.length3 * .5 * self.n_factor, 0,
0))
xsi.SetNeutralPose(self.fk3_ctl, c.siST)
par.setKeyableParameters(self.fk3_ctl)
par.addLocalParamToCollection(self.inv_params, self.fk3_ctl,
["posx", "posy", "posz"])
# IK Controlers ------------------------------------
self.ik_cns = pri.addNullFromPos(self.root, self.getName("ik_cns"),
self.guide.apos[3], self.size * .02)
self.addToGroup(self.ik_cns, "hidden")
self.ikcns_ctl = self.addCtl(self.ik_cns,
"ikcns_ctl",
self.ik_cns.Kinematics.Global.Transform,
self.color_ik,
"null",
h=self.size * .2)
self.addToCtlGroup(self.ikcns_ctl)
par.setKeyableParameters(self.ikcns_ctl)
par.addLocalParamToCollection(self.inv_params, self.ikcns_ctl,
["posx", "rotx", "rotz"])
t = tra.getTransformLookingAt(self.guide.apos[3], self.guide.apos[4],
self.x_axis, "zx", False)
self.ik_ctl = self.addCtl(self.ikcns_ctl,
"ik_ctl",
t,
self.color_ik,
"cube",
h=self.size * .12,
w=self.size * .12,
d=self.length2,
po=XSIMath.CreateVector3(
0, 0, self.length2 * .5))
par.setKeyableParameters(self.ik_ctl)
par.addLocalParamToCollection(self.inv_params, self.ik_ctl, ["posx"])
# Upv
v = XSIMath.CreateVector3()
v.Sub(self.guide.apos[2], self.guide.apos[0])
v.Cross(self.normal, v)
v.NormalizeInPlace()
v.ScaleInPlace(self.size * -.5)
v.AddInPlace(self.guide.apos[1])
self.upv_cns = pri.addNullFromPos(self.root, self.getName("upv_cns"),
v, self.size * .02)
self.addToGroup(self.upv_cns, "hidden")
self.upv_ctl = self.addCtl(self.upv_cns,
"upv_ctl",
self.upv_cns.Kinematics.Global.Transform,
self.color_ik,
"leash",
h=self.size * .05,
ap=self.guide.apos[1])
par.setKeyableParameters(self.upv_ctl, self.t_params)
par.addLocalParamToCollection(self.inv_params, self.upv_ctl, ["posx"])
# References ---------------------------------------
x = XSIMath.CreateVector3(0, -1, 0)
x.MulByRotationInPlace(
self.ik_ctl.Kinematics.Global.Transform.Rotation)
z = XSIMath.CreateVector3(1, 0, 0)
z.MulByRotationInPlace(
self.ik_ctl.Kinematics.Global.Transform.Rotation)
r = tra.getRotationFromAxis(x, z, "xz", self.negate)
t = self.ik_ctl.Kinematics.Global.Transform
t.SetRotation(r)
# Ik ref
self.ik_ref = pri.addNull(self.ik_ctl, self.getName("ik_ref"), t,
self.size * .1)
self.addToGroup(self.ik_ref, "hidden")
# Fk ref
self.fk_ref = pri.addNull(self.fk3_ctl, self.getName("fk_ref"), t,
self.size * .1)
self.addToGroup(self.fk_ref, "hidden")
# Roll Controler -----------------------------------
if self.settings["roll"] == 0: # Roll with a controler
self.roll_ctl = self.addCtl(
self.root,
"roll_ctl",
self.ik_ctl.Kinematics.Global.Transform,
self.color_ik,
"bendedarrow2",
w=self.length2 * .5 * self.n_factor,
po=XSIMath.CreateVector3(0, self.length2 * .5 * self.n_factor,
0))
if self.negate:
self.roll_ctl.Kinematics.Local.Parameters("rotx").Value = 180
xsi.SetNeutralPose(self.roll_ctl)
par.setKeyableParameters(self.roll_ctl, self.r_params)
# Chain --------------------------------------------
self.ref_chn = pri.add2DChain(self.root, self.getName("ref"),
self.guide.apos[:3], self.normal,
self.negate, self.size * .1, True)
self.addToGroup(self.ref_chn.all, "hidden")
self.end_chn = pri.add2DChain(self.ref_chn.bones[-1],
self.getName("end"),
self.guide.apos[2:4], self.normal,
self.negate, self.size * .1, True)
self.addToGroup(self.end_chn.all, "hidden")
# Reference Nulls ---------------------------------
self.ref_loc = []
parent = self.root
for i, ref in enumerate(
[self.fk0_ctl, self.fk1_ctl, self.fk2_ctl, self.fk_ref]):
t = tra.getFilteredTransform(ref.Kinematics.Global.Transform, True,
True, False)
ref_loc = pri.addNull(parent, self.getName("ref%s_loc" % i), t,
self.size * .1)
self.addToGroup(ref_loc, "hidden")
self.ref_loc.append(ref_loc)
parent = ref_loc
# Mid Controler ------------------------------------
self.ctrn0_loc = pri.addNullFromPos(self.ref_loc[0],
self.getName("ctrn0_loc"),
self.guide.apos[1],
self.size * .05)
self.ctrn1_loc = pri.addNullFromPos(self.ref_loc[1],
self.getName("ctrn1_loc"),
self.guide.apos[2],
self.size * .05)
self.addToGroup([self.ctrn0_loc, self.ctrn1_loc], "hidden")
self.mid0_ctl = self.addCtl(self.ctrn0_loc,
"mid0_ctl",
self.ctrn0_loc.Kinematics.Global.Transform,
self.color_ik,
"sphere",
h=self.size * .1)
par.addLocalParamToCollection(self.inv_params, self.mid0_ctl,
["posx", "posy", "posz"])
self.mid1_ctl = self.addCtl(self.ctrn1_loc,
"mid1_ctl",
self.ctrn1_loc.Kinematics.Global.Transform,
self.color_ik,
"sphere",
h=self.size * .1)
par.addLocalParamToCollection(self.inv_params, self.mid1_ctl,
["posx", "posy", "posz"])
# Twist references ---------------------------------
t = tra.getTransformLookingAt(self.guide.apos[0], self.guide.apos[1],
self.normal, "xz", self.negate)
self.tws0_loc = pri.addNull(self.root, self.getName("tws0_loc"), t,
self.size * .05)
self.tws0_rot = pri.addNull(self.tws0_loc, self.getName("tws0_rot"), t)
pri.setNullDisplay(self.tws0_rot, 0, self.size * .05, 2, 0, 0, 0,
self.size * .01)
self.tws1_loc = pri.addNull(self.ctrn0_loc, self.getName("tws1_loc"),
self.ctrn0_loc.Kinematics.Global.Transform,
self.size * .05)
self.tws1_rot = pri.addNull(self.tws1_loc, self.getName("tws1_rot"),
self.ctrn0_loc.Kinematics.Global.Transform)
pri.setNullDisplay(self.tws1_rot, 0, self.size * .05, 2, 0, 0, 0,
self.size * .01)
self.tws2_loc = pri.addNull(self.ctrn1_loc, self.getName("tws2_loc"),
self.ctrn1_loc.Kinematics.Global.Transform,
self.size * .05)
self.tws2_rot = pri.addNull(self.tws2_loc, self.getName("tws2_rot"),
self.ctrn1_loc.Kinematics.Global.Transform)
pri.setNullDisplay(self.tws2_rot, 0, self.size * .05, 2, 0, 0, 0,
self.size * .01)
t = tra.getFilteredTransform(
self.ref_loc[-2].Kinematics.Global.Transform, True, True, False)
t.SetTranslation(self.guide.apos[3])
self.tws3_loc = pri.addNull(self.ref_loc[-2], self.getName("tws3_loc"),
t, self.size * .05)
self.tws3_rot = pri.addNull(self.tws3_loc, self.getName("tws3_rot"), t)
self.tws3_rot.Kinematics.Global.Parameters("SclX").Value = .001
pri.setNullDisplay(self.tws3_rot, 0, self.size * .05, 2, 0, 0, 0,
self.size * .01)
self.addToGroup([
self.tws0_loc, self.tws0_rot, self.tws1_loc, self.tws1_rot,
self.tws2_loc, self.tws2_rot, self.tws3_loc, self.tws3_rot
], "hidden")
# End reference ------------------------------------
t = tra.getFilteredTransform(self.tws3_rot.Kinematics.Global.Transform,
True, True, False)
self.end_ref = pri.addNull(self.tws3_rot, self.getName("end_ref"), t,
self.size * .2)
self.addToGroup(self.end_ref, "hidden")
self.addShadow(self.end_ref, "end")
# Divisions ----------------------------------------
# We have at least one division at the start, the end and one for the elbow.
self.divisions = self.settings["div0"] + self.settings[
"div1"] + self.settings["div2"] + 4
self.div_cns = []
for i in range(self.divisions):
div_cns = pri.addNull(self.tws0_loc, self.getName("div%s_loc" % i),
XSIMath.CreateTransform())
pri.setNullDisplay(div_cns, 1, self.size * .02, 10, 0, 0, 0, 1, 1,
2)
self.addToGroup(div_cns, "hidden")
self.div_cns.append(div_cns)
self.addShadow(div_cns, i)
