Render Series

Version 1.0, Updated December 2024 using Octane 2024.1 and Cinema 4D 2025.1

About this Guide

This is the fourth guide in the Post Production/AOV series. It focuses on the Output AOV system in Octane. If you don’t know what Output AOVs are, how they differ from Render AOVs, or what an AOV even is, start here instead.

This guide is split into two parts - the first one gives a high-level overview of the system, and the second is a walkthrough that takes you through the most important parts of it. It doesn’t cover every node, but by the end of it, you should have a feel for how to start doing some post work in Octane.

PDF

A PDF version of this guide can be found here.

Downloads

Follow-along files for Part II of this guide can be found here.

Part I: Overview

As we learned previously, Octane currently has two AOV systems that are kind of intertwined: 

Render AOVs are the components of the actual render itself that can then be used IN post. 

Output AOVs are part of Octane’s internal compositing system, so they basically ARE post. 

How is this different from using a dedicated post app?

The obvious advantage to this over exporting to an external compositor is that we don’t have to export to an external compositor. If something makes sense to fix with an AOV, we do that in Octane. If it’s easier to fix in render, we do that in Octane, all without having to round-trip to a different app. The disadvantage is that it doesn’t have all the thousands of plugins, options, and other craziness that a dedicated post app has, but if we only need to do what the AOV system can do, it saves us a lot of extra steps.

Even if the eventual goal is to send to an external app, the Output AOV system is also useful for auditioning and pre-visualizing a bunch of different looks so we can make any last-minute adjustments to the actual render before exporting and recreating those looks in our post app.

How is this different from the Imager?

We do get many of the same options in the Imager that we get using Output AOVs: We can do adjustments like saturation, exposure, tone mapping, LUTs, denoising, postFX, and a few other things, but everything we do in the Imager ONLY affects the entire beauty pass after it’s been reconstructed. 

We can’t, for instance, adjust the saturation of only the reflections, or mask out part of the render and adjust the exposure on only that one part using the Imager, or quickly set up a scenario where we’re testing ACES vs AgX, but we can do that - and much more - using Output AOVs. 

The Imager is good if we get 95%+ to our goal in render and we just need to give the beauty pass a quick polish or some postfx jazz before sending out for review or the web. Output AOVs are good for advanced compositing and auditioning looks without having to leave Octane. 

Anatomy of the Output AOV system

Officially, what we’re making here is called an Output AOV. That’s the thing that we export as our final SDR render, or send alongside other Render AOVs using an HDR format like EXR. 

In certain parts of the UI, we might still see the term “Composite AOV” pop up which is an old legacy system that’s kept around for compatibility reasons. 

An Output AOV made up of a number of layers, each of which can hold a chain of nodes. There are ones that reference data we’ve already rendered, as well as adjustment and utility nodes. Similar to other compositing programs, these layers are combined via blend modes and masks. Output AOV layers can also be further organized into groups if we need to get more complex with our node structures.

As of this writing, we can currently make 16 Output AOVs per C4D Render Setting. 

Output AOV management

Output AOVs are managed in C4D’s Render Settings (Ctl-B/Cmd-B) > Octane Renderer > “AOV Group”. Unlike Render AOVs, we don’t need to turn anything on - as soon as we add stuff to this area, we start seeing our AOVs in the Live Viewer.

This section contains a few UI elements. There’s a list of presets, but they’re generally not super helpful and are really just there as examples. There are also buttons to add and remove Output AOVs (called inputs here), but this comes with a pretty big gotcha that we’ll look at shortly.

While we can manage and build out our Output AOVs using C4D’s controls and UI, it quickly gets tedious and unmanageable because of all of the different levels we have to work across (as we can see above), so it’s far easier and more efficient to use the node editor.

AOVs in the Node Editor

When we click the Node Editor button in the AOV groups tab, it launches a node editor with a single “Octane Renderer” node in it (assuming we didn’t add any Render or Output AOVs).

