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

The new RIS mode introduced in RenderMan 19 is a completely new render-engine that is very different from REYES. Being a brute force path tracer (uni- and bidirectional modes) it works much more like other renderers that follow a similar approach (e.g. Arnold). That approach aims to make the render process more simple and interactive. And while I personally don’t like it completely yet it seems to get widely adopted in the film industry and we all have to adjust to it sooner or later :)
The good thing about RIS is that it offers a much more interactive way of working. The interface and controls are much simpler now and offer easier controls to tweak your renders. However this comes at the price that compared to Reyes I have seen final rendering times increase by 3-6 times, because all the hacks are removed for a “physically plausible” workflow.
Now because there is not a lot of stuff you can tweak to squeeze rendering times it is important to understand how sampling in RIS works. RIS uses importance sampling, which in layman terms means instead of uniformly sampling an area above the hemisphere it concentrates samples around the areas that are more important (e.g. brighter, higher solid angle, etc.). Here’s a good example comparison with 2 objects – just 1 high contrast environment light importance sampled vs uniformly sampled (same number of samples):

Importance sampling is the standard sampling method in PRMan (both REYES and RIS) due to its obvious benefits.
The main settings in the render globals that control the quality of the final image are the following:
Min Samples
Max Samples
Pixel Variance
Light Samples
Bxdf Samples
Indirect Samples

The way it works is fairly straight forward: Min- and MaxSamples are a global setting for every kind of sampling in your scene (AA, Light, Shader, GI Sampling). The amount of Samples for each of those will never be higher than MaxSamples and never lower than Min Samples.
The parameter to control whether the Sampling biases towards Min or Max Samples is the Pixel Variance. Starting with Min Samples RIS will check the contrast (=noise) between the current sampling-point and those around it. If that contrast is higher than the value specified for Pixel Variance it will adaptively continue to shoot more Samples for that point until the contrast is equal or lower to the Pixel Variance (with Max Samples as a maximum). Therefore a lower Pixel Variance will increase the likelyhood of more rays being fired and therefore a better quality image (and also longer rendering time).
As noted before the problem with just using Min/MaxSamples/Pixel Variance as your global is that it affects all the Sampling in your scene. So if your shadows are grainy for example, but speculars, GI, motion blur, etc look clean, increasing the MaxSamples or reducing the Pixel Variance might give you clean shadows but also waste samples for all other sampling methods in your scene.
Therefore you also have Sampling controls for Lights, Bxdf’s and Indirect rays. Which one of them to use in a particular scenario depends on a couple of factors.
Indirect is the most obvious knob. Increasing it will spawn more indirect rays after the first bounce (=rays that cannot be directly connected back to a light source). This inhabits indirect diffuse, indirect specular (reflection/refraction) and subsurface. You can gain finer control over the sampling counts on each of these by changing the SampleMode from “bxdf” to “manual”. That way you can specify exact values for a given indirect ray type.
When to use LightSamples vs BxdfSamples isn’t quite as obvious at first. It depends on what kind of surface you are shading. The main indicator here is the lobe of the BXDF. Let’s say you have a plain diffuse material. Increasing the Bxdf samples in that case won’t benefit you much, because a diffuse surface naturally has a very wide lobe. That way increasing the sampling on the Shader will result in a lot of wasted samples:

Note that all the renders are scaled up crops to better show the sampling problems.
However if you are using Light-Sampling things get a lot more efficient as you are now shifting the importance towards the lights:

In comparison to get a similarly clean image by solely adjusting the Min/MaxSamples and PixelVariance and leaving LightSamples at its default of 1 you will waste a lot of rendertime to get the same result:

As you might have guessed for direct specular shading that has a very tight lobe (=more mirror-like) it works the exact opposite. Because the lobe is so narrow adjusting light Samples globally will most likely not reduce noise as it’s very unlikely for all the lights to have an effect on the given point of shading:

…increasing the Bxdf Samples however is way more efficient:

And once again, just using Min/MaxSamples and PixelVariance to adjust the quality wastes more time than needed:

Now, what about rough speculars? Often times reflections are having a broader lobe which sits somewhere inbetween that of a rather mirror-like specular and a diffuse lobe. In that case you have to mix between Light- and Bxdf Samples. Due to RIS taking advantage of multiple importance sampling it tries to automatically allocate samples that make the most sense for the current shadingpoint. But as a general rule of thumb I personally found that for a roughness of ~30% using the same value for Light- and Bxdf Samples gives a good starting point. If the spec gets more shiny you bias towards Bxdf Sampling and if it gets rougher you bias towards Light Sampling.

Once the direct light components are noise-free, indirect noise tends to be a bit harder to tackle as this will be the main source of noise most of the time. Often times unfortunately adjusting Indirect Samples will only get you so far until render times start to explode:

The MaxSpecularDepth in this scene and on the objects is 4. As you can see even with 10 indirect samples the render isn’t really as smooth as it should be. Luckily you have 2 more options that can help eliminate noise. Clamp Depth and Clamp Luminance. Sampling Fireflies usually happen when there is a big contrast between higher and lower luminance sampling points. The clamp controls try to get rid of those brighter samples to reduce the noise. If you for example set the clamp depth to 2 and the clamp luminance to 1 it means that starting from the 2nd bounce of the light path (be it diffuse, specular or subsurface) the sample intensity will be clamped to 1, meaning no samples at this depth have a higher value than the one specified in the clamp luminance:

As you can see the resulting image is much cleaner. I was even able to reduce the indirect samples and still get a cleaner result and lower rendering time. However you also have to be careful to not set your clamp luminance too low as this might produce too washed-out-looking bounces.
You can also control indirect sampling through the Roulette Depth/Threshold Control. This will randomly terminate a percentage of samples (threshold) at a given depth. The default values of 4 for roulette depth and 0.2 for roulette threshold means that starting at the 4th bounce of light 20% of the samples will randomly be terminated. This control is useful if you have a lot of light bounces and want to get rid of unneccesserely low-importance samples at larger depths. And while it reduces render times nicely it also reduces quality at the same time, so those controls should be used with caution.

As a general workflow what personally worked best for me is to usually
1) Adjust Min-/MaxSamples and PixelVariance until I get clean Anti-Aliasing and motion blur (..and DOF).
2) Check the diffuse_direct AOV for noise and increase Light Samples if needed
3) Check the specular_direct AOV for noise and balance between increasing Bxdf/Light samples Samples if needed (depending on spec roughness)
4) Check diffuse_indirect, specular_indirect and subsurface and increase indirect Samples as needed
5) Try to play with Roulette Depth/Threshold & Clamp Depth/Luminance to eliminate fireflies

I always try to not go higher than needed with Min-/MaxSamples and PixelVariance. They tend to be the most sensitive control and increase render times the most.
Also often times globally adjusting a sampling type may be excessive when only one light/surface produces noise. For lights you can adjust samples individually, which is quite cool if you have a scene with lots of lights but only the shadows from your keylight are noisy for example. Unfortunately individual sampling controls for controlling the sampling on shaders are not exposed in the out-of-the-box pixar shaders, so unless you create your own you have to adjust Bxdf samples globally.

 
_________________________________________________
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

Primitive Variables are a really cool way to get variation in Renderman Shading Networks. As it requires adding Attributes to your Shape Nodes within Maya to control the variation it can be quite time consuming to set it up. So I was trying an attempt to build an interface that helps a bit with the set up.The GUI let’s you choose a name, the PrimVar type and min/max values of which it will randomly pick floating point numbers within that range. It is also possible to just use integers with the according checkbox. The GUI is far from being pretty or well organized, but it does the job. :)

As I am a bit short on time however I just had the time to properly make use of Float PrimVars as that’s what I need for a current project I’m doing. As with all my scripts they are not written very well, but should be kind of readable. So feel free to modify it as needed. I hope I will find the time soon to make the other types work properly.
So for example using 3 PrimVars with just one shader on all objects results in loads of variation… Which is always a good thing :)

Additionally as you can see there is also an “Object ID” part in the GUI. It let’s you add integer PrimVars with increasing values for each object. At the same time it will add an AOV with the same name like the primvar (of course this custom AOV has to be set up in Slim beforehand).
An alternative approach to making Object ID’s would be having distinct floating point values for each object. So the value that get’s assigned by the script corresponds to the value that is being rendered within the Object ID AOV. For example object 3, that has the Object ID primvar value of 3 assigned has a value of 3,3,3,3 for RGBA. The good part is that it is very easy to set up, but one may run into aliasing issues when dealing with very thin geometry for example. To make use of this technique I also prepared a Nuke Gizmo that handles these kind of Object ID’s and has a slider to separate them.

