(wip) Added planar convolution

ScriptableRenderPipeline/Core/CoreRP/CoreResources/TexturePadding.cs

             m_KMainTop          = m_CS.FindKernel("KMainTop");
             m_KMainRight        = m_CS.FindKernel("KMainRight");
         }
-        public void Pad(CommandBuffer cmd, RTHandle source, RectInt from, RectInt to)
+        public void Pad(CommandBuffer cmd, RenderTexture source, RectInt from, RectInt to)
         {
             if (from.width < to.width)
             {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

 
             m_Asset = asset;
             m_GPUCopy = new GPUCopy(asset.renderPipelineResources.copyChannelCS);
-            m_BufferPyramid = new BufferPyramid(
+            var bufferPyramidProcessor = new BufferPyramidProcessor(
-            ); 
+            );
+            m_BufferPyramid = new BufferPyramid(bufferPyramidProcessor); 
 
             EncodeBC6H.DefaultInstance = EncodeBC6H.DefaultInstance ?? new EncodeBC6H(asset.renderPipelineResources.encodeBC6HCS);
 
 
             m_MaterialList.ForEach(material => material.Build(asset));
 
-            m_IBLFilterGGX = new IBLFilterGGX(asset.renderPipelineResources);
+            m_IBLFilterGGX = new IBLFilterGGX(asset.renderPipelineResources, bufferPyramidProcessor);
 
             m_LightLoop.Build(asset, m_ShadowSettings, m_IBLFilterGGX);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoopDef.hlsl

             //_Env2DCaptureVP is in capture space
             float3 ndc = ComputeNormalizedDeviceCoordinatesWithZ(texCoord, _Env2DCaptureVP[index]);
 
-            color.rgb = SAMPLE_TEXTURE2D_ARRAY_LOD(_Env2DTextures, s_trilinear_clamp_sampler, ndc.xy, index, 0).rgb;
+            color.rgb = SAMPLE_TEXTURE2D_ARRAY_LOD(_Env2DTextures, s_trilinear_clamp_sampler, ndc.xy, index, lod).rgb;
             color.a = any(ndc.xyz < 0) || any(ndc.xyz > 1) ? 0.0 : 1.0;
             
 #ifdef DEBUG_DISPLAY

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/GGXConvolution/RuntimeFilterIBL.cs

 using UnityEngine.Rendering;
 using System;
+using System.Collections.Generic;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
 
 
         RenderPipelineResources m_RenderPipelineResources;
+        BufferPyramidProcessor m_BufferPyramidProcessor;
+        List<RenderTexture> m_PlanarColorMips = new List<RenderTexture>();
-        public IBLFilterGGX(RenderPipelineResources renderPipelineResources)
+        public IBLFilterGGX(RenderPipelineResources renderPipelineResources, BufferPyramidProcessor processor)
+            m_BufferPyramidProcessor = processor;
         }
 
         public bool IsInitialized()
         {
             CoreUtils.Destroy(m_GgxConvolveMaterial);
             CoreUtils.Destroy(m_GgxIblSampleData);
+            for (var i = 0; i < m_PlanarColorMips.Count; ++i)
+                m_PlanarColorMips[i].Release();
+            m_PlanarColorMips.Clear();
         }
 
         void FilterCubemapCommon(   CommandBuffer cmd,
 
         public void FilterPlanarTexture(CommandBuffer cmd, Texture source, RenderTexture target)
         {
-            // TODO: planar convolution
-            cmd.CopyTexture(source, 0, 0, target, 0, 0);
+            var lodCount = Mathf.Max(Mathf.FloorToInt(Mathf.Log(Mathf.Min(source.width, source.height), 2f)) - 3, 0);
+
+            for (var i = 0 ; i < lodCount; ++i)
+            {
+                var width = target.width >> i;
+                var height = target.height >> i;
+                var rtHash = HashRenderTextureProperties(
+                    width,
+                    height,
+                    target.depth,
+                    target.format,
+                    target.sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear
+                );
+
+                var lodIsMissing = i >= m_PlanarColorMips.Count;
+                RenderTexture rt = null;
+                var createRT = lodIsMissing 
+                    || (rt = m_PlanarColorMips[i]) == null
+                    || rtHash != HashRenderTextureProperties(
+                        rt.width, rt.height, rt.depth, rt.format, rt.sRGB
+                            ? RenderTextureReadWrite.sRGB 
+                            : RenderTextureReadWrite.Linear
+                    );
+
+                if (createRT && rt)
+                    rt.Release();
+                if (createRT)
+                {
+                    rt = new RenderTexture(
+                        width,
+                        height,
+                        target.depth,
+                        target.format,
+                        target.sRGB ? RenderTextureReadWrite.sRGB : RenderTextureReadWrite.Linear
+                    );
+                    rt.name = "Planar Convolution Tmp RT";
+                    rt.hideFlags = HideFlags.HideAndDontSave;
+                    rt.Create();
+                }
+                if (lodIsMissing)
+                    m_PlanarColorMips.Add(rt);
+                else if (createRT)
+                    m_PlanarColorMips[i] = rt;
+            }
+
+            m_BufferPyramidProcessor.RenderColorPyramid(
+                new RectInt(0, 0, source.width, source.height),
+                cmd,
+                source,
+                target,
+                m_PlanarColorMips,
+                lodCount
+            );
         }
 
         // Filters MIP map levels (other than 0) with GGX using multiple importance sampling.
             m_GgxConvolveMaterial.SetTexture("_MarginalRowDensities", marginalRowCdf);
 
             FilterCubemapCommon(cmd, source, target, m_faceWorldToViewMatrixMatrices);
+        }
+
+        int HashRenderTextureProperties(
+            int width, 
+            int height,
+            int depth, 
+            RenderTextureFormat format, 
+            RenderTextureReadWrite sRGB)
+        {
+            return  width.GetHashCode()
+                  ^ height.GetHashCode()
+                  ^ depth.GetHashCode()
+                  ^ format.GetHashCode()
+                  ^ sRGB.GetHashCode();
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/BufferPyramid.cs

 
         BufferPyramidProcessor m_Processor;
 
-        public BufferPyramid(
-            ComputeShader colorPyramidCS,
-            ComputeShader depthPyramidCS, 
-            GPUCopy gpuCopy,
-            TexturePadding texturePadding
-        )
+        public BufferPyramid(BufferPyramidProcessor processor)
-            m_Processor = new BufferPyramidProcessor(
-                colorPyramidCS,
-                depthPyramidCS,
-                gpuCopy,
-                texturePadding
-            );
+            m_Processor = processor;
         }
 
         float GetXRscale()

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/BufferPyramidProcessor.cs

 using System.Collections.Generic;
+using UnityEngine.Assertions;
-    class BufferPyramidProcessor
+    public class BufferPyramidProcessor
     {
         static readonly int _Size = Shader.PropertyToID("_Size");
         static readonly int _Source = Shader.PropertyToID("_Source");
         int[] m_DepthKernels = null;
         int depthKernel8 { get { return m_DepthKernels[0]; } }
         int depthKernel1 { get { return m_DepthKernels[1]; } }
+
+        List<RenderTexture> m_RenderColorPyramid_CastTmp = new List<RenderTexture>();
 
         public BufferPyramidProcessor(
             ComputeShader colorPyramidCS,
             // Other BlitCameraTexture version will setup the viewport based on the destination RT scale (square here) so we need override it here.
             HDUtils.BlitCameraTexture(cmd, hdCamera, sourceTexture, targetTexture, new Rect(0.0f, 0.0f, hdCamera.actualWidth, hdCamera.actualHeight));
 
+            m_RenderColorPyramid_CastTmp.Clear();
+            for (var i = 0 ; i < mips.Count; ++i)
+                m_RenderColorPyramid_CastTmp.Add(mips[i]);
-                hdCamera.actualWidth, hdCamera.actualHeight,
+                new RectInt(0, 0, hdCamera.actualWidth, hdCamera.actualHeight),
-                sourceTexture,
-                mips,
+                m_RenderColorPyramid_CastTmp,
                 lodCount,
                 scale
             );
-            int width, int height,
+            RectInt srcRect,
-            RTHandle sourceTexture,
-            RTHandle targetTexture,
-            List<RTHandle> mips,
-            int lodCount,
-            Vector2 scale
+            Texture sourceTexture,
+            RenderTexture targetTexture,
+            List<RenderTexture> mips,
+            int lodCount
-            // Copy mip 0
-            HDUtils.BlitTexture(cmd, sourceTexture, targetTexture, scale, 0, false);
+            Assert.AreEqual(0, srcRect.x, "Offset are not supported");
+            Assert.AreEqual(0, srcRect.y, "Offset are not supported");
+            Assert.IsTrue(srcRect.width > 0);
+            Assert.IsTrue(srcRect.height > 0);
+
+            var scale = new Vector2(
+                sourceTexture.width / (float)srcRect.width,
+                sourceTexture.height / (float)srcRect.height
+            );
+
+            cmd.Blit(sourceTexture, targetTexture, scale, Vector2.zero);
-                width, height,
+                srcRect,
-                sourceTexture,
                 targetTexture,
                 mips,
                 lodCount,
 
         void RenderColorPyramidMips(
-            int width, int height,
+            RectInt srcRect,
-            RTHandle sourceTexture,
-            RTHandle targetTexture,
-            List<RTHandle> mips,
+            RenderTexture targetTexture,
+            List<RenderTexture> mips,
-            RTHandle src = targetTexture;
+            Assert.AreEqual(0, srcRect.x, "Offset are not supported");
+            Assert.AreEqual(0, srcRect.y, "Offset are not supported");
+            Assert.IsTrue(srcRect.width > 0);
+            Assert.IsTrue(srcRect.height > 0);
+
+            var src = targetTexture;
-                RTHandle dest = mips[i];
+                var dest = mips[i];
-                var srcMip = new RectInt(0, 0, width >> i, height >> i);
+                var srcMip = new RectInt(0, 0, srcRect.width >> i, srcRect.height >> i);
                 var dstMip = new RectInt(0, 0, srcMip.width >> 1, srcMip.height >> 1);
                 var srcWorkMip = new RectInt(
                     0, 
                 cmd.SetComputeVectorParam(
                     m_ColorPyramidCS, 
                     _Size, 
-                    new Vector4(dest.rt.width, dest.rt.height, 1f / dest.rt.width, 1f / dest.rt.height)
+                    new Vector4(dest.width, dest.height, 1f / dest.width, 1f / dest.height)
                 );
                 cmd.DispatchCompute(
                     m_ColorPyramidCS,
                     1
                 );
 
-                var dstMipWidthToCopy = Mathf.Min(dest.rt.width, dstWorkMip.width);
-                var dstMipHeightToCopy = Mathf.Min(dest.rt.height, dstWorkMip.height);
+                var dstMipWidthToCopy = Mathf.Min(dest.width, dstWorkMip.width);
+                var dstMipHeightToCopy = Mathf.Min(dest.height, dstWorkMip.height);
 
                 // If we could bind texture mips as UAV we could avoid this copy...(which moreover copies more than the needed viewport if not fullscreen)
                 cmd.CopyTexture(