Custom HDRP Pass AfterOpaqueAndNormal - how to WRITE normal?

Unity Engine
, ,
1

I created a Custom Pass Volume and created a FullScreenPass Shader that simply offsets the Normal for testing purpose.
I want to read & write the normal.

When I select the injection point “After Post Process” and simply return a float4 in my Pass, I see the normal COLOR. Great for debugging I guess. But I want to WRITE the normal.

How? In a normal Shader, I’d use:

EncodeIntoNormalBuffer(normalData, output.gBuffer1);

where “output” is a struct:

//FeatureName   Standard
            //GBuffer0      baseColor.r,    baseColor.g,    baseColor.b,    specularOcclusion
            //GBuffer1      normal.xy (1212),   perceptualRoughness
            //GBuffer2      f0.r,   f0.g,   f0.b,   featureID(3) / coatMask(5)
            //GBuffer3      bakedDiffuseLighting.rgb
            struct FragmentOutput {
                float4 gBuffer0 : SV_Target0;
                float4 gBuffer1 : SV_Target1;
                float4 gBuffer2 : SV_Target2;
                float4 gBuffer3 : SV_Target3;
            };

I think I got those comments from the Forum or the Documentation of HDRP.

Anyway, returning a float4 shows me the Color in “After Post Process” Injection Point - as it doesn’t expect any normals. But in “AfterOpaqueAndNormal” Injection Point it doesn’t show any change, not even when I return my FragmentOutput struct with the SV_Targets - I was thinking I would be targetting the gbuffer for the normal Data…

The documentation even says this for AfterOpaqueDepthAndNormal:

Buffers will contain all opaque objects. Here you can modify the normal, roughness and depth buffer, it will be taken in account in the lighting and the depth pyramid. Note that normals and roughness are in the same buffer, you can use DecodeFromNormalBuffer and EncodeIntoNormalBuffer functions to read/write normal and roughness data
  • Note the last Part: “you can use … EncodeIntoNormalBuffer…” - but HOW? by returning a struct? I do I need some inout/out variable as a parameter? Or maybe a special Tag in my Pass? This is no where doucmented - or I can’t find it.

@antoinel_unity has some examples on his GitHub, but I don’t see any GBuffer Tags or similar in the code… I only see the depth being written by a “inout depth” parameter.

How do I write Normals in a Fullscreen Custom Pass in HDRP, at the “AfterOpaqueDepthAndNormal” Injection Point.

Thanks!

2

I figured it out. You need to create a C# custom Pass as well. There you can define the render targets and call your custom Pass to render. The shader itself actually just returns float4, but you can then write it to the normalBuffer in the Execute Method:

CoreUtils.SetRenderTarget(ctx.cmd, ctx.cameraNormalBuffer, ClearFlag.None);
CoreUtils.DrawFullScreen(ctx.cmd, fullscreenPassMat, ctx.propertyBlock, shaderPassId: 0);
3

hello, could you provide more info on this? when i write a custom pass to try to write to the normal buffer, it completely corrupts it. all i want to do is write to the normal/roughness buffer using a fullscreen shader.

4

Hm, a “human readable” normal is the “decoded” version, the gbuffer wants the “encoded” version, that actually looks like the normals got scrambled. Have a look at the Frame debugger what a “HDRP/Lit” shader does to the normals.

Decoded, human readable version:

For Comparison, Encoded GBuffer version using “EncodeIntoNormalBuffer”:

But I had some issues with the buffer format, ended up using “R32G32B32A32_SFloat”, the other variants in the comment are formats that I tried before… Maybe that helps

myCustomBuffer = RTHandles.Alloc(
            Vector2.one, TextureXR.slices, dimension: TextureXR.dimension,
            colorFormat: GraphicsFormat.R32G32B32A32_SFloat,  // colorFormat: GraphicsFormat.R8G8B8A8_SRGB,GraphicsFormat.R8G8B8A8_UNorm,
            useDynamicScale: true, name: "custom normal buffer 2"
        );

This is how I used EncodeIntoNormalBuffer:

FragmentOutput GBufferFragment(VertexOutput input) : SV_TARGET{
                UNITY_SETUP_INSTANCE_ID(input);
                float3 albedo = col;
                float4 specular_roughness = float4(_SpecularRGB.r, _SpecularRGB.g, _SpecularRGB.b, _RoughnessValue);
                float4 normal_roughness = float4(input.worldNormal.xy, 0, 0);
                normal_roughness = float4(0, 0, 0, 0);


                NormalData normalData;
                normalData.normalWS = input.worldNormal.xyz;
                normalData.perceptualRoughness = 0.6f;
                float4 positionSS = input.clipPos;
                EncodeIntoNormalBuffer(normalData, positionSS, output.gBuffer1);


                output.gBuffer0.rgba = float4(albedo.rgb, _SpecularOcclusion); // Diffuse (RGB), specularOcclusion (A)
                output.gBuffer1.rgba = normal_roughness; // normal.xy(1212), perceptualRoughness

                float3 shadow_color = albedo.rgb * 0.8;
                shadow_color.r += 0.4f;
                shadow_color.b += 0.45f;
                output.gBuffer2.rgba = float4(shadow_color, 0); // f0.r, f0.g, f0.b, featureID(3) / coatMask(5)
                output.gBuffer3.rgba = float4(0, 0, 0, 0); // bakedDiffuseLighting.rgb

                return output;
            }

(I brightened the shadows, but you get the point) If you bake lights you might get a black mesh with this one.

To make it work, and because I couldn’t get the #includes to work (clashed with “UnityCG.cginc”) I pasted the relevant parts:

struct NormalData // from "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/NormalBuffer.hlsl"
            {
                float3 normalWS;
                float  perceptualRoughness;
            };
            // Inserts the bits indicated by 'mask' from 'src' into 'dst'.
            uint BitFieldInsert(uint mask, uint src, uint dst)
            {
                return (src & mask) | (dst & ~mask);
            }
            // Composes a floating point value with the magnitude of 'x' and the sign of 's'.
            // See the comment about FastSign() below.
            float CopySign(float x, float s, bool ignoreNegZero = true)
            {
#if !defined(SHADER_API_GLES)
                if (ignoreNegZero)
                {
                    return (s >= 0) ? abs(x) : -abs(x);
                }
                else
                {
                    uint negZero = 0x80000000u;
                    uint signBit = negZero & asuint(s);
                    return asfloat(BitFieldInsert(negZero, signBit, asuint(x)));
                }
#else
                return (s >= 0) ? abs(x) : -abs(x);
#endif
            }
            // Ref: http://jcgt.org/published/0003/02/01/paper.pdf
            // Encode with Oct, this function work with any size of output
            // return float between [-1, 1]
            float2 PackNormalOctQuadEncode(float3 n)
            {
                //float l1norm    = dot(abs(n), 1.0);
                //float2 res0     = n.xy * (1.0 / l1norm);

                //float2 val      = 1.0 - abs(res0.yx);
                //return (n.zz < float2(0.0, 0.0) ? (res0 >= 0.0 ? val : -val) : res0);

                // Optimized version of above code:
                n *= rcp(dot(abs(n), 1.0));
                float t = saturate(-n.z);
                return n.xy + (n.xy >= 0.0 ? t : -t);
            }
            // Pack float2 (each of 12 bit) in 888
            float3 PackFloat2To888(float2 f)
            {
                uint2 i = (uint2)(f * 4095.5);
                uint2 hi = i >> 8;
                uint2 lo = i & 255;
                // 8 bit in lo, 4 bit in hi
                uint3 cb = uint3(lo, hi.x | (hi.y << 4));

                return cb / 255.0;
            }
            void EncodeIntoNormalBuffer(NormalData normalData, uint2 positionSS, out float4 outNormalBuffer0)
            {
                // The sign of the Z component of the normal MUST round-trip through the G-Buffer, otherwise
                // the reconstruction of the tangent frame for anisotropic GGX creates a seam along the Z axis.
                // The constant was eye-balled to not cause artifacts.
                // TODO: find a proper solution. E.g. we could re-shuffle the faces of the octahedron
                // s.t. the sign of the Z component round-trips.
                const float seamThreshold = 1.0 / 1024.0;
                normalData.normalWS.z = CopySign(max(seamThreshold, abs(normalData.normalWS.z)), normalData.normalWS.z);

                // RT1 - 8:8:8:8
                // Our tangent encoding is based on our normal.
                float2 octNormalWS = PackNormalOctQuadEncode(normalData.normalWS);
                float3 packNormalWS = PackFloat2To888(saturate(octNormalWS * 0.5 + 0.5));
                // We store perceptualRoughness instead of roughness because it is perceptually linear.
                outNormalBuffer0 = float4(packNormalWS, normalData.perceptualRoughness);
            }

hope it helps