This node is a visual representation of the active C4D Render Setting. If we select that node, we’ll see the same Octane Renderer settings on the right that we see if we open the Render Settings window and choose “Octane Renderer”. Anything we change in one place updates in the other - it’s literally the same.

We need to add an Output AOV to anything in this section. We do this by hitting the Add input button in the AOV groups area.

Wonky naming

Right away, we see two confusing things if we’re using at least Octane 2024.1 or earlier. 

First off, the input (pin) in the Octane Renderer node that our new Output AOV goes into is called “Composite AOV1”. As mentioned before, this is left over from the legacy Composite AOV system. We need to pretend this says “Output AOV 1”.

The second thing is that our new Output AOV itself is named “AOV group”. It’s not a group though, it’s a single Output AOV. We can see this by selecting it and under the Basic tab on the right, looking at the Type menu. The Type is Output AOV. 

If we select that node and look at the list, we’ll see that there’s an option to turn it into an actual AOV group if we want (which we don’t since this hasn’t been fully implemented yet). For now, we can either ignore the name of it or rename it to Output AOV 1 to have it make more sense.

Exploring Output AOV nodes

One of the easiest ways to explore all the options we have in the system is in the list of nodes on the left. This list is sometimes hidden, but we can show it at all times by going into the Octane settings (gear menu) > Settings tab > Nodes subtab > and uncheck “Auto hide menu” at the top.

The Output AOV nodes are at the bottom of the list and are kind of lavender colored. Most of the Output AOV nodes are here, but not all of them (we’ll cover this in another guide). We can also filter out most of the other nodes by deselecting all the filters at the top except for “AOV”.

Adding nodes

We can add an AOV node in a few ways: 

• We can just pull a wire out from the Layer 1 pin and we’ll see a list of nodes that can connect into it - that’s probably the fastest way
• We can also pick it from the list on the left toward the bottom
• We can pop up the Commander with Spacebar or the letter C and search
• We can use the Create menu in the Node Editor, and under node, under AOV, find them there.
• Bonus: if we have a wire connecting an output to a node already and want to insert a node in the middle, we can hover over the wire, and click the little yellow square that appears in the middle of the connection and that gives us a list we can choose from too

A Tale of Two Systems

Important: The node editor shows us all our Render AOVs (if we have any) AND all our Output AOVs. One of the most confusing things we’re going to have to deal with early on (and probably revisit a few times) is that we can’t mix and match systems. 

The Output AOV system has its own Render Output AOV node (unhelpfully called Render AOV, but only sometimes) that lets us access our render data (diffuse/reflection/etc), but it’s a different type of node in a different system. If we try to connect an actual Render AOV node from the Render AOV system into our Output AOV chain, it simply will not connect and we’ll be left scratching our heads.

Also important: The other thing to get into our heads early is that the Output AOV system can only work with data that has already been rendered. By default, Octane renders a beauty and lighting stack, so we have those passes at our disposal, but if we want to play with Cryptomattes or Denoised passes or depth passes, etc, we need to first render those by turning them on in the Imager or Render AOV nodes.

Add shortcut to node editor in C4D UI

If we find ourselves using Output AOVs, or the node editor in general a lot, there’s a faster way to get into it when we open C4D. We can dock an Octane Node Editor button somewhere in the C4D UI by going to the Window menu and choosing Command Manager (shift-f12). If we search for “Octane Node”, we’ll find the button and then we can drag it out and dock it. The Custom Defaults guide has a detailed look at this.

When we click that button, it launches the Octane Node editor that’s either blank or has a material. There’s a button at the top that says “Render AOVs”, which should just read “AOVs” because it covers both Render and Output AOVs, but whatever - when we click the button, it shows us all our AOVs and we’re good to go.

This is also super useful for bouncing back and forth between editing materials and our AOVs without having to open and close the node editor all the time.