Also here’s a quick demo:

Simple PrimVar Helper Script from Julius Ihle on Vimeo.

So hopefully I will find some time to complete the script, but for now if anyone’s interested feel free to grab it from HERE.

CG fur always has the tendency to look very clean and soft. To break up the structure and to give a bit more realism I like to mix it with a bit of dirt, e.g. some leafs or sticks in the fur of a character walking through the woods. Here’s a quick rundown on what I’m doing to achieve this using Yeti and Renderman within Maya.Let’s start with a simple sphere and some clumpy fur on it to get started. This is my base fur setup.

What I’m doing next is to create another YetiNode on the same Mesh. This will be (one of) my dirt layers. In this example I’d like to have some leafs between the fur strands. For this I’m going to use polyPlanes with textures on them. So to distribute those planes along my sphere I need to first of all get some guide strands lain out. To make the planes take the direction of the fur I have to create a custom comb attribute which I’ll call “dirt_dir” in this example. So after comb’ing the grown fur with the groom I’m going to create yet another comb which has a comb attribute called “dirt_dir” in it.

Next I’ll import the planes which are supposed to hold the leafs and instance them on the fur strands. For the alignment I’m going to choose my “dirt_dir” attribute to make the planes align along the fur strands. For this to work I have to set the “Instance To” to “Elements.

To get a bit more variation and randomness one can also change the alignment, scale and twist variation as well as tick the “Deform” checkbox in the “Objects” tab.
Alright, now that this is setup you can assign a simple Shader which holds a leaf texture for example and render and you’ll have a bit of dirt between the fur. However I personally like to have a bit more control over things in comp, so let’s take this a step further. I’m going to set up an AOV which holds the color and alpha of the leafs respectively, but the actual fur render will not contain the leafs at all. To set this up, I just map the leaf’s color to the diffuse and the leaf’s alpha to the mask input of a GPSurface Shader. Also I will turn up the transparency to full white because I don’t want the leafs to appear in the actual beauty render.

For more information on how to set up custom AOV’s in Slim there’s a nice explanation over at pixar.

When rendered and everything is set up correctly something like this should come out:

Of course with a bit more sophisticated than just planes with textures on them one can get really nice results while still maintaining a lot of control. One thing I might add is that the color AOV of the dirt  should actually be rendered without the fur being visible. Otherwise as you can see it will be held out by the fur aswell, which could lead to premultiplication issues in comp. In this example it’s not really obvious but there might be cases where you should be aware of it.

To render more efficiently and to get some particular features working one has to feed Renderman with .tex files. Most regular image files can be converted to .tex files with the txmake executable that comes with RPS. However converting multiple files such as UDIM’s from Mari can be time consuming. So let’s make things a bit quicker… :)

I often use Nuke for things such as texture adjustments or making light cookies. Often I make minor adjustments and want to preview changes right away. So I would have to go and txmake my outputs every single time. Thanks to our Comp TD who generously helped me at this point I wrote a simple script to automate the .tex – conversion after rendering from within Nuke. You can obtain the script from HERE. Just place it within your .nuke directory. On the Write Nodes you would go to the “after render” line in the Python-tab and paste the following to execute the script after the render has finished:

import make_tex; make_tex.make_tex()

The script assumes that you are outputting .exr’s. In case you are using something different you can modify the script as needed.

When you are outputting load’s of UDIM’s from Mari and want to render with PRMan you have to convert them to .tex files to use them with the TextureAtlas Nodes. I found a very handy script online that does this already. However it involves a second step to make the conversion and isn’t handled by the python script itself. I removed the additional step and made it work in one go. You can get my modified version from HERE. It’s just a matter of cd’ing to the directory that holds the .tifs from Mari (to use something different you can modify the script) and executing the python file.

I tested those scripts only on Linux so far, but they should work no matter the OS.

Maybe someone will find this helpful… :)