Fixed depth pyramid buffer

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDAssetFactory.cs

                 newAsset.colorPyramidCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/ColorPyramid.compute");
                 newAsset.depthPyramidCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/DepthPyramid.compute");
                 newAsset.copyChannelCS = Load<ComputeShader>(CorePath + "CoreResources/GPUCopy.compute");
+                newAsset.texturePaddingCS = Load<ComputeShader>(CorePath + "CoreResources/TexturePadding.compute");
                 newAsset.applyDistortionCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/ApplyDistorsion.compute");
 
                 newAsset.clearDispatchIndirectShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/LightLoop/cleardispatchindirect.compute");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

             m_BufferPyramid = new BufferPyramid(
                 asset.renderPipelineResources.colorPyramidCS,
                 asset.renderPipelineResources.depthPyramidCS,
-                m_GPUCopy);
+                m_GPUCopy,
+                new TexturePadding(asset.renderPipelineResources.texturePaddingCS)
+            ); 
 
             EncodeBC6H.DefaultInstance = EncodeBC6H.DefaultInstance ?? new EncodeBC6H(asset.renderPipelineResources.encodeBC6HCS);
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipelineAsset.asset

       skyReflectionSize: 256
       skyLightingOverrideLayerMask:
         serializedVersion: 2
-        m_Bits: 256
+        m_Bits: 0
     shadowInitParams:
       shadowAtlasWidth: 4096
       shadowAtlasHeight: 4096

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/BufferPyramid.cs

         const int k_DepthBlockSize = 4;
 
         GPUCopy m_GPUCopy;
+        TexturePadding m_TexturePadding;
         ComputeShader m_ColorPyramidCS;
 
         RTHandle m_ColorPyramidBuffer;
         ComputeShader m_DepthPyramidCS;
         RTHandle m_DepthPyramidBuffer;
         List<RTHandle> m_DepthPyramidMips = new List<RTHandle>();
-        int m_DepthPyramidKernel_8;
-        int m_DepthPyramidKernel_1;
+        int[] m_DepthKernels = null;
+        int depthKernel8 { get { return m_DepthKernels[0]; } }
 
         public RTHandle colorPyramid { get { return m_ColorPyramidBuffer; } }
         public RTHandle depthPyramid { get { return m_DepthPyramidBuffer; } }
-            ComputeShader depthPyramidCS, GPUCopy gpuCopy)
+            ComputeShader depthPyramidCS, 
+            GPUCopy gpuCopy,
+            TexturePadding texturePadding
+        )
         {
             m_ColorPyramidCS = colorPyramidCS;
             m_ColorPyramidKernel = m_ColorPyramidCS.FindKernel("KMain");
-            m_DepthPyramidKernel_8 = m_DepthPyramidCS.FindKernel("KMain_8");
-            m_DepthPyramidKernel_1 = m_DepthPyramidCS.FindKernel("KMain_1");
+            m_DepthKernels = new int[]
+            {
+                m_DepthPyramidCS.FindKernel("KDepthDownSample8"),
+                m_DepthPyramidCS.FindKernel("KDepthDownSample2_0"),
+                m_DepthPyramidCS.FindKernel("KDepthDownSample2_1"),
+                m_DepthPyramidCS.FindKernel("KDepthDownSample2_2"),
+                m_DepthPyramidCS.FindKernel("KDepthDownSample2_3"),
+            };
+
+            m_TexturePadding = texturePadding;
+        }
+
+        int GetDepthKernel2(int pattern)
+        {
+            return m_DepthKernels[pattern + 1];
         }
 
         float GetXRscale()
 
             cmd.SetGlobalVector(HDShaderIDs._DepthPyramidMipSize, new Vector4(hdCamera.actualWidth, hdCamera.actualHeight, lodCount, 0.0f));
 
-            m_GPUCopy.SampleCopyChannel_xyzw2x(cmd, depthTexture, m_DepthPyramidBuffer, new Vector2(hdCamera.actualWidth, hdCamera.actualHeight));
+            m_GPUCopy.SampleCopyChannel_xyzw2x(cmd, depthTexture, m_DepthPyramidBuffer, new RectInt(0, 0, hdCamera.actualWidth, hdCamera.actualHeight));
 
             Vector2 scale = GetPyramidToScreenScale(hdCamera);
 
                 RTHandle dest = m_DepthPyramidMips[i];
 
