Since XSI does not allow for shadow maps paths, this is how you can do (a ray3 standalone license is required).

After setting up a shadow mapped light, export a single frame archive (mi2) ascii file.

Edit the file with a text editor, and look for the light options section. There you find the shadowmap settings.

To have the map written, just add a line with the “shadowmap file” statement, followed by the path for the file (.zt format mandatory).

light "Spot_Root/Spot/Light" = "Spot_Root/Spot/Light/soft_light"
origin 0 0 0
direction 0 0 -1
spread 0.866025
shadowmap on
shadowmap resolution 500
shadowmap softness 0.002
shadowmap samples 20
#the following line added
shadowmap file "C:\temp\sm.zt"
energy 7500 7500.01 7500
...
end light

Save the file and render it with ray3.

To just render the shadow map and not the image, you can use the handy “-shadowmap only” option. In my case, being the archive file named C:\temp\out.mi2, I run

ray3 C:\temp\out.mi2 -shadowmap only -verbose on

Once finished, you should find the map on disk (C:\temp\sm.zt in my case), and view it by

imf_disp C:\temp\sm.zt

This is a simple sphere over a grid

The grid does not show up, not being a shadow caster itself.

So you can now check the shadow map extent, which is particularly interesting for infinite lights, being determined by the extent of the parts of the scene that cast shadows (for spot light sources, only the cone spread parameter matters).

Also, by left clicking on the image, you can read the z value for each pixel, and finally (maybe) understand the obscure bias option ;).

For years I’ve been doing this and for years I’ve been meaning to get around to making it slicker but somehow there was never time. So the other day it rained - fit to burst - and I had a day inside with nothing else to do and this is what I ended up with.

Earlier attempts ended up in a puddle on the floor because for some reason the only links I could find to VSS command line building pointed me at VCBuild.exe, which is just a plain old mess. This time, though, I found a link to a list of command line options for devenv.exe - what you run to bring up the VS IDE - at the excelent codeproject.com and these are much more straightforward.

The process is fairly simple:

1. unload the plugin.
2. run a command line build using system()
3. copy over the dll (my build has this built in)
4. reload the plugin.
5. test
6. package

Step 2 involves a little bit of wrastling with .bat command line, um, features but really the code (at the end of this article) is quite simple. Because it’s scripted you can build entire plugin sets and package them in one go. The whole process takes only seconds because it’s self contained and it’s dead easy to stuff in some test code. You can easily slip back to the IDE when you need it and it makes working with a preferred text editor easier if that’s your bag.

There’s also the advantage that the build inherits the paths to libraries from the XSI version you’re working with. No more .bat file wrappers. Neat!

This example code is just a list of functions:

Build( solutionName, PluginName, forceRebuild ); // do the actual build.
GetConfig(); //gets the platform type (32/64)
Package( PluginName ); // package. Output name is hard coded in the example.

I stuff the plugin names in an array so I can build a bunch of them in one.

I also have a custom property I use with a dropdown list of my main projects along with build and package buttons.

And finally, I figure I might, next time it rains, get this working alongside package location. Who knows.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

var sPlugins = new Array( "TinyCurveExtrude", "TinyCap" );
var slnName = sPlugins[0];
var sPluginName = slnName + "Plugin";
 
Build( slnName, sPluginName, false );
Package( sPluginName );
 
// build the solution. doRebuild is a boolean, forces a complete compile and build if true.
//
function Build( slnName, sPluginName, doRebuild ) {
	var oPlugin = Application.Plugins( sPluginName );
	var sPluginFileName = oPlugin.FileName;
 
	if ( !oPlugin ) {
		logmessage( "Can't find plugin to unload: " + sPluginName, siError );
		return;
	}
 
	Logmessage( "Unloading Plugin " + sPluginFileName );	
	Application.UnloadPlugin( sPluginFileName );
 
	var Cmd = BuildCmdRoot( slnName );
	var sConfig = GetConfig();
 
	var sOpt = (doRebuild) ? " /rebuild " : " /build ";
 
	if ( sConfig ) {
		system( Cmd + sOpt + sConfig + " & pause" );
	} else {
		Logmessage( "Build Failed", siError );
	}
 
	LogMessage( "ReLoading Plugin: " + sPluginFileName );
	Application.LoadPlugin( sPluginFileName );
 
} 
// get the platform type, 32 or 64 bit. Release is hard coded
//
function GetConfig() {
	var sPlatform = Application.Platform;
	Logmessage( sPlatform );
 
	if ( sPlatform.match( /win64/i ) ) return "\"Release x64|x64\"";
	if ( sPlatform.match( /win32/i ) ) return "\"Release|Win32\"";
 
	Logmessage( "Unsupported Platform: " + sPlatform, siError );
	return false;
}
 