Removing an Output AOV

We touched on this earlier, but let’s look at this again, since it can be a real pain point. Let’s say we have three Output AOVs and want to get rid of AOV 1. Adding and removing the actual inputs (pins) from the Octane Renderer node can only be done in the AOV groups tab. We can get to that either through the C4D render settings, or by selecting the Octane Renderer node itself and looking in the right area - again, it’s the same set of controls, just in a different place.

Really important: If we select AOV 1 at the top and hit the Remove input button it deletes AOV 3 (not 1) and EVERYTHING ATTACHED TO IT. So if we have a long chain with a ton of layers and groups and stuff that we spent an hour constructing, it’s all gone in a single click. Like gone-gone, not just disconnected.

Here’s the really weird part: The remove input button removes the last input that has something attached to it. So if the AOV 3 input with nothing connected and we hit Remove input, it will remove AOV 2 and everything connected to that instead. If AOV 2 is also empty, it will remove AOV 1. If all the AOVs are empty, it won’t do anything at all and we can mash it all day and wonder if it’s broken. 

Now, all’s not lost - we do have a few levels of undo if we catch it early enough, but it’s really important to be careful when removing inputs. 

So what to do?

The best thing to do really is just never use that button, and manually disconnect, disable, or delete the nodes we don’t want. Turns out, it doesn’t really matter whether the pin is showing in the Octane Renderer node or not - if nothing is connected to it, then the tab doesn’t appear in the Live Viewer window.

If we’re hyper-organized we can just rewire the AOVs so they’re in the first slots, and if we’re REALLY hyper organized, we can attach a new output AOV to the empty pins and THEN use the Remove input button to get rid of them. Again, if we don’t have anything attached, it will delete the last input that does, so we need to be super careful.

Part III: Walkthrough

Let’s take a guided tour around the AOV system and see what trouble we can get into. 

A starter file is here if you’d like to follow along (along with various states of completion).

Getting started

Our starter file doesn’t contain any AOV data, so let’s pop open the Render Settings, head over to the Output AOV tab in the Octane Renderer section, and click Add input (and give that Remove input button the side-eye while we’re here). Again, early on while we’re learning, we’ll want to rename “AOV group” to Output AOV 1, because it’s not a group, and this can get confusing otherwise.

Now let’s hit the Node editor button and get this show on the road.

Let’s add a Render output AOV node into the Layer1 pin of our Output AOV 1 node using one of the methods we learned about earlier (pulling out a wire from the Layer1 pin is probably the easiest way). If we select our new Render output AOV node and go into the Parameters tab on the right, we can see a list of all the available passes we can pick from.

These are all the same ones we learned about in the last few guides, but in order to use them in the Output AOV system, we need to use this particular Render output AOV node (which sometimes shows as “Render AOV” node), and not the Render AOV system’s Render AOV node (I know, right?).

If we set the…grmbl... “Render AOV” dropdown to beauty and then go to the Live Viewer and render, we’ll see that both the Main and Out1 tabs at the bottom are exactly the same, since they’re both pulling the rendered beauty pass. We could also pick diffuse, reflections, refractions, lights, info passes, or most of the other AOVs we’re already familiar with and we’ll just see that in the Live Viewer, but for now let’s just leave it on beauty.

Adding an Adjustment AOV

Let’s say we want to mess with the saturation of the whole image. We have an Adjust saturation node, so we can just drag that out from the side or search for it and drop it into our scene. If we have any previous Octane experience (we probably do), then what we’re expecting to see is an input and an output pin so we can put it between our render node and the Output AOV node, but nope, it just has an output pin. This leads us to a really important concept here:

Important: Unlike most of the materials system, The Output AOV system is pretty much all layers-based. It’s rare that we can run one node through another node. Most of the time we need to stack them in layers, and the higher numbered layers affect the lower numbered ones, so order matters.