-                var srcMipWidth = hdCamera.actualWidth >> i;
-                var srcMipHeight = hdCamera.actualHeight >> i;
-                var dstMipWidth = srcMipWidth >> 1;
-                var dstMipHeight = srcMipHeight >> 1;
+                var srcMip = new RectInt(0, 0, hdCamera.actualWidth >> i, hdCamera.actualHeight >> i);
+                var dstMip = new RectInt(0, 0, srcMip.width >> 1, srcMip.height >> 1);
-                var kernel = m_DepthPyramidKernel_8;
-                var kernelBlockSize = 8f;
-                if (dstMipWidth < 4 * k_DepthBlockSize
-                    || dstMipHeight < 4 * k_DepthBlockSize)
+                var kernel = GetDepthKernel2(0);
+                var kernelSize = 1;
+                var srcWorkMip = srcMip;
+                var dstWorkMip = dstMip;
+
+                if (dstWorkMip.width >= 8 && dstWorkMip.height >= 8)
-                    kernel = m_DepthPyramidKernel_1;
-                    kernelBlockSize = 1;
+                    srcWorkMip.width = Mathf.CeilToInt(srcWorkMip.width / 16.0f) * 16;
+                    srcWorkMip.height = Mathf.CeilToInt(srcWorkMip.height / 16.0f) * 16;
+                    dstWorkMip.width = srcWorkMip.width >> 1;
+                    dstWorkMip.height = srcWorkMip.height >> 1;
+
+                    m_TexturePadding.Pad(cmd, src, srcMip, srcWorkMip);
+                    kernel = depthKernel8;
+                    kernelSize = 8;
+                }
+                else
+                {
+                    m_TexturePadding.Pad(cmd, src, srcMip, new RectInt(0, 0, src.rt.width, src.rt.height));
-                cmd.SetComputeVectorParam(m_DepthPyramidCS, _SrcSize, new Vector4(srcMipWidth, srcMipHeight, (1.0f / srcMipWidth) * scale.x, (1.0f / srcMipHeight) * scale.y));
+                cmd.SetComputeVectorParam(m_DepthPyramidCS, _SrcSize, new Vector4(
+                    srcWorkMip.width, srcWorkMip.height, 
+                    (1.0f / srcWorkMip.width) * scale.x, (1.0f / srcWorkMip.height) * scale.y)
+                );
-                    Mathf.CeilToInt(dstMipWidth / kernelBlockSize),
-                    Mathf.CeilToInt(dstMipHeight / kernelBlockSize),
-                    1);
+                    Mathf.CeilToInt(dstWorkMip.width / (float)kernelSize),
+                    Mathf.CeilToInt(dstWorkMip.height / (float)kernelSize),
+                    1
+                );
+
+                var dstMipWidthToCopy = Mathf.Min(dest.rt.width, dstWorkMip.width);
+                var dstMipHeightToCopy = Mathf.Min(dest.rt.height, dstWorkMip.height);
-                cmd.CopyTexture(m_DepthPyramidMips[i], 0, 0, 0, 0, dstMipWidth, dstMipHeight, m_DepthPyramidBuffer, 0, i + 1, 0, 0);
+                cmd.CopyTexture(m_DepthPyramidMips[i], 0, 0, 0, 0, dstMipWidthToCopy, dstMipHeightToCopy, m_DepthPyramidBuffer, 0, i + 1, 0, 0);
                 src = dest;
             }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/DepthPyramid.compute

 #include "CoreRP/ShaderLibrary/Common.hlsl"
 
