HDRenderLoop: Test about packing all GBufer in two RT U16

This will not work for now but allow to stress the design in some comple
case. May be remove later or adapted

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Lighting/Deferred.shader

 
             #include "Common.hlsl"
 
-            // CAUTION: In case deferred lighting need to support various lighting model statically, we will require to do multicompile with different define like UNITY_MATERIAL_DISNEYGXX
-            // TODO: Currently a users that add a new deferred material must also add it manually here... Need to think about it. Maybe add a multicompile inside a file in Material directory to include here ?
+            // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
+            // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem), 
+            // the deferred shader will require to use multicompile.
             #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
             #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs.hlsl"
             #include "Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderVariables.hlsl"

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/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.PackgbufferInFP16 == 1) ? 2 : 4
+            Count = (ShaderConfig.PackgbufferInU16 == 1) ? 2 : 4
         };
 
         public class RenderLoop : Object
                 RTReadWrite = new RenderTextureReadWrite[(int)GBufferMaterial.Count];
 
 #pragma warning disable 162 // warning CS0162: Unreachable code detected
-                if (ShaderConfig.PackgbufferInFP16 == 1)
+                if (ShaderConfig.PackgbufferInU16 == 1)
-                    RTFormat[0] = RenderTextureFormat.ARGBHalf; RTReadWrite[0] = RenderTextureReadWrite.Linear;
-                    RTFormat[1] = RenderTextureFormat.ARGBHalf; RTReadWrite[1] = RenderTextureReadWrite.Linear;
+                    RTFormat[0] = RenderTextureFormat.ARGBInt; RTReadWrite[0] = RenderTextureReadWrite.Linear;
+                    RTFormat[1] = RenderTextureFormat.ARGBInt; RTReadWrite[1] = RenderTextureReadWrite.Linear;
                 }
                 else
                 {

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Lit/Lit.hlsl

 // SurfaceData is define in Lit.cs which generate Lit.cs.hlsl
 #include "Lit.cs.hlsl"
 
+// 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_PS4
+// 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
+#define GBufferType0 float4
+#define GBufferType1 float4
+#define GBufferType2 float4
+#define GBufferType3 float4
+#endif
+
 // Reference Lambert diffuse / GGX Specular for IBL and area lights
 // #define LIT_DISPLAY_REFERENCE
 // Use Lambert diffuse instead of Disney diffuse
 // Must be in sync with RT declared in HDRenderLoop.cs ::Rebuild
 void EncodeIntoGBuffer( SurfaceData surfaceData,
                         float3 bakeDiffuseLighting,
-                        out float4 outGBuffer0,
-                        out float4 outGBuffer1,
-                        out float4 outGBuffer2,
-                        out float4 outGBuffer3)
+                        #if SHADEROPTIONS_PACK_GBUFFER_IN_U16
+                        out GBufferType0 outGBufferU0,
+                        out GBufferType1 outGBufferU1
+                        #else
+                        out GBufferType0 outGBuffer0,
+                        out GBufferType1 outGBuffer1,
+                        out GBufferType2 outGBuffer2,
+                        out GBufferType3 outGBuffer3
+                        #endif
+                        )
+    #if SHADEROPTIONS_PACK_GBUFFER_IN_U16
+    float4 outGBuffer0, outGBuffer1, outGBuffer2, outGBuffer3;
+    #endif
+
     // RT0 - 8:8:8:8 sRGB
     outGBuffer0 = float4(surfaceData.baseColor, surfaceData.specularOcclusion);
 
 
     // Lighting
     outGBuffer3 = float4(bakeDiffuseLighting, 0.0);
