def sn_curveslide2_op(outcrv, incrv, position=0, maxstretch=1, maxsquash=1, softness=0): inlength = incrv.ActivePrimitive.Geometry.Length # Create Operator op = XSIFactory.CreateObject("sn_curveslide2_op") # IO op.AddIOPort(outcrv.ActivePrimitive) op.AddInputPort(incrv.ActivePrimitive) # Set default values op.Parameters("mstlength").Value = inlength op.Parameters("slvlength").Value = inlength op.Parameters("position").Value = position op.Parameters("maxstretch").Value = maxstretch op.Parameters("maxsquash").Value = maxsquash op.Parameters("softness").Value = softness # Connect op.Connect() return op
def gear_CreateSymmetryMappingTemplate_Execute(): if not xsi.Selection.Count: gear.log("No selection", gear.sev_error) return deformers = XSIFactory.CreateObject("XSI.Collection") deformers.Unique = True for sel in xsi.Selection: # Check input if sel.Type not in ["polymsh", "crvlist", "surfmsh"]: gear.log("Invalid selection", gear.sev_warning) continue # Get Envelope envelope_op = ope.getOperatorFromStack(sel, "envelopop") if not envelope_op: gear.log("There's no envelope on " + sel.Fullname, gear.sev_warning) continue deformers.AddItems(envelope_op.Deformers) if deformers.Count: env.createSymmetryMappingTemplate(deformers)
def sn_ik2bone_op(out=[], root=None, eff=None, upv=None, lengthA=5, lengthB=3, negate=False): # Create Operator op = XSIFactory.CreateObject("sn_ik2bone_op") # Outputs for i, s in enumerate(["OutBoneA", "OutBoneB", "OutCenterN", "OutEff"]): if len(out) > i and out[i] is not None: port = op.AddOutputPort(out[i].Kinematics.Global, s) # Inputs op.AddInputPort(root.Kinematics.Global) op.AddInputPort(eff.Kinematics.Global) op.AddInputPort(upv.Kinematics.Global) # Set default values op.Parameters("negate").Value = negate op.Parameters("lengthA").Value = lengthA op.Parameters("lengthB").Value = lengthB # Connect op.Connect() return op
def applyCurveResamplerOp(curve): op = XSIFactory.CreateObject("gear_CurveResamplerOp") op.AddIOPort(curve.ActivePrimitive) op.Connect() return op
def highlight(obj, branch=True): # save selection in order to retrieve it at the end selection = XSIFactory.CreateObject("XSI.Collection") selection.AddItems(xsi.Selection) pref = xsi.Dictionary.GetObject("Preferences") scene_color = dynDispatch(pref.NestedObjects("Scene Colors")) sel_color = scene_color.Parameters("selcol") inh_color = scene_color.Parameters("inhcol") selColor_value = sel_color.Value inhColor_value = inh_color.Value sel_color.Value = 16712703 inh_color.Value = 16712703 if branch: mode = "BRANCH" else: mode = "ASITIS" xsi.SelectObj(obj, mode) xsi.Refresh() time.sleep(.2) sel_color.Value = selColor_value inh_color.Value = inhColor_value # Retrieve selection xsi.SelectObj(selection)
def gear_SymmetrizePoints_Execute(): if not xsi.Selection.Count: gear.log("No selection", gear.sev_error) return pntSubComp = xsi.Selection(0) if pntSubComp.Type not in ["pntSubComponent"]: gear.log("Invalid Selection, need a pntSubComponent", gear.sev_error) return obj = pntSubComp.SubComponent.Parent3DObject # Get Symmetry Map ------------------- sym_map = uti.getSymmetryMap(obj) if not sym_map: gear.log("There is no symmetry map on selected object", gear.sev_error) return cls = obj.ActivePrimitive.Geometry.AddCluster( c.siVertexCluster, "gear_SymmetrizePointsOp_cls", pntSubComp.SubComponent.ElementArray) # Apply Operator ---------------------- op = XSIFactory.CreateObject("gear_SymmetrizePointsOp") op.AddIOPort(obj.ActivePrimitive) op.AddInputPort(sym_map) op.AddInputPort(cls) op.Connect() xsi.InspectObj(op) return op
def gear_Renamer_PreviewChain_OnClicked(): chain_objects = XSIFactory.CreateObject("XSI.Collection") chain_objects.Unique = True for sel in xsi.Selection: if sel.Type in ["root", "bone", "eff"]: if sel.Type == "root": chain_objects.Add(sel) chain_objects.AddItems(sel.Bones) chain_objects.Add(sel.Effector) else: chain_objects.Add(sel.Root) chain_objects.AddItems(sel.Root.Bones) chain_objects.Add(sel.Root.Effector) grid_data = PPG.PreviewGrid.Value grid_data.RowCount = chain_objects.Count for i in range(grid_data.RowCount): obj = chain_objects(i) new_name = renameChain(PPG, obj) grid_data.SetRowLabel(i, " " + str(i) + " ") grid_data.SetRowValues(i, [ obj.Model.FullName, obj.FullName[obj.FullName.find(".") + 1:], new_name ]) setRowColor(grid_data, i) PPG.Refresh()
def createMirrorCnxTemplate(model, in_controlers=None): cnx_prop = model.Properties(MIRROR_PROP_NAME) if not cnx_prop: cnx_prop = model.AddProperty("gear_Mirror", False, MIRROR_PROP_NAME) cnx_grid = cnx_prop.Parameters("CnxGridHidden").Value connections = par.getDictFromGridData(cnx_grid) if in_controlers is not None: controlers = XSIFactory.CreateObject("XSI.Collection") controlers.AddItems(in_controlers) cnx_grid.BeginEdit() pbar = uit.progressBar(controlers.Count, 1, "Creating Mirror Template", "", False) # Adding selected controlers to Connection map for ctl in controlers: pbar.StatusText = ctl.Name connections = addMirroringRule(ctl, cnx_grid, connections) pbar.Increment() pbar.Visible = False par.setDataGridFromDict(cnx_grid, connections) cnx_prop.Parameters("Count").Value = len(connections) cnx_grid.EndEdit() return cnx_grid
def setKey(controlers=xsi.Selection): if not controlers.Count: uit.msgBox("Nothing selected", c.siMsgExclamation, "Key Selection Failed") return False keyable_params = getKeyableParameters(controlers) if not keyable_params.Count: uit.msgBox("There is no keyable parameter on selection", c.siMsgExclamation, "Key Selection Failed") return False # Save Key playcontrol = xsi.GetValue("PlayControl") # Some Keyable display parameters (id) can be in the list, we need to remove them # or some parameters with expression on them itemsToRemove = XSIFactory.CreateObject("XSI.Collection") for param in keyable_params: if not param.Animatable or param.isAnimated(c.siExpressionSource): itemsToRemove.Add(param) if itemsToRemove.Count: keyable_params.RemoveItems(itemsToRemove) xsi.SaveKey(keyable_params, playcontrol.Parameters("Key").Value) return True
def createSymmetryMappingTemplate(in_deformers): deformers = XSIFactory.CreateObject("XSI.Collection") deformers.AddItems(in_deformers) temp_mesh = deformers(0).Model.AddGeometry("Sphere", "MeshSurface", "TempMesh") temp_mesh.ApplyEnvelope(deformers, False, False) # Create Mapping Template mapTemplate = xsi.CreateSymmetryMappingTemplate(temp_mesh, False, 0, False) for deformer in deformers: # Skip effectors if deformer.Type == "eff": continue sym_deformers = deformer.Model.FindChild( uti.convertRLName(deformer.Name)) if not sym_deformers or sym_deformers.IsEqualTo(deformer): continue xsi.AddMappingRule(mapTemplate, deformer.Name, sym_deformers.Name, xsi.GetNumMappingRules(mapTemplate)) xsi.DeleteObj(temp_mesh) return mapTemplate
def __init__(self, rig, guide): # -------------------------------------------------- # Main Objects self.rig = rig self.guide = guide self.options = self.rig.options self.model = self.rig.model self.settings = self.guide.values self.name = self.settings["comp_name"] self.side = self.settings["comp_side"] self.index = self.settings["comp_index"] # -------------------------------------------------- # Shortcut to useful settings self.size = self.guide.size self.color_fk = self.options[self.side + "_color_fk"] self.color_ik = self.options[self.side + "_color_ik"] self.negate = self.side == "R" if self.negate: self.n_sign = "-" self.n_factor = -1 else: self.n_sign = "" self.n_factor = 1 # -------------------------------------------------- # Builder init self.groups = {} ## Dictionary of groups self.controlers = [] ## List of all the controlers of the component self.inv_params = XSIFactory.CreateObject("XSI.Collection") if not self.settings["set_ctl_grp"] or (self.settings["set_ctl_grp"] and self.settings["ctl_grp"] == ""): self.settings["ctl_grp"] = "01" # -------------------------------------------------- # Property init self.anim_layout = ppg.PPGLayout() self.anim_logic = ppg.PPGLogic() self.setup_layout = ppg.PPGLayout() self.setup_logic = ppg.PPGLogic() self.ui = None # -------------------------------------------------- # Connector init self.connections = {} self.connections["standard"] = self.connect_standard self.relatives = {} # -------------------------------------------------- # Step self.stepMethods = [eval("self.step_0%s"%i) for i in range(len(self.steps))]
def twoPointsCns(obj, master0, master1, comp=False): masters = XSIFactory.CreateObject("XSI.Collection") masters.Add(master0) masters.Add(master1) cns = obj.Kinematics.AddConstraint("TwoPoints", masters, comp) return cns
def getAllControlers(): synoptic_prop = getSynoptic() controlers = XSIFactory.CreateObject("XSI.Collection") for group in getControlersGroups(): if synoptic_prop.Parameters(group.Name) and synoptic_prop.Parameters( group.Name).Value: controlers.AddItems(group.Members) return controlers
def gear_CopyWeights_Execute(): if not xsi.Selection.Count: gear.log("No selection", gear.sev_error) return sel = xsi.Selection(0) # Check input if sel.Type not in ["pntSubComponent"]: gear.log("Invalid selection", gear.sev_error) return obj = sel.SubComponent.Parent3DObject envelope_op = ope.getOperatorFromStack(obj, "envelopop") if not envelope_op: gear.log("There is no envelope on selected mesh", gear.sev_error) return cls = obj.ActivePrimitive.Geometry.AddCluster( c.siVertexCluster, "gear_CopyWeightsOp_Cls", sel.SubComponent.ElementArray) # Pick Session source_pnt = uit.pickSession(c.siPointFilter, "Pick Source Point", True) if not source_pnt: return points = source_pnt.SubComponent.ElementArray if len(points) != 1: gear.log("Please Select Only One Point", gear.sev_error) return # Need to find the cluster for port in envelope_op.InputPorts: if port.Target2.Type == "envweights": env_cls = port.Target2 if not env_cls: gear.log("Invalid Envelop, no cluster was found", gear.sev_error) return # Apply Operator ---------------------- op = XSIFactory.CreateObject("gear_CopyWeightsOp") op.AddIOPort(env_cls) op.AddInputPort(cls) op.Index = points[0] op.Connect() xsi.InspectObj(op) return op
def gear_CopyEnvWithGator_Execute(): # Check Selection if not xsi.Selection.Count: gear.log("No selection", gear.sev_error) return meshes = [] for item in xsi.Selection: if item.Type == "#Group": for member in item.Members: if member.Type == "polymsh": meshes.append(member) else: gear.log("Invalid Selection : %s" % member.FullName, gear.sev_warning) elif item.Type == "polymsh": meshes.append(item) else: gear.log("Invalid Selection : %s" % item.FullName, gear.sev_warning) if not meshes: gear.log("Invalid Selection", gear.sev_error) return # Pick Session for the sources source_meshes = XSIFactory.CreateObject("XSI.Collection") while True: picked = uit.pickSession(c.siGenericObjectFilter, "Pick Source Mesh", False) if not picked: break if picked.Type in ["#Group"]: for member in picked.Members: if ope.getOperatorFromStack(member, "envelopop"): source_meshes.AddItems(member) else: gear.log("No Envelope on " + member.Name, gear.sev_warning) else: if ope.getOperatorFromStack(picked, "envelopop"): source_meshes.Add(picked) else: gear.log("No Envelope on " + picked.Name, gear.sev_warning) if not source_meshes: gear.log("Invalid Picking", gear.sev_error) return # Process for mesh in meshes: env.copyEnvelopeWithGator(mesh, source_meshes)
def selectMulti(in_mousebutton, in_keymodifier, object_names, exclude=[]): # Right click - Do nothing if in_mousebutton == 2: return model = getModel() controlers = XSIFactory.CreateObject("XSI.Collection") # Get objects for name in object_names: children = model.FindChildren(name) if children.Count: controlers.AddItems(children) # Remove objects # As we can yuse symbol such as '*' in the name list we might need to filter the result for name in exclude: if model.Name + "." + name in controlers.GetAsText().split(","): controlers.RemoveItems(model.Name + "." + name) if not controlers.Count: gear.log("Can't Find Controlers : " + ",".join(object_names), sn.sev_siError) return # Key pressed ======================================= if in_keymodifier == 0: # No Key or No Valid Key xsi.SelectObj(controlers) elif in_keymodifier == 1: # Shift check the object isn't already selected try: xsi.AddToSelection(controlers) except: return elif in_keymodifier == 2: # Ctrl xsi.ToggleSelection(controlers) elif in_keymodifier == 3: # Shift+Ctrl xsi.RemoveFromSelection(controlers) elif in_keymodifier == 4: # Alt xsi.SelectObj(controlers, "BRANCH", True) elif in_keymodifier == 5: # Alt+Shift check the object isn't already selected try: xsi.AddToSelection(controlers, "BRANCH", True) except: return elif in_keymodifier == 6: # Alt+Ctrl xsi.ToggleSelection(controlers, "BRANCH", True) elif in_keymodifier == 7: # Alt+Shift+Ctrl xsi.RemoveFromSelection(controlers)
def applyScaleShapeOp(shape, points): mesh = shape.Parent3DObject cls = mesh.ActivePrimitive.Geometry.AddCluster(c.siVertexCluster, "gear_ScaleShapeOp_Cls", points) # Apply Operator op = XSIFactory.CreateObject("gear_ScaleShapeOp") op.AddIOPort(shape) op.AddInputPort(cls) op.Connect(None, c.siConstructionModeModeling) return op
def sn_curvelength_op(out, crv): # Create Operator op = XSIFactory.CreateObject("sn_curvelength_op") # Output op.AddOutputPort(out) # Input op.AddInputPort(crv.ActivePrimitive) # Connect op.Connect() return op
def sn_stretchChainMulti_op(root, ik_ctl): op = XSIFactory.CreateObject("sn_stretchChainMulti_op") for bone in root.Bones: op.Parameters("restlength").Value += bone.Length.Value op.AddOutputPort(root.Effector.Kinematics.Global) op.AddOutputPort(root.Bones(0).Kinematics.Local.Parameters("sclx")) op.AddInputPort(root.Kinematics.Global) op.AddInputPort(ik_ctl.Kinematics.Global) op.Connect() return op
def gear_MirrorAnimation_Execute(): if not xsi.Selection.Count: gear.log("No selection", gear.sev_error) return controlers = XSIFactory.CreateObject("XSI.Collection") controlers.AddItems(xsi.Selection) # Get First and Last Frame frames = fcv.getFirstAndLastKey(controlers) if not frames: gear.log("No Key on selection, cannot perform mirror animation", gear.sev_error) return # UI ui_prop = xsi.ActiveSceneRoot.AddProperty("CustomProperty", False, "Mirror Animation") pOffset = ui_prop.AddParameter3("offset", c.siInt4, 0, None, None, False, False) pConsiderTime = ui_prop.AddParameter3("considerTime", c.siBool, False, None, None, False, False) pFrameIn = ui_prop.AddParameter3("frameIn", c.siInt4, frames[0], None, None, False, False) pFrameOut = ui_prop.AddParameter3("frameOut", c.siInt4, frames[1], None, None, False, False) layout = ui_prop.PPGLayout layout.AddGroup("Options") layout.AddItem(pOffset.ScriptName, "Offset") layout.AddItem(pConsiderTime.ScriptName, "Consider Time") layout.AddRow() layout.AddItem(pFrameIn.ScriptName, "Frame In") layout.AddItem(pFrameOut.ScriptName, "Frame Out") layout.EndRow() layout.EndGroup() rtn = xsi.InspectObj(ui_prop, "", "Mirror Animation", c.siModal, False) frame_offset = pOffset.Value considerTime = pConsiderTime.Value frame_in = pFrameIn.Value frame_out = pFrameOut.Value xsi.DeleteObj(ui_prop) if rtn: return # Mirror ani.mirror(controlers, True, frame_offset, considerTime, frame_in, frame_out) return
def addMirroringRule(ctl, cnx_grid, inversed_params=[], delUnused=False): model = ctl.Model # I want to get all the keyable parameters for this object and the easiest way # is to use the FindObjectsByMarkingAndCapabilities() method # but it only applies on collection controlers = XSIFactory.CreateObject("XSI.Collection") controlers.Add(ctl) key_params = controlers.FindObjectsByMarkingAndCapabilities(None, 2048) # try to find the mirror object mirror_ctl = model.FindChild(uti.convertRLName(ctl.Name)) connections = par.getDictFromGridData(cnx_grid) for param in key_params: # Skip marking set to avoid having all the params twice if param.Parent.Name == "MarkingSet" or param.Parent.Name.startswith( "DisplayInfo"): continue fullName = param.FullName[param.FullName.find(".") + 1:] # If the object mirror on itself, try to find R and L parameters if not mirror_ctl or mirror_ctl.IsEqualTo(ctl): mirror_param = param.Parent.Parameters( uti.convertRLName(param.Name)) if mirror_param: mirror_fullName = mirror_param.FullName[mirror_param.FullName. find(".") + 1:] else: mirror_fullName = fullName else: mirror_fullName = fullName.replace(ctl.Name, mirror_ctl.Name) if delUnused and (fullName == mirror_fullName and not param.FullName in inversed_params): continue connections[fullName] = [ mirror_fullName, param.FullName in inversed_params ] par.setDataGridFromDict(cnx_grid, connections) return connections
def sn_interpose_op(out, objA, objB): # Create Operator op = XSIFactory.CreateObject("sn_interpose_op") # Outputs op.AddOutputPort(out.Kinematics.Global.FullName) # Inputs op.AddInputPort(objA.Kinematics.Global.FullName) op.AddInputPort(objB.Kinematics.Global.FullName) # Connect op.Connect() return op
def getOperatorFromStack(obj, opType, firstOnly=True): operators = XSIFactory.CreateObject("XSI.Collection") for nested in obj.ActivePrimitive.NestedObjects: if nested.IsClassOf(c.siOperatorID): if nested.Type == opType: if firstOnly: return nested else: operators.Add(nested) if operators.Count: return operators return False
def gear_MatchGeometry_Execute(): if not xsi.Selection.Count: gear.log("No selection", gear.sev_error) return target = xsi.Selection(0) if target.Type not in ["pntSubComponent", "polymsh", "surfmsh", "crvlist"]: gear.log("Invalid Selection, select a geometry or a point selection", gear.sev_error) return # Get reference source = uit.pickSession(c.siGenericObjectFilter, "Pick Source Geometry") if not source: return # Get cluster if target.Type == "pntSubComponent": obj = target.SubComponent.Parent3DObject cls = obj.ActivePrimitive.Geometry.AddCluster( c.siVertexCluster, "gear_MatchGeometryOp_cls", target.SubComponent.ElementArray) else: obj = target cls = obj.ActivePrimitive.Geometry.AddCluster( c.siVertexCluster, "gear_MatchGeometryOp_cls") if source.Type != obj.Type: gear.log("Invalid Selection", gear.sev_error) xsi.DeleteObj(cls) return # Apply Operator op = XSIFactory.CreateObject("gear_MatchGeometryOp") op.AddIOPort(obj.ActivePrimitive) op.AddInputPort(source.ActivePrimitive) op.AddInputPort(cls) op.AddInputPort(obj.Kinematics.Global) op.AddInputPort(source.Kinematics.Global) op.Connect() xsi.InspectObj(op) return op
def sn_rotspring_op(out): # Create Operator op = XSIFactory.CreateObject("sn_rotspring_op") # Outputs op.AddOutputPort(out.Kinematics.Global) # Inputs op.AddInputPort(out.Parent3DObject.Kinematics.Global) # Connect op.Connect() par.addExpression(op.Parameters("fc"), "fc") return op
def sn_inverseRotorder_op(out_obj, in_obj): # Create Operator op = XSIFactory.CreateObject("sn_inverseRotorder_op") # Output op.AddOutputPort(out_obj.Kinematics.Local.Parameters("rotorder")) # Input # Connect op.Connect() par.addExpression(op.Parameters("rotorder"), in_obj.Kinematics.Local.Parameters("rotorder").FullName) return op
def sn_curveslide_op(crv): length = crv.ActivePrimitive.Geometry.Length # Create Operator op = XSIFactory.CreateObject("sn_curveslide_op") # IO op.AddIOPort(crv.ActivePrimitive) # Set default values op.Parameters("length").Value = length # Connect op.Connect() return op
def gear_NormalizeToDeformer_Execute(): if not xsi.Selection.Count: gear.log("No selection", gear.sev_error) return sel = xsi.Selection(0) if sel.Type in ["polymsh", "surfmsh", "crvlist"]: mesh = sel points = range(mesh.ActivePrimitive.Geometry.Points.Count) elif sel.Type == "pntSubComponent": mesh = sel.SubComponent.Parent3DObject points = sel.SubComponent.ElementArray else: gear.log("Invalid selection", gear.sev_error) return # Get Envelope from object envelope_op = ope.getOperatorFromStack(mesh, "envelopop") if not envelope_op: gear.log("There is no envelope on selected mesh", gear.sev_error) return # Get The deformers deformers = XSIFactory.CreateObject("XSI.Collection") while True: deformer = uit.pickSession(c.siGenericObjectFilter, "Pick Deformer", False) if not deformer: break if env.isDeformer(envelope_op, deformer): deformers.Add(deformer) else: gear.log("Picked object is not a deformer for this envelope", c.siWarning) if not deformers.Count: return # Process env.normalizeToDeformer(envelope_op, deformers, points) env.freezeEnvelope(envelope_op) env.rebuiltEnvelope(envelope_op)
def sn_xfspring_op(out, mode=2): # Create Operator op = XSIFactory.CreateObject("sn_xfspring_op") # Outputs op.AddOutputPort(out.Kinematics.Global) # Inputs op.AddInputPort(out.Parent3DObject.Kinematics.Global) # Set default values op.Parameters("mode").Value = mode # Connect op.Connect() par.addExpression(op.Parameters("fc"), "fc") return op
def sn_stretchChain_op(root, ik_ctl): op = XSIFactory.CreateObject("sn_stretchChain_op") op.Parameters("rest0").Value = root.Bones(0).Length.Value op.Parameters("rest1").Value = root.Bones(1).Length.Value op.Parameters("prefrot").Value = root.Bones(1).Properties( "Kinematic Joint").Parameters("prefrotz").Value op.AddOutputPort(root.Effector.Kinematics.Global) op.AddOutputPort(root.Bones(0).Length) op.AddOutputPort(root.Bones(1).Length) op.AddOutputPort( root.Bones(1).Properties("Kinematic Joint").Parameters("prefrotz")) op.AddInputPort(root.Kinematics.Global) op.AddInputPort(ik_ctl.Kinematics.Global) op.Connect() return op