-#pragma kernel KMain_8                KERNEL_SIZE=8     KERNEL_NAME=KMain_8
-#pragma kernel KMain_1                KERNEL_SIZE=1     KERNEL_NAME=KMain_1
+// ------------------------------------------------
+// Algorithm
+// ------------------------------------------------
+// Downsample a depth texture by taking min value of sampled pixels
+// It also handles computing in a viewport of a texture.
+// When we use partial kernels there are only 4 patterns (first is full): 
+//  0.  |x|x|       1.  |x|o|       2.  |o|o|       3.  |o|o|
+//      |x|x|           |x|o|           |x|x|           |x|o|
+
+// ------------------------------------------------
+// Variants
+// ------------------------------------------------
+
+#pragma kernel KDepthDownSample8                    KERNEL_SIZE=8       PATTERN=0       KERNEL_NAME=KDepthDownSample8    
+#pragma kernel KDepthDownSample2_0                  KERNEL_SIZE=1       PATTERN=0       KERNEL_NAME=KDepthDownSample2_0
+#pragma kernel KDepthDownSample2_1                  KERNEL_SIZE=1       PATTERN=1       KERNEL_NAME=KDepthDownSample2_1
+#pragma kernel KDepthDownSample2_2                  KERNEL_SIZE=1       PATTERN=2       KERNEL_NAME=KDepthDownSample2_2
+#pragma kernel KDepthDownSample2_3                  KERNEL_SIZE=1       PATTERN=3       KERNEL_NAME=KDepthDownSample2_3
-Texture2D<float> _Source;
-RWTexture2D<float> _Result;
+// ------------------------------------------------
+// Texture buffers
+// ------------------------------------------------
+
+Texture2D<float2> _Source;
+RW_TEXTURE2D(float2, _Result);
+// ------------------------------------------------
+// Constant buffers
+// ------------------------------------------------
+int2 _RectOffset;          // Offset in source texture
+// ------------------------------------------------
+// Kernel
+// ------------------------------------------------
+
+#if UNITY_REVERSED_Z
+# define MIN_DEPTH(l, r) max(l, r)
+# define MAX_DEPTH(l, r) min(l, r)
+#else
+# define MIN_DEPTH(l, r) min(l, r)
+# define MAX_DEPTH(l, r) max(l, r)
+#endif
-    int2 threadUL = dispatchThreadId;
+    uint2 srcPixelUL = _RectOffset + (dispatchThreadId << 1);
+    // Offset by 0.5 so sampling get the proper pixels
+    float2 offset = float2(srcPixelUL) + 0.5;
-    // Downsample the block
-    float2 offset = float2(threadUL) * 2.0f + 1.0f;
-    float4 depths = GATHER_RED_TEXTURE2D(_Source, sampler_PointClamp, offset * _SrcSize.zw, 0.0);
+    float4 depths = GATHER_RED_TEXTURE2D(_Source, sampler_PointClamp, offset * _SrcSize.zw, 0.0).wzxy;
-    // Downsample the block
     float p00 = SAMPLE_TEXTURE2D_LOD(_Source, sampler_PointClamp, (offset) * _SrcSize.zw, 0.0).x;
     float p10 = SAMPLE_TEXTURE2D_LOD(_Source, sampler_PointClamp, (offset + float2(1.0, 0.0)) * _SrcSize.zw, 0.0).x;
     float p01 = SAMPLE_TEXTURE2D_LOD(_Source, sampler_PointClamp, (offset + float2(0.0, 1.0)) * _SrcSize.zw, 0.0).x;
 
     // Select the nearest sample
-#if UNITY_REVERSED_Z
-    float minDepth = max(max(depths.x, depths.y), max(depths.z, depths.w));
-#else
-    float minDepth = min(min(depths.x, depths.y), min(depths.z, depths.w));
+#if PATTERN == 0
+    float minDepth = MIN_DEPTH(MIN_DEPTH(depths.x, depths.y), MIN_DEPTH(depths.z, depths.w));
+    float maxDepth = MAX_DEPTH(MAX_DEPTH(depths.x, depths.y), MAX_DEPTH(depths.z, depths.w));
+#elif PATTERN == 1
+    float minDepth = MIN_DEPTH(depths.x, depths.z);
+    float maxDepth = MAX_DEPTH(depths.x, depths.z);
+#elif PATTERN == 2
+    float minDepth = MIN_DEPTH(depths.x, depths.y);
+    float maxDepth = MAX_DEPTH(depths.x, depths.y);
+#elif PATTERN == 3
+    float minDepth = depths.x;
+    float maxDepth = depths.x;
-    _Result[dispatchThreadId] = minDepth;
+    uint2 dstPixel = (_RectOffset >> 1) + dispatchThreadId;
+    _Result[dstPixel] = float2(minDepth, maxDepth);
+
+#undef MIN_DEPTH
+#undef MAX_DEPTH

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/HDRenderPipelineResources.asset

   colorPyramidCS: {fileID: 7200000, guid: 4e3267a1135742441a14298d8dcac04a, type: 3}
   depthPyramidCS: {fileID: 7200000, guid: 64a553bb564274041906f78ffba955e4, type: 3}
   copyChannelCS: {fileID: 7200000, guid: a4d45eda75e8e474dbe24a31f741f3b4, type: 3}
+  texturePaddingCS: {fileID: 7200000, guid: 6736f53014c69f84aa2130aeae99730b, type: 3}
   applyDistortionCS: {fileID: 7200000, guid: 2fa6c0e3fe6dc3145a4156f21913fe5c, type: 3}
   clearDispatchIndirectShader: {fileID: 7200000, guid: fc1f553acb80a6446a32d33e403d0656,
     type: 3}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/RenderPipelineResources.cs

         public ComputeShader colorPyramidCS;
         public ComputeShader depthPyramidCS;
         public ComputeShader copyChannelCS;
+        public ComputeShader texturePaddingCS;
         public ComputeShader applyDistortionCS;
 
         // Lighting tile pass resources