// build the devenv.ex command line
// NOTE: this is set to work on a 64 bit system. Take out the (x86) and spaces 
// for 32 bit. Cross compile works well enough but you'll need the 64 bit libs
function BuildCmdRoot( sTargetName ) {
	var slnRoot = "c:\\fatty\\DEV\\CPP";
 
	var vcVars = "call \"C:\\Program Files (x86)\\Microsoft Visual Studio 8\\VC\\vcvarsall.bat\" x86";
 
	var slnPath = slnRoot + "\\" + sTargetName + "\\" + sTargetName + ".sln"
	var Cmd = vcVars + " & devenv " + slnPath;
	return Cmd;
}
 
// Package.
// ToDo: rebuild for package location.
//
function Package( sPluginName ) {
	logmessage( "Packaging ... " );
 
	var sOutputPath = "C:/Fatty/Dev/CPP/Release"
 
	var sPlatform = Application.Platform;
 
	var oPlugin = Application.Plugins( sPluginName );
	var sPluginFileName = oPlugin.FileName;
 
	var oAddOn = Application.CreateAddon();
 
	oAddOn.AddItem( siPluginAddonItemType, oPlugin.FileName );
 
	oAddOn.DefaultInstallationPath = siUserAddonPath;
	oAddOn.SubDirectory = sPluginName;
 
	var sPluginFileName = sOutputPath + "/" + sPluginName + "_" + sPlatform + ".xsiaddon"
 
	oAddOn.Save( sPluginFileName );
 
	logmessage( "Packaged to: " + sPluginFileName  );
}

  mklink /D d:\alias_location  d:\actual\location\of\directory

The /D stands for directory link, because file links are also supported. Even better, the link can be to a remote location.

  mklink /D d:\alias_location  \\server\share

Naturally, if you only wanted a drive letter shortcut, the old ‘subst‘ command still works.

Callbacks in XSI plugins are functions in the global scope who’s name must be defined exactly the way XSI expects to find them.

I would have preferred callbacks to be supplied by the user in a way that allows them to have any name and in a way that allows them to be changed on the fly. In all fairness, Softimage probably has some very good reasons for the way they did things.

So this is where we, as users, exploit the power that has been given to us and take things into our own hands. Here is my implementation of dynamic, interchangeable, replaceable callbacks.

Code Time!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

import win32com.client
from win32com.client import constants as c
from vg.xsi.dynamic import *
 
def XSILoadPlugin( in_reg ):
	in_reg.Author = "Patrick Boucher"
	in_reg.Name = "dynCbCommandPlugin"
	in_reg.Major = 1
	in_reg.Minor = 0
	in_reg.RegisterCommand("dynCbCommand", "dynCbCommand")
	return True
 
def XSIUnloadPlugin( in_reg ):
	strPluginName = in_reg.Name
	Application.LogMessage(str(strPluginName) + str(" has been unloaded."),c.siVerbose)
	return True
 
def dynCbCommand_Init( in_ctxt ):
	oCmd = in_ctxt.Source
	oCmd.Description = ""
	oCmd.ReturnValue = True
	return True
 
@dynamic
def dynCbCommand_Execute():
	Application.LogMessage('In original callback!')
	setCallback(dynCbCommand_Execute, callbackTwo)
	return True
 
def callbackTwo():
	Application.LogMessage('In %s!' % callback(dynCbCommand_Execute).func_name)
	setCallback(dynCbCommand_Execute, callbackThree)
	return True	
 
def callbackThree():
	Application.LogMessage('In callback three!')
	restoreCallback('dynCbCommand_Execute')
	return True	
 
setCallback(dynCbCommand_Execute, callbackTwo)

The first time you run this command it will run the code in callbackTwo and switch itself to new code. The next time it will run callbackThree and the next time it will run the original callback code. It will then, with each consecutive invocation of the command, continue on in this loop. This plugin, as you have guessed, is just a demo of the dynamic callbacks.

