Updated CloudLayer, CloudLayerRenderer, and CloudSettings to work with CoreCLR

Author: jrs-unity

Packages/com.unity.render-pipelines.high-definition/Runtime/Sky/CloudSystem/CloudLayer/CloudLayer.cs

@@ -263,6 +263,14 @@ public override int GetHashCode()
 
                 return hash;
             }
+
+#if UNITY_EDITOR
+            [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+            static void ResetStaticsOnLoad()
+            {
+                s_DefaultTexture = null;
+            }
+#endif
         }
 
         /// <summary>Layer A.</summary>
@@ -337,6 +345,8 @@ public override int GetHashCode()
         /// </summary>
         static void Init()
         {
+            CloudMap.s_DefaultTexture = null;
+
             if (GraphicsSettings.TryGetRenderPipelineSettings<HDRenderPipelineRuntimeTextures>(out var runtimeTextures))
             {
                 CloudMap.s_DefaultTexture = runtimeTextures.defaultCloudMap;

Packages/com.unity.render-pipelines.high-definition/Runtime/Sky/CloudSystem/CloudLayer/CloudLayerRenderer.cs

@@ -13,14 +13,14 @@ class CloudLayerRenderer : CloudRenderer
 
         private float lastTime = 0.0f;
         int m_LastPrecomputationParamHash;
+        ComputeShader m_BakeCloudTextureCS, m_BakeCloudShadowsCS;
+        int m_BakeCloudTextureKernel, m_BakeCloudShadowsKernel;
 
         static readonly int _CloudTexture = Shader.PropertyToID("_CloudTexture");
         static readonly int _CloudShadows = Shader.PropertyToID("_CloudShadows");
         static readonly int _FlowmapA = Shader.PropertyToID("_FlowmapA"), _FlowmapB = Shader.PropertyToID("_FlowmapB");
         static readonly int _CloudMapA = Shader.PropertyToID("_CloudMapA"), _CloudMapB = Shader.PropertyToID("_CloudMapB");
         static readonly int _AmbientProbeBuffer = Shader.PropertyToID("_AmbientProbeBuffer");
-        static ComputeShader s_BakeCloudTextureCS, s_BakeCloudShadowsCS;
-        static int s_BakeCloudTextureKernel, s_BakeCloudShadowsKernel;
         static readonly Vector4[] s_VectorArray = new Vector4[2];
 
         public RTHandle cloudTexture { get { return m_PrecomputedData.cloudTextureRT; } }
@@ -38,20 +38,23 @@ public override void Build()
 
             m_CloudLayerMaterial = CoreUtils.CreateEngineMaterial(shaders.cloudLayerPS);
 
-            s_BakeCloudTextureCS = shaders.bakeCloudTextureCS;
-            s_BakeCloudTextureKernel = s_BakeCloudTextureCS.FindKernel("BakeCloudTexture");
+            m_BakeCloudTextureCS = shaders.bakeCloudTextureCS;
+            m_BakeCloudTextureKernel = m_BakeCloudTextureCS.FindKernel("BakeCloudTexture");
 
-            s_BakeCloudShadowsCS = shaders.bakeCloudShadowsCS;
-            s_BakeCloudShadowsKernel = s_BakeCloudShadowsCS.FindKernel("BakeCloudShadows");
+            m_BakeCloudShadowsCS = shaders.bakeCloudShadowsCS;
+            m_BakeCloudShadowsKernel = m_BakeCloudShadowsCS.FindKernel("BakeCloudShadows");
         }
 
         public override void Cleanup()
         {
             CoreUtils.Destroy(m_CloudLayerMaterial);
 
+            m_BakeCloudTextureCS = null;
+            m_BakeCloudShadowsCS = null;
+
             if (m_PrecomputedData != null)
             {
-                s_PrecomputationCache.Release(m_LastPrecomputationParamHash);
+                PrecomputationCacheInstance.Release(m_LastPrecomputationParamHash);
                 m_LastPrecomputationParamHash = 0;
                 m_PrecomputedData = null;
             }
@@ -62,8 +65,8 @@ bool UpdateCache(CloudLayer cloudLayer, Light sunLight)
             int currPrecomputationParamHash = cloudLayer.GetBakingHashCode(sunLight);
             if (currPrecomputationParamHash != m_LastPrecomputationParamHash)
             {
-                s_PrecomputationCache.Release(m_LastPrecomputationParamHash);
-                m_PrecomputedData = s_PrecomputationCache.Get(cloudLayer, currPrecomputationParamHash);
+                PrecomputationCacheInstance.Release(m_LastPrecomputationParamHash);
+                m_PrecomputedData = PrecomputationCacheInstance.Get(cloudLayer, currPrecomputationParamHash);
                 m_LastPrecomputationParamHash = currPrecomputationParamHash;
                 return true;
             }
@@ -89,7 +92,7 @@ public override bool GetSunLightCookieParameters(CloudSettings settings, ref Coo
         }
 
         public override void RenderSunLightCookie(BuiltinSunCookieParameters builtinParams)
-            => m_PrecomputedData.BakeCloudShadows((CloudLayer)builtinParams.cloudSettings, builtinParams.sunLight, builtinParams.hdCamera, builtinParams.commandBuffer);
+            => m_PrecomputedData.BakeCloudShadows(this, (CloudLayer)builtinParams.cloudSettings, builtinParams.sunLight, builtinParams.hdCamera, builtinParams.commandBuffer);
 
         public override void RenderClouds(BuiltinSkyParameters builtinParams, bool renderForCubemap)
         {
@@ -108,7 +111,7 @@ public override void RenderClouds(BuiltinSkyParameters builtinParams, bool rende
             if (!hdCamera.animateMaterials)
                 cloudLayer.layerA.scrollFactor = cloudLayer.layerB.scrollFactor = 0.0f;
 
-            m_PrecomputedData.InitIfNeeded(cloudLayer, builtinParams.sunLight, hdCamera, builtinParams.commandBuffer);
+            m_PrecomputedData.InitIfNeeded(this, cloudLayer, builtinParams.sunLight, hdCamera, builtinParams.commandBuffer);
             m_CloudLayerMaterial.SetTexture(_CloudTexture, m_PrecomputedData.cloudTextureRT);
 
             // Parameters
@@ -252,6 +255,18 @@ public void Release(int hash)
                     }
                 }
             }
+
+            public void Clear()
+            {
+                foreach (var refCountData in m_CachedData.Values)
+                {
+                    refCountData.refCount = 0;
+                    refCountData.data.Release();
+                    m_DataPool.Release(refCountData);
+                }
+
+                m_CachedData.Clear();
+            }
         }
 
         class PrecomputationData
