I have recently started getting into Shader Writing in OSL (actually rather Pattern Writing just to not get frustrated too quickly :-) ). To start things off I wrote a simple Pattern that lets you create a life 3d mask in your shading network that can be used to alter different shading effects in very particular areas of an object without the need to paint texture masks. On top of that being OSL it should work in any renderer that supports it (e.g. PRMan/RIS, Cycles in Blender, VRay, etc).

The Pattern itself only has a few simple controls:

PMask OSL Pattern inside Maya with RenderMan (PxrOSL Node)

Here’s a quick explanation:
Mapping – determines whether to use world- or object-space for the 3d mask (choose PWorld or PRef). Unfortunately the PxrOSL node in Maya ignores shader metadata for creating a nice dropdown menu here (Blender users might be luckier :)).
Radius – The X, Y, Z (-> R, G, B) scale of the spherical mask.
Whitepoint – Values below 1 will move the core towards the outside edge
Blackpoint – Values above 0 will move the outside edge towards the core
Gamma – Can be used to increase or decrease the falloff

All of these parameters are mappable, too! In the case of this Tool this has some very nice benefits.

The first one is that you can create a locator for example and map its translation to the Pos input. If you are using PWorld as your Mapping type it will use the world space coordinates so wherever you move the locator the mask will go as well. However assuming you are not animating the locator this will be a static mask in worldspace and any objects which are animated will swim through the mask.
If you want your mask to follow your object you can set the Mapping to PRef. This will use the coordinates of the objects translation and deformation from a reference position (zero’d out transforms) and will make the mask stick to the object wherever it’s going. Keep in mind that the Origin for the position (0,0,0) is always wherever the object has zero’d out transforms. This means that you might need an offset if you have frozen your transforms at one point. Another alternative would be to parent or constraint a locator to a moving object and leave the Mapping set to PWorld.
To double-check the coordinates the OSL node allows you to output PWorld and PRef for debugging purposes (you can take the RGB color values of a point in the render as your Pos value).

Also most of the time a simple sphere is not very desirable, so you can also map the radius with other procedurals or textures to break up its shape.

Because this is based on position data it’s completely independent of the object’s UV’s.

You can download it HERE.

Here’s a quick demo video:

3D Position Masks in OSL for Shading Networks from Julius Ihle on Vimeo.

 
_________________________________________________
If this post has helped you in any way you can express your gratefulness by using the Donate Button below to buy me a coffee! :)

3M5xNSV7g2NzVpHMqzYKhgoKJZ8CWa644m

One of the worst things to sample for any brute-force ray tracer are specular highlights / reflections with a low roughness in motion blur. Even worse so on fine displacements or bump. And EVEN more worse with lots of small highlights. When all of these things come together sampling these highlights in motionblur is going to become really hard and with conventional methods you will end up having to rely on extemely high AA samples and even then the highlight-streaks will most likely still be dotty… And you won’t make any friends if they have to paint these streaks smooth in Comp :) So during the crunch time of a recent project I was brain storming with some of my collegues how this could potentially be fixed without needing too much samples and I’ve been working on implementing that idea which seems to work quite nicely.

If you try to sample this speedy fella in an environment like that with this look you will inevitably end up with streaky specs.

So how do you fix it without changing the look? Let’s say you have a simple scene like the following:

In this case I’m using Arnold, but the base concept is the same with any renderer. Low roughness on the specs + bumpy surface + lots of harsh highlights result in something like this when you turn on motionblur:

This one already has 12 AA samples + 2 light samples. It won’t get much smoother just cranking up the samples, but trust me it will render longer :) One way to smooth the streaks out however would be to increase the roughness and decrease the bump / displacement.

That looks way better. However the problem with this is that these adjustments will affect the look a lot and the asset will look very different in non-motionblurred frames. So let’s make it work only when the character is in motionblur.
Most renderers offer some sort of a node that allows you to extract the motion vectors from a moving object, which basically define what distance each point on an object travels from one frame to another in XYZ.

As you can see we get quite big values for this frame just outputting the raw motion vectors. It’s very important that they are in a raw format and not normalized, because otherwise you won’t have the actual movement distance but just something normalized (positive values between 0-1) to make it better visible.
Now these negative values won’t help us much. Eventually we want to be able to use this infortmation as a mask to switch between rough/blurry (for motion blur areas) and sharp reflections (for non-motionblurred areas).
So let’s make sure these values are always absolute.

This way no matter what the motionvector outputs, they will always be positive. Now we need to convert this to a float to make it useable as a mask. In this case a simple RGB to luminance won’t quite cut it as you will have a weighted average of the movement in X,Y and Z. You can use a max or a sum of all the three channels to always make sure you grab the biggest motion.

The only thing left to do is to bring the whole thing into a suitable normalized range to be able to use it as a mask. How you are remapping it, depends on at which point you want to completely switch from one roughness to the other. If you have your usual range/remap node you can specify with the input max at which point the value of the resulting mask should be 1. If I’d set it to 30 for example, as soon as the motionvector reaches a value of 30 it will result in a white mask and it will smoothly blend to 0 for areas/frames with no motion. We can use this mask then to mix between 2 roughness and bump values or textures. This way we retain the look of the original asset and have nice and smooth motion blur.
Here’s a before and after frame with this method. Both have the same sampling settings

 
_________________________________________________
If this post has helped you in any way you can express your gratefulness by using the Donate Button below to buy me a coffee! :)

