Custom Render Pass & Custom buffers

Unity Engine
,
1

Hi,

I’m using the new Custom Pass feature in HDRP.
https://github.com/Unity-Technologies/ScriptableRenderPipeline/pull/4317

My goal is to render the all image in Black and White except for certain objects.

I created a FullScreenCustomPass with a shader that output the grayscale version of the image.

Now, I would need to not do that on the objects I tag.

If I can avoid using Layers to do it, that would be great.

I saw that there is a “SampleCustomColor(float2 uv)” in the shader template for FullScreenPass.

It seems that I could write to a custom buffer, which would be perfect for my case.

I could write red on every objects I want to isolate from the grayscale.

But I didn’t find anything on how, where, to write to the custom buffer.

Can someone have an insight on that ?

Or maybe a better solution ?

Thank you

1 Like
2

Hello,

Concerning the HDRP custom pass feature, there are some example of how to implement some effects here: GitHub - alelievr/HDRP-Custom-Passes: A bunch of custom passes made for HDRP, The closest effect to what you want to acheve is the Slight Blur which have a mask faeture to not blur some objects.

You can use the DrawRenderers custom pass to render only objects you want to render in color and store them in the custom buffer allocated by HDRP, once you have that, you can sample the buffer into the fullscreen pass using SampleCustomColor. The only problem is that you can’t filter objects by anything else than the layer.

If you don’t mind writing some C#, you could create a new custom pass type which calls direcrtly the DrawRenderers function (There is an exmaple in the Slight Blur effect I pointed), then you will have access to all the filter available in the API. If you don’t want to use layers, you still have the rendering layer mask that you can setup on the Renderer.

One more thing, it may be a bit early but here is the V1 of the doc for custom passes i’ve been working on: https://github.com/Unity-Technologies/ScriptableRenderPipeline/blob/d216461d36bf99617e865e7d1584a9462cfa7897/com.unity.render-pipelines.high-definition/Documentation~/Custom-Pass.md.

1 Like
3

Thanks Antoine !
I’ll check that ASAP.

4

@antoinel_unity I am trying to copy the result of DrawRenderersCustomPass to the render texture, to use it in the UI. I am trying the following code:

public class RenderToTexturePass : DrawRenderersCustomPass {
        public RenderTexture renderTexture;

        protected override void Execute(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) {
            base.Execute(renderContext, cmd, hdCamera, cullingResult);

            GetCustomBuffers(out RTHandle color, out _);

            cmd.CopyTexture(color, renderTexture);
        }
    }

The render texture and the color buffer formats (r16g16b16a16_SFloat) and width/height are the same . But I am getting the following error in the console:

Graphics.CopyTexture called with mismatching texture types (src=5 dst=2)

What am I missing?

5

In HDRP, when you allocate a render target, you must use the RTHandle system that automatically handles screen resizing, support of VR and reuse between different cameras.
Here is an example of an RTHandle allocation:

RTHandles.Alloc(Vector2.one, TextureXR.slices, dimension: TextureXR.dimension, colorFormat: GraphicsFormat.R16G16B16A16_SFloat, useDynamicScale: true, name: "Buffer Debug Name");

The error you have is due to the dimension of the texture you’re copying, i guess your RenderTexture is a Tex2D but the color buffer of the camera which is a RTHandle is a Tex2DArray (for VR support). Also since RTHandles supports multiple camera of different size, when you do a copy, it may result in unused memory being copied, to avoid that you can do a copy of only the size of the current camera (Note tat you have access to the RThandle size in the property struct).

6

@antoinel_unity I’m trying to understand the custom pass API, basing my work off the examples you have provided. In my case, I need an outline on a single object, not a whole layer, and I can’t put it in a separate layer (because I’m using it for physics logic). You mentioned using the rendering layer mask but I can’t figure out how to actually use this. I tried replacing this block of code

