Merge branch '10.x.x/release' into HDRP/backport-4265

Author: sebastienlagarde

com.unity.render-pipelines.core/Runtime/Common/ConstantBuffer.cs

@@ -19,7 +19,7 @@ public class ConstantBuffer
         /// <param name="shaderId">Shader porperty id to bind the constant buffer to.</param>
         public static void PushGlobal<CBType>(CommandBuffer cmd, in CBType data, int shaderId) where CBType : struct
         {
-            var cb = TypedConstantBuffer<CBType>.instance;
+            var cb = ConstantBufferSingleton<CBType>.instance;
 
             cb.UpdateData(cmd, data);
             cb.SetGlobal(cmd, shaderId);
@@ -35,7 +35,7 @@ public static void PushGlobal<CBType>(CommandBuffer cmd, in CBType data, int sha
         /// <param name="shaderId">Shader porperty id to bind the constant buffer to.</param>
         public static void Push<CBType>(CommandBuffer cmd, in CBType data, ComputeShader cs, int shaderId) where CBType : struct
         {
-            var cb = TypedConstantBuffer<CBType>.instance;
+            var cb = ConstantBufferSingleton<CBType>.instance;
 
             cb.UpdateData(cmd, data);
             cb.Set(cmd, cs, shaderId);
@@ -51,7 +51,7 @@ public static void Push<CBType>(CommandBuffer cmd, in CBType data, ComputeShader
         /// <param name="shaderId">Shader porperty id to bind the constant buffer to.</param>
         public static void Push<CBType>(CommandBuffer cmd, in CBType data, Material mat, int shaderId) where CBType : struct
         {
-            var cb = TypedConstantBuffer<CBType>.instance;
+            var cb = ConstantBufferSingleton<CBType>.instance;
 
             cb.UpdateData(cmd, data);
             cb.Set(mat, shaderId);
@@ -65,7 +65,7 @@ public static void Push<CBType>(CommandBuffer cmd, in CBType data, Material mat,
         /// <param name="data">Input data of the constant buffer.</param>
         public static void UpdateData<CBType>(CommandBuffer cmd, in CBType data) where CBType : struct
         {
-            var cb = TypedConstantBuffer<CBType>.instance;
+            var cb = ConstantBufferSingleton<CBType>.instance;
 
             cb.UpdateData(cmd, data);
         }
@@ -78,7 +78,7 @@ public static void UpdateData<CBType>(CommandBuffer cmd, in CBType data) where C
         /// <param name="shaderId">Shader porperty id to bind the constant buffer to.</param>
         public static void SetGlobal<CBType>(CommandBuffer cmd, int shaderId) where CBType : struct
         {
-            var cb = TypedConstantBuffer<CBType>.instance;
+            var cb = ConstantBufferSingleton<CBType>.instance;
 
             cb.SetGlobal(cmd, shaderId);
         }
@@ -92,7 +92,7 @@ public static void SetGlobal<CBType>(CommandBuffer cmd, int shaderId) where CBTy
         /// <param name="shaderId">Shader porperty id to bind the constant buffer to.</param>
         public static void Set<CBType>(CommandBuffer cmd, ComputeShader cs, int shaderId) where CBType : struct
         {
-            var cb = TypedConstantBuffer<CBType>.instance;
+            var cb = ConstantBufferSingleton<CBType>.instance;
 
             cb.Set(cmd, cs, shaderId);
         }
@@ -105,14 +105,14 @@ public static void Set<CBType>(CommandBuffer cmd, ComputeShader cs, int shaderId
         /// <param name="shaderId">Shader porperty id to bind the constant buffer to.</param>
         public static void Set<CBType>(Material mat, int shaderId) where CBType : struct
         {
-            var cb = TypedConstantBuffer<CBType>.instance;
+            var cb = ConstantBufferSingleton<CBType>.instance;
 
             cb.Set(mat, shaderId);
         }
 
         /// <summary>
-        /// Release all currently allocated constant buffers.
-        /// This needs to be called before shutting down the application.
+        /// Release all currently allocated singleton constant buffers.
+        /// This needs to be called before shutting down the application. 
         /// </summary>
         public static void ReleaseAll()
         {
@@ -122,86 +122,149 @@ public static void ReleaseAll()
             m_RegisteredConstantBuffers.Clear();
         }
 
-        internal abstract class ConstantBufferBase
-        {
-            public abstract void Release();
-        }
-
         internal static void Register(ConstantBufferBase cb)
         {
             m_RegisteredConstantBuffers.Add(cb);
         }
 
-        class TypedConstantBuffer<CBType> : ConstantBufferBase where CBType : struct
-        {
-            // Used to track all global bindings used by this CB type.
-            HashSet<int> m_GlobalBindings = new HashSet<int>();
-            // Array is required by the ComputeBuffer SetData API
-            CBType[] m_Data = new CBType[1];
+    }
 
-            static TypedConstantBuffer<CBType> s_Instance = null;
-            internal static TypedConstantBuffer<CBType> instance
-            {
-                get
-                {
-                    if (s_Instance == null)
-                        s_Instance = new TypedConstantBuffer<CBType>();
-                    return s_Instance;
-                }
-                set
-                {
-                    s_Instance = value;
-                }
-            }
-            ComputeBuffer m_GPUConstantBuffer = null;
+    /// <summary>
+    /// The base class of Constant Buffer.
+    /// </summary>
+    public abstract class ConstantBufferBase
+    {
+        /// <summary>
+        /// Release the constant buffer.
+        /// </summary>
+        public abstract void Release();
+    }
 
-            TypedConstantBuffer()
-            {
-                m_GPUConstantBuffer = new ComputeBuffer(1, UnsafeUtility.SizeOf<CBType>(), ComputeBufferType.Constant);
-                ConstantBuffer.Register(this);
-            }
 
-            public void UpdateData(CommandBuffer cmd, in CBType data)
-            {
-                m_Data[0] = data;
+    /// <summary>
+    /// An instance of a constant buffer.
+    /// </summary>
+    /// <typeparam name="CBType">The type of structure representing the constant buffer data.</typeparam>
+    public class ConstantBuffer<CBType> : ConstantBufferBase where CBType : struct
+    {
+        // Used to track all global bindings used by this CB type.
+        HashSet<int> m_GlobalBindings = new HashSet<int>();
+        // Array is required by the ComputeBuffer SetData API
+        CBType[] m_Data = new CBType[1];
+
+
+        ComputeBuffer m_GPUConstantBuffer = null;
+
+        /// <summary>
+        /// Constant Buffer constructor.
+        /// </summary>
+        public ConstantBuffer()
+        {
+            m_GPUConstantBuffer = new ComputeBuffer(1, UnsafeUtility.SizeOf<CBType>(), ComputeBufferType.Constant);
+        }
+
+        /// <summary>
+        /// Update the GPU data of the constant buffer.
+        /// </summary>
+        /// <param name="cmd">Command Buffer used to execute the graphic commands.</param>
+        /// <param name="data">Input data of the constant buffer.</param>
+        public void UpdateData(CommandBuffer cmd, in CBType data)
+        {
+            m_Data[0] = data;
 #if UNITY_2021_1_OR_NEWER
-                cmd.SetBufferData(m_GPUConstantBuffer, m_Data);
+            cmd.SetBufferData(m_GPUConstantBuffer, m_Data);
 #else
                 cmd.SetComputeBufferData(m_GPUConstantBuffer, m_Data);
 #endif
-            }
+        }
 
-            public void SetGlobal(CommandBuffer cmd, int shaderId)
-            {
-                m_GlobalBindings.Add(shaderId);
-                cmd.SetGlobalConstantBuffer(m_GPUConstantBuffer, shaderId, 0, m_GPUConstantBuffer.stride);
-            }
+        /// <summary>
+        /// Bind the constant buffer globally.
+        /// </summary>
+        /// <param name="cmd">Command Buffer used to execute the graphic commands.</param>
+        /// <param name="shaderId">Shader porperty id to bind the constant buffer to.</param>
+        public void SetGlobal(CommandBuffer cmd, int shaderId)
+        {
+            m_GlobalBindings.Add(shaderId);
+            cmd.SetGlobalConstantBuffer(m_GPUConstantBuffer, shaderId, 0, m_GPUConstantBuffer.stride);
+        }
 
-            public void Set(CommandBuffer cmd, ComputeShader cs, int shaderId)
-            {
-                cmd.SetComputeConstantBufferParam(cs, shaderId, m_GPUConstantBuffer, 0, m_GPUConstantBuffer.stride);
-            }
+        /// <summary>
+        /// Bind the constant buffer to a compute shader.
+        /// </summary>
+        /// <param name="cmd">Command Buffer used to execute the graphic commands.</param>
+        /// <param name="cs">Compute shader to which the constant buffer should be bound.</param>
+        /// <param name="shaderId">Shader porperty id to bind the constant buffer to.</param>
+        public void Set(CommandBuffer cmd, ComputeShader cs, int shaderId)
+        {
+            cmd.SetComputeConstantBufferParam(cs, shaderId, m_GPUConstantBuffer, 0, m_GPUConstantBuffer.stride);
+        }
+
+        /// <summary>
+        /// Bind the constant buffer to a material.
+        /// </summary>
+        /// <param name="mat">Material to which the constant buffer should be bound.</param>
+        /// <param name="shaderId">Shader porperty id to bind the constant buffer to.</param>
+        public void Set(Material mat, int shaderId)
+        {
+            // This isn't done via command buffer because as long as the buffer itself is not destroyed,
+            // the binding stays valid. Only the commit of data needs to go through the command buffer.
+            // We do it here anyway for now to simplify user API.
+            mat.SetConstantBuffer(shaderId, m_GPUConstantBuffer, 0, m_GPUConstantBuffer.stride);
+        }
+
+        /// <summary>
+        /// Update the GPU data of the constant buffer and bind it globally.
+        /// </summary>
+        /// <param name="cmd">Command Buffer used to execute the graphic commands.</param>
+        /// <param name="data">Input data of the constant buffer.</param>
+        /// <param name="shaderId">Shader porperty id to bind the constant buffer to.</param>
+        public void PushGlobal(CommandBuffer cmd, in CBType data, int shaderId)
+        {
+            UpdateData(cmd, data);
+            SetGlobal(cmd, shaderId);
+        }
+        
+        /// <summary>
+        /// Release the constant buffers.
+        /// </summary>
+        public override void Release()
+        {
+            // Depending on the device, globally bound buffers can leave stale "valid" shader ids pointing to a destroyed buffer.
+            // In DX11 it does not cause issues but on Vulkan this will result in skipped drawcalls (even if the buffer is not actually accessed in the shader).
+            // To avoid this kind of issues, it's good practice to "unbind" all globally bound buffers upon destruction.
+            foreach (int shaderId in m_GlobalBindings)
+                Shader.SetGlobalConstantBuffer(shaderId, (ComputeBuffer)null, 0, 0);
+            m_GlobalBindings.Clear();
 
-            public void Set(Material mat, int shaderId)
+            CoreUtils.SafeRelease(m_GPUConstantBuffer);
+        }
+    }
+
+    class ConstantBufferSingleton<CBType> : ConstantBuffer<CBType> where CBType : struct
+    {
+        static ConstantBufferSingleton<CBType> s_Instance = null;
+        internal static ConstantBufferSingleton<CBType> instance
+        {
+            get
             {
-                // This isn't done via command buffer because as long as the buffer itself is not destroyed,
-                // the binding stays valid. Only the commit of data needs to go through the command buffer.
-                // We do it here anyway for now to simplify user API.
-                mat.SetConstantBuffer(shaderId, m_GPUConstantBuffer, 0, m_GPUConstantBuffer.stride);
+                if (s_Instance == null)
+                {
+                    s_Instance = new ConstantBufferSingleton<CBType>();
+                    ConstantBuffer.Register(s_Instance);
+                }
+                return s_Instance;
             }
-
-            public override void Release()
+            set
             {
-                // Depending on the device, globally bound buffers can leave stale "valid" shader ids pointing to a destroyed buffer.
-                // In DX11 it does not cause issues but on Vulkan this will result in skipped drawcalls (even if the buffer is not actually accessed in the shader).
-                // To avoid this kind of issues, it's good practice to "unbind" all globally bound buffers upon destruction.
-                foreach (int shaderId in m_GlobalBindings)
-                    Shader.SetGlobalConstantBuffer(shaderId, (ComputeBuffer)null, 0, 0);
-                m_GlobalBindings.Clear();
-
-                CoreUtils.SafeRelease(m_GPUConstantBuffer);
-                s_Instance = null;
+                s_Instance = value;
             }
         }
+
+        public override void Release()
+        {
+            base.Release();
+            s_Instance = null;
+        }
     }
 }

com.unity.render-pipelines.high-definition/Editor/BuildProcessors/HDRPPreprocessShaders.cs

@@ -7,6 +7,7 @@
 using UnityEngine.Rendering.HighDefinition;
 using System.Diagnostics;
 using Debug = UnityEngine.Debug;
+using System.Reflection;
 
 namespace UnityEditor.Rendering.HighDefinition
 {
@@ -297,6 +298,11 @@ public void OnProcessComputeShader(ComputeShader shader, string kernelName, ILis
             if (HDRenderPipeline.currentAsset == null)
                 return;
 
+            // Discard any compute shader use for raytracing if none of the RP asset required it
+            ComputeShader unused;
+            if (!ShaderBuildPreprocessor.playerNeedRaytracing && ShaderBuildPreprocessor.computeShaderCache.TryGetValue(shader.GetInstanceID(), out unused))
+                return;
+
             var exportLog = ShaderBuildPreprocessor.hdrpAssets.Count > 0
                 && ShaderBuildPreprocessor.hdrpAssets.Any(hdrpAsset => hdrpAsset.shaderVariantLogLevel != ShaderVariantLogLevel.Disabled);
 
@@ -535,23 +541,73 @@ public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList<Shad
     class ShaderBuildPreprocessor : IPreprocessBuildWithReport
     {
         private static List<HDRenderPipelineAsset> _hdrpAssets;
+        private static Dictionary<int, ComputeShader> s_ComputeShaderCache;
+        private static bool s_PlayerNeedRaytracing;
 
         public static List<HDRenderPipelineAsset> hdrpAssets
         {
             get
             {
-                if (_hdrpAssets == null || _hdrpAssets.Count == 0) GetAllValidHDRPAssets();
+                if (_hdrpAssets == null || _hdrpAssets.Count == 0)
+                    GetAllValidHDRPAssets();
                 return _hdrpAssets;
             }
         }
 
+        public static Dictionary<int, ComputeShader> computeShaderCache
+        {
+            get
+            {
+                if (s_ComputeShaderCache == null)
+                    BuilRaytracingComputeList();
+                return s_ComputeShaderCache;
+            }
+        }
+
+        public static bool playerNeedRaytracing
+        {
+            get
+            {
+                return s_PlayerNeedRaytracing;
+            }
+        }
+
+        public static void BuilRaytracingComputeList()
+        {
+            if (s_ComputeShaderCache != null)
+                s_ComputeShaderCache.Clear();
+            else
+                s_ComputeShaderCache = new Dictionary<int, ComputeShader>();
+
+            if (HDRenderPipeline.defaultAsset == null)
+                return;
+
+            if (HDRenderPipeline.defaultAsset.renderPipelineRayTracingResources == null)
+                return;
+
+            foreach (var fieldInfo in HDRenderPipeline.defaultAsset.renderPipelineRayTracingResources.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))
+            {
+                ComputeShader computeshader;
+                computeshader = fieldInfo.GetValue(HDRenderPipeline.defaultAsset.renderPipelineRayTracingResources) as ComputeShader;
+
+                if (computeshader != null)
+                {
+                    s_ComputeShaderCache.Add(computeshader.GetInstanceID(), computeshader);
+                }
+            }
+        }
+
         static void GetAllValidHDRPAssets()
         {
+            s_PlayerNeedRaytracing = false;
+
             if (HDRenderPipeline.currentAsset == null)
                 return;
 
-            if (_hdrpAssets != null) _hdrpAssets.Clear();
-            else _hdrpAssets = new List<HDRenderPipelineAsset>();
+            if (_hdrpAssets != null)
+                _hdrpAssets.Clear();
+            else
+                _hdrpAssets = new List<HDRenderPipelineAsset>();
 
             using (ListPool<HDRenderPipelineAsset>.Get(out var tmpAssets))
             {
@@ -642,6 +698,15 @@ static void GetAllValidHDRPAssets()
                     Debug.LogWarning("There is no HDRP Asset provided in GraphicsSettings. Build time can be extremely long without it.");
                 }
             }
+            else
+            {
+                // Take the opportunity to know if we need raytracing at runtime
+                foreach (var hdrpAsset in _hdrpAssets)
+                {
+                    if (hdrpAsset.currentPlatformRenderPipelineSettings.supportRayTracing)
+                        s_PlayerNeedRaytracing = true;
+                }
+            }
 
             /*
             Debug.Log(string.Format("{0} HDRP assets in build:{1}",