I’m trhilled to be able to finally showcase, at least, some of our very own Python implementation into 3ds Max!

First off, our primary reason for writing our own, proprietary, Python connection to 3ds Max is Tactic by Southpaw Technology. An awesome asset management system entirely written in Python that I decided to invest in and integrate our tools and software packages into. Another reason for this connection, later came up, was the need for writing much more complex scripts with complex GUIs, since, as you probably know, a few functional lines of code are hardly enough in a modern, efficient, VFX production of today.

The heart of our Python integration is dotNET from Microsoft. I can’t express myself enough how much I appretiate this framework! The brain of our Python integration is IronPython. Also a product from Microsoft, completely open source and free, which are two very important aspects for any pipeline tool in any production facility of any size. Not the price as much as the availability of the software. And with IronPython and Microsoft, I am certain that this piece of software will be around for years!

So, what have we done?

• We’ve developed a bridge that connects MAXScript and Python via dotNET.
• The bridge converts most of native Python and MAXScript data types to and from one another.
• We’ve implemented several, custom, methods in Python that allow us to directly communicate with 3ds Max via MAXScript.
• We’ve also implemented error reporting so that when an error is thrown in Python, it’ll return the exception in MAXScript for debuging.
• Everything is based on dotNET and written in C#.
• The best part? Our Python bridge is completely platform and 3ds Max version independent!

Let me talk about the custom Python methods first. We’ve incorporated a class called mxsCon, that stores several methods for direct communication with 3ds Max as well as a variable
that stores passed arguments from MAXScript to Python for greater flexibility, especially when executing short code snippets.

The initial design meant to provide a way of directly running Python code from within MAXScript. However, with more complex tools needed nowdays, this proved to be insufficient and thus we’ve developed a way of executing more complex Python scripts written externally using IronPython. This works perfectly well if you plan on using 3ds Max’s interpreter and just want to pass values around MAXScript and Python. This is perfectly efficitent and enough for writing really complex tools based on Python. In our case, it’s the connection to Tactic.

However, later, it occured to me that since we have most of the hard work done, why not bring everything over to the Python side. Since Python is such a great and powerful language, why bother with MAXScript! So we developed another method for executing MAXScript code directly within Python scripts and have the result, evaluated in MAXScript, be passed back to Python. IronPython that is. Since all the value conversions had already been done, this proved to be an extremely powerful and efficient way of writing very complex tools, now even, with very complex GUIs. Since everything is based on dotNET, we can utilise IronPython and some of the IDEs available for super quick GUI development. I used SharpDevelop, an open source IDE for writing dotNET applications, for all my GUI and code stuff. Then I just hook up MAXScript commands that I pass Python values to in order to perform some actions in 3ds Max, like opening a file from our server stored in Tactic. Or, create objects and list them in a ListView. Or even write a direct 3ds Max – Maya translator! Why not?

Anyways, here are the methods and their purpose in 3ds Max:

• Python.run( <string> ) — will execute a Python script wrapped in double quotes (effectively a string).

Example:

Python.run
(
	"import sys
	mxsCon.setResult( sys.version )"
)

In this case, Python.run() will return whatever the mxsCon.setResult() will pass to it (more on that later).

