I’ll elaborate on this topic some more later, but I thought I’d let you know that I’ve successfully deployed, configured and tested Prime Focus’ Deadline®, the render manager of choice for duber studio.

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)

If you still haven’t bought the book yet, DO IT NOW!

Or at least, do it after you’ve read this thorough review of the book.

I can’t resist to quote what the reviewer is saying about my chapter, of which I’m quite proud, obviously.

The advanced unwrapping chapter I found very useful as unwrapping is not my strongest skill in Max. By the way, none of the authors are shy about suggesting outside plugins and stand alone utilities if they think they will do the job better or at least faster than Max. In this Chapter 4 Lukas Dubeda suggested a small separate program for UV layouts that I downloaded to try myself. It does seem to be quite capable at getting the job done. The following sums up this section pretty well:

…

That “…just scratching the surface” seems to be the sentiment of many of the experts in this book. Believe me that they are all making some pretty deep scratches, providing us with an in-depth look at their chapter’s topic.

Anyways, here’s the full review for those still undecided.

Evermotion.org published a nice, short, overview of the 3ds Max 2010 Advanced To Expert book I participated in writing. Here’s what they have to say about my chapter:

The fourth chapter reveals us advanced techniques of unwrapping 3d models. We are taught how to handle both organic and non-organic objects using such features as multiple UVW spaces and pelt mapping. Keeping in mind the fact that 3ds Max does not provide us with powerful enough unwrapping tools, the author introduces us other interesting solutions – UVLayout, Unwrella and other, less known programs and plug-ins. Moreover we are instructed how to generate normal maps inside 3ds Max 2010 using texture baking. Again .max files from the CD become more than useful.

Definitely go check the book out, it’s really a brilliant piece of work put together by top-class artists in the field and as such will be an invaluable asset in everyone’s tools arsenal.

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.

The 3ds Max 2010, Advanced to Expert book is finally shipping! And I already got my bunch!

At first sight, the book is a monster! 20 chapters, all approximately 30 pages each, plus the gallery and some additional info. I’d say the book has about 700 pages (the pages don’t have numbers, only each chapter has its own set)!

The book is beautiful, printed on a very high quality paper, in full color, at high res. But what’s most important is the information it conceals. Simply brilliant!

I couldn’t have resisted the shameless self-promo

Definitely go preorder the book, if you haven’t done so, as it’s really worth every cent!

Hands down, the updates are really not about new big features at all, this time. Well, maybe except for Maya 2010, which’ll, for the first time in years, come in one version only, just Maya 2010, no Unlimited or Complete (which was confusing anyways) and will include Toxik (altough called Maya Composite) and MatchMover.

I still haven’t seen any presentations of these new features, but I’m really looking forward to that. Even though I really dislike the idea of having Toxik inside of Maya by default. I never liked that compositor, always felt very “Flame-ish” and therefore “odd” to me, being used to Fusion or Nuke. But still, I’ll save my judgement after I see a demo.

Autodesk also announced a 3ds Max 2010 SP1 release, which is always good, if it wasn’t for “subscribtion customers only”, which is, in my opinion, bullshit!

Then Softimage 2010 with some minor additions and bugfixes. Notably f-curve editor really needed that sweet touch and Scintilla, which I really felt in love with after it was included in 3ds Max, is also a very nice additon.

They’ve also announced digital production Suites, which seem to be a great idea, possibly taken from Adobe, that you’ll be able to buy a bundle of 3ds Max/Maya, Motion Builder, or even 3ds Max/Maya, Motion Builder, Mudbox. If the prices are “reasonable”, I’m sold!

As I’ve said, I’ll wait for tomorrow’s demos to pass my judgement on these new releases, so, stay tuned…

I received a word, that the 3ds Max 2010, Advanced to Expert book, I’ve contributed to (1 chapter + a tech. review of the MAXScript Chapter), had been sent to the printer and thus is on schedule to be ready for shipment in August! This is great news and I’m really looking forward to the publication (I’ll receive a copy of the book, which is awesome ).

If you’re still hesitant to preorder, 3DATS has put up a few pages from each of the beefed-up chapters for your viewing pleasure, go see them on the book’s page.

But if you want to stay on my blog here are the direct links for you:

The full table of contents in PDF
The sample pages from all of the 20 chapters, also in a PDF

I very highly recommend this book for any advanced (not limited to 3ds Max) user, from what I’ve seen, it’s a massive publication full of the juiciest information on the subject. If I didn’t receive a complimentary copy of the book, I’d have preordered one as well as there are some chapters I’m particularly looking forward to read (Color Management, Compositing, Managing Large-scale Projects and pretty much the entire sixth part of the book).

For only $99.90 USD + Shipping, this is a bargain! Coz’ remember, education is the only thing nobody can take away from you