- Removed useless shadow atlases from HDRP

- Added debug texture name to all our caches
- Fixed a few leaks (rendertexture, materials, ...)

ScriptableRenderPipeline/Core/CoreRP/CoreUtils.cs

             return temp;
         }
 
+        public static string GetTextureAutoName(int width, int height, TextureFormat format, TextureDimension dim = TextureDimension.None, string name = "", bool mips = false, int depth = 0)
+        {
+            string temp;
+            if(depth == 0)
+                temp = string.Format("{0}x{1}_{2}{3}", width, height, format, mips ? "_Mips" : "");
+            else
+                temp = string.Format("{0}x{1}x{2}_{3}{4}", width, height, depth, format, mips ? "_Mips" : "");
+            temp = String.Format("{0}_{1}_{2}", name == "" ? "Texture" : name, (dim == TextureDimension.None) ? "" : dim.ToString(), temp);
+
+            return temp;
+        }
+
         public static void ClearCubemap(CommandBuffer cmd, RenderTexture renderTexture, Color clearColor, bool clearMips = false)
         {
             int mipCount = 1;

ScriptableRenderPipeline/Core/CoreRP/TextureCache.cs

     {
         private Texture2DArray m_Cache;
 
+        public TextureCache2D(string cacheName = "")
+            : base(cacheName)
+        {
+        }
+
         public override void TransferToSlice(CommandBuffer cmd, int sliceIndex, Texture texture)
         {
             var mismatch = (m_Cache.width != texture.width) || (m_Cache.height != texture.height);
             m_Cache = new Texture2DArray(width, height, numTextures, format, isMipMapped)
             {
                 hideFlags = HideFlags.HideAndDontSave,
-                wrapMode = TextureWrapMode.Clamp
+                wrapMode = TextureWrapMode.Clamp,
+                name = CoreUtils.GetTextureAutoName(width, height, format, TextureDimension.Tex2DArray, depth: numTextures, name: m_CacheName)
             };
 
             return res;
         private int m_CubeMipLevelPropName;
         private int m_cubeSrcTexPropName;
 
+        public TextureCacheCubemap(string cacheName = "")
+            : base(cacheName)
+        {
+        }
+
         public override void TransferToSlice(CommandBuffer cmd, int sliceIndex, Texture texture)
         {
             if (!TextureCache.supportsCubemapArrayTextures)
                     wrapMode = TextureWrapMode.Repeat,
                     wrapModeV = TextureWrapMode.Clamp,
                     filterMode = FilterMode.Trilinear,
-                    anisoLevel = 0
+                    anisoLevel = 0,
+                    name = CoreUtils.GetTextureAutoName(panoWidthTop, panoHeightTop, format, TextureDimension.Tex2DArray, depth: numCubeMaps, name: m_CacheName)
                 };
 
                 m_NumPanoMipLevels = isMipMapped ? GetNumMips(panoWidthTop, panoHeightTop) : 1;
                     hideFlags = HideFlags.HideAndDontSave,
                     wrapMode = TextureWrapMode.Clamp,
                     filterMode = FilterMode.Trilinear,
-                    anisoLevel = 0 // It is important to set 0 here, else unity force anisotropy filtering
+                    anisoLevel = 0, // It is important to set 0 here, else unity force anisotropy filtering
+                    name = CoreUtils.GetTextureAutoName(width, width, format, TextureDimension.CubeArray, depth: numCubeMaps, name: m_CacheName)
                 };
             }
 
     public abstract class TextureCache
     {
         protected int m_NumMipLevels;
+        protected string m_CacheName;
 
         public static bool isMobileBuildTarget
         {
             //    assert(m_SliceArray[m_SortedIdxArray[q-1]].CountLRU>=m_SliceArray[m_SortedIdxArray[q]].CountLRU);
         }
 
-        protected TextureCache()
+        protected TextureCache(string cacheName)
+            m_CacheName = cacheName;
             m_NumTextures = 0;
             m_NumMipLevels = 0;
         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalSystem.cs

             {
                 if (m_DecalAtlas == null)
                 {
-                    m_DecalAtlas = new TextureCache2D();
+                    m_DecalAtlas = new TextureCache2D("DecalAtlas");
                     m_DecalAtlas.AllocTextureArray(2048, 128, 128, TextureFormat.RGBA32, true);
                 }
                 return m_DecalAtlas;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

             m_SSSBufferManager.Cleanup();
             m_SkyManager.Cleanup();
             m_VolumetricLightingModule.Cleanup();
+            m_IBLFilterGGX.Cleanup();
 
             DestroyRenderTextures();
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightLoop/LightLoop.cs

             atlasInit.shadowClearShader         = resources.shadowClearShader;
             atlasInit.shadowBlurMoments         = resources.shadowBlurMoments;
 
+            /*
+            // Code kept here for reference if we want to add VSM/MSM later on
-            varianceInit.baseInit.shadowmapFormat = ShadowVariance.GetFormat( false, false, true );
-
+            varianceInit.baseInit.shadowmapFormat = ShadowVariance.GetFormat(false, false, true);
-            varianceInit2.baseInit.shadowmapFormat = ShadowVariance.GetFormat( true, true, false );
-
+            varianceInit2.baseInit.shadowmapFormat = ShadowVariance.GetFormat(true, true, false);
-            varianceInit3.baseInit.shadowmapFormat = ShadowVariance.GetFormat( true, false, true );
+            varianceInit3.baseInit.shadowmapFormat = ShadowVariance.GetFormat(true, false, true);
+            m_Shadowmaps = new ShadowmapBase[] { new ShadowAtlas(ref atlasInit), new ShadowVariance(ref varianceInit), new ShadowVariance(ref varianceInit2), new ShadowVariance(ref varianceInit3) };
+            */
-            m_Shadowmaps = new ShadowmapBase[] { new ShadowVariance(ref varianceInit), new ShadowVariance(ref varianceInit2), new ShadowVariance(ref varianceInit3), new ShadowAtlas(ref atlasInit) };
+            m_Shadowmaps = new ShadowmapBase[] { new ShadowAtlas(ref atlasInit) };
 
             ShadowContext.SyncDel syncer = (ShadowContext sc) =>
                 {
                     cb.SetGlobalBuffer(HDShaderIDs._ShadowDatasExp, s_ShadowDataBuffer);
                     cb.SetGlobalBuffer(HDShaderIDs._ShadowPayloads, s_ShadowPayloadBuffer);
                     // bind textures
-                    cb.SetGlobalTexture(HDShaderIDs._ShadowmapExp_VSM_0, tex[0]);
-                    cb.SetGlobalTexture(HDShaderIDs._ShadowmapExp_VSM_1, tex[1]);
-                    cb.SetGlobalTexture(HDShaderIDs._ShadowmapExp_VSM_2, tex[2]);
-                    cb.SetGlobalTexture(HDShaderIDs._ShadowmapExp_PCF, tex[3]);
+                    cb.SetGlobalTexture(HDShaderIDs._ShadowmapExp_PCF, tex[0]);
+                    // Code kept here for reference if we want to add VSM/MSM later on
+                    //cb.SetGlobalTexture(HDShaderIDs._ShadowmapExp_VSM_0, tex[1]);
+                    //cb.SetGlobalTexture(HDShaderIDs._ShadowmapExp_VSM_1, tex[2]);
+                    //cb.SetGlobalTexture(HDShaderIDs._ShadowmapExp_VSM_2, tex[3])
 
                     // TODO: Currently samplers are hard coded in ShadowContext.hlsl, so we can't really set them here
                 };
         {
             if (m_Shadowmaps != null)
             {
-                (m_Shadowmaps[0] as ShadowAtlas).Dispose();
-                (m_Shadowmaps[1] as ShadowAtlas).Dispose();
-                (m_Shadowmaps[2] as ShadowAtlas).Dispose();
-                (m_Shadowmaps[3] as ShadowAtlas).Dispose();
+                foreach(var shadowMap in m_Shadowmaps)
+                {
+                    (shadowMap as ShadowAtlas).Dispose();
+                }
                 m_Shadowmaps = null;
             }
             m_ShadowMgr = null;
         public static readonly Vector3 k_BoxCullingExtentThreshold = Vector3.one * 0.01f;
 
         // Static keyword is required here else we get a "DestroyBuffer can only be called from the main thread"
-        static ComputeBuffer s_DirectionalLightDatas = null;
-        static ComputeBuffer s_LightDatas = null;
-        static ComputeBuffer s_EnvLightDatas = null;
-        static ComputeBuffer s_shadowDatas = null;
-        static ComputeBuffer s_DecalDatas = null;
+        ComputeBuffer m_DirectionalLightDatas = null;
+        ComputeBuffer m_LightDatas = null;
+        ComputeBuffer m_EnvLightDatas = null;
+        ComputeBuffer m_shadowDatas = null;
+        ComputeBuffer m_DecalDatas = null;
-        static Texture2DArray s_DefaultTexture2DArray;
-        static Cubemap s_DefaultTextureCube;
+        Texture2DArray  m_DefaultTexture2DArray;
+        Cubemap         m_DefaultTextureCube;
 
         PlanarReflectionProbeCache m_ReflectionPlanarProbeCache;
         ReflectionProbeCache m_ReflectionProbeCache;
             for (int i = 0, c = Mathf.Max(1, hdAsset.renderPipelineSettings.lightLoopSettings.maxPlanarReflectionProbes); i < c; ++i)
                 m_Env2DCaptureVP.Add(Matrix4x4.identity);
 
-            s_DirectionalLightDatas = new ComputeBuffer(k_MaxDirectionalLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalLightData)));
-            s_LightDatas = new ComputeBuffer(k_MaxPunctualLightsOnScreen + k_MaxAreaLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
-            s_EnvLightDatas = new ComputeBuffer(k_MaxEnvLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(EnvLightData)));
-            s_shadowDatas = new ComputeBuffer(k_MaxCascadeCount + k_MaxShadowOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(ShadowData)));
-            s_DecalDatas = new ComputeBuffer(k_MaxDecalsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DecalData)));
+            m_DirectionalLightDatas = new ComputeBuffer(k_MaxDirectionalLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalLightData)));
+            m_LightDatas = new ComputeBuffer(k_MaxPunctualLightsOnScreen + k_MaxAreaLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
+            m_EnvLightDatas = new ComputeBuffer(k_MaxEnvLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(EnvLightData)));
+            m_shadowDatas = new ComputeBuffer(k_MaxCascadeCount + k_MaxShadowOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(ShadowData)));
+            m_DecalDatas = new ComputeBuffer(k_MaxDecalsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DecalData)));
-            m_CookieTexArray = new TextureCache2D();
+            m_CookieTexArray = new TextureCache2D("Cookie");
-            m_CubeCookieTexArray = new TextureCacheCubemap();
+            m_CubeCookieTexArray = new TextureCacheCubemap("Cookie");
             m_CubeCookieTexArray.AllocTextureArray(gLightLoopSettings.cubeCookieTexArraySize, gLightLoopSettings.pointCookieSize, TextureFormat.RGBA32, true, m_CubeToPanoMaterial);
 
             TextureFormat probeCacheFormat = gLightLoopSettings.reflectionCacheCompressed ? TextureFormat.BC6H : TextureFormat.RGBAHalf;
                             int index = GetDeferredLightingMaterialIndex(outputSplitLighting, lightLoopTilePass, shadowMask, debugDisplay);
 
                             m_deferredLightingMaterial[index] = CoreUtils.CreateEngineMaterial(m_Resources.deferredShader);