• Python.runFromFile( <string> ) [ args:#() ] — will execute a Python script stored in an external file and alternatively pass it custom arguments.

Example:

Python.runFromFile @"C:\myPythonScript.py" args:#( 10., true, #(1,2,3), "some string" )

In Python, you’ll have to catch the passed arguments in order to use them, however the conversion of the data types will be done automatically for you.

• Python.inspect( <data type> ) — this method will inspect what data type you passed to it and how it will convert it to Python.
• Python.getError() — this method returns the last unhandled exception in Python code.
• Python.setVerbosity( <int> ) — allows you to set the level of verbosity for error reporting.
• Python.getVerbosity() — retreives the level of verbosity you currently use.
• Python.resetPy() — a very useful method for resetting our bridge residing in memory in case you’ve changed something radical in the source code etc…

And here are the custom methods developed in C# for IronPython use in the scripts. These only exist when run via our Pythoner.dll module. If you run the Python scripts without Pythoner, you’ll have to handle their lack of presence. I’ve done this via a custom class that I import in the scripts I use. This is extremely flexible since when I run the code outside of 3ds Max, I can still use its functionality without having to deal with error handlers all over the place.

• mxsCon.setResult( <data> ) # this method will return whatever it encapsulates directly to 3ds Max as well as in Python should you need to work with it later in the script.

Example:

import math

def myFunc( arg ):
	sum = arg + 100.
	return mxsCon.setResult( [arg, sum] )

if __name__ == '<module>':
	myFunc( math.pi )

The myFunc function will not only return a List of whatever you pass to it as well as the result of addition, but it’ll also pass this List directly to MAXScript for later use in 3ds Max.

• mxsCon.getResult() # this method will only return the last value stored in memory using the .setResult() method. Useful for later usage in Python.
• mxsCon.convert( <data> ) # this method will convert the input data types from Python to MAXScript compatible data types, but will return then wrapped as a string. This
  may be useful for other usage reasons. I used it for debugging or printing values in Python in MAXScript format.
• mxsCon.execute( <data> ) # here’s where the magic happens. This method is quite complex. It not only evaluates whatever is passed to it in a String format, but it’ll also wait for the result from MAXScript and return it within Python. Another, very cool, feature of this method is similar to String formatting capabilities known from Python.

Some examples of the mxsCon.execute() method:

# assume here's a ton of complex Python code that invokes this method
returnedVal = mxsCon.execute( r'Box()' )
# will create a box in 3ds Max and return OK (converted to True) back to Python.

returnedVal = mxsCon.execute( r'getDir {0}', r'#scripts' )

The .execute method will first evaluate its input into a single string,
in this case: r’getDir #scripts’, in a similar fashion the .format method works in Python.
Then it’ll execute the command in MAXScript and retun its output back to Python.
The output, in this case, will be a string: ‘C:\Program Files\Autodesk\3ds Max 2009\scripts’

But, enought with the talk, see it for yourself in action in this short Windows.Forms demo. (clicking the image will take you to the video)

I am very excited to present a very early development results for our own Python implementation in 3ds Max.

First a bit of an intro. At duber, I’ve setup everything around Python, the most versatile and powerful language I’ve ever seen. I felt in love with Python so much that it even influenced my decision to leave Fusion (my favourite compositing app) and dive into Nuke (my, now, most favourite compositing app). I even invested in a commercial data and asset management system, Tactic, that is entirely written in Python. I run tons of custom Python scripts to tie together programs such as Tactic, Nuke, FrameCycler, Photoshop etc… etc… But the last missing piece to the entire pipeline puzzle was 3ds Max.

There were initiatives to bring Python into Max, both from Autodesk and from 3rd party developers. The problem is, none of those are final, open-source, nor fully functional.

What I need with Max, at least for now, is to be able to communicate with the Python tools running at my studio. I need Max to be able to communicate with Tactic. I need it to communicate with FrameCycler. And I need it to communicate with Nuke. Since I have most of the tiny scripts up and running that provide this communication layer, the last bit missing was Max being able to execute Python scripts and catch Python’s outputs.

We’ve achieved this with IronPython and a bit of C# magic.

Even though IronPython is different from CPython (the regular distro), it provides some additional functionality and mainly, it communicates flawlessly with dotNET. Another area that Max is well tied to. So this made for a perfect match! All we needed was a layer, a bridge of some sort, that’d make IronPython play nice with Max and vice versa. What we have right now is a very early Alpha build, very simple, elegant and light, that does just that! Maybe, if Autodesk doesn’t do it for us, we might extend this functionality beyond a simple communication layer and might actually make Python scripts command 3ds Max, so that we will be able to create objects, modify them, manipulate with the scene etc… etc… all directly via Python’s code. But for now, all I need is a two way communication tunnel that bridges the gap between MAXscript and Python. So far, we can run directly Python commands/scripts from within MAXScript code and we can run Python script files stored on the HDD and return results in MAXScript.

Here’s a sample of what we have right now:

We’re working on proper data type wrapping right now. So far, we’ve got INTEGER, FLOAT and STRING types as well as DOUBLE type (naturally) being properly translated between MAXScript and Python. Hopefully I’ll have all the various data types being correctly translated to and from MAXScript and Python by the end of the week.

Also, the beauty of it is that it’s based on dotNET code and it was compiled independent on CPU architecture, which means it runs as fast and fine on both x86 machines and versions of Max as on x64 platforms. The other huge benefit is it is independent of 3ds Max entirely. It only requires dotNET Framework 3.5+ and IronPython libraries, but doesn’t require a recompile if I need it running under Max 9, 2008, 2009, 2010 or any other future versions of Max!

It is obviously not as robust or complex as Blur’s latest Python plugin, but thanks to that, it’s very versatile and flexible, which is great!

Basically, Structs are these overly simplified custom classes know from such languages as Python (to which I’ll try to compare these). However, Structs are really so simple that they don’t even implement such functionality as inheritance (a pitty by the way), or more advanced functionality known from Python. Structs, rather than classes, could be called groups. That’s what I’ve been using them for mainly. I grouped a bunch of functions and called them via a standard attribute reference paradigm.

Here’s a super simple Struct encapsulating a function that prints “HELLO WORLD”:

struct tstStruct
(
	fn printHello =
	(
		print "HELLO WORLD"
	)
)

You can then call the function via it’s parent, the struct, like this:
tstStruct.printHello()

A very convenient method for grouping tons of functions together and not messing around with namespaces or any other, possibly existing, names in your MAXScript session. However, after I read the article on avoiding using global variables at all times, over at tech-artists.org, I discovered new possibilities and immediately started writing much cleaner and more elegant complex scripts! However, since I’m used to classes from Python and I’ve never used variables inside Structs, I bumped into a problem I didn’t know about. When you declare a struct with a variable in it, the variable isn’t immediately accessible from the outside of the Struct, you have to, sort of, initialize the variable at first. This is what I did wrong:

struct tstStruct
(
	myVar = 0.,

	fn printHello =
	(
		print "HELLO WORLD"
	)
)

I simply assumed that the variable is there and I can access and modify it at will. But I was wrong. You see, accessing the variable myVar right after the Struct’s declaration will throw this error:

-- Unknown property: "myVar" in #Struct:tstStruct(
  myVar:<data>,
  printHello:<fn>)

