HDRenderPipeline: Move all are LTC data in one texture2DArray

Required to save ressource index for PS4 until playstation platform team
fix the issue of limited resource (16 texture + compute buffer)

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.cs

             private Material      m_InitPreFGD;
             private RenderTexture m_PreIntegratedFGD;
 
-            // For area lighting
-            private Texture2D m_LtcGGXMatrix;                    // RGBA
-            private Texture2D m_LtcDisneyDiffuseMatrix;          // RGBA
-            private Texture2D m_LtcMultiGGXFresnelDisneyDiffuse; // RGB, A unused
+            // For area lighting - We pack all texture inside a texture array to reduce the number of resource required
+            private Texture2DArray m_LtcData; // 0: m_LtcGGXMatrix - RGBA, 2: m_LtcDisneyDiffuseMatrix - RGBA, 3: m_LtcMultiGGXFresnelDisneyDiffuse - RGB, A unused
-            Texture2D CreateLUT(int width, int height, TextureFormat format, Color[] pixels)
-            {
-                Texture2D tex = new Texture2D(width, height, format, false /*mipmap*/, true /*linear*/);
-                tex.hideFlags = HideFlags.HideAndDontSave;
-                tex.wrapMode = TextureWrapMode.Clamp;
-                tex.filterMode = FilterMode.Bilinear;
-                tex.SetPixels(pixels);
-                tex.Apply();
-                return tex;
-            }
-            Texture2D LoadLUT(TextureFormat format, float[] LUTScalar)
+            void LoadLUT(Texture2DArray tex, int arrayElement, TextureFormat format, float[] LUTScalar)
             {
                 const int count = k_LtcLUTResolution * k_LtcLUTResolution;
                 Color[] pixels = new Color[count];
                     pixels[i] = new Color(0, 0, 0, LUTScalar[i]);
                 }
 
-                return CreateLUT(k_LtcLUTResolution, k_LtcLUTResolution, format, pixels);
+                tex.SetPixels(pixels, arrayElement);
-            Texture2D LoadLUT(TextureFormat format, double[,] LUTTransformInv)
+            void LoadLUT(Texture2DArray tex, int arrayElement, TextureFormat format, double[,] LUTTransformInv)
             {
                 const int count = k_LtcLUTResolution * k_LtcLUTResolution;
                 Color[] pixels = new Color[count];
                                           (float)LUTTransformInv[i, 6]);
                 }
 
-                return CreateLUT(k_LtcLUTResolution, k_LtcLUTResolution, format, pixels);
+                tex.SetPixels(pixels, arrayElement);
-            Texture2D LoadLUT(TextureFormat format, float[] LtcGGXMagnitudeData,
-                                                    float[] LtcGGXFresnelData,
-                                                    float[] LtcDisneyDiffuseMagnitudeData)
+            void LoadLUT(Texture2DArray tex, int arrayElement, TextureFormat format,   float[] LtcGGXMagnitudeData,
+                                                                                        float[] LtcGGXFresnelData,
+                                                                                        float[] LtcDisneyDiffuseMagnitudeData)
             {
                 const int count = k_LtcLUTResolution * k_LtcLUTResolution;
                 Color[] pixels = new Color[count];
                                           LtcGGXFresnelData[i], LtcDisneyDiffuseMagnitudeData[i], 1);
                 }
 
-                return CreateLUT(k_LtcLUTResolution, k_LtcLUTResolution, format, pixels);
+                tex.SetPixels(pixels, arrayElement);
             }
 
             public void Build()
                 m_PreIntegratedFGD.wrapMode = TextureWrapMode.Clamp;
                 m_PreIntegratedFGD.Create();
 
-                m_LtcGGXMatrix                    = LoadLUT(TextureFormat.RGBAHalf, s_LtcGGXMatrixData);
-                m_LtcDisneyDiffuseMatrix          = LoadLUT(TextureFormat.RGBAHalf, s_LtcDisneyDiffuseMatrixData);
+                m_LtcData = new Texture2DArray(k_LtcLUTResolution, k_LtcLUTResolution, 3, TextureFormat.RGBAHalf, false /*mipmap*/, true /* linear */)
+                {
+                    hideFlags = HideFlags.HideAndDontSave,
+                    wrapMode = TextureWrapMode.Clamp,
+                    filterMode = FilterMode.Bilinear
+                };
+
+                LoadLUT(m_LtcData, 0, TextureFormat.RGBAHalf,   s_LtcGGXMatrixData);
+                LoadLUT(m_LtcData, 1, TextureFormat.RGBAHalf,   s_LtcDisneyDiffuseMatrixData);
-                m_LtcMultiGGXFresnelDisneyDiffuse = LoadLUT(TextureFormat.RGBAHalf, s_LtcGGXMagnitudeData,
-                                                                                    s_LtcGGXFresnelData,
-                                                                                    s_LtcDisneyDiffuseMagnitudeData);
+                LoadLUT(m_LtcData, 2, TextureFormat.RGBAHalf,   s_LtcGGXMagnitudeData, s_LtcGGXFresnelData, s_LtcDisneyDiffuseMagnitudeData);
+
+                m_LtcData.Apply();
 
                 isInit = false;
             }
 
             public void Bind()
             {
-                Shader.SetGlobalTexture("_PreIntegratedFGD",                m_PreIntegratedFGD);
-                Shader.SetGlobalTexture("_LtcGGXMatrix",                    m_LtcGGXMatrix);
-                Shader.SetGlobalTexture("_LtcDisneyDiffuseMatrix",          m_LtcDisneyDiffuseMatrix);
-                Shader.SetGlobalTexture("_LtcMultiGGXFresnelDisneyDiffuse", m_LtcMultiGGXFresnelDisneyDiffuse);
+                Shader.SetGlobalTexture("_PreIntegratedFGD", m_PreIntegratedFGD);
+                Shader.SetGlobalTexture("_LtcData", m_LtcData);
             }
         }
     }