The lines you have to concentrate on are the following:

from vg.xsi.dynamic import *

and

@dynamic

These are the lines that provide the core of the functionality which is imported from the vg.xsi.dynamic module. Here it is…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

import sys
 
__all__ = ['dynamic', 'setCallback', 'callback', 'restoreCallback']
 
class Wrapper(object):
    def __init__(self, cb):
        self.__defaultCb = cb
        self.__cb = cb
 
    def call(self, *args, **kwargs):
        return self.__cb(*args, **kwargs)
 
    def setCallback(self, newCb):
        self.__cb = newCb
 
    def callback(self):
        return self.__cb
 
    def restoreCallback(self):
        self.__cb = self.__defaultCb
 
def dynamic(func):
    cbWrap = Wrapper(func)
    return cbWrap.call
 
def setCallback(bound, newCb):
    bound = _getCallable(bound)
    newCb = _getCallable(newCb)
    return bound.im_self.setCallback(newCb)
 
def callback(bound):
    bound = _getCallable(bound)
    return bound.im_self.callback()
 
def restoreCallback(bound):
    bound = _getCallable(bound)
    return bound.im_self.restoreCallback()
 
def _getCallable(req):
    if callable(req):
        return req
 
    if type(req) is str:
        g = sys._getframe(2).f_globals
        return g[req]

I’ve removed any comments or docstrings for the sake of brevity.

About Decorators

The import line I said was of particular interest. Well it is but only in the sense that it will allow you to use the module in which the features are implemented… Moving on quickly.

The real fun is with the @dynamic decorator. What is a decorator and what happens when we use one (or this one in particular)? Before we look at what a decorator is and does, let’s look at what happens when we define a function.

1
2

def func():
    pass

When a function is defined, what is happening is that an identifier is created in your current scope and this identifier is given the name of your function. Now let’s add the decorator. A decorator is just a simple function, but a function who’s purpose is very specific and a function that must return a callable (another function most of the time).

1
2
3

@myDecorator
def func():
    pass

What happens here is that the identifier func is still created but what lies ‘in’ this identifier is not the function itself but the result of passing said function to myDecorator. To help you visualize, the above code could just as easily been written like so:

1
2
3

def func():
    pass
func = myDecorator(func)

Let’s Get Specific

The decorator @dynamic takes your callback and wraps it inside a Wrapper object and returns the call method of this new object. When XSI tries to call what it thinks is just a simple callback it is actually calling the call method of an object that in turn calls your original callback. Whew!

This means that you now have the liberty of querying and editing the callback object and telling it to call something different depending on context. This functionality is provided by the setCallback, callback and restoreCallback functions.

These three functions either take the callback function objects or the callback’s names (as a string) as arguments.

There are some more particularities to this code such as the use of sys._getframe, the im_self attribute or the use of the call method on the Wrapper object instead of implementing __call__ but I think they might be outside the scope of this article. If there are requests for it I can expand in the comments or another post.

Meanwhile you can download the example. Drop the plugin into a plugin folder (user, factory or workgroup) and drop the vg folder somewhere in your Python path.

Cheers!

You all remember the idea of a proxy parameter where editing a parameter in a custom PPG (lets call this one the source) will in fact be changing another elsewhere in the scene (this one we will call the target). Extend this idea to a selection where selecting a source will in fact ‘transfer’ the selection to another object. This could be useful, among other cases, in a rigging scenario.

As it was suggested in the thread, there are many use cases for a functionality like this that can be addressed with native XSI tools and methodologies but nonetheless, I felt like there might be some cases where an actual proxy select could be useful. So I cooked one up for Bryan, and here it is.

Select one or more targets and then go to Get -> Property -> Proxy Select and then pick one or more source objects. From then on whenever you select a source object, it will unselect itself and select the targets instead. There is some sanity checking in there to try and avoid dependency loops and the like, just in case.

There are also three menu items in the MCP Select menu that will toggle proxy select functionality in six different ways.

• Toggle on proxy select for all objects - when nothing is selected
• Toggle off proxy select for all objects - when nothing is selected
• Toggle/Inverse proxy select state for all objects - when nothing is selected
• Toggle on proxy select for selected objects
• Toggle off proxy select for selected objects
• Toggle/Inverse proxy select state for selected objects