+
+    #if SHADEROPTIONS_PACK_GBUFFER_IN_U16
+    // Now pack all buffer into 2 uint buffer
+    // TODO: should be more efficient to pack data directly in uint format rather than going through outGBuffer but easier to maintain in case of change
+
+    // We don't have hardware sRGB, so just sqrt the baseColor value instead
+    data.outGBuffer0.xyz = sqrt(data.outGBuffer0.xyz);
+
+    uint outGBuffer0X = uint(saturate(data.outGBuffer0.x) * 255.5);
+    uint outGBuffer0Y = uint(saturate(data.outGBuffer0.y) * 255.5);
+    uint outGBuffer0Z = uint(saturate(data.outGBuffer0.z) * 255.5);
+    uint outGBuffer0W = uint(saturate(data.outGBuffer0.w) * 255.5);
+
+    outGBufferU0 = uint4(   PackFloatToUInt(outGBuffer1.x, 10, 0) | PackFloatToUInt(outGBuffer1.w, 2, 10) | PackNUpperbitFromU8(outGBuffer0Z, 2, 12) | PackNUpperbitFromU8(outGBuffer0W, 2, 14),
+                            PackFloatToUInt(outGBuffer1.y, 10, 0) | PackNLowerbitFromU8(outGBuffer0Z, 6, 10),
+                            PackFloatToUInt(outGBuffer1.z, 10, 0) | PackNLowerbitFromU8(outGBuffer0W, 6, 10),
+                            outGBuffer0X | outGBuffer0Y << 8
+                        );
+
+    uint outGBuffer2X = uint(saturate(data.outGBuffer2.x) * 255.5);
+    uint outGBuffer2Y = uint(saturate(data.outGBuffer2.y) * 255.5);
+    uint outGBuffer2Z = uint(saturate(data.outGBuffer2.z) * 255.5);
+    uint outGBuffer2W = uint(saturate(data.outGBuffer2.w) * 255.5);
+
+    // TODO: This doesn't work for lighting buffer as the encoded format is float. i.e it mean that we must convert first to 111110Float format (TODO: Look at the code maybe not so expensive ?)
+    // before storing as uint the binary representation. Alternative is to use RGBM/LogLuv.
+    outGBufferU1 = uint4(   PackFloatToUInt(outGBuffer3.x, 11, 0) | PackNUpperbitFromU8(outGBuffer2Z, 3, 11) | PackNUpperbitFromU8(outGBuffer2W, 2, 14),
+                            PackFloatToUInt(outGBuffer3.z, 11, 0) | PackNLowerbitFromU8(outGBuffer2Z, 5, 11),
+                            PackFloatToUInt(outGBuffer3.x, 10, 0) | PackNLowerbitFromU8(outGBuffer2W, 6, 10),
+                            outGBuffer2X | outGBuffer2Y << 8
+                        );
+    #endif
-void DecodeFromGBuffer( float4 inGBuffer0,
-                        float4 inGBuffer1,
-                        float4 inGBuffer2,
-                        float4 inGBuffer3,
+void DecodeFromGBuffer( 
+                        #if SHADEROPTIONS_PACK_GBUFFER_IN_U16
+                        GBufferType0 inGBufferU0,
+                        GBufferType1 inGBufferU1,
+                        #else
+                        GBufferType0 inGBuffer0,
+                        GBufferType1 inGBuffer1,
+                        GBufferType2 inGBuffer2,
+                        GBufferType3 inGBuffer3,
+                        #endif
+
+    #if SHADEROPTIONS_PACK_GBUFFER_IN_U16
+    float4 inGBuffer0, inGBuffer1, inGBuffer2, inGBuffer3;
+    
+    inGBuffer0.x = UnpackUIntToFloat(inGBufferU0.w, 8, 0);
+    inGBuffer0.y = UnpackUIntToFloat(inGBufferU0.w, 8, 8);
+    inGBuffer0.z = (UnpackNLowerbitFromU8(inGBufferU1.y, 6, 10) | UnpackNUpperbitFromU8(inGBufferU1.x, 2, 12)) / 255.0;
+    inGBuffer0.w = (UnpackNLowerbitFromU8(inGBufferU1.z, 6, 10) | UnpackNUpperbitFromU8(inGBufferU1.x, 2, 14)) / 255.0;
+
+    inGBuffer1.x = UnpackUIntToFloat(inGBufferU0.x, 10, 0);
+    inGBuffer1.y = UnpackUIntToFloat(inGBufferU0.y, 10, 0);
+    inGBuffer1.z = UnpackUIntToFloat(inGBufferU0.z, 10, 0);
+    inGBuffer1.w = UnpackUIntToFloat(inGBufferU0.x, 2, 10);
+    
+    inGBuffer2.x = UnpackUIntToFloat(inGBufferU1.w, 8, 0);
+    inGBuffer2.y = UnpackUIntToFloat(inGBufferU1.w, 8, 8);
+    inGBuffer2.z = (UnpackNLowerbitFromU8(inGBufferU1.y, 5, 11) | UnpackNUpperbitFromU8(inGBufferU1.x, 3, 11)) / 255.0;
+    inGBuffer2.w = (UnpackNLowerbitFromU8(inGBufferU1.z, 6, 10) | UnpackNUpperbitFromU8(inGBufferU1.x, 2, 14)) / 255.0;
+
+    inGBuffer3.x = UnpackUIntToFloat(inGBufferU1.x, 11, 0);
+    inGBuffer3.y = UnpackUIntToFloat(inGBufferU1.y, 11, 0);
+    inGBuffer3.z = UnpackUIntToFloat(inGBufferU1.z, 10, 0);
+    inGBuffer3.w = 0.0;
+    #endif
 
     float3 baseColor = inGBuffer0.rgb;
     bsdfData.specularOcclusion = inGBuffer0.a;

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/Material/Material.hlsl

 #if GBUFFERMATERIAL_COUNT == 2
 
 #define OUTPUT_GBUFFER(NAME)                            \
-        out float4 MERGE_NAME(NAME, 0) : SV_Target0,    \
-        out float4 MERGE_NAME(NAME, 1) : SV_Target1
+        out GBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,    \
+        out GBufferType1 MERGE_NAME(NAME, 1) : SV_Target1
 
 #define DECLARE_GBUFFER_TEXTURE(NAME)   \
         TEXTURE2D(MERGE_NAME(NAME, 0));  \
-        float4 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
-        float4 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0));
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0));
 
 #define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1))
 #define DECODE_FROM_GBUFFER(NAME, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
 #elif GBUFFERMATERIAL_COUNT == 3
 
 #define OUTPUT_GBUFFER(NAME)                            \
