We humans work numbers in what’s known as the “Numeral system“, also known as the “base 10″ system (as we have that many fingers…) but hold on… the alphabet has 26 letters, not 10, so what do we call that system? It has a name: it’s the Hexavigesimal (or “base 26″) system.

As the ever-so-handy Wikipedia denotes,

Any number may be converted to base-26 by repeatedly dividing the number by 26.

Pretty easy stuff for Python.

This is how I’d do it:

 
def base26str(i, padding = ""):
	"""
	Turns a number to a base26 string, with optional padding support.
	"""
 
	alphabet = map(chr, range(65, 91))
	alphaStr = ""
 
	if i > 0:
		number = i
		while (number > 0):
			remainder = number % 26
			alphaStr = alphabet[remainder] + alphaStr
			number /= 26
	else:
		alphaStr = "A"
 
	# Pad to X digits?
	if str(padding).isdigit():
		alphaStr = alphaStr.zfill(int(padding)).replace("0",alphabet[0])
 
	return alphaStr
 
# ------------------------------------
 
# Check this out...
print base26str(4)		# "E"
print base26str(4, 3)		# "AAE" ("E" padded to 3 letters. A = 0)
print base26str(28)		# "BC"
 
#

Now let’s put it to use in a simple renamer example. This sample below is Softimage-oriented, but you could easily change it to PyMEL:

from math import ceil
xsi = Application
 
typeSuffix = {
	"crvlist":	"CRV",
	"polymsh":	"GEO",
	"surfmsh":	"GEO",
	"null":		"NULL",
	"root":		"RT",
	"bone":		"BN",
	"eff":		"EFF"
}
 
oSel = xsi.Selection
prefix = xsi.XSIInputBox("What would you like to prefix these objects?", "NAME PREFIX", oSel(0).Name )
 
 
# Find out the padding required:
padding = ""
if oSel.Count > 26:
	padding = int( ceil( oSel.Count / 26.0 ) )
 
for i, eachObj in enumerate(oSel):
 
	# Get suffix if it has been defined, else leave blank:
	suffix = ( "" if eachObj.Type not in typeSuffix.keys() else "_"+typeSuffix[eachObj.Type] )
 
	# Rename object:
	newname = prefix+"_"+ base26str(i) +suffix
	print eachObj.Name+" --RENAMED-TO--> "+newname
	eachObj.Name = newname
 
#

Here’s a fun trick for parsing an ICE string attribute, identifying the letters and typing out the text with particles:

Download the sample scene here and read more about it below. (Soft 2011+ required.)

Taking this knowledge we can also do variations on the concept like turning a string into an array of booleans, for example:

Let me know in the comments if you make anything cool with this technique.

The classical way of doing symmetrical shapekeys (a.k.a. “blendshapes” if you’re in Maya or morphs if you’re in Max) is to make a symmetrical one then add it twice and paint off its influence with two weight maps, one for each half. In Maya you’d use the Paint Blend Shape Weights tool, but it’s basically the same deal.

In ICE, shapekeys have a .positions ICEattribute in them. This is an array of positions (vectors) representing the relative offset from the original mesh. In other words, it means you need to add them to the existing point positions to make said shape occur. That said, we won’t be using .positions in this post but full PointPosition’s instead.

Here’s what we’re gonna be working with in my example:

Normally you would make the 2 weightmaps, select one then Shape->Modulate Shape Key with Weight Map. The map looks kinda like this:

This involves making sure you have 100% of one half and 50% of the middle. You want 50% because you want to be able to add the shapes for both sides and get 100% of the deformation in the middle, else you’d get 200% and that’s no good.

Let’s see how we can use ICE to skip that step altogether by only deforming points in one half instead of relying on a map to define it, as pictured at the beginning of this post.

So as you can see we read the PointPosition, split out to scalars with the “3D Vector to Scalar“, then feed the X to different nodes to see if it’s bigger or equal to / bigger / smaller or equal to / smaller than zero. With the “Select Case” we use the correct one as defined from our dropdown menu input attribute “Type“. (If you didn’t know: to define a dropdown menu for an attribute in a compound just rightclick it and go to Properties, then fill in “Combo string” and “Combo value” then click “Add combo” as desired.)

The If node before the Linear Interpolate makes sure that if we’re not dealing with the correct half, we just let the positions pass through untouched. Otherwise, we check if the “Type” (mode) is set to one that includes the middle line, and if X is 0 it means we have a point in the perfect middle of the mesh, in which case we only affect it by 50%, else we let it go through. At the end we do one more Linear Interpolate between the affected result and the original mesh, so we can blend it gradually with a slider.

Lastly, if anyone’s curious what the word “Epsilon” means in regards to an “Equals” node, it’s basically the margin of error permitted in the comparison since vector values aren’t exact numbers most of the time in 3D. Thus an epsilon of 0.001 in this case means that a vector’s posX can be off from 0 by 0.001, so it could anywhere between -0.001 and 0.001 and still be considered to equal 0. You can increase the epsilon if you need to.

