Migrating to Render Graph: Understanding the Render Graph Samples - Part 2

Added: 2026-05-05

[00:00:04]Welcome back to part two. Let's begin with blit with frame data. Blit with frame data shows an example of how to use the same texture in different passes.

[00:00:14]A possible use case would be if you wanted to do before and after effect with two textures side by [music] side.

[00:00:19]To do this, you could capture the before texture in an initial custom pass [music] and store the texture in a frame data instance. This is passed as an instance of the context container class, [music] a type of dictionary, to the record render graph method. Subsequent passes do the post-processing and then with a further custom pass, you can fetch the before texture back [music] from the frame data and have the pass draw the current camera color and the before texture side by side.

[00:00:45]Take a look at the file blit render feature from the folder URP render graph samples blit with frame data. [music] The key class is blit data, which will be added to the frame data parameter of the record render graph method.

[00:01:01]For each pass, it extends context item.

[00:01:04]The class creates two texture handles, texture handle front and texture handle back.

[00:01:10]The blit data uses the property texture to select between these two textures.

[00:01:15]The class also includes three record methods, one for each pass.

[00:01:20]This file contains three passes. One, blit start render pass, used to initialize the blit data class.

[00:01:27]Two, blit render pass, used to blit using a list of materials.

[00:01:32]And three, blit end render pass, used to restore from the texture stored in the first pass.

[00:01:38]Notice that for the blit and blit end passes, the record render graph method accesses the blit data instance created in the blit start pass from the frame data parameter using the get method.

[00:01:48]Then each pass uses a custom record method found in the blit data class.

[00:01:53]The key takeaway here is passing data between passes uses a custom class that is created using the create method of the frame data instance.

[00:02:01]Texture reference with frame data.

[00:02:03]Similar to the previous example, texture reference with frame data uses a custom class extended from context item to hold a texture reference to be used by future passes.

[00:02:13]This is useful to avoid additional blit operations, copying back and forth to the camera's color attachment, instead of copying it back after the blit operation.

[00:02:22]We can instead update the reference to the blit destination and use that for future passes.

[00:02:27]The frame data is the preferred way to share resources between passes.

[00:02:30]Previously, it was common to use global textures for this. However, it's better to avoid using global textures where you can because global textures can impact performance.

[00:02:40]Output texture.

[00:02:42]In this sample, a named output texture is created that can be attached by name to a material.

[00:02:47]Take a look at output texture render feature.cs from the URP render graph samples folder.

[00:02:54]This file contains the classes output texture render feature and output texture pass. The render feature contains four properties that can be set in the inspector.

[00:03:04]Pass event is a stage in the pipeline to run the pass.

[00:03:08]Texture name is the name attached to the texture.

[00:03:11]Texture type, the texture input can be color, depth, normal, or motion. And material, the material used for the blit pass.

[00:03:21]The create method of the render feature uses the pass event property to set the render pass event for the scriptable pass.

[00:03:28]To pass the properties from the render feature to the render pass, this sample uses a setup method. Let's take a look.

[00:03:36]The texture type is set using the configure input method of the scriptable render pass.

[00:03:42]Then in the record render graph method, we get the source based on the texture type property.

[00:03:47]The source might be invalid if the pass event is set to before the source is created. So we check and return if this is the case.

[00:03:56]Finally, we configure a blit materials parameters instance.

[00:04:00]The source is set to source, destination to active color texture, material to the material property, and the pass to zero.

[00:04:09]Then we assign the source texture property ID using the texture name.

[00:04:14]This means we can access this texture using a name and a shader graph.

[00:04:18]Take a look at the shader graph blit target texture.

[00:04:22]You'll see it uses a single property input texture, a texture 2D.

[00:04:26]This simple graph uses this as the target input to a sample texture 2D node.

[00:04:32]To use the shader, you need to set the texture name property of the render feature to input texture and the material to blit target texture.

[00:04:41]If you're using the GitHub repo with complete scenes, notice this uses the shader graph output texture, which uses the texture name my texture.

[00:04:50]If you try changing the texture name, you may need to close and reopen the scene for the updates to be used correctly.

[00:04:56]Compute.

[00:04:57]Render graph does not just deal with raster operations. A developer can use compute shaders [music] to handle computations that benefit from the massive parallelism available via the GPU.

[00:05:08]Compute render feature is a simple example to help you understand the code used.

[00:05:13]You'll find it in the URP render graph samples compute [music] folder.

[00:05:18]If you're using the GitHub repo, open scenes compute compute.

[00:05:22]>> [music] >> Take a look at the render graph viewer and check that the pass filter includes compute passes.