I can already hear you asking: “How can I select a proxy select source to toggle it’s functionality if it is already on and automatically transfers it’s selection?”

Well,

• If it is only one object you wish to toggle you can go directly to it’s Proxy Select custom property.
• If you wish to act on multiple objects with these toggle menus, you can multi select the objects and toggle them all together. When multiple objects are selected, no selection transfer takes place.
• This also means that you can multi select a proxy select source with any other object and then use the menu items, any object that isn’t a proxy select source will be safely ignored.

And then came Thiago

One of the people involved in the thread was Thiago Costa from Nervo.tv. He is actually the one who suggested an approach for creating the Proxy Select plugin in the first place. Well, about the same time I had sent Bryan my first draft Thiago posted his version. I said it in the thread and I will say it again, it is very nicely executed.

One of the things he did is that he anticipated the user’s needs and thought for a second about what you would like to do with the resulting select.

Something that happens to often (well for me anyway), and especially in the heat of production, is that we fail to properly establish requirements.

These requirement will inevitably change.

When the first wave of requirements is put down on paper some time should be spent trying to anticipate the user’s needs as well as possible future requirements. Even if these extra features aren’t initially implemented, having this foresight will allow the resulting code to better accomodate change.

Downloads

Check out the thread at Softimage|Net for Thiago’s version.

Download my version from here.

However, it has some limitations, for instance not supporting texture pre-filtering, and the fact that its spacing is expressed in world coordinates instead of uv coordinates like the old node. This leads to frequent aliasing problems, that can sometimes be limited by texturing the spacing based on the object’s distance from the camera.

Another way of fixing the aliasing is to filter the high frequencies of the input texture. The primary way to achieve this filtering is to do it on the image in an editing program like Photoshop, but this is harder to do with procedural nodes.

However, by using a few nodes in the rendertree, it is possible to do it there also.

The bump node outputs the new normal (N’), after having bent the original one (N) based on the texture gradient at the current point.

So, we can compare N to N’ by subtracting them and getting the length (L) of this difference vector (D). Since N and N’ are normalized, and the maximum bump angle is 90 degrees, D ranges from 0 (no bump) to 1.41, ie the hypotenuse of a right triangle with unit catheti.

We can then set a maximum length for D, and re-arrange N’ in order not to exceed it, so to filter off the high frequencies and limit the aliasing.

In this first rendertree, we simply want to check the “dangerous” zones. We take the length (L) of the normal’s difference (D) and check it against a maximum scalar. If this scalar is exceeded red is returned or green otherwise.

In this example the scalar is set to 1, we are seeing in red the parts where the bending angle exceeds 60 degrees.

To output the filtered normal, we do the same test as above, but connected to a scalar switch.
The switcher outputs the maximum between Max Displacement and L. This value is used to set the new length of D (VectorNormalize + VectorSetLength).

This vector is then added to the original normal N and normalized. This is our new, filtered normal.

Of course this is a very basic filter, more complex ones can easily be built to fit your needs.

You can grab the scene if you want. The red and green subtree is also included, connected to the shadow port.

I put some effort into commenting the script accordingly, so that it may be used for learning purposes.

cheers!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

// query the geometry data
var obj = selection(0);
var geo = obj.Activeprimitive.Geometry;
var polygons = geo.Polygons;
 
// create an array to track which polygon has been visited
var polygonVisited = [];
var polygonsLeft = polygons.Count;
 
// fill up the array to say: "no polygon has been visited yet"
for(var i=0;i<polygons .count;i++)
{
	polygonVisited[i] = false;
}
 
// create some helper variables
var clusterIndices = [];
var currentRow = [];
 
// log the start of the process
logmessage("Starting with "+polygonsLeft+" polygons...");
 
