def sn_rollsplinekine_op(out, ctrl=[], u=.5):
# Create Operator
op = XSIFactory.CreateObject("sn_rollsplinekine_op")
# Outputs
op.AddOutputPort(out.Kinematics.Global)
# Inputs
for obj in ctrl:
op.AddInputPort(obj.Parent.Kinematics.Global)
op.AddInputPort(obj.Kinematics.Local)
op.AddInputPort(ctrl[0].Parent.Kinematics.Global)
# Set default values
op.Parameters("count").Value = len(ctrl)
op.Parameters("u").Value = u
op.Parameters("resample").Value = True
# Connect
op.Connect()
return op
def gear_dualUpVDirCns(cns, ref, target, negate=False):
# -----------------------------------------------------
# JSCRIPT
paramDefs = []
paramDefs.append(
XSIFactory.CreateParamDef("negate", c.siBool, 0,
c.siPersistable | c.siAnimatable, "", "",
negate))
outputPorts = [(cns.Kinematics.Global, "out")]
inputPorts = [(cns.Kinematics.Global, "kcns"),
(ref.Kinematics.Global, "kref"),
(target.Kinematics.Global, "ktar")]
op = createJSOpFromFile("gear_dualUpVDirCns",
os.path.join(JSOPPATH, "gear_dualUpVDirCns_op.js"),
outputPorts, inputPorts, paramDefs)
# Connect
op.Connect()
return op
def sn_interLocalOri_op(out, refA, refB, blend=0):
# Create Operator
op = XSIFactory.CreateObject("sn_interLocalOri_op")
# Outputs
for s in ["rotx", "roty", "rotz", "nrotx", "nroty", "nrotz"]:
op.AddOutputPort(out.Parameters(s), s)
# Inputs
op.AddInputPort(refA.Kinematics.Global)
op.AddInputPort(refB.Kinematics.Global)
op.AddInputPort(out.Parent.Kinematics.Global)
op.AddInputPort(refA.Parameters("rotx"))
op.AddInputPort(refB.Parameters("rotx"))
# Set default values
op.Parameters("blend").Value = blend
# Connect
op.Connect()
return op
def gear_CopyEnvWithGator_Execute():
if not xsi.Selection.Count:
gear.log("No selection", gear.sev_error)
return
source_meshes = XSIFactory.CreateObject("XSI.Collection")
while True:
picked = uit.pickSession(c.siGeometryFilter, "Pick Source Mesh", False)
if not picked:
break
if not ope.getOperatorFromStack(picked, "envelopop"):
gear.log("No Envelope on " + picked.Name, c.siWarning)
continue
source_meshes.Add(picked)
if not source_meshes:
return
for mesh in xsi.Selection:
env.copyEnvelopeWithGator(mesh, source_meshes)
def removeEnvDeformer(envelope_op, obj):
mesh = envelope_op.Parent3DObject
points = mesh.ActivePrimitive.Geometry.Points
point_count = points.Count
deformers = envelope_op.Deformers
deformer_count = deformers.Count
index = 0
weights_tuple = envelope_op.Weights.Array
weights = [
weights_tuple[j][i] for i in range(len(weights_tuple[0]))
for j in range(len(weights_tuple))
]
new_deformers = XSIFactory.CreateObject("XSI.Collection")
# Process
for deformer_index, deformer in enumerate(deformers):
if obj.FullName == deformer.FullName:
index = deformer_index
else:
new_deformers.add(deformer)
newWeight = []
for point_index in range(point_count):
newWeight.extend(
weights[point_index * deformer_count:point_index * deformer_count +
index])
newWeight.extend(
weights[point_index * deformer_count + index +
1:point_index * deformer_count + deformer_count])
# Delete the old Envelope and add the new one with the new Deformers
xsi.RemoveFlexEnv(mesh)
envelope_op = mesh.ApplyEnvelope(new_deformers)
envelope_op.Weights.Array = newWeight
return envelope_op
def gear_RemoveUnusedEnvCls_Execute():
# This method is named based and doesn't provide a perfect result but should work in most of the case.
# Return All the Pnt Cluster from the active scene
point_clusters = xsi.FindObjects(None,
"{E4DD8E40-1E1C-11D0-AA2E-00A0243E34C4}")
# Search for unused EnvelopWeightCls
delete_objs = XSIFactory.CreateObject("XSI.Collection")
for cls in point_clusters:
if cls.Name.startswith("EnvelopWeightCls"):
delete = True
for prop in cls.Properties:
if prop.Type == "envweights":
delete = False
if delete:
delete_objs.Add(cls)
# Delete
if delete_objs.Count:
xsi.DeleteObj(delete_objs)
def select(in_mousebutton, in_keymodifier, name=None):
model = getModel()
if name is None:
ctl = model
else:
ctl = model.FindChild(name)
# Check if the object exists
if not ctl:
gear.log("Can't Find object : " + name, gear.sev_warning)
return
# Create Collection for different selection mode
controlers = XSIFactory.CreateObject("XSI.Collection")
# Mouse button ======================================
# Left Clic - Simple select
if in_mousebutton == 0:
controlers.Add(ctl)
# Middle Clic - Select in 'branch'
elif in_mousebutton == 1:
controlers.Add(ctl)
# Get all controlers of the model
controlers_filtered = []
for group in getControlersGroups():
controlers_filtered.extend(group.Members.GetAsText().split(","))
# First Method, Try to find controlers of the same 'kind'
# Find controler index
has_index = False
sIndex = re.search("[0-9]+_ctl$", ctl.Name)
if sIndex:
index = int(sIndex.group(0)[:-4])
has_index = True
# Try to find child of the same 'type'
if has_index and controlers_filtered:
while True:
index += 1
next_name = re.sub("[0-9]+_ctl$",
str(index) + "_ctl", ctl.Name)
if model.Name + "." + next_name not in controlers_filtered:
break
controlers.Add(model.FindChild(next_name))
# Second Method if no child found
# we get all controlers children of selected one
if controlers.Count == 1 and controlers_filtered:
for child in ctl.FindChildren():
if child.FullName in controlers_filtered:
controlers.Add(child)
# Right Clic - Do nothing
elif in_mousebutton == 2:
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 getKeyableParameters(in_controlers):
# We make sure input is a collection (next method doesn't work with selection)
controlers = XSIFactory.CreateObject("XSI.Collection")
controlers.AddItems(in_controlers)
return controlers.FindObjectsByMarkingAndCapabilities(None, 2048)
def mirror(controlers=xsi.Selection,
animation=False,
frame_offset=0,
considerTime=False,
frame_in=0,
frame_out=0):
if not animation:
source_type = 1
considerTime = False
frame_offset = 0
else:
source_type = 6
params = getKeyableParameters(controlers)
# Avoid having the parameter and its proxy in the collection
# Curiosly, XSI can store the fcurves of the parameter and its proxy separatly
# We get weird result when applying the action
key_params = XSIFactory.CreateObject("XSI.Collection")
key_params.Unique = True
for param in params:
if param.Type == "ProxyParameter":
key_params.Add(param.MasterParameter)
else:
key_params.Add(param)
if not key_params.Count:
gear.log("No Keyable Parameter on Selection", gear.sev_error)
return
# Get all keys if considerTime is False
if not considerTime and animation:
frame_in, frame_out = fcu.getFirstAndLastKey(controlers)
# Get Connexion Map --------------------
model = controlers(0).Model
cnx_prop = model.Properties(MIRROR_PROP_NAME)
if not cnx_prop:
gear.log("There is no Mirror Cnx Template on this model",
gear.sev_error)
return
cnx_grid = cnx_prop.Parameters("CnxGridHidden").Value
connections = par.getDictFromGridData(cnx_grid)
# Actions ------------------------------
# Store the Action
if model.Sources("Temp_MirrorAction"):
xsi.DeleteObj(model.Sources("Temp_MirrorAction"))
action = xsi.StoreAction(model, key_params, source_type,
"Temp_MirrorAction", False, frame_in, frame_out,
considerTime, False, False, False)
# Edit the stored Action
for item in action.SourceItems:
# skip sourceItems if not listed in the CnxMap
if item.Target not in connections:
continue
# Change the target to mirror action
target = connections[item.Target]
item.Target = target[0]
# Inverse the value of fcurve if necessary
# The string version is to keep compatibility with previous version of XSI
# When the gridata was only returning string
if target[1] in [True, "True"]:
invertSource(item.Source)
xsi.ApplyAction(action, model, True, frame_in + frame_offset,
frame_out + frame_offset, False)
xsi.DeleteObj(action)
return
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 pruneWeights(envelope_op,
points=None,
threshold=.1,
remove=False,
showPBar=False):
# Get weights array
mesh = envelope_op.Parent3DObject
point_count = mesh.ActivePrimitive.Geometry.Points.Count
weights_tuple = envelope_op.Weights.Array
weights = [
weights_tuple[j][i] for i in range(len(weights_tuple[0]))
for j in range(len(weights_tuple))
]
deformer_count = envelope_op.Deformers.Count
used_deformers = XSIFactory.CreateObject("XSI.Collection")
used_deformers.Unique = True
if points is None:
points = range(point_count)
if showPBar:
pbar = uit.progressBar(
len(points), 1,
str(len(points)) + " points to prune on : " + mesh.Name, "0",
False)
# Prune Weights
pointsToNormalize = []
for point_index in points:
if showPBar:
pbar.StatusText = point_index
for deformer_index, deformer in enumerate(envelope_op.Deformers):
if weights[point_index * deformer_count +
deformer_index] <= threshold:
weights[point_index * deformer_count + deformer_index] = 0
if not point_index in pointsToNormalize:
pointsToNormalize.append(point_index)
else:
used_deformers.Add(deformer)
if showPBar:
pbar.Increment()
if showPBar:
pbar.Visible = False
# Normalize points
envelope_op.Weights.Array = weights
normalizeWeights(envelope_op, pointsToNormalize)
freezeEnvelope(envelope_op)
# Rebuilt Envelope ------------------------------------------------
# If True, we rebuilt the envelope a first time without the unused deformers
if remove:
gear.log("There is " +
str(envelope_op.Deformers.Count - used_deformers.Count) +
" deformers that will be removed")
path = XSIUtils.ResolvePath("Temp")
preset_name = mesh.Name + "_Weights"
env_prop = envelope_op.PortAt(4, 0, 0).Target2
xsi.SavePreset(env_prop, preset_name, path, None, 1, None, None)
xsi.RemoveFlexEnv(mesh)
envelope_op = mesh.ApplyEnvelope(used_deformers)
env_prop = envelope_op.PortAt(4, 0, 0).Target2
xsi.LoadPreset(path + "/" + preset_name, env_prop)
# Rebuilt the envelope to get the correct colors and normalisation warning
envelope_op = rebuiltEnvelope(envelope_op)
return envelope_op
def sn_ikfk2bone_op(out=[],
root=None,
eff=None,
upv=None,
fk0=None,
fk1=None,
fk2=None,
lengthA=5,
lengthB=3,
negate=False,
blend=0,
lang=CPP):
# -----------------------------------------------------
if lang == CPP:
# Create Operator
op = XSIFactory.CreateObject("sn_ikfk2bone_op")
# Outputs
for i, s in enumerate(["OutBoneA", "OutBoneB", "OutCenterN",
"OutEff"]):
if len(out) > i and out[i] is not None:
op.AddOutputPort(out[i].Kinematics.Global, s)
# Inputs
op.AddInputPort(root.Kinematics.Global)
op.AddInputPort(eff.Kinematics.Global)
op.AddInputPort(upv.Kinematics.Global)
op.AddInputPort(fk0.Kinematics.Global)
op.AddInputPort(fk1.Kinematics.Global)
op.AddInputPort(fk2.Kinematics.Global)
# -----------------------------------------------------
elif lang == JSCRIPT:
paramDefs = []
paramDefs.append(
XSIFactory.CreateParamDef("lengthA", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
3, 0, None, 0, 10))
paramDefs.append(
XSIFactory.CreateParamDef("lengthB", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
5, 0, None, 0, 10))
paramDefs.append(
XSIFactory.CreateParamDef("negate", c.siBool, 0,
c.siPersistable | c.siAnimatable, "", "",
False))
paramDefs.append(
XSIFactory.CreateParamDef("blend", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
0, 0, 1, 0, 1))
paramDefs.append(
XSIFactory.CreateParamDef("roll", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
0, -360, 360, -360, 360))
paramDefs.append(
XSIFactory.CreateParamDef("scaleA", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
1, 0, None, 0, 2))
paramDefs.append(
XSIFactory.CreateParamDef("scaleB", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
1, 0, None, 0, 2))
paramDefs.append(
XSIFactory.CreateParamDef("maxstretch", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
1, 1, None, 1, 2))
paramDefs.append(
XSIFactory.CreateParamDef("softness", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
0, 0, None, 0, 1))
paramDefs.append(
XSIFactory.CreateParamDef("slide", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
0.5, 0, 1, 0, 1))
paramDefs.append(
XSIFactory.CreateParamDef("reverse", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
0, 0, 1, 0, 1))
outputPorts = [(out[i].Kinematics.Global, name)
for i, name in enumerate(
["OutBoneA", "OutBoneB", "OutCenterN", "OutEff"])
if (len(out) > i and out[i] is not None)]
inputPorts = [(obj.Kinematics.Global, "input_%s" % i)
for i, obj in enumerate([root, eff, upv, fk0, fk1, fk2])]
op = createJSOpFromFile("sn_ikfk2bone_op",
os.path.join(JSOPPATH, "sn_ikfk2bone_op.js"),
outputPorts, inputPorts, paramDefs)
# -----------------------------------------------------
# Set default values
op.Parameters("negate").Value = negate
op.Parameters("lengthA").Value = lengthA
op.Parameters("lengthB").Value = lengthB
op.Parameters("blend").Value = blend
# Connect
op.Connect()
return op
def sn_curveslide2_op(outcrv,
incrv,
position=0,
maxstretch=1,
maxsquash=1,
softness=0,
lang=CPP):
inlength = incrv.ActivePrimitive.Geometry.Length
# CPP -----------------------------------------------
if lang == CPP:
# 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()
# JSCRIPT -------------------------------------------
elif lang == JSCRIPT:
paramDefs = []
paramDefs.append(
XSIFactory.CreateParamDef("mstlength", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
inlength, 0, None, inlength * .5,
inlength * 2))
paramDefs.append(
XSIFactory.CreateParamDef("slvlength", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
inlength, 0, None, inlength * .5,
inlength * 2))
paramDefs.append(
XSIFactory.CreateParamDef("position", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
position, 0, 1, 0, 1))
paramDefs.append(
XSIFactory.CreateParamDef("maxstretch", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
maxstretch, 0, None, 0, 3))
paramDefs.append(
XSIFactory.CreateParamDef("maxsquash", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
maxsquash, 0, 1, 0, 1))
paramDefs.append(
XSIFactory.CreateParamDef("softness", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "",
softness, 0, 1, 0, 1))
outputPorts = [(outcrv.ActivePrimitive, "out")]
inputPorts = [(outcrv.ActivePrimitive, "in_crv"),
(incrv.ActivePrimitive, "ref_crv")]
op = createJSOpFromFile(
"gear_curveslide2", os.path.join(JSOPPATH,
"gear_curveslide2_op.js"),
outputPorts, inputPorts, paramDefs)
op.Connect()
layout = op.PPGLayout
layout.Clear()
layout.AddGroup("Default")
layout.AddItem("slvlength", "Slave Length")
layout.AddItem("mstlength", "Master Length")
layout.EndGroup()
layout.AddGroup("Animate")
layout.AddItem("position", "Position")
layout.AddItem("maxstretch", "Max Stretch")
layout.AddItem("maxsquash", "Max Squash")
layout.AddItem("softness", "Softness")
layout.EndGroup()
return op
def gear_zipper_op(crv0, crv1):
# -----------------------------------------------------
# JSCRIPT
paramDefs = []
paramDefs.append(
XSIFactory.CreateParamDef("zip", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "", 0,
0, 1, 0, 1))
paramDefs.append(
XSIFactory.CreateParamDef("bias", c.siDouble, 0,
c.siPersistable | c.siAnimatable, "", "", .5,
0, 1, 0, 1))
paramDefs.append(XSIFactory.CreateFCurveParamDef("start_fcv"))
paramDefs.append(XSIFactory.CreateFCurveParamDef("speed_fcv"))
outputPorts = [(crv0.ActivePrimitive, "out_0"),
(crv1.ActivePrimitive, "out_1")]
inputPorts = [(crv0.ActivePrimitive, "crv0"),
(crv1.ActivePrimitive, "crv1")]
op = createJSOpFromFile("gear_zipper",
os.path.join(JSOPPATH, "gear_zipper_op.js"),
outputPorts, inputPorts, paramDefs)
op.Connect()
# FCurve profile
fcv.drawFCurve(
op.Parameters("start_fcv").Value, [[0, 0], [1, 1]],
c.siLinearKeyInterpolation)
fcv.drawFCurve(
op.Parameters("speed_fcv").Value, [[0, 0], [1, 1]],
c.siLinearKeyInterpolation)
# Layout
layout = op.PPGLayout
layout.Clear()
layout.AddGroup("Zipper")
layout.AddItem("Mute", "Mute")
layout.AddItem("zip", "Zip")
layout.AddItem("bias", "Bias")
layout.EndGroup()
layout.AddGroup("Profile")
item = layout.AddFCurve("start_fcv")
item.SetAttribute(c.siUIFCurveLabelX, "Points")
item.SetAttribute(c.siUIFCurveLabelY, "Start")
item.SetAttribute(c.siUIFCurveViewMinX, -.1)
item.SetAttribute(c.siUIFCurveViewMaxX, 1.1)
item.SetAttribute(c.siUIFCurveViewMinY, -.1)
item.SetAttribute(c.siUIFCurveViewMaxY, 1.1)
item.SetAttribute(c.siUIFCurveGridSpaceX, .1)
item.SetAttribute(c.siUIFCurveGridSpaceY, .1)
layout.EndGroup()
layout.AddGroup("Speed")
item = layout.AddFCurve("speed_fcv")
item.SetAttribute(c.siUIFCurveLabelX, "Points")
item.SetAttribute(c.siUIFCurveLabelY, "Speed")
item.SetAttribute(c.siUIFCurveViewMinX, -.1)
item.SetAttribute(c.siUIFCurveViewMaxX, 2.1)
item.SetAttribute(c.siUIFCurveViewMinY, -.1)
item.SetAttribute(c.siUIFCurveViewMaxY, 1.1)
item.SetAttribute(c.siUIFCurveGridSpaceX, .1)
item.SetAttribute(c.siUIFCurveGridSpaceY, .1)
layout.EndGroup()
return op
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 gear_ReplaceDeformer_Execute():
if not xsi.Selection.Count:
gear.log("No selection", gear.sev_error)
return
sel = xsi.Selection(0)
if sel.Type == "polymsh":
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 False
# Source deformers
source_deformers = XSIFactory.CreateObject("XSI.Collection")
while True:
picked = uit.pickSession(c.siGenericObjectFilter,
"Pick Source Deformers", False)
if not picked:
break
if picked.Type == "#Group":
source_deformers.AddItems(picked.Members)
else:
source_deformers.Add(picked)
if not source_deformers.Count:
return False
# Target deformers
target_deformers = XSIFactory.CreateObject("XSI.Collection")
while True:
picked = uit.pickSession(c.siGenericObjectFilter,
"Pick Target Deformers", False)
if not picked:
break
if picked.Type == "#Group":
target_deformers.AddItems(picked.Members)
else:
target_deformers.Add(picked)
if not target_deformers.Count:
return False
# Some log to be sure of what we have selected
gear.log("Geometry: " + mesh.FullName + " \nSource(s): " +
str(source_deformers) + " \nTarget(s): " + str(target_deformers))
env.replaceDeformerInEnvelope(envelope_op, source_deformers,
target_deformers, points)