3M5xNSV7g2NzVpHMqzYKhgoKJZ8CWa644m

During the last year I luckily had some time to spend on digging a bit deeper into Katana. From working on assets and shots I experienced some moments where I thought it’d be great to have some basic tools to help get the job done just a little bit quicker. So whenever I had a bit of spare time I was developing some Macros/Gizmos/Tools to help artists on some common problems.

Katana Macro/Tool Dev from Julius Ihle on Vimeo.

One of the tools is a macro that helps managing multiple lights. Based on a CEL you can freely modify exposed shading and transform parameters. This especially comes in handy in scenes with bigger environments that have to be lit with multiple light sources. It also features some randomization controls for lightcolor and rotation & scale.

Next up we occasionally had some shots that required very accurate light cookies/gobos based on the plate. On recent shows we for example had some shots of characters walking through the woods with quite direct lighting which caused very complex noticeable shadows from the tree’s branches and leaves. In some scenes one could get away with putting just some random lightcookies as projectors (slidemaps) on the lights, but others needed a more accurate solution. This is a macro I have been working on which automates the whole process:

It basically works this way: You project the plate through the render camera onto the set geometry and render that result back through the light source which will should give you a proper light gobo. Now, there are usually a few things to consider, like the camera’s focal length, pre/post transformations of the plate to match the light’s scale and so on which all depends on the way the slidemap is implemented into the shader. On this one no one had to worry about it, because it’s all handled automatically :) The only drawback is that the generation of the resulting cookie involves a 2-step rendering process (projection on geo and post-tweaks) which makes it not as interactive as it could be, but luckily those renders go through really quick at least.

Here’s a quick run through on a previous set up which is based on the same technique, but a bit more manual and goes through Nuke. This should also work with really any setup that requires building accurate light cookies.
Say this is your light setup (in this case in Katana, but could be Maya, Houdini, or whatever):

You replicate the same thing in Nuke importing the same camera and set geometry. You project the plate through the rendercam onto the set geometry and copy over the light transformations from your 3D package into a new camera, which you then render through:

The tricky part is getting the correct settings for focal length, etc. on your camera that resembles the light, which involves a bit trial and error. You can then just desaturate the map and grade, paint and do all the fancy comp stuff to make it do what you want and then use it on your lights:

When the guys from FX do their magic and blow things up into thousands of pieces that’s always awesome. Anyone in comp is usually happy if you provide them ID’s for just about anything so, provided the FX cache contains separate geometry pieces or face-sets that’s pretty straight forward with this ID randomizer:

When Lookdev’ing assets it always helps to ensure some consistency between the renders. While we had templates that managed chrome- and greyballs and rendercameras, we didn’t have a setup for the turntable itself… Well, now we have:

 
_________________________________________________
If this post has helped you in any way you can express your gratefulness by using the Donate Button below to buy me a coffee! :)

3M5xNSV7g2NzVpHMqzYKhgoKJZ8CWa644m

In the process of trying to streamline things a bit more in my day-to-day workflow I have recently been working on a hand-full of small helper tools. One of them is a small set of scripts that handle the conversion of a selection of files to Arnold & RenderMan’s native .tx/.tex files from the filebrowser… because people like the GUI, right? :)
Unfortunately for anyone out there on Windows or OS X they won’t be of much use I’m afraid. If you are on Linux and using Gnome or KDE as your Desktop environment (others may work, too) this might come in handy. The file conversion is being handled on a selection of files through the standard right-click context menu:

Upon clicking you will be presented with a little pop-up menu that allows you to enter additional options for the conversion if needed. Anything that’s noted in the -help docs of the respective commands should work in the dialog boxes. Upon specifying your options there’s time to grab another cup of coffee… The progress bar will let you know when it’s done :)

By default it is assumed that the bin folders of Arnold and RPS are part of your $PATH environment variable, but if you need to change it the code should be fairly easy to read (although it looks a bit messy because it’s 1 line :) ) and can be modified to suit your needs. The dialogs are using KDialog and zenity (for KDE and Gnome respectively), but those should come by default depending on what desktop you are using.

To use them on KDE put the attached .desktop files in ~/.kde/share/kde4/services/ or /usr/share/kde4/services/ (for all users).
For Gnome you need to install nautilus-actions and import the attached .schemas files. Once that’s done just restart nautilus/dolphin or log out and log back in again.

Tested on my laptop with CentOS 7 (KDE 4.10.5) and my trusty old CentOS 5 testbox (Gnome 2.16.0). Unfortunately I don’t have my main workstation around to test it on CentOS 6, but it should work there as well.
//Edit: Now also tested & confirmed working on CentOS 6.

Arnold .tx Converter for KDE
Arnold .tx Converter for Gnome
PRMan .tex Converter for KDE
PRMan .tex Converter for Gnome

 
_________________________________________________
If this post has helped you in any way you can express your gratefulness by using the Donate Button below to buy me a coffee! :)

3M5xNSV7g2NzVpHMqzYKhgoKJZ8CWa644m