// loop until there are no polygons left
// or there are still items in the cluster array
while(polygonsLeft > 0 || clusterIndices.length > 0)
{
	// if there are no items in the next row...
	if(currentRow.length == 0)
	{
		// if there are items in the cluster index array
		if(clusterIndices.length > 0)
		{
			// log the creation of the cluster
			logmessage("Creating cluster with "+clusterIndices.length+" elements...");
 
			// create a new mesh containing all of these polygons
			// first, create an array containing all pointindices
			// and two additional point hash arrays
			// of which one is used to determine if a point is already used
			// and the second one is used to map the original index to the new one
			var pointIndices = [];
			var pointUsed = [];
			var pointNewIndex = [];
 
			for(var i=0;i<clusterIndices.length;i++)
			{
				var poly = polygons.item(clusterIndices[i]);
				var pointIndexArray = poly.points.indexArray.toArray(); //(VBS to JScript conversion)
 
				// loop through all points and check if it they are used
				for(var j=0;j<pointIndexArray.length;j++)
				{
					var index = pointIndexArray[j];
					if(!pointUsed[index])
					{
						pointNewIndex[index] = pointIndices.length;
						pointIndices.push(index);
						pointUsed[index] = true;	
					}
				}
			}
 
			// now, create the array of the positions of all points of this island
			var islandPos = [];
			for(var i=0;i<pointIndices.length;i++)
			{
				var point = geo.points.item(pointIndices[i]);
				islandPos.push(point.position.x);
				islandPos.push(point.position.y);
				islandPos.push(point.position.z);
			}
 
			// now we need to create the description of the polygons
			var islandPoly = [];
			// for that we loop over the polygons of the island again
			// and record their pointindices, well, actually the remapped
			// indices (given by the pointNewIndex hash array)
			for(var i=0;i<clusterIndices.length;i++)
			{
				var poly = polygons.item(clusterIndices[i]);
				var pointIndexArray = poly.points.indexArray.toArray(); //(VBS to JScript conversion)
 
				// first add the number of points of this polygon 
				// to this polygon's description
				islandPoly.push(pointIndexArray.length);
 
				// now add the remapped index for each point to the description
				for(var j=0;j<pointIndexArray.length;j++)
				{
					var index = pointIndexArray[j];
					islandPoly.push(pointNewIndex[index]);
				}
			}
 
			obj.Parent.AddPolygonMesh(islandPos,islandPoly,obj.name+"_island");
			clusterIndices = [];
 
			// if there are no polyons left we can stop now
			if(polygonsLeft == 0)
				break;
		}
 
		// loop over the polygons and try to find 
		// one which hasn't been visited yet
		for(var i=0;i<polygons.Count;i++)
		{
			if(polygonVisited[i] == false)
			{
				currentRow.push(i);
				clusterIndices.push(i);
				polygonVisited[i] = true;
				polygonsLeft--;
				break;
			}
		}
	}
 
	// define the nextrow after the current row
	var nextRow = [];
 
	// loop over all items in the current row
	for(var i=0;i<currentRow.length;i++)
	{
		var polygon = polygons.item(currentRow[i]);
		var neighbors = polygon.NeighborPolygons();
 
		// loop through all of the neighbors and add them to the nextRow
		for(var j=0;j<neighbors.count;j++)
		{
			// check if the neighbor has been
			// visited yet
			var neighbor = neighbors.item(j).index;
			if(polygonVisited[neighbor]==false)
			{
				// add the neighbor to the next row
				nextRow.push(neighbor);
				clusterIndices.push(neighbor);
				polygonVisited[neighbor] = true;
				polygonsLeft--;
				break;
			}
		}
	}
 
	currentRow = nextRow;
}
 
selection.SetAsText(obj.name+"_island*");

working on some characters with secondary motion I came up with a pretty simple spring op including some caching / plotting functionality and thought I’d share it.

It is a very basic radial spring, which comes with a DisplayInfo to control all parameters through the viewport. Additionally the objects created are put in groups for your convenience.

Here’s a video demonstrating the addon:
http://217.160.138.15/helge/rigtut/mt_spring.avi (Encoded in Techsmith Camtasia, 51 MB)

And finally, here’s the link to the addon:
http://217.160.138.15/helge/rigtut/mt_spring_addon.zip

Some of the choices that need to be addressed are the technological choices of tools, systems, libraries and techniques.

Which tools and technologies should you use and why? I won’t pretend to be suggesting the holy grail of tool chests. I just felt like sharing the choices I’ve made and why I made them. Please don’t hesitate and comment if you think I’m off base, you have questions or would like to suggest other alternatives that you use. I’d love to hear, and learn, from you!

Core Tools and Systems

My preferred programming language as you may (or may not) have noticed, is Python. It has clean and concise syntax, an object oriented approach second to none in dynamic languages, and a standard library that provides most of the functionality you’ll ever need. It has almost become the defacto language in our industry with support in XSI, Maya, Houdini and RealFlow just to name a few. With Python you can code system tools, CG application plugins and scripts, standalone applications, web applications as well as custom libraries to back all of these up. The language is evolving and has strong community and industry support. Need I say more?