+                            m_deferredLightingMaterial[index].name = string.Format("{0}_{1}", m_Resources.deferredShader.name, index);
                             CoreUtils.SetKeyword(m_deferredLightingMaterial[index], "OUTPUT_SPLIT_LIGHTING", outputSplitLighting == 1);
                             CoreUtils.SelectKeyword(m_deferredLightingMaterial[index], "LIGHTLOOP_TILE_PASS", "LIGHTLOOP_SINGLE_PASS", lightLoopTilePass == 1);
                             CoreUtils.SetKeyword(m_deferredLightingMaterial[index], "SHADOWS_SHADOWMASK", shadowMask == 1);
                 }
             }
 
-            s_DefaultTexture2DArray = new Texture2DArray(1, 1, 1, TextureFormat.ARGB32, false);
-            s_DefaultTexture2DArray.SetPixels32(new Color32[1] { new Color32(128, 128, 128, 128) }, 0);
-            s_DefaultTexture2DArray.Apply();
+            m_DefaultTexture2DArray = new Texture2DArray(1, 1, 1, TextureFormat.ARGB32, false);
+            m_DefaultTexture2DArray.hideFlags = HideFlags.HideAndDontSave;
+            m_DefaultTexture2DArray.name = CoreUtils.GetTextureAutoName(1, 1, TextureFormat.ARGB32, depth: 1, dim: TextureDimension.Tex2DArray, name: "LightLoopDefault");
+            m_DefaultTexture2DArray.SetPixels32(new Color32[1] { new Color32(128, 128, 128, 128) }, 0);
+            m_DefaultTexture2DArray.Apply();
-            s_DefaultTextureCube = new Cubemap(16, TextureFormat.ARGB32, false);
-            s_DefaultTextureCube.Apply();
+            m_DefaultTextureCube = new Cubemap(16, TextureFormat.ARGB32, false);
+            m_DefaultTextureCube.Apply();
 
             InitShadowSystem(hdAsset, shadowSettings);
         }
             DeinitShadowSystem();
 
