HDRenderPipeline: Remove SHADEROPTIONS_PACK_GBUFFER_IN_U16

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs

         public enum GBufferMaterial
         {
             // Note: This count doesn't include the velocity buffer. On shader and csharp side the velocity buffer will be added by the framework
-            Count = (ShaderConfig.k_PackgbufferInU16 == 1) ? 2 : 4
+            Count = 4
         };
 
         //-----------------------------------------------------------------------------
         RenderTextureFormat[] m_RTFormat4 = { RenderTextureFormat.ARGB32, RenderTextureFormat.ARGB2101010, RenderTextureFormat.ARGB32, RenderTextureFormat.RGB111110Float };
         RenderTextureReadWrite[] m_RTReadWrite4 = { RenderTextureReadWrite.sRGB, RenderTextureReadWrite.Linear, RenderTextureReadWrite.Linear, RenderTextureReadWrite.Linear };
 
-        // TODO: Just discovered that Unity doesn't support unsigned 16 RT format.
-        RenderTextureFormat[] m_RTFormat2 = { RenderTextureFormat.ARGBInt, RenderTextureFormat.ARGBInt };
-        RenderTextureReadWrite[] m_RTReadWrite2 = { RenderTextureReadWrite.Linear, RenderTextureReadWrite.Linear };
-
-            if (ShaderConfig.s_PackgbufferInU16 == 1)
-            {
-                RTFormat = m_RTFormat2;
-                RTReadWrite = m_RTReadWrite2;
-            }
-            else
-            {
-                RTFormat = m_RTFormat4;
-                RTReadWrite = m_RTReadWrite4;
-            }
+            RTFormat = m_RTFormat4;
+            RTReadWrite = m_RTReadWrite4;
         }
 
         //-----------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 # endif
 #endif
 