@@ -280,10 +295,31 @@ public void Cache(int textureWidth, int textureHeight, RTHandle texture)
                     height = textureHeight;
                     rt = texture;
                 }
+
+                public void Clear()
+                {
+                    width = 0;
+                    height = 0;
+
+                    if (rt != null)
+                    {
+                        RTHandles.Release(rt);
+                        rt = null;
+                    }
+                }
             }
-            static TextureCache cloudTextureCache;
-            static TextureCache cloudShadowsCache;
 
+            static TextureCache s_CloudTextureCache;
+            static TextureCache s_CloudShadowsCache;
+
+#if UNITY_EDITOR
+            [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+            static void ResetStaticsOnLoad()
+            {
+                s_CloudTextureCache.Clear();
+                s_CloudShadowsCache.Clear();
+            }
+#endif
             bool initialized = false;
             int cloudTextureWidth, cloudTextureHeight, cloudShadowsResolution;
             public RTHandle cloudTextureRT = null;
@@ -294,126 +330,144 @@ public void Allocate(CloudLayer cloudLayer)
                 initialized = false;
                 cloudTextureWidth = (int)cloudLayer.resolution.value;
                 cloudTextureHeight = cloudLayer.upperHemisphereOnly.value ? cloudTextureWidth / 2 : cloudTextureWidth;
-                if (!cloudTextureCache.TryGet(cloudTextureWidth, cloudTextureHeight, ref cloudTextureRT))
+                if (!s_CloudTextureCache.TryGet(cloudTextureWidth, cloudTextureHeight, ref cloudTextureRT))
                     cloudTextureRT = RTHandles.Alloc(cloudTextureWidth, cloudTextureHeight, TextureWrapMode.Repeat, TextureWrapMode.Clamp,
                         slices: cloudLayer.NumLayers, colorFormat: GraphicsFormat.R16G16_SFloat, dimension: TextureDimension.Tex2DArray,
                         enableRandomWrite: true, useMipMap: false, filterMode: FilterMode.Bilinear, name: "Cloud Texture");
 
                 cloudShadowsRT = null;
                 cloudShadowsResolution = (int)cloudLayer.shadowResolution.value;
-                if (cloudLayer.CastShadows && !cloudShadowsCache.TryGet(cloudShadowsResolution, cloudShadowsResolution, ref cloudShadowsRT))
+                if (cloudLayer.CastShadows && !s_CloudShadowsCache.TryGet(cloudShadowsResolution, cloudShadowsResolution, ref cloudShadowsRT))
                     cloudShadowsRT = RTHandles.Alloc(cloudShadowsResolution, cloudShadowsResolution,
                         colorFormat: GraphicsFormat.B10G11R11_UFloatPack32, dimension: TextureDimension.Tex2D,
                         enableRandomWrite: true, useMipMap: false, filterMode: FilterMode.Bilinear, name: "Cloud Shadows");
             }
 
             public void Release()
             {
-                cloudTextureCache.Cache(cloudTextureHeight, cloudTextureHeight, cloudTextureRT);
-                cloudShadowsCache.Cache(cloudShadowsResolution, cloudShadowsResolution, cloudShadowsRT);
+                s_CloudTextureCache.Cache(cloudTextureHeight, cloudTextureHeight, cloudTextureRT);
+                s_CloudShadowsCache.Cache(cloudShadowsResolution, cloudShadowsResolution, cloudShadowsRT);
             }
 
