Raytracing shaders in RenderGraph Compute

Unity Engine
, , ,
1

I see that RenderGraph computebuffer has wrappers for DispatchRays, and SetRaytracingAccelerationStructure etc. However, there doesn’t seem to be any examples of its usage, and there also doesn’t seem to be a wrapper for SetRayTracingShaderPass.

First I tried dispatching rays after setting the render textures directly to camera resources. This didn’t work of course and I get a message saying only raster passes can be merged.

So I tried writing to render textures, and then creating an extra raster pass to blit them with the camera color. Didn’t seem to work either. Still getting the same message.

Here is my code. Any examples of using raytracing with Render Graph would be much appreciated:

using UnityEngine.Rendering.RenderGraphModule;
using UnityEngine.Rendering;
using UnityEngine.Rendering.Universal;

public class VoxelRenderPass : ScriptableRenderPass
{
    public VoxelRenderFeature _renderFeature;
    public RayTracingAccelerationStructure TLAS;
    private RTHandle depthTex;

    private const string VoxelColorTex = "_VoxelRTColor";
    private const string VoxelDepthTex = "_VoxelRTDepth";

    private RenderTextureDescriptor _voxelRTDescriptor;

    public VoxelRenderPass(VoxelRenderFeature voxelRenderFeature)
        {
        _renderFeature = voxelRenderFeature;

        _voxelRTDescriptor = new RenderTextureDescriptor(
    Screen.width,
    Screen.height,
    RenderTextureFormat.Default,
    depthBufferBits: 0);

        }

    private class ComputePassData {

        public TextureHandle DepthTex;
        public TextureHandle ColorTex;

        }

    private class BlitPassData
        {

        public TextureHandle ColorTex;

        }

    public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
        {
        UniversalResourceData resourceData = frameData.Get<UniversalResourceData>();

        if (resourceData.isActiveTargetBackBuffer)
            return;

        UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();

        _voxelRTDescriptor.width = cameraData.cameraTargetDescriptor.width;
        _voxelRTDescriptor.height = cameraData.cameraTargetDescriptor.height;
        _voxelRTDescriptor.msaaSamples = cameraData.cameraTargetDescriptor.msaaSamples;
        _voxelRTDescriptor.enableRandomWrite = true;

        var voxelRTcolor = UniversalRenderer.CreateRenderGraphTexture(
    renderGraph,
    _voxelRTDescriptor,
    VoxelColorTex,
    clear: false);
        var voxelRTdepth = UniversalRenderer.CreateRenderGraphTexture(
            renderGraph,
            _voxelRTDescriptor,
            VoxelDepthTex,
            clear: false);

        using (var builder = renderGraph.AddComputePass<ComputePassData>("Dispatch Raycasts", out var passData))
            {
            builder.AllowPassCulling(false);
            passData.DepthTex = voxelRTdepth;
            passData.ColorTex = voxelRTcolor;
            builder.UseTexture(passData.DepthTex, AccessFlags.Write);
            builder.UseTexture(passData.ColorTex, AccessFlags.Write);

            builder.SetRenderFunc((ComputePassData data, ComputeGraphContext context) =>
    ExecutePass(data, context));

            }

        using (var builder = renderGraph.AddRasterRenderPass<BlitPassData>("Blit Textures",
           out var passData))
            {
            builder.AllowPassCulling(false);
            passData.ColorTex = voxelRTcolor;

            builder.UseTexture(passData.ColorTex, AccessFlags.Read);
            builder.SetRenderAttachment(resourceData.cameraColor, 0, AccessFlags.Write);

            builder.SetRenderFunc((BlitPassData data, RasterGraphContext context) =>
                ExecuteBlit(data, context));
            }



        }

    private void ExecutePass(ComputePassData data, ComputeGraphContext context)
        {
        var command = context.cmd;
        command.SetRayTracingTextureParam(_renderFeature.RaytracingShader, "RenderTarget", data.ColorTex);
        command.SetRayTracingTextureParam(_renderFeature.RaytracingShader, "depthTarget", data.DepthTex);
/*        command.SetRayTracingShaderPass(resources.defaultRayTraceShader.Value, "MyRaytracingPass");*/
        command.SetRayTracingAccelerationStructure(_renderFeature.RaytracingShader, "_RaytracingAccelerationStructure", TLAS);
        var projection = GL.GetGPUProjectionMatrix(Camera.main.projectionMatrix, false);
        var inverseProjection = projection.inverse;

        command.SetRayTracingMatrixParam(_renderFeature.RaytracingShader, "_InverseProjection", inverseProjection);
        command.SetRayTracingMatrixParam(_renderFeature.RaytracingShader, "_ProjectionMatrix", projection);
        command.SetRayTracingMatrixParam(_renderFeature.RaytracingShader, "_CameraToWorld", Camera.main.cameraToWorldMatrix);
        command.SetRayTracingVectorParam(_renderFeature.RaytracingShader, "_WorldSpaceCameraPos", Camera.main.transform.position);
        command.DispatchRays(_renderFeature.RaytracingShader, "MyRayGenerationShader",
            (uint)1920, (uint)1080, 1u, Camera.main);

        /*        Graphics.ExecuteCommandBuffer(command);*/

        }

    private static void ExecuteBlit(BlitPassData data, RasterGraphContext context)
        {
        Blitter.BlitTexture(context.cmd, data.ColorTex, new Vector4(1f, 1f, 0f, 0f), 0, false);
        }


    }

The raytracing shader works perfectly find when I use Graphics.ExecuteCommand and render to a regular render texture. But I’d like to draw to the depth buffer/color directly to z blend it with my rasterized objects.

2

Maybe this will help: Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/Raytracing/HDRenderPipeline.RaytracingAmbientOcclusion.cs

This is the RTAO algorithm written by HDRP. You can start with RenderRTAO function.