Re-add PackNormalOctQuadEncode()

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Packing.hlsl

 // Ref: http://www.vis.uni-stuttgart.de/~engelhts/paper/vmvOctaMaps.pdf
 // Encode with Oct, this function work with any size of output
 // return real between [-1, 1]
-real2 PackNormalOctEncode(real3 n)
+real2 PackNormalOctRectEncode(real3 n)
 {
     // Perform planar projection.
     real3 p = n * rcp(dot(abs(n), 1.0));
     return real2(s * r, g);
 }
 
-real3 UnpackNormalOctEncode(real2 f)
+real3 UnpackNormalOctRectEncode(real2 f)
 {
     real r = f.r;
     real g = f.g;
     real x = 0.5 * g + 0.5 - s * r;
     real y = g - x;
-    real z = s * max(FLT_EPS, 1.0 - abs(x) - abs(y)); // Clamping is absolutely crucial for numerical stability
+    real z = s * max(1.0 - abs(x) - abs(y), FLT_EPS); // Clamping is absolutely crucial for numerical stability
+}
+
+// Ref: http://jcgt.org/published/0003/02/01/paper.pdf
+// Encode with Oct, this function work with any size of output
+// return real between [-1, 1]
+real2 PackNormalOctQuadEncode(real3 n)
+{
+    //real l1norm    = dot(abs(n), 1.0);
+    //real2 res0     = n.xy * (1.0 / l1norm);
+
+    //real2 val      = 1.0 - abs(res0.yx);
+    //return (n.zz < real2(0.0, 0.0) ? (res0 >= 0.0 ? val : -val) : res0);
+
+    // Optimized version of above code:
+    n *= rcp(dot(abs(n), 1.0));
+    real t = saturate(-n.z);
+    return n.xy + (n.xy >= 0.0 ? t : -t);
+}
+
+real3 UnpackNormalOctQuadEncode(real2 f)
+{
+    real3 n = real3(f.x, f.y, 1.0 - abs(f.x) - abs(f.y));
+
+    //real2 val = 1.0 - abs(n.yx);
+    //n.xy = (n.zz < real2(0.0, 0.0) ? (n.xy >= 0.0 ? val : -val) : n.xy);
+
+    // Optimized version of above code:
+    real t = max(-n.z, 0.0);
+    n.xy += n.xy >= 0.0 ? -t.xx : t.xx;
+
+    return normalize(n);
 }
 
 real2 PackNormalHemiOctEncode(real3 n)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

     // We store perceptualRoughness instead of roughness because it save a sqrt ALU when decoding
     // (as we want both perceptualRoughness and roughness for the lighting due to Disney Diffuse model)
     // Encode normal on 20bit with oct compression + 2bit of sign
-    float2 octNormalWS = PackNormalOctEncode(surfaceData.normalWS);
+    float2 octNormalWS = PackNormalOctRectEncode(surfaceData.normalWS);
     // To have more precision encode the sign of xy in a separate uint
     uint octNormalSign = (octNormalWS.x < 0.0 ? 1 : 0) | (octNormalWS.y < 0.0 ? 2 : 0);
     outGBuffer1 = float4(PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness), abs(octNormalWS), PackInt(octNormalSign, 2));
     octNormalWS.x = (octNormalSign & 1) ? -octNormalWS.x : octNormalWS.x;
     octNormalWS.y = (octNormalSign & 2) ? -octNormalWS.y : octNormalWS.y;
 
-    bsdfData.normalWS = UnpackNormalOctEncode(octNormalWS);
+    bsdfData.normalWS = UnpackNormalOctRectEncode(octNormalWS);
 
     // metallic15 is range [0..12] if metallic data is needed
     bool pixelHasNoMetallic = HasFeatureFlag(pixelFeatureFlags, MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR | MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING | MATERIALFEATUREFLAGS_LIT_TRANSMISSION);