Here’s my take on said function for both Softimage and Maya…

First of all, we need to know the math behind it. Knowing global position vectors A and B, the formula for the distance (d) between them would be:

d = √  Ax-Bx² + Ay-By² + Az-Bz²  

I’ve decided to borrow sqrt() and pow() functions from Python’s math library, by the way.

First let’s see how to do this with Python in Softimage:

xsi = Application
lm = xsi.LogMessage
 
def ctr_dist( objA, objB ):
	from math import sqrt,pow
 
	Ax, Ay, Az = objA.Kinematics.Global.Transform.GetTranslationValues2()
	Bx, By, Bz = objB.Kinematics.Global.Transform.GetTranslationValues2()
 
	return sqrt(  pow(Ax-Bx,2) + pow(Ay-By,2) + pow(Az-Bz,2)  )
# -------------------------
 
 
# Try it out with 2 selected objects:
fromObj, toObj = xsi.Selection(0), xsi.Selection(1)
 
lm(
"Distance between <"+fromObj.FullName+"> to <"+toObj.FullName+"> is: "
+str( ctr_dist(fromObj, toObj) )
)

Now let’s repurpose it for PyMEL in Maya, without using distance nodes:

from pymel.core import *
 
def ctr_dist( objA, objB ):
	from math import sqrt,pow
 
	Ax, Ay, Az = objA.getTranslation(space="world")
	Bx, By, Bz = objB.getTranslation(space="world")
 
	return sqrt(  pow(Ax-Bx,2) + pow(Ay-By,2) + pow(Az-Bz,2)  )
# -------------------------
 
 
# Try it out with 2 selected objects:
sel = ls(sl=1)
print "Distance between <"+sel[0]+"> to <"+sel[1]+"> is: "+str( ctr_dist(sel[0],sel[1]) )

By the way, note the awesomeness of Python for letting you assign multiple variables from an array using a single line. That’s pretty nice.

Hope somebody finds this useful! You can use it a measuring tool or for distance-dependent rigging logic.

If you do use it for rigging, please remember that if you want the distance to stay the same while a character is scaled, you must divide the distance by the scaling value.

LogMessage( XSIUtils.Environment("TEMP") );

If I run that (JavaScript) I get something like: C:\Users\Alan\AppData\Local\Temp\XSI_Temp_15076

The number is unique every time and if you open multiple XSI sessions, each will get their own temp folder. If you close Softimage, the corresponding temp folder is deleted completely.

This is a much more elegant solution to temporary filepaths because you don’t have to waste time coding a purging/cleanup mechanism in your plugin.

Furthermore, if Softimage crashes it will get cleaned anyways next time you run it. It seems to check for XSI_Temp_* folders on startup and delete any that are not in use by an existing session.

I found this feature by accident when I needed a temp file function for a scripted tool I was working on. I was expecting to get the normal TEMP path set by Windows, but to my surprise Softimage had overriden it with their own that autopurges by itself. Handy!

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.
   
• [*Update 23/Dec/2010*] Eric Thivierge has brought up that apparently if you key a refmodel’s object to another and animate the Active parameter, those keys will not be saved. However, if you key the Blend instead, you’ll be fine.
• [*Update 05/May/2011*] There’s a very interesting SDK bug (confirmed in 2011 SAP, not checked other versions) whereby dealing with Model Instances with refmodels will create an instance group and seems to work fine, but if you try to get the .ActionDeltas of the Delta via scripting, it will fail as if it didn’t exist. Rename the group once and then .ActionDeltas work again. Very strange!!
• [*Update 13/May/2011*] With 2011.0 (the first one) there is a serious bug whereby shaders may get disconnected. The bug that causes the issue is fixed in the ServicePacks that followed. Inform yourself straight from the source at Stephen Blair’s eX-SI Support blog.

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!

With this Rendertree compound you have AO in darkness and that’s it. Simple!

Now….. can you spot the differences between these images below?

Diffuse pass, boring looking, no AO:

BAD — Sloppy AO that’s been applied everywhere: (notice how dirty it looks towards the center light)

GOOD — Shadow-aware AO, only exists where it should… in darkness:

Credit where credit is due; this method was originally pointed out by Guy Rabiller many years ago, back when our software was called a 3 letter word.

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();

Fiddling with the ExtrudeOp options

Try this yourself:

1. Get a sphere. (My screenshot example was a half-sphere.)
2. Select all polys. (Press Y to enter poly mode then Ctrl+A to select all.)
3. Press Ctrl+D to Extrude.
4. In an Explorer open your object’s operator stack, find the ExtrudeOp and open its PPG.
5. Turn off Merge, then fiddle with Length, Inset Amount and Subdivs.
6. Then in the Transform tab, play with the sliders there.
   You can get some very interesting (and often abstract) results!

*UPDATE [21/05/10]*: A buddy of mine who uses Maya informs me that the mayan Extrude has options to do this as well if you peek in the channel box. Just so you know.