So if we want to desaturate our beauty pass, we need to make a second layer in the Output AOV by clicking it and choosing Add layer from the Parameters tab on the right. Then we can attach our Adjust Saturation node and it affects all the layers under it. 

Let’s set it to 125% to boost the saturation a bit so we get more clicks on the socials.

We’re not going to add any more adjustment layers here because we don’t want our node structure to get too large for this walkthrough, but we can see a few other things we can control in the illustration above.

Yes, we can desaturate/oversaturate the whole image in the Imager either globally or per-camera, but if all we wanted to do is mess with a simple adjustment, we wouldn’t be using AOVs. The point here is that we can do everything we can do in the Imager and Post Processing tabs of the camera or global settings, but we can do a whole lot more too.

Blend Modes

Let’s select our Output AOV 1 node again and add another layer. Now let’s pull a wire out from the Layer 3 pin and choose Solid Color. If we have the render going in the Live Viewer and Out1 selected, we’ll see it turn white because our solid defaults to white. Let’s make this purply blue by clicking the Solid color node and giving it a value like H:260/S:100/V:100 (assuming we’re using the C4D color picker). Now our render turns solid blue, which is great and all, but not super interesting.

If we select either the Solid Color node or the Output AOV node and look under Layer 3 (same options, different spot), just below the color picker is a section for Blending Settings. This may or may not be twirled up - if so, we need to twirl it down by clicking it.

Right now we’re on Normal mode which means it’s not going to blend at all. 

If we set it to Physical/Add (which is called Linear Dodge in other compositing apps), we’ll see our scene with a purply blue overlay. It’s a bit washed out because it’s adding the values of the solid pixels to the values of the ones in the lower layers, so everything gets brighter. If we’re breaking apart our render into separate beauty or lighting passes to modify the passes themselves, “Add” is what we’d use to recompile all the passes to form the Beauty render again.

If we set it to Physical/Subtract, we’ll see the scene turn green. Makes sense if we think about it since it’s subtracting purply blue (H:260°) from the scene, so we’re left with the complementary color (H:260°-180°=80°, or green). This probably isn’t used on color data that much, but it’s super helpful for blending and altering grayscale masks.

Physical/Multiply is good for bringing out shadows, like with an Ambient Occlusion or Shadows pass. The other modes have their uses too, but just aren’t as common.

Let’s set it to Add for now.

Masking & Grouping

Masking is an important function of a compositing system. We learned all about how to generate masks in Octane in the last guide, but now we can use that data to isolate components and adjust them.

There are two ways we can do masking in Output AOVs - either with Cryptomatte or using the attribute of a layer (or groups of them). Crytpomatte takes a little more setup, so let’s look at masking with a layer or layer group first.

Masking with a layer group

Let’s make a fourth layer in our Output AOV1 node and attach a Mask with layer group node.

Note: Despite it being called “Mask with layer group”, we don’t actually need a layer group here - we can just mask with a single layer if we want.

This node has an input pin which is where the mask data goes. Let’s make a simple mask by hooking up a Texture AOV node to that and then put a checkerboard texture into that. We could also use an Image AOV with a custom grayscale image, or any number of generators or masked data earlier in the chain. For now, checks will do because it’s simple and obvious.

If we head back to the “Mask with layer” group node, we’ll see a dropdown for Source. This is the property of the source texture that we’re pulling the masking data from. The checkerboard texture doesn’t have an alpha channel, so the default of Alpha won’t do us any favors. Instead we want Luminance so black means fully transparent and white means fully opaque.  

…and that’s exactly what we see in the Out1 tab in the Live Viewer when we select that. The black squares in our checkerboard make that part of the image 100% transparent all the way down to the transparency grid, and the white squares show our beauty pass with the saturation boost and purply blue overlay.

