Implement constant buffers for HDRP global variables.

com.unity.render-pipelines.core/Editor/ShaderGenerator/ShaderTypeGeneration.cs

@@ -407,7 +407,15 @@ public string EmitTypeDecl()
 
             shaderText += "// Generated from " + type.FullName + "\n";
             shaderText += "// PackingRules = " + attr.packingRules.ToString() + "\n";
-            if (!attr.omitStructDeclaration)
+
+            if (attr.generateCBuffer)
+            {
+                if (attr.constantRegister != -1)
+                    shaderText += "GLOBAL_CBUFFER_START(" + type.Name + ", b" + attr.constantRegister + ")\n";
+                else
+                    shaderText += "CBUFFER_START(" + type.Name + ")\n";
+            }
+            else if (!attr.omitStructDeclaration)
             {
                 shaderText += "struct " + type.Name + "\n";
                 shaderText += "{\n";
@@ -418,7 +426,11 @@ public string EmitTypeDecl()
                 shaderText += "    " + shaderFieldInfo.ToString() + "\n";
             }
 
-            if (!attr.omitStructDeclaration)
+            if (attr.generateCBuffer)
+            {
+                shaderText += "CBUFFER_END\n";
+            }
+            else if (!attr.omitStructDeclaration)
             {
                 shaderText += "};\n";
             }
@@ -764,6 +776,10 @@ private string EmitPackedGetters()
                         {
                             funcSignature = "float4 " + funcSignature;
                         }
+                        else if (packedInfo.fieldType == typeof(Vector2Int))
+                        {
+                            funcSignature = "int2 " + funcSignature;
+                        }
                         funcBody += "return (" + sourceName + "." + packedInfo.fieldName + ");";
                         break;
                     default:
@@ -850,6 +866,10 @@ private string EmitPackedSetters()
                         {
                             funcSignature += "float4 " + newParamName + ", inout " + type.Name + " " + sourceName + ")";
                         }
+                        else if (packedInfo.fieldType == typeof(Vector2Int))
+                        {
+                            funcSignature += "int2 " + newParamName + ", inout " + type.Name + " " + sourceName + ")";
+                        }
                         funcBody += sourceName + "." + packedInfo.fieldName + " = " + newParamName + ";";
                         break;
                     default:
@@ -939,6 +959,10 @@ private string EmitPackedInit()
                         {
                             funcSignature += "float4 " + newParamName + ", inout " + type.Name + " " + sourceName + ")";
                         }
+                        else if (packedInfo.fieldType == typeof(Vector2Int))
+                        {
+                            funcSignature += "int2 " + newParamName + ", inout " + type.Name + " " + sourceName + ")";
+                        }
                         funcBody += sourceName + "." + packedInfo.fieldName + " = " + newParamName + ";";
                         break;
                     default:
@@ -1015,6 +1039,16 @@ public bool Generate()
                     var arrayInfos = (field.GetCustomAttributes(typeof(HLSLArray), false) as HLSLArray[]);
                     if (arrayInfos.Length != 0)
                     {
+                        // For constant buffers, every element of the array needs to be aligned to a Vector4
+                        if (attr.generateCBuffer &&
+                            arrayInfos[0].elementType != typeof(Vector4) &&
+                            arrayInfos[0].elementType != typeof(ShaderGenUInt4) &&
+                            arrayInfos[0].elementType != typeof(Matrix4x4))
+                        {
+                            Error("Invalid HLSLArray target: '" + field.FieldType + "'" + ", only Vector4, Matrix4x4 and ShaderGenUInt4 are supported for arrays in constant buffers.");
+                            return false;
+                        }
+
                         arraySize = arrayInfos[0].arraySize;
                         fieldType = arrayInfos[0].elementType;
                     }
@@ -1171,6 +1205,10 @@ public bool Generate()
                         EmitPrimitiveType(floatPrecision, 3, arraySize, field.Name, "", m_ShaderFields);
                     else if (fieldType == typeof(Vector4))
                         EmitPrimitiveType(floatPrecision, 4, arraySize, field.Name, "", m_ShaderFields);
+                    else if (fieldType == typeof(Vector2Int))
+                        EmitPrimitiveType(PrimitiveType.Int, 2, arraySize, field.Name, "", m_ShaderFields);
+                    else if (fieldType == typeof(ShaderGenUInt4))
+                        EmitPrimitiveType(PrimitiveType.UInt, 4, arraySize, field.Name, "", m_ShaderFields);
                     else if (fieldType == typeof(Matrix4x4))
                         EmitMatrixType(floatPrecision, 4, 4, arraySize, field.Name, "", m_ShaderFields);
                     else if (!ExtractComplex(field, m_ShaderFields))

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

