[Solved] How to use Blit with a CustomPostProcessVolumeComponent?

[McDev02]

I implement a former ImageEffect to HDRP with a CustomPostProcessVolumeComponent and I have various issues.

1. When I follow these instructions I am unable to add the post effect to the BeforePP list, only to the AfterPP. It seems to be fine for my needs but having raw, non-tonemapped values could be beneficial in some cases.

2. Is there a way to change the order of PostProcessing Components? It seems that each has a predefined priority. Component inspector position has no impact.

3. How to use Blit with this system? Solution

My shader consists of the following steps:
For each iteration
Blit: BlurX Pass
Blit: BlurY Pass

This results in a blurred image I need to use on the final output pass, that I could do like this:

m_Material.SetTexture("_MaskTexture", blurredTexture);
HDUtils.DrawFullScreen(cmd, m_Material, destination);

The main question however is how I perform Blits. Here is what I tried but Blit is not working.

public override void Render(CommandBuffer cmd, HDCamera camera, RTHandle source, RTHandle destination)
    {
        if (m_Material == null)
            return;

        m_Material.SetFloat("_Pixel", Pixel.value);
        m_Material.SetFloat("_Amount", Amount.value);
        m_Material.SetFloat("_Amount2", SecondAmount.value);
        m_Material.SetFloat("_Threshold", Threshold.value);
        m_Material.SetTexture("_InputTexture", source);

        RenderTexture tmp1 = RenderTexture.GetTemporary(destination.rt.width, destination.rt.height);
        RenderTexture tmp2 = RenderTexture.GetTemporary(destination.rt.width, destination.rt.height);
   
        cmd.Blit(source.rt, tmp1);

        for (int i = 0; i < Iterations.value; i++)
        {
            cmd.Blit(tmp1, tmp2, blurMaterial, 0); //BlurX
            cmd.Blit(tmp2, tmp1, blurMaterial, 1); //BlurY
        }

        m_Material.SetTexture("_MaskTexture", tmp1);
        //UnsharpMask Pass
        HDUtils.DrawFullScreen(cmd, m_Material, destination, null, 0);

        RenderTexture.ReleaseTemporary(tmp1);
        RenderTexture.ReleaseTemporary(tmp2);
    }

[Olmi]

Hi @McDev02

1. You probably didn’t read carefully enough?

“The injectionPoint override allows you to specify where in the pipeline HDRP executes the effect. There are currently three injection points:”.

This line in the example allows you to set execution point:

public override CustomPostProcessInjectionPoint injectionPoint =>
CustomPostProcessInjectionPoint.AfterPostProcess;

I remember it worked fine for me sometime in August last year, but things might have changed since then.

3. Check Keijiro’s HDRP post processing examples for blit examples.

You need to reserve RTHandles for each render pass you need, like one for your horizontal pass, one for your vertical pass, then render the final result to the destination or whatever you call the incoming image (RTHandle) in your Render() override. Then use HDUtils.DrawFullScreen to render your shader pass.

At least that’s how I’ve done it, while there’s no proper documentation available it’s just guesswork, trial and error. Not sure if it’s the right way but it worked for me.

[McDev02]

Thanks @Olmi

But it just doesn’t work. I made a few checks to see if the materials and shaders are fine and they are.
For example when I change var lastRT = source.rt; then “_MaskTexture” is set and I can use it in the shader, but the way I do it the texture remains black.
If I call HDUtils.DrawFullScreen(cmd, m_Material, destination, _prop, 1); I also get what I expect.
The way I create the RTHandles are taken from the example you posted, the Streak Effect.

public RTHandle GetNewRTHandle(HDCamera camera)
{
    var width = camera.actualWidth;
    var height = camera.actualHeight;
    const GraphicsFormat RTFormat = GraphicsFormat.R16G16B16A16_SFloat;
    var rt = RTHandles.Alloc(scaleFactor: Vector2.one, colorFormat: RTFormat);// RTHandles.Alloc(width, height,  colorFormat: RTFormat);

    rtHandles.Add(rt);
    return rt;
}


