Getting Started with V-Nova PresenZ Houdini
This section is dedicated to getting you up and running with V-Nova PresenZ in Houdini
Getting started with Houdini and the compositing process can feel daunting, but this section is designed to make it straightforward.
We’ll cover the basic export workflow, how to start manipulating the generated points, and best practices for compositing them into a VR-ready scene. To begin, here’s a brief overview of what you’ll need in Houdini and how to set it up.
Note: if you have skipped the Maya and Arnold sections please make sure that you understand each of the "Getting started" sections before proceeding to Houdini, as these are in a linear workflow simulating the production process and there is information in these sections that you will need in the following sections.
Basics
Exporting AOV's and light groups
If you’ve worked through the Maya and Arnold section, you should be familiar with the current setup. In the render settings, we’ve enabled AOVs such as ID, Albedo, and Pref, and we’ve also added light groups under RGBA_sky, _lamp, and _sun. In PresenZ, this data is applied to the generated points so that, when you rebuild them in Houdini (or another compositing package), they behave as a coherent image layer, similar to what you’d expect from a standard, uncompressed image file (for example, an .exr).
It’s also worth noting that, in addition to adding AOVs, we can separate the scene into layers in Maya. I’ve linked the Maya Clipping Sphere section here; we can use that approach, or Maya’s render layer exports as shown below. The goal is the same: avoid re-rendering multiple frames of a static background, and render animated characters separately to reduce render time and cost.
Note: If you’re rendering animation, make sure you have Motion Vectors setup, as these values are also applied to the points generated and will be vital for smooth interpolation on animation.
Getting started Houdini basics
Now lets move on to the more daunting part, creating a PresenZ setup is remarkable easy. This section will go over the step by step of creating a Houdini PresenZ scene and outputting a .PRZ file so that you can view in the player or sequencer.
Lets start by creating a PresenZ node in the object level, this will be our main workspace going forward and is simply a modified Geometry SOP node.
Inside of this node you will see that there is a basic setup ready. If you have a .przRender file created from maya this is where we will add it in the Loader.
To manipulate PresenZ data you always need to start with the Loader PresenZ node.
Its important to note that here in my example I have added both left and right eyes, but the process is the same. Simply use the Load PresenZ node to select the files required,we then use the copy_right_to_left_eye node. This is important as it will append the AOV's and values with correct left and right eye values, which we will see in the spreadsheet.
If you have, like me, separated parts of the scene using the clipping tool, you will have multiple layers to call in as seen below.
It’s worth noting that the multiple blocks shown above are expected. For example, Outside Left and Outside Right each contain three blocks (0–2). This comes from the render blocks explained in the Maya Arnold section (link here). It’s important to label these correctly at this stage to avoid confusion later.
As you can see, you can use a simple Merge node to combine the left-eye blocks and, separately, the right-eye blocks. However, when it comes to combining the left and right eyes, use the copy_right_to_left_eye node again. This ensures all the required information from the right eye is copied across and that the attributes are named correctly for the steps that follow.
In short, merge the blocks per eye with a simple Merge node, then use copy_right_to_left_eye to combine the left and right eye renders with the correct data and attribute naming.
If you wish to create new Loader nodes, simply tab and type Load and you should see the node available, and if you need to create a new write node it is the same bellow.
Now lets setup the write node. We just need to tick the "save PRZ file" control and set the file path for the output, the rest of the setting should be set from the scene, so you should check the start and end frames.
And we are now ready to render for V-Nova PresenZ Player or Sequencer. Once done, simply locate your .prz file and either double click if you have the dashboard tools installed and setup or use the player and drag and drop your .prz file into the work space. You can then view in VR or Monitor view depending on preference.
Load PresenZ node (prz_loader)
The Load PresenZ node, identified as prz_loader, is a geometry node in Houdini designed for importing and converting PresenZ files (przDetect, przRender, or prz) into Houdini point clouds. This node is crucial for volumetric renders that leverage point cloud data.
Input file formats
This node accepts three types of PresenZ files:
przDetect
przRender
prz
Each file type is processed and converted into a Houdini-compatible point cloud, retaining essential metadata in the detail attributes.
Left eye branch
Load PresenZ Nodes: Two nodes named THEROOM_Tutorial_L_bloc0 and THEROOM_Tutorial_L_bloc1 are used to import the left eye’s point cloud data.
Merge Node: A merge node labeled merge6 consolidates the point cloud data from the two Load PresenZ nodes.
Right eye branch
Load PresenZ Nodes: Similar to the left eye branch, two nodes named THEROOM_Tutorial_R_bloc0 and THEROOM_Tutorial_R_bloc1 load the right eye’s point cloud data.
Merge Node: Another merge node labeled merge7 combines the point cloud data from the right eye’s Load PresenZ nodes.
Combining left and right eye data
PresenZ Combine Node: The prz_combine_LR node takes the merged output from both the left and right eye branches. It is specifically designed to handle stereoscopic data, ensuring the point clouds are combined in a way that preserves the spatial and visual integrity of the stereoscopic effect.
Write PresenZ node (prz_writer)
The Write PresenZ node, referred to as prz_writer, is a geometry node in Houdini used for exporting point cloud data into PresenZ file formats. This node is pivotal for creating przRender files or prz files from within Houdini.
Supported output formats
The Write PresenZ node supports two primary output formats:
przRender Files: Used for rendering purposes, carrying detailed color and spatial data.
prz Files: Typically used for storing compressed point cloud data.
Color space consideration
An essential aspect of using the prz_writer node is the color space of the point cloud data:
The node assumes that the color data of the point cloud is in a Linear/ACEScg Color Space. This assumption is critical for ensuring that the output files maintain color accuracy and consistency with the intended design.
Compositing with AOV's
Now let’s go over the process for using the AOV's in order to edit Colour in our Houdini scene and improve our render. So what are AOV's?
So what are AOV's?
Arbitrary Output Variables (AOV's) are render passes that break down a 3D scene into specific data layers (like reflections, shadows, depth, normals, material IDs) beyond just the final colour ("beauty pass"), giving compositors control to adjust elements individually in post-production, enabling more flexible adjustments (lighting, colour correction, motion blur) without re-rendering the entire scene.
In PresenZ, we store all of this data on the points that we generate. This allows us to do very similar adjustments to what you would see in any post-production workflow. If you are not used to comping, this process might seem odd, but it simply allows the artist to tweak and adjust the final render without re-rendering, allowing us to beauty light characters like we see in post film production.
For comp artists, this process will be nothing new, but Houdini might be new software that we don't usually associate with compositing. Let me be clear: the process is essentially the same. If you are used to Nuke or other compositing packages, you will find Houdini operates much the same way. Instead of using a 2D image, we have 3D points. Nuke has been able to visualise points since version 6.0 in 2010, so most Nuke artists will be aware that points can be used to hold values for compositing. Houdini just allows us to use points more easily.
So that aside, let’s start.
Taking a look at the image above, we can see a list of available AOV's that have come through on the points. These are on each of the Load PresenZ nodes and will need to be activated, but there is a handy Activate All at the bottom of the list.
Now we need to add a Unpremult. For those artists who have used comp packages like nuke this is nothing new. Unpremulting an image before working in compositing is a critical step because it allows you to colour correct, grade, or manipulate the colour values of a masked object without affecting its transparency or creating dark, unwanted halos around the edges. Dividing the RGB by the alpha restores the original colours of the image. The grade is applied to the image data, not the boundary pixels, resulting in clean, natural, and accurate colours.
we can find the unpremult and Premult nodes by tabbing and typing in the search.
From here, we should move to the compositing node. This can be found by simply hitting Tab and typing comp, and it should appear in the dropdown menu, as shown bellow. Now double-click to move inside.
Inside the comp node, we can see we have a simple setup ready for us. We can also see there is a brief description/notes to show us how this functions. We can ignore the input 2 section for now, and let’s look at a very simple adjustment of our light groups.
Let’s start by creating the basic adjustment nodes: an attribvop with an attribadjustcolor node, and then an attribute combine to merge with the original. We can go over the settings one by one, but let’s start by double-clicking the attribute VOP to go inside.
Inside, you should be greeted with the image above. We won’t need the Geometry VOP Global. We need to add a parameter node to identify the attribute to edit, so let’s start with a light group and create an ADD node to adjust it before plugging into the Cd value on the Geometryvopoutputt, shown below.
Below is an example of hooking up the RGBA_sky AOV into the ADD and Geometryvopoutputt. Here, I added it as a Color, as my values are RGB, not RGBA, but we can change the type to Color+Alpha if you have just RGBA values. Note that this was a preference, but RGB is better for use in PresenZ.
you can also get a list of available AOV's from the Geomatry Spreadsheet seen above
Having added all the lights, you can see the basic setup below.
Below, you can see the difference in the render when we add a bit more warmth to our lamps and a bit cooler blue to the sky. by adjusting the Constant color and changing the Operation to a multiplier . The bottom image is with the attributadjustcolor node disabled.
This shows how we can quickly and easily adjust the lighting in our Houdini comp node, but perhaps you will need to adjust these lights on a specific object, so now let’s look at how to isolate objects and apply similar adjustments.
Color management
The point cloud colour data is in a linear/ACEScg color space. In order to preview the color properly in the Houdini viewport, please make sure that the setup does a proper linear to sRGB correction.
The color correction panel can be found here. Please consult the Houdini documentation for OCIO management. By default, Houdini will use a gamma 2.2 correction that is mostly correct.
Compositing with przRender files
For compositing purposes, it is recommended to use przRender files. These files contain data in floating-point format and are in a linear space/ACEScg color space. This ensures high-quality rendering outputs, suitable for professional-grade compositing.
Point cloud attributes
The point cloud generated by the Load PresenZ node has several modifiable and non-modifiable attributes:
Modifiable attributes:
v@Cd: Color of the point. The color for the right eye is encoded in v@Cd_Right.
f@Alpha: Alpha value of the point. Modification is discouraged unless necessary.
v@v: Motion vector information in 3D space. It defines the position of a point in the next frame using the formula v@P = v@P + v@v in an attribute wrangle node.
v@N: Normal of the underlying plaque defined by the current point. Modification is discouraged without a valid reason.
You will also find your AOVs as others point attributes.
Non-modifiable attributes:
Other values like v@P, i@camera, i@posx, i@posy, and f@distance are crucial for saving the point back into the V-Nova PresenZ format. Modifying these may result in incorrect prz files or be ignored entirely.
Manipulation of points:
Points can be removed, merged, grouped, or isolated as needed for compositing purposes.
Detail attributes
The point cloud’s detail attributes provide vital information about the render settings used:
draft: Indicates the draft mode setting.
eye: Specifies which eye (left or right) the render corresponds to, important in stereo rendering.
renderscale: Provides the scale factor used in the render.
AOV names: Lists the names of the Arbitrary Output Variables involved in the rendering process.
box scale: Indicates the scale of the Zone of View used in the render.
imageSizeX and imageSizeY: Provide the dimensions of the rendered image in pixels.
These detail attributes are essential for understanding the context and settings under which the original file was rendered, and may influence how the point cloud is manipulated or re-rendered.
Creating masks
In compositing, a mask is a tool that controls the visibility or effect of an image or video layer, acting like a stencil to reveal (white), hide (black), or partially show specific areas, allowing for precise blending, isolation, or selective application of effects without permanently altering the original pixels.
When creating a mask, we use the PresenZ Mask node. You can create a Mask node by hitting Tab and typing Mask while in the node graph inside our PresenZ Geo.
We don’t need the second input, which is for tracking data, but in this example we will isolate our ball and use the mask so that we can confine our Color Correct to it.
We can see we have the ball isolated by the fact it is shaded white.
Here, we are going to use the Color Correct to boost the red of the ball, but we could just as easily change the colour completely.
This method can be useful for separated objects, but it has issues when objects are interacting with others or are moving. In this case, you can place the mask object carefully, but cryptomattes are easier, as we will explain.
PresenZ background mask node (prz_background_mask)
The PresenZ Background Mask node, named prz_background_mask, is used within a Houdini network to generate a background mask attribute for scenes using przRender files. This mask identifies regions of the render that are not occluded by any geometry, effectively marking the background.
Functionality
Input: This node processes data from prz_loader nodes that contain przRender files. For the mask creation process, only the loaders for the left eye are necessary.
Background mask creation: The prz_background_mask node adds a “background mask” detail attribute to the point cloud data. This attribute distinguishes between foreground (occluded by points) and background (unoccluded regions).
Baking the mask: After the “background mask” detail attribute is created, it can be baked back into the network, allowing for further processing or output.
Attribute copying
An attribute copy node, named attribcopy1, is used to transfer the “background mask” detail attribute to the relevant points in the point cloud. This ensures that the attribute is consistently applied throughout the data, preparing it for the final baking process.
Final output
The output of this network is an image baked with a background mask inside the .prz file. This can be used in subsequent compositing or rendering processes to isolate or replace the background with alternate imagery or effects.
Usage instructions
Connect the prz_loader nodes for the left eye to the prz_background_mask node.
Ensure that the “background mask” detail attribute is correctly configured in the prz_background_mask node.
Use the attribute copy node to apply the “background mask” attribute to the entire dataset.
Connect the output to the prz_writer node to bake the mask into the final image or to proceed with further adjustments.
Note
This node is particularly useful in virtual production and compositing workflows where background elements need to be selectively adjusted or replaced.
Using Cryptomattes
In compositing, a Cryptomatte is a powerful system that generates automatic, pixel-perfect ID mattes (masks) for objects and materials directly from your 3D renders, allowing you to easily select and manipulate specific elements in post-production without re-rendering, even with motion blur, transparency, and depth of field. It works by encoding object/material IDs into special image layers, which compositing software can then interpret to create masks by simply selecting an element in the render.
Let’s start by applying a Cryptomatte as a mask. We can use a Cryptomatte by creating an Apply Cryptomatte node inside our PresenZ workspace, by hitting Tab in the node graph and typing Crypto, as shown in the image below.
This then allows us to isolate a Cryptomatte to use as a mask. Simply use the cog and select your asset. In this case, we will isolate the ballShape.
You can also find a list of cryptomattes in the Geomatry_spreadsheet under cryptomanifest
Now all you need to do is use this mask/Cryptomatte to edit the scene. In this case, I am editing the colour of our ball. Now I want it purple.
Now all you need to do is use this mask/Cryptomatte to edit the scene. In this case, I am editing the colour of our ball. Now I want it purple.
We can use this method to update specific objects or assets in the scene without affecting anything else. It doesn’t require tracking data or animation like a mask, as it is a pass in the render coming from the object.
PresenZ Apply Cryptomatte
The Apply Cryptomatte HDA node is used within a Houdini network to generate a mask attribute using Cryptomatte AOVs.
Parameters
Type: Specifies the type of Cryptomatte (object, material, or asset).
Mask Name: Defines the group name where the points corresponding to the hashes will be added.
Hashes: A list of hashes to search for. These hashes can be found in the corresponding .json files located next to the przRender files.
Notes
There are a series of corresponding AOVs named “_mask0” and “_mask1” that contain the percentage of ownership for the hash. A value of 1 indicates exclusive ownership, meaning no other hashes correspond to that point.
These AOVs should be used in cases where colour correction is applied, allowing you to multiply the effect of the correction by the ownership value. Unfortunately, Houdini groups do not support weighting, so implementing this feature is left to the user’s discretion.
PresenZ visualizer node (prz_visualizer)
The PresenZ Visualizer node, prz_visualizer, is a geometry node in Houdini that transforms point cloud data into geometry representations. This conversion aims to closely mimic the output that will be displayed by the PresenZ Player, providing a more realistic preview of the final render.
Functionality
The PresenZ Visualizer node serves as a visualisation tool, converting point cloud data into geometry. This is particularly useful for previewing how the final render will appear in the PresenZ Player.
Usage considerations
Editing: The output from the PresenZ Visualizer node is not intended for editing. Any modifications should be made prior to this visualisation stage.
Shading effects: Shading applied to the geometry can alter the perceived colour of the scene. This may result in a visual difference between the visualiser output and the original point cloud data.
This node is useful for a more accurate preview during development, but users should be aware of its limitations around editing and colour fidelity.
That will about cover the basics, in the advanced section we will try to show how we use all of these nodes in unisan. Showing how we can take a basic and simple setup into a fully working production model for a more complex project.
Last updated
Was this helpful?