@@ -0,0 +1,191 @@
+using System.Collections.Generic;
+using Unity.Collections.LowLevel.Unsafe;
+
+namespace UnityEngine.Rendering
+{
+    /// <summary>
+    /// Constant Buffer management class.
+    /// </summary>
+    public class ConstantBuffer
+    {
+        static List<ConstantBufferBase> m_RegisteredConstantBuffers = new List<ConstantBufferBase>();
+
+        /// <summary>
+        /// Update the GPU data of the constant buffer and bind it globally.
+        /// </summary>
+        /// <typeparam name="CBType">The type of structure representing the constant buffer data.</typeparam>
+        /// <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 static void PushGlobal<CBType>(CommandBuffer cmd, in CBType data, int shaderId) where CBType : struct
+        {
+            var cb = TypedConstantBuffer<CBType>.instance;
+
+            cb.UpdateData(cmd, data);
+            cb.SetGlobal(cmd, shaderId);
+        }
+
+        /// <summary>
+        /// Update the GPU data of the constant buffer and bind it to a compute shader.
+        /// </summary>
+        /// <typeparam name="CBType">The type of structure representing the constant buffer data.</typeparam>
+        /// <param name="cmd">Command Buffer used to execute the graphic commands.</param>
+        /// <param name="data">Input data of the constant buffer.</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 static void Push<CBType>(CommandBuffer cmd, in CBType data, ComputeShader cs, int shaderId) where CBType : struct
+        {
+            var cb = TypedConstantBuffer<CBType>.instance;
+
+            cb.UpdateData(cmd, data);
+            cb.Set(cmd, cs, shaderId);
+        }
+
+        /// <summary>
+        /// Update the GPU data of the constant buffer and bind it to a material.
+        /// </summary>
+        /// <typeparam name="CBType">The type of structure representing the constant buffer data.</typeparam>
+        /// <param name="cmd">Command Buffer used to execute the graphic commands.</param>
+        /// <param name="data">Input data of the constant buffer.</param>
+        /// <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 static void Push<CBType>(CommandBuffer cmd, in CBType data, Material mat, int shaderId) where CBType : struct
+        {
+            var cb = TypedConstantBuffer<CBType>.instance;
+
+            cb.UpdateData(cmd, data);
+            cb.Set(mat, shaderId);
+        }
+
+        /// <summary>
+        /// Update the GPU data of the constant buffer.
+        /// </summary>
+        /// <typeparam name="CBType">The type of structure representing the constant buffer data.</typeparam>
+        /// <param name="cmd">Command Buffer used to execute the graphic commands.</param>
+        /// <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;
+
+            cb.UpdateData(cmd, data);
+        }
+
+        /// <summary>
+        /// Bind the constant buffer globally.
+        /// </summary>
+        /// <typeparam name="CBType">The type of structure representing the constant buffer data.</typeparam>
+        /// <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 static void SetGlobal<CBType>(CommandBuffer cmd, int shaderId) where CBType : struct
+        {
+            var cb = TypedConstantBuffer<CBType>.instance;
+
+            cb.SetGlobal(cmd, shaderId);
+        }
+
+        /// <summary>
+        /// Bind the constant buffer to a compute shader.
+        /// </summary>
+        /// <typeparam name="CBType">The type of structure representing the constant buffer data.</typeparam>
+        /// <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 static void Set<CBType>(CommandBuffer cmd, ComputeShader cs, int shaderId) where CBType : struct
+        {
+            var cb = TypedConstantBuffer<CBType>.instance;
+
+            cb.Set(cmd, cs, shaderId);
+        }
+
+        /// <summary>
+        /// Bind the constant buffer to a material.
+        /// </summary>
+        /// <typeparam name="CBType">The type of structure representing the constant buffer data.</typeparam>
+        /// <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 static void Set<CBType>(Material mat, int shaderId) where CBType : struct
+        {
+            var cb = TypedConstantBuffer<CBType>.instance;
+
+            cb.Set(mat, shaderId);
+        }
+
+        /// <summary>
+        /// Release all currently allocated constant buffers.
+        /// This needs to be called before shutting down the application.
+        /// </summary>
+        public static void ReleaseAll()
+        {
+            foreach (var cb in m_RegisteredConstantBuffers)
+                cb.Release();
+
+            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
+        {
+            CBType[] m_Data = new CBType[1]; // Array is required by the ComputeBuffer SetData API
+            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;
+
+            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;
+                cmd.SetComputeBufferData(m_GPUConstantBuffer, m_Data);
+            }
+
+            public void SetGlobal(CommandBuffer cmd, int 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);
+            }
+
+            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);
+            }
+
+            public override void Release()
+            {
+                CoreUtils.SafeRelease(m_GPUConstantBuffer);
+                s_Instance = null;
+            }
+        }
+    }
+}

