Filter on LayerMask - Renderpass / Scriptable Render pass / render feature

Unity Engine
, ,
1

Hi Guys

Looking at this video . I want to leave my game in Full res but only pixelate one layer.

Cause of all the jitter in Pixel perfect cam I am not using it but using Scriptable Render pass.

So I manged to get this working following some other guides and trying to understand it all.

It Work!! But full screen only. Which I wanted but I want to mix the styles.
I Added a LayerMask in PixelizeFeature.cs ( ScriptableRendererFeature ) and pass it to PixelizePass.cs ( ScriptableRenderPass)

But I have no Idea how to apply this Layermask to it. Here is the Code and the Shader. Would love if someone cane help me on this.

PixelizePass.cs

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

public class PixelizePass : ScriptableRenderPass
{
    private PixelizeFeature.CustomPassSettings settings;

    private RenderTargetIdentifier colorBuffer, pixelBuffer;
    private int pixelBufferID = Shader.PropertyToID("_PixelBuffer");

    //private RenderTargetIdentifier pointBuffer;
    //private int pointBufferID = Shader.PropertyToID("_PointBuffer");

    private Material material;
    private int pixelScreenHeight, pixelScreenWidth;

    public PixelizePass(PixelizeFeature.CustomPassSettings settings)
    {
        this.settings = settings;
        this.renderPassEvent = settings.renderPassEvent;
        if (material == null) material = CoreUtils.CreateEngineMaterial("Hidden/Pixelize");
    }

    public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
    {
        colorBuffer = renderingData.cameraData.renderer.cameraColorTarget;
        RenderTextureDescriptor descriptor = renderingData.cameraData.cameraTargetDescriptor;

        //cmd.GetTemporaryRT(pointBufferID, descriptor.width, descriptor.height, 0, FilterMode.Point);
        //pointBuffer = new RenderTargetIdentifier(pointBufferID);

        pixelScreenHeight = settings.screenHeight;
        pixelScreenWidth = (int)(pixelScreenHeight * renderingData.cameraData.camera.aspect + 0.5f);

        material.SetVector("_BlockCount", new Vector2(pixelScreenWidth, pixelScreenHeight));
        material.SetVector("_BlockSize", new Vector2(1.0f / pixelScreenWidth, 1.0f / pixelScreenHeight));
        material.SetVector("_HalfBlockSize", new Vector2(0.5f / pixelScreenWidth, 0.5f / pixelScreenHeight));

        descriptor.height = pixelScreenHeight;
        descriptor.width = pixelScreenWidth;

        cmd.GetTemporaryRT(pixelBufferID, descriptor, FilterMode.Point);
        pixelBuffer = new RenderTargetIdentifier(pixelBufferID);
    }

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        CommandBuffer cmd = CommandBufferPool.Get();
        using (new ProfilingScope(cmd, new ProfilingSampler("Pixelize Pass")))
        {
            // No-shader variant
            //Blit(cmd, colorBuffer, pointBuffer);
            //Blit(cmd, pointBuffer, pixelBuffer);
            //Blit(cmd, pixelBuffer, colorBuffer);

            Blit(cmd, colorBuffer, pixelBuffer, material);
            Blit(cmd, pixelBuffer, colorBuffer);
        }

        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }

    public override void OnCameraCleanup(CommandBuffer cmd)
    {
        if (cmd == null) throw new System.ArgumentNullException("cmd");
        cmd.ReleaseTemporaryRT(pixelBufferID);
        //cmd.ReleaseTemporaryRT(pointBufferID);
    }

}

PixelizeFeature.cs

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

public class PixelizeFeature : ScriptableRendererFeature
{
    [System.Serializable]
    public class CustomPassSettings
    {
        public RenderPassEvent renderPassEvent = RenderPassEvent.BeforeRenderingPostProcessing;
        public int screenHeight = 144;
        public LayerMask LayerMask;
    }
   
        
     