What I didn’t know was that I had to initialize the variables in the Struct in order to be able to access them. The problem was that Structs don’t provide special methods (functions) for such things as Python does, for example. So I couldn’t use something like the __init__ function. I fired up the MAXScript reference and read that in order to initialize the variables, I have to assign the Struct to a new object and explicitly assign to the variables, which is highly inconvenient, by the way. Anyways, here’s how to do it:

struct tstStruct
(
	myVar = 0.,

	fn printHello =
	(
		print "HELLO WORLD"
	)
)

clsInst = tstStruct myVar:0.

At that moment, you have to call the clsInst object in order to access all the functions and all the explicitly declared variables:

clsInst.myVar; clsInst.printHello()

Now it works as it should and I can use the variable inside the Struct to assign to and read from in my scripts, which is a very good practice as I’ve learned

Let’s see how it’s done in Python. Python’s classes are the real deal, they support such advanced features as inheritance, multiple inheritance even, and also provide a much, much broader functionality, such as special methods. However, there is a bit of similarity between MAXScript’s Structs and Python’s Classes. Let’s see:

class tstClass:
	myVar = 0.

	def __init__(self):
		self.testVal = 10.

	def printHello(self):
		print "HELLO WORLD"

The simple code example above declared a new Class object named tstClass. The Class itself contains a variable object, myVar, a mandatory __init__ method and a custom function, printHello, similar in functionality to the MAXScript counterpart. However, the similar behavior of the Class and the Struct is in that when I call the Class directly and ask for its myVar variable, I get a value of 0.0, which is correct, since I haven’t initialized the Class object yet and thus the __init__ method wasn’t executed. The similarity is in that the Class wasn’t initialized, but I can still access the variable myVar without Python throwing an error. Which was what I assumed from MAXScript at first.

However, as soon as I initialize the Class by assigning the object to a new variable, I execute the __init__ method and thus overwrite the myVar variable with a value of 10.0. By calling this code snippet:

instCls = testClass()

print testClass.testVal
print instCls.testVal

I get this output:

0.0
10.0

Meaning that the myVar value called upon uninitialized Class is still the default 0.0, but as soon as the Class gets initialized, the variable gets assigned a value of 10.0 in the __init__ special method.

Unfortunately MAXScript doesn’t utilize special methods for its Structs, thus the initialization is a bit cumbersome and unintuitive, also quite inconvenient when having tons of variables in the Structs. Same goes for the self special object that references objects inside the Class, which is very handy.

EDIT: As Mathieson pointed out in the comments below, you don’t need to explicitly call the variables when instantiating the Struct. All that really is needed is to instantiate the Struct properly for the inicialization process to take place and then you can access all the variables within the Struct. Thanks again to Mathieson for pointing that out!

Yes! Once again, Blur studio showed how it’s supposed to be done.

They’ve released, or allowed their Eric Hulser to release, an updated version of their blurPython modules for 32bit and 64bit 3ds Max versions from Max 9 all the way up to 2009! And not only that. They’ve also provided libs and modules for tying up Python, 3ds Max and Qt together! This is massive news as I’ve been trying to get Python (concretely IronPython) work in 3ds Max but I’ve been constantly hitting road blocks until I finally bumped into Blur’s updated blurPython.

