Compress normals to two-component 16-bit float

Light pass now renders in camera space, since normals must be in view space to hide artifacts with z-poles

Author: pezcode

README.md

@@ -27,13 +27,13 @@ The code is programmed to support bgfx's OpenGL and DirectX 11/12 backends. I've
 
 - G-Buffer with 4 render targets
     - diffuse RGB, roughness
-    - normal
+    - [encoded view-space normal](https://aras-p.info/texts/CompactNormalStorage.html#method04spheremap) (RG16F)
     - F0 RGB, metallic
     - emissive RGB, occlusion
 - light culling with light geometry
     - axis-aligned bounding box
     - backface rendering with reversed depth test
-    - fragment world position reconstructed from geometry pass depth
+    - fragment position reconstructed from depth buffer
 - final forward pass for transparent meshes
 
 ### Forward Shading

src/Renderer/DeferredRenderer.cpp

@@ -55,17 +55,23 @@ DeferredRenderer::~DeferredRenderer()
 bool DeferredRenderer::supported()
 {
     const bgfx::Caps* caps = bgfx::getCaps();
-    return Renderer::supported() &&
-           // blitting depth texture after geometry pass
-           (caps->supported & BGFX_CAPS_TEXTURE_BLIT) != 0 &&
-           // fragment depth available in fragment shader
-           (caps->supported & BGFX_CAPS_FRAGMENT_DEPTH) != 0 &&
-           // render target for G-Buffer material parameters
-           (caps->formats[bgfx::TextureFormat::BGRA8]   & BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER) != 0 &&
-           // render target for G-Buffer normals
-           (caps->formats[bgfx::TextureFormat::RGB10A2] & BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER) != 0 &&
-           // multiple render targets
-           caps->limits.maxFBAttachments >= GBufferAttachment::Count; // does depth count as an attachment?
+    bool supported = Renderer::supported() &&
+                     // blitting depth texture after geometry pass
+                     (caps->supported & BGFX_CAPS_TEXTURE_BLIT) != 0 &&
+                     // fragment depth available in fragment shader
+                     (caps->supported & BGFX_CAPS_FRAGMENT_DEPTH) != 0 &&
+                     // multiple render targets
+                     caps->limits.maxFBAttachments >= GBufferAttachment::Count; // does depth count as an attachment?
+    if(!supported)
+        return false;
+
+    for(bgfx::TextureFormat::Enum format : gBufferAttachmentFormats)
+    {
+        if((caps->formats[format] & BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER) == 0)
+            return false;
+    }
+
+    return true;
 }
 
 void DeferredRenderer::onInitialize()

src/Renderer/DeferredRenderer.h

@@ -28,9 +28,7 @@ class DeferredRenderer : public Renderer
         // A = a (remapped roughness)
         Diffuse_A,
 
-        // TODO encode as two 16-bit components (RG16F)
-        // https://aras-p.info/texts/CompactNormalStorage.html
-        // Method #4: Spheremap Transform looks ideal
+        // RG = encoded normal
         Normal,
 
         // RGB = F0 (Fresnel at normal incidence)
@@ -47,12 +45,13 @@ class DeferredRenderer : public Renderer
         Count
     };
 
-    static constexpr bgfx::TextureFormat::Enum gBufferAttachmentFormats[] =
+    static constexpr bgfx::TextureFormat::Enum gBufferAttachmentFormats[GBufferAttachment::Count - 1] =
     {
         bgfx::TextureFormat::BGRA8,
-        bgfx::TextureFormat::RGB10A2,
+        bgfx::TextureFormat::RG16F,
         bgfx::TextureFormat::BGRA8,
         bgfx::TextureFormat::BGRA8
+        // depth format is determined dynamically
     };
 
     TextureBuffer gBufferTextures[GBufferAttachment::Count + 1]; // includes depth, + null-terminated

src/Renderer/Shaders/fs_deferred_geometry.sc

@@ -12,11 +12,16 @@ void main()
     vec3 N = convertTangentNormal(v_normal, v_tangent, mat.normal);
     mat.a = specularAntiAliasing(N, mat.a);
 
+    // save normal in camera space
+    // the other renderers render in world space but the
+    // deferred renderer uses camera space to hide artifacts from
+    // normal packing and to make fragment position reconstruction easier
+    // the normal matrix transforms to world coordinates, so undo that
+    N = mul(u_view, vec4(N, 0.0)).xyz;
+
     // pack G-Buffer
     gl_FragData[0] = vec4(mat.diffuseColor, mat.a);