    [SerializeField] private CustomPassSettings settings;
   
    private PixelizePass customPass;

    public override void Create()
    {
       
        customPass = new PixelizePass(settings);
    }
    public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
    {

#if UNITY_EDITOR
        if (renderingData.cameraData.isSceneViewCamera) return;
#endif
        renderer.EnqueuePass(customPass);
    }
}

8454995–1122044–Pixelize.shader (1.79 KB)

2

Is this what you are going to achieve?
8465381--1124393--gif2.gif
I have applied a mask feature - the same I am using in the CrossSection asset for selective outline effect.
The sphere stays on a separate layer with the mask feature applied, and the pixelize shader uses input from the mask texture.

The gif image illustrates the animation of the pixelScreenHeight parameter in the pixelize effect.

4 Likes
3

Wow. That is what I want. But I haven’ found a way to get it working yet.

4

Is there any movement on this? I’m also looking for a way to filter objects in a render pass.

5

To filter objects in a RenderPass, you use the ScriptableRenderContext to call the DrawRenderers command with CullResults, DrawSettings, and FilterSettings parameters inside Execute().

FilterSettings filteringSettings = new FilteringSettings(RenderQueueRange.all, passSettings.LayerMask.value);

DrawingSettings drawingSettings = CreateDrawingSettings(passSettings.shaderTags, ref renderingData, passSettings.SortingCriteria);
drawingSettings.overrideMaterial = passSettings.MaskMaterial;
drawingSettings.overrideMaterialPassIndex = 0;

context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filteringSettings);

Note that you can define your DrawSettings and FilterSettings anywhere, so doesn’t need to be done inside Execute.

As @tomekkie2 showed, because pixelization is as a post-process effect, you’ll want to do this in two RenderPasses.

In the first pass, you filter your objects to those Layers/RenderLayers you want and draw them to a new render texture using an RTHandle. You’re simply creating a greyscale mask here, so the shader will be relatively simple. You then set this mask texture as a global texture using the cmd.SetGlobalTexture() method.

In the second pass, you Blit the screen with a shader that takes your global MaskTexture as an input.

Be careful when using Global variables in shaders: your global texture needs to be declared with the same name as defined by cmd.SetGlobalTexture() inside the relevant shader pass; but don’t declare it in the Shader’s Properties block. If you do, the compiler will assume you’re looking for Material property and not a Global property of the same name, and your Mask Texture won’t be set on your shader.

3 Likes
6

Thanks for the info. I still have to learn a lot here. This is just something I understand what to do but don’t know how to
. I just can’t seem to get it working. One day I will try again to do this. I just can’t. Not giving up! Just stuck

7

Thanks from me as well. I will give this a go.

8

Honestly, we had very much the same experience. Our team consists of two technical artists, and the Render Feature we implemented was thoroughly explained by Ben Golus, but the URP API caused huge headaches which were only solved with two weeks of trial and error. That also included sleuthing old docs and making some educated guesses and assumptions about how URP worked in the current version.

All that to say is I feel your pain. If you do want to ask any more questions, I’m happy to help when I can. (Though my knowledge is pretty much limited to making one multi-pass RenderFeature work.)

1 Like
9

Thanks a lot!. Will do. Skipping this step for now to continue on my progress with some other objectives. I am doing is solo at this stage.

when I return to this section. I would love to be in contact.

10

So, I’m trying to understand this, and maybe this will help others in the future.

Currently, I have this code in my render pass

    RenderTargetIdentifier source;
    RenderTargetHandle destination;