-            public bool InitIfNeeded(CloudLayer cloudLayer, Light sunLight, HDCamera hdCamera, CommandBuffer cmd)
+            public bool InitIfNeeded(CloudLayerRenderer cloudLayerRenderer, CloudLayer cloudLayer, Light sunLight, HDCamera hdCamera, CommandBuffer cmd)
             {
                 if (initialized) return false;
 
+                var bakeCloudTextureCS = cloudLayerRenderer.m_BakeCloudTextureCS;
+                var bakeCloudTextureKernel = cloudLayerRenderer.m_BakeCloudTextureKernel;
+
                 Vector4 params1 = sunLight == null ? Vector3.zero : -sunLight.transform.forward;
                 params1.w = (cloudLayer.upperHemisphereOnly.value ? 1.0f : -1.0f) * hdCamera.planet.radius;
 
-                cmd.SetComputeVectorParam(s_BakeCloudTextureCS, HDShaderIDs._Params, params1);
-                cmd.SetComputeTextureParam(s_BakeCloudTextureCS, s_BakeCloudTextureKernel, _CloudTexture, cloudTextureRT);
+                cmd.SetComputeVectorParam(bakeCloudTextureCS, HDShaderIDs._Params, params1);
+                cmd.SetComputeTextureParam(bakeCloudTextureCS, bakeCloudTextureKernel, _CloudTexture, cloudTextureRT);
 
-                cmd.SetComputeTextureParam(s_BakeCloudTextureCS, s_BakeCloudTextureKernel, _CloudMapA, cloudLayer.layerA.cloudMap.value);
+                cmd.SetComputeTextureParam(bakeCloudTextureCS, bakeCloudTextureKernel, _CloudMapA, cloudLayer.layerA.cloudMap.value);
                 var paramsA = cloudLayer.layerA.GetBakingParameters();
 
                 if (cloudLayer.NumLayers == 1)
                 {
-                    s_BakeCloudTextureCS.DisableKeyword("USE_SECOND_CLOUD_LAYER");
-                    cmd.SetComputeVectorParam(s_BakeCloudTextureCS, HDShaderIDs._Params1, paramsA.Item1);
-                    cmd.SetComputeVectorParam(s_BakeCloudTextureCS, HDShaderIDs._Params2, paramsA.Item2);
+                    bakeCloudTextureCS.DisableKeyword("USE_SECOND_CLOUD_LAYER");
+                    cmd.SetComputeVectorParam(bakeCloudTextureCS, HDShaderIDs._Params1, paramsA.Item1);
+                    cmd.SetComputeVectorParam(bakeCloudTextureCS, HDShaderIDs._Params2, paramsA.Item2);
                 }
                 else
                 {
-                    cmd.SetComputeTextureParam(s_BakeCloudTextureCS, s_BakeCloudTextureKernel, _CloudMapB, cloudLayer.layerB.cloudMap.value);
+                    cmd.SetComputeTextureParam(bakeCloudTextureCS, bakeCloudTextureKernel, _CloudMapB, cloudLayer.layerB.cloudMap.value);
                     var paramsB = cloudLayer.layerB.GetBakingParameters();
 
-                    s_BakeCloudTextureCS.EnableKeyword("USE_SECOND_CLOUD_LAYER");
+                    bakeCloudTextureCS.EnableKeyword("USE_SECOND_CLOUD_LAYER");
                     s_VectorArray[0] = paramsA.Item1; s_VectorArray[1] = paramsB.Item1;
-                    cmd.SetComputeVectorArrayParam(s_BakeCloudTextureCS, HDShaderIDs._Params1, s_VectorArray);
+                    cmd.SetComputeVectorArrayParam(bakeCloudTextureCS, HDShaderIDs._Params1, s_VectorArray);
                     s_VectorArray[0] = paramsA.Item2; s_VectorArray[1] = paramsB.Item2;
-                    cmd.SetComputeVectorArrayParam(s_BakeCloudTextureCS, HDShaderIDs._Params2, s_VectorArray);
+                    cmd.SetComputeVectorArrayParam(bakeCloudTextureCS, HDShaderIDs._Params2, s_VectorArray);
                 }
 
-                cmd.SetComputeFloatParam(s_BakeCloudTextureCS, HDShaderIDs._Resolution, 1.0f / cloudTextureWidth);
+                cmd.SetComputeFloatParam(bakeCloudTextureCS, HDShaderIDs._Resolution, 1.0f / cloudTextureWidth);
 
                 const int groupSizeX = 8;
                 const int groupSizeY = 8;
                 int threadGroupX = (cloudTextureWidth + (groupSizeX - 1)) / groupSizeX;
                 int threadGroupY = (cloudTextureHeight + (groupSizeY - 1)) / groupSizeY;
 
-                cmd.DispatchCompute(s_BakeCloudTextureCS, s_BakeCloudTextureKernel, threadGroupX, threadGroupY, 1);
+                cmd.DispatchCompute(bakeCloudTextureCS, bakeCloudTextureKernel, threadGroupX, threadGroupY, 1);
 
                 initialized = true;
                 return true;
             }
 
