As you might know there has been a significant change in the latest Shotgun API that’s somehow transparent to the CPython users, but presents a rather significant roadblock for IronPython users (including our duberPython bridge, that is based on the IronPython engine).

First, let’s discuss what’s changed in the API so dramatically that it breaks IronPython compatibility. It’s the introduction of a JSON formatting that requires a few specific CPython libraries that are not available in IronPython. The effect it has on CPython users is a faster data transfer to/from Shotgun, but other than that, the API looks to be unchanged from a user point of view. You still keep calling the same methods and you’re getting back the same objects. From IronPython point of view, you’ll hit a roadblock as there are a few modifications you’ll have to make to the Shotgun modules in order to make them run in IPy without issues.

With huge thanks to the Shotgun Software support, I was able to work around the few limitations and start using the latest API without issues inside IronPython. Here’s what you have to do, in order to make this happen:

• First and foremost, download the latest Shotgun API from the github site. Place it some place you’d like to use it from, most likely in the Lib\site-packages folder, though my folder structure is completely different and based on different rules.

Now if you try to instantiate the Shotgun class, you’ll get tons of errors, so, allow me to save you a few minutes (hours in my case, to be honest) searching and working around them.

• The first thing you have to overcome the “IDNA” encoding, which isn’t supported directly in IronPython. This isn’t as clean and easy as it could be, though the workaround is rather trivial, but bear in mind you might break something potentially doing this. I haven’t come across any issues yet, so, I’d consider this modification safe. Find the iri2uri.py module in the httplib2 folder, open it and change line 71 from authority = authority.encode(‘idna’) to authority = authority.encode(‘utf-8′). This effectively changes the codec under which you’ll be dealing with the unicode strings. Again, it’s not a clean modification and you can potentially run into issues doing this, but in my experience, all seems to have been working fine so far.

• The next problem will be SSL authentication, which, again, is tripping IronPython’s SSL module. To fix this, open the shotgun.py module and on line 73 change NO_SSL_VALIDATION = False to NO_SSL_VALIDATION = True.

• Then IronPython will still be complaining about a module called zlib, which is a compiled CPython module that cannot be used inside IronPython. Luckily there is a C# variant based on the same code as zlib. Download it from Jeff Hardy’s bitBucket site and place it somewhere where IronPython can source it (i.e. within your PATH). I put it in a recommended folder called DLLs directly in the IronPython folder. This means that the IPy interpreter will source the DLL automatically, but bear in mind you’ll have to add a reference to this library manually in your scripts when run outside the shell.

• The easiest way is to add these two lines in your imports into the shotgun.py module:

  import clr
  clr.AddReference("IronPython.Zlib")

This way you’ll make sure the zlib module required by some of the shotgun modules is going to be readily available.

That’s it! Let’s test it. Oh, one more thing, I’ve found these Python variant couples to be perfectly compatible and working in production: IronPython 2.6.2 and CPython 2.6 and for clr4 folks IronPython 2.7.1 and Python 2.7.2.

IronPython 2.7.1:

duberPython (utilizing IronPython engine 2.6.2):

I hope this helps you out with your IronPython and Shotgun scripting and I’m certainly looking forward to the new versions of the Shotgun API.

A huge thank you to the Shotgun Software support team!

As with my previous post, I’m preparing a few handy tools for 3ds Max artists using Mari and Nuke. This bit is the fun part with Nuke: live communication between 3ds Max and Nuke.

Stay tuned!

I’m starting to write a useful set of tools for Mari and 3ds Max users. This is the very beginning – establishing reliable communication from 3ds Max’s MAXScript console directly to Mari.

I’ll keep you posted.

We’ve launched a brand new website, courtesy of our friends at refresh.cz, with some latest finished projects showcase, including our new demoreel. Head over to duber.cz and leave a comment if you like, hell, even if you don’t like the new site.

Thanks for watching!

The thing with 3ds Max is that regular expressions are foreign to MAXScripters and they don’t usually use them. I too am more used to regex in Python or IronPython than MAXScript. However, since we do have access to .NET in MAXScript, we can use its Regex class inside MAXScript.

Why I’m mentioning this and why could it be useful to you? I bumped into a little issue with my pipeline’s handling of rendered files. They assume to be exactly the same as I set them up in 3ds Max, which is logical and correct. However, since I started using Deadline’s SMTD script for submitting my files to the render farm, which takes care of handling the path remapping and storing, it also accidentally took care of letter casing. So, in the end, my render files were being saved all upper cased: “\\SERVER\PROJECT\RENDERS\ABC.EXR” instead of what I set in the Render Dialog: “\\SERVER\Project\Renders\ABC.exr”. The reason was simple, I used simple MAXScript substituteString() method to re-map my local paths to my server, UNC, paths and I converted everything to upper case just in case I got a mismatch:

substituteString (toUpper srcPath) @"D:" @"\\RAMMSTEIN\__UNMANAGED_PROJECTS__"

This wouldn’t be such an issue in a Windows environment, however, when you start dealing with path and file names in Python and you start mixing up casing, you can easily get burnt.

So, the only option left in Python would be to use the re module and search or replace strings based on regular expression matching. In MAXScript, however, we don’t natively have a re module and its methods, but luckily for us, we can use .NET, so that the previous method written in MAXScript using regex would look like this:

regex = dotNetClass "System.Text.RegularExpressions.Regex"
regex.Replace srcPath @"^(D[:])" @"\\RAMMSTEIN\__UNMANAGED_PROJECTS__"

This replaces the capital letter D in the source path srcPath with the UNC server path exactly the same way as the substituteString method above. However, since this is a regular expression engine you’re using, you can modify the search in order to match any casing, should that be your choice.

There are two ways of doing that. The ultimate way I chose in the end was to modify the search pattern to @”^([D|d][:])”, which matches both “D:” and “d:” in the source path and then replaces it with the UNC path at the end.

The other option you can use, should you choose to, is the RegexOptions Enumeration argument at the very end of the method call. If you want to ignore casing, just use this:

regex = dotNetClass "System.Text.RegularExpressions.Regex"
regexOpt = dotNetClass "System.Text.RegularExpressions.RegexOptions"
regex.Replace @"d:\testProject\projFolder\something.exr" @"^(D[:])"
@"\\MyServer\__myProjects__" regexOpt.IgnoreCase

Tadaaa! It’s as simple as that. No path splitting, no case testing, just a single line of a regular expression call (not counting the class call) and you’re done. Besides you can use this at a much greater scale with far more complex regex search strings for anything you like directly inside MAXScript.

Note that I’m replacing a D: drive letter in the source paths since that is my projects local drive. You can use whatever you want, hell, you can replace any and all drive letters in one regex call, if you want:

@"^([A-Z|a-z][:])"

I just updated to the final release of Deadline 5.1 after beta testing it for a few months and I couldn’t recommend any other render manager more. If you’re still on Deadline 5 or prior, this update is highly recommended! Especially since it boasts a full CPython support, tight Shotgun integration, draft, the ability to run multiple instances on one render node and much more. For more details, read the official announcement.

Here’s a video demonstrating the power and practical usage of Shotgun (data) brought over to 3ds Max natively via our Python plugin, duberPython.

I’ve been looking for the perfect phone since my good old Nokia 7650 I had in high school. It was a great phone, back then. Had a very comfy portrait keypad and a large screen. Since then I had a few more Nokias until finally switching to HTC phones. My first HTC was TyTN II, what a beast! Then, after the iPhone introduction, some more touch only or touch + type HTC phones. My last one was HD2. I loved and hated the phone equally.

You see, the problem wasn’t the hardware, which is still one of the best even today. The problem was software. TyTN II with Windows Mobile 5 at least had a stylus and wasn’t that much about touch interface (remember, this was a pre-iPhone era). It was cool. Very expensive, but pretty cool. Then Windows Mobile 6 came around with a touch “skin” made by HTC. It was OK, but far, really far, from being smooth, deeply integrated or polished as iPhone’s was.

I ditched Windows Mobile over a year ago in favor of Android (still on my HD2). It was great! I fell in love with Android very, very fast and love it even today. The problem was, again, the smoothness. It just wasn’t at par with the holy grail, in this regard, the iPhone.

Finally I took a blind leap in Windows Phone 7 direction not very long ago. About two months? I bought a HTC 7 Pro, mainly because I was afraid the touch-type experience was going to be mediocre again, so I wanted to be safe with the full hardware qwerty keyboard on board. Man was I surprised! The user interface is as polished and smooth as it gets! I’m loving my phone again. Even typing short e-mails or SMSes on the software qwerty is a joy!

I love the form factor, I love the size, I love the user experience. I am honestly, deeply impressed with Windows Phone 7 and I wish it succeeds in the mobile OS war.

It still doesn’t have the developer base as it should, so, there certainly are fewer apps than for Android or iOS, but it’s getting there and honestly, everything I personally need is there.

As for sideloading, I’ve purchased a ChevronWP7 Pass (for about $9 USD) and officially unlocked my device, so I can sideload any app I wish! The tools for doing so are freely available directly from Microsoft. And once IronPython makes it to the platform, oh man will I be all over the developer side!

Sweet times ahead. So if you haven’t checked Windows Phones out yet, give them a good hard look, they’re awesome!