-    // encode normal for unsigned normalized texture
-    // w of 1.0 so it gets rendered in the debug visualization
-    gl_FragData[1] = vec4(N * 0.5 + 0.5, 1.0);
+    gl_FragData[1] = vec4(packNormal(N), 0.0, 0.0);
     gl_FragData[2] = vec4(mat.F0, mat.metallic);
     gl_FragData[3] = vec4(mat.emissive, mat.occlusion);
 }

src/Renderer/Shaders/fs_deferred_pointlight.sc

@@ -11,8 +11,6 @@ SAMPLER2D(s_texF0Metallic,        SAMPLER_DEFERRED_F0_METALLIC);
 SAMPLER2D(s_texEmissiveOcclusion, SAMPLER_DEFERRED_EMISSIVE_OCCLUSION);
 SAMPLER2D(s_texDepth,             SAMPLER_DEFERRED_DEPTH);
 
-uniform vec4 u_camPos;
-
 uniform vec4 u_lightIndexVec;
 #define u_lightIndex uint(u_lightIndexVec.x)
 
@@ -21,7 +19,7 @@ void main()
     vec2 texcoord = gl_FragCoord.xy / u_viewRect.zw;
 
     vec4 diffuseA = texture2D(s_texDiffuseA, texcoord);
-    vec3 N = texture2D(s_texNormal, texcoord).xyz * 2.0 - 1.0;
+    vec3 N = unpackNormal(texture2D(s_texNormal, texcoord).xy);
     vec4 F0Metallic = texture2D(s_texF0Metallic, texcoord);
 
     // unpack material parameters used by the PBR BRDF function
@@ -31,18 +29,18 @@ void main()
     mat.F0 = F0Metallic.xyz;
     mat.metallic = F0Metallic.w;
 
-    // get fragment world position
+    // get fragment position
+    // rendering happens in view space
     vec4 screen = gl_FragCoord;
     screen.z = texture2D(s_texDepth, texcoord).x;
-    vec4 eyePos = screen2Eye(screen);
-    vec3 fragPos = mul(u_invView, eyePos).xyz;
+    vec3 fragPos = screen2Eye(screen).xyz;
 
-    vec3 camPos = u_camPos.xyz;
-    vec3 V = normalize(camPos - fragPos);
+    vec3 V = normalize(-fragPos);
 
     // lighting
 
     PointLight light = getPointLight(u_lightIndex);
+    light.position = mul(u_view, vec4(light.position, 1.0)).xyz;
 
     vec3 radianceOut = vec3_splat(0.0);
     float dist = distance(light.position, fragPos);

src/Renderer/Shaders/util.sh

@@ -72,4 +72,27 @@ vec3 convertTangentNormal(vec3 normal_ref, vec3 tangent_ref, vec3 normal)
     return normalize(mul(TBN, normal));
 }
 
+// compress viewspace normal into two components
+// spheremap transform used by Cry Engine 3
+// https://aras-p.info/texts/CompactNormalStorage.html#method04spheremap
+// must be viewspace so we can hide z-pole
+// both (0,0,1) and (0,0,-1) have the same encoding
+// the original implementation always decoded to (0,0,1)
+// changed it to return normals pointing towards the camera for
+// a left-handed coordinate system
+
+vec2 packNormal(vec3 normal)
+{
+    float f = sqrt(8.0 * -normal.z + 8.0);
+    return normal.xy / f + 0.5;
+}
+
+vec3 unpackNormal(vec2 encoded)
+{
+    vec2 fenc = encoded * 4.0 - 2.0;
+    float f = dot(fenc, fenc);
+    float g = sqrt(1.0 - f * 0.25);
+    return vec3(fenc * g, -(1.0 - f * 0.5));
+}
+
 #endif // UTIL_SH_HEADER_GUARD

src/Renderer/Shaders/vs_deferred_light.sc

@@ -5,4 +5,6 @@ $input a_position
 void main()
 {
     gl_Position = mul(u_modelViewProj, vec4(a_position, 1.0));
+    // prevent far plane clipping for point light volumes outside the camera frustum
+    //gl_Position.z = min(gl_Position.z / gl_Position.w, 1.0) * gl_Position.w;
 }