void DrawOutlineMeshes(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) {
    var result = new RendererListDesc(shaderTags, cullingResult, hdCamera.camera) {
        // We need the lighting render configuration to support rendering lit objects
        rendererConfiguration = PerObjectData.LightProbe | PerObjectData.LightProbeProxyVolume | PerObjectData.Lightmaps,
        renderQueueRange = RenderQueueRange.all,
        sortingCriteria = SortingCriteria.BackToFront,
        excludeObjectMotionVectors = false,
        layerMask = outlineLayer,
    };
    CoreUtils.SetRenderTarget(cmd, outlineBuffer, ClearFlag.Color);
    HDUtils.DrawRendererList(renderContext, cmd, RendererList.Create(result));
}

with the following:

void DrawOutlineMeshes(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult) {
    DrawingSettings drawingSettings = new DrawingSettings() {
        perObjectData=(PerObjectData.LightProbe | PerObjectData.LightProbeProxyVolume | PerObjectData.Lightmaps),
        sortingSettings=new SortingSettings(hdCamera.camera),
    };
    FilteringSettings filteringSettings = FilteringSettings.defaultValue;
    CoreUtils.SetRenderTarget(cmd, outlineBuffer, ClearFlag.Color);
    renderContext.ExecuteCommandBuffer(cmd);
    cmd.Clear();
    renderContext.DrawRenderers(cullingResult, ref drawingSettings, ref filteringSettings);
}

and tried all kinds of variations of the filter/drawing settings, but I couldn’t get the outlines to actually show up. I’m not sure if my renderingLayerMask was wrong, since I couldn’t expose this as an enum field in the editor - I ended up opening the debug mode inspector, copying the uint value of the mask of a renderer, and pasting it into my code, to no avail.

My question is: what am I doing wrong here? Or alternatively, is there a way to specify a list of renderers explicitly?

7

@Elynwir and anyone else that comes here I just figured this out

        void DrawOutlineMeshes(ScriptableRenderContext renderContext, CommandBuffer cmd, HDCamera hdCamera, CullingResults cullingResult)
        {
            var result = new RendererListDesc(shaderTags, cullingResult, hdCamera.camera)
            {
                // We need the lighting render configuration to support rendering lit objects
                rendererConfiguration = PerObjectData.LightProbe | PerObjectData.LightProbeProxyVolume | PerObjectData.Lightmaps,
                renderQueueRange = RenderQueueRange.all,
                sortingCriteria = SortingCriteria.BackToFront,
                excludeObjectMotionVectors = false
            };

            CoreUtils.SetRenderTarget(cmd, outlineBuffer, ClearFlag.Color);

            RendererList renderList = RendererList.Create(result);
            renderList.filteringSettings.renderingLayerMask = 1 << 7;

            HDUtils.DrawRendererList(renderContext, cmd, renderList);
        }
1 Like
8

Hi @antoinel_unity , sorry for the necro bump on this thread. I’ve been trying to achieve the same results as the one above in Unity 2021.3, where the RendererList and DrawRendererList have gone through some refactors, so we can use Rendering Layers to filter out objects when applying a custom pass effect.

I’m attaching below a sample script which has 3 different tests:

1- CoreUtils.DrawRendererList with a UnityEngine.Rendering.RendererUtils RendererList.

  • In 2022.2 and above I believe this method works, since Rendering Layers are now exposed into RendererListDesc and you also have RendererListParams as another option. Unfortunately, 2021.3 does not have this functionality yet, so we can only filter out elements by regular Layers.

2- ScriptableRenderContext.DrawRenderers

  • As I believe you’ve mentioned in this thread (and this other thread here ), this seems to be the ideal approach where you have more control over how you’re drawing and filtering objects. Unfortunately, the test below does not render anything, and I couldn’t find a sample online that could get some insights on what I’m missing.

3- CoreUtils.DrawRendererList with a deprecated UnityEngine.Experimental.Rendering RendererList.

  • This method is the only one I’ve managed to get semi-working, and is based on the sample above by punk. The deprecated RendererList contains a FilteringSettings field which you can assign rendering layers and seems to be working fine in the Scene View. Unfortunately, the effect does not show in the Game View.

Is there anything in the second or third approach that we’re doing wrong and we could fix to make the effect work in game? Any insights on this subject would help a ton :).

using System;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.Rendering.RendererUtils; // uncomment this if you're using Test 1 or 2
//using UnityEngine.Experimental.Rendering; // uncomment this if you're using Test 3

