Here’s some of my observations with them in the context of artists animating a referenced rig in production:

• StoredExpressions doesn’t always store expressions. They actually show up in StoredPositions almost every time you touch something with an expression. They often also break / stop evaluating when this happens. (They often get stored even when you disable storing of expressions in your Delta, but it’s hard to repro.)
   
• StoredPositions remembers transforms by the mere act of selecting and having translate/rotate/scale tool active. While not exactly a bug, it easily causes problems if you edit centers later on, because the transforms get remembered and so it causes a wacky offset.
  Stuff can exist in both StoredPositions and StoredFCurves but it shouldn’t. If it’s keyed/animated, keys take priority, which means you got redundant junk in StoredPositions. XSI won’t remove the StoredPositions entry when setting a key (which makes a StoredFCurves entry.)
   
• StoredPositions will (from time to time) remember changes to a referenced material’s parameters. This combines with the annoyance of updating a material later and having old values mysteriously enforced on it because they were in StoredPositions and shared the same names. (Maybe a better name is “StoredValues”, since it stores more than positions.)
   
• Generally rigs don’t come preanimated so there’s no point for “StoredRemoveAnimations” to exist. It gets created whenever you remove keys from something in the rig.
   
• StoredConstraints remembers constraint relations by explicit naming. Sometimes these don’t update when the objects name changes, and sometimes they do.
  So say if you constrain an arm of the referenced character rig to a null you just made, THEN rename the null, there’s a very high chance when you save and reopen the constraint won’t be connected, since it will be expecting the original null name. The good news is you can open the Delta in an Explorer, doubleclick the StoredConstraints subproperty and rename the object names in each row to whatever are the correct ones.
   
• Whenever you edit contents of a Delta by hand and want to see the updated result, you must rightclick on the referenced model in an Explorer and “Update Referenced Model.”
   
• You need a Delta per model… and in the case of having a rig with one or more models inside it, this rule still applies.
   
• Just because a Delta sits below a model that doesn’t necessarily mean that is the model it’s working on. It’s actually working on whatever its “Target” parameter specifies.
   
• If “Record” isn’t ON (in the Delta’s PPG) before you make changes, they don’t get saved. End of story. — Turning it on after doing changes won’t save your ass. (Good thing it’s on by default, eh?)
   
• If you have a convoluted/complex rig that crashes when you do “Update Reference Model” or when simply offloading, but works fine otherwise… if you need to update the refmodel path, you can do this without opening your scene by editing the relevant scntoc file and then when you open your scene it’ll be path you wanted.
   
• When you duplicate a material from a referenced model, it duplicates fine EXCEPT for the image clips/sources, which stay referenced and when you reopen the scene, they will have dissapeared.
   
• Using Animation Layers with referenced models is not to be trusted. [*update*: Steven Caron from Blur Studios has noted that as of Soft 2010 SP1, animation layers work fine with referenced models. Beware if you are using a previous version.]
  If you use them, always open the scene you just saved in a new XSI without closing the first one so you can check that when it opens all the animation is still there and works properly. (I haven’t confirmed, but I believe I read on the mailing list that you can collapse animation layers before you save and then it’s okay.)
   
• Someone on the Softimage mailing list mentioned once that only the first Delta for a particular model remembers Mixer stuff like actionclips and such, regardless of what you set. Good to bare in mind.

At work I made two relatively simple scripts that help us with refmodel woes. I’d like to share them with you:

This really simple script imports a refmodel, make a fresh empty delta for it (and extra Deltas for any models in it) and sets these defaults automatically:

• Static Pos and Other Parameters ON
• FCurves ON
• Expressions OFF
• Constraints ON
• Animation Mixer ON
• Group Relations ON
  (this stores partitions relationships so it’s very important!)
• Model Instances OFF
  (could be left ON if you need it)
• External Connections ON
  (this remembers stuff like constraining something in the refmodel to an external object)
• New Properties OFF
• Clusters OFF
• Cluster Properties OFF
• Operators OFF

then in Mixer Modifications:

• Animation ON
• Shapes OFF
• Audio ON
• Cache ON

These are the ideal settings for using a referenced model to move/animate it, put it in partitions/groups/layers and render.

Download the AF_ImportRefModelForAnimation.py Python script here. Make it into a button or incorporate it into your workflow tools if you have any.

“Clean Delta”:
It deletes stuff from a Delta that shouldn’t be there if you just wanted to animate and render a referenced rig or model. See the code for more specifics.

Download the AF_DeltaCleaner.py Python script here and run it from a button with refmodels selected. I’ve left plenty of code comments to make sense of what it does. I urge you to read them.

I hope these scripts assist you in having a more pleasant experience with referenced models. They’re actually quite wonderful after you learn their quirks.

If anyone has anything else to say about deltas, modifications, suggestions, code improvements, constructive critique, cheese and monkeys, etc. please leave a comment. Thank you.