The problem with IronPython would be the .NET classes that are required in order to embed IronPython inside 3ds Max. Since I don’t know C# at all, I’m not able to write custom wrappers to use in this combination, unfortunately. Another issue would be incompatibility with other programs that already run Python natively, such as Nuke or Maya, that I want to tie together under one managed pipeline environment in my studio. IronPython is a Microsoft opensource project that brings Python programming to .NET or vice-versa, which is great on many levels and I was really excited on bringing this to Max, since Max is already pretty tied in with .NET and I thought this might have been the best and easiest solution.

Well, nevermind, I’ll leave that part on Autodesk, if they ever decide to bring Python to Max. But for now, I’ll be happily enjoying Blur’s blurPython effort with Qt, which I was about to learn anyways (I bought a Rapid GUI Programming with Python and Qt book a while back, but haven’t gotten to reading it yet).

After a few minutes fiddling with Python 2.6, Qt and a bunch of modules required in order to make blurPython run under Max, I’ve finally managed to get Python code executed and working correctly in Max!

And with a bit of help from Thorsten Kaufmann, I also managed to get Python code up and running from an external editor, which is very useful! Although I use SciTe, which got implemented as a MAXScript Pro Editor in Max 2008, I believe, I can’t get lexer and other language syntax up and running in it since it’s heavily modified and fit for MAXScript only, which sucks. So I use SciTe externally for Python and simply run the code from there to show up in Max.

The only drawback of this is the fact that we’ll be 100% dependant on Blur for maintainig these plugins and modules. Well, modules won’t be an issue, these are open-source, but the parts that are closed-source are inaccessible to other programmers. So, whatever Blur decides to do with their plugins, we’ll have to go their way. Which is a bit problematic for a studio to rely their entire 3ds Max pipline on this (like mine). But we’ll see, maybe Autodesk will acquire or at least somehow officially support Blur’s efforts. Maybe Blur will decide to release the package as an open-source project to the public, or perhaps as a commercial package? If not, we’ll still be dependant on on thing or another, but this might prove to be either a huge win or a huge loss situation. The pros are, thankfully, huge for me, at least. So I’ll take the risk and adopt blurPython in my pipeline, since I need it for accessing Tactic projects and SObjects from within Max.

I’ve gotten sick of the defaultly setup auto-indentation in MAXScript Pro Editor as I’m too used to the old-school MAXScript editor found in Max prior to 3ds Max 2008. Thankfully, since somebody at Autodesk had the brightest idea of implementing a very well-known and well-used Scintilla based text editor, we’re allowed to tweak and change any of the editor’s settings to our liking!

I simply love total control over what I do and how I do it. So, changing this behavior was a must for me. I opened up the SciTE documentation and looked up the auto indentation options. Thankfully, there was the one and only command that I needed in order to override the lexer pre-defined indentation for MAXScript code:

indent.maintain.filepattern=1

Easily enough, replace the filepattern property with $(file.patterns.MAXScript) and you’re done!

To include this tag in the actual MAXScript Pro Editor, open the MXS_Editor.properties file and paste this code below line 112 which should read: “#indent.auto=1″ (if not, for the sake of tidyness, paste the line in the “#Indentation” area):

indent.maintain.$(file.patterns.MAXScript)=1

That’s it, now SciTE behaves exactly like the old-school MAXScript editor, indentation-wise, of course

One of them is, as Adam describes, utilizing Python from within Max and call its native MD5 functions. There are two ways, but both are very limiting. One of them is registering a COM server from within Python and calling the functions through OLE objects from Max. The other possibility is using blur’s implementation of Python’s interpreter, blurPython, and calling the module, somehow, natively. Both of these methods work and are quite easy to setup, however, both of them are very hard to be deployed in a more complex environment.

What I need is an integrated MAXScript solution that yields the same result as the MD5 implementation in Python, so that I’ll be able to directly compare results from within Maya and Max for example. After searching the web and looking into the MD5 algorithm I quickly realized that re-writing the algorithm myself in MAXScript isn’t the way. But thankfully, Microsoft implemented a vast number of hash algorithms into its .NET framework as I learned on the web, so this looked like the obvious choice.

After a few minutes at the MSDN central I found what I’d been looking for. An actual MD5 implementation. However, as .NET is quite a comprehensive and large framework, the implementation isn’t as straight forward as the one found in Python. Nevertheless, all you need are two classes:

"System.Security.Cryptography.MD5"
"System.Text.Encoding"

These are the .NET strings you’ll need for instancing the classes in MAXScript. So, let’s take a look at the code block:


md5Class = dotNetClass "System.Security.Cryptography.MD5"
encoding = dotNetClass "System.Text.Encoding"
MD5 = md5Class.Create()


