Add new task pages and fixes to render graph system documentation

Update render graph documentation with common tasks we missed, and fixes.

Additions/changes are:
- Add framebuffer fetch page
- Add basic compute shader pages
- Add relevant links to package samples
- Fix issues raised by @adrien-moulin 
- Fix issues with render graph viewer reference raised by @arttu-peltonen 
- Fix other issues

We've moved blit helper documentation to a separate ticket (https://jira.unity3d.com/browse/DOCG-5682) while we wait for a fix.

Jira ticket: https://jira.unity3d.com/browse/DOCG-5214

Author: markg-unity

Packages/com.unity.render-pipelines.universal/Documentation~/TableOfContents.md

@@ -177,13 +177,17 @@
       * [Introduction to the render graph system](render-graph-introduction.md)
       * [Write a render pass using the render graph system](render-graph-write-render-pass.md)
       * [Use textures](working-with-textures.md)
-        * [Create a render graph system texture](render-graph-create-a-texture.md)
+        * [Create a texture in the render graph system](render-graph-create-a-texture.md)
         * [Import a texture into the render graph system](render-graph-import-a-texture.md)
         * [Access a texture in a custom render pass](render-graph-read-write-texture.md)
         * [Transfer a texture between render passes](render-graph-pass-textures-between-passes.md)
         * [URP blit best practices](customize/blit-overview.md)
-      * [Draw objects in a render pass](render-graph-draw-objects-in-a-pass.md)
       * [Use frame data](accessing-frame-data.md)
+      * [Get the current framebuffer with framebuffer fetch](render-graph-framebuffer-fetch.md)
+      * [Draw objects in a render pass](render-graph-draw-objects-in-a-pass.md)
+      * [Use a compute shader in a render pass](render-graph-compute-shader.md)
+        * [Run a compute shader in a render pass](render-graph-compute-shader-run.md)
+        * [Create input data for a compute shader](render-graph-compute-shader-input.md)
       * [Analyze a render graph](render-graph-view.md)
       * [Use Compatibility Mode APIs in render graph render passes](render-graph-unsafe-pass.md)
       * [Render Graph Viewer window reference](render-graph-viewer-reference.md)

Packages/com.unity.render-pipelines.universal/Documentation~/accessing-frame-data.md

@@ -4,9 +4,7 @@ You can fetch the textures the Universal Render Pipeline (URP) creates for the c
 
 These textures are called frame data, resource data, or frame resources.
 
-Some textures might not exist in the frame data, depending on which injection point you use to insert your custom render pass into the URP frame rendering loop. Refer to the following for information about which textures exist when:
-
-- [Injection points reference](customize/custom-pass-injection-points.md)
+Some textures might not exist in the frame data, depending on which injection point you use to insert your custom render pass into the URP frame rendering loop. For more information about which textures exist when, refer to [Injection points reference](customize/custom-pass-injection-points.md).
 
 ## Get frame data
 
@@ -21,7 +19,7 @@ Follow these steps to get a handle to a texture in the frame data:
     ```csharp
     public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameContext)
     {
-        using (var builder = renderGraph.AddPass<PassData>("Get frame data", out var passData))
+        using (var builder = renderGraph.AddRasterRenderPass<PassData>("Get frame data", out var passData))
         {
             UniversalResourceData frameData = frameContext.Get<UniversalResourceData>();
         }
@@ -36,7 +34,9 @@ Follow these steps to get a handle to a texture in the frame data:
     TextureHandle activeColorTexture = frameData.activeColorTexture;
     ```
 
-You can then read from and write to the texture. Refer to [Use a texture in a render pass](render-graph-read-write-texture.md) for more information.
+You can then read from and write to the texture. Refer to [Use a texture in a render pass](render-graph-read-write-texture.md).
+
+The texture handle is valid only for the current render graph in the current frame.
 
 You can use the [ConfigureInput](xref:UnityEngine.Rendering.Universal.ScriptableRenderPass.ConfigureInput(UnityEngine.Rendering.Universal.ScriptableRenderPassInput)) API to make sure URP generates the texture you need in the frame data.
 