-        out float4 MERGE_NAME(NAME, 0) : SV_Target0,    \
-        out float4 MERGE_NAME(NAME, 1) : SV_Target1,    \
-        out float4 MERGE_NAME(NAME, 2) : SV_Target2
+        out GBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,    \
+        out GBufferType1 MERGE_NAME(NAME, 1) : SV_Target1,    \
+        out GBufferType2 MERGE_NAME(NAME, 2) : SV_Target2
 
 #define DECLARE_GBUFFER_TEXTURE(NAME)   \
         TEXTURE2D(MERGE_NAME(NAME, 0));  \
 #define FETCH_GBUFFER(NAME, TEX, UV)                                        \
-        float4 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
-        float4 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0)); \
-        float4 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), uint3(UV, 0));
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0)); \
+        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), uint3(UV, 0));
 
 #define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2))
 #define DECODE_FROM_GBUFFER(NAME, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME,0), MERGE_NAME(NAME,1), MERGE_NAME(NAME,2), BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
 #elif GBUFFERMATERIAL_COUNT == 4
 
 #define OUTPUT_GBUFFER(NAME)                            \
-        out float4 MERGE_NAME(NAME, 0) : SV_Target0,    \
-        out float4 MERGE_NAME(NAME, 1) : SV_Target1,    \
-        out float4 MERGE_NAME(NAME, 2) : SV_Target2,    \
-        out float4 MERGE_NAME(NAME, 3) : SV_Target3
+        out GBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,    \
+        out GBufferType1 MERGE_NAME(NAME, 1) : SV_Target1,    \
+        out GBufferType2 MERGE_NAME(NAME, 2) : SV_Target2,    \
+        out GBufferType3 MERGE_NAME(NAME, 3) : SV_Target3
 
 #define DECLARE_GBUFFER_TEXTURE(NAME)   \
         TEXTURE2D(MERGE_NAME(NAME, 0));  \
 
 #define FETCH_GBUFFER(NAME, TEX, UV)                                        \
-        float4 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
-        float4 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0)); \
-        float4 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), uint3(UV, 0)); \
-        float4 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), uint3(UV, 0));
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0)); \
+        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), uint3(UV, 0)); \
+        GBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), uint3(UV, 0));
 
 #define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3))
 #define DECODE_FROM_GBUFFER(NAME, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), BSDF_DATA, BAKE_DIFFUSE_LIGHTING)
 #elif GBUFFERMATERIAL_COUNT == 5
 
 #define OUTPUT_GBUFFER(NAME)                            \
-        out float4 MERGE_NAME(NAME, 0) : SV_Target0,    \
-        out float4 MERGE_NAME(NAME, 1) : SV_Target1,    \
-        out float4 MERGE_NAME(NAME, 2) : SV_Target2,    \
-        out float4 MERGE_NAME(NAME, 3) : SV_Target3,    \
-        out float4 MERGE_NAME(NAME, 4) : SV_Target4
+        out GBufferType0 MERGE_NAME(NAME, 0) : SV_Target0,    \
+        out GBufferType1 MERGE_NAME(NAME, 1) : SV_Target1,    \
+        out GBufferType2 MERGE_NAME(NAME, 2) : SV_Target2,    \
+        out GBufferType3 MERGE_NAME(NAME, 3) : SV_Target3,    \
+        out GBufferType4 MERGE_NAME(NAME, 4) : SV_Target4
 
 #define DECLARE_GBUFFER_TEXTURE(NAME)   \
         TEXTURE2D(MERGE_NAME(NAME, 0));  \
         TEXTURE2D(MERGE_NAME(NAME, 4));
 
 #define FETCH_GBUFFER(NAME, TEX, UV)                                        \
