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)

Here are my top 10 reasons why FrameCycler is the single best sequence player on the market:

• It is 64bit.
• It supports very flexible 3D LUT files.
• It sports very robust review and edit features.
• It does Stereo pretty damn good and fast.
• It is rock solid and reliable.
• It is extremely fast.
• It supports command line input.
• It plays nice with other production tools.
• It has amazing support.
• It is really cheap.

If you still preview your sequences in an absolutely obsolete and impossible RAM Player in Max, or terribly outdated and rigid FlipBook, do yourself a favour and buy a license today!

I’m still amazed how useful DOS can be, even in 2010! And the main reason I thin it’s the most revolutionary OS of all times is that it actually brought the entire PC industry to regular folks’ hands.

Now, by DOS, I’m actually referring to the simplest form of OS environment, IO.sys, MSDOS.sys and COMMAND.com. That’s all you need in order to communicate with your system. That’s all you need to actually get some work done! Isn’t it amazing?

Obviously, Windows and MacOS heavily extended the OS functionality and brought something else in the game. But that’s just evolution. However, DOS on the other hand was truly revolutionary. I may be skipping some other important OS attempts, but DOS was the first OS I ever used as a little kid. I remember when I was about 8 or 9 years old, my grandpa had a, at the time, high-end 286 computer, 512KB of RAM, some 30MB HDD, it was a beast! and it was running DOS. I learnt a few basic commands, such as CD, MD, CLS, COPY etc… just to be able to run Prince of Persia or Wolf3D

A few years later, when I started a high school, one of the computer classes started with a comprehensive DOS course. We learnt all the tricky bits and hidden gems of the OS. We learnt to use batch files effectively, escape sequences, pipes, even a bit of BASIC programming. This was in 2003.

Obviously I don’t have to tell you how much time I spent in DOS trying to configure or repair my Windows 95 or Windows 98 installations.

Then Windows 2000 came along, the first NT OS for the masses, in my opinion, which desperately tried to get rid of DOS for the users. There were several reasons for it. One of them was the NTFS file system. You simply weren’t able to access those NTFS partitions from DOS. Another was security. This is also tied to the NTFS, but security was a big concern. Another reason was the fact that Microsoft, ever since it introduced MS-DOS, tried to get rid of it. They wanted people to use Windows exclusively and not the cheap OS alternative. But even so Microsoft added an RConsole (I believe the name was? I might be mistaking it for the RAdmin in NetWare?).

Funny thing is, even nowdays there are software companies that still write software for DOS. Mainly database systems for large enterprises, like Post Offices, Banks, Account Management companies etc… This really surprises me on one hand, on the other, it makes some sense. You can run DOS on your wristwatch, it doesn’t multitask (well, there are programs that allowed a limited amount of multitasking) which means it can’t run viruses effectively without the user noticing, it’s pretty bulletproof (because it’s extremely simple) etc…

Now, it is 2010 and I still use DOS from time to time. Obviously not that often, but recently with the addition of a dedicated server and a network storage to my studio, I’ve spent a lot of time in DOS configuring the storage controllers, BIOSes and running other little utilities. It’s interesting how important this OS still is. And in my opinion we won’t get rid of it any time soon. It’s so simple, yet powerful, that people still need it for some lower level system configuration. One of the proofs of DOS’s power is the Shell. Sure it existed long before DOS in nix systems, which makes the point even more valid, it’s the simplest way of communicating with the system for the user. I wouldn’t be surprised if I was still using DOS to configure my uber-servers in my, by then, huge VFX facility.

That’s right! I needed to convert a fairly complex, proprietary, LUT for preview purposes to one of the IRIDAS’ formats. I chose .ilut, since it’s a really simple, yet, extremely powerful format!