This is great and all if we want a simple transparent PNG as our output, but we’ll quickly realize that no matter how much we shuffle nodes around, we can’t get any parts of the image to show under the masked section. That’s because a mask - just like all the other adjustment layers - affects EVERY layer in the stack that’s below it. So what do we do if we only want part of our image masked, but see the rest of it (or something else) beneath it?

 This is where layer groups come into play.

Groups

The Output AOV system has two types of groups. There’s the actual Output AOV group node, and the Layer group node. 

Important: As of this writing (version 2024.1-[R3]), the actual Output AOV group node is not implemented, and is probably only there for compatibility reasons with Standalone. If we create one (which is tricky to do since it only shows up in one location), it’ll just generate transparent data and ignore everything plugged into it.

So we’ll focus on the Layer group node. This can be connected to any input pin that has “Layer” or “Input” in the name, so that means an Output AOV, either of the “Mask with…” nodes, an Output AOV layer switch, or another Layer group node.

Let’s see how it works by adding a layer group in between our Output AOV 1 node and our Mask with layer group node. We can do this via yet another method, which is to hover over the connecting wire and click the little yellow square that appears in the middle of the wire and double-click “Layer group” - that will insert a group between our nodes and shove the other nodes over to the left to make room.

Nothing changes in the render, which is what we expected. In the Layer group node, we can add another layer, so now we have two. Things get a little confusing here, so let’s break it down.

Our Checks and Texture AOV nodes only make up our mask data. Masks always go on top of whatever it is we want punch pieces out of. This means we need to move the wire coming out of the “Mask with layer group” from Layer 1 to Layer 2 in the Layer group node so it can mask something that we feed in below it. 

For now, let’s feed in another solid color just to see how this works. This time let’s make the color orange (H:30, S:100, V:100), and connect that to the Layer 1 input of the layer group.

Instead of making the beauty render transparent and putting a solid orange thing below it, we created an orange thing with squares punched out of it based on the checkerboard texture and laid it over the top of the full beauty render (with the saturation boost and purply blue overlay). We could reverse this by shuffling the nodes around, but this is easier to show in our example here. 

 

Cryptomatte

Now let’s check out masking with Cryptomatte. Up until now, we’ve used render data that made up the beauty pass (diffuse/reflection/emission, etc.), and we also created a checkerboard using a texture generator and fed that into a Texture AOV node.

Important: The Output AOV system does not have its own Cryptomatte generator node because it’s a compositor system, not a render/generator system. Cryptomatte is an extra chunk of data we would have had to render using a render AOV.

Cryptomatte doesn’t come stock in a Beauty render, so it’s something we need to add on during the initial rendering process, and for that we actually have to use an actual Render AOV (not a Render Output AOV). To do that, we can just click the Octane Renderer node, go into the Render AOV group tab, click Enable (important), and then click the Add AOV button, and under Auxiliary, choose Cryptomatte.

This pops in a Render AOV 1 input in our Octane Renderer and hooks up a Cryptomatte node named “Material node name”. When we click that we’ll see a place to rename that, and a type that says Cryptomatte, but no way to change the type from Material node name…

..or IS there?

Turns out if we expand the pane out a bit we’ll see another field for Crypto type. Now we can select one of the other ways to get cryptomatte data. The starter file has Octane Object tag on all the various objects, and they have different Layer IDs assigned to each, so we can just pick the Render Layer Cryptomatte type. This changes the name of the node to Render Layer which can also cause more confusion, so let’s rename it to Cryptomatte so we know what it is. If we’re going to use several Cryptomatte nodes, we could name it Cryptomatte-RL or whatever to keep organized.

As we know by now, we can’t just feed this cryptomatte node into our Output AOV system because it’s a different system, but we can access it now using a Mask with Cryptomatte node, so let’s make one of those and replace the Checks/Texture AOV/Mask with layer group nodes with it.

If we select it, we’ll see a Type dropdown here and a box that says Mattes. 

So now what?

This node has a new picker - it’s the blue map pin icon with a C in it that lets us choose which matte or mattes we want, so that’s cool.