-        float4 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
-        float4 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0)); \
-        float4 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), uint3(UV, 0)); \
-        float4 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), uint3(UV, 0)); \
-        float4 MERGE_NAME(NAME, 4) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 4), uint3(UV, 0));
+        GBufferType0 MERGE_NAME(NAME, 0) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 0), uint3(UV, 0)); \
+        GBufferType1 MERGE_NAME(NAME, 1) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 1), uint3(UV, 0)); \
+        GBufferType2 MERGE_NAME(NAME, 2) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 2), uint3(UV, 0)); \
+        GBufferType3 MERGE_NAME(NAME, 3) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 3), uint3(UV, 0)); \
+        GBufferType4 MERGE_NAME(NAME, 4) = LOAD_TEXTURE2D(MERGE_NAME(TEX, 4), uint3(UV, 0));
 
 #define ENCODE_INTO_GBUFFER(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, NAME) EncodeIntoGBuffer(SURFACE_DATA, BAKE_DIFFUSE_LIGHTING, MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4))
 #define DECODE_FROM_GBUFFER(NAME, BSDF_DATA, BAKE_DIFFUSE_LIGHTING) DecodeFromGBuffer(MERGE_NAME(NAME, 0), MERGE_NAME(NAME, 1), MERGE_NAME(NAME, 2), MERGE_NAME(NAME, 3), MERGE_NAME(NAME, 4), BSDF_DATA, BAKE_DIFFUSE_LIGHTING)

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs

         // TODO: Currently it is not yet possible to use this feature, we need to provide previousPositionCS to the vertex shader as part of Attribute for GBuffer pass
         // TODO: How to enable this feature only on mesh that effectively require it like skinned and moving mesh (other can be done with depth reprojection. But TAA can be an issue)
         VelocityInGBuffer = 0, // Change to 1 to enable the feature
-        PackGBufferInFP16 = 0
+        PackGBufferInU16 = 0
     };
 
     // Note: #define can't be use in include file in C# so we choes this way to configure both C# and hlsl
         public const int VelocityInGbuffer = (int)ShaderOptions.VelocityInGBuffer;
-        public const int PackgbufferInFP16 = (int)ShaderOptions.PackGBufferInFP16;
+        public const int PackgbufferInU16 = (int)ShaderOptions.PackGBufferInU16;
     }
 }
 

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderConfig.cs.hlsl

 // UnityEngine.Experimental.ScriptableRenderLoop.ShaderOptions:  static fields
 //
 #define SHADEROPTIONS_VELOCITY_IN_GBUFFER (0)
-#define SHADEROPTIONS_PACK_GBUFFER_IN_FP16 (0)
+#define SHADEROPTIONS_PACK_GBUFFER_IN_U16 (0)
 
 
 #endif

Assets/ScriptableRenderLoop/HDRenderLoop/Shaders/ShaderPass/ShaderPassLightTransport.hlsl

     {
         // Apply diffuseColor Boost from LightmapSettings.
         // put abs here to silent a warning, no cost, no impact as color is assume to be positive.
-        res.rgb = clamp(pow(abs(lightTransportData.diffuseColor), saturate(unity_OneOverOutputBoost)), 0, unity_MaxOutputValue);
+        res.rgb = Clamp(pow(abs(lightTransportData.diffuseColor), saturate(unity_OneOverOutputBoost)), 0, unity_MaxOutputValue);
     }
     
     if (unity_MetaFragmentControl.y)