@@ -57,23 +57,21 @@ You can fetch the following textures from the frame data.
 | `cameraDepthTexture` | A copy of the depth texture, if you enable **Depth Priming Mode** in the [renderer](urp-universal-renderer.md) or **Depth Texture** in the active [URP Asset](universalrp-asset.md). | `CopyDepth` or `DepthPrepass` |
 | `cameraNormalsTexture` | The scene normals texture. Contains the scene depth for objects with shaders that have a `DepthNormals` pass. | `DepthNormals` prepass |
 | `cameraOpaqueTexture` | A texture with the opaque objects in the scene, if you enable **Opaque Texture** in the [URP Asset](universalrp-asset.md). | `CopyColor` |
-| `dBuffer` | The Decals texture. Refer to [DBuffer](renderer-feature-decal.md#dbuffer) for more information. | `Decals` |
-| `dBufferDepth` | The Decals depth texture. Refer to [DBuffer](renderer-feature-decal.md#dbuffer) for more information. | `Decals` |
+| `dBuffer` | The Decals texture. For more information about the decals texture, refer to [DBuffer](renderer-feature-decal.md#dbuffer). | `Decals` |
+| `dBufferDepth` | The Decals depth texture. Refer to [DBuffer](renderer-feature-decal.md#dbuffer). | `Decals` |
 | `debugScreenTexture` | If you enable [HDR Debug Views](post-processing/hdr-output.md#hdr-debug-views), URP writes the output of [post-processing](integration-with-post-processing.md) to this texture instead of `backBufferColor`. | `uberPost` and `finalPost` |
-| `gBuffer` | The G-buffer textures. Refer to [G-buffer](rendering/deferred-rendering-path.md#g-buffer-layout) for more information. | `GBuffer`  |
+| `gBuffer` | The G-buffer textures. Refer to [G-buffer](rendering/deferred-rendering-path.md#g-buffer-layout). | `GBuffer`  |
 | `internalColorLut` | The internal look-up textures (LUT) texture. | `InternalLut` |
 | `mainShadowsTexture ` | The main shadow map. | `ShadowCaster` |
-| `motionVectorColor` | The motion vectors color texture. Refer to [motion vectors](features/motion-vectors.md) for more information. | `Camera Motion Vectors` and `MotionVectors` |
-| `motionVectorDepth` | The motion vectors depth texture. Refer to [motion vectors](features/motion-vectors.md) for more information. | `Camera Motion Vectors` and `MotionVectors` |
+| `motionVectorColor` | The motion vectors color texture. Refer to [motion vectors](features/motion-vectors.md). | `Camera Motion Vectors` and `MotionVectors` |
+| `motionVectorDepth` | The motion vectors depth texture. Refer to [motion vectors](features/motion-vectors.md). | `Camera Motion Vectors` and `MotionVectors` |
 | `overlayUITexture` | The overlay UI texture. | `DrawScreenSpaceUI` |
 | `renderingLayersTexture` | The Rendering Layers texture. Refer to [Rendering layers](features/rendering-layers.md) | `DrawOpaques` or the `DepthNormals` prepass, depending on your settings. |
-| `ssaoTexture` | The Screen Space Ambient Occlusion (SSAO) texture. Refer to [Ambient occlusion](post-processing-ssao.md) for more information. | `SSAO` |
+| `ssaoTexture` | The Screen Space Ambient Occlusion (SSAO) texture. Refer to [Ambient occlusion](post-processing-ssao.md). | `SSAO` |
 
 ## Example
 
-Refer to the following for examples of custom render passes that use the frame data:
-
-- The render graph system samples in the [URP package samples](package-sample-urp-package-samples.md)
+For a full example, refer to the example called **TextureReference w. FrameData** in the [Universal Render Pipeline (URP) package samples](package-samples.md).
 
 ## Additional resources
 

Packages/com.unity.render-pipelines.universal/Documentation~/package-samples.md

@@ -27,4 +27,5 @@ To open a package sample:
 
 The package samples that URP provides are:
 
-* URP Package Samples: A collection of example shaders, C# scripts, and other assets you can build upon or use in your application. For more information, refer to [URP Package Samples](package-sample-urp-package-samples.md).
+* URP Package Samples: A collection of example shaders, C# scripts, and other assets you can build upon or use in your application. Refer to [URP Package Samples](package-sample-urp-package-samples.md).
+* URP RenderGraph Samples: A collection of example [Scriptable Renderer Features](renderer-features/scriptable-renderer-features/scriptable-renderer-features-landing.md) demonstrating how to use the render graph system. For more information about the render graph samples, refer to [Render graph system](render-graph.md).

Packages/com.unity.render-pipelines.universal/Documentation~/render-graph-compute-shader-input.md

@@ -0,0 +1,66 @@
+
+## Create input data for a compute shader
+
+When you [run a compute shader in a render pass](render-graph-compute-shader-run.md), you can allocate a buffer to provide input data for the compute shader.
+
+Follow these steps:
+
+1. Create a graphics buffer, then add a handle to it in your pass data. For example:
+
+    ```csharp
+    // Declare an input buffer
+    public GraphicsBuffer inputBuffer;
+
+    // Add a handle to the input buffer in your pass data
+    class PassData
+    {
+        ...
+        public BufferHandle input;
+    }
+
+    // Create the buffer in the render pass constructor
+    public ComputePass(ComputeShader computeShader)
+    {
+        // Create the input buffer as a structured buffer
+        // Create the buffer with a length of 5 integers, so you can input 5 values.
+        inputBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured, 5, sizeof(int));
+    }
+    ```
+
+2. Set the data in the buffer. For example:
+
+    ```csharp
+    var inputValues = new List<int> { 1, 2, 3, 4, 5 };
+    inputBuffer.SetData(inputValues);
+    ```
+
+3. Use the `ImportBuffer` render graph API to convert the buffer to a handle the render graph system can use, then set the `BufferHandle` field in the pass data. For example:
+
+    ```csharp
+    BufferHandle inputHandleRG = renderGraph.ImportBuffer(inputBuffer);
+    passData.input = inputHandleRG;
+    ```
+    
+4. Use the `UseBuffer` method to set the buffer as a readable buffer in the render graph system. For example:
+
+    ```csharp
+    builder.UseBuffer(passData.input, AccessFlags.Read);
+    ```
+5. In your `SetRenderFunc` method, use the [`SetComputeBufferParam`](https://docs.unity3d.com/ScriptReference/Rendering.CommandBuffer.SetComputeBufferParam.html) API to attach the buffer to the compute shader. For example:
+
+    ```csharp
+    // The first parameter is the compute shader
+    // The second parameter is the function that uses the buffer
+    // The third parameter is the RWStructuredBuffer input variable to attach the buffer to
+    // The fourth parameter is the handle to the input buffer
+    context.cmd.SetComputeBufferParam(passData.computeShader, passData.computeShader.FindKernel("Main"), "inputData", passData.input);
+    ```
+
+## Example 
+
+For a full example, refer to the example called **Compute** in the [Universal Render Pipeline (URP) package samples](package-samples.md).
+
+## Additional resources
+
+- [Compute shaders](https://docs.unity3d.com/6000.0/Documentation/Manual/class-ComputeShader.html)
+- [Writing shaders](https://docs.unity3d.com/6000.0/Documentation/Manual/shader-writing.html)

Packages/com.unity.render-pipelines.universal/Documentation~/render-graph-compute-shader-run.md

@@ -0,0 +1,142 @@
+# Run a compute shader in a render pass
+
+To create a render pass that runs a compute shader, do the following:
+
+1. Set up the render pass to use a compute shader.
+2. Add an output buffer.
+3. Pass in and execute the compute shader.
+4. Get the output data from the output buffer.
+
+To check if a platform supports compute shaders, use the [`SystemInfo.supportsComputeShaders`](https://docs.unity3d.com/ScriptReference/SystemInfo-supportsComputeShaders.html) API 
+
+## Set up the render pass to use a compute shader
+
+When you [create a `ScriptableRenderPass`](render-graph-write-render-pass.md), do the following:
+
+1. Use `AddComputePass` instead of `AddRasterRenderPass`.
+2. Use `ComputeGraphContext` instead of `RasterGraphContext`.
+
+For example:
+
+```csharp
+class ComputePass : ScriptableRenderPass
+{
+    ...
+
+    public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer contextData)
+    {
+        ...
+        // Use AddComputePass instead of AddRasterRenderPass.
+        using (var builder = renderGraph.AddComputePass("MyComputePass", out PassData data))
+        {
+            ...
+
+            // Use ComputeGraphContext instead of RasterGraphContext.
+            builder.SetRenderFunc((PassData data, ComputeGraphContext context) => ExecutePass(data, context));
+
+            ...
+        }
+    }
+}
+
+```
+
+## Add an output buffer
+
+To create a buffer the compute shader outputs to, follow these steps:
+
+1. Create a graphics buffer, then add a handle to it in your pass data.
+
+    ```csharp
+    // Declare an output buffer
+    public GraphicsBuffer outputBuffer;
+
+    // Add a handle to the output buffer in your pass data
+    class PassData
+    {
+        public BufferHandle output;
+    }
+
+    // Create the buffer in the render pass constructor
+    public ComputePass(ComputeShader computeShader)
+    {
+        // Create the output buffer as a structured buffer
+        // Create the buffer with a length of 5 integers, so the compute shader can output 5 values.
+        outputBuffer = new GraphicsBuffer(GraphicsBuffer.Target.Structured, 5, sizeof(int));
+    }
+    ```
+
+2. Use the `ImportBuffer` render graph API to convert the buffer to a handle the render graph system can use, then set the `BufferHandle` field in the pass data. For example:
+
+    ```csharp
+    BufferHandle outputHandleRG = renderGraph.ImportBuffer(outputBuffer);
+    passData.output = outputHandleRG;
+    ```
+
+
+3. Use the `UseBuffer` method to set the buffer as a writeable buffer in the render graph system.
+
+    ```csharp
+    builder.UseBuffer(passData.output, AccessFlags.Write);
+    ```
+
+## Pass in and execute the compute shader
+
+Follow these steps:
+
+1. Pass the compute shader to the render pass. For example, in a `ScriptableRendererFeature` class, expose a `ComputeShader` property, then pass the compute shader into the render pass class.
+
+2. Add a `ComputeShader` field to your pass data, and set it to the compute shader. For example:
+
+    ```csharp
+    // Add a `ComputeShader` field to your pass data
+    class PassData
+    {
+        ...
+        public ComputeShader computeShader;
+    }
+
+    // Set the `ComputeShader` field to the compute shader
+    passData.computeShader = yourComputeShader;
+    ```
+
+3. In your `SetRenderFunc` method, use the [`SetComputeBufferParam`](https://docs.unity3d.com/ScriptReference/Rendering.CommandBuffer.SetComputeBufferParam.html) API to attach the buffer to the compute shader. For example:
+
+    ```csharp
+    // The first parameter is the compute shader
+    // The second parameter is the function that uses the buffer
+    // The third parameter is the StructuredBuffer output variable to attach the buffer to
+    // The fourth parameter is the handle to the output buffer
+    context.cmd.SetComputeBufferParam(passData.computeShader, passData.computeShader.FindKernel("Main"), "outputData", passData.output);
+    ```
+
+4. Use the [`DispatchCompute`](https://docs.unity3d.com/ScriptReference/Rendering.CommandBuffer.DispatchCompute.html) API to execute the compute shader.
+
+    ```csharp
+    context.cmd.DispatchCompute(passData.computeShader, passData.computeShader.FindKernel("CSMain"), 1, 1, 1);
+    ```
+
+## Get the output data from the output buffer
+
+To fetch the data from the output buffer, use the [`GraphicsBuffer.GetData`](https://docs.unity3d.com/ScriptReference/GraphicsBuffer.GetData.html) API.
+
+You can only fetch the data after the render pass executes and the compute shader finishes running.
+
+For example:
+
+```csharp
+// Create an array to store the output data
+outputData = new int[5];
+
+// Copy the output data from the output buffer to the array
+outputBuffer.GetData(outputData);
+```
+
+## Example
+
+For a full example, refer to the example called **Compute** in the [render graph system URP package samples](package-samples.md).
+
+## Additional resources
+
+- [Compute shaders](https://docs.unity3d.com/6000.0/Documentation/Manual/class-ComputeShader.html)
+- [Writing shaders](https://docs.unity3d.com/6000.0/Documentation/Manual/shader-writing.html)

Packages/com.unity.render-pipelines.universal/Documentation~/render-graph-compute-shader.md

@@ -0,0 +1,13 @@
+# Use a compute shader in a render pass
+
+To create a render pass that runs a compute shader, use the render graph system.
+
+| Page | Description |
+|-|-|
+| [Run a compute shader in a render pass](render-graph-compute-shader-run.md) | Create a render pass that allocates a buffer and runs a compute shader to output data into the buffer. |
+| [Create input data for a compute shader](render-graph-compute-shader-input.md) | Allocate a buffer that provides input data for a compute shader in a render pass. |
+
+## Additional resources
+
+- [Compute shaders](https://docs.unity3d.com/6000.0/Documentation/Manual/class-ComputeShader.html)
+- [Writing shaders](https://docs.unity3d.com/6000.0/Documentation/Manual/shader-writing.html)

Packages/com.unity.render-pipelines.universal/Documentation~/render-graph-create-a-texture.md

@@ -1,10 +1,10 @@
-# Create a render graph system texture
+# Create a texture in the render graph system
 
-You can create a render graph texture in a custom render pass. You can then [read from or write to the texture](render-graph-read-write-texture.md).
+To create a texture in the render graph system, use the `UniversalRenderer.CreateRenderGraphTexture` API.
 
-When the Universal Render Pipeline (URP) optimizes the render graph, it might not create a texture if the final frame doesn't use the texture, to reduce the memory and bandwidth the render passes use. Refer to [Introduction to the render graph system](render-graph-introduction.md) for more information.
+When the Universal Render Pipeline (URP) optimizes the render graph, it might not create a texture if the final frame doesn't use the texture, to reduce the memory and bandwidth the render passes use. For more information about how URP optimizes render graphs, refer to [Introduction to the render graph system](render-graph-introduction.md).
 
-If you need to use a texture in multiple frames or on multiple cameras, for example a texture asset you imported in your project, refer to [Import a texture into the render graph system](render-graph-import-a-texture.md).
+For more information about using a texture in multiple frames or on multiple cameras, for example a texture asset you imported in your project, refer to [Import a texture into the render graph system](render-graph-import-a-texture.md).
 
 ## Create a texture
 
@@ -28,7 +28,7 @@ The render graph system manages the lifetime of textures you create with `Create
 
 ### Example
 
-The following Scriptable Renderer Feature contains an example render pass that creates a texture and clears it to yellow. Refer to [Inject a pass using a Scriptable Renderer Feature](renderer-features/scriptable-renderer-features/inject-a-pass-using-a-scriptable-renderer-feature.md#add-renderer-feature-to-asset) for instructions on how to add the render pass to a project.
+The following Scriptable Renderer Feature contains an example render pass that creates a texture and clears it to yellow. For more information about adding the render pass to the render pipeline, refer to [Inject a pass using a Scriptable Renderer Feature](renderer-features/scriptable-renderer-features/inject-a-pass-using-a-scriptable-renderer-feature.md#add-renderer-feature-to-asset).
 
 Use the [Frame Debugger](https://docs.unity3d.com/2023.3/Documentation/Manual/frame-debugger-window.html) to check the texture the render pass adds.
 
@@ -89,6 +89,8 @@ public class CreateYellowTextureFeature : ScriptableRendererFeature
 }
 ```
 
+For another example, refer to the example called **OutputTexture** in the [Universal Render Pipeline (URP) package samples](package-samples.md).
+
 ## Additional resources
 
 * [Import a texture into the render graph system](render-graph-import-a-texture.md)