-            CoreUtils.SafeRelease(s_DirectionalLightDatas);
-            CoreUtils.SafeRelease(s_LightDatas);
-            CoreUtils.SafeRelease(s_EnvLightDatas);
-            CoreUtils.SafeRelease(s_shadowDatas);
-            CoreUtils.SafeRelease(s_DecalDatas);
+            CoreUtils.Destroy(m_DefaultTexture2DArray);
+            CoreUtils.Destroy(m_DefaultTextureCube);
+
+            CoreUtils.SafeRelease(m_DirectionalLightDatas);
+            CoreUtils.SafeRelease(m_LightDatas);
+            CoreUtils.SafeRelease(m_EnvLightDatas);
+            CoreUtils.SafeRelease(m_shadowDatas);
+            CoreUtils.SafeRelease(m_DecalDatas);
 
             if (m_ReflectionProbeCache != null)
             {
 
         void UpdateDataBuffers()
         {
-            s_DirectionalLightDatas.SetData(m_lightList.directionalLights);
-            s_LightDatas.SetData(m_lightList.lights);
-            s_EnvLightDatas.SetData(m_lightList.envLights);
-            s_shadowDatas.SetData(m_lightList.shadows);
-            s_DecalDatas.SetData(DecalSystem.m_DecalDatas, 0, 0, Math.Min(DecalSystem.m_DecalDatasCount, k_MaxDecalsOnScreen)); // don't add more than the size of the buffer
+            m_DirectionalLightDatas.SetData(m_lightList.directionalLights);
+            m_LightDatas.SetData(m_lightList.lights);
+            m_EnvLightDatas.SetData(m_lightList.envLights);
+            m_shadowDatas.SetData(m_lightList.shadows);
+            m_DecalDatas.SetData(DecalSystem.m_DecalDatas, 0, 0, Math.Min(DecalSystem.m_DecalDatasCount, k_MaxDecalsOnScreen)); // don't add more than the size of the buffer
 
             // These two buffers have been set in Rebuild()
             s_ConvexBoundsBuffer.SetData(m_lightList.bounds);
                 cmd.SetGlobalTexture(HDShaderIDs._Env2DTextures, m_ReflectionPlanarProbeCache.GetTexCache());
                 cmd.SetGlobalMatrixArray(HDShaderIDs._Env2DCaptureVP, m_Env2DCaptureVP);
 
-                cmd.SetGlobalBuffer(HDShaderIDs._DirectionalLightDatas, s_DirectionalLightDatas);
+                cmd.SetGlobalBuffer(HDShaderIDs._DirectionalLightDatas, m_DirectionalLightDatas);
-                cmd.SetGlobalBuffer(HDShaderIDs._LightDatas, s_LightDatas);
+                cmd.SetGlobalBuffer(HDShaderIDs._LightDatas, m_LightDatas);
-                cmd.SetGlobalBuffer(HDShaderIDs._EnvLightDatas, s_EnvLightDatas);
+                cmd.SetGlobalBuffer(HDShaderIDs._EnvLightDatas, m_EnvLightDatas);
-                cmd.SetGlobalBuffer(HDShaderIDs._DecalDatas, s_DecalDatas);
+                cmd.SetGlobalBuffer(HDShaderIDs._DecalDatas, m_DecalDatas);
-                cmd.SetGlobalBuffer(HDShaderIDs._ShadowDatas, s_shadowDatas);
+                cmd.SetGlobalBuffer(HDShaderIDs._ShadowDatas, m_shadowDatas);
 
                 cmd.SetGlobalInt(HDShaderIDs._NumTileFtplX, GetNumTileFtplX(hdCamera));
                 cmd.SetGlobalInt(HDShaderIDs._NumTileFtplY, GetNumTileFtplY(hdCamera));

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

 //#define SHADOW_DISPATCH_USE_SEPARATE_PUNC_ALGOS	    // enables separate resources and algorithms for spot and point lights
 
 // directional
-#define SHADOW_DISPATCH_DIR_TEX   3
+#define SHADOW_DISPATCH_DIR_TEX   0
 #define SHADOW_DISPATCH_DIR_SMP   0
 #define SHADOW_DISPATCH_DIR_ALG   GPUSHADOWALGORITHM_PCF_TENT_5X5   // all cascades
 #define SHADOW_DISPATCH_DIR_ALG_0 GPUSHADOWALGORITHM_PCF_TENT_7X7   // 1st cascade
 // point
-#define SHADOW_DISPATCH_POINT_TEX 3
+#define SHADOW_DISPATCH_POINT_TEX 0
-#define SHADOW_DISPATCH_SPOT_TEX 3
+#define SHADOW_DISPATCH_SPOT_TEX 0
-#define SHADOW_DISPATCH_PUNC_TEX 3
+#define SHADOW_DISPATCH_PUNC_TEX 0
 #define SHADOW_DISPATCH_PUNC_SMP 0
 #define SHADOW_DISPATCH_PUNC_ALG GPUSHADOWALGORITHM_PCF_TENT_3X3
 

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

 StructuredBuffer<ShadowData>	_ShadowDatasExp;
 StructuredBuffer<int4>			_ShadowPayloads;
 
+// Currently we only use the PCF atlas.
+// Keeping all other bindings for reference and for future PC dynamic shadow configuration as it's harmless anyway.
-	sc.tex2DArray[0]   = _ShadowmapExp_VSM_0;
-	sc.tex2DArray[1]   = _ShadowmapExp_VSM_1;
-	sc.tex2DArray[2]   = _ShadowmapExp_VSM_2;
-	sc.tex2DArray[3]   = _ShadowmapExp_PCF;
-	sc.samplers[0]	   = sampler_ShadowmapExp_VSM_0;
+    sc.tex2DArray[0]   = _ShadowmapExp_PCF;
+    sc.tex2DArray[1]   = _ShadowmapExp_VSM_0;
+	sc.tex2DArray[2]   = _ShadowmapExp_VSM_1;
+	sc.tex2DArray[3]   = _ShadowmapExp_VSM_2;
+    sc.compSamplers[0] = sampler_ShadowmapExp_PCF;
+    sc.samplers[0]	   = sampler_ShadowmapExp_VSM_0;
-	sc.compSamplers[0] = sampler_ShadowmapExp_PCF;
 	return sc;
 }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/PlanarReflectionProbeCache.cs

 
             m_ProbeSize = probeSize;
             m_CacheSize = cacheSize;
-            m_TextureCache = new TextureCache2D();
+            m_TextureCache = new TextureCache2D("PlanarReflectionProbe");
             m_TextureCache.AllocTextureArray(cacheSize, probeSize, probeSize, probeFormat, isMipmaped);
             m_IBLFilterGGX = iblFilter;
 
                 m_TempRenderTexture.dimension = TextureDimension.Tex2D;
                 m_TempRenderTexture.useMipMap = true;
                 m_TempRenderTexture.autoGenerateMips = false;
-                m_TempRenderTexture.name = CoreUtils.GetRenderTargetAutoName(m_ProbeSize, m_ProbeSize, RenderTextureFormat.ARGBHalf, "PlanarReflection", mips : true);
+                m_TempRenderTexture.name = CoreUtils.GetRenderTargetAutoName(m_ProbeSize, m_ProbeSize, RenderTextureFormat.ARGBHalf, "PlanarReflectionTemp", mips : true);
                 m_TempRenderTexture.Create();
 
                 m_ConvolutionTargetTexture = new RenderTexture(m_ProbeSize, m_ProbeSize, 1, RenderTextureFormat.ARGBHalf);
 
         public void Release()
         {
-            if (m_TextureCache != null)
-            {
-                m_TextureCache.Release();
-                m_TextureCache = null;
-            }
-            if (m_TempRenderTexture != null)
-            {
-                m_TempRenderTexture.Release();
-                m_TempRenderTexture = null;
-            }
-            if (m_ConvolutionTargetTexture != null)
-            {
-                m_ConvolutionTargetTexture.Release();
-                m_ConvolutionTargetTexture = null;
-            }
+            m_TextureCache.Release();
+            CoreUtils.Destroy(m_TempRenderTexture);
+            CoreUtils.Destroy(m_ConvolutionTargetTexture);
+
             m_ProbeBakingState = null;
 
             CoreUtils.Destroy(m_ConvertTextureMaterial);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Reflection/ReflectionProbeCache.cs

 
             m_ProbeSize = probeSize;
             m_CacheSize = cacheSize;
-            m_TextureCache = new TextureCacheCubemap();
+            m_TextureCache = new TextureCacheCubemap("ReflectionProbe");
             m_TextureCache.AllocTextureArray(cacheSize, probeSize, probeFormat, isMipmaped, m_CubeToPano);
             m_IBLFilterGGX = iblFilter;
 
                 m_TempRenderTexture.dimension = TextureDimension.Cube;
                 m_TempRenderTexture.useMipMap = true;
                 m_TempRenderTexture.autoGenerateMips = false;
-                m_TempRenderTexture.name = CoreUtils.GetRenderTargetAutoName(m_ProbeSize, m_ProbeSize, RenderTextureFormat.ARGBHalf, "PlanarReflection", mips : true);
+                m_TempRenderTexture.name = CoreUtils.GetRenderTargetAutoName(m_ProbeSize, m_ProbeSize, RenderTextureFormat.ARGBHalf, "ReflectionProbeTemp", mips : true);
                 m_TempRenderTexture.Create();
 
                 m_ConvolutionTargetTexture = new RenderTexture(m_ProbeSize, m_ProbeSize, 1, RenderTextureFormat.ARGBHalf);
                 m_ConvolutionTargetTexture.autoGenerateMips = false;
-                m_ConvolutionTargetTexture.name = CoreUtils.GetRenderTargetAutoName(m_ProbeSize, m_ProbeSize, RenderTextureFormat.ARGBHalf, "PlanarReflection", mips : true);
+                m_ConvolutionTargetTexture.name = CoreUtils.GetRenderTargetAutoName(m_ProbeSize, m_ProbeSize, RenderTextureFormat.ARGBHalf, "ReflectionProbeConvolution", mips : true);
                 m_ConvolutionTargetTexture.Create();
 
                 InitializeProbeBakingStates();
 
         public void Release()
         {
-            if (m_TextureCache != null)
-            {
-                m_TextureCache.Release();
-                m_TextureCache = null;
-            }
-            if (m_TempRenderTexture != null)
-            {
-                m_TempRenderTexture.Release();
-                m_TempRenderTexture = null;
-            }
-            if (m_ConvolutionTargetTexture != null)
-            {
-                m_ConvolutionTargetTexture.Release();
-                m_ConvolutionTargetTexture = null;
-            }
+            m_TextureCache.Release();
+            CoreUtils.Destroy(m_TempRenderTexture);
+            CoreUtils.Destroy(m_ConvolutionTargetTexture);
+
             m_ProbeBakingState = null;
 
             CoreUtils.Destroy(m_ConvertTextureMaterial);

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

                 m_GgxIblSampleData.enableRandomWrite = true;
                 m_GgxIblSampleData.filterMode = FilterMode.Point;
                 m_GgxIblSampleData.name = CoreUtils.GetRenderTargetAutoName(m_GgxIblMaxSampleCount, k_GgxIblMipCountMinusOne, RenderTextureFormat.ARGBHalf, "GGXIblSampleData");
+                m_GgxIblSampleData.hideFlags = HideFlags.HideAndDontSave;
                 m_GgxIblSampleData.Create();
 
                 m_ComputeGgxIblSampleDataCS.SetTexture(m_ComputeGgxIblSampleDataKernel, "output", m_GgxIblSampleData);
                 var lookAt = Matrix4x4.LookAt(Vector3.zero, CoreUtils.lookAtList[i], CoreUtils.upVectorList[i]);
                 m_faceWorldToViewMatrixMatrices[i] = lookAt * Matrix4x4.Scale(new Vector3(1.0f, 1.0f, -1.0f)); // Need to scale -1.0 on Z to match what is being done in the camera.wolrdToCameraMatrix API. ...
             }
+        }
+
+        public void Cleanup()
+        {
+            CoreUtils.Destroy(m_GgxConvolveMaterial);
+            CoreUtils.Destroy(m_GgxIblSampleData);
         }
 
         void FilterCubemapCommon(   CommandBuffer cmd,

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.cs

             {
                 hideFlags = HideFlags.HideAndDontSave,
                 wrapMode = TextureWrapMode.Clamp,
-                filterMode = FilterMode.Bilinear
+                filterMode = FilterMode.Bilinear,
+                name = CoreUtils.GetTextureAutoName(k_LtcLUTResolution, k_LtcLUTResolution, TextureFormat.RGBAHalf, depth: 3, dim: TextureDimension.Tex2DArray, name: "LTC_LUT")
             };
 
             LoadLUT(m_LtcData, 0, TextureFormat.RGBAHalf,   s_LtcGGXMatrixData);
         public override void Cleanup()
         {
             CoreUtils.Destroy(m_InitPreFGD);
+            CoreUtils.Destroy(m_PreIntegratedFGD);
+            CoreUtils.Destroy(m_LtcData);
 
             // TODO: how to delete RenderTexture ? or do we need to do it ?
             m_isInit = false;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/SkyManager.cs

         public void Cleanup()
         {
             CoreUtils.Destroy(m_StandardSkyboxMaterial);
+            CoreUtils.Destroy(m_BlitCubemapMaterial);
+            CoreUtils.Destroy(m_OpaqueAtmScatteringMaterial);
 
             m_BakingSky.Cleanup();
             m_VisualSky.Cleanup();