Assets/ScriptableRenderLoop/ShaderLibrary/AreaLighting.hlsl

 {
     float cosTheta = dot(v1, v2);
     // TODO: Explain the 0.9999 <= precision is important!
-    cosTheta = clamp(cosTheta, -0.9999, 0.9999);
+    cosTheta = Clamp(cosTheta, -0.9999, 0.9999);
 
     // TODO: Experiment with fastAcos
     float theta = acos(cosTheta);

Assets/ScriptableRenderLoop/ShaderLibrary/Common.hlsl

 #include "API/Validate.hlsl"
 
 // ----------------------------------------------------------------------------
+// Common intrinsic (general implementation of intrinsic available on some platform)
+// ----------------------------------------------------------------------------
+
+#ifndef INTRINSIC_BITFIELD_EXTRACT
+// unsigned integer bit field extract implementation
+uint BitFieldExtract(uint inData, uint inSize, uint inOffset)
+{
+    return (inData >> inOffset) & ((1u << inSize) - 1u);
+}
+#endif // INTRINSIC_BITFIELD_EXTRACT
+
+#ifndef INTRINSIC_CLAMP
+// TODO: should we force all clamp to be intrinsic by default ?
+// Some platform have one instruction clamp
+#define Clamp clamp
+#endif // INTRINSIC_CLAMP
+
+#ifndef INTRINSIC_MED3
+float Med3(float a, float b, float c)
+{
+    return Clamp(a, b, c);
+}
+#endif // INTRINSIC_MED3
+
+#ifndef INTRINSIC_MINMAX3
+float Min3(float a, float b, float c)
+{
+    return min(min(a, b), c);
+}
+
+float2 Min3(float2 a, float2 b, float2 c)
+{
+    return min(min(a, b), c);
+}
+
+float3 Min3(float3 a, float3 b, float3 c)
+{
+    return min(min(a, b), c);
+}
+
+float4 Min3(float4 a, float4 b, float4 c)
+{
+    return min(min(a, b), c);
+}
+
+float Max3(float a, float b, float c)
+{
+    return max(max(a, b), c);
+}
+
+float2 Max3(float2 a, float2 b, float2 c)
+{
+    return max(max(a, b), c);
+}
+
+float3 Max3(float3 a, float3 b, float3 c)
+{
+    return max(max(a, b), c);
+}
+
+float4 Max3(float4 a, float4 b, float4 c)
+{
+    return max(max(a, b), c);
+}
+#endif // INTRINSIC_MINMAX3
+
+#ifndef INTRINSIC_CUBEMAP_FACE_ID
+// TODO: implement this. Is the reference implementation of cubemapID provide by AMD the reverse of our ? 
+/*
+float CubemapFaceID(float3 dir)
+{
+    float faceID;
+    if (abs(dir.z) >= abs(dir.x) && abs(dir.z) >= abs(dir.y))
+    {
+        faceID = (dir.z < 0.0) ? 5.0 : 4.0;
+    }
+    else if (abs(dir.y) >= abs(dir.x))
+    {
+        faceID = (dir.y < 0.0) ? 3.0 : 2.0;
+    }
+    else
+    {
+        faceID = (dir.x < 0.0) ? 1.0 : 0.0;
+    }
+    return faceID;
+}
+*/
+#endif // INTRINSIC_CUBEMAP_FACE_ID
+
+#define CUBEMAPFACE_POSITIVE_X 0
+#define CUBEMAPFACE_NEGATIVE_X 1
+#define CUBEMAPFACE_POSITIVE_Y 2
+#define CUBEMAPFACE_NEGATIVE_Y 3
+#define CUBEMAPFACE_POSITIVE_Z 4
+#define CUBEMAPFACE_NEGATIVE_Z 5
+
+void GetCubeFaceID(float3 dir, out int faceIndex)
+{
+    // TODO: Use faceID intrinsic on console
+    float3 adir = abs(dir);
+
+    // +Z -Z
+    faceIndex = dir.z > 0.0f ? CUBEMAPFACE_NEGATIVE_Z : CUBEMAPFACE_POSITIVE_Z;
+
+    // +X -X
+    if (adir.x > adir.y && adir.x > adir.z)
+    {
+        faceIndex = dir.x > 0.0 ? CUBEMAPFACE_NEGATIVE_X : CUBEMAPFACE_POSITIVE_X;
+    }
+    // +Y -Y
+    else if (adir.y > adir.x && adir.y > adir.z)
+    {
+        faceIndex = dir.y > 0.0 ? CUBEMAPFACE_NEGATIVE_Y : CUBEMAPFACE_POSITIVE_Y;
+    }
+}
+
+// ----------------------------------------------------------------------------
 // Common math definition and fastmath function
 // ----------------------------------------------------------------------------
 
     N = normalize(N);
 
     return saturate(dot(N, V)); // TODO: this saturate should not be necessary here
-}
-
-// ----------------------------------------------------------------------------
-// Util cubemap
-// ----------------------------------------------------------------------------
-
-#define CUBEMAPFACE_POSITIVE_X 0
-#define CUBEMAPFACE_NEGATIVE_X 1
-#define CUBEMAPFACE_POSITIVE_Y 2
-#define CUBEMAPFACE_NEGATIVE_Y 3
-#define CUBEMAPFACE_POSITIVE_Z 4
-#define CUBEMAPFACE_NEGATIVE_Z 5
-
-void GetCubeFaceID(float3 dir, out int faceIndex)
-{
-    // TODO: Use faceID intrinsic on console
-    float3 adir = abs(dir);
-
-    // +Z -Z
-    faceIndex = dir.z > 0.0f ? CUBEMAPFACE_NEGATIVE_Z : CUBEMAPFACE_POSITIVE_Z;
-
-    // +X -X
-    if (adir.x > adir.y && adir.x > adir.z)
-    {
-        faceIndex = dir.x > 0.0 ? CUBEMAPFACE_NEGATIVE_X : CUBEMAPFACE_POSITIVE_X;
-    }
-    // +Y -Y
-    else if (adir.y > adir.x && adir.y > adir.z)
-    {
-        faceIndex = dir.y > 0.0 ? CUBEMAPFACE_NEGATIVE_Y : CUBEMAPFACE_POSITIVE_Y;
-    }
 }
 
 #endif // UNITY_COMMON_INCLUDED