In this block, I’ve declared three variables, the first two were instances of the .NET classes and the last one, MD5, is a newly created object from the Cryptograpy.MD5 class called by the .NET .Create() method. You have a few options for the method to specify how the MD5 algorithm should treat your input, but I left it at default as I don’t need anything specific.

Now we are set to go through the last step, which is providing the MD5 object with arguments for computing the hash. This is done through another .NET method called .ComputeHash(). Unfortunately for us, the ComputeHash method only accepts either a Byte[] array or a Stream object (not sure whether it’d take a Max’s fileStream object directly, but mu guess is it wouldn’t) to generate the hash based on the input data. This is where the System.Text.Encoding class comes in handy, because it has a method for converting a string through a concrete character table (ASCII, UTF-8, etc…) to bytes. I’ve chosen the UTF-8 even though I’m certain I’m not likely to use anything beyond the ASCII table definition. The procedure to get the byte code of your string is as follows:


encoding = dotNetClass "System.Text.Encoding"
encoding.UTF8.GetBytes(myString)

Bear in mind that you can use different character tables to facilitate your concrete needs, but basically this is all you need to pass the MD5 function to calculate your checksum. With this knowledge, the following code is all there is to calculating correct MD5 checksums inside 3ds Max:

md5Class = dotNetClass "System.Security.Cryptography.MD5"
encoding = dotNetClass "System.Text.Encoding"
MD5 = md5Class.Create()
hashArr = MD5.ComputeHash(encoding.UTF8.GetBytes(myString)) -- it's smarter to store the resulting array of byte values for later manipulation


The interesting part is that by default, this method returns an array of decimal numbers:

#(13, 87, 80, 212, 152, 226, 236, 248, 58, 163, 91, 29, 33, 199, 60, 102)

I don’t know of any .NET method or a property that’d return a standard hexadecimal value as we’re used to from, for example, Python. However, it is easy to overcome with a formatting function (since Max 2008 or with an AVG extension in previous versions) called formattedPrint. I wrote a custom function that solves this whole issue and does exactly what you’d expect from a natively implemented function, it simply expects a value and returns a hexadecimal (correctly formatted) string. Make sure you check the documentation for the correct formattedString arguments as they are quite important in this case for correct formatting of the hexadecimal values! Here’s the code:

fn MD5Checksum input =
(
    md5Class = dotNetClass "System.Security.Cryptography.MD5"
    encoding = dotNetClass "System.Text.Encoding"
    myHash = "" as string
    myString = "" as string
    try (myString = input as string) catch (return false)
    MD5 = md5Class.Create()
    hashArr = MD5.ComputeHash(encoding.UTF8.GetBytes(myString))
    for o in hashArr do
    (
        myHash += formattedPrint o format:"02x"
    )
    return myHash
)

To sum this up, let’s compare this custom MD5 function based on .NET classes with Python’s native implementation. For the sake of completeness, here’s the code you’ll need in order to generate an MD5 hash in Python (I’ll use the same name “myString” for the string variable as in the MXS example above for clarity):

import hashlib
hashlib.md5(myString).hexdigest()

Yeah, I know, very simple, isn’t it Yet again, Python kicks some serious ass here! Anyways, let’s test it on a long string (just to make sure both of the methods yield the same result) like:

"ThisIsAVeryLongStringThatIsHardToReadButShouldStressTestBothMethodsEnough"

Both MAXScript and Python return (strings):

"0d5750d498e2ecf83aa35b1d21c73c66"

So, this is it, now you should be more familiar with .NET classes, how they work from within MAXScript and that the whole .NET framework is one hell of a good job by Microsoft for developers of any kind, such as TDs working in DCC applications, which is sweet!

To save you some time, don’t bother trying to connect to the database (db for short) via the standard example:
DogConn=createOLEObject "ADODB.Connection"
DogConn.Open "driver={SQL Server}; server=localhost; database=test"

output:

-- Runtime error: OLEObject method call failed:
Error Message 1: [Microsoft][ODBC SQL Server Driver][DBNETLIB]SQL Server does not exist or access denied.
method: open()

This concrete driver is a Microsoft SQL Server driver, so obviously, this doesn’t make much senese to use this method for connecting to a MySQL database. Since there are numerous ways of setting up the connection via different providers or drivers I was lost. But thankfully , Sun provides its own ODBC connectors for various operating systems, including 64bit versions for Windows. So download the one that fits your OS and after installing it, just check what name the driver has assigned in the Data Sources(ODBC) under Administrative Tools. It should read “MySQL ODBC 5.1 Driver”, which is exactly what you need for successful connecting to a MySQL database. Easily enough, from the comprehensive list of example connection strings found at ConnectionStrings.com I was finally able to write this code:

DogConn=createOLEObject "ADODB.Connection"
DogConn.Open "Driver={MySQL ODBC 5.1 Driver};Server=serverName;Database=dbName;User=userName; Password=password"

Even though it returns “undefined”, don’t be alarmed, this is a good thing. So, now you’re good to go and start fully appretiating the whole database purpose and design!

As for dotNET. It’s much easier (as it’s Microsoft’s next “big thing”) to code for and also you’re less likely to bump into similar problems. Again, download the latest .NET connector from Sun and try executing this snippet in Max 9+:

dotNet.loadAssembly "C:\\Program Files (x86)\\MySQL\\MySQL Connector Net 5.2.2\\Binaries\\.NET 2.0\\MySql.Data.dll"
DBConnection = dotNetObject "MySql.Data.MySqlClient.MySqlConnection"
DBConnection.ConnectionString = "Server=192.168.1.14;Database=test;Uid=root;Pwd=root"
DBConnection.open()

dotNET works in a slightly different way. Instead of loading up a provider or service, it loads up an “assembly”, which is a dll, in this case Sun’s .NET connector, and then allows you to work with its methods. So I first loaded the dll up, then fired the dotNetObject function, then I specified the connection string and finally opened up the connection. Then you’re good to go!

Even simplier is the Python way of things, as usual All you need is a MySQLdb module available at SourceForge.net, install it for your version of Python and then try running this code:

import MySQLdb as db
conn = db.connect("serverName","userName","password","databaseName")

Now you’re ready for some serious querying! It really is this simple and that’s why I’m really loving Python. Anyways, these were just a few examples of how to connect to a MySQL database via ODBC, .NET and Python, which is really all you’ll ever need for connecting to MySQL from 3ds Max, Maya or XSI.

There is a simple way to get object’s transformation value in their parent space, the equation is as follows:

objectsOffsetTM = $myObject.transform * inverse $myObject.parent.transform

The resulting matrix3 value yields the exact transform of the object “MyObject” extracted in its parent space, which is extremely useful if you’ve done some, slightly advanced, rigging. Now, from this equation and with very basic math knowledge, one’d assume that when the only unknow in this formula would be the $MyObject.transform value, you’d divide the entire equation by the “inverse $MyObject.parent.transform” value and so you’d get something like this:

$myObject.transform = objectsOffsetTM / inverse $myObject.parent.transform

In fact, this is not possible as there’s no formal mathematical way defined for matrix divisions. Trying to do this will produce an error. However, with a little knowledge of math, you’ll be able to quickly rewrite the equation so that it uses defined math methods for matrices and get the transform for your object. In my case, however, I didn’t want to calculate the object’s parent space transformation from its own parent, but instead, I wanted to calculate the object’s parent space transformation from a completely separate object, which, in fact, lied on a totally different level of the hierarchy (in my rig). So, instead of using the formula above, you’d only swap the “parent” transformation value for a completely different transformation value, like so:

$myObject.transform = objectsOffsetTM / inverse $differentObject.transform

This formula is to give you an idea (off of the names of the variables used) what I needed. Now, this still throws an error, since, as stated above, you can’t divide matrices. How did I go about this issue then? Let’s use a simplified example to show the math principle behind this. The equation I’m using here is of this kind:

x = A * B

But, what if you don’t know “A”? How do you get the unknown “A” then?

A = x/B

Great, we finally arrived at the very destination which isn’t possible, as we can’t use divisions. Think for a second a division is inverse multiplication, right? So, a variable “B” has to be inversed in order to use multiplication in the equation above. How to do that? Simple, a “B” on the power of 1 yields exactly the same value “B”, right? Inversion is defined as a power of “negative” exponent, which in this case is -1, so, the modified equation with this knowledge applied looks like this:

A = x * B^(-1)

That’s it! That’s all I needed for calculating the object’s transform from a known offset and a known different object transform. There’s only one little problem left to solve. How do you square a matrix? It’s easy when the exponent is positive, however, what if, like in this case, the exponent is actually negative? The math definition for non-positive exponent square in relation to the matrices is their “inverse” value. Thankfully, there’s a function in Max that does exactly that, it’s logically called “inverse” Now, there’s nothing standing in our way to solve the problem! The resulting equation with all the math involved looks like this:

$myObject.transform = objectsOffsetTM * inverse(inverse $differentObject.transform)

You can simplify this as inverting an already inverse matrix is the matrix itself:

$myObject.transform = objectsOffsetTM * $differentObject.transform