-// In case we pack data uint16 buffer we need to change the output render target format to uint16
-// TODO: Is there a way to automate these output type based on the format declare in lit.cs ?
-#if SHADEROPTIONS_PACK_GBUFFER_IN_U16
-#define GBufferType0 uint4
-#define GBufferType1 uint4
-
-// TODO: How to abstract that ? We would like to avoid this PS4 test here
-#ifdef SHADER_API_PSSL
-// On PS4 we need to specify manually the format of the output render target, output type is not enough
-#pragma PSSL_target_output_format(target 0 FMT_UINT16_ABGR)
-#pragma PSSL_target_output_format(target 1 FMT_UINT16_ABGR)
-#endif
-
-#else
-#endif
 
 // GBuffer texture declaration
 TEXTURE2D(_GBufferTexture0);
 void EncodeIntoGBuffer( SurfaceData surfaceData,
                         float3 bakeDiffuseLighting,
                         uint2 positionSS,
-                        #if SHADEROPTIONS_PACK_GBUFFER_IN_U16
-                        out GBufferType0 outGBufferU0,
-                        out GBufferType1 outGBufferU1
-                        #else
-                        #endif
-#if SHADEROPTIONS_PACK_GBUFFER_IN_U16
-    float4 outGBuffer0, outGBuffer1, outGBuffer2, outGBuffer3;
-#endif
-
     ApplyDebugToSurfaceData(surfaceData);
 
     // RT0 - 8:8:8:8 sRGB
 
     // Lighting
     outGBuffer3 = float4(bakeDiffuseLighting, 0.0);
-
-#if SHADEROPTIONS_PACK_GBUFFER_IN_U16
-    // Now pack all buffer into 2 uint buffer
-
-    // We don't have hardware sRGB to store base color in case we pack int u16, so rather than perform full sRGB encoding just use cheap gamma20
-    // TODO: test alternative like FastLinearToSRGB to better match unpacked gbuffer
-    outGBuffer0.xyz = LinearToGamma20(outGBuffer0.xyz);
-
-    uint packedGBuffer1 = PackR10G10B10A2(outGBuffer1);
-
-    outGBufferU0 = uint4(   PackFloatToUInt(outGBuffer0.x, 8, 0)  | PackFloatToUInt(outGBuffer0.y, 8, 8),
-                            PackFloatToUInt(outGBuffer0.z, 8, 0)  | PackFloatToUInt(outGBuffer0.w, 8, 8),
-                            (packedGBuffer1 & 0x0000FFFF),
-                            (packedGBuffer1 & 0xFFFF0000) >> 16);
-
-    uint packedGBuffer3 = PackToR11G11B10f(outGBuffer3.xyz);
-
-    outGBufferU1 = uint4(   PackFloatToUInt(outGBuffer2.x, 8, 0)  | PackFloatToUInt(outGBuffer2.y, 8, 8),
-                            PackFloatToUInt(outGBuffer2.z, 8, 0)  | PackFloatToUInt(outGBuffer2.w, 8, 8),
-                            (packedGBuffer3 & 0x0000FFFF),
-                            (packedGBuffer3 & 0xFFFF0000) >> 16);
-#endif
-}
-
-float4 DecodeGBuffer0(GBufferType0 encodedGBuffer0)
-{
-    float4 decodedGBuffer0;
-#if SHADEROPTIONS_PACK_GBUFFER_IN_U16
-    decodedGBuffer0.x = UnpackUIntToFloat(encodedGBuffer0.x, 8, 0);
-    decodedGBuffer0.y = UnpackUIntToFloat(encodedGBuffer0.x, 8, 8);
-    decodedGBuffer0.z = UnpackUIntToFloat(encodedGBuffer0.y, 8, 0);
-    decodedGBuffer0.w = UnpackUIntToFloat(encodedGBuffer0.y, 8, 8);
-
-    decodedGBuffer0.xyz = Gamma20ToLinear(encodedGBuffer0.xyz);
-#else
-    decodedGBuffer0 = encodedGBuffer0;
-#endif
-    return decodedGBuffer0;
 }
 
 void DecodeFromGBuffer(
     out float3 bakeDiffuseLighting)
 {
-#if SHADEROPTIONS_PACK_GBUFFER_IN_U16
-    GBufferType0 inGBufferU0 = LOAD_TEXTURE2D(_GBufferTexture0, positionSS);
-    GBufferType1 inGBufferU1 = LOAD_TEXTURE2D(_GBufferTexture1, positionSS);
-#else
-#endif
-
-#if SHADEROPTIONS_PACK_GBUFFER_IN_U16
-    float4 inGBuffer0, inGBuffer1, inGBuffer2, inGBuffer3;
-
-    inGBuffer0 = DecodeGBuffer0(inGBufferU0);
-
-    uint packedGBuffer1 = inGBufferU0.z | inGBufferU0.w << 16;
-    inGBuffer1 = UnpackR10G10B10A2(packedGBuffer1);
-
-    inGBuffer2.x = UnpackUIntToFloat(inGBufferU1.x, 8, 0);
-    inGBuffer2.y = UnpackUIntToFloat(inGBufferU1.x, 8, 8);
-    inGBuffer2.z = UnpackUIntToFloat(inGBufferU1.y, 8, 0);
-    inGBuffer2.w = UnpackUIntToFloat(inGBufferU1.y, 8, 8);
-
-    uint packedGBuffer3 = inGBufferU1.z | inGBufferU1.w << 16;
-    inGBuffer3.xyz = UnpackFromR11G11B10f(packedGBuffer1);
-    inGBuffer3.w = 0.0;
-#endif
 
     float3 baseColor = inGBuffer0.rgb;
     bsdfData.specularOcclusion = inGBuffer0.a;

ScriptableRenderPipeline/HDRenderPipeline/ShaderConfig.cs

         // 3) When this is solve (i.e move previousPositionCS to a free attribute semantic), Unity only support one pSecondaryFormat. Mean if we ahve a vertex color instance stream and motion vector, motion vector will overwrite vertex color stream. See MeshRenderingData.cpp
         // All this could be fix we a new Mesh API not ready yet. Note that this feature only affect animated mesh (vertex or skin) as others use depth reprojection.
         VelocityInGBuffer = 0, // Change to 1 to enable the feature, then regenerate hlsl headers.
-        // TODO: not working yet, waiting for UINT16 RT format support
-        PackGBufferInU16 = 0,
         CameraRelativeRendering = 1 // Rendering sets the origin of the world to the position of the primary (scene view) camera
     };
 
         // but it is usually small, so we are fine with it (until someone at microsoft fix the debuggger).
         public const int k_VelocityInGbuffer = (int)ShaderOptions.VelocityInGBuffer;
         public static int s_VelocityInGbuffer = (int)ShaderOptions.VelocityInGBuffer;
-
-        public const int k_PackgbufferInU16 = (int)ShaderOptions.PackGBufferInU16;
-        public static int s_PackgbufferInU16 = (int)ShaderOptions.PackGBufferInU16;
 
         public const int k_CameraRelativeRendering = (int)ShaderOptions.CameraRelativeRendering;
         public static int s_CameraRelativeRendering = (int)ShaderOptions.CameraRelativeRendering;

ScriptableRenderPipeline/HDRenderPipeline/ShaderConfig.cs.hlsl

 // UnityEngine.Experimental.Rendering.HDPipeline.ShaderOptions:  static fields
 //
 #define SHADEROPTIONS_VELOCITY_IN_GBUFFER (0)
-#define SHADEROPTIONS_PACK_GBUFFER_IN_U16 (0)
 #define SHADEROPTIONS_CAMERA_RELATIVE_RENDERING (1)