Assets/ScriptableRenderLoop/ShaderLibrary/EntityLighting.hlsl

 	// but last one is not used.
 	// Clamp to edge of the "internal" texture, as R is from half texel to size of R texture minus half texel.
 	// This avoid leaking
-	texCoord.x = clamp(texCoord.x * 0.25, 0.5 * texelSizeX, 0.25 - 0.5 * texelSizeX);
+	texCoord.x = Clamp(texCoord.x * 0.25, 0.5 * texelSizeX, 0.25 - 0.5 * texelSizeX);
 
 	float4 shAr = SAMPLE_TEXTURE3D(SHVolumeTexture, SHVolumeSampler, texCoord);
 	texCoord.x += 0.25;

Assets/ScriptableRenderLoop/ShaderLibrary/ImageBasedLighting.hlsl

             // invOmegaP is precomputed on CPU and provide as a parameter of the function
             // float omegaP = FOUR_PI / (6.0f * cubemapWidth * cubemapWidth);   // Solid angle associated to a pixel of the cubemap
             // Clamp is not necessary as the hardware will do it.
-            // mipLevel     = clamp(0.5f * log2(omegaS * invOmegaP), 0, mipmapcount);
+            // mipLevel     = Clamp(0.5f * log2(omegaS * invOmegaP), 0, mipmapcount);
             mipLevel        = 0.5 * log2(omegaS * invOmegaP); // Clamp is not necessary as the hardware will do it.
         }
 

Assets/ScriptableRenderLoop/ShaderLibrary/Packing.hlsl

     UnpackFloatInt(val, maxi, 65536.0, f, i);
 }
 
+//-----------------------------------------------------------------------------
+// float packing to sint/uint
+//-----------------------------------------------------------------------------
+
+uint PackFloatToUInt(float src, uint size, uint offset)
+{
+    const uint MAX_VALUE = (1 << size) - 1;
+
+    return Clamp(uint(src * MAX_VALUE), uint(0), uint(MAX_VALUE)) << offset;
+}
+
+float UnpackUIntToFloat(uint src, uint size, uint offset)
+{
+    const uint MAX_VALUE = (1 << size) - 1;
+
+    return BitFieldExtract(src, size, offset) / float(MAX_VALUE);
+}
+
+uint PackNUpperbitFromU8(uint src, uint nbit, uint offset)
+{
+    return ( (src & (((1 << nbit) - 1) << (8 - nbit))) >> (8 - nbit) ) << offset;
+}
+
+uint PackNLowerbitFromU8(uint src, uint nbit, uint offset)
+{
+    return (src & ((1 << nbit) - 1)) << offset;
+}
+
+uint UnpackNUpperbitToU8(uint src, uint nbit, uint offset)
+{
+    return ((src & (((1 << nbit) - 1) << offset)) >> offset) << (8 - nbit);
+}
+
+uint UnpackNLowerbitToU8(uint src, uint nbit, uint offset)
+{
+    return (src & (((1 << nbit) - 1) << offset)) >> offset;
+}
+
+
 #endif // UNITY_PACKING_INCLUDED