public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
    {
        source = renderingData.cameraData.renderer.cameraColorTarget;
        cmd.GetTemporaryRT(destination.id, renderingData.cameraData.cameraTargetDescriptor);
    }

    // Here you can implement the rendering logic.
    // Use <c>ScriptableRenderContext</c> to issue drawing commands or execute command buffers
    // https://docs.unity3d.com/ScriptReference/Rendering.ScriptableRenderContext.html
    // You don't have to call ScriptableRenderContext.submit, the render pipeline will call it at specific points in the pipeline.

    public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        CommandBuffer cmd = CommandBufferPool.Get();

        cmd.Blit(source, destination.Identifier(), settings.material, 0);
        cmd.Blit(destination.Identifier(), source);

        context.ExecuteCommandBuffer(cmd);
        CommandBufferPool.Release(cmd);
    }

    // Cleanup any allocated resources that were created during the execution of this render pass.

    public override void OnCameraCleanup(CommandBuffer cmd)
    {
        cmd.ReleaseTemporaryRT(destination.id);
    }

Pretty simple, it just blits a given material onto all the objects seen in the renderer color camera target, and back to the same camera. That much, I think I understand.
However, it’s currently all happening in pass 0. Do I need to do something like “if (pass == 0)” outside of these commands, in order to apply the drawing settings in the first pass, put the above in an else block and change the render pass there in the Blit to 1? Or would it be sufficient to put all of this code in execute, just change that render pass in the Blit to a 1, and add

        //filter by layer
        drawingSettings = CreateDrawingSettings(settings.shaderTags, ref renderingData, settings.SortingCriteria);
        drawingSettings.overrideMaterial = settings.material;
        drawingSettings.overrideMaterialPassIndex = 0;
        context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filteringSettings);

into Execute above my code?

As I understand it, I would instead need to pass the drawingSettings.overrideMaterial into the Blit(), right?

If I understand that much correctly, I believe I am just stuck on the shader and the sorting criteria.
You said “You’re simply creating a greyscale mask here, so the shader will be relatively simple. You then set this mask texture as a global texture using the cmd.SetGlobalTexture() method.” So that means I have to create a new shader to pass into the DrawingSettings as the shaderTags? I don’t understand what this shader is meant to do. No shader is “simple” to me, I’m afraid =/ What is the purpose of setting the global texture? Clearly it has something to do with the shader, so that’s a complete mystery to me.
As for the sorting criteria, I don’t want to apply any additional sorting beyond what the cameras are already handling. Is that None sorting? RendererPriority sorting? RenderQueue sorting? All of them make some sense.

Finally, you say “In the first pass, you filter your objects to those Layers/RenderLayers you want and draw them to a new render texture using an RTHandle.” I don’t see an RTHandle being used anywhere in your code. Is that associated with the shaderTags somehow?

Sorry for the extremely noob questions, shaders and postprocessing are still mostly a mystery to me and it’s very difficult to debug attempts when I don’t really even understand what it is I’m trying to do to accomplish my goal. I think the sorting would be fairly simple to figure out, but the shader is really stopping my progress.

11

Hmm still stuck on this, this is where I’ve got to in Execute(). I know I’m missing something but not sure what…

        // Filter objects by layer mask
        drawingSettings = CreateDrawingSettings(settings.shaderTags, ref renderingData, settings.sortingCriteria);
        drawingSettings.overrideMaterial = settings.material;
        drawingSettings.overrideMaterialPassIndex = 0;
        context.DrawRenderers(renderingData.cullResults, ref drawingSettings, ref filteringSettings);
        context.Submit();

        var culledSource = renderingData.cameraData.renderer.cameraColorTarget;

        // Blit filtered objects to temporary render target
        var cmd = CommandBufferPool.Get();
        cmd.Blit(culledSource, destination.Identifier(), settings.material);

        // Overlay filtered objects onto original image
        cmd.SetGlobalTexture("_MainTex", destination.Identifier());
        cmd.Blit(destination.Identifier(), source);

        context.ExecuteCommandBuffer(cmd);

        CommandBufferPool.Release(cmd);
1 Like
12

Yeah, I’m struggling to wrap this up as well… Ended up with pretty similar code, however what I need is to filter certain objects with layer mask and blit that into the material. This is for custom fog which needs to have a filtered objects. Any thoughts how to properly filter objects, make a blit of them and push the texture into shader? I mean documentation for renderer features in URP is pretty NON-EXISTING