com.unity.render-pipelines.core/Runtime/ShaderGenerator/ShaderGeneratorAttributes.cs

@@ -94,6 +94,14 @@ public class GenerateHLSL : System.Attribute
         /// Generate structure declaration or not.
         /// </summary>
         public bool omitStructDeclaration;
+        /// <summary>
+        /// Generate constant buffer declaration or not.
+        /// </summary>
+        public bool generateCBuffer;
+        /// <summary>
+        /// If specified, when generating a constant buffer, use this explicit register.
+        /// </summary>
+        public int constantRegister;
 
         /// <summary>
         /// GenerateHLSL attribute constructor.
@@ -105,7 +113,10 @@ public class GenerateHLSL : System.Attribute
         /// <param name="paramDefinesStart">Start value of debug defines.</param>
         /// <param name="omitStructDeclaration">Omit structure declaration.</param>
         /// <param name="containsPackedFields">Contains packed fields.</param>
-        public GenerateHLSL(PackingRules rules = PackingRules.Exact, bool needAccessors = true, bool needSetters = false, bool needParamDebug = false, int paramDefinesStart = 1, bool omitStructDeclaration = false, bool containsPackedFields = false)
+        /// <param name="generateCBuffer">Generate a constant buffer.</param>
+        /// <param name="constantRegister">When generating a constant buffer, specify the optional constant register.</param>
+        public GenerateHLSL(PackingRules rules = PackingRules.Exact, bool needAccessors = true, bool needSetters = false, bool needParamDebug = false, int paramDefinesStart = 1,
+                                bool omitStructDeclaration = false, bool containsPackedFields = false, bool generateCBuffer = false, int constantRegister = -1)
         {
             packingRules = rules;
             this.needAccessors = needAccessors;
@@ -114,6 +125,8 @@ public GenerateHLSL(PackingRules rules = PackingRules.Exact, bool needAccessors
             this.paramDefinesStart = paramDefinesStart;
             this.omitStructDeclaration = omitStructDeclaration;
             this.containsPackedFields = containsPackedFields;
+            this.generateCBuffer = generateCBuffer;
+            this.constantRegister = constantRegister;
         }
     }
 
@@ -183,7 +196,7 @@ public class HLSLArray : System.Attribute
         /// <summary>
         /// Size of the array.
         /// </summary>
-        public int  arraySize;
+        public int arraySize;
         /// <summary>
         /// Type of the array elements.
         /// </summary>
@@ -282,5 +295,11 @@ public PackingAttribute(string displayName = "", FieldPacking packingScheme = Fi
         }
     }
 
+    /// <summary>
+    /// This type needs to be used when generating unsigned integer arrays for constant buffers.
+    /// </summary>
+    public struct ShaderGenUInt4
+    {
 
+    }
 }

com.unity.render-pipelines.high-definition/Editor/Material/UIBlocks/AxfSurfaceInputsUIBlock.cs

@@ -426,7 +426,6 @@ void DrawAxfSurfaceOptionsGUI()
                     BRDFVariants |= ((uint)wardVariant) << 2;
                     BRDFVariants |= ((uint)blinnVariant) << 4;
 
-//                    cmd.SetGlobalFloat( HDShaderIDs._TexturingModeFlags, *(float*) &texturingModeFlags );
                     m_SVBRDF_BRDFType.floatValue = (float)BRDFType;
                     m_SVBRDF_BRDFVariants.floatValue = (float)BRDFVariants;
 
@@ -488,8 +487,6 @@ void DrawAxfSurfaceOptionsGUI()
                         clearcoatRefraction = EditorGUILayout.Toggle("Enable Refraction", clearcoatRefraction);
                     }
 
-//                    cmd.SetGlobalFloat( HDShaderIDs._TexturingModeFlags, *(float*) &texturingModeFlags );
-
                     --EditorGUI.indentLevel;
                     break;
                 }