[00:05:29]Notice that the compute pass uses [music] the input buffer, green indicating read access, and uses the output buffer, red [music] indicating write access, in the resource list.

[00:05:40]The work done by the compute shader is shown in the console. If you're new to compute shaders, there are three Unity videos available to explain the topic.

[00:05:48]Links to those are in the description.

[00:05:50]Let's take a look at the compute render feature code.

[00:05:53]>> [music] >> Notice the compute pass class includes a compute shader, two buffer handles, and a list. [music] In the constructor, the list is initialized by storing the first 20 integers, 0 to 19.

[00:06:06]The class also includes the definition [music] of two more custom classes.

[00:06:10]Pass data that is used when passing data to the execution function. And read back pass that is [music] used by the pass that reads the result of the compute shader.

[00:06:21]The record render graph method creates two buffers, input [music] and output.

[00:06:27]Then we use the add compute pass method.

[00:06:29]It populates the pass data out parameter, sets the access parameters for the buffers, and sets the render function.

[00:06:36]As discussed, the sample includes a second pass to read the result of the compute shader.

[00:06:41]This uses the add on safe [music] pass method. Here, after assigning the buffer to read, the set render function simply asynchronously gets data from the buffer and dumps it to the console using debug [music] log.

[00:06:54]All the compute shader does is double the input value because this is just a example after all. So with the input data 0, 1, 2 to 19, we see 0 to 4 [music] up to 38 in the console.

[00:07:09]The important takeaway being how to use a render feature to run a compute shader.

[00:07:14]Next up is renderer list. In this sample, we clear the active color texture and then draw geometry filtered by a layer mask via a rendered list handle. The purpose of the sample is to demonstrate combining draw operations into a pass.

[00:07:28]Take a look at renderer list render feature.cs from the URP render graph samples.

[00:07:33]The file contains a custom pass class under renderer feature.

[00:07:37]The renderer feature uses a custom constructor to pass [music] the layer mask to the renderer list pass.

[00:07:44]The renderer list referred to by the sample is a list of objects to render after layer mask filtering, >> [music] >> not the renderer list we see for the active URP asset used to define the settings for the render.

[00:07:56]The key to the sample is the init renderer list method in the renderer list pass. Here we access the model assets via universal rendering data, cameras via universal camera data, and lights via universal light data. We set sort flags to default opaque. We use render queue range opaque and the layer mask property to create a filter settings variable.

[00:08:20]We create a forward only shader tag ID list. This is needed to build a render list. Now we have the properties needed to create an instance of the draw settings class, which gives the necessary properties to generate a render list handle.

[00:08:34]Let's look at the record render graph method.

[00:08:37]Here we get the frame data and we pass it to the init renderer list method.

[00:08:45]We check if this call gave a valid renderer list handle and return if it didn't.

[00:08:50]We tell the builder to use a renderer list, set the render target and [music] depth buffer, and finally set the render function.

[00:09:01]It will use the execute pass method, which is actually quite simple.

[00:09:07]It clears the render target to green and then calls draw renderer list using the renderer [music] list handle as a parameter.

[00:09:14]In the repo, we created a desk layer.

[00:09:17]The desk and the things on the desk are on this layer.

[00:09:20]If we switch to this layer, we see just the desk on a green background.

[00:09:25]This is useful for highlighting something in a scene.

[00:09:28]Culling.

[00:09:29]>> [music] >> The culling sample is very similar to the render list sample. The key difference is demonstrating how to access the culling results from the camera rather than taking them directly from the universal rendering data call result [music] contained in the frame data.

[00:09:42]This will be useful if you want to manually customize the culling results.

[00:09:47]Take a look at culling render pass render feature.cs from the URP render graph samples culling folder. Notice the init renderer list method includes a call parameter missing in the render list version.

[00:10:01]In it, render list is called from the record render graph method.

[00:10:04]To create the cull results, we first get the cull context data from the frame data. Then we call the camera method try get [music] calling parameters. Once we have the calling parameters and the cull context data, [music] we can get the calling results by passing the calling parameters to the cull method of the cull context data instance.

[00:10:23]Unsafe [music] pass.

[00:10:25]This sample shows how to set up a blit when source and target have different dimensions. This means a raster render pass cannot be used and an unsafe pass is used instead. An unsafe pass, as we learned earlier, cannot be merged and so should only be used when essential. In some cases, using an unsafe pass does make sense. [music] For example, in this sample, we know that the set of adjacent passes are not mergeable because of the size differences. So, we can optimize the render graph compile time on top of simplifying the multiple passes setup.

[00:10:55]If we review the record render graph method, you can see three textures are created. The first matches the size of the active color texture. The second halves the size and the third halves it again.

