def alignRootToFirstBone(xChain):
t = XSIMath.CreateTransform()
t.SetTranslation(xChain.root.Kinematics.Global.Transform.Translation)
t.SetRotation(xChain.bones[0].Kinematics.Global.Transform.Rotation)
xChain.root.Kinematics.Global.Transform = t
t = XSIMath.CreateTransform()
xChain.bones[0].Kinematics.Local.Transform = t
def draw(self, parent=None):
# Initial hierarchy
if parent is None:
self.initialHierarchy()
parent = self.model
# Controlers
for name, controler in self.controlers.items():
obj = controler.create(self.controlers_org, name,
XSIMath.CreateTransform(), [.25, .35, .25])
self.controlers_grp.AddMember(obj)
# Components
for name in self.componentsIndex:
comp_guide = self.components[name]
if comp_guide.parentComponent is None:
parent = self.model
else:
parent = self.model.FindChild(
comp_guide.parentComponent.getName(
comp_guide.parentLocalName))
if not parent:
gear.log(
"Unable to find parent (%s.%s) for guide %s" %
(comp_guide.parentComponent.getFullName,
comp_guide.parentLocalName, comp_guide.getFullName))
parent = self.model
comp_guide.drawFromXml(parent)
def getNegatedTransform(t, axis="xy"):
m = t.Matrix4
if axis == "yz":
m.Set(m.Value(0, 0), m.Value(0, 1), m.Value(0, 2),
m.Value(0, 3), -m.Value(1, 0), -m.Value(1, 1), -m.Value(1, 2),
m.Value(1, 3), -m.Value(2, 0), -m.Value(2, 1), -m.Value(2, 2),
m.Value(2, 3), m.Value(3, 0), m.Value(3, 1), m.Value(3, 2),
m.Value(3, 3))
elif axis == "xy":
m.Set(-m.Value(0, 0), -m.Value(0, 1), -m.Value(0, 2), m.Value(0, 3),
-m.Value(1, 0), -m.Value(1, 1), -m.Value(1, 2), m.Value(1, 3),
m.Value(2, 0), m.Value(2, 1), m.Value(2, 2), m.Value(2, 3),
m.Value(3, 0), m.Value(3, 1), m.Value(3, 2), m.Value(3, 3))
elif axis == "zx":
m.Set(-m.Value(0, 0), -m.Value(0, 1), -m.Value(0, 2), m.Value(0, 3),
m.Value(1, 0), m.Value(1, 1), m.Value(1, 2), m.Value(1, 3),
-m.Value(2, 0), -m.Value(2, 1), -m.Value(2, 2), m.Value(2, 3),
m.Value(3, 0), m.Value(3, 1), m.Value(3, 2), m.Value(3, 3))
t = XSIMath.CreateTransform()
t.Matrix4 = m
return t
def addNullFromPos(parent, name, position=XSIMath.CreateVector3(), size=1, color=[0,0,0]):
t = XSIMath.CreateTransform()
t.SetTranslation(position)
null = addNull(parent, name, t, size, color)
return null
def addBoneFromPos(parent, name, position=XSIMath.CreateVector3(), length=1):
t = XSIMath.CreateTransform()
t.SetTranslation(position)
bone = addBone(parent, name, t, length)
return bone
def addImplicite(parent, preset, name, t=XSIMath.CreateTransform(), size=1):
implicite = parent.AddPrimitive(preset, name)
implicite.Parameters("length").Value = max(size, .01)
implicite.Kinematics.Global.Transform = t
return implicite
def addNull(parent, name, t=XSIMath.CreateTransform(), size=1, color=[0,0,0]):
null = parent.AddNull(name)
null.Parameters("Size").Value = max(size, .01)
null.Kinematics.Global.Transform = t
uti.setColor(null, color)
return null
def __init__(self, t=XSIMath.CreateTransform()):
self.transform = t
self.x = XSIMath.CreateVector3(1, 0, 0)
self.y = XSIMath.CreateVector3(0, 1, 0)
self.z = XSIMath.CreateVector3(0, 0, 1)
self.x.MulByRotationInPlace(t.Rotation)
self.y.MulByRotationInPlace(t.Rotation)
self.z.MulByRotationInPlace(t.Rotation)
def getTransformLookingAt(position, lookat, normal, axis="xy", negate=False):
a = XSIMath.CreateVector3()
a.Sub(lookat, position)
r = getRotationFromAxis(a, normal, axis, negate)
t = XSIMath.CreateTransform()
t.SetTranslation(position)
t.SetRotation(r)
return t
def getFilteredTransform(t, translation=True, rotation=True, scaling=True):
out = XSIMath.CreateTransform()
if translation:
out.SetTranslation(t.Translation)
if rotation:
out.SetRotation(t.Rotation)
if scaling:
out.SetScaling(t.Scaling)
return out
def drawVector(vector, name="vector", parent=xsi.ActiveSceneRoot):
points = [0, 0, 0, 1, vector.X, vector.Y, vector.Z, 1]
curve = xsi.ActiveSceneRoot.AddNurbsCurve(points, None, False, 1,
c.siNonUniformParameterization,
c.siSINurbs, name)
log.logVector(vector, "draw " + curve.Name + " : ")
t = XSIMath.CreateTransform()
t.SetTranslation(parent.Kinematics.Global.Transform.Translation)
curve.Kinematics.Global.Transform = t
return curve
def addLattice(parent,
name,
t=XSIMath.CreateTransform(),
subd=[4, 4, 4],
size=[1, 1, 1]):
lattice = parent.AddPrimitive("Lattice", name)
lattice.Kinematics.Global.Transform = t
for i, s in enumerate("xyz"):
lattice.Parameters("subdiv%s" % s).Value = subd[i]
lattice.Parameters("size%s" % s).Value = size[i]
return lattice
def logMatrix4AsSRT(m, msg="matrix4"):
t = XSIMath.CreateTransform()
t.SetMatrix4(m)
vScl = t.Scaling
vRot = t.Rotation.XYZAngles
vRot.Set(XSIMath.RadiansToDegrees(vRot.X),
XSIMath.RadiansToDegrees(vRot.Y),
XSIMath.RadiansToDegrees(vRot.Z))
vPos = t.Translation
logVector(vScl, msg + " S")
logVector(vRot, msg + " R")
logVector(vPos, msg + " T")
def addCurve(parent,
name,
points,
close=False,
degree=1,
t=XSIMath.CreateTransform(),
color=[0, 0, 0]):
curve = parent.AddNurbsCurve(points, None, close, degree,
c.siNonUniformParameterization, c.siSINurbs,
name)
uti.setColor(curve, color)
curve.Kinematics.Global.Transform = t
return curve
def getTransform(self):
t = XSIMath.CreateTransform()
t.SetTranslationFromValues(float(self.transform["posx"]),
float(self.transform["posy"]),
float(self.transform["posz"]))
t.SetRotationFromXYZAnglesValues(
math.radians(float(self.transform["rotx"])),
math.radians(float(self.transform["roty"])),
math.radians(float(self.transform["rotz"])))
t.SetScalingFromValues(float(self.transform["sclx"]),
float(self.transform["scly"]),
float(self.transform["sclz"]))
return t
def draw(self, parent=None):
# Initial hierarchy
if parent is None:
self.initialHierarchy()
parent = self.model
# Controlers
for name, controler in self.controlers.items():
if controler.xml.find("primitive").find("curve") != None:
rC = controler.xml.find("primitive").find("curve").get(
"rColor")
gC = controler.xml.find("primitive").find("curve").get(
"gColor")
bC = controler.xml.find("primitive").find("curve").get(
"bColor")
ctlColor = [rC, gC, bC]
else:
ctlColor = [.25, .35, .25]
obj = controler.create(self.controlers_org, name,
XSIMath.CreateTransform(), ctlColor)
self.controlers_grp.AddMember(obj)
# Components
for name in self.componentsIndex:
comp_guide = self.components[name]
if comp_guide.parentComponent is None:
parent = self.model
else:
parent = self.model.FindChild(
comp_guide.parentComponent.getName(
comp_guide.parentLocalName))
if not parent:
gear.log(
"Unable to find parent (%s.%s) for guide %s" %
(comp_guide.parentComponent.getFullName,
comp_guide.parentLocalName, comp_guide.getFullName))
parent = self.model
comp_guide.drawFromXml(parent)
def addCurve2(parent,
name,
points,
ncp=[],
kn=[],
nkn=[],
close=[],
degree=[],
t=XSIMath.CreateTransform(),
color=[0, 0, 0]):
pointCount = len(ncp)
aPar = [c.siNonUniformParameterization for i in range(pointCount)]
curve = parent.AddNurbsCurveList2(pointCount, points, ncp, kn, nkn, close,
degree, aPar, c.siSINurbs, name)
uti.setColor(curve, color)
curve.Kinematics.Global.Transform = t
return curve
def addClusterCenter(obj, pnt_index=[]):
obj_geo = obj.ActivePrimitive.Geometry
if not pnt_index:
pnt_index = range(obj_geo.Points.Count)
centers = []
for i in pnt_index:
cluster = obj_geo.AddCluster(c.siVertexCluster, "center_%s"%i, [i])
t = XSIMath.CreateTransform()
t.SetTranslation(obj_geo.Points(i).Position)
center = obj.AddNull("center_%s"%i)
center.Kinematics.Global.Transform = t
xsi.ApplyOp( "ClusterCenter", cluster.FullName+";"+center.FullName, 0, 0, None, 2)
centers.append(center)
return centers
def addCurveFromPos(parent,
name,
positions,
close=False,
degree=1,
knotsPara=c.siNonUniformParameterization,
t=XSIMath.CreateTransform(),
color=[0, 0, 0]):
points = []
for v in positions:
points.append(v.X)
points.append(v.Y)
points.append(v.Z)
points.append(1)
curve = parent.AddNurbsCurve(points, None, close, degree, knotsPara,
c.siSINurbs, name)
uti.setColor(curve, color)
curve.Kinematics.Global.Transform = t
return curve
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
tra.setRefPose(self.fk0_ctl, [-90,0,0], self.negate)
xsi.SetNeutralPose(self.fk0_ctl, c.siSRT)
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.normal, "xz", self.negate)
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(self.length2*.5*self.n_factor,0,0))
tra.setRefPose(self.ik_ctl, [-90,0,0], self.negate)
par.setKeyableParameters(self.ik_ctl)
par.addLocalParamToCollection(self.inv_params, self.ik_ctl, ["posx"])
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)
self.addToGroup([self.bone0, self.bone1, self.ctrn_loc, self.eff_loc], "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*.05)
par.addLocalParamToCollection(self.inv_params, self.mid_ctl, ["posx", "posy", "posz"])
# Membrane -----------------------------------------
self.memb_loc = pri.addNull(self.mid_ctl, self.getName("memb_loc"), self.mid_ctl.Kinematics.Global.Transform, self.size*.02)
self.memb_crv = cur.addCnsCurve(self.memb_loc, self.getName("memb_crv"), [self.root, self.memb_loc, self.eff_loc], False, 3)
# 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 initialHierarchy(self):
self.plog.log("Build initial hierarchy")
# --------------------------------------------------
# Model
self.model = xsi.ActiveSceneRoot.AddModel(None,
self.options["rigName"])
self.model.Properties("visibility").Parameters("viewvis").Value = False
# --------------------------------------------------
# Global Ctl
if "global_C0_ctl" in self.guide.controlers.keys():
self.global_ctl = self.guide.controlers["global_C0_ctl"].create(
self.model, "global_C0_ctl", XSIMath.CreateTransform(),
self.options["C_color_fk"])
else:
self.global_ctl = icon.crossarrow(self.model, "global_C0_ctl", 10,
self.options["C_color_fk"])
par.setKeyableParameters(
self.global_ctl,
["posx", "posy", "posz", "rotx", "roty", "rotz", "rotorder"])
self.addToGroup(self.global_ctl, "controlers_01")
# --------------------------------------------------
# INFOS
self.info_prop = self.model.AddProperty("gear_PSet", False, "info")
pRigName = self.info_prop.AddParameter3("rig_name", c.siString,
self.options["rigName"], None,
None, False, True)
pUser = self.info_prop.AddParameter3("user", c.siString,
getpass.getuser(), None, None,
False, True)
pIsWip = self.info_prop.AddParameter3("isWip", c.siBool,
self.options["mode"] != 0, None,
None, False, True)
pDate = self.info_prop.AddParameter3("date", c.siString,
datetime.datetime.now(), None,
None, False, True)
pXSIVersion = self.info_prop.AddParameter3("xsi_version", c.siString,
xsi.Version(), None, None,
False, True)
pGEARVersion = self.info_prop.AddParameter3("gear_version", c.siString,
gear.getVersion(), None,
None, False, True)
pSynoptic = self.info_prop.AddParameter3("synoptic", c.siString,
self.options["synoptic"],
None, None, False, False)
pComments = self.info_prop.AddParameter3("comments", c.siString,
self.options["comments"],
None, None, False, True)
pComponentsGrid = self.info_prop.AddGridParameter("componentsGrid")
self.components_grid = pComponentsGrid.Value
self.components_grid.ColumnCount = 4
self.components_grid.SetColumnLabel(0, "Name")
self.components_grid.SetColumnLabel(1, "Type")
self.components_grid.SetColumnLabel(2, "Version")
self.components_grid.SetColumnLabel(3, "Author")
self.info_layout = ppg.PPGLayout()
self.info_mainTab = self.info_layout.addTab("Main")
group = self.info_mainTab.addGroup("Main")
group.addItem(pRigName.ScriptName, "Name")
group.addItem(pUser.ScriptName, "User")
group.addItem(pIsWip.ScriptName, "Is Wip")
group.addItem(pDate.ScriptName, "Date")
group.addItem(pXSIVersion.ScriptName, "XSI Version")
group.addItem(pGEARVersion.ScriptName, "GEAR Version")
group = self.info_mainTab.addGroup("Synoptic")
item = group.addItem(pSynoptic.ScriptName, "Synoptic")
item.setAttribute(c.siUINoLabel, True)
group = self.info_mainTab.addGroup("Comments")
item = group.addString(pComments.ScriptName, "", True, 120)
item.setAttribute(c.siUINoLabel, True)
self.info_componentTab = self.info_layout.addTab("Components")
group = self.info_componentTab.addGroup("GEAR")
group.addItem(pGEARVersion.ScriptName, "Version")
group = self.info_componentTab.addGroup("Components")
item = group.addItem(pComponentsGrid.ScriptName, "", c.siControlGrid)
item.setAttribute(c.siUINoLabel, True)
self.info_prop.Parameters("layout").Value = self.info_layout.getValue()
# --------------------------------------------------
# UI SETUP AND ANIM
self.ui = UIHost(self.global_ctl)
# Setup_Ctrl
self.setup_mainTab = self.ui.setup_layout.addTab("Main")
# Anim_Ctrl
self.anim_mainTab = self.ui.anim_layout.addTab("Main")
self.pRigScale = self.ui.anim_prop.AddParameter2(
"rigScale", c.siDouble, 1, 0.001, None, .001, 3,
c.siClassifUnknown, c.siAnimatable | c.siKeyable)
self.pOGLLevel = self.ui.anim_prop.AddParameter3(
"oglLevel", c.siInt4, 0, 0, 2, False, False)
self.pResolutions = self.ui.anim_prop.AddParameter3(
"resolutions", c.siInt4, 0, 0, None, False, False)
group = self.anim_mainTab.addGroup("Animate")
group.addItem(self.pRigScale.ScriptName, "Global Scale")
group = self.anim_mainTab.addGroup("Performance")
#group.addEnumControl(self.pResolutions.ScriptName, ["default", 0], "Resolutions", c.siControlCombo)
group.addItem(self.pOGLLevel.ScriptName, "OGL Level")
# scale expression
for s in "xyz":
par.addExpression(
self.global_ctl.Kinematics.Local.Parameters("scl" + s),
self.pRigScale)
# --------------------------------------------------
# Basic set of null
if self.options["shadowRig"]:
self.shd_org = self.model.AddNull("shd_org")
self.addToGroup(self.shd_org, "hidden")
def addBone(parent, name, t=XSIMath.CreateTransform(), length=1):
bone = addImplicite(parent, "Bone", name, t, length)
return bone
def getTransformFromPosition(position):
t = XSIMath.CreateTransform()
t.SetTranslation(position)
return t
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)
xsi.SetNeutralPose(self.fk0_ctl, c.siST)
par.setKeyableParameters(self.fk0_ctl)
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)
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)
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)
# 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)
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)
# 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)
# References ---------------------------------------
# Ik ref
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")
# Fk ref
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")
# Roll Controler -----------------------------------
if self.settings["roll"] == 0: # Roll with a controler
self.roll_ctl = self.addCtl(
self.ik_ref,
"roll_ctl",
self.ik_ref.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)
self.mid1_ctl = self.addCtl(self.ctrn1_loc,
"mid1_ctl",
self.ctrn1_loc.Kinematics.Global.Transform,
self.color_ik,
"sphere",
h=self.size * .1)
# 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[-1], self.getName("tws3_loc"),
t, self.size * .05)
self.tws3_rot = pri.addNull(self.tws3_loc, self.getName("tws3_rot"), t)
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")
# 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)