public override void Render(CommandBuffer cmd, HDCamera camera, RTHandle source, RTHandle destination)
{
    if (m_Material == null)
        return;

    m_Material.SetFloat("_Pixel", Pixel.value);
    m_Material.SetFloat("_Amount", Amount.value);
    m_Material.SetFloat("_Amount2", SecondAmount.value);
    m_Material.SetFloat("_Threshold", Threshold.value);
    m_Material.SetTexture("_InputTexture", source);
   
    if (rth1 == null)
        rth1 = GetNewRTHandle(camera);
    if (rth2 == null)
        rth2 = GetNewRTHandle(camera);

    HDUtils.DrawFullScreen(cmd, m_Material, rth1, _prop, 1);

    var lastRT = rth1;

    //for (int i = 0; i < Iterations.value; i++)
    //{
    //    cmd.Blit(tmp1, tmp2, blurMaterial, 0);
    //    cmd.Blit(tmp2, tmp1, blurMaterial, 1);
    //}

    m_Material.SetTexture("_MaskTexture", lastRT);
    HDUtils.DrawFullScreen(cmd, m_Material, destination);
}

[McDev02]

Alright this shows that posting full source is beneficial. The issue was the difference between LOAD_TEXTURE2D_X and LOAD_TEXTURE2D. For my RTHandles I have to use LOAD_TEXTURE2D. I do not plan for VR so I don’t mind but maybe there also is a way to enable VR mode for RTHandles in case this becomes necessary.
Here is some insight

HDRP Post Processing shaders - accessing GBuffers

Hi, It will probably be a long post so for starters here is some sort tl;dr: So far I was able to fork HDRP and plug it back to unity, add some code to embedded post processing system to do some sort of shader work as in FinalPass. I’ve created new material using CoreUtils.CreateEngineMaterial(m_Resources.shaders.outlineShader); And then, after all of the built-in post processing (but before FinalPass call) I am using it with: HDUtils.DrawFullScreen(cmd, m_OutlineMaterial, destination); S…

Shader head

half _Pixel, _Amount, _Amount2, _Threshold, _DepthBias, _Fac;
TEXTURE2D_X(_InputTexture);
TEXTURE2D(_MaskTexture);

Render Method

public override void Render(CommandBuffer cmd, HDCamera camera, RTHandle source, RTHandle destination)
{
    if (m_Material == null)
        return;

    m_Material.SetFloat("_Pixel", Pixel.value);
    m_Material.SetFloat("_Amount", Amount.value);
    m_Material.SetFloat("_Amount2", SecondAmount.value);
    m_Material.SetFloat("_Threshold", Threshold.value);
    m_Material.SetTexture("_InputTexture", source);

    if (rth1 == null)
        rth1 = GetNewRTHandle(camera);
    if (rth2 == null)
        rth2 = GetNewRTHandle(camera);

    //_prop.SetTexture(Shader.PropertyToID("_InputTexture"), source);
    HDUtils.DrawFullScreen(cmd, m_Material, rth1, _prop, 3);

    for (int i = 0; i < Iterations.value; i++)
    {
        _prop.SetTexture(Shader.PropertyToID("_MaskTexture"), rth1);
        HDUtils.DrawFullScreen(cmd, m_Material, rth2, _prop, 1);

        _prop.SetTexture(Shader.PropertyToID("_MaskTexture"), rth2);
        HDUtils.DrawFullScreen(cmd, m_Material, rth1, _prop, 2);
    }

    m_Material.SetTexture("_MaskTexture", rth1);
    HDUtils.DrawFullScreen(cmd, m_Material, destination);
}

[Olmi]

Good to hear you got it working. Yes it would be good to also have the shader side of code visible as quite a few things have changed (when compared to built-in render pipeline.)