Having text live in your shaders can be a great way to add decals, burn-ins, etc. to your renders. I’ve gone on a bit of an adventure to implement an OSL shader which can be used to display arbitrary text right in your shader.

Unfortunately implementing a .ttf reader is way above my head, so I had to resort to a more primitive solution. I’m using a library of images of all the common characters found on an english keyboard layout. These are read back into the shader based on the text input. Having special characters (such as ~#!$?&) in file-names however is a big nono, so I resorted to unicode character naming conversion, where a single integer represents a given character. ASCII characters are the most important ones, which I have included in the package in a few common fonts. If you would like to use a font other than the ones provided in the package, I’m also supplying an example Nuke script in which you can just change the font and output in the required manner for the shader to read it properly:

The idea is to supply the shader with the rendered image sequence of the unicode characters in the font_source parameter replacing the unicode numbers with a hash, like so:
/home/julius/shaders/util/unicode_characters/Arial/#.tx
Note that some DCC’s convert the # to the current frame number, which can be avoided by escaping it, eg by prepending a backslash: \#
If the input font path is not valid, you will get a warning in the terminal and the shader will output the color specified in the false_color parameter.

The text to render can be anything you like, provided you have a corresponding unicode character rendered. New lines can be added via \n (some DCC’s might need \\n).

Apart from that you have a couple of options for placing it on the UV’s and general text editing stuff (alignment, leading, kerning, etc).

One thing I find this particularly useful for is pipeline automation… automated burnins on slates, etc. The assets from example turntable setup in the demo below is from the awesome team at CAVE Academy. Make sure you check them out!

You can download it HERE

Demo can be seen here:

OSL Text Shader 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

A very artist-friendly and powerful feature of RenderMan is the ability to light-link light filters to specific objects. In certain scenarios this can become quite useful to make detailed tweaks. In Arnold this is unfortunately not possible to my knowledge, but luckily there are ways to do something similar…

…through the use of userdata (primvars)! Specifically what I wanted to replicate was RenderMan’s MultFilter. The idea is pretty simple, but combined with the ability to light-link it to specific objects it can be extremely useful for adjusting small details of a given scene.

It also was a great starting point to get my hands dirty with C++. I’m still mostly lost for anything that is more complex than multiplying a few values together, but also happy that I got something out that at least seems to work reasonably well :)

The controls are relatively straight forward. To make use of the userdata inputs, make sure you tag your objects with an Arnold-compliant float userdata and a value between 0 and 1 to drive the amount.

For Katana specifically I’m also providing a setup that is meant to serve as an example of using it with the built-in light-linking features. The way I’ve been approach it is the following:
1) Resolve the light linking information (which lights are linked to which geo)
2) Tag light-linked filters with the hierarchy location of the lightfilter as the userdata name and set the default depending on the initialState:

3) Tag linked objects with the userdata name of the lightfilter location

This is a more artist-friendly and direct way of setting up using known workflows. It’s probably recreatable to a degree in other DCC’s as well. A Katana example file that includes this setup can be found HERE
 

Also here’s a bit more guided walkthrough available on Vimeo:

… and you can grab it from HERE (source + precompiled for Linux, MacOS and Windows)

_________________________________________________
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

Sometimes getting complex refactive behavior through surfaces can be a tricky challenge. If you’re trying to recreate something like cracks inside of ice it can be a challenge to get this behavior as it can involve a lot of iterations in on the internal geometry and shader adjustments. Often it will also take a long while to render if you’re doing actual refractions. If you need something simpler tough there are ways to do that in the shader directly

I got the initial idea for this from Ben Cloward’s ice shader test in Unreal. It’s a very smart approach in which you get the appearance of the surface texture extending into the volume of the geometry that you are applying the shader to. Given this approach I wrote an OSL shader that does the same thing. I mainly created it for the purpose of shading ice-like internal structures but it can potentially be extended for other use cases as well.