public class RenderingLayerExampleCustomPass : CustomPass
{
    // A duplicate of the rendering layer mask enum.
    // I couldn't find a way to access it, so I created a copy. Sorry.
    [Flags]
    public enum RenderingLayerMaskCopy
    {
        None = 0,
        Everything = -1,
        LightLayerDefault = 1 << 0,
        LightLayer1 = 1 << 1,
        LightLayer2 = 1 << 2,
        LightLayer3 = 1 << 3,
        LightLayer4 = 1 << 4,
        LightLayer5 = 1 << 5,
        LightLayer6 = 1 << 6,
        LightLayer7 = 1 << 7,
        DecalLayerDefault = 1 << 8,
        DecalLayer1 = 1 << 9,
        DecalLayer2 = 1 << 10,
        DecalLayer3 = 1 << 11,
        DecalLayer4 = 1 << 12,
        DecalLayer5 = 1 << 13,
        DecalLayer6 = 1 << 14,
        DecalLayer7 = 1 << 15,
        RenderingLayer16 = 1 << 16,
        RenderingLayer17 = 1 << 17,
        RenderingLayer18 = 1 << 18,
        RenderingLayer19 = 1 << 19,
        RenderingLayer20 = 1 << 20,
        RenderingLayer21 = 1 << 21,
        RenderingLayer22 = 1 << 22,
        RenderingLayer23 = 1 << 23,
        RenderingLayer24 = 1 << 24,
        RenderingLayer25 = 1 << 25,
        RenderingLayer26 = 1 << 26,
        RenderingLayer27 = 1 << 27,
        RenderingLayer28 = 1 << 28,
        RenderingLayer29 = 1 << 29,
        RenderingLayer30 = 1 << 30,
        RenderingLayer31 = 1 << 31,
    }

    public bool DrawInSceneView = true;
    public LayerMask LayerMaskFilter;
    public RenderingLayerMaskCopy RenderingLayerMaskFilter;

    [SerializeField]
    private Material _replacementMaterial;

    private ShaderTagId[] _shaderTags;
    private RendererList _rendererList;

    protected override bool executeInSceneView
    {
        get { return DrawInSceneView; }
    }
 
    protected override void Setup (ScriptableRenderContext renderContext, CommandBuffer cmd)
    {
        // Warning: You can use all tags in Test 1 and 3, but Test 2 only allows 1 ShaderTag per DrawRenderers command.
        _shaderTags = new ShaderTagId[5]
        {
            new ShaderTagId("Forward"),
            new ShaderTagId("ForwardOnly"),     // Unlit Shaders
            new ShaderTagId("GBuffer"),         // Lit Shaders
            new ShaderTagId("SRPDefaultUnlit"),
            new ShaderTagId("FirstPass")
        };
    }