The following Python script iterates through your selected enveloped objects, creates SymmetryMaps if one doesn’t exist, and then goes through their envelope deformers and appends them to the SymmetryMappingTemplate for that model based on the naming convention of prefixing “L_” for left-side and “R_” for right-side objects.

It assumes the following: (and maybe in the future I’ll make the code smarter…)
- Your selected objects all have envelopes.
- Your left-side objects begin with “L_” and the right-side with “R_”.
- All your selected objects belong to the same Model.
- That you don’t have more than one SymmetryMappingTemplate under your model. (It will append to the first one found under the model, and create one if one isn’t found.) I recommend not having one to start with.

Make yourself a button with this:

xsi = Application
lm = xsi.LogMessage
from win32com.client import constants as c
import win32com.client
 
objects = win32com.client.Dispatch( "XSI.Collection" )
objects.AddItems(xsi.Selection)
 
# Iterate through selection
for envObj in objects:
	lm( "Iterating through: "+envObj.FullName, c.siVerbose )
 
	# Create a SymmetryMappingTemplate if needed.
	oSymmetryMapTemplate = xsi.Dictionary.GetObject( envObj.Model.Name+".SymmetryMappingTemplate", False )
	if not oSymmetryMapTemplate:
		oSymmetryMapTemplate = xsi.CreateSymmetryMappingTemplate(envObj, False, 0, False)
		lm( "Symmetry Mapping Template not found; created one.", c.siVerbose )
 
 
 
	# Create a SymmetryMap if it doesn't exist.
	sMapCls = envObj.ActivePrimitive.Geometry.Clusters("SymmetryMapCls")
 
	found = False
	if sMapCls:
		sMap_props = sMapCls.LocalProperties
		for eachProp in sMap_props:
			if eachProp.Type == "map" and not found:
				sMap = eachProp
				found = True
				lm( "Found SymmetryMap: "+sMap.FullName, c.siVerbose )
 
	if not found:
		lm( "SymmetryMap not found; created one.", c.siVerbose )
		#sMap = xsi.CreateSymmetryMap("", envObj, "Symmetry_Map")(0)
		sMap = xsi.CreateSymmetryMap("", envObj, "", "")(0)
 
 
 
	# Add envelope deformers to template by name:
	i = xsi.GetNumMappingRules( oSymmetryMapTemplate ) + 1
	oppositeNaming = {"L_":"R_", "R_":"L_"}
	envelope = envObj.Envelopes(0)
	deformers = envelope.Deformers
	for eachDef in deformers:
		name_A = eachDef.Name
 
		if name_A[:2] in oppositeNaming.keys():
			name_B = name_A.replace(name_A[:2], oppositeNaming.get(name_A[:2]), 1)
 
			xsi.AddMappingRule( oSymmetryMapTemplate, name_A, name_B, i)
			lm( "Adding Mapping Rule #"+str(i)+": "+name_A+" <--> "+name_B, c.siVerbose )
			i += 1
 
xsi.SelectObj(objects)

I might update the code in the future to support multiple models and check if an entry in the template has been added already, but for now this above will have to do.

Hope it’s useful to somebody!

However, the way it’s designed relies on the existance of the addon to evaluate. Without it, your rig is broken. I’ve made a version which is self-contained, so when you export your rig you don’t need to tell people to install any addon.

Select your curve(s) and run this code from either a button or the Script Editor. Here’s the JavaScript:

// Self-Contained CurveLength Op -- http://darkvertex.com/
 
function CurveLengthOp_Update( In_UpdateContext, Out, Incrvlist ) {
	Out.Value = Incrvlist.Value.Geometry.Curves(0).Length;
	return true;
}
 
function ApplyCurveLengthProp() {
	oEnum = new Enumerator( Application.Selection ) ;
	for (;!oEnum.atEnd();oEnum.moveNext() )
	{
		var sel = oEnum.item();
		if (sel.Type == "crvlist") {
			var oProp = sel.AddProperty( "Custom_parameter_list", false, "CurveLength" );
			var p = oProp.AddParameter2("CurveLength",siDouble,0,-8000,8000,-8000,8000,siClassifUnknown,siPersistable | siAnimatable, "Length");
			var crvList = sel.ActivePrimitive;
			var newOp = AddScriptedOp( p, CurveLengthOp_Update.toString(), crvList, "CurveLengthOp", "JScript" );
 
			newOp.Debug = 0;
			newOp.AlwaysEvaluate = true;
			newOp.Connect();
 
			LogMessage("Added CurveLengthOp to: "+sel.FullName, siVerbose);
		}
	}
}
 
ApplyCurveLengthProp();

[CLICK TO SEE DEMO VIDEO]

FORUM THREADS: [xsibase] [xsiforum.com] [softimage.ru]

WHAT IT DOES:
Inserts a <script> tag into every htm file in the docs folder so that when you click on any paragraph, it will be automagically translated to your chosen native language. (The video above shows a Spanish demo.) Language is set when you run the patching script.