See how simple that is This equation in practice applied to an object in a scene looks as if the object was linked (parented) to the master object, while in fact, it’s not, which was the whole point of this example:

One last note about matrices, don’t forget that matrices are not commutative, which means that A * B != B * A, so in this case the differentObject’s transform has to be pre-multiplied by the objectsOffsetTM matrix and not the other way around.

(the video lags a bit, but the entire rig is actually faster than real-time)

Aside from bumping and dealing with a few 3ds Max “quirks”, I actually had to solve quite an interesting problem. When I start setting up a system/rig or working out a tricky problem I begin with the simplest possible scenario, so in this case I started with a simple one dimensional solution to the rotational problem. I simply sent the wheel master (that dragged all the helpers along) in one direction I wanted the wheel to spin. Obviously, this was the “forward” direction so that the wheel could actually turn. You can read about this simple solution at Paul Neale’s web, I simply based my solution on his procedure. However, as I said, this is only a one dimensional approach, which means, the system spins the wheel no matter which direction it travels. Besides, Paul’s example doesn’t take local rotation of the wheel into account. I needed a more robust solution: first of all, I needed a system that’d spin the wheel only when travelling forward or backward relatively to its orientation, so that it wouldn’t spin if, for example, the wheel was oriented perpendicular to the direction of travel. Secondly, I needed the wheel to “stick” to any given surface as it’d be used in an animation where the animator would, preferrably, only setup a direction of travel and the rig would take care of the rest of the secondary animation for them. This brought a new problem up as I’ll describe later.

So, back to the one dimensional solution. Essentially, all you need is a value about which the wheel center will spin. You can calculate that quite easily by multiplying the travelled distance by the circumference of the wheel. The circumference is 2*Pi*r, where r is the radius of the wheel. However, you subdivide the circumference by 6.28319 in Paul’s example, so, you can simply skip the 2*Pi calculation as that’s essentially the same value. In the end, all you need is the total distance travelled ‘v’ (which is NOT a vector!) and the radius of the wheel. The formula is super simple: rotation = v/r. That’s it! Really, there’s no catch to that, it simply works. Another note to take into account is that the whole system is history dependant, which means it has to start at a specific time and it has to be provided (updated) with a constant Dt (delta t = time step). So, go ahead and prepare your scene like in Paul’s tutorial.

Done? Good. You should now end up with a wheel that spins when moved in its “forward” or “backward” direction. The problems start when you move the wheel sideways, it still spins! Why is that? Well, the whole system is based on a position of the wheel in space, which, in other words, means a vector pointing from the origin to the wheel’s pivot. The other problem, directly associated with this approach, is that it doesn’t respect the local orientation of the wheel. I wanted to find a solution to this problem as well.

A local vector pointing in the direction where the wheel will be travelling was the obvious choice. But how do you get such a vector? You can’t derive the local direction of travel from the object itself as is. A vector is a direction with a magnitude, which is very important to realize, especially if your system is heavily dependant on both. So, to get the correct vector pointing in the direction where the wheel will be travelling AND having the correct magnitude of the actual speed of the wheel, you need to compare two points in time-space (master being a point helper controlling the position of the wheel):


local posIncrement = 0.0 as float
posIncrement = master.pos.y - (at time (currentTime-1) master.pos.y)
rotation = (posIncrement+storedDistance)/(wheelRadius)


I just used the at time context to get the object’s previous x position and subtracted it from the current object’s x position. However, this method yields only the magnitude I was after, not the direction I also needed. So how do you go about this? First the theory: if you need to get a direction vector between two points, you need to subtract the two points in space, then, you can ask for the vector’s length to obtain its magnitude. So, basically, I subtract from a position at time t position at time t-1 and get the difference vector, which yields the direction the wheel will be travelling. The problem is, this doesn’t solve the problem with the wheel’s local orientation To cover that, you need to multiply this resulting vector by the direction vector, which in my case was the Y axis as the wheel was originally aligned to the identity matrix when I was rigging it. The final snipped for this step looks like this:


local posIncrement = 0.0 as float
posIncrement = length((master.pos - (at time (currentTime-1) master.pos)) * master.transform.row2)
rotation = (posIncrement+storedDistance)/(wheelRadius)


This gets me the positional incremet in the wheel’s local Y axis (row2 of the transform matrix is the projection vector of the object’s Y axis), if the Y axis is fully aligned to the direction it travels, the multiplication ratio will be 1:1 (if normalized! you should never scale control objects, due to this behavior!). So, this was it, I solved the problem in 1 dimension in respect to the local orientation of the wheel!