We need to have the cryptomatte visible, so let’s head over to the Live Viewer and hit the cm-RL tab at the bottom which will show us our Cryptomatte data. We may have to restart the render to see it.

Now let’s select the Mask with Cryptomatte node that we dropped in and look at the options on the right (we can shrink that pane down a little now - no more hidden options at the moment). 

Important: We need to make sure the Type dropdown is set to the Cryptomatte type that we’re seeing in the Live Viewer (in this case Render layer, or cm-RL).

So we have a different color for each object with a different Layer ID. If we click our little Cryptopicker icon, we’ll see it show up in the Live Viewer UI. If we click it again, it goes away. Let’s click it again to bring it up and then pick the bust (the gold head) mask which is probably dark blue in the cryptomatte depending on whether the colors got reset in your particular installation.

Now we’ll see “layer-2” appear in the matte box, so we know that’s selected. If we click the head again, it goes away. We can toggle on/off as many as we want by clicking around in the Live Viewer. We can also go into the box and just type “layer-2” if we know that’s the name of it, or delete ones we don’t want. Let’s just end up in a state where we only have layer-2 in that box. Let’s also click the picker icon again to get it out of our Live Viewer UI.

If we did everything right, when we go back to Out1, we’ll see our purple beauty render, but the head is now solid orange (because of the orange solid node). Again, cool, but not a practical use case. 

Let’s swap that orange solid out with the original beauty pass so we can see the original material. We can either run a wire from the Render output AOV we have at the bottom, or we can bring in a new Render output AOV and connect that up. Either method is valid since this node is just a pointer to the original render data - we’re not duplicating effort. We can pick the method that keeps our nodes best organized.

For now, let’s create a new Render output AOV node and replace the Solid color node with it - and voila, we have our original copper head back amongst the rest of the purplized scene.

Light Mixing

Up to now we’ve only been working with beauty passes, but Octane generates lighting passes by default too, as we learned in the Intro to AOV guide. Octane has a node called the Light Mixer that lets us adjust all the lights in our scene in one handy dashboard.

Let’s add another layer to our Output AOV 1 and then create a Light Mixer node.

Important: There’s also a legacy Light Mixer node that worked with earlier versions of Composite AOVs - we don’t want this - fortunately it says (legacy) after it so we know to avoid it. 

The Light Mixer node should go low down in the stack because otherwise it’ll override many of the other nodes in the scene like our purply blue adjustment layer. The order of our layers matter a lot. Let’s move all the other nodes up one layer and put our Light Mixer into Input 2. When we select it, we see an overwhelming list of stuff on the right, but we’re really only interested in a few of these sliders

If you’re following along with the starter scene, there are 3 lights that came with it - an HDRI, a key light, and a fill light. The HDRI is always on the Ambient light pass. The key light was set to ID 2, and the fill light was set to ID 3. We can enable/disable the light IDs, and also adjust the intensity and tint of every light assigned to the same ID. 

It’s going to be hard to see what we’re doing with the other adjustment layers going on, so let’s click each one of those layers and uncheck “enable” for the Saturation, Solid Color, and Layer group that we used for masking. Now we just see the beauty render.

Let’s play around with these sliders, tint the lights, and turn some of the passes on and off. When we’re done, let’s make the ambient multiplier (HDRI) 100%, ID 2’s multiplier 200% (key light) and ID 1’s multiplier 200%, and remove all tinting (set all the tints to white).

Color management

Octane’s internal compositing system works in 32-bit, which is great. It means we never lose render data while we’re working with most of the nodes (some say SDR-only which means they only operate on converted-down 8-bit data).

As we learned in the Color Management guide, we have various ways of applying 8-bit conversions to our 32-bit data so we can export them for the web or some other use (or just to previz them before we move the 32-bit data into another app for further compositing). 

