HDRP and GBuffer

I want to write outline post process shader, but I have problem. When I want to use normals from GBuffer textures, I got just grey output.

Code (CSharp):

1. Shader "Hidden/SotR/Outline"
2. {
3.     HLSLINCLUDE
4.  
5.         #include "Packages/com.unity.postprocessing/PostProcessing/Shaders/StdLib.hlsl"
6.  
7.         //TEXTURE2D_SAMPLER2D(_MainTex, sampler_MainTex);
8.         TEXTURE2D_SAMPLER2D(_CameraGBufferTexture2, sampler_CameraGBufferTexture2);
9.        
10.         float _Blend;
11.  
12.         float4 Frag(VaryingsDefault i) : SV_Target
13.         {
14.             //float4 color = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.texcoord);
15.             float4 color = SAMPLE_TEXTURE2D(_CameraGBufferTexture2, sampler_CameraGBufferTexture2, i.texcoord);
16.             //float luminance = dot(color.rgb, float3(0.2126729, 0.7151522, 0.0721750));
17.             //color.rgb = lerp(color.rgb, luminance.xxx, _Blend.xxx);
18.             return color;
19.         }
20.  
21.     ENDHLSL
22.  
23.     SubShader
24.     {
25.         Cull Off ZWrite Off ZTest Always
26.  
27.         Pass
28.         {
29.             HLSLPROGRAM
30.  
31.                 #pragma vertex VertDefault
32.                 #pragma fragment Frag
33.  
34.             ENDHLSL
35.         }
36.     }
37. }

 

Thanks! Ok, I got this. I had some problems with library, but in the end i handled that. Unfortunately I have two problems now:
1. The texture does not clear on the sky.

2. The second problem i that, when I change window size, outline based on normal texture is not refreshing.

 

First problem: I didn't disable anything. Camera settings are from the template.
Second problem: I handled the second issue using ratio of _MainTex_TexelSize and _NormalBufferTexture_TexelSize.

 

@arnaud-carre I am looking for an example of a shader that renderes to the HDRP Gbuffer when executed with DrawProcedural on a CommandBuffer. I haven't seen that work without actually altering the HDRP. Is it possible in the current version of HDRP?

 

Can someone show a working method of just getting the Normals, the line below gives me an error!!!!

#include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/NormalBuffer.hlsl"

HDRP is terrible to work with, nothing is documented and constantly changing, what the hell is going on Unity>>>>>????

 

Any update on this, help would be appreciated, we need access to the Normal buffer in HDRP / LWRP latest version.

 

Hello,
Sorry to be a little bit late on the answer and also english is not my first langage But I felt on this post when I wanted to about the same thing in HDRP.
I found that into HDRP the function to read information from related textures are defined with this macro:
In the file GLCore.hlsl

Code (CSharp):

1. #define LOAD_TEXTURE2D_ARRAY(textureName, unCoord2, index)                      textureName.Load(int4(unCoord2, index, 0))

The parameters from LOAD_TEXTURE... they require a Pixel coordinate, this is why in the PostProcess the code is like this:

Code (CSharp):

1.     float4 CustomPostProcess(Varyings input) : SV_Target
2.  
3.     {
4.         UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
5.         uint2 positionSSRegular = input.texcoord* _ScreenSize.xy;...

We can use the positionSSRegular to find the informations example the world normals.
The G Buffer is not cleared into HDRP as Arnaud mentionned

So in a post process.
What I did is make three functions to explain how I dealt with the required informations I needed to get in my post-process.
Exemple to get the Depth I use this as a function

Code (CSharp):

1. float GetDepth(int2 SSRegular)
2. {
3.     return LOAD_TEXTURE2D_X(_CameraDepthTexture, SSRegular).x;
4. }

It gives this:


Exemple to get the Normal WorldSpace. I use this:

Code (CSharp):

1.     float3 normalWS = GetNormalWorldSpace(positionSSRegular, depth);

The function is like this:

Code (CSharp):

1. /* Use this to clear GBuffer like...*/
2. float3 GetNormalWorldSpace(float2 uv, float depth)
3. {
4.     float3 normalWS = 0.0f;
5.    
6.     if (depth > 0.0f)
7.     {
8.         NormalData normalData;
9.         const float4 normalBuffer = LOAD_TEXTURE2D_X(_NormalBufferTexture, uv);
10.         DecodeFromNormalBuffer(normalBuffer, uv, normalData);
11.         normalWS = normalData.normalWS;
12.     }
13.    
14.     return normalWS;
15. }
16.  

Which gives:


The problem you have with the normalWS are because the Gbuffer is not cleared, so a simple trick you can do is to simple check if the Depth is > 0.0f

 

This should solve the NormalWS problem.

Code (CSharp):

1.     if (depth > 0.0f)
2.     {
3.         NormalData normalData;
4.         const float4 normalBuffer = LOAD_TEXTURE2D_X(_NormalBufferTexture, uv);
5.         DecodeFromNormalBuffer(normalBuffer, uv, normalData);
6.         normalWS = normalData.normalWS;
7.     }

 

nice, is there also a way to get the basecolor and other layers too like specular, diffuse and so on ?

 

Bump this, I also want to know how to get albedo/diffuse

 

Bump, and very surprised something important like this wouldn't be documented for HDRP?
(Please correct me if I'm wrong though!)

 

Bumping this, I would also like to know if there is a way to decode the Albedo.

 

Same Here. I also want to know how to get albedo/diffuse in HDRP.

 

I would also be interested in knowing how to get albedo/diffuse