However, there is another problem when you extend the system to the point that the wheel actually sticks to a surface. The problem lies in the wheel’s Z direction it can travel as it adds to the final rotation. Why should I be concerned about the Z axis? Well, imagine a very rough terrain the wheel would be travelling on. If you move forward, it spins correctly without any “sliding”, however, if there’s a big bump in the way, the wheel actually spins slower than it should, because it only counts on the translation along the Y axis (in my case), not in the Z axis! A wheel is actually a two-dimensional object, like a circle, which can spin when touching any of the two world planes in the 2D space. Sphere, for example, is a fully three-dimensional object that can spin in any direction when touching any of the three world planes. You can see the result of the 2D solution on the video above where the wheel nicely sticks to the rough terrain no matter which direction it travels (as long as it’s aligned to the direction). So, how do you go about that? Well, you need to extend the whole formula into another dimension. In this case you need a two dimensional solution that’d take care of the translation in Y and Z axis. The script snippet would then look like this:


local posIncrement = [0.0,0.0] as point2
posIncrement.x = length((master.pos - (at time (currentTime-1) master.pos)) * master.transform.row2)
posIncrement.y = length((master.pos - (at time (currentTime-1) master.pos)) * master.transform.row3)
rotation = (length (posIncrement+storedDistance))/(wheelRadius)


Notice the use of a point2 data type in this case. You need to store the positional increment for the Y axis as well as for the Z axis. You then sum it up with the stored distance value (also of a point2 data type) and ask for the length of the resulting vector, which gives you the magnitude, which is the distance the wheel travelled in the last time step.

That’s pretty much it, well, at least the most difficult part, there are other problems I had to face, which I don’t consider that difficult to solve, like the actuall snapping on the surface or dealing with negative time increments (i.e.: scrubbing through the time slider backwards) or dealing with Max’s script controllers not updating custom attribute variables correctly, which is an annoying bug. Well, I hope you’ve enjoyed this article at least as much as I enjoyed solving this little puzzle

Take a look at this short video capturing the result of modeling a noise procedural:

My approach used a very simple way of “sampling” points in space and testing, whether the noise texture in that particular point has a value higher or equal to 0.5 (again, you can choose whatever number you like, the range is from -1 to 1 for noise textures, I only scaled the resulting value to a 0 – 1 range, so 0.5 represents a value of 0.0). I chose a cubic volume (a box) in which I sampled 125 000 points and tested every one of them whether they lie in a color value higher than 0.5. The result yielded 67 632 actual TRUE values, which means that the algorythm created 67 632 point helpers in the exact spot where the color value of the noise function was higher than 0.0 (remember, I scaled the noise, so the test value was 0.5!). The final result can be seen in the short video above.

Now, how did I go about it. Firstly note that I wrote this algo. in about 1 minute so it’s nowhere near being optimized or “clean”, but it was so simple to write I sticked with it, besides it worked, so, for the sake of the experiment, I didn’t bother investing more time into optimizing it etc… The basic idea is to sample a point in three axis in a given volume. The volume was specified by the box I created at the begining. I simply used it’s .min and .max properties to get the exact bounding box of the object (at first I wanted to try to sample points in a sphere, but then I ditched the idea as writing the actual sphere volume in a script would delay me too much from the experiment I wanted to perform) and then three loops to go through all the values in each of the axis in the volume by a certain increment (remember, you cannot calculate infinite formulas ). Here’s the script that did all the work for me:


step = 2
volume = $Box01
for i = volume.min.x to volume.max.x by step do
(
    for j = volume.min.y to volume.max.y by step do
    (
        for k = volume.min.z to volume.max.z by step do
        (
            if noiseVal = 0.5*(1.0+(fractalNoise [i/20., j/20., k/20.] 0.5 2.0 5.0)) >= 0.5 do
                (
                    pt = point size:1.0 centerMarker:false axisTripod:false cross:false box:true constantScreenSize:true drawOnTop:false wireColor:white
                    pt.pos = [i, j, k]
                )
        )
    )
)


I told you it was simple! The for loops go through the individual directions in the tripod-axis and stop each 2 units in that direction (in this case, the variable step controls this sampling) and tests whether the noise color value is greater than 0.5 then it continues on with the next point and so on and so forth. Each time it hits a value greater or equal to 0.5 it creates a point helper. That’s it, that’s all it does. Obviously, this could be pushed much much farther, for example, you could actually model a geometrical object based on these values, but, quite frankly, I don’t think I’d be able to code that as that’d require some really complex algorythms to just generate the mesh from vertices it creates. But it’d be interesting to see what the actual mesh would look like as the points look a bit chaotic and blend together, visually.