I’m, along with Gavin Greenwalt from Straightface, featured in Thinkbox’s study that took a look into the Deadline Power Management feature and how it can help save your studio money in the end.

Go ahead, it’s an interesting read.

Every TD knows that command line tools are among the most powerful in their arsenal of tricks and secrets.

I want to mention RVIO, as today it saved me quite a lot of time (again), which is absolutely key when a deadline is coming.

My client requested a minor tweak of animation (a lip sync, to be concrete) on an almost finished shot. So, the general approach would be to do the change, have the animation data go through the pipeline and at the end have the finished frames ready to be loaded in an existing edit, which then gets rendered out and the final result gets showed to the client.

All fine, until you realize your render farm is completely full with other shots, so you have to skip the “beauty” pass rendering and only present the client with a, somehow, polished preview directly from your 3D package, which isn’t the safest way, trust me. But this client is great and understands that what he sees is actually only a preview of the animation.

So, the last piece of puzzle to solve is to get the preview assembled with additional layers of information (such as frame number, shot name etc…), basically a slightly customized overlay. All this sounds nice and simple, you just open up (in my case) Premiere Pro, swap the layers, render out the portion you need and be done with it.

But this certainly isn’t the TD way.

Fortunately for me, I’d purchased a license of RVIO some time ago, so I have an extremely powerful and versatile tool in my arsenal of VFX software that just gets the job done, no matter what.

The problem with the Premiere Pro approach, actually, there are two problems: 1) my lazyness and 2) the time it actually takes to get it done. Besides, this way you are also exposing your project to errors. You might accidently save the project and when you least need it, it’ll jump back at you and you’ll have to be dealing with this fuck-up in the least desirable time – the minute before the deadline.

So, the easiest approach for such a trivial task would be something that allows you to combine an image sequence with your sound file and spits out a movie file with the correct size, color, the whole package, basically.

RVIO is such a tool and it is aimed at TDs and people who aren’t afraid of using the command line (which you certainly should NOT be as it is the most powerful, fastest and actually easiest way of getting things done, even in 2011). It allows for both simple and extremely complex image, movie and sound file conversions. See the RVIO site for more info on that.

So, what is the concrete example I’m talking about? Something as simple as delivering a correct file and presenting it properly to the client can be a complex process in a large pipeline. In my case, as I’m a fairly small boutique, what I needed to do was to take an image sequence of the fixed animation, place it in an existing timeline (effectively replacing the previous, fully rendered, version), setting up markers for in-out points, setting up the export settings, correct file name, correct video and audio codecs, correct output size etc… Then have it exported, review the file, upload it to our server and present the link to our proprietary review site for clients to the client.

This entire process isn’t too difficult to manage in five to ten minutes, but presents a bit of a security threat that I mentioned above and also isn’t very flexible or comfortable. Sure, for people that can only deal with their software via nice and polished user interfaces, this is the only way to get the job done, but for a TD, there is a much smarter, faster and cooler way.

Here come the super-powers of RVIO. It’s strictly a command line tool. But to perform all (and many more!) tasks that I just mentioned, all you need is this line of code:

rvio [ "inputFrameSequence_12-125#.tif" "inputSoundFile.wav" ] -codec avc1
-outkeyinterval 20 -outdatarate 1000000 -outgamma 0.85 -outres 1024 576
-audiocodec aac -o "outputMovieFile.mp4"

That’s it! See how awesomely simple, fast, effective and cool this is?!

Now, this was just a command line command you execute directly and you get a outputMovieFile.mp4 in the correct format, the correct in and out of the animation, correct sound and everything between. However, imagine what you can do with this! If you know Python, or on Windows, preferrably, IronPython, you can do WONDERS!

I’ve tied RVIO with Shotgun via IronPython so that I can do very easily, effectively and super fast deliveries to our client on a project with about 120+ shots. It’s not a huge project, though, but the sheer number of shots definitely calls for scripting. There is no way I’d be sitting at 4am at the computer and manually editing and converting 120+ shots to a desired format for review whenever there is a change in the animation or compositing! That’d be a suicide and a complete waste of resources.

What I did was calling a loop on all the shot folders where our final comp files were being stored, picked the rendered files and fed them to RVIO with a few parameters set specifically for that project, similar to what I just showed you above, pulling a few variables from Shotgun, such as in and out cuts, shot name and other data. Then it automatically takes the resulting movie files and uploads them to our review system via FTP. That was it! With about fifty lines of code I achieved a task that’d take me at least three hours of intensive file hassling and messing around! All of this then takes about ten minutes to process, which is perfect for a coffee break.

Besides, it’s recycable, in a sense that when there is something changed in any of the shots and we need to re-deliver, I just run the script again.

This is what I love about my work! The effectivity, productivity and the cool factor, of course.