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.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 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 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 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"]