Assets/ScriptableRenderLoop/HDRenderPipeline/Material/Lit/Lit.hlsl

 // TODO: Check if anisotropy with a dynamic if on anisotropy > 0 is performant. Because it may mean we always calculate both isotropy and anisotropy case.
 // Maybe we should always calculate anisotropy in case of standard ? Don't think the compile can optimize correctly.
 
-// TODO: I haven't configure this sampler in the code, we should be able to do it (but Unity don't allow it for now...)
-// By default Unity provide MIG_MAG_LINEAR_POINT sampler, so it fit with our need.
-// TODO: to avoid the message Fragment program 'Frag' : sampler 'sampler_PreIntegratedFGD' has no matching texture and will be undefined.
-// We need to test this define LIGHTLOOP_TILE_DIRECT, this is a bad workaround but no alternative until we can setup sampler correctly...
-#if defined(LIT_DISPLAY_REFERENCE_IBL) || defined(LIGHTLOOP_TILE_DIRECT)
-// When reference mode is enabled, then we need to chose another sampler not related to cubemap code...
-SAMPLER2D(sampler_LtcGGXMatrix);
-#define SRL_BilinearSampler sampler_LtcGGXMatrix // Used for all textures
-#else
-SAMPLER2D(sampler_PreIntegratedFGD);
-#define SRL_BilinearSampler sampler_PreIntegratedFGD // Used for all textures
-#endif
-
+// TODO: we can share the sampler here and name it SRL_BilinearSampler. However Unity currently doesn't support to set sampler in C#
+// + to avoid the message Fragment program 'Frag' : sampler 'sampler_PreIntegratedFGD' has no matching texture and will be undefined.
-TEXTURE2D(_LtcGGXMatrix);                    // RGBA
-TEXTURE2D(_LtcDisneyDiffuseMatrix);          // RGBA
-TEXTURE2D(_LtcMultiGGXFresnelDisneyDiffuse); // RGB, A unused
+SAMPLER2D(sampler_PreIntegratedFGD);
+TEXTURE2D_ARRAY(_LtcData); // We pack the 3 Ltc data inside a texture array
+SAMPLER2D(sampler_LtcData);
+#define LTC_GGX_MATRIX_INDEX 0 // RGBA
+#define LTC_DISNEY_DIFFUSE_MATRIX_INDEX 1 // RGBA
+#define LTC_MULTI_GGX_FRESNEL_DISNEY_DIFFUSE_INDEX 2 // RGB, A unused
 
 //-----------------------------------------------------------------------------
 // Helper functions/variable specific to this material
     //  _PreIntegratedFGD.y = Gv * Fc
     // Pre integrate DisneyDiffuse FGD:
     // _PreIntegratedFGD.z = DisneyDiffuse
-    float3 preFGD = SAMPLE_TEXTURE2D_LOD(_PreIntegratedFGD, SRL_BilinearSampler, float2(NdotV, perceptualRoughness), 0).xyz;
+    float3 preFGD = SAMPLE_TEXTURE2D_LOD(_PreIntegratedFGD, sampler_PreIntegratedFGD, float2(NdotV, perceptualRoughness), 0).xyz;
 
     // f0 * Gv * (1 - Fc) + Gv * Fc
     specularFGD = fresnel0 * preFGD.x + preFGD.y;
     // Note we load the matrix transpose (avoid to have to transpose it in shader)
     preLightData.ltcXformGGX      = 0.0;
     preLightData.ltcXformGGX._m22 = 1.0;
-    preLightData.ltcXformGGX._m00_m02_m11_m20 = SAMPLE_TEXTURE2D_LOD(_LtcGGXMatrix, SRL_BilinearSampler, uv, 0);
+    preLightData.ltcXformGGX._m00_m02_m11_m20 = SAMPLE_TEXTURE2D_ARRAY_LOD(_LtcData, sampler_LtcData, uv, LTC_GGX_MATRIX_INDEX, 0);
-    preLightData.ltcXformDisneyDiffuse._m00_m02_m11_m20 = SAMPLE_TEXTURE2D_LOD(_LtcDisneyDiffuseMatrix, SRL_BilinearSampler, uv, 0);
+    preLightData.ltcXformDisneyDiffuse._m00_m02_m11_m20 = SAMPLE_TEXTURE2D_ARRAY_LOD(_LtcData, sampler_LtcData, uv, LTC_DISNEY_DIFFUSE_MATRIX_INDEX, 0);
-    float3 ltcMagnitude = SAMPLE_TEXTURE2D_LOD(_LtcMultiGGXFresnelDisneyDiffuse, SRL_BilinearSampler, uv, 0).r;
+    float3 ltcMagnitude = SAMPLE_TEXTURE2D_ARRAY_LOD(_LtcData, sampler_LtcData, uv, LTC_MULTI_GGX_FRESNEL_DISNEY_DIFFUSE_INDEX, 0).rgb;
     preLightData.ltcGGXFresnelMagnitudeDiff = ltcMagnitude.r;
     preLightData.ltcGGXFresnelMagnitude     = ltcMagnitude.g;
     preLightData.ltcDisneyDiffuseMagnitude  = ltcMagnitude.b;

ProjectSettings/ProjectVersion.txt

-m_EditorVersion: 5.6.0b5
+m_EditorVersion: 5.6.0b6