13

My research has told me documentation has been forthcoming for… I think like 3 years now. I think we’re trying to accomplish the same goal? I have a shader/material that does postprocessing, but it does it on all layers and I need to only blit the modifications to a specific layer as identified by a layer mask.
This is the sort of thing that would be really easy with a specific example. Tonight I plan on trying to look at the RenderObject postprocessing code, if I can, because I know it has a layermask option.

1 Like
14

RenderObject doesn’t blit a currently rendered frame into texture. I need to 1. render certain objects with specific layer mask 2. blit that rendered image into shader 3. blit that modified shader to the output image. Doesn’t really sound that difficult.

15

That sounds like the same goal to me. Get objects with a layer mask, apply the shader/mat only to those objects, and render those objects with the shader applied to the final image.
I’ve been looking into various approaches - the problem is, I have no idea how to (easily) see what is happening when I try different things, because all I have is the output to the screen and I don’t have enough knowledge about postprocessing in Unity to come up with a bunch of alternative methods.

My results have been, so far:

  1. the shader/material applies to my whole scene (what I had when I started)
  2. my whole screen is black
  3. the whole screen is black but the shader appears (but what it appears on is not in the layer mask)

So, basically, no progress on this since I started.

16

I’ve come up with a pretty nice solution (Put a lot of resources together) and it works for me! The only thing that is still problematic is transparency (as always, lol). My approach for custom fog in post-processing is as follows:

  • Render a black and white image with filtered objects using a LayerMask.
  • Blit the rendered black and white image into a render texture and use that render texture in a custom fog shader.
  • The fog shader does not actually work with the scene color, but with black and white masks. So, I can use that to filter objects regarding the black/white pixel (black means *0, one means *1).
  • I use a transition from clear black to fog color, which is determined by the depth buffer. The depth buffer is then multiplied by the mask value received from custom blit. If the value is zero, the object won’t be highlighted or will ignore the fog.
  • The most important thing to figure out is, “How do I blend this image with the scene color?” I have to apply a blending option, such as “Blend One One” (default additional) or “Blend SrcAlpha OneMinusSrcAlpha” (traditional transparency). I guess that was the trickiest part.
  • In the final stage, I use that material to blit to the actual scene color.

Here is my RendererFeature. I hope that helps…