You can supply a texture file into the filename parameter. The texture will be applied to the surface UV’s with periodic tiling. With the default values it creates a duplicate of the supplied texture “inside” the objects that the shader is applied to at the specified depth. The invert_depth parameter will drastically change the look. Depending on the source texture you are using it can give the appearance of occluded cracks vs a “see through” repetition of the surface texture. A roughness parameter is also available which you can use to simulate the texture getting more murky the deeper it goes “into” the object. This is not a physical parameter but just a simple texture blur. If you want a smoother appearance of continuous streaks as the texture goes into the surface you can increase the number of steps. This can simulate continuous from the surface down to the specified depth. Keep in mind that this is the number of texture calls, so having high values here can potentially make it quite slow.
Unfortunately this time it won’t work with Blender as I couldn’t find a proper way to get the derivatives & UV’s to work as expected :( If anyone has the time to look into it please feel free to do so!

As always having a visual demo is probably a good idea, so here it comes:

OSL Fake Parallax Shader from Julius Ihle on Vimeo.

You can download it from HERE.

_________________________________________________
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

When trying to integrate CG renders into real life footage one common hurdle is to treat reflections properly. Often times in your plate you will have elements that have bright reflections (eg windows, plastic chairs, shiny tables, etc) in which your CG elements need to reflect. Rendering a simple reflection pass however often times does not really cut it

See the example below. If you were to add a usual reflection pass to it the result does not really make sense:

This is because the reflection is simply added in this case. While adding reflections is technically correct, the problem is that we already have reflections in the plate. The window behind the table has a large contribution to the specular reflection on the table. If you look at the cup on the right what is happening is that the cups reflection is blocking the highlights from the window. As the cup is neither emissive nor very bright it’s reflection is a lot darker.

We’d need to do something similar to the reflection of the CG render. A common trick is to render a separate reflection of the same element but with a constant white shader. This has several drawbacks tough:
Most renderers don’t support arbitrary utility outputs in traced results. This means the render would need to be a separate layer
–> more render layers to manage for the Lighting TD
–> longer rendering times
–> Comp has to deal with more separate renders
–> even more layers to manage if additional utility passes are requested (reflected Position, Normals, userdata, etc.)

Ideally you would have the alpha and any additional arbitrary outputs as an AOV instead of a separate render to remedy all of the drawbacks mentioned above.

I therefore wrote a simple OSL shader. This however probably only works reliably in more recent versions of Arnold. You can assign it to your set geometry and anything that will reflect in it will sample whichever shading component you specify. This supports OSL builtins (eg P and N) as well as arbitrary userdata (eg Pref). If you use dist or distance as a special keyword for the trace_component it will output the distance of the reflection from the current shading point, which can be used in comp to fake roughness. If the given component is not found it will reflect the trace_color (eg to be used as an alpha for reflections).
If your set geometry contains multiple shapes you can add them to a trace set and specify that same trace set in the shader and untick inclusive. This will allow only reflections from your anything other than the set geometry.

The shader will output rgb data which means you can pipe it into custom AOVs for example with the help of aov_write shading nodes:

With a little bit of comp love you can get quite promising results:

You can give it a whirl by downloading the jiTraceAOVs shader from my github

Here’s a bit more indepth demo + a simple comp example:

_________________________________________________
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

Occasionally there might be the need for LookDev Artists to adjust areas of a shader based on different UDIMs. If an asset has a continuous mesh that is only separated by UDIMs (eg nails on a character or decorative parts of clothing) it can be useful to create masks for specific UDIMs in the shading network to isolate areas of interest.

It is relatively straight forward to get the integer values of each UDIM in a shader by just creating a Nodegraph that resembles the UDIM formula:
1000+(floor(u)+1)+(floor(v)*10)

You can output the result into a compare node in your renderer of choice and check whether it matches against a certain UDIM. While this is fine for 1 or 2 UDIMs it gets quite cumbersome with many UDIMs.

As I like playing with OSL I put together a version that allows you to create masks from a specified list of UDIMs. It expects a comma-separated list of UDIM tiles. You can also specify ranges. Eg 1001,1003-1006,1015,125 will select the following UDIMs: 1001,1003,1004,1005,1006,1015,1025.
You can also just output the raw UDIM tiles integers if you want to create more complex masks downstream.

There are just a few caveats:
1) The input is a string, so internally it’s checking against a regex to see if the passed input is a valid list of UDIMs. This can potentially be expensive in larger shading networks.
2) At the moment there’s a hard-coded maximum of 10 entries that are allowed for performance reasons (note that ranges such as 1001-1005 count as 1 entry). You can edit the #define MAX_TILES 10 in the supplied .osl file if you need more.
3) At the moment I could only test it with Arnold. Not sure if Blender supports UDIMs properly in this way. RenderMan should work as well.

You can download it HERE from github.

Here’s a quick demo:

OSL UDIM Mask 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 things I found myself having to do more and more recently was creating contactsheets. This is mainly to keep an overview for myself over all the shots in every sequence for example. It usually saves me a lot of time, especially at the beginning of a show when I wasn’t neccesserely familiar yet with all the shots we had to work on.
Creating the contactsheets themselves however proved to be rather tedious as my workflow consisted of doing it all in Nuke. Adding, shuffling or annotating shots wasn’t really easy without some serious Python trickery. Luckily I found a great alternative.

So what’s the fancy title all about? The tool that I’m going to be using is an open source command line image-editing utility called Image Magick. The beauty of it is that it can be used to batch-process a ton of images. It can seem quite overwhelming at first as it ships with a lot of utilities and options but this is what also makes it so powerful. A lot details and examples can be found in the v6 documentation HERE.

I should preface this write-up by saying that I only touched the tip of the iceberg and am still discovering new things day by day.

What I did know was the main purpose I wanted to use it for: Stitching thumbnails of all relevant shots from our database so that I would have a one-stop quick overview for the shots. Alongside this I wanted to have the following information displayed for each shot:
-annotate each thumbnail with the shotname
-show some info from the database about the status from relevant departments
-annotate each thumbnail with assigned artist

Goal is set, so here’s a quick rundown on my humble tests. I have been using the following 3 utilities that ship with ImageMagick:
convert
montage
identify

convert is pretty straight forward. It’s main purpose is to do all sort of image manipulation. Transforms, filters, color corrections, annotations – you name it.
montage is very useful for stitching multiple images together to create a collage.
identify is a useful tool for getting information about an image such as resolution, color space, etc.

I set up a testproject with some thumbnails based on a sort-of famous movie… I made up sequence- and shot names. Alltogether I have 7 sequences, each with a couple of shots inside them. The directory structure is split up so we have $PROJ/$SEQ/$SHOT/thumbnail.png:
.
├── testproj
│   ├── FS
│   │   ├── 0310
│   │   │   ├── test.png
│   │   │   └── thumbnail.png
│   │   ├── 0320
│   │   │   └── thumbnail.png
│   │   ├── 0330
│   │   │   └── thumbnail.png
│   │   ├── 0360
│   │   │   └── thumbnail.png
│   │   ├── 0370
│   │   │   └── thumbnail.png
│   │   └── 0390
│   │       └── thumbnail.png
│   ├── GR
│   │   ├── 0040
│   │   │   └── thumbnail.png
│   │   ├── 0050
│   │   │   └── thumbnail.png
│   │   ├── 0060
│   │   │   └── thumbnail.png
│   │   ├── 0070
│   │   │   └── thumbnail.png

etc…

The general syntax for using the image magick tools is
magick tool inputImage [-options] outputImage
example:

magick convert thumbnail.png -resize 50% test.jpg

This will shrink the input image thumbnail.png by 50% and save the output as test.jpg. Easy enough…
(Note that the magick prefix has only been introduced from ImageMagick v7 onwards.)

However my thumbnails are not really thumbnails at the moment. They are massive as they are just screenshots from the BluRay. I want to resize them down from their original size of 1920×1040 to 640×480. 640×480 is a different aspect ratio however and the default for resizing an image using convert is to resize the image to the specified width and keep the aspect ratio from the original image. I could use -extent in the following way to force the output resolution:

magick convert thumbnail.png -resize 640x480 -background black -gravity center -extent 640x480 test.png

This will resize the original image to 640×347 (due to the different aspect ratio), extend the resolution to 640×480 afterwards and fill the empty areas with black while keeping the image centered.

There are multiple ways to add text to an image. You can use -draw to place text exactly where you want. Preceding options can define the style and positioning of the text. This example will create white text saying ‘test’, outlined with black and a size of 250 in the center of the image:

magick convert thumbnail.png \
  -font DejaVu-Sans \
  -pointsize 250 \
  -fill white \
  -stroke black \
  -strokewidth 5 \
  -gravity center \
  -draw "text 0,0 'test'" test.png

ImageMagick’s main benefit lies in batch processing a multitude of images. I could shrink all my images and annotate them with the shot name in the same way as outlined above (in this case using bash):

for sequence in testproj/*; do
#get the sequence name from folder
seqName=$(basename ${sequence})
#create directory of current sequence inside seqSheets dir
mkdir -p seqSheets/${seqName};
#create annotated thumbnail and export to seqSheets directory
for thumb in ${sequence}/*/thumbnail.png; do
  shotName=$(basename $(dirname ${thumb}))
  magick convert $thumb \
    -resize 640x480 \
    -background black \
    -gravity center \
    -extent 640x480 \
    -font DejaVu-Sans-Bold \
    -pointsize 150 \
    -fill rgba\(255,255,255,0.30\) \
    -stroke black \
    -strokewidth 5 \
    -gravity center \
    -draw "text 0,0 '${shotName}'" \
    "seqSheets/${seqName}/${shotName}.png";
  done;
