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