Let’s take a look at the syntax first. On the online documentation IRIDAS site, you’ll see all the different LUT formats FrameCycler supports, as well as the syntax for those files. The .ilut format is pretty flexible. It supports either an XML (ASCII) syntax, or an inrerpretable script format. For my complex LUT I used the XML format. The LUT wouldn’t be of much use to you as it’s used on a specific machine with a specific graphics card, specifically calibrated display and generally a different color workflow than the rest of the machines at the studio. But, to demonstrate the usefulness of this LUT file format, I’ll show you my sRGB LUT I created a while ago using the interpretable script syntax for previewing linear images (OpenEXR for example).

But first, let’s take a look at the math behind the sRGB gamma curve. Basically, the sRGB standard specifies that whenever the input value is less or equal to 0.00304, the output value will equal to the input value multiplied by 12.92. In all other cases, the output value will utilise a slightly more complex formula, a 1.055 times the input value on the power of 0.416 (it’s a periodical float value, thus it’s being expressed as a fraction 1.0/2.4) subtracting the value of 0.055. Quite simple.

Here’s the expression in IRIDAS’ .ilut compatible format:

<IRIDAScript>

//sRGB LUT script

out = 0;

if (in <= 0.00304)
{
	out = in*12.92;
}
else
	out = (1.055 * pow(in, (1.0/2.4)) - 0.055);

red = out;
green = out;
blue = out;

</IRIDAScript>

As the documentation suggests, all the user variables should be pre-defined prior to being used. The out variable is my own variable that holds the output. The in variable is, I assume, a built in variable that holds the input value. The formula is simlpe, as explained above. Here’s the same formula written in Python, for those who struggle with the .ilut syntax (even though I consider it trivial):

output = 0.
input = .5 # in reality this will go through the whole interval of <0.0, 1.0>

def sRGB(input):
	if input <= .00304:
		output = input * 12.92
	else:
		output = 1.055 * pow(input, (1.0/2.4)) - 0.055

	return output

output = sRGB(input)

All you need is simply to save the .ilut script above to a file with the .ilut extension, save it in the LUTs folder within the FrameCycler folder, restart FrameCycler and you're done. You can then choose the LUT from the Calibration drop down list (lower right corner) to use the LUT on your Linear sequences. This will then calculate the pixel values (I think on a GPU, not sure though) for each frame and display the image in a correct sRGB format on your standard monitor.

As a side note, the huge benefit of using the script syntax as opposed to the XML format is that the values are being dynamically calculated, so, you're not constrained by the LUT precision.

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!

I finally received the Windows Server 2008 Standard (not R2) package via the terrible czech post service, so I can finally start to fully concentrate on the server side software development for my studio.

I’ll write about it some more later, when I actually have something worthy showing off

After a good two hours of looking around for the perfect Firefox theme, I bumped into two plugins that saved the day, Glasser and Stylish.

Glasser will conveniently turn most of the browser’s upper area transparent. Or rather, take advantage of Aero Glass’ theme.

But Stylish is really cool. It allows you to easily modify everything in Firefox, from the button colors, text highlights, to the menu width etc… and all using a simple CSS syntax. Really nice.

So, if you’re like me and hate the blueish shitstorm present everywhere in Aero Glass, or at least in Firefox, go get these two addons, they’re really cool!

I’m already having hard times getting used to the over-brightened workspace (dual monitor setup certainly doesn’t help), especially since I’m used to working late at nights. I adjusted most of my professional applications to make it a little more easy on me. I’ve brightened 3ds Max a little:

I’ve brightened Nuke a bit as well:

And of course, I had to brighten my beloved Total Commander:

And the last thing I want to customize is the web browser. I’ve been using Firefox for ages now. I don’t even remember when I installed it for the first time. The thing is, Firefox, by default, takes its UI from Windows, as most apps do. Including the terribly light blue tabs, address and bookmarks pane. It’s hideous, overbrightened and just ugly to look at all the time. I can’t get used to this. So I looked at tons of themes available for Firefox, however, most of them were even uglier, brighter or plain stupid. There weren’t many “neutral” or “classic” themes that I’d like. So I looked around for a different web browser since I’m not a very demanding user. All I need is my bookmarks and the internet banking to work, then I’m happy with whatever I have, perhaps except for IE, which isn’t that bad, but it’s an overkill for a simple web browser. Then I realized Google has released a web browser not very long ago, Chrome. That might be worth checking out. So I download it (in my virtual machine at first though) and gave it a quick test run. It runs everything I need (and I don’t need much, really ). So, I might be intrigued to switch to Chrome from Firefox, well, until perhaps they release 3.7 or maybe 4.x, which might look also nice and not distracting that much.

Anyways, I’m really trying hard to get comfortable and used to Aero, even though I think that at one point, if Microsoft finally gets its shit together, I might switch back to the classic theme, even though I like some of the Aero features, which are mainly just eye-candy I can certainly live without. In the mean time, I’ll try not to get blind from all the white on my two screens. And I was actually going to upgrade to a 30″ + 2x 24″ workspace. That’d kill me in the middle of the night while trying to open a folder in Explorer.

As you might know, I’ve upgraded to Windows 7 recently, however, I’m slowly starting to regret it.

I’m a bit choleric about certain things, especially when somebody enforces me to do, think or work the way they want. And I’m extra sensitive to bad UI designs.

I generally think that Aero and especially its Aero Glass theme is a very badly designed theme with terrible user experience, globally. Windows 7, however, bring this nonsense to a whole new level by almost strictly enforcing you to use Aero, because without it, it simply doesn’t work!

Here are things I absolutely hate about Windows 7. They are mostly tiny details, mainly UI related, but all the more they piss me off! Especially since they not only influence my overall Windows 7 experience, but, by their nature, they influence it all the times.

• Icons don’t show up under the mouse cursor while being dragged

• Icon spacing in the List View mode in Explorer is almost twice as wide as it was in Vista

• The entire idea of making programs “Pinnable” to the Taskbar, while praised as being ingenious, is ridiculously stupid. Not only is it positioned too far from the actual button, but it’s huge and I don’t want it to display pinning and other crappy info I already know. I admit it might be a bit useful in Aero with Live Previews and stuff, but in the old-school theme? Useless!

• Control pane icons order. Do I need to say more?!

• Bright text background color in search areas in Explorer everywhere in Windows 7

• Windows Media Player 12 doesn’t remember its last size, always starts in its default mini size, then grows to fit the playing video. Also, I like to see how far in the video I am, so I switch it to show the [current time]/[overall video length] info. But it never remembers it and when run again, always defaults to the factory defaults.

• Since I also loathe the User Profiles paradigm, I still understand its purpose and design, but the whole security bullshit is ridiculous. I have to run most of my productivity software with Administrator priviledges, while I also am an Admin on my workstation, which doesn’t make any sense! Without the Admin priviledges, those programs can’t write in their install directories (Program Files) which makes them unusable.

• Basically to make the system usable for a Power User who prefers raw computing power over, arguably, good looks, is a helluva work!

I had to tweak tons of Registry keys, fiddle around with services and more advanced system settings general users don’t even know are in Windows. So pretty much, it took me about three days to get to this point where I can’t seem to get the most annoying kinks ironed out (the icons not showing up below the cursor, the icons spacing etc…). This is not such a big deal for general users, as usually they don’t feel the need to setup Windows so deeply, since if it runs from the start, they’re happy about it. But I’m a fucking obsessed perfectionist and even the tiniest things usually piss me off so much that people get scared around me. Hell, even this character attribute of mine makes me want to kick my own ass. But I’m the way I am and I either learn to live with it, or make everything possible to conform my environment to my habbits and perfectionist liking, if possible.

Anyways, obviously there are things I love about Windows 7, but I think this makes for a more interesting read, instead of praising how super awesome this or that feature is, that you’ve probably read pretty much anywhere on the net by now