done

This way I have a small annotated version of each thumbnail inside a newly created seqSheets folder as well:
.
├── seqSheets
│   ├── FS
│   │   ├── 0310.png
│   │   ├── 0320.png
│   │   ├── 0330.png
│   │   ├── 0360.png
│   │   ├── 0370.png
│   │   └── 0390.png
│   ├── GR
│   │   ├── 0040.png
│   │   ├── 0050.png
│   │   ├── 0060.png
│   │   ├── 0070.png

Now that I have each shot annotated with its name I can use montage to stack them on top of each other. I would like to do that in a specific way tough. Preferably I would like my contact sheet to be aligned at the top so I have the sequence names in one row and the shots for each sequence stacked beneath them:

montage is a great utility for aligning images as it features a lot of options. To be able to easily update things on a per-sequence level I decided to do an individual sheet per sequence first.
If montage is not being given any options it will try to align images in a more-or-less smart manner itself:

magick montage seqSheets/FS/*png test.png

There are a number of ways how you can set your alignment in montage. You can use the -tile AxB option to define how many rows and column your montage should have (where A are the columns and B the rows). As with a lot of options on the ImageMagick toolset it’s possible to leave out either rows or columns and montage will just force one column for example independent of how many images you have.

montage seqSheets/FS/*png -tile 1x test.png

My goal is to put all the individual sequence sheets next to each other afterwards. For this to be more straight forward I want to force each sequence sheet to have the same number of rows. I will therefore just grab the sequence with the most number of shots and set every sheet to have this number of rows:

#grab the maximum number of shots per sequence

maxShots=$(find testproj/ | rev | cut -d "/" -f2- | rev | sort | uniq -c | sort -k1n,1 | tail -n1 | sed 's/^\s*//' | cut -d " " -f1)
for sequence in $(ls -d seqSheets/*/); do
  seqName=$(basename ${sequence})
  magick montage ${sequence}/* \
    -background black \
    -fill white \
    -pointsize 18 \
    -font DejaVu-Sans-Bold \
    -title $seqName \
    -tile "1x${maxShots}" \
    "seqSheets/${seqName}.png"
done

The resulting sheets will consequently all have the same dimensions so stitching them together afterwards will be pretty easy:

I will use convert this time instead of montage to simply append all of the images together. Reason being is that it will just keep the input formats and it’s a bit easier to control spacing using the -border option. +append stacks the images horizontally, -append would stack them vertically:

convert seqSheets/*png \
  -background black \
  -bordercolor black \
  -border 25x \
  +append \
  final_contactsheet.png \

Taking this further one could grab additional information from the project database. If there’s a way to access it via a Python API for example one could annotate each shot with their respective department status, assigned user, etc. This way it can provide lot’s of very useful information at a glance. I just made up something here but I hope it shows the point:

_________________________________________________
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

Getting Reflections and Speculars to look right is one of the most essential parts to creating realistic-looking CGI. At the same time it is also one of the hardest things to get right. This is just a personal opinion on how I think varying specular behavior across a surface can be handled nicer than using traditional ways.

The main thing that gives you a nice specular variance across a surface is using roughness variations. Another technique that is well established alongside that is the use of specular-color/specmaps to modulate the intensity of specular highlights and reflections across a surface. Does it look good? Yep, usually! Is it accurate? Not really…

With the way most shaders are structured in VFX having a specular map to break up the intensity of specular reflections is not accurate. The specular color and specular gain of all shaders should always be white (RGB: 1,1,1). Wait, what? Let me explain…

If you look for example on refractiveindex.info you will notice that no matter what material you look at, they have one thing in common: The specular reflectance at the glancing angle is always 1, which means that if you were to look at any material at a potential angle of 90 degrees they would reflect all incoming light. Furthermore for dielectrics the specular component of the surface maintains its incoming polarization and is consequently not tinting the outgoing reflection. Changing the wavelength of light hitting dielectrics will not have a (perceivable) impact on the amount of light that is reflected so the specular or reflection color should stay white.

Where they all differ is how much light they reflect when looking directly at them at a 0 degree angle (often reffered to as F0, R0, spec0 or something along those lines). This is caused by the different indecies of refraction for the materials:

Also as you can see in the Fresnel graphs the amount of light that is reflected does not really change that much from 0 to about 45 degrees. If you were to take a sphere and visualize the areas that contribute the most to the overall surface appearance on screen its the range of 0-45 degrees (visualized in green) vs 45-90 degrees (visualized in red):

Now back to the point why I said the specular albedo should always be 1 is because the way shaders in most offline-renderers work. They calculate the total surface specular reflectance with Specular Color * Specular Gain which is then attenuated by the IOR depending on the angle you are looking at it. So if you were to change the specular color to anything less than 1 you would never potentially reach full reflectance at a 90° angle.
Consequently if your goal is to be technically accurate you would vary the index of refraction across a surface instead of the specular-color or -gain to achieve different levels in specular reflectance:

With varying the specular IOR instead of the color you are making sure you retain enough edge reflectance to create a more plausible surface appearance.

The IOR range for most dielectrics is about 1.3-1.8. I will ignore metals on purpose as they come with their own special sauce. These values however are not very artist friendly to work with as they are outside the 0-1 range.
Personally what I like doing is to first remap my spec map in a 0-1 range so I get the contrast ratio I want and then remap the result to the desired IOR range (using the out_min and out_max of a remap/range node for example).

Having a nicely varying specular roughness (alongside potentially anisotropy) across the surface will give most of the realism in most circumstances with a bit of IOR variation to round the whole thing off.

Even tough almost everything these days is path traced at the end of the day rendering is still a hack to imitate the reel world with our limited computing resources. So while this technique in theory should be more “physically accurate” it’s definitely not a solution that will always look best.

At the end of the day whatever makes an asset or a shot look great is usually the right way to go regardless of the technique in my opinion :)

_________________________________________________
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

This will be a quick one. Light Path Expressions offer a lot of flexibility over the AOV’s you would like to pass off to Compositing. Most modern path tracing render engines like Arnold, RenderMan, Blender’s Cycles, VRay, etc. have support for it by now. With LPE’s you can split pretty much any light path you desire, which brings me to the solution to this first problem.

Usually when you have a refractive object in your scene everything that is being refracted lands in 1 single AOV (usually called refraction, transmission, or something along those lines).
So if I have a scene like this…

My transmission AOV will usually look like this:

…and my diffuse like this:

As you can imagine tweaking the diffuse in comp will be a bit of a cumbersome task as the color of the teapot for example is in 2 different AOVs. Luckily what you can do is to modify the default LPE’s a bit to include transmissive paths in other AOVs like diffuse, specular, subsurface scattering, etc.

I won’t go into too much details of how it works. If you want a proper overview on LPE’s you can read up on them HERE.
The default diffuse_direct looks like this usually:
C<RD>[<L.>O]
Which simply means the lightpath Camera (C) -> Diffuse Reflection event (<RD>) -> Light Source / Emissive Object ([<L.>O])

To make all the light paths include refraction events as well you can tell the light paths to look for zero or more transmissive specular events before evaluating the rest of the light path.
So if you modify the diffuse_direct like this:
C<TS>*<RD>[<L.>O]

… then the diffuse will be a lot more useful for tweaking in Compositing:

 
 

Likewise to make sure everything adds back together nicely you can modify the refraction pass to only include pure transmissive events:
C<TS>+[<L.>O]

 

As a TL;DR here is the stuff I personally like using:
diffuse_direct: lpe:C<TS>*<RD>[<L.>O]
diffuse_indirect: lpe:C<TS>*<RD>[DS]+[<L.>O]
diffuse_albedo: lpe:C<TS>*<RD>A
specular_direct: lpe:C<TS>*<RS>[<L.>O]
specular_indirect: lpe:C<TS>*<RS>[DS]+[<L.>O]
refraction: lpe:C<TS>+[<L.>O]
sss: lpe:C<TS>*<TD>[DS]*[<L.>O]
 
 

_________________________________________________
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

If you have a lot of different passes in your Katana script it can become a bit draining to constantly switch your view flag. The separate Viewer Node in Nuke for example makes it easy to quickly switch between outputs by pressing 1,2,3,…9 as it can accept multiple inputs. In Katana you have to navigate through your script to the desired node to change the view-flag or launch a render.

Being overly lazy I hacked together this simple UI which lets’s you quickly change the view flag and launch live [L] and preview [P] renders. It’s not very aesthetic but it get’s the job done:

To add the buttons to the UI you can set it to get nodes by Type, Name or based on your current selection in the Nodegraph. It should be worth noting that the text input is CaseSensitve. If you don’t have the add option checked it will replace your current set of buttons.

Katana Interactive RenderPanel from Julius Ihle on Vimeo.

There are a lot of things there that’d be nice to have… A simple option to delete button groups, save bookmarks, etc… Maybe… Some day… :)

If you’re feeling adventurous you can give it a try HERE.
To use it put the .pyc file in a sub-directory called Tabs that’s part of your $KATANA_RESOURCES.

 
_________________________________________________
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

Nuke makes it really easy to access metadata from incoming images. You can easily access information from pictures that you shot with your camera or access render stats from CG renderings. This can prove to be really useful in a production environment where you want to make sure that your frames are rendering in a reasonable time without consuming too much memory. This example shows how to access and display that information in Nuke with renderings from Arnold.

Here’s an example of Displaying useful information from a render :

(yes, you are doing something wrong, if it renders that long and takes this much RAM :))
 

 
You can see the metadata of an image with the ViewMetaData node. This node displays all available metadata from your input.
Here’s an example of what a default Arnold EXR render comes with:

Quite a lot of stuff…
Metadata information is accessible in Nuke through TCL expressions which you can use in a Text Node for example. For a full list of what you can do with TCL you can refer to the documentation.

TCL expressions are evaluated in square brackets. You can access metadata with [metadata name/of/metadata]. If I want to get the average rays per pixel for example I could use [metadata exr/arnold/stats/rays/all/pixel] rays/pixel:

As this is averaging the rays of all the pixels it outputs a floating point number. We can convert it to an integer with int(). Note that whenever you want to manipulate numbers you have to enclose your mathematical operation in [expr ]:
[expr int([metadata exr/arnold/stats/rays/all/pixel])] rays/pixels

You can do the same thing to display your RAM usage. By default Arnold displays memory usage in Megabytes… Converted to Gigabytes it might be a bit more useful:

[expr [metadata exr/arnold/stats/memory/peak]/1000]GB

Just a few too many decimal places for my taste… You can use [format] similar to how it’s used in Python to change it to 2 decimal places for example:

[format “%0.2f” [expr [metadata exr/arnold/stats/memory/peak]/1000]]GB

The metadata for the render time comes in seconds with Arnold. If you’re a math genious or have very optimized renders this might work for you. Unfortunately neither applies to me, so a display in hh:mm:ss seems a bit easier to decipher :)

I’m using expr to convert the seconds to integers and display them in hours, minutes and seconds separately:
[expr int([metadata exr/arnold/stats/time/render]/3600)] [expr int(fmod([metadata exr/arnold/stats/time/render]/60,60))] [expr int(fmod([metadata exr/arnold/stats/time/render],60))]

…and use [format] similar to the above example to make it nice and tidy:
[format “%02d:%02d:%02d” [expr int([metadata exr/arnold/stats/time/render]/3600)] [expr int(fmod([metadata exr/arnold/stats/time/render]/60,60))] [expr int(fmod([metadata exr/arnold/stats/time/render],60))]]

Another thing that I find useful to colorize the output. If you just have numbers whooshing by when you play an animation it’s hard to spot potential problematic frames. If you just want a simple heatmap from green to red one way you could do it is to just shift the hue of your text. Looking at a Hue ramp red has a hue of 0 and green has a hue of 0.3333:

So you could put your text in HSV space and offset the red channel to shift your Hue (the hue shift in Nuke does not work properly – see HERE) and make sure you have your saturation at 1:

 

 
So all that’s left to do is to remap the numbers from whichever range you like to 0 as a maximum (red) and 0.3333 as a minimum (green). Remapping numbers can be achieved like this:
outputMin + (value – inputMin) * (outputMax – outputMin) / (inputMax – inputMin)
So if I for example would like to remap the hue of my render time in seconds to display everything with a time below 2minutes (120 seconds) in green and everything above 10 minutes (600 seconds) in red I can use:
(1/3) + ([metadata exr/arnold/stats/time/render] – 120) * (0 – (1/3)) / (600 – 120)
Just make sure you clamp the whole thing to 0 and 0.3333 so the values outside of this range don’t shift to another hue:

 

 
Wrap the whole thing up into a Gizmo and you are good to go… The min values specify up to which point the text will stay green and the max values specify at which point it will be completely red:

You can grab the Gizmo from this example HERE.

 
_________________________________________________
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