-            public void BakeCloudShadows(CloudLayer cloudLayer, Light sunLight, HDCamera hdCamera, CommandBuffer cmd)
+            public void BakeCloudShadows(CloudLayerRenderer cloudLayerRenderer, CloudLayer cloudLayer, Light sunLight, HDCamera hdCamera, CommandBuffer cmd)
             {
-                InitIfNeeded(cloudLayer, sunLight, hdCamera, cmd);
+                InitIfNeeded(cloudLayerRenderer, cloudLayer, sunLight, hdCamera, cmd);
+
+                var bakeCloudShadowsCS = cloudLayerRenderer.m_BakeCloudShadowsCS;
+                var bakeCloudShadowsKernel = cloudLayerRenderer.m_BakeCloudShadowsKernel;
+
                 Vector4 _Params = cloudLayer.shadowTint.value;
                 _Params.w = cloudLayer.shadowMultiplier.value * 8.0f;
 
                 // Parameters
-                cmd.SetComputeFloatParam(s_BakeCloudShadowsCS, HDShaderIDs._Resolution, 1.0f / cloudShadowsResolution);
-                cmd.SetComputeVectorParam(s_BakeCloudShadowsCS, HDShaderIDs._Params, _Params);
+                cmd.SetComputeFloatParam(bakeCloudShadowsCS, HDShaderIDs._Resolution, 1.0f / cloudShadowsResolution);
+                cmd.SetComputeVectorParam(bakeCloudShadowsCS, HDShaderIDs._Params, _Params);
 
-                cmd.SetComputeTextureParam(s_BakeCloudShadowsCS, s_BakeCloudShadowsKernel, _CloudTexture, cloudTextureRT);
-                cmd.SetComputeTextureParam(s_BakeCloudShadowsCS, s_BakeCloudShadowsKernel, _CloudShadows, cloudShadowsRT);
+                cmd.SetComputeTextureParam(bakeCloudShadowsCS, bakeCloudShadowsKernel, _CloudTexture, cloudTextureRT);
+                cmd.SetComputeTextureParam(bakeCloudShadowsCS, bakeCloudShadowsKernel, _CloudShadows, cloudShadowsRT);
 
                 var _FlowmapParamA = cloudLayer.layerA.GetRenderingParameters(hdCamera);
                 var _FlowmapParamB = cloudLayer.layerB.GetRenderingParameters(hdCamera);
                 _FlowmapParamA.w = cloudLayer.upperHemisphereOnly.value ? 1 : 0;
                 _FlowmapParamB.w = cloudLayer.opacity.value;
 
                 s_VectorArray[0] = _FlowmapParamA; s_VectorArray[1] = _FlowmapParamB;
-                cmd.SetComputeVectorArrayParam(s_BakeCloudShadowsCS, HDShaderIDs._FlowmapParam, s_VectorArray);
+                cmd.SetComputeVectorArrayParam(bakeCloudShadowsCS, HDShaderIDs._FlowmapParam, s_VectorArray);
 
                 s_VectorArray[0] = sunLight.transform.right; s_VectorArray[1] = sunLight.transform.up;
                 s_VectorArray[0].w = cloudLayer.layerA.altitude.value; s_VectorArray[1].w = cloudLayer.layerB.altitude.value;
-                cmd.SetComputeVectorArrayParam(s_BakeCloudShadowsCS, HDShaderIDs._Params1, s_VectorArray);
+                cmd.SetComputeVectorArrayParam(bakeCloudShadowsCS, HDShaderIDs._Params1, s_VectorArray);
 
-                cmd.SetComputeVectorParam(s_BakeCloudShadowsCS, HDShaderIDs._SunDirection, -sunLight.transform.forward);
+                cmd.SetComputeVectorParam(bakeCloudShadowsCS, HDShaderIDs._SunDirection, -sunLight.transform.forward);
 
-                cmd.SetComputeTextureParam(s_BakeCloudShadowsCS, s_BakeCloudShadowsKernel, _FlowmapA, cloudLayer.layerA.flowmap.value);
-                cmd.SetComputeTextureParam(s_BakeCloudShadowsCS, s_BakeCloudShadowsKernel, _FlowmapB, cloudLayer.layerB.flowmap.value);
+                cmd.SetComputeTextureParam(bakeCloudShadowsCS, bakeCloudShadowsKernel, _FlowmapA, cloudLayer.layerA.flowmap.value);
+                cmd.SetComputeTextureParam(bakeCloudShadowsCS, bakeCloudShadowsKernel, _FlowmapB, cloudLayer.layerB.flowmap.value);
 
                 // Keywords
                 bool enabled1 = cloudLayer.layerA.castShadows.value;
                 var mode1 = cloudLayer.layerA.distortionMode.value;
-                CoreUtils.SetKeyword(s_BakeCloudShadowsCS, "LAYER1_OFF", !enabled1);
-                CoreUtils.SetKeyword(s_BakeCloudShadowsCS, "LAYER1_STATIC", enabled1 && mode1 == CloudDistortionMode.None);
-                CoreUtils.SetKeyword(s_BakeCloudShadowsCS, "LAYER1_PROCEDURAL", enabled1 && mode1 == CloudDistortionMode.Procedural);
-                CoreUtils.SetKeyword(s_BakeCloudShadowsCS, "LAYER1_FLOWMAP", enabled1 && mode1 == CloudDistortionMode.Flowmap);
+                CoreUtils.SetKeyword(bakeCloudShadowsCS, "LAYER1_OFF", !enabled1);
+                CoreUtils.SetKeyword(bakeCloudShadowsCS, "LAYER1_STATIC", enabled1 && mode1 == CloudDistortionMode.None);
+                CoreUtils.SetKeyword(bakeCloudShadowsCS, "LAYER1_PROCEDURAL", enabled1 && mode1 == CloudDistortionMode.Procedural);
+                CoreUtils.SetKeyword(bakeCloudShadowsCS, "LAYER1_FLOWMAP", enabled1 && mode1 == CloudDistortionMode.Flowmap);
 
                 bool enabled2 = (cloudLayer.layers.value == CloudMapMode.Double) && cloudLayer.layerB.castShadows.value;
                 var mode2 = cloudLayer.layerB.distortionMode.value;
-                CoreUtils.SetKeyword(s_BakeCloudShadowsCS, "LAYER2_OFF", !enabled2);
-                CoreUtils.SetKeyword(s_BakeCloudShadowsCS, "LAYER2_STATIC", enabled2 && mode2 == CloudDistortionMode.None);
-                CoreUtils.SetKeyword(s_BakeCloudShadowsCS, "LAYER2_PROCEDURAL", enabled2 && mode2 == CloudDistortionMode.Procedural);
-                CoreUtils.SetKeyword(s_BakeCloudShadowsCS, "LAYER2_FLOWMAP", enabled2 && mode2 == CloudDistortionMode.Flowmap);
+                CoreUtils.SetKeyword(bakeCloudShadowsCS, "LAYER2_OFF", !enabled2);
+                CoreUtils.SetKeyword(bakeCloudShadowsCS, "LAYER2_STATIC", enabled2 && mode2 == CloudDistortionMode.None);
+                CoreUtils.SetKeyword(bakeCloudShadowsCS, "LAYER2_PROCEDURAL", enabled2 && mode2 == CloudDistortionMode.Procedural);
+                CoreUtils.SetKeyword(bakeCloudShadowsCS, "LAYER2_FLOWMAP", enabled2 && mode2 == CloudDistortionMode.Flowmap);
 
                 // Dispatch
                 const int groupSizeX = 8;
                 const int groupSizeY = 8;
                 int threadGroupX = (cloudShadowsResolution + (groupSizeX - 1)) / groupSizeX;
                 int threadGroupY = (cloudShadowsResolution + (groupSizeY - 1)) / groupSizeY;
 
-                cmd.DispatchCompute(s_BakeCloudShadowsCS, s_BakeCloudShadowsKernel, threadGroupX, threadGroupY, 1);
+                cmd.DispatchCompute(bakeCloudShadowsCS, bakeCloudShadowsKernel, threadGroupX, threadGroupY, 1);
                 cloudShadowsRT.rt.IncrementUpdateCount();
             }
         }
 
-        static PrecomputationCache s_PrecomputationCache = new PrecomputationCache();
+        static PrecomputationCache s_PrecomputationCache = null;
+        static PrecomputationCache PrecomputationCacheInstance => s_PrecomputationCache ??= new PrecomputationCache();
+
         PrecomputationData m_PrecomputedData;
+
+#if UNITY_EDITOR
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        static void ResetStaticsOnLoad()
+        {
+            s_PrecomputationCache?.Clear();
+            s_PrecomputationCache = null;
+        }
+#endif
     }
 }