def gear_pathdriver_op(out, max, min, perc, driver):
# -----------------------------------------------------
# JSCRIPT
paramDefs = []
paramDefs.append(
XSIFactory.CreateParamDef("max", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
max, None, None, 0, 1))
paramDefs.append(
XSIFactory.CreateParamDef("min", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
min, None, None, -1, 0))
paramDefs.append(
XSIFactory.CreateParamDef("percentage", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
perc, 0, 100, 0, 100))
paramDefs.append(
XSIFactory.CreateParamDef("driver", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "", 0,
None, None, -1, 1))
outputPorts = [(out, "out")]
inputPorts = []
op = createJSOpFromFile("gear_pathdriver",
os.path.join(JSOPPATH, "gear_pathdriver_op.js"),
outputPorts, inputPorts, paramDefs)
op.Connect()
par.addExpression(op.Parameters("driver"), driver)
return op
def addLocMulti(self, name, parent):
if "#" not in name:
gear.log("You need to put a '#' in the name of multiple location.",
gear.sev_error)
return False
locs = []
i = 0
while True:
localName = string.replaceSharpWithPadding(name, i)
if localName not in self.tra.keys():
break
loc = pri.addNull(parent, self.getName(localName),
self.tra[localName])
pri.setNullDisplay(loc, 1, .5, 2, 0, 0, 0, .5, .5, .5,
GUIDE_LOC_COLOR)
par.addExpression(loc.size, self.root.size.FullName + " * .5")
locs.append(loc)
parent = loc
i += 1
return locs
def connect_standardWithIkRef(self):
self.parent.AddChild(self.root)
# Set the Ik Reference
if self.settings["ikrefarray"]:
ref_names = self.settings["ikrefarray"].split(",")
if len(ref_names) == 1:
ref = self.rig.findChild(ref_names[0])
ref.AddChild(self.ik_cns)
else:
for i, ref_name in enumerate(ref_names):
ref = self.rig.findChild(ref_name)
cns = self.ik_cns.Kinematics.AddConstraint("Pose", ref, True)
par.addExpression(cns.Parameters("active"), self.pIkRef.FullName+" == "+str(i))
# Set the Upv Reference
if self.settings["upvrefarray"]:
ref_names = self.settings["upvrefarray"].split(",")
if len(ref_names) == 1:
ref = self.rig.findChild(ref_names[0])
ref.AddChild(self.upv_cns)
else:
for i, ref_name in enumerate(ref_names):
ref = self.rig.findChild(ref_name)
cns = self.upv_cns.Kinematics.AddConstraint("Pose", ref, True)
par.addExpression(cns.Parameters("active"), self.pUpvRef.FullName+" == "+str(i))
def connect_standardWithIkRef(self):
self.parent.AddChild(self.root)
cns = aop.poseCns(self.head_cns, self.fk_ctl[-1], True, True, True,
False)
# Set the Head Reference
if self.settings["headrefarray"]:
ref_names = self.settings["headrefarray"].split(",")
for i, ref_name in enumerate(ref_names):
ref = self.rig.findChild(ref_name)
cns = aop.poseCns(self.head_cns, ref, True, False, True, False)
par.addExpression(cns.Parameters("active"),
self.pHeadRef.FullName + " == " + str(i + 1))
# Set the Ik Reference
if self.settings["ikrefarray"]:
ref_names = self.settings["ikrefarray"].split(",")
if len(ref_names) == 1:
ref = self.rig.findChild(ref_names[0])
ref.AddChild(self.ik_cns)
else:
for i, ref_name in enumerate(ref_names):
ref = self.rig.findChild(ref_name)
cns = self.ik_cns.Kinematics.AddConstraint(
"Pose", ref, True)
par.addExpression(cns.Parameters("active"),
self.pIkRef.FullName + " == " + str(i))
def connect_standardWithIkRef(self):
self.parent.AddChild(self.root)
# Set the Ik Reference
if self.settings["ikrefarray"]:
ref_names = self.settings["ikrefarray"].split(",")
if len(ref_names) == 1:
ref = self.rig.findChild(ref_names[0])
ref.AddChild(self.ik_cns)
else:
for i, ref_name in enumerate(ref_names):
ref = self.rig.findChild(ref_name)
cns = self.ik_cns.Kinematics.AddConstraint(
"Pose", ref, True)
par.addExpression(cns.Parameters("active"),
self.pIkRef.FullName + " == " + str(i))
# Set the Upv Reference
if self.settings["upvrefarray"]:
ref_names = self.settings["upvrefarray"].split(",")
if len(ref_names) == 1:
ref = self.rig.findChild(ref_names[0])
ref.AddChild(self.upv_cns)
else:
for i, ref_name in enumerate(ref_names):
ref = self.rig.findChild(ref_name)
cns = self.upv_cns.Kinematics.AddConstraint(
"Pose", ref, True)
par.addExpression(cns.Parameters("active"),
self.pUpvRef.FullName + " == " + str(i))
def connect_standardWithIkRef(self):
self.parent.AddChild(self.root)
cns = aop.poseCns(self.head_cns, self.fk_ctl[-1], True, True, True, False)
# Set the Head Reference
'''
if self.settings["headrefarray"]:
ref_names = self.settings["headrefarray"].split(",")
for i, ref_name in enumerate(ref_names):
ref = self.rig.findChild(ref_name)
cns = self.head_cns.Kinematics.AddConstraint("Pose", ref, True)
par.addExpression(cns.Parameters("active"), self.pHeadRef.FullName+" == "+str(i+1))
'''
# Set the Ik Reference
if self.settings["ikrefarray"]:
ref_names = self.settings["ikrefarray"].split(",")
if len(ref_names) == 1:
ref = self.rig.findChild(ref_names[0])
ref.AddChild(self.ik_cns)
else:
for i, ref_name in enumerate(ref_names):
ref = self.rig.findChild(ref_name)
cns = self.ik_cns.Kinematics.AddConstraint("Pose", ref, True)
par.addExpression(cns.Parameters("active"), self.pIkRef.FullName+" == "+str(i))
def connect_leg_3jnt_01(self):
# If the parent component hasn't been generated we skip the connection
if self.parent_comp is None:
return
self.parent_comp.ik_ctl.AddChild(self.root)
self.bk_ctl[-1].AddChild(self.parent_comp.ik_ref)
self.parent_comp.tws3_rot.AddChild(self.fk_ref)
par.addExpression(self.pBlend, self.parent_comp.pBlend.FullName)
def connect_leg_3jnt_01(self):
# If the parent component hasn't been generated we skip the connection
if self.parent_comp is None:
return
self.parent_comp.ik_ctl.AddChild(self.root)
self.bk_ctl[-1].AddChild(self.parent_comp.ik_ref)
self.parent_comp.tws3_rot.AddChild(self.fk_ref)
par.addExpression(self.pBlend, self.parent_comp.pBlend.FullName)
def connect_leg_3jnt_01(self):
# If the parent component hasn't been generated we skip the connection
if self.parent_comp is None:
return
self.parent_comp.fk3_ctl.addChild(self.root)
self.root.Kinematics.AddConstraint("Pose", self.parent_comp.fk3_ctl, True)
cns = self.root.Kinematics.AddConstraint("Pose", self.parent_comp.ik_ctl, True)
par.addExpression(cns.Parameters("blendweight"), self.parent_comp.pBlend.FullName)
self.parent_comp.tws3_rot.addChild(self.ref_chn[0].root)
def addOperators(self):
for i, ref_chn in enumerate(self.ref_chn):
ref_chn.eff.Kinematics.AddConstraint("Position", self.dir_ref[i+1], False)
self.fk_ref[i].Kinematics.AddConstraint("Pose", ref_chn.bones[0], False)
for fk_ref, fk_ctl in zip(self.fk_ref, self.fk_ctl):
for s in "xyz":
par.addExpression(fk_ctl.Kinematics.Local.Parameters("nrot"+s), fk_ref.Kinematics.Local.Parameters("rot"+s))
par.addExpression(fk_ctl.Kinematics.Local.Parameters("npos"+s), fk_ref.Kinematics.Local.Parameters("pos"+s))
def connect_leg_3jnt_01(self):
# If the parent component hasn't been generated we skip the connection
if self.parent_comp is None:
return
self.parent_comp.fk3_ctl.addChild(self.root)
self.root.Kinematics.AddConstraint("Pose", self.parent_comp.fk3_ctl,
True)
cns = self.root.Kinematics.AddConstraint("Pose",
self.parent_comp.ik_ctl, True)
par.addExpression(cns.Parameters("blendweight"),
self.parent_comp.pBlend.FullName)
self.parent_comp.tws3_rot.addChild(self.ref_chn[0].root)
def addLoc(self, name, parent, position=None):
if name not in self.tra.keys():
self.tra[name] = tra.getTransformFromPosition(position)
if name in self.prim.keys():
loc = self.prim[name].create(parent, self.getName(name), self.tra[name], GUIDE_LOC_COLOR)
else:
loc = pri.addNull(parent, self.getName(name), self.tra[name])
pri.setNullDisplay(loc, 1, .5, 2, 0, 0, 0, .5, .5, .5, GUIDE_LOC_COLOR)
if loc.Type == "null":
par.addExpression(loc.size, self.root.size.FullName+" * .5")
return loc
def sn_inverseRotorder_op(out_obj, in_obj):
# Create Operator
op = XSIFactory.CreateObject("sn_inverseRotorder_op")
# Output
op.AddOutputPort(out_obj.Kinematics.Local.Parameters("rotorder"))
# Input
# Connect
op.Connect()
par.addExpression(op.Parameters("rotorder"), in_obj.Kinematics.Local.Parameters("rotorder").FullName)
return op
def sn_rotspring_op(out):
# Create Operator
op = XSIFactory.CreateObject("sn_rotspring_op")
# Outputs
op.AddOutputPort(out.Kinematics.Global)
# Inputs
op.AddInputPort(out.Parent3DObject.Kinematics.Global)
# Connect
op.Connect()
par.addExpression(op.Parameters("fc"), "fc")
return op
def sn_inverseRotorder_op(out_obj, in_obj):
# Create Operator
op = XSIFactory.CreateObject("sn_inverseRotorder_op")
# Output
op.AddOutputPort(out_obj.Kinematics.Local.Parameters("rotorder"))
# Input
# Connect
op.Connect()
par.addExpression(op.Parameters("rotorder"),
in_obj.Kinematics.Local.Parameters("rotorder").FullName)
return op
def sn_rotspring_op(out):
# Create Operator
op = XSIFactory.CreateObject("sn_rotspring_op")
# Outputs
op.AddOutputPort(out.Kinematics.Global)
# Inputs
op.AddInputPort(out.Parent3DObject.Kinematics.Global)
# Connect
op.Connect()
par.addExpression(op.Parameters("fc"), "fc")
return op
def addOperators(self):
for i, ref_chn in enumerate(self.ref_chn):
ref_chn.eff.Kinematics.AddConstraint("Position",
self.dir_ref[i + 1], False)
self.fk_ref[i].Kinematics.AddConstraint("Pose", ref_chn.bones[0],
False)
for fk_ref, fk_ctl in zip(self.fk_ref, self.fk_ctl):
for s in "xyz":
par.addExpression(
fk_ctl.Kinematics.Local.Parameters("nrot" + s),
fk_ref.Kinematics.Local.Parameters("rot" + s))
par.addExpression(
fk_ctl.Kinematics.Local.Parameters("npos" + s),
fk_ref.Kinematics.Local.Parameters("pos" + s))
def connect_standardWithIkRef(self):
self.parent.AddChild(self.root)
if self.settings["cornerARefArray"]:
ref_names = self.settings["cornerARefArray"].split(",")
for i, ref_name in enumerate(ref_names):
ref = self.rig.findChild(ref_name)
cns = aop.poseCns(self.cornerA, ref, True, True, True, False)
par.addExpression(cns.Parameters("active"), self.pCornerARef.FullName+" == "+str(i+1))
if self.settings["cornerBRefArray"]:
ref_names = self.settings["cornerBRefArray"].split(",")
for i, ref_name in enumerate(ref_names):
ref = self.rig.findChild(ref_name)
cns = aop.poseCns(self.cornerB, ref, True, True, True, False)
par.addExpression(cns.Parameters("active"), self.pCornerBRef.FullName+" == "+str(i+1))
def sn_xfspring_op(out, mode=2):
# Create Operator
op = XSIFactory.CreateObject("sn_xfspring_op")
# Outputs
op.AddOutputPort(out.Kinematics.Global)
# Inputs
op.AddInputPort(out.Parent3DObject.Kinematics.Global)
# Set default values
op.Parameters("mode").Value = mode
# Connect
op.Connect()
par.addExpression(op.Parameters("fc"), "fc")
return op
def sn_xfspring_op(out, mode=2):
# Create Operator
op = XSIFactory.CreateObject("sn_xfspring_op")
# Outputs
op.AddOutputPort(out.Kinematics.Global)
# Inputs
op.AddInputPort(out.Parent3DObject.Kinematics.Global)
# Set default values
op.Parameters("mode").Value = mode
# Connect
op.Connect()
par.addExpression(op.Parameters("fc"), "fc")
return op
def gear_pathdriver_op(out, max, min, perc, driver):
# -----------------------------------------------------
# JSCRIPT
paramDefs = []
paramDefs.append(XSIFactory.CreateParamDef("max", c.siDouble, 0, c.siPersistable|c.siAnimatable, "", "", max, None, None, 0, 1))
paramDefs.append(XSIFactory.CreateParamDef("min", c.siDouble, 0, c.siPersistable|c.siAnimatable, "", "", min, None, None, -1, 0))
paramDefs.append(XSIFactory.CreateParamDef("percentage", c.siDouble, 0, c.siPersistable|c.siAnimatable, "", "", perc, 0, 100, 0, 100))
paramDefs.append(XSIFactory.CreateParamDef("driver", c.siDouble, 0, c.siPersistable|c.siAnimatable, "", "", 0, None, None, -1, 1))
outputPorts = [ (out, "out") ]
inputPorts = []
op = createJSOpFromFile("gear_pathdriver", os.path.join(JSOPPATH, "gear_pathdriver_op.js"), outputPorts, inputPorts, paramDefs)
op.Connect()
par.addExpression(op.Parameters("driver"), driver)
return op
def connect_standardWithIkRef(self):
self.parent.AddChild(self.root)
if self.settings["cornerARefArray"]:
ref_names = self.settings["cornerARefArray"].split(",")
for i, ref_name in enumerate(ref_names):
ref = self.rig.findChild(ref_name)
cns = aop.poseCns(self.cornerA, ref, True, True, True, False)
par.addExpression(
cns.Parameters("active"),
self.pCornerARef.FullName + " == " + str(i + 1))
if self.settings["cornerBRefArray"]:
ref_names = self.settings["cornerBRefArray"].split(",")
for i, ref_name in enumerate(ref_names):
ref = self.rig.findChild(ref_name)
cns = aop.poseCns(self.cornerB, ref, True, True, True, False)
par.addExpression(
cns.Parameters("active"),
self.pCornerBRef.FullName + " == " + str(i + 1))
def addOperators(self):
for i, chain in enumerate(self.chain):
op = aop.sn_xfspring_op(chain.eff, 2)
par.addExpression(op.Parameters("speed"), self.pSpeed.FullName)
par.addExpression(op.Parameters("damping"), self.pDamping.FullName + "* .1")
if self.settings["multi_blend"]:
par.addExpression(op.Parameters("scale"), self.pMainBlend.FullName+" * "+self.pBlend[i].FullName)
else:
par.addExpression(op.Parameters("scale"), self.pMainBlend.FullName)
chain.root.Kinematics.AddConstraint("Orientation", self.fk_ctl[i], False)
self.ref[i].Kinematics.AddConstraint("Orientation", chain.bones[0])
def addLocMulti(self, name, parent):
if "#" not in name:
gear.log("You need to put a '#' in the name of multiple location.", gear.sev_error)
return False
locs = []
i = 0
while True:
localName = string.replaceSharpWithPadding(name, i)
if localName not in self.tra.keys():
break
loc = pri.addNull(parent, self.getName(localName), self.tra[localName])
pri.setNullDisplay(loc, 1, .5, 2, 0, 0, 0, .5, .5, .5, GUIDE_LOC_COLOR)
par.addExpression(loc.size, self.root.size.FullName+" * .5")
locs.append(loc)
parent = loc
i += 1
return locs
def addOperators(self):
for i, chain in enumerate(self.chain):
op = aop.sn_xfspring_op(chain.eff, 2)
par.addExpression(op.Parameters("speed"), self.pSpeed.FullName)
par.addExpression(op.Parameters("damping"),
self.pDamping.FullName + "* .1")
if self.settings["multi_blend"]:
par.addExpression(
op.Parameters("scale"),
self.pMainBlend.FullName + " * " + self.pBlend[i].FullName)
else:
par.addExpression(op.Parameters("scale"),
self.pMainBlend.FullName)
chain.root.Kinematics.AddConstraint("Orientation", self.fk_ctl[i],
False)
self.ref[i].Kinematics.AddConstraint("Orientation", chain.bones[0])
xsi.SetNeutralPose(self.ref[0])
def finalize(self):
# Properties --------------------------------------
self.plog.log("Filling layout and logic")
self.ui.fillLayoutAndLogic()
# Groups ------------------------------------------
self.plog.log("Creating groups")
# Retrieve group content from components
for name in self.componentsIndex:
component = self.components[name]
for name, objects in component.groups.items():
self.addToGroup(objects, name)
# Creating all groups
for name, objects in self.groups.items():
collection = XSIFactory.CreateObject("XSI.Collection")
collection.AddItems(objects)
self.groups[name] = self.model.AddGroup(collection, name + "_grp")
# Hidden
if self.options["setHidden"]:
self.groups["hidden"].Parameters("viewvis").Value = 0
self.groups["hidden"].Parameters("rendvis").Value = 0
# Unselectable
if self.options["setUnselectable"]:
self.groups["unselectable"].Parameters("selectability").Value = 0
# Deformers
if self.options["setDeformers"]:
self.groups["deformers"].Parameters("viewvis").Value = 0
self.groups["deformers"].Parameters("rendvis").Value = 0
# Geometries
if self.options["setGeometries"]:
self.groups["geometries"].Parameters("selectability").Value = 0
prop = self.groups["geometries"].AddProperty("GeomApprox")
par.addExpression(prop.Parameters("gapproxmosl"), self.pOGLLevel)
# Skin --------------------------------------------
if self.options["addGeometry"]:
self.plog.log("Applying skin")
# Import geometry
if self.options["geo_path"] and os.path.exists(
self.options["geo_path"]):
geo_model = xsi.ImportModel(self.options["geo_path"],
xsi.ActiveSceneRoot, False,
None)(1)
geo_objects = geo_model.FindChildren()
self.model.AddChild(geo_model.children)
for group in geo_model.Groups:
target_group = pri.createOrReturnGroup(
self.model, group.Name)
target_group.AddMember(group.Members)
xsi.DeleteObj(geo_model)
# Apply skin
if self.options["skin_path"] and os.path.exists(
self.options["skin_path"]):
xml_objs = io.getObjectDefinitions(
self.options["skin_path"], geo_objects, False)
for obj in geo_objects:
if obj.Name not in xml_objs.keys():
continue
io.importSkin(xml_objs[obj.Name], obj)
# Symmetry Mapping Template -----------------------
if self.options["mode"] == 1:
env.createSymmetryMappingTemplate(self.groups["deformers"].Members)
for geo in self.groups["geometries"].Members:
if geo.Type == "polymsh":
xsi.CreateSymmetryMap("SymmetryMap", geo, "Symmetry Map")
# Mirror Animation Template -----------------------
if self.options["mode"] == 0:
cnx_prop = ani.createMirrorCnxTemplate(self.model)
for count, compName in enumerate(self.componentsIndex):
component = self.components[compName]
inversed_params = component.inv_params.GetAsText().split(",")
for ctl in component.controlers:
ani.addMirroringRule(ctl, cnx_prop, inversed_params, True)
# Reset Pose --------------------------------------
self.plog.log("Creating rest pose")
controlers = XSIFactory.CreateObject("XSI.Collection")
for group in self.model.Groups:
if group.Name.startswith("controlers"):
controlers.AddItems(group.Members)
keyableParams = controlers.FindObjectsByMarkingAndCapabilities(
None, c.siKeyable)
xsi.StoreAction(self.model, keyableParams, 1, "reset", False)
# Isolate and popup -------------------------------
if self.options["isolateResult"]:
xsi.SelectObj(self.model, "BRANCH")
xsi.IsolateSelected(False, -1)
xsi.DeselectAll()
if self.options["popUpControls"]:
xsi.InspectObj(self.ui.anim_prop)
def addOperators(self):
# Visibilities -------------------------------------
for ctl in self.bk_ctl:
par.addExpression(
ctl.Properties("Visibility").Parameters("viewvis"),
self.pShowBackward.FullName + " * " + self.pBlend.FullName)
for ctl in self.fk_ctl:
par.addExpression(
ctl.Properties("Visibility").Parameters("viewvis"),
self.pShowForward.FullName)
if self.settings["roll"] == 0: # Using the controler
par.addExpression(
self.roll_ctl.Properties("Visibility").Parameters("viewvis"),
self.pBlend.FullName)
par.addExpression(
self.tip_ctl.Properties("Visibility").Parameters("viewvis"),
self.pBlend.FullName)
par.addExpression(
self.heel_ctl.Properties("Visibility").Parameters("viewvis"),
self.pBlend.FullName)
# Roll / Bank --------------------------------------
if self.settings["roll"] == 0: # Using the controler
self.pRoll = self.roll_ctl.Kinematics.Local.Parameters("rotz")
self.pBank = self.roll_ctl.Kinematics.Local.Parameters("rotx")
par.addExpression(
self.heel_loc.Parameters("rotz"),
"cond(%s>0, %s, 0)" % (self.pRoll.FullName, self.pRoll.FullName))
par.addExpression(self.heel_loc.Parameters("rotx"),
self.pBank.FullName)
# Bank pivot compensation
self.heel_loc.Kinematics.Local.pivotcompactive.Value = False
outside = vec.getDistanceToAxe(self.guide.pos["outpivot"],
self.guide.pos["heel"],
self.guide.apos[-4])
inside = vec.getDistanceToAxe(self.guide.pos["inpivot"],
self.guide.pos["heel"],
self.guide.apos[-4])
if self.negate:
par.addExpression(
self.heel_loc.Parameters("pposz"),
"cond(%s>0, %s, %s)" % (self.pBank.FullName, -inside, outside))
else:
par.addExpression(
self.heel_loc.Parameters("pposz"),
"cond(%s>0, %s, %s)" % (self.pBank.FullName, outside, -inside))
# Reverse Controler offset -------------------------
angle = "0"
for i, ctl in enumerate(reversed(self.bk_ctl)):
if i < len(self.pStartAngle):
pStartAngle = self.pStartAngle[i]
par.addExpression(
ctl.Kinematics.Local.Parameters("pcrotz"),
"MIN(0,MAX(" + self.pRoll.FullName + " + (" + angle +
"), -" + pStartAngle.FullName + "))")
angle += " + " + pStartAngle.FullName
else:
par.addExpression(
ctl.Kinematics.Local.Parameters("pcrotz"),
"MIN(0," + self.pRoll.FullName + " + (" + angle + "))")
# Reverse compensation -----------------------------
for i, ctl in enumerate(self.fk_ctl):
bk_ctl = self.bk_ctl[-i - 1]
for s in "xyz":
par.addExpression(
ctl.Kinematics.Local.Parameters("pcrot" + s), "- (" +
bk_ctl.Kinematics.Local.Parameters("rot" + s).FullName +
" + " +
bk_ctl.Kinematics.Local.Parameters("pcrot" + s).FullName +
") * " + self.pBlend.FullName)
aop.sn_inverseRotorder_op(ctl, bk_ctl)
# Global Scale
for s in "xyz":
par.addExpression(
self.fk_ref.Kinematics.Global.Parameters("scl%s" % s),
self.root.Kinematics.Global.Parameters("scl%s" % s))
def addOperators(self):
# Controlers Limits -------------------------------
# pos_0 = self.crv[0].ActivePrimitive.Geometry.Curves(0).EvaluatePosition(0)[0]
# pos_1 = self.crv[0].ActivePrimitive.Geometry.Curves(0).EvaluatePosition(4)[0]
# pos_0 = XSIMath.MapObjectPositionToWorldSpace(self.crv[0].Kinematics.Global.Transform, pos_0)
# pos_1 = XSIMath.MapObjectPositionToWorldSpace(self.crv[0].Kinematics.Global.Transform, pos_1)
# lim_min = pos_0.Y - self.ctl[0].Kinematics.Global.Transform.Translation.Y
# lim_max = pos_1.Y - self.ctl[0].Kinematics.Global.Transform.Translation.Y
for ctl, crv, upv, centers, off, perc in zip(self.ctl, self.crv,
self.upv, self.ctr,
self.off,
self.percentages):
# crv_geo = crv.ActivePrimitive.Geometry
# crv_0 = crv_geo.Curves(0)
# crv_tra = crv.Kinematics.Global.Transform
# Set Limits ----------------------------------
par.setLimit(ctl, ["posy"], -1, 1)
# ctl.Kinematics.Local.Parameters("posyminactive").Value = True
# ctl.Kinematics.Local.Parameters("posymaxactive").Value = True
# ctl.Kinematics.Local.Parameters("posyminlimit").Value = lim_min
# ctl.Kinematics.Local.Parameters("posymaxlimit").Value = lim_max
# Path Constraint -----------------------------
constraints = []
for ctr in centers:
cns = aop.pathCns(ctr, crv, 0, perc, True, upv, False)
ope.setConstraintTangency(cns, [0, 1, 0], [0, 0, -1])
constraints.append(cns)
pos_min = "max(0,-%s)*%s" % (
ctl.Kinematics.Local.Parameters("posy").FullName, perc)
pos_max = "max(0,%s)*%s" % (
ctl.Kinematics.Local.Parameters("posy").FullName, 100 - perc)
par.addExpression(constraints[1].Parameters("perc"),
"%s - %s + %s" % (perc, pos_min, pos_max))
cns_perc = constraints[1].Parameters("perc").FullName
par.addExpression(constraints[0].Parameters("perc"),
cns_perc + " * .5 ")
par.addExpression(constraints[2].Parameters("perc"),
cns_perc + " + (100 - " + cns_perc + " ) * .5 ")
# Connect Offset to Controler
for s in "xz":
par.addExpression(
off.Kinematics.Local.Parameters("pos%s" % s),
ctl.Kinematics.Local.Parameters("pos%s" % s).FullName +
" * " + str(self.scale))
for s in "yz":
par.addExpression(
off.Kinematics.Local.Parameters("rot%s" % s),
ctl.Kinematics.Local.Parameters("rot%s" % s).FullName)
for s in "x":
par.addExpression(
off.Kinematics.Local.Parameters("scl%s" % s),
ctl.Kinematics.Local.Parameters("scl%s" % s).FullName)
# Constrained Curve -------------------------------
for i in range(self.crv_count):
if i == self.inter_crv:
centers = self.off
else:
centers = [ctr[i] for ctr in self.ctr]
for ctr, pnts in zip(centers, [[0, 1], [2], [3, 4]]):
aop.clsCtrOp(self.cns_crv[i], ctr, pnts)
# Shadows -----------------------------------------
constraints = []
for i in range(self.shd_count):
u = i / 4.0
for j in range(self.crv_count):
if j == self.inter_crv:
cns = aop.pathCns(self.loc[j * self.shd_count + i],
self.cns_crv[j], 1, u, True, None, False)
constraints.append(cns)
else:
cns = aop.pathCns(self.loc[j * self.shd_count + i],
self.cns_crv[j], 1, u, True, self.upv[0],
False)
# Connect Roll
aop.gear_pointAtObjectAxis(constraints[0], self.ctl[0], [0, 0, 1])
aop.spinePointAtOp(constraints[1], self.ctl[0], self.ctl[1], .5)
aop.gear_pointAtObjectAxis(constraints[2], self.ctl[1], [0, 0, 1])
aop.spinePointAtOp(constraints[3], self.ctl[1], self.ctl[2], .5)
aop.gear_pointAtObjectAxis(constraints[4], self.ctl[2], [0, 0, 1])
def addOperators(self):
# Visibilities -------------------------------------
for ctl in self.bk_ctl:
par.addExpression(ctl.Properties("Visibility").Parameters("viewvis"), self.pShowBackward.FullName+" * "+self.pBlend.FullName)
for ctl in self.fk_ctl:
par.addExpression(ctl.Properties("Visibility").Parameters("viewvis"), self.pShowForward.FullName)
if self.settings["roll"] == 0: # Using the controler
par.addExpression(self.roll_ctl.Properties("Visibility").Parameters("viewvis"), self.pBlend.FullName)
par.addExpression(self.tip_ctl.Properties("Visibility").Parameters("viewvis"), self.pBlend.FullName)
par.addExpression(self.heel_ctl.Properties("Visibility").Parameters("viewvis"), self.pBlend.FullName)
# Roll / Bank --------------------------------------
if self.settings["roll"] == 0: # Using the controler
self.pRoll = self.roll_ctl.Kinematics.Local.Parameters("rotz")
self.pBank = self.roll_ctl.Kinematics.Local.Parameters("rotx")
par.addExpression(self.heel_loc.Parameters("rotz"), "cond(%s>0, %s, 0)"%(self.pRoll.FullName, self.pRoll.FullName))
par.addExpression(self.heel_loc.Parameters("rotx"), self.pBank.FullName)
# Bank pivot compensation
self.heel_loc.Kinematics.Local.pivotcompactive.Value = False
outside = vec.getDistanceToAxe(self.guide.pos["outpivot"], self.guide.pos["heel"], self.guide.apos[-4])
inside = vec.getDistanceToAxe(self.guide.pos["inpivot"], self.guide.pos["heel"], self.guide.apos[-4])
if self.negate:
par.addExpression(self.heel_loc.Parameters("pposz"), "cond(%s>0, %s, %s)"%(self.pBank.FullName, -inside, outside))
else:
par.addExpression(self.heel_loc.Parameters("pposz"), "cond(%s>0, %s, %s)"%(self.pBank.FullName, outside, -inside))
# Reverse Controler offset -------------------------
angle = "0"
for i, ctl in enumerate(reversed(self.bk_ctl)):
if i < len(self.pStartAngle):
pStartAngle = self.pStartAngle[i]
par.addExpression(ctl.Kinematics.Local.Parameters("pcrotz"), "MIN(0,MAX("+self.pRoll.FullName+" + ("+angle+"), -"+pStartAngle.FullName+"))")
angle += " + " + pStartAngle.FullName
else:
par.addExpression(ctl.Kinematics.Local.Parameters("pcrotz"), "MIN(0,"+self.pRoll.FullName+" + ("+angle+"))")
# Reverse compensation -----------------------------
for i, ctl in enumerate(self.fk_ctl):
bk_ctl = self.bk_ctl[-i-1]
for s in "xyz":
par.addExpression(ctl.Kinematics.Local.Parameters("pcrot"+s),
"- ("+bk_ctl.Kinematics.Local.Parameters("rot"+s).FullName+" + "+bk_ctl.Kinematics.Local.Parameters("pcrot"+s).FullName+") * "+self.pBlend.FullName)
aop.sn_inverseRotorder_op(ctl, bk_ctl)
def addOperators(self):
#Jaw Operators
par.addExpression(self.jawRotCenter.Kinematics.Local.Parameters("rotz"), self.jawControl.Kinematics.Local.Parameters("rotz").FullName )
par.addExpression(self.jawTrans.Kinematics.Local.Parameters("posz"), self.jawControl.Kinematics.Local.Parameters("posz").FullName + " *" + self.mult_jaw_trans_Z.FullName )
par.addExpression(self.jawRotBase.Kinematics.Local.Parameters("rotx"), "(" + self.jawControl.Kinematics.Local.Parameters("posy").FullName + " *" + self.mult_jaw_rot_X.FullName + ") * -1")
par.addExpression(self.jawRotBase.Kinematics.Local.Parameters("roty"), self.jawControl.Kinematics.Local.Parameters("posx").FullName + " *" + self.mult_jaw_rot_Y.FullName )
par.addExpression(self.jawRotBase.Kinematics.Local.Parameters("rotz"), self.jawControl.Kinematics.Local.Parameters("posx").FullName + " *" + self.mult_jaw_rot_Z.FullName )
oAxis = [ "posx", "posy", "posz"]
par.setLimit( self.jawControl, oAxis, -1, 1)
#teeth
self.intePose01 = aop.sn_interpose_op(self.teeth_lvl, self.teethHead, self.teethJaw )
par.addExpression(self.intePose01.Parameters("blend_pos"), "MIN( MAX((" + self.jawControl.Kinematics.Local.Parameters("posy").FullName + "*" + self.upLips_jaw_head_multi.FullName + ")+" + self.sticky_Lips.FullName + "+" + self.upLips_jaw_head.FullName + "+ abs(" + self.jawControl.Kinematics.Local.Parameters("posx").FullName + " ) , 0 + " + self.upLips_jaw_head.FullName + " + " + self.sticky_Lips.FullName + "), 1 )" )
par.addExpression(self.intePose01.Parameters("blend_dir"), "MIN( MAX((" + self.jawControl.Kinematics.Local.Parameters("posy").FullName + "*" + self.upLips_jaw_head_multi.FullName + ")+" + self.sticky_Lips.FullName + "+" + self.upLips_jaw_head.FullName + "+ abs(" + self.jawControl.Kinematics.Local.Parameters("posx").FullName + " ), abs(" + self.jawControl.Kinematics.Local.Parameters("posx").FullName + ")+" + self.upLips_jaw_head.FullName + "+ " + self.sticky_Lips.FullName +" ), 1 )" )
par.addExpression(self.intePose01.Parameters("blend_upv"), "MIN( MAX((" + self.jawControl.Kinematics.Local.Parameters("posy").FullName + "*" + self.upLips_jaw_head_multi.FullName + ")+" + self.sticky_Lips.FullName + "+" + self.upLips_jaw_head.FullName + "+ abs(" + self.jawControl.Kinematics.Local.Parameters("posx").FullName + " ) , 0 + " + self.upLips_jaw_head.FullName + " + " + self.sticky_Lips.FullName + "), 1 )" )
#lips
self.intePose02 = aop.sn_interpose_op(self.upLips_lvl, self.upLipsHead, self.upLipsJaw )
par.addExpression(self.intePose02.Parameters("blend_pos"), "MIN( MAX((" + self.jawControl.Kinematics.Local.Parameters("posy").FullName + "*" + self.upLips_jaw_head_multi.FullName + ")+" + self.sticky_Lips.FullName + "+" + self.upLips_jaw_head.FullName + "+ abs(" + self.jawControl.Kinematics.Local.Parameters("posx").FullName + " ) , 0 + " + self.upLips_jaw_head.FullName + " + " + self.sticky_Lips.FullName + "), 1 )" )
par.addExpression(self.intePose02.Parameters("blend_dir"), "MIN( MAX((" + self.jawControl.Kinematics.Local.Parameters("posy").FullName + "*" + self.upLips_jaw_head_multi.FullName + ")+" + self.sticky_Lips.FullName + "+" + self.upLips_jaw_head.FullName + "+ abs(" + self.jawControl.Kinematics.Local.Parameters("posx").FullName + " ), abs(" + self.jawControl.Kinematics.Local.Parameters("posx").FullName + ")+" + self.upLips_jaw_head.FullName + "+ " + self.sticky_Lips.FullName +" ), 1 )" )
par.addExpression(self.intePose02.Parameters("blend_upv"), "MIN( MAX((" + self.jawControl.Kinematics.Local.Parameters("posy").FullName + "*" + self.upLips_jaw_head_multi.FullName + ")+" + self.sticky_Lips.FullName + "+" + self.upLips_jaw_head.FullName + "+ abs(" + self.jawControl.Kinematics.Local.Parameters("posx").FullName + " ) , 0 + " + self.upLips_jaw_head.FullName + " + " + self.sticky_Lips.FullName + "), 1 )" )
#Lips profile contrains
self.cnsLower01 = aop.poseCns(self.uLip01_lvl, self.uLip01Lower_ref, True)
self.cnsUpper01 = aop.poseCns(self.uLip01_lvl, self.uLip01Upper_ref, True)
par.addExpression(self.cnsUpper01.Parameters("blendweight"), self.lip_01.FullName )
self.cnsLower01.Parameters("cnsscl").Value = False
self.cnsUpper01.Parameters("cnsscl").Value = False
self.cnsLower02 = aop.poseCns(self.uLip02_lvl, self.uLip02Lower_ref, True)
self.cnsUpper02 = aop.poseCns(self.uLip02_lvl, self.uLip02Upper_ref, True)
par.addExpression(self.cnsUpper02.Parameters("blendweight"), self.lip_02.FullName )
self.cnsLower02.Parameters("cnsscl").Value = False
self.cnsUpper02.Parameters("cnsscl").Value = False
self.cnsLower03 = aop.poseCns(self.uLip03_lvl, self.uLip03Lower_ref, True)
self.cnsUpper03 = aop.poseCns(self.uLip03_lvl, self.uLip03Upper_ref, True)
par.addExpression(self.cnsUpper03.Parameters("blendweight"), self.lip_03.FullName )
self.cnsLower03.Parameters("cnsscl").Value = False
self.cnsUpper03.Parameters("cnsscl").Value = False
self.cnsLower04 = aop.poseCns(self.cLip04_lvl, self.lLip04Lower_ref, True)
self.cnsUpper04 = aop.poseCns(self.cLip04_lvl, self.lLip04Upper_ref, True)
par.addExpression(self.cnsUpper04.Parameters("blendweight"), self.lip_04.FullName )
self.cnsLower04.Parameters("cnsscl").Value = False
self.cnsUpper04.Parameters("cnsscl").Value = False
self.cnsLower05 = aop.poseCns(self.lLip05_lvl, self.lLip05Lower_ref, True)
self.cnsUpper05 = aop.poseCns(self.lLip05_lvl, self.lLip05Upper_ref, True)
par.addExpression(self.cnsUpper05.Parameters("blendweight"), self.lip_05.FullName )
self.cnsLower05.Parameters("cnsscl").Value = False
self.cnsUpper05.Parameters("cnsscl").Value = False
self.cnsLower06 = aop.poseCns(self.lLip06_lvl, self.lLip06Lower_ref, True)
self.cnsUpper06 = aop.poseCns(self.lLip06_lvl, self.lLip06Upper_ref, True)
par.addExpression(self.cnsUpper06.Parameters("blendweight"), self.lip_06.FullName )
self.cnsLower06.Parameters("cnsscl").Value = False
self.cnsUpper06.Parameters("cnsscl").Value = False
self.cnsLower07 = aop.poseCns(self.lLip07_lvl, self.lLip07Lower_ref, True)
self.cnsUpper07 = aop.poseCns(self.lLip07_lvl, self.lLip07Upper_ref, True)
par.addExpression(self.cnsUpper07.Parameters("blendweight"), self.lip_07.FullName )
self.cnsLower07.Parameters("cnsscl").Value = False
self.cnsUpper07.Parameters("cnsscl").Value = False
self.cnsLower08 = aop.poseCns(self.lLip08_lvl, self.lLip08Lower_ref, True)
self.cnsUpper08= aop.poseCns(self.lLip08_lvl, self.lLip08Upper_ref, True)
par.addExpression(self.cnsUpper08.Parameters("blendweight"), self.lip_08.FullName )
self.cnsLower08.Parameters("cnsscl").Value = False
self.cnsUpper08.Parameters("cnsscl").Value = False
self.cnsLower09 = aop.poseCns(self.lLip09_lvl, self.lLip09Lower_ref, True)
self.cnsUpper09 = aop.poseCns(self.lLip09_lvl, self.lLip09Upper_ref, True)
par.addExpression(self.cnsUpper09.Parameters("blendweight"), self.lip_09.FullName )
self.cnsLower09.Parameters("cnsscl").Value = False
self.cnsUpper09.Parameters("cnsscl").Value = False
self.cnsLower10 = aop.poseCns(self.cLip10_lvl, self.lLip10Lower_ref, True)
self.cnsUpper10 = aop.poseCns(self.cLip10_lvl, self.lLip10Upper_ref, True)
par.addExpression(self.cnsUpper10.Parameters("blendweight"), self.lip_10.FullName )
self.cnsLower10.Parameters("cnsscl").Value = False
self.cnsUpper10.Parameters("cnsscl").Value = False
self.cnsLower11 = aop.poseCns(self.uLip11_lvl, self.uLip11Lower_ref, True)
self.cnsUpper11 = aop.poseCns(self.uLip11_lvl, self.uLip11Upper_ref, True)
par.addExpression(self.cnsUpper11.Parameters("blendweight"), self.lip_11.FullName )
self.cnsLower11.Parameters("cnsscl").Value = False
self.cnsUpper11.Parameters("cnsscl").Value = False
self.cnsLower12 = aop.poseCns(self.uLip12_lvl, self.uLip12Lower_ref, True)
self.cnsUpper12 = aop.poseCns(self.uLip12_lvl, self.uLip12Upper_ref, True)
par.addExpression(self.cnsUpper12.Parameters("blendweight"), self.lip_12.FullName )
self.cnsLower12.Parameters("cnsscl").Value = False
self.cnsUpper12.Parameters("cnsscl").Value = False
#mouth compression
par.addExpression(self.upLips_loc.Kinematics.Local.Parameters("sclx"), "1-((" + \
self.jawControl.Kinematics.Local.Parameters("posy").FullName + \
"*-1)*"+ self.lips_compression.FullName + ")")
par.addExpression(self.lowLipsJaw.Kinematics.Local.Parameters("sclx"), "1-((" + \
self.jawControl.Kinematics.Local.Parameters("posy").FullName +"*-1)*"+ \
self.lips_compression.FullName+ ")")
par.addExpression(self.upLips_loc.Kinematics.Local.Parameters("posz"), "((MAX("+ \
self.jawControl.Kinematics.Local.Parameters("posy").FullName + "*-1,0))*" + \
self.lips_upperTranslation.FullName + ")+" + self.lips_upperOffset.FullName )
par.addExpression(self.lowLipsJaw.Kinematics.Local.Parameters("posz"), "((MAX("+ \
self.jawControl.Kinematics.Local.Parameters("posy").FullName + "*-1,0))*" + \
self.lips_lowerTranslation.FullName + ") +" + self.lips_lowerOffset.FullName )
# # ICE Shapes Controls
# self.intePose03 = aop.sn_interpose_op(self.mouthICE_lvl, self.upLipsHead, self.upLipsJaw )
def addOperators(self):
# Controlers Limits -------------------------------
# pos_0 = self.crv[0].ActivePrimitive.Geometry.Curves(0).EvaluatePosition(0)[0]
# pos_1 = self.crv[0].ActivePrimitive.Geometry.Curves(0).EvaluatePosition(4)[0]
# pos_0 = XSIMath.MapObjectPositionToWorldSpace(self.crv[0].Kinematics.Global.Transform, pos_0)
# pos_1 = XSIMath.MapObjectPositionToWorldSpace(self.crv[0].Kinematics.Global.Transform, pos_1)
# lim_min = pos_0.Y - self.ctl[0].Kinematics.Global.Transform.Translation.Y
# lim_max = pos_1.Y - self.ctl[0].Kinematics.Global.Transform.Translation.Y
for ctl, crv, upv, centers, off, perc in zip(self.ctl, self.crv, self.upv, self.ctr, self.off, self.percentages):
# crv_geo = crv.ActivePrimitive.Geometry
# crv_0 = crv_geo.Curves(0)
# crv_tra = crv.Kinematics.Global.Transform
# Set Limits ----------------------------------
par.setLimit(ctl, ["posy"], -1, 1)
# ctl.Kinematics.Local.Parameters("posyminactive").Value = True
# ctl.Kinematics.Local.Parameters("posymaxactive").Value = True
# ctl.Kinematics.Local.Parameters("posyminlimit").Value = lim_min
# ctl.Kinematics.Local.Parameters("posymaxlimit").Value = lim_max
# Path Constraint -----------------------------
constraints = []
for ctr in centers:
cns = aop.pathCns(ctr, crv, 0, perc, True, upv, False)
ope.setConstraintTangency(cns, [0,1,0], [0,0,-1])
constraints.append(cns)
pos_min = "max(0,-%s)*%s"%(ctl.Kinematics.Local.Parameters("posy").FullName,perc)
pos_max = "max(0,%s)*%s"%(ctl.Kinematics.Local.Parameters("posy").FullName,100-perc)
par.addExpression(constraints[1].Parameters("perc"), "%s - %s + %s"%(perc,pos_min,pos_max))
cns_perc = constraints[1].Parameters("perc").FullName
par.addExpression(constraints[0].Parameters("perc"), cns_perc + " * .5 ")
par.addExpression(constraints[2].Parameters("perc"), cns_perc + " + (100 - "+cns_perc+" ) * .5 ")
# Connect Offset to Controler
for s in "xz":
par.addExpression(off.Kinematics.Local.Parameters("pos%s"%s), ctl.Kinematics.Local.Parameters("pos%s"%s).FullName+" * "+str(self.scale))
for s in "yz":
par.addExpression(off.Kinematics.Local.Parameters("rot%s"%s), ctl.Kinematics.Local.Parameters("rot%s"%s).FullName)
for s in "x":
par.addExpression(off.Kinematics.Local.Parameters("scl%s"%s), ctl.Kinematics.Local.Parameters("scl%s"%s).FullName)
# Constrained Curve -------------------------------
for i in range(self.crv_count):
if i == self.inter_crv:
centers = self.off
else:
centers = [ctr[i] for ctr in self.ctr]
for ctr, pnts in zip(centers, [[0,1],[2],[3,4]]):
aop.clsCtrOp(self.cns_crv[i], ctr, pnts)
# Shadows -----------------------------------------
constraints = []
for i in range(self.shd_count):
u = i/4.0
for j in range(self.crv_count):
if j == self.inter_crv:
cns = aop.pathCns(self.loc[j*self.shd_count+i], self.cns_crv[j], 1, u, True, None, False)
constraints.append(cns)
else:
cns = aop.pathCns(self.loc[j*self.shd_count+i], self.cns_crv[j], 1, u, True, self.upv[0], False)
# Connect Roll
aop.gear_pointAtObjectAxis(constraints[0], self.ctl[0], [0,0,1])
aop.spinePointAtOp(constraints[1], self.ctl[0], self.ctl[1], .5)
aop.gear_pointAtObjectAxis(constraints[2], self.ctl[1], [0,0,1])
aop.spinePointAtOp(constraints[3], self.ctl[1], self.ctl[2], .5)
aop.gear_pointAtObjectAxis(constraints[4], self.ctl[2], [0,0,1])
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 addOperators(self):
#return
i = 0
for x in self.oDirDrivenList:
oTmpOp = aop.dirCns(x, self.oDirDriverList[i], self.upVec, False,
"xz")
xsi.ParentObj(x, self.oPointerLvlList[i])
i += 1
i = 0
for oBlock in self.blockList:
# Corners
par.addExpression(self.oCornersList[i].Kinematics.Local.Parameters("posy"), \
"(cond(" + self.cornerA.Kinematics.Local.Parameters("posy").FullName + " > 0," + \
self.cornerA.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][3].FullName + "," + \
self.cornerA.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][4].FullName + ") +" + \
"cond(" + self.cornerB.Kinematics.Local.Parameters("posy").FullName + " > 0," + \
self.cornerB.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][11].FullName + "," + \
self.cornerB.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][12].FullName + "))" + \
"+ (cond(" + self.cornerA.Kinematics.Local.Parameters("posx").FullName + " > 0," + \
self.cornerA.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][7].FullName + "," + \
self.cornerA.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][8].FullName + ") +" + \
"cond(" + self.cornerB.Kinematics.Local.Parameters("posx").FullName + " > 0," + \
self.cornerB.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][15].FullName + "," + \
self.cornerB.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][16].FullName + "))")
par.addExpression(self.oCornersList[i].Kinematics.Local.Parameters("posx"), \
"cond(" + self.cornerA.Kinematics.Local.Parameters("posy").FullName + " > 0," + \
self.cornerA.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][1].FullName + "," + \
self.cornerA.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][2].FullName + ") +" + \
"cond(" + self.cornerB.Kinematics.Local.Parameters("posy").FullName + " > 0," + \
self.cornerB.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][9].FullName + "," + \
self.cornerB.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][10].FullName + ")" + \
"+ (cond(" + self.cornerA.Kinematics.Local.Parameters("posx").FullName + " > 0," + \
self.cornerA.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][5].FullName + "," + \
self.cornerA.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][6].FullName + ") +" + \
"cond(" + self.cornerB.Kinematics.Local.Parameters("posx").FullName + " > 0," + \
self.cornerB.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][13].FullName + "," + \
self.cornerB.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][14].FullName + "))")
#Control up down
par.addExpression(self.oUpDownList[i].Kinematics.Local.Parameters("posy"), \
"cond(" + self.control.Kinematics.Local.Parameters("posy").FullName + " > 0," + \
self.control.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][19].FullName + "," + \
self.control.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][20].FullName + ")")
par.addExpression(self.oUpDownList[i].Kinematics.Local.Parameters("posx"), \
"cond(" + self.control.Kinematics.Local.Parameters("posy").FullName + " > 0," + \
self.control.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][17].FullName + "," + \
self.control.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][18].FullName + ")")
#Control sides
par.addExpression(self.oSidesList[i].Kinematics.Local.Parameters("posy"), \
"cond(" + self.control.Kinematics.Local.Parameters("posx").FullName + " > 0," + \
self.control.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][23].FullName + "," + \
self.control.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][24].FullName + ")")
par.addExpression(self.oSidesList[i].Kinematics.Local.Parameters("posx"), \
"cond(" + self.control.Kinematics.Local.Parameters("posx").FullName + " > 0," + \
self.control.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][21].FullName + "," + \
self.control.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][22].FullName + ")")
i += 1
def addOperators(self):
# Visibilities -------------------------------------
par.addExpression(self.fk0_ctl.Properties("visibility").Parameters("viewvis"), "1 - "+self.pBlend.FullName)
par.addExpression(self.fk1_ctl.Properties("visibility").Parameters("viewvis"), "1 - "+self.pBlend.FullName)
par.addExpression(self.fk2_ctl.Properties("visibility").Parameters("viewvis"), "1 - "+self.pBlend.FullName)
par.addExpression(self.upv_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName)
par.addExpression(self.ikcns_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName +" * "+ self.pIkCns.FullName)
par.addExpression(self.ik_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName)
# Leash --------------------------------------------
aop.clsCtrOp(self.upv_ctl, self.mid_ctl, [0])
# IK Solver-----------------------------------------
out = [self.bone0, self.bone1, None, self.eff_loc]
op = aop.sn_ikfk2bone_op(out, self.root, self.ik_ctl, self.upv_ctl, self.fk0_ctl, self.fk1_ctl, self.fk2_ctl, self.length0, self.length1, self.negate)
par.addExpression(op.Parameters("blend"), self.pBlend.FullName)
par.addExpression(op.Parameters("roll"), self.pIkRoll.FullName)
par.addExpression(op.Parameters("scaleA"), self.pScale.FullName)
par.addExpression(op.Parameters("scaleB"), self.pScale.FullName)
par.addExpression(op.Parameters("maxstretch"), self.pMaxStretch.FullName)
par.addExpression(op.Parameters("softness"), self.pSoftness.FullName)
par.addExpression(op.Parameters("slide"), self.pSlide.FullName)
par.addExpression(op.Parameters("reverse"), self.pReverse.FullName)
# I'm not using the output of the solver to get the ctrn because it only has a +/-180 degree
# With this simple expression I have a much better result
# Also remove scaling from ctrn
for s in "xyz":
par.addExpression(self.ctrn_loc.Kinematics.Local.Parameters("rot"+s), self.bone1.Kinematics.Local.Parameters("rot"+s).FullName + " * .5")
par.addExpression(self.ctrn_loc.Kinematics.Global.Parameters("scl"+s), self.root.Kinematics.Global.Parameters("scl"+s).FullName)
# Membrane
par.addExpression(self.memb_loc.Kinematics.Local.Parameters("posy"), self.pStartPos.FullName+" + ("+self.pEndPos.FullName+" - "+self.pStartPos.FullName+") * ( 1 - ( ctr_dist("+self.root.Kinematics.Global.FullName+","+self.eff_loc.Kinematics.Global.FullName+") / "+self.pRestDist.FullName+"))")
# Twist references ---------------------------------
self.pRestDist.Value = vec.getDistance2(self.root, self.eff_loc)
par.addExpression(self.pDriver, "(ctr_dist(%s, %s) + ctr_dist(%s, %s)) / %s"
%(self.tws0_loc.Kinematics.Global.FullName, self.tws1_loc.Kinematics.Global.FullName,
self.tws1_loc.Kinematics.Global.FullName, self.tws2_loc.Kinematics.Global.FullName,
self.root.Kinematics.Global.Parameters("sclx").FullName))
self.tws0_loc.Kinematics.AddConstraint("Pose", self.root, True)
aop.dirCns(self.tws0_loc, self.mid_ctl, None, False, self.n_sign+"xy")
self.tws1_loc.Kinematics.AddConstraint("Position", self.mid_ctl)
self.tws1_loc.Kinematics.AddConstraint("Scaling", self.mid_ctl)
self.tws1_rot.Kinematics.AddConstraint("Orientation", self.mid_ctl)
par.addExpression(self.tws1_rot.Parameters("rotx"), 0)
par.addExpression(self.tws1_rot.Parameters("roty"), 0)
par.addExpression(self.tws1_rot.Parameters("rotz"), 0)
self.tws2_loc.Kinematics.AddConstraint("Position", self.eff_loc)
self.tws2_loc.Kinematics.AddConstraint("Scaling", self.eff_loc)
aop.poseCns(self.tws2_rot, self.eff_loc, False, False, True, False)
par.addExpression(self.tws2_rot.Parameters("rotx"), 0)
par.addExpression(self.tws2_rot.Parameters("roty"), 0)
par.addExpression(self.tws2_rot.Parameters("rotz"), 0)
par.setRotOrder(self.tws2_rot, "YZX")
self.tws0_rot.SclX = .001
par.addExpression(self.tws1_rot.SclX, self.pRoundness.FullName + " + .001")
self.tws2_rot.SclX = .001
# Divisions ----------------------------------------
# at 0 or 1 the division will follow exactly the rotation of the controler.. and we wont have this nice tangent + roll
for i, div_cns in enumerate(self.div_cns):
if i < (self.settings["div0"]+1):
perc = i*.5 / (self.settings["div0"]+1.0)
else:
perc = .5 + (i-self.settings["div0"]-1.0)*.5 / (self.settings["div1"]+1.0)
perc = max(.001, min(.999, perc))
# Roll
if self.negate:
op = aop.sn_rollsplinekine_op(div_cns, [self.tws2_rot, self.tws1_rot, self.tws0_rot], 1-perc)
else:
op = aop.sn_rollsplinekine_op(div_cns, [self.tws0_rot, self.tws1_rot, self.tws2_rot], perc)
# Squash n Stretch
op = aop.sn_squashstretch2_op(div_cns, self.root, self.pDriver.Value, "x")
par.addExpression(op.Parameters("blend"), self.pVolume.FullName)
par.addExpression(op.Parameters("driver"), self.pDriver.FullName)
if self.options["mode"] == 1: # wip
par.addExpression(op.Parameters("stretch"), self.pStretch[i])
par.addExpression(op.Parameters("squash"), self.pSquash[i])
else:
op.Parameters("stretch").Value = self.st_value[i]
op.Parameters("squash").Value = self.sq_value[i]
def addOperators(self):
# Visibilities -------------------------------------
par.addExpression(self.fk0_ctl.Properties("visibility").Parameters("viewvis"), "1 - "+self.pBlend.FullName)
par.addExpression(self.fk1_ctl.Properties("visibility").Parameters("viewvis"), "1 - "+self.pBlend.FullName)
par.addExpression(self.fk2_ctl.Properties("visibility").Parameters("viewvis"), "1 - "+self.pBlend.FullName)
par.addExpression(self.upv_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName)
par.addExpression(self.leash_crv.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName)
par.addExpression(self.ikcns_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName +" * "+ self.pIkCns.FullName)
par.addExpression(self.ik_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName)
# Twist --------------------------------------------
for i, div_loc in enumerate(self.div0_loc):
if i == 0:
cns = aop.gear_dualUpVDirCns(div_loc, self.chain.root, self.chain.bones[1])
# cns = aop.dirCns(div_loc, self.chain.bones[1], None, False, "xy")
# aop.gear_pointAtObjectAxis(cns, self.chain.root, [0,1,0])
elif i == self.settings["division0"]-1:
continue
else:
d = i/(self.settings["division0"]-1.0)
cns = aop.dirCns(div_loc, self.chain.bones[1], None, False, "xy")
op = aop.spinePointAtOp(cns, self.div0_loc[0], self.chain.bones[0], d)
for i, div_loc in enumerate(self.div_loc):
d = i/(self.settings["division1"]-1.0)
par.addExpression(div_loc.Parameters("rotx"), self.end_ref.Parameters("rotx").FullName+" * "+str(d))
# IK Solver-----------------------------------------
# cns
self.chain.eff.Kinematics.AddConstraint("Position", self.ik_ref, False)
aop.chainUpvOp(self.chain, self.upv_ctl)
for bone, fk_ctl, length, div in zip(self.chain.bones, [self.fk0_ctl, self.fk1_ctl], [self.length0, self.length1], self.div_loc):
# for bone, fk in zip(self.chain.bones, [self.fk0_ctl, self.fk1_ctl]):
# ik/fk orientation
cns = bone.Kinematics.AddConstraint("Orientation", fk_ctl, False)
par.addExpression(cns.Parameters("blendweight"), "1 - "+self.pBlend.FullName)
# stretch
fk_st = fk_ctl.Parameters("sclx").FullName + " * (1 - "+self.pBlend.FullName+")"
root_eff_dist = "ctr_dist(%s.kine.global, %s.kine.global)"%(self.root.FullName, self.ik_ctl.FullName)
ik_st = "cond("+root_eff_dist+" > "+str(self.chain.length)+", "+root_eff_dist+" / "+str(self.chain.length)+", 1) * "+self.pBlend.FullName
parent_scl = bone.Parent3DObject.Parameters("sclx").FullName
par.addExpression(bone.Parameters("sclx"), "("+fk_st+" + "+ik_st+")/"+parent_scl)
# par.addExpression(div.Parameters("sclx"), bone.Parameters("length").FullName+"/"+str(length))
# blend / roll
par.addExpression(self.chain.blend, self.pBlend)
par.addExpression(self.chain.roll, self.pIkRoll)
# ctr_loc
self.ctrn_loc.Kinematics.AddConstraint("Position", self.chain.bones[1], False)
for s in "xyz":
par.addExpression(self.ctrn_loc.Kinematics.Local.Parameters("rot"+s), self.chain.bones[1].Kinematics.Local.Parameters("rot" + s).FullName + " * .5")
# Stretch -----------------------------------------
# root_eff = "ctr_dist(%s.kine.global, %s.kine.global)"%(self.chain.root, self.ik_ref)
# st_value = "(%s/%s)"%(root_eff,self.chain.length)
# for bone in self.chain.bones:
# par.addExpression(bone.Parameters("length"),
# "cond(%s>%s,%s*%s,%s)*%s + %s*(1 - %s)"%(root_eff,
# self.chain.length,
# bone.Parameters("length").Value,
# st_value, bone.Parameters("length").Value,
# self.pBlend.FullName,
# bone.Parameters("length").Value,
# self.pBlend.FullName))
# Hook
self.end_ref.Kinematics.AddConstraint("Position", self.chain.eff)
self.end_ref.Kinematics.AddConstraint("Scaling", self.chain.eff)
aop.poseCns(self.end_ref, self.fk2_ctl, True, False, True, False)
cns = aop.poseCns(self.end_ref, self.ik_ref, True, False, True, False)
par.addExpression(cns.Parameters("blendweight"), self.pBlend.fullName)
par.addExpression(self.end_ref.Parameters("rotx"), 0)
par.addExpression(self.end_ref.Parameters("roty"), 0)
par.addExpression(self.end_ref.Parameters("rotz"), 0)
par.setRotOrder(self.end_ref, "YZX")
# Shape Reference ---------------------------------
# shoulder
aop.gear_rotationToPose(self.end_ref, self.chain.bones[1], self.ankle_outputs, "x", 0)
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 addOperators(self):
# Visibilities -------------------------------------
par.addExpression(
self.ik_ctl.Properties("visibility").Parameters("viewvis"),
self.pShowIk.FullName)
for fk_ctl in self.fk_ctl:
par.addExpression(
fk_ctl.Properties("visibility").Parameters("viewvis"),
self.pShowFk.FullName)
# Tangent position ---------------------------------
d = vec.getDistance(self.guide.pos["root"], self.guide.pos["neck"])
exp = self.pTan0.FullName + " * " + str(
self.tan0_loc.Parameters("nposy").Value
) + " * (ctr_dist(" + self.root.FullName + "," + self.ik_ctl.FullName + ") / " + str(
d) + ")"
par.addExpression(self.tan0_loc.Parameters("nposy"), exp)
exp = self.pTan1.FullName + " * " + str(
self.tan1_loc.Parameters("nposy").Value
) + " * (ctr_dist(" + self.root.FullName + "," + self.ik_ctl.FullName + ") / " + str(
d) + ")"
par.addExpression(self.tan1_loc.Parameters("nposy"), exp)
# Curves -------------------------------------------
op = aop.sn_curveslide2_op(self.slv_crv, self.mst_crv, 0, 1.5, .5, .5)
par.addExpression(op.Parameters("position"), 0)
par.addExpression(op.Parameters("maxstretch"),
self.pMaxStretch.FullName)
par.addExpression(op.Parameters("maxsquash"), self.pMaxSquash.FullName)
par.addExpression(op.Parameters("softness"), self.pSoftness.FullName)
# Division -----------------------------------------
for i in range(self.settings["division"]):
# References
u = i / (self.settings["division"] - 1.0)
div_cns = self.div_cns[i]
cns = aop.pathCns(div_cns, self.slv_crv, 0, u * 100, True, None,
False)
cns.Parameters("dirx").Value = 0
cns.Parameters("diry").Value = 1
cns.Parameters("dirz").Value = 0
cns.Parameters("upx").Value = 0
cns.Parameters("upy").Value = 0
cns.Parameters("upz").Value = -1
# Roll
aop.spinePointAtOp(cns, self.root, self.ik_ctl, u)
# Squash n Stretch
op = aop.sn_squashstretch2_op(
div_cns, self.slv_crv,
self.slv_crv.ActivePrimitive.Geometry.Curves(0).Length, "y")
par.addExpression(op.Parameters("blend"), self.pVolume.FullName)
par.addExpression(op.Parameters("driver"), self.pDriver.FullName)
if self.options["mode"] == 1: # wip
par.addExpression(op.Parameters("stretch"), self.pStretch[i])
par.addExpression(op.Parameters("squash"), self.pSquash[i])
else:
import gear
op.Parameters("stretch").Value = self.st_value[i]
op.Parameters("squash").Value = self.sq_value[i]
# Controlers
fk_ctl = self.fk_ctl[i]
for s in "xyz":
par.addExpression(fk_ctl.Parameters("npos" + s),
div_cns.Parameters("pos" + s).FullName)
par.addExpression(fk_ctl.Parameters("nrot" + s),
div_cns.Parameters("rot" + s).FullName)
par.addExpression(
fk_ctl.Kinematics.Global.Parameters("scl" + s),
div_cns.Kinematics.Global.Parameters("scl" + s).FullName)
# Orientation Lock
cns = self.div_cns[-1].Kinematics.AddConstraint(
"Orientation", self.ik_ctl, False)
par.addExpression(cns.Parameters("blendweight"),
self.pLockOri.FullName)
# Volume -------------------------------------------
op = aop.sn_curvelength_op(self.pDriver, self.slv_crv)
# Head ---------------------------------------------
self.fk_ctl[-1].AddChild(self.head_cns)
if self.headref_count > 0:
cns = self.head_cns.Kinematics.AddConstraint(
"Orientation", self.fk_ctl[-1], True)
par.addExpression(cns.Parameters("active"),
self.pHeadRef.FullName + " == 0")
def addOperators(self):
# Visibilities -------------------------------------
par.addExpression(
self.fk0_ctl.Properties("visibility").Parameters("viewvis"),
"1 - " + self.pBlend.FullName)
par.addExpression(
self.fk1_ctl.Properties("visibility").Parameters("viewvis"),
"1 - " + self.pBlend.FullName)
par.addExpression(
self.fk2_ctl.Properties("visibility").Parameters("viewvis"),
"1 - " + self.pBlend.FullName)
par.addExpression(
self.fk3_ctl.Properties("visibility").Parameters("viewvis"),
"1 - " + self.pBlend.FullName)
par.addExpression(
self.upv_ctl.Properties("visibility").Parameters("viewvis"),
self.pBlend.FullName)
par.addExpression(
self.ikcns_ctl.Properties("visibility").Parameters("viewvis"),
self.pBlend.FullName + " * " + self.pIkCns.FullName)
par.addExpression(
self.ik_ctl.Properties("visibility").Parameters("viewvis"),
self.pBlend.FullName)
if self.settings["roll"] == 0:
par.addExpression(
self.roll_ctl.Properties("visibility").Parameters("viewvis"),
self.pBlend.FullName)
# Leash --------------------------------------------
aop.clsCtrOp(self.upv_ctl, self.mid0_ctl, [0])
# IK Solver-----------------------------------------
if self.settings["roll"] == 0:
self.ref_chn.eff.Kinematics.AddConstraint("Pose", self.roll_ctl,
True)
self.end_chn.eff.Kinematics.AddConstraint("Pose", self.roll_ctl,
True)
else:
self.ref_chn.eff.Kinematics.AddConstraint("Pose", self.ik_ref,
True)
self.end_chn.eff.Kinematics.AddConstraint("Pose", self.ik_ref,
True)
op = xsi.ApplyOp(
"SkeletonUpVector",
self.ref_chn.bones[0].FullName + ";" + self.upv_ctl.FullName)[0]
par.addExpression(self.ref_chn.roll, self.pIkRoll.FullName + " + 180")
op = xsi.ApplyOp(
"SkeletonUpVector",
self.end_chn.bones[0].FullName + ";" + self.upv_ctl.FullName)[0]
par.addExpression(self.end_chn.roll, self.pIkRoll.FullName + " + 180")
# Roll
# cns = self.dir_ref.Kinematics.AddConstraint("Orientation", self.ik_ref, True)
# cns = aop.dirCns(self.dir_ref, self.root, None, False, "yz")
#
# restLength = vec.getDistance(self.guide.apos[0], self.guide.apos[3])
# maxLength = self.ref_chn.length + self.end_chn.length
# par.addExpression(cns.Parameters("blendweight"), "MIN(1, MAX(0, (ctr_dist("+self.root.FullName+".kine.global, "+self.ik_ref.FullName+".kine.global) - "+str(restLength)+") / " \
# +"("+str(maxLength - restLength)+")))")
# ctrn
for s in "xyz":
par.addExpression(
self.ctrn0_loc.Kinematics.Local.Parameters("rot" + s),
self.ref_loc[1].Kinematics.Local.Parameters("rot" + s).FullName
+ " * .5")
par.addExpression(
self.ctrn0_loc.Kinematics.Global.Parameters("scl" + s),
self.root.Kinematics.Global.Parameters("scl" + s).FullName)
par.addExpression(
self.ctrn1_loc.Kinematics.Local.Parameters("rot" + s),
self.ref_loc[2].Kinematics.Local.Parameters("rot" + s).FullName
+ " * .5")
par.addExpression(
self.ctrn1_loc.Kinematics.Global.Parameters("scl" + s),
self.root.Kinematics.Global.Parameters("scl" + s).FullName)
self.ctrn0_loc.Kinematics.AddConstraint("Position", self.ref_loc[1],
False)
self.ctrn1_loc.Kinematics.AddConstraint("Position", self.ref_loc[2],
False)
# References Nulls ---------------------------------
fk_ref = [
self.fk0_ctl, self.fk1_ctl, self.fk2_ctl, self.fk3_ctl, self.fk_ref
]
ik_ref = [
self.ref_chn.bones[0], self.ref_chn.bones[1],
self.end_chn.bones[0], self.ik_ref
]
for i, ref_loc in enumerate(self.ref_loc):
# fk
cns = ref_loc.Kinematics.AddConstraint("Orientation", fk_ref[i],
False)
if i != len(self.ref_loc) - 1:
cns = aop.dirCns(ref_loc, fk_ref[i + 1], None, False,
self.n_sign + "xz")
par.addExpression(cns.Parameters("blendweight"),
"1 - " + self.pBlend.FullName)
#ik
cns = ref_loc.Kinematics.AddConstraint("Orientation", ik_ref[i],
False)
par.addExpression(cns.Parameters("blendweight"),
self.pBlend.FullName)
for s in "xyz":
par.addExpression(
ref_loc.Kinematics.Local.Parameters("rot" + s), 0)
par.addExpression(
self.ref_loc[1].Kinematics.Local.Parameters("posx"), self.n_sign +
" (ctr_dist(%s.kine.global, %s.kine.global) * (1 - %s) + ctr_dist(%s.kine.global, %s.kine.global) * %s)"
% (self.fk0_ctl.FullName, self.fk1_ctl.FullName,
self.pBlend.FullName, self.ref_chn.bones[0].FullName,
self.ref_chn.bones[1].FullName, self.pBlend.FullName))
par.addExpression(
self.ref_loc[2].Kinematics.Local.Parameters("posx"), self.n_sign +
" (ctr_dist(%s.kine.global, %s.kine.global) * (1 - %s) + ctr_dist(%s.kine.global, %s.kine.global) * %s)"
% (self.fk1_ctl.FullName, self.fk2_ctl.FullName,
self.pBlend.FullName, self.ref_chn.bones[1].FullName,
self.end_chn.bones[0], self.pBlend.FullName))
par.addExpression(
self.ref_loc[3].Kinematics.Local.Parameters("posx"), self.n_sign +
" (ctr_dist(%s.kine.global, %s.kine.global) * (1 - %s) + ctr_dist(%s.kine.global, %s.kine.global) * %s)"
% (self.fk2_ctl.FullName, self.fk3_ctl.FullName,
self.pBlend.FullName, self.end_chn.bones[0].FullName,
self.end_chn.eff, self.pBlend.FullName))
# Twist references ---------------------------------
par.addExpression(
self.pDriver,
"ctr_dist(%s, %s) + ctr_dist(%s, %s) + ctr_dist(%s, %s)" %
(self.tws0_loc.Kinematics.Global.FullName,
self.tws1_loc.Kinematics.Global.FullName,
self.tws1_loc.Kinematics.Global.FullName,
self.tws2_loc.Kinematics.Global.FullName,
self.tws2_loc.Kinematics.Global.FullName,
self.tws3_loc.Kinematics.Global.FullName))
self.tws1_loc.Kinematics.AddConstraint("Position", self.mid0_ctl)
self.tws1_loc.Kinematics.AddConstraint("Scaling", self.mid0_ctl)
self.tws1_rot.Kinematics.AddConstraint("Orientation", self.mid0_ctl)
par.addExpression(self.tws1_rot.Parameters("rotx"), 0)
par.addExpression(self.tws1_rot.Parameters("roty"), 0)
par.addExpression(self.tws1_rot.Parameters("rotz"), 0)
self.tws2_loc.Kinematics.AddConstraint("Position", self.mid1_ctl)
self.tws2_loc.Kinematics.AddConstraint("Scaling", self.mid1_ctl)
self.tws2_rot.Kinematics.AddConstraint("Orientation", self.mid1_ctl)
par.addExpression(self.tws2_rot.Parameters("rotx"), 0)
par.addExpression(self.tws2_rot.Parameters("roty"), 0)
par.addExpression(self.tws2_rot.Parameters("rotz"), 0)
self.tws3_loc.Kinematics.AddConstraint("Position", self.ref_loc[-1])
#self.tws3_loc.Kinematics.AddConstraint("Scaling", self.eff_loc)
aop.poseCns(self.tws3_rot, self.fk_ref, True, False, True, False)
cns = aop.poseCns(self.tws3_rot, self.ik_ref, True, False, True, False)
par.addExpression(cns.Parameters("blendweight"), self.pBlend.FullName)
par.addExpression(
self.tws3_rot.Parameters("rotx"),
self.ik_ctl.Parameters("rotx").FullName + " * (1 - " +
self.pBlend.FullName + ") + " +
self.fk3_ctl.Parameters("rotx").FullName + " * " +
self.pBlend.FullName)
par.addExpression(self.tws3_rot.Parameters("roty"), 0)
par.addExpression(self.tws3_rot.Parameters("rotz"), 0)
self.tws0_rot.SclX = .001
par.addExpression(self.tws1_rot.SclX,
self.pRoundness.FullName + " + .001")
par.addExpression(self.tws2_rot.SclX,
self.pRoundness.FullName + " + .001")
self.tws3_rot.SclX = .001
# Divisions ----------------------------------------
# at 0 or 1 the division will follow exactly the rotation of the controler.. and we wont have this nice tangent + roll
step = 1.0 / (self.divisions - 1.0)
for i, div_cns in enumerate(self.div_cns):
perc = max(.001, min(.999, i * step))
if self.negate:
op = aop.sn_rollsplinekine_op(div_cns, [
self.tws3_rot, self.tws2_rot, self.tws1_rot, self.tws0_rot
], 1 - perc)
else:
op = aop.sn_rollsplinekine_op(div_cns, [
self.tws0_rot, self.tws1_rot, self.tws2_rot, self.tws3_rot
], perc)
# Squash n Stretch
op = aop.sn_squashstretch2_op(div_cns, self.root,
self.pDriver.Value, "x")
par.addExpression(op.Parameters("blend"), self.pVolume.FullName)
par.addExpression(op.Parameters("driver"), self.pDriver.FullName)
if self.options["mode"] == 1: # wip
par.addExpression(op.Parameters("stretch"), self.pStretch[i])
par.addExpression(op.Parameters("squash"), self.pSquash[i])
else:
op.Parameters("stretch").Value = self.st_value[i]
op.Parameters("squash").Value = self.sq_value[i]
def addOperators(self):
# Visibilities -------------------------------------
par.addExpression(
self.fk0_ctl.Properties("visibility").Parameters("viewvis"),
"1 - " + self.pBlend.FullName)
par.addExpression(
self.fk1_ctl.Properties("visibility").Parameters("viewvis"),
"1 - " + self.pBlend.FullName)
par.addExpression(
self.fk2_ctl.Properties("visibility").Parameters("viewvis"),
"1 - " + self.pBlend.FullName)
par.addExpression(
self.fk3_ctl.Properties("visibility").Parameters("viewvis"),
"1 - " + self.pBlend.FullName)
par.addExpression(
self.upv_ctl.Properties("visibility").Parameters("viewvis"),
self.pBlend.FullName)
par.addExpression(
self.ikcns_ctl.Properties("visibility").Parameters("viewvis"),
self.pBlend.FullName + " * " + self.pIkCns.FullName)
par.addExpression(
self.ik_ctl.Properties("visibility").Parameters("viewvis"),
self.pBlend.FullName)
if self.settings["roll"] == 0:
par.addExpression(
self.roll_ctl.Properties("visibility").Parameters("viewvis"),
self.pBlend.FullName)
# Leash --------------------------------------------
aop.clsCtrOp(self.upv_ctl, self.mid0_ctl, [0])
# IK Solver-----------------------------------------
self.roll_ctl.Kinematics.AddConstraint("Position", self.ik_ref, False)
self.ref_chn.eff.Kinematics.AddConstraint("Pose", self.roll_ctl, True)
self.end_chn.eff.Kinematics.AddConstraint("Pose", self.roll_ctl, True)
op = xsi.ApplyOp(
"SkeletonUpVector",
self.ref_chn.bones[0].FullName + ";" + self.upv_ctl.FullName)[0]
par.addExpression(self.ref_chn.roll, self.pIkRoll.FullName + " + 180")
op = xsi.ApplyOp(
"SkeletonUpVector",
self.end_chn.bones[0].FullName + ";" + self.upv_ctl.FullName)[0]
par.addExpression(self.end_chn.roll, self.pIkRoll.FullName + " + 180")
# ctrn
for s in "xyz":
par.addExpression(
self.ctrn0_loc.Kinematics.Local.Parameters("rot" + s),
self.ref_loc[1].Kinematics.Local.Parameters("rot" + s).FullName
+ " * .5")
par.addExpression(
self.ctrn0_loc.Kinematics.Global.Parameters("scl" + s),
self.root.Kinematics.Global.Parameters("scl" + s).FullName)
par.addExpression(
self.ctrn1_loc.Kinematics.Local.Parameters("rot" + s),
self.ref_loc[2].Kinematics.Local.Parameters("rot" + s).FullName
+ " * .5")
par.addExpression(
self.ctrn1_loc.Kinematics.Global.Parameters("scl" + s),
self.root.Kinematics.Global.Parameters("scl" + s).FullName)
self.ctrn0_loc.Kinematics.AddConstraint("Position", self.ref_loc[1],
False)
self.ctrn1_loc.Kinematics.AddConstraint("Position", self.ref_loc[2],
False)
# References Nulls ---------------------------------
fk_ref = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl, self.fk_ref]
ik_ref = [
self.ref_chn.bones[0], self.ref_chn.bones[1],
self.end_chn.bones[0], self.ik_ref
]
for i, ref_loc in enumerate(self.ref_loc):
# fk
cns = ref_loc.Kinematics.AddConstraint("Orientation", fk_ref[i],
False)
if i != len(self.ref_loc) - 1:
cns = aop.dirCns(ref_loc, fk_ref[i + 1], None, False,
self.n_sign + "xz")
par.addExpression(cns.Parameters("blendweight"),
"1 - " + self.pBlend.FullName)
#ik
cns = ref_loc.Kinematics.AddConstraint("Orientation", ik_ref[i],
False)
par.addExpression(cns.Parameters("blendweight"),
self.pBlend.FullName)
for s in "xyz":
par.addExpression(
ref_loc.Kinematics.Local.Parameters("rot" + s), 0)
par.addExpression(
self.ref_loc[1].Kinematics.Local.Parameters("posx"), self.n_sign +
" (ctr_dist(%s.kine.global, %s.kine.global) * (1 - %s) + ctr_dist(%s.kine.global, %s.kine.global) * %s)"
% (self.fk0_ctl.FullName, self.fk1_ctl.FullName,
self.pBlend.FullName, self.ref_chn.bones[0].FullName,
self.ref_chn.bones[1].FullName, self.pBlend.FullName))
par.addExpression(
self.ref_loc[2].Kinematics.Local.Parameters("posx"), self.n_sign +
" (ctr_dist(%s.kine.global, %s.kine.global) * (1 - %s) + ctr_dist(%s.kine.global, %s.kine.global) * %s)"
% (self.fk1_ctl.FullName, self.fk2_ctl.FullName,
self.pBlend.FullName, self.ref_chn.bones[1].FullName,
self.end_chn.bones[0], self.pBlend.FullName))
par.addExpression(
self.ref_loc[3].Kinematics.Local.Parameters("posx"), self.n_sign +
" (ctr_dist(%s.kine.global, %s.kine.global) * (1 - %s) + ctr_dist(%s.kine.global, %s.kine.global) * %s)"
% (self.fk2_ctl.FullName, self.fk3_ctl.FullName,
self.pBlend.FullName, self.end_chn.bones[0].FullName,
self.end_chn.eff, self.pBlend.FullName))
# Global Scale
for s in "xyz":
par.addExpression(
self.ref_loc[0].Kinematics.Global.Parameters("scl%s" % s), 1)
par.addExpression(
self.end_ref.Kinematics.Global.Parameters("scl%s" % s),
self.root.Kinematics.Global.Parameters("scl%s" % s))
# Twist references ---------------------------------
par.addExpression(
self.pDriver,
"(ctr_dist(%s, %s) + ctr_dist(%s, %s) + ctr_dist(%s, %s)) / %s" %
(self.tws0_loc.Kinematics.Global.FullName,
self.tws1_loc.Kinematics.Global.FullName,
self.tws1_loc.Kinematics.Global.FullName,
self.tws2_loc.Kinematics.Global.FullName,
self.tws2_loc.Kinematics.Global.FullName,
self.tws3_loc.Kinematics.Global.FullName,
self.root.Kinematics.Global.Parameters("sclx").FullName))
self.tws0_loc.Kinematics.AddConstraint("Pose", self.root, True)
aop.dirCns(self.tws0_loc, self.mid0_ctl, None, False,
self.n_sign + "xy")
self.tws1_loc.Kinematics.AddConstraint("Position", self.mid0_ctl)
self.tws1_loc.Kinematics.AddConstraint("Scaling", self.mid0_ctl)
self.tws1_rot.Kinematics.AddConstraint("Orientation", self.mid0_ctl)
par.addExpression(self.tws1_rot.Parameters("rotx"), 0)
par.addExpression(self.tws1_rot.Parameters("roty"), 0)
par.addExpression(self.tws1_rot.Parameters("rotz"), 0)
self.tws2_loc.Kinematics.AddConstraint("Position", self.mid1_ctl)
self.tws2_loc.Kinematics.AddConstraint("Scaling", self.mid1_ctl)
self.tws2_rot.Kinematics.AddConstraint("Orientation", self.mid1_ctl)
par.addExpression(self.tws2_rot.Parameters("rotx"), 0)
par.addExpression(self.tws2_rot.Parameters("roty"), 0)
par.addExpression(self.tws2_rot.Parameters("rotz"), 0)
self.tws3_loc.Kinematics.AddConstraint("Position", self.ref_loc[-1])
#self.tws3_loc.Kinematics.AddConstraint("Scaling", self.eff_loc)
aop.poseCns(self.tws3_rot, self.fk_ref, False, False, True, False)
cns = aop.poseCns(self.tws3_rot, self.ik_ref, True, False, True, False)
par.addExpression(cns.Parameters("blendweight"), self.pBlend.FullName)
par.addExpression(self.tws3_rot.Parameters("rotx"), 0)
par.addExpression(self.tws3_rot.Parameters("roty"), 0)
par.addExpression(self.tws3_rot.Parameters("rotz"), 0)
par.setRotOrder(self.tws3_rot, "YZX")
self.tws0_rot.SclX = .001
par.addExpression(self.tws1_rot.SclX,
self.pRoundness.FullName + " + .001")
par.addExpression(self.tws2_rot.SclX,
self.pRoundness.FullName + " + .001")
self.tws3_rot.SclX = .001
# Divisions ----------------------------------------
# at 0 or 1 the division will follow exactly the rotation of the controler.. and we wont have this nice tangent + roll
for i, div_cns in enumerate(self.div_cns):
if i < (self.settings["div0"] + 1):
perc = i / ((self.settings["div0"] + 1.0) * 3)
elif i < (self.settings["div0"] + self.settings["div1"] + 2):
perc = (1 / 3.0) + ((i - self.settings["div0"] - 1.0) /
((self.settings["div1"] + 1.0) * 3))
else:
perc = (2 / 3.0) + (
(i - self.settings["div0"] - self.settings["div1"] - 2.0) /
((self.settings["div2"] + 1.0) * 3))
perc = max(.001, min(.999, perc))
if self.negate:
op = aop.sn_rollsplinekine_op(div_cns, [
self.tws3_rot, self.tws2_rot, self.tws1_rot, self.tws0_rot
], 1 - perc)
else:
op = aop.sn_rollsplinekine_op(div_cns, [
self.tws0_rot, self.tws1_rot, self.tws2_rot, self.tws3_rot
], perc)
# Squash n Stretch
op = aop.sn_squashstretch2_op(div_cns, self.root,
self.pDriver.Value, "x")
par.addExpression(op.Parameters("blend"), self.pVolume.FullName)
par.addExpression(op.Parameters("driver"), self.pDriver.FullName)
if self.options["mode"] == 1: # wip
par.addExpression(op.Parameters("stretch"), self.pStretch[i])
par.addExpression(op.Parameters("squash"), self.pSquash[i])
else:
op.Parameters("stretch").Value = self.st_value[i]
op.Parameters("squash").Value = self.sq_value[i]
def addOperators(self):
#return
i = 0
for x in self.oDirDrivenList:
oTmpOp = aop.dirCns(x, self.oDirDriverList[i], self.upVec, False, "xz")
xsi.ParentObj(x, self.oPointerLvlList[i])
i +=1
i =0
for oBlock in self.blockList:
# Corners
par.addExpression(self.oCornersList[i].Kinematics.Local.Parameters("posy"), \
"(cond(" + self.cornerA.Kinematics.Local.Parameters("posy").FullName + " > 0," + \
self.cornerA.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][3].FullName + "," + \
self.cornerA.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][4].FullName + ") +" + \
"cond(" + self.cornerB.Kinematics.Local.Parameters("posy").FullName + " > 0," + \
self.cornerB.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][11].FullName + "," + \
self.cornerB.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][12].FullName + "))" + \
"+ (cond(" + self.cornerA.Kinematics.Local.Parameters("posx").FullName + " > 0," + \
self.cornerA.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][7].FullName + "," + \
self.cornerA.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][8].FullName + ") +" + \
"cond(" + self.cornerB.Kinematics.Local.Parameters("posx").FullName + " > 0," + \
self.cornerB.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][15].FullName + "," + \
self.cornerB.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][16].FullName + "))")
par.addExpression(self.oCornersList[i].Kinematics.Local.Parameters("posx"), \
"cond(" + self.cornerA.Kinematics.Local.Parameters("posy").FullName + " > 0," + \
self.cornerA.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][1].FullName + "," + \
self.cornerA.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][2].FullName + ") +" + \
"cond(" + self.cornerB.Kinematics.Local.Parameters("posy").FullName + " > 0," + \
self.cornerB.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][9].FullName + "," + \
self.cornerB.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][10].FullName + ")" + \
"+ (cond(" + self.cornerA.Kinematics.Local.Parameters("posx").FullName + " > 0," + \
self.cornerA.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][5].FullName + "," + \
self.cornerA.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][6].FullName + ") +" + \
"cond(" + self.cornerB.Kinematics.Local.Parameters("posx").FullName + " > 0," + \
self.cornerB.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][13].FullName + "," + \
self.cornerB.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][14].FullName + "))")
#Control up down
par.addExpression(self.oUpDownList[i].Kinematics.Local.Parameters("posy"), \
"cond(" + self.control.Kinematics.Local.Parameters("posy").FullName + " > 0," + \
self.control.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][19].FullName + "," + \
self.control.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][20].FullName + ")")
par.addExpression(self.oUpDownList[i].Kinematics.Local.Parameters("posx"), \
"cond(" + self.control.Kinematics.Local.Parameters("posy").FullName + " > 0," + \
self.control.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][17].FullName + "," + \
self.control.Kinematics.Local.Parameters("posy").FullName + " * " + self.blockList[i][18].FullName + ")")
#Control sides
par.addExpression(self.oSidesList[i].Kinematics.Local.Parameters("posy"), \
"cond(" + self.control.Kinematics.Local.Parameters("posx").FullName + " > 0," + \
self.control.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][23].FullName + "," + \
self.control.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][24].FullName + ")")
par.addExpression(self.oSidesList[i].Kinematics.Local.Parameters("posx"), \
"cond(" + self.control.Kinematics.Local.Parameters("posx").FullName + " > 0," + \
self.control.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][21].FullName + "," + \
self.control.Kinematics.Local.Parameters("posx").FullName + " * " + self.blockList[i][22].FullName + ")")
i+=1
def addOperators(self):
# Visibilities -------------------------------------
if self.isFkIk:
for fk_ctl in self.fk_ctl:
par.addExpression(fk_ctl.Properties("visibility").Parameters("viewvis"), "1 - "+self.pBlend.FullName)
par.addExpression(self.upv_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName)
par.addExpression(self.ikcns_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName +" * "+ self.pIkCns.FullName)
par.addExpression(self.ik_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName)
# IK Chain -----------------------------------------
if self.isIk:
# Leash
aop.clsCtrOp(self.upv_ctl, self.chain.bones[0], [0])
# Constraint and up vector
self.chain.eff.Kinematics.AddConstraint("Position", self.ik_ctl, False)
xsi.ApplyOp("SkeletonUpVector", self.chain.bones[0].FullName+";"+self.upv_ctl.FullName, 3, "siPersistentOperation", "", 0)
par.addExpression(self.chain.roll, self.pRoll.FullName)
# Chain of deformers -------------------------------
for i, loc in enumerate(self.loc):
if self.settings["type"] == 0: # fk only
loc.Kinematics.addConstraint("Pose", self.fk_ctl[i])
elif self.settings["type"] == 1: # ik only
loc.Kinematics.addConstraint("Pose", self.chain.bones[i])
elif self.settings["type"] == 2: # fk/ik
# orientation
cns = loc.Kinematics.AddConstraint("Orientation", self.fk_ctl[i])
cns = loc.Kinematics.AddConstraint("Orientation", self.chain.bones[i])
par.addExpression(cns.Parameters("blendweight"), self.pBlend.FullName)
# position / scaling
for s in "xyz":
par.addExpression(loc.Kinematics.Local.Parameters("pos%s"%s), self.fk_ctl[i].Kinematics.Local.Parameters("pos%s"%s).FullName+" * (1 - "+self.pBlend.FullName+") + "+self.chain.bones[i].Kinematics.Local.Parameters("pos%s"%s).FullName +" * "+self.pBlend.FullName)
par.addExpression(loc.Kinematics.Local.Parameters("scl%s"%s), self.fk_ctl[i].Kinematics.Local.Parameters("scl%s"%s).FullName+" * (1 - "+self.pBlend.FullName+") + "+self.chain.bones[i].Kinematics.Local.Parameters("scl%s"%s).FullName +" * "+self.pBlend.FullName)
# Default Values -----------------------------------
if self.isFkIk:
self.pBlend.Value = self.settings["blend"]
def addOperators(self):
# Visibilities -------------------------------------
par.addExpression(self.fk0_ctl.Properties("visibility").Parameters("viewvis"), "1 - "+self.pBlend.FullName)
par.addExpression(self.fk1_ctl.Properties("visibility").Parameters("viewvis"), "1 - "+self.pBlend.FullName)
par.addExpression(self.fk2_ctl.Properties("visibility").Parameters("viewvis"), "1 - "+self.pBlend.FullName)
par.addExpression(self.fk3_ctl.Properties("visibility").Parameters("viewvis"), "1 - "+self.pBlend.FullName)
par.addExpression(self.upv_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName)
par.addExpression(self.ikcns_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName +" * "+ self.pIkCns.FullName)
par.addExpression(self.ik_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName)
if self.settings["roll"] == 0:
par.addExpression(self.roll_ctl.Properties("visibility").Parameters("viewvis"), self.pBlend.FullName)
# Leash --------------------------------------------
aop.clsCtrOp(self.upv_ctl, self.mid0_ctl, [0])
# IK Solver-----------------------------------------
self.roll_ctl.Kinematics.AddConstraint("Position", self.ik_ref, False)
self.ref_chn.eff.Kinematics.AddConstraint("Pose", self.roll_ctl, True)
self.end_chn.eff.Kinematics.AddConstraint("Pose", self.roll_ctl, True)
op = xsi.ApplyOp("SkeletonUpVector", self.ref_chn.bones[0].FullName+";"+self.upv_ctl.FullName)[0]
par.addExpression(self.ref_chn.roll, self.pIkRoll.FullName + " + 180")
op = xsi.ApplyOp("SkeletonUpVector", self.end_chn.bones[0].FullName+";"+self.upv_ctl.FullName)[0]
par.addExpression(self.end_chn.roll, self.pIkRoll.FullName + " + 180")
# ctrn
for s in "xyz":
par.addExpression(self.ctrn0_loc.Kinematics.Local.Parameters("rot" + s), self.ref_loc[1].Kinematics.Local.Parameters("rot" + s).FullName + " * .5")
par.addExpression(self.ctrn0_loc.Kinematics.Global.Parameters("scl" + s), self.root.Kinematics.Global.Parameters("scl" + s).FullName)
par.addExpression(self.ctrn1_loc.Kinematics.Local.Parameters("rot" + s), self.ref_loc[2].Kinematics.Local.Parameters("rot" + s).FullName + " * .5")
par.addExpression(self.ctrn1_loc.Kinematics.Global.Parameters("scl" + s), self.root.Kinematics.Global.Parameters("scl" + s).FullName)
self.ctrn0_loc.Kinematics.AddConstraint("Position", self.ref_loc[1], False)
self.ctrn1_loc.Kinematics.AddConstraint("Position", self.ref_loc[2], False)
# References Nulls ---------------------------------
fk_ref = [self.fk0_ctl, self.fk1_ctl, self.fk2_ctl, self.fk_ref]
ik_ref = [self.ref_chn.bones[0], self.ref_chn.bones[1], self.end_chn.bones[0], self.ik_ref]
for i, ref_loc in enumerate(self.ref_loc):
# fk
cns = ref_loc.Kinematics.AddConstraint("Orientation", fk_ref[i], False)
if i != len(self.ref_loc)-1:
cns = aop.dirCns(ref_loc, fk_ref[i+1], None, False, self.n_sign+"xz")
par.addExpression(cns.Parameters("blendweight"), "1 - " + self.pBlend.FullName)
#ik
cns = ref_loc.Kinematics.AddConstraint("Orientation", ik_ref[i], False)
par.addExpression(cns.Parameters("blendweight"), self.pBlend.FullName)
for s in "xyz":
par.addExpression(ref_loc.Kinematics.Local.Parameters("rot"+s), 0)
par.addExpression(self.ref_loc[1].Kinematics.Local.Parameters("posx"), self.n_sign+" (ctr_dist(%s.kine.global, %s.kine.global) * (1 - %s) + ctr_dist(%s.kine.global, %s.kine.global) * %s)"%(self.fk0_ctl.FullName, self.fk1_ctl.FullName, self.pBlend.FullName, self.ref_chn.bones[0].FullName, self.ref_chn.bones[1].FullName, self.pBlend.FullName))
par.addExpression(self.ref_loc[2].Kinematics.Local.Parameters("posx"), self.n_sign+" (ctr_dist(%s.kine.global, %s.kine.global) * (1 - %s) + ctr_dist(%s.kine.global, %s.kine.global) * %s)"%(self.fk1_ctl.FullName, self.fk2_ctl.FullName, self.pBlend.FullName, self.ref_chn.bones[1].FullName, self.end_chn.bones[0], self.pBlend.FullName))
par.addExpression(self.ref_loc[3].Kinematics.Local.Parameters("posx"), self.n_sign+" (ctr_dist(%s.kine.global, %s.kine.global) * (1 - %s) + ctr_dist(%s.kine.global, %s.kine.global) * %s)"%(self.fk2_ctl.FullName, self.fk3_ctl.FullName, self.pBlend.FullName, self.end_chn.bones[0].FullName, self.end_chn.eff, self.pBlend.FullName))
# Twist references ---------------------------------
par.addExpression(self.pDriver, "(ctr_dist(%s, %s) + ctr_dist(%s, %s) + ctr_dist(%s, %s)) / %s"
%(self.tws0_loc.Kinematics.Global.FullName, self.tws1_loc.Kinematics.Global.FullName,
self.tws1_loc.Kinematics.Global.FullName, self.tws2_loc.Kinematics.Global.FullName,
self.tws2_loc.Kinematics.Global.FullName, self.tws3_loc.Kinematics.Global.FullName,
self.root.Kinematics.Global.Parameters("sclx").FullName))
self.tws1_loc.Kinematics.AddConstraint("Position", self.mid0_ctl)
self.tws1_loc.Kinematics.AddConstraint("Scaling", self.mid0_ctl)
self.tws1_rot.Kinematics.AddConstraint("Orientation", self.mid0_ctl)
par.addExpression(self.tws1_rot.Parameters("rotx"), 0)
par.addExpression(self.tws1_rot.Parameters("roty"), 0)
par.addExpression(self.tws1_rot.Parameters("rotz"), 0)
self.tws2_loc.Kinematics.AddConstraint("Position", self.mid1_ctl)
self.tws2_loc.Kinematics.AddConstraint("Scaling", self.mid1_ctl)
self.tws2_rot.Kinematics.AddConstraint("Orientation", self.mid1_ctl)
par.addExpression(self.tws2_rot.Parameters("rotx"), 0)
par.addExpression(self.tws2_rot.Parameters("roty"), 0)
par.addExpression(self.tws2_rot.Parameters("rotz"), 0)
self.tws3_loc.Kinematics.AddConstraint("Position", self.ref_loc[-1])
#self.tws3_loc.Kinematics.AddConstraint("Scaling", self.eff_loc)
aop.poseCns(self.tws3_rot, self.fk_ref, True, False, True, False)
cns = aop.poseCns(self.tws3_rot, self.ik_ref, True, False, True, False)
par.addExpression(cns.Parameters("blendweight"), self.pBlend.FullName)
par.addExpression(self.tws3_rot.Parameters("rotx"), self.ik_ctl.Parameters("rotx").FullName + " * (1 - "+self.pBlend.FullName+") + " + self.fk3_ctl.Parameters("rotx").FullName + " * " + self.pBlend.FullName)
par.addExpression(self.tws3_rot.Parameters("roty"), 0)
par.addExpression(self.tws3_rot.Parameters("rotz"), 0)
self.tws0_rot.SclX = .001
par.addExpression(self.tws1_rot.SclX, self.pRoundness.FullName + " + .001")
par.addExpression(self.tws2_rot.SclX, self.pRoundness.FullName + " + .001")
self.tws3_rot.SclX = .001
# Divisions ----------------------------------------
# at 0 or 1 the division will follow exactly the rotation of the controler.. and we wont have this nice tangent + roll
for i, div_cns in enumerate(self.div_cns):
if i < (self.settings["div0"]+1):
perc = i / ((self.settings["div0"]+1.0)*3)
elif i < (self.settings["div0"]+self.settings["div1"]+2):
perc = (1/3.0) + ((i-self.settings["div0"]-1.0) / ((self.settings["div1"]+1.0)*3))
else:
perc = (2/3.0) + ((i-self.settings["div0"]-self.settings["div1"]-2.0) / ((self.settings["div2"]+1.0)*3))
perc = max(.001, min(.999, perc))
if self.negate:
op = aop.sn_rollsplinekine_op(div_cns, [self.tws3_rot, self.tws2_rot, self.tws1_rot, self.tws0_rot], 1-perc)
else:
op = aop.sn_rollsplinekine_op(div_cns, [self.tws0_rot, self.tws1_rot, self.tws2_rot, self.tws3_rot], perc)
# Squash n Stretch
op = aop.sn_squashstretch2_op(div_cns, self.root, self.pDriver.Value, "x")
par.addExpression(op.Parameters("blend"), self.pVolume.FullName)
par.addExpression(op.Parameters("driver"), self.pDriver.FullName)
if self.options["mode"] == 1: # wip
par.addExpression(op.Parameters("stretch"), self.pStretch[i])
par.addExpression(op.Parameters("squash"), self.pSquash[i])
else:
op.Parameters("stretch").Value = self.st_value[i]
op.Parameters("squash").Value = self.sq_value[i]
def finalize(self):
# Properties --------------------------------------
self.plog.log("Filling layout and logic")
self.ui.fillLayoutAndLogic()
# Groups ------------------------------------------
self.plog.log("Creating groups")
# Retrieve group content from components
for name in self.componentsIndex:
component = self.components[name]
for name, objects in component.groups.items():
self.addToGroup(objects, name)
# Creating all groups
for name, objects in self.groups.items():
collection = XSIFactory.CreateObject("XSI.Collection")
collection.AddItems(objects)
self.groups[name] = self.model.AddGroup(collection, name + "_grp")
# Hidden
if self.options["setHidden"]:
self.groups["hidden"].Parameters("viewvis").Value = 0
self.groups["hidden"].Parameters("rendvis").Value = 0
# Unselectable
if self.options["setUnselectable"]:
self.groups["unselectable"].Parameters("selectability").Value = 0
# Deformers
if self.options["setDeformers"]:
self.groups["deformers"].Parameters("viewvis").Value = 0
self.groups["deformers"].Parameters("rendvis").Value = 0
# Geometries
if self.options["setGeometries"]:
self.groups["geometries"].Parameters("selectability").Value = 0
prop = self.groups["geometries"].AddProperty("GeomApprox")
par.addExpression(prop.Parameters("gapproxmosl"), self.pOGLLevel)
# Skin --------------------------------------------
if self.options["addGeometry"]:
self.plog.log("Applying skin")
# Import geometry
if self.options["geo_path"] and os.path.exists(self.options["geo_path"]):
geo_model = xsi.ImportModel(self.options["geo_path"], xsi.ActiveSceneRoot, False, None)(1)
geo_objects = geo_model.FindChildren()
self.model.AddChild(geo_model.children)
for group in geo_model.Groups:
target_group = pri.createOrReturnGroup(self.model, group.Name)
target_group.AddMember(group.Members)
xsi.DeleteObj(geo_model)
# Apply skin
if self.options["skin_path"] and os.path.exists(self.options["skin_path"]):
xml_objs = io.getObjectDefinitions(self.options["skin_path"], geo_objects, False)
for obj in geo_objects:
if obj.Name not in xml_objs.keys():
continue
io.importSkin(xml_objs[obj.Name], obj)
# Symmetry Mapping Template -----------------------
if self.options["mode"] == 1:
env.createSymmetryMappingTemplate(self.groups["deformers"].Members)
for geo in self.groups["geometries"].Members:
if geo.Type == "polymsh":
xsi.CreateSymmetryMap("SymmetryMap", geo, "Symmetry Map")
# Mirror Animation Template -----------------------
if self.options["mode"] == 0:
cnx_prop = ani.createMirrorCnxTemplate(self.model)
for count, compName in enumerate(self.componentsIndex):
component = self.components[compName]
inversed_params = component.inv_params.GetAsText().split(",")
for ctl in component.controlers:
ani.addMirroringRule(ctl, cnx_prop, inversed_params, True)
# Reset Pose --------------------------------------
self.plog.log("Creating rest pose")
controlers = XSIFactory.CreateObject("XSI.Collection")
for group in self.model.Groups:
if group.Name.startswith("controlers"):
controlers.AddItems(group.Members)
keyableParams = controlers.FindObjectsByMarkingAndCapabilities(None, c.siKeyable)
xsi.StoreAction(self.model, keyableParams, 1, "reset", False)
# Isolate and popup -------------------------------
if self.options["isolateResult"]:
xsi.SelectObj(self.model, "BRANCH")
xsi.IsolateSelected(False, -1)
xsi.DeselectAll()
if self.options["popUpControls"]:
xsi.InspectObj(self.ui.anim_prop)
def addOperators(self):
# Visibilities -------------------------------------
par.addExpression(self.ik0_ctl.Properties("visibility").Parameters("viewvis"), self.pShowIk.FullName)
par.addExpression(self.ik1_ctl.Properties("visibility").Parameters("viewvis"), self.pShowIk.FullName)
par.addExpression(self.tan0_ctl.Properties("visibility").Parameters("viewvis"), self.pShowIk.FullName)
par.addExpression(self.tan1_ctl.Properties("visibility").Parameters("viewvis"), self.pShowIk.FullName)
for fk_ctl in self.fk_ctl[1:-1]:
par.addExpression(fk_ctl.Properties("visibility").Parameters("viewvis"), self.pShowFk.FullName)
# Tangent position ---------------------------------
d = vec.getDistance(self.guide.apos[0], self.guide.apos[1])
exp = self.pTan0.FullName + " * " + str(self.tan0_ctl.Parameters("nposy").Value)+" * (ctr_dist("+self.ik0_ctl.FullName+","+self.ik1_ctl.FullName+") / "+str(d)+")"
par.addExpression(self.tan0_ctl.Parameters("nposy"), exp)
exp = self.pTan1.FullName + " * " + str(self.tan1_ctl.Parameters("nposy").Value)+" * (ctr_dist("+self.ik0_ctl.FullName+","+self.ik1_ctl.FullName+") / "+str(d)+")"
par.addExpression(self.tan1_ctl.Parameters("nposy"), exp)
# Curves -------------------------------------------
op = aop.sn_curveslide2_op(self.slv_crv, self.mst_crv, 0, 1.5, .5, .5)
par.addExpression(op.Parameters("position"), self.pPosition.FullName)
par.addExpression(op.Parameters("maxstretch"), self.pMaxStretch.FullName)
par.addExpression(op.Parameters("maxsquash"), self.pMaxSquash.FullName)
par.addExpression(op.Parameters("softness"), self.pSoftness.FullName)
# Division -----------------------------------------
for i in range(self.settings["division"]):
# References
u = i / (self.settings["division"] - 1.0)
div_cns = self.div_cns[i]
cns = aop.pathCns(div_cns, self.slv_crv, 0, u*100, True, None, False)
cns.Parameters("dirx").Value = 0
cns.Parameters("diry").Value = 1
cns.Parameters("dirz").Value = 0
cns.Parameters("upx").Value = 0
cns.Parameters("upy").Value = 0
cns.Parameters("upz").Value = -1
# Roll
aop.spinePointAtOp(cns, self.ik0_ctl, self.ik1_ctl, u)
# Squash n Stretch
op = aop.sn_squashstretch2_op(div_cns, self.slv_crv, self.slv_crv.ActivePrimitive.Geometry.Curves(0).Length, "y")
par.addExpression(op.Parameters("blend"), self.pVolume.FullName)
par.addExpression(op.Parameters("driver"), self.pDriver.FullName)
if self.options["mode"] == 1: # wip
par.addExpression(op.Parameters("stretch"), self.pStretch[i])
par.addExpression(op.Parameters("squash"), self.pSquash[i])
else:
op.Parameters("stretch").Value = self.st_value[i]
op.Parameters("squash").Value = self.sq_value[i]
# Controlers
fk_ctl = self.fk_ctl[i]
for s in "xyz":
par.addExpression(fk_ctl.Parameters("npos"+s), div_cns.Parameters("pos"+s).FullName)
par.addExpression(fk_ctl.Parameters("nrot"+s), div_cns.Parameters("rot"+s).FullName)
par.addExpression(fk_ctl.Kinematics.Global.Parameters("scl"+s), div_cns.Kinematics.Global.Parameters("scl"+s).FullName)
# Orientation Lock
cns = self.div_cns[0].Kinematics.AddConstraint("Orientation", self.ik0_ctl, False)
par.addExpression(cns.Parameters("blendweight"), self.pLockOri0.FullName)
cns = self.div_cns[-1].Kinematics.AddConstraint("Orientation", self.ik1_ctl, False)
par.addExpression(cns.Parameters("blendweight"), self.pLockOri1.FullName)
# Volume -------------------------------------------
op = aop.sn_curvelength_op(self.pDriver, self.slv_crv)
# Connections (Hooks) ------------------------------
self.cnx0.Kinematics.AddConstraint("Position", self.div_cns[0], False)
self.cnx0.Kinematics.AddConstraint("Orientation", self.div_cns[0], False)
self.cnx1.Kinematics.AddConstraint("Position", self.fk_ctl[-1], False)
self.cnx1.Kinematics.AddConstraint("Orientation", self.fk_ctl[-1], False)
def addOperators(self):
# Visibilities -------------------------------------
if self.isFkIk:
for fk_ctl in self.fk_ctl:
par.addExpression(
fk_ctl.Properties("visibility").Parameters("viewvis"),
"1 - " + self.pBlend.FullName)
par.addExpression(
self.upv_ctl.Properties("visibility").Parameters("viewvis"),
self.pBlend.FullName)
par.addExpression(
self.ikcns_ctl.Properties("visibility").Parameters("viewvis"),
self.pBlend.FullName + " * " + self.pIkCns.FullName)
par.addExpression(
self.ik_ctl.Properties("visibility").Parameters("viewvis"),
self.pBlend.FullName)
# IK Chain -----------------------------------------
if self.isIk:
# Leash
aop.clsCtrOp(self.upv_ctl, self.chain.bones[0], [0])
# Constraint and up vector
self.chain.eff.Kinematics.AddConstraint("Position", self.ik_ctl,
False)
xsi.ApplyOp(
"SkeletonUpVector",
self.chain.bones[0].FullName + ";" + self.upv_ctl.FullName, 3,
"siPersistentOperation", "", 0)
par.addExpression(self.chain.roll, self.pRoll.FullName)
# Chain of deformers -------------------------------
for i, loc in enumerate(self.loc):
if self.settings["type"] == 0: # fk only
loc.Kinematics.addConstraint("Pose", self.fk_ctl[i])
elif self.settings["type"] == 1: # ik only
loc.Kinematics.addConstraint("Pose", self.chain.bones[i])
elif self.settings["type"] == 2: # fk/ik
# orientation
cns = loc.Kinematics.AddConstraint("Orientation",
self.fk_ctl[i])
cns = loc.Kinematics.AddConstraint("Orientation",
self.chain.bones[i])
par.addExpression(cns.Parameters("blendweight"),
self.pBlend.FullName)
# position / scaling
for s in "xyz":
par.addExpression(
loc.Kinematics.Local.Parameters("pos%s" % s),
self.fk_ctl[i].Kinematics.Local.Parameters(
"pos%s" % s).FullName + " * (1 - " +
self.pBlend.FullName + ") + " +
self.chain.bones[i].Kinematics.Local.Parameters(
"pos%s" % s).FullName + " * " +
self.pBlend.FullName)
par.addExpression(
loc.Kinematics.Local.Parameters("scl%s" % s),
self.fk_ctl[i].Kinematics.Local.Parameters(
"scl%s" % s).FullName + " * (1 - " +
self.pBlend.FullName + ") + " +
self.chain.bones[i].Kinematics.Local.Parameters(
"scl%s" % s).FullName + " * " +
self.pBlend.FullName)
# Default Values -----------------------------------
if self.isFkIk:
self.pBlend.Value = self.settings["blend"]