public sealed class CustomMaskRendererFeature : ScriptableRendererFeature
    {
        private class MaskRendererPass : ScriptableRenderPass
        {
            private readonly string profName;

            private readonly Material fogMaterial;
            private readonly Material maskMaterial;

            private FilteringSettings filteringSettings;

            private readonly RenderTargetHandle texHandle = RenderTargetHandle.CameraTarget;
            private readonly List<ShaderTagId> shaderTags = new List<ShaderTagId>
            {
                new ShaderTagId("SRPDefaultUnlit"),
                new ShaderTagId("UniversalForward"),
                new ShaderTagId("UniversalForwardOnly"),
                new ShaderTagId("LightweightForward")
            };

            public MaskRendererPass(string profName, Material fogMat, LayerMask layerMask)
            {
                this.profName = profName;
                fogMaterial = fogMat;
                texHandle.Init("_TempFogTex");
                filteringSettings = new FilteringSettings(RenderQueueRange.all, layerMask);
                if(maskMaterial == null)
                    maskMaterial = new Material(Shader.Find("Hidden/BlackMask")); // This is basically a shader that outputs just a black color, nothing else
            }

            /// <summary>
            /// Setup before executing for each camera
            /// </summary>
            public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
            {
                RenderTextureDescriptor cameraTextureDesc = renderingData.cameraData.cameraTargetDescriptor;
                cameraTextureDesc.depthBufferBits = 0;

                cmd.GetTemporaryRT(texHandle.id, cameraTextureDesc, FilterMode.Bilinear);
                ConfigureTarget(texHandle.Identifier());
            }

            /// <summary>
            /// Execute every frame for each camera
            /// </summary>
            public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
            {
                if (fogMaterial == null)
                    return;

                CommandBuffer cmd = CommandBufferPool.Get(profName);

                using (new ProfilingScope(cmd,
                new ProfilingSampler(profName)))
                {
// Render plain image
                    context.ExecuteCommandBuffer(cmd);
                    cmd.Clear();
// Fill the skybox
                    context.DrawSkybox(renderingData.cameraData.camera);
                    DrawingSettings drawSettings = CreateDrawingSettings(shaderTags, ref renderingData, SortingCriteria.CommonOpaque);
// Override the current objects material with the mask material
                    drawSettings.overrideMaterial = maskMaterial;
// Draw the filtered objects (will appear black)
                    context.DrawRenderers(renderingData.cullResults, ref drawSettings, ref filteringSettings);
// Push to command buffer
                    context.Submit();
// Blit the fog shader to the current final frame
                    Blit(cmd, texHandle.Identifier(), renderingData.cameraData.renderer.cameraColorTarget, fogMaterial);
                }

                context.ExecuteCommandBuffer(cmd);
                CommandBufferPool.Release(cmd);
            }

            /// <summary>
            /// Cleanup after finishing for each camera
            /// </summary>
            public override void OnCameraCleanup(CommandBuffer cmd)
            {
                cmd.ReleaseTemporaryRT(texHandle.id);
            }
        }

        [Serializable]
        public sealed class Settings
        {
            public Material fogMaterial;
            public LayerMask exludeLayers;
            public RenderPassEvent renderEvent = RenderPassEvent.AfterRenderingTransparents;
        }

        public Settings settings = new Settings();

        private MaskRendererPass renderPass;

        /// <summary>
        /// Once the feature is created
        /// </summary>
        public override void Create()
        {
            renderPass = new MaskRendererPass(name, settings.fogMaterial, settings.exludeLayers);
            renderPass.renderPassEvent = settings.renderEvent;
        }

        /// <summary>
        /// Updated every frame
        /// </summary>
        public override void AddRenderPasses(ScriptableRenderer renderer, ref RenderingData renderingData)
        {
            renderer.EnqueuePass(renderPass);
        }
    }
17

And this is my simple fog shader in post processing, just to clear your image…

real4 frag(Varyings i) : SV_Target
            {
// Screen space pos
                real2 pos = i.vertex.xy / _ScreenParams.xy;

// This is the mask called _MainTex (dunno why Unity needs this specific name) pushed from the renderer feature
// This mask holds b/w pixels of the filtered objects. I'm also multiplying this with some value to see the pixels more bright in some cases...
                real4 mask = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, pos) * _FogMulti;

                real dp = SampleSceneDepth(pos);
                real depth = smoothstep(_FogStart, _FogStart + _FogEnd, saturate(dp * _FogDist));

// Shader feature for overriding skybox
#ifdef _OVRDSKYBOX
                if (depth <= 0.0) _BaseColor;
#else
                if (depth <= 0.0) discard;
#endif

// Middle gardient feature
#ifdef _MIDGRAD
                if (depth >= 1.0) return 0.;
                real dgrad = 1.0 - depth;
#else
                real dgrad = 1.0;
                depth = 1.0 - depth;
#endif
                return lerp(0., _BaseColor, ((dgrad * depth) * _FogIntens * mask.r));
            }

At the very top, below the SubShader or above the Pass keywords I have a blending mode Blend One One which basically blends the black and white pixels. But Blend SrcAlpha OneMinusSrcAlpha works better…

18

How performant is that? I’m no expert but it seems like a lot of additional draw calls (2 + the blit?) every frame that you have fog, for every camera?

19

Yeah, first rendering the skybox and mesh, then fog and the final blit = 3 batches.