[00:11:06]The render function uses blit texture, which handles the difference in size between the source and the destination of the blit. We can see the unsafe pass includes a custom pass data class, which has four texture handles.

[00:11:19]The record render graph adds an unsafe pass with pass data.

[00:11:23]We set the pass data as the current active color texture.

[00:11:27]Create three textures, each the half size of the previous.

[00:11:30]We set access for each texture.

[00:11:33]In the render function, we get a command buffer and set up four blits.

[00:11:40]And we can see the result of the blits using the frame debugger.

[00:11:44]MRT or multiple render targets.

[00:11:47]This sample demonstrates using multiple render targets with a render graph and URP. This will be useful if a pass needs to output more than a single RGBA texture to output various buffers in one pass.

[00:11:58]The MRT renderer feature class includes an array of three render textures.

[00:12:03]>> [music] >> The MRT pass includes properties, RTs, an array of three RT handles, and an array of three render target infos, RT infos. The setup method includes a reference to the MRT renderer feature render texture properties as parameter three.

[00:12:20]In the method, we check if each of the MRT pass properties, RTs, are empty or do not match the MRT renderer feature render texture for the index.

[00:12:30]If this is the case, we optionally release an existing reference and allocate the handle. We also copy the descriptor details.

[00:12:38]In the record render graph method, we create an array of texture handles and assign these using the RTs and RT infos created in the setup method. We set the render attachment for these handles.

[00:12:50]In the render function, we use draw procedural to render the full screen triangle with a material property. You could use this approach to output to color, normals, and depth buffers in a single pass. Useful for deferred rendering or creating custom lighting buffers. G-buffer visualization. This sample demonstrates accessing G-buffer components inside a pass when they are not global. So, you can inspect or use G-buffer data locally in a pass. This sample applies to a deferred rendering pipeline where lighting is delayed until after surfaces are drawn. Storing surface data in a G-buffer.

[00:13:26]This makes handling many lights efficient but has tradeoffs with memory and transparency.

[00:13:31]Visualizing can be useful for debugging.

[00:13:34]>> [music] >> Again, in the render graph samples folder, take a look at the file G-buffer visualization renderer feature.

[00:13:41]First, we store an array of integer values, which are the property IDs of each G-buffer.

[00:13:47]In the record render graph method, we set use texture for each G-buffer. If you take a look at the render graph viewer, you'll see the visualized G-buffer components pass as G-buffer zero through to G-buffer four with read access.

[00:14:02]G-buffer three is skipped, so it doesn't appear in the resources for the path.

[00:14:08]In the render graph function for each G-buffer, we set the texture, then use draw procedural to draw the buffer.

[00:14:15]This uses a custom material.

[00:14:18]Let's take a look at the shader.

[00:14:20]>> [music] >> You'll find G-buffer visualization shader sample.shader in the same folder as the render feature.

[00:14:26]It's set to use G-buffer two, the normals buffer.

[00:14:30]This is a super simple shader. The vertex shader gets the transform position and UV for the vertex.

[00:14:37]And the fragment shader uses the interpolated UV values in the triangle being rendered to sample the buffer. The key takeaway of this sample is how to request access to G-buffer textures when they're not set as global shader properties.

[00:14:50]Global G-buffers. As an alternative to the previous example, global G-buffers declares G-buffer textures as global resources in the render graph so that subsequent passes can access them.

[00:15:02]Although this sample itself doesn't make any use of them. Take a look at global G-buffers renderer feature.cs.

[00:15:09]As in the previous sample, in the global G-buffers render pass, we create an array of IDs of the G-buffers.

[00:15:16]In the record render graph method, we get the G-buffer array from the universal resource data found in the frame data passed to the method.

[00:15:23]The key is the call to set global G-buffer textures.

[00:15:28]In this method, we iterate over the G-buffer array.

[00:15:32]And if a buffer is valid and the index is not three, the G-buffer lighting index value, the I raster render graph builder parameter builder, has a method set global texture after pass.

[00:15:45]This takes a buffer on an ID and sets the G-buffer as global for subsequent passes.

[00:15:51]Some global textures are accessed using specific shader IDs that are internal to URP.

[00:15:57]To use the G-buffer in these places, we need to set the ID to point to the corresponding G-buffer component.

[00:16:03]This applies to G-buffer normal smoothness index and G-buffer renderer layers index.

[00:16:09]If we look at the render graph viewer, you'll see that G-buffers zero to four, excluding the lighting index three, are now all global.

[00:16:17]The key takeaway for this sample is how to promote textures from local scope to global scope in render graph.

[00:16:24]The render graph API has a fairly steep learning curve, but we hope walking through these best practice approaches has equipped you with lots of useful ways to customize the rendered frame.