Bouncing back and forth between different looks is kind of an involved thing when we’re doing it in the main UI, but one super nice thing about Output AOVs is that we can quickly set up a stack of output AOVs so we can test different looks and compare them against each other.

Basically what we need to do is take Beauty Render output AOV and the Light Mixer and move them from Output AOV 1 to a new layer group. It’s a good idea to rename these nodes for our own sanity, so let’s call it “Main Scene”. We don’t need our masking or purply-blue overlay anymore - this will be easier to see without them.

Let’s select Octane Renderer and in the AOV group tab set up a few more Output AOVs (four total), and add a new layer to each one. We can run our Main Scene node into Layer 1 for each one, and then create a bunch of Convert for SDR display nodes. Let’s pick basic, ACES, AgX, and a new one - smooth. 

If we run each one of those into the corresponding Layer 2 in each output AOV (and rename them so we know what we’re doing in the future), we now have four different AOVs that we can compare :) 

We can take AgX (or any OCIO) tonemapping a step further and stack an Apply OCIO look node on top of that and then choose one of the built-in looks for that config. For now, let’s do that in Output AOV 3 and choose “Punchy” when we select the Apply OCIO look node. The Convert for SDR display (AgX) node has a punchy checkbox also so we don’t actually need the Apply OCIO look for that, but it doesn’t have a “golden” one if we wanted that look.

Important: Convert for SDR should almost always be the topmost node in our stack because we want it to affect everything below it. This node removes HDR data, so anything we do on top of it might blow out highlights or affect colors in unexpected ways.

What we end up with here is a Main tab, which shows what the render looked like prior to us futzing around with the Light Mixer. We have the default tone mapping applied here (sRGB clipped), which Octane refers to as “Basic”. Then we have Out1 (our first Output AOV) which shows what happens when Basic tonemapping is applied after the Light Mixer. Out2 shows us what ACES tonemapping looks like after the light mixer, Out3 shows us AgX using the Punchy look, and Out4 shows us a new type of tonemapping that was introduced to Octane recently called “Smooth”. For now, this is the only place we can access Smooth tonemapping which is pretty cool.

We can also do the same thing with a custom curve, LUTs, gamma, or a camera response curve to get a ton of different looks that we can quickly cycle between.

Important: when we go to save any of these Output AOVs where we already used a Convert for SDR node for the web or review, we want to make sure we don’t apply tonemapping again. Depending on how we’re saving it, it may be called Basic, sRGB, none, or no tonemapping in the Color space options.

It seems counterintuitive at first, but we’re using the Output AOV system to apply tonemapping to the HDR data already, so if we go to save it out as a PNG or other 8-bit file using OCIO or forced ACES tonemapping, it’ll double up on the tonemapping and it won’t look as expected. Most of the time it’ll be extra contrasty - either a little bit like the AgX example above or a lot more extreme if we try this with ACES because of the sharper curves.

Basic (no tone mapping) won’t alter the image at all when we go to save, so it will look exactly as we were seeing in the Live Viewer.

Wrap Up

That’s probably enough for now. If you’ve made it this far, you should have a pretty good understanding of what the Output AOV system in Octane is and does, how to navigate some of the strange naming of things, and how to do most of the basics. 

We’ll take a look at more of the specific nodes, workflows, and options in future guides, but this should at least get you started with doing some post work without having to leave Octane.

Author Notes

OG046 Output AOVs - Intro and Walkthrough Version 1.0, Updated Dec 2024 using Octane 2024.1 and Cinema 4D 2025.0.2 

This guide originally appeared on https://be.net/scottbenson and https://help.otoy.com/hc/en-us/categories/201718003-OctaneRender-Support-Guides

All rights reserved.

The written guide may be distributed freely and can be used for personal or professional training, but not modified or sold. The assets distributed within this guide are either generated specifically for this guide and released as cc0, or sourced from cc0 sites, so they may be used for any reason, personal or commercial.