    protected override void Execute (CustomPassContext ctx)
    {
        // TEST 1: Regular DrawRendererList from Core Utils.
        // This is successful in creating a custom pass, but there's no place in the current pipeline that allows you to set a Rendering Layer mask in Unity 2021. this is fixed in Unity 2022 though.
        //
        // ----------------------------------------------------------------------------------------------------
        //
        // var result = new RendererListDesc(_shaderTags, ctx.cullingResults, ctx.hdCamera.camera)
        // {
        //     rendererConfiguration = PerObjectData.None,
        //     sortingCriteria = SortingCriteria.BackToFront,
        //     overrideMaterial = _replacementMaterial,
        //     overrideMaterialPassIndex = 0,
        //     renderQueueRange = RenderQueueRange.all,
        //     excludeObjectMotionVectors = false,
        //     layerMask = LayerMaskFilter,
        //     stateBlock = new RenderStateBlock(RenderStateMask.Depth){ depthState = new DepthState(true,  CompareFunction.LessEqual)},
        // };
        //
        // _rendererList = ctx.renderContext.CreateRendererList(result);
        // CoreUtils.DrawRendererList(ctx.renderContext,ctx.cmd, _rendererList);

 
 
        // TEST 2: Lower level call using ScriptableRenderContext.DrawRenderers.
        // This is actually the recommended suggestion by a Unity Engineer in these threads:
        // https://discussions.unity.com/t/761329
        // https://discussions.unity.com/t/783910
        //
        // This requires you to manually setup the drawing settings, filtering settings and render state.
        // The Filtering settings is the most important part of this call, because you can set a Rendering Layer mask in it.
        //
        // ----------------------------------------------------------------------------------------------------
 
        FilteringSettings filteringSettings = FilteringSettings.defaultValue;
        var drawSettings = new DrawingSettings(_shaderTags[1], new SortingSettings(ctx.hdCamera.camera));
 
        drawSettings.perObjectData = PerObjectData.None;
        drawSettings.overrideMaterial = _replacementMaterial;
        drawSettings.overrideMaterialPassIndex = 0;
        filteringSettings.renderQueueRange = RenderQueueRange.all;
        filteringSettings.excludeMotionVectorObjects = false;
        filteringSettings.layerMask = LayerMaskFilter;
        filteringSettings.renderingLayerMask = (uint)RenderingLayerMaskFilter;
        RenderStateBlock stateBlock = new RenderStateBlock(RenderStateMask.Depth)
        {
            depthState = new DepthState(true, CompareFunction.LessEqual)
        };
        ctx.renderContext.DrawRenderers(ctx.cullingResults, ref drawSettings, ref filteringSettings, ref stateBlock);


        // TEST 3: Using a deprecated Renderer List struct that contains a Filtering Settings field.
        // Warning: Uncomment UnityEngine.Experimental.Rendering and comment out UnityEngine.Rendering.RendererUtils as they have conflicting definitions.
        //
        // In recent versions, Unity has moved the RendererList struct away from the RenderPipeline package, and into the internal UnityEngine.Rendering namespace.
        // The previous version is still semi-functional in which you can actually get it to work in scene view, but for some reason I can't get it to show in game view.
        //
        // ----------------------------------------------------------------------------------------------------
        //
        // var result = new RendererListDesc(_shaderTags, ctx.cullingResults, ctx.hdCamera.camera)
        // {
        //      rendererConfiguration = PerObjectData.None,
        //      sortingCriteria = SortingCriteria.BackToFront,
        //      overrideMaterial = _replacementMaterial,
        //      overrideMaterialPassIndex = 0,
        //      renderQueueRange = RenderQueueRange.all,
        //      excludeObjectMotionVectors = false,
        //      stateBlock = new RenderStateBlock(RenderStateMask.Depth){ depthState = new DepthState(true,  CompareFunction.LessEqual)},
        // };
        //
        // _rendererList = RendererList.Create(result);
        //
        // FilteringSettings filteringSettings = FilteringSettings.defaultValue;
        //
        // filteringSettings.renderQueueRange = RenderQueueRange.all;
        // filteringSettings.excludeMotionVectorObjects = false;
        // filteringSettings.renderingLayerMask = (uint)RenderingLayerMaskFilter;
        // filteringSettings.layerMask = LayerMaskFilter;
        // RenderStateBlock stateBlock = new RenderStateBlock(RenderStateMask.Depth)
        // {
        //     depthState = new DepthState(true, CompareFunction.LessEqual)
        // };
        //
        // _rendererList.filteringSettings = filteringSettings;
        // _rendererList.stateBlock = stateBlock;
        //
        // CoreUtils.DrawRendererList(ctx.renderContext, ctx.cmd, _rendererList);
    }
}
9

Hello @Dorodo ,

In your script, you’re using the renderContext.DrawRenderers() function to draw the objects, this method is immediate rather than using the command buffer of the current rendering. This means that your drawRenderers call is actually executed before the rendering of the whole frame (command buffer execution is delayed until it’s added to the scriptable render context).

To fix this, you can force the command buffer to flush before doing your DrawRenderers call like so:

// Append the command list to the context
ctx.renderContext.ExecuteCommandBuffer(ctx.cmd);
// Clear the command buffer to avoid command duplication when it's added in the context later on
ctx.cmd.Clear();

// Here you can use the render context to draw your renderers.
1 Like
10

Hi Antoinel, so sorry for the late response. That did the trick perfectly, thank you so much for the help! :slight_smile:

1 Like
11

can i add a new pass in built-in pipeline ?