On the server I run Linux. Wouldn’t have it any other way. Actually, right now I’ve been forced into running a pipeline off a Windows box and I hate it to death! I can already hear you asking: “Which linux distribution?” On the server, honestly, I don’t really care. I’ve often built all my applications from scratch according to a technique a friend has taught me. This guy was, at one point or another in his career, senior systems administrator for the likes of Hydro-Quebec and Teleglobe - I tend to trust him in IT matters.

On top of the OS I like to run Apache with mod_python for all my web serving needs and MySQL for database needs. Apache is by far the most versatile web server I’ve worked with and with a few cnames in your DNS and virtual hosts in Apache you can be very organized in your web applications. As far as MySQL goes, it is free, well hooked into a multitude of languages, and very stable. Until recently it didn’t have any stored procedures but that’s the kind of stuff I like to keep in my application logic anyway. To make easy MySQL management even easier I’ll also build a vhost in my apache dedicated to serving phpMyAdmin, by far the best web front end for MySQL.

Note: With the purchase of MySQL by Sun and after a few discussions with a friend, I think I’ll be looking heavily into PostgreSQL.

The last thing I usually install onto the system is Subversion. Even if you’re a lone developer I think source code control is invaluable in helping you track not only code changes but also release cycles and versions. Also look at installing Subversion and/or TortoiseSVN on your development station to make interfacing with the server easier.

Libraries

To help build the web applications you’re probably going to be needing, look into Django. It’s biggest assets for me are it’s Model and Object Relational Mapper (ORM) as well as it’s template language. Django is also built in such a modular fashion that you can use the template language in standalone applications that need to build static HTML pages or you can use it’s ORM in XSI tools that need to access a Database. This means you can build a whole lot of application logic in such a way that it is highly decoupled from either the database or the ui. Django can really break out from the web, this shouldn’t be forgotten. SQLAlchemy also exists as far as ORM layers go but it doesn’t jive as well with me and obviously doesn’t offer an end to end solution if you’re building a web app.

On the networking side, I’ve started tinkering with Twisted. Wow. This is definitely going to be a part of my standard set of tools. When building more complex systems that need to interact over the network Twisted’s protocol building facilities are simply wicked! Some of it’s constructs needed a bit of getting used to for me, see the deferred, but once I got a handle on them I saw how they can get quite powerful.

Finally, on the UI side for standalone applications, I’ve fallen in love with QT. I had used Tk and WxWidgets in the past but they definitely don’t compare to QT. And QT is much more than UI, it is also networking, OpenGL, threading, etc… To get QT and Python working together you’ll need PyQT whose latest version includes everything you need to get started, including QT itself. I know that from the UI perspective XSI allready offers much of what we need in its PPGs but if you are in a mixed pipeline, think Maya and XSI, there is some merit in using a UI toolkit that you can run in both applications to cut down on the amount of code you’ll be doing.

Techniques

One of my self imposed rules is the maximum length of a function or method. If I can’t fit it into a single screen it is probably too long and I should rethink it and split it up.

I am also trying to better my documentation. I like self documentation through variable names so you’ll often find rather verbose symbol names in my code. With a proper IDE that does name completion the burden on typing isn’t so big. I also try to do a first draft of my functions or methods in pure comment form. This gets my ideas out quickly while they are fresh without bogging me down in details. The comments also wind up being present in the final code thus helping out comprehension of the program. Finally I try, and often fail miserably ;), to use Python’s docstrings to document public interfaces.

One of the latest things I want to impose upon myself is unit testing. Especially for my libraries. Some detractors of dynamic languages will gripe about type safety and they would be right. That’s why you test. And testing not only helps with types but also algorithms, refactoring, logic, etc… If your application breaks in one way or another, proper testing can help find the break sooner than later. On the subject of unit testing libraries check out this nice roundup. I’m currently leaning towards py.test.

Bored yet?

I hope you’re not bored out of your mind yet! Were you really expecting me not to totally geek out in an article entitled “Technological Choices”?

Cheers!

Update your subscriptions if you wish. The links can be found in the footer, entries to the left and comments to the right.

Cheers!