[Reflection] Fetch more information for Dxil shader reflection

Author: gongminmin

Include/ShaderConductor/ShaderConductor.hpp

@@ -121,6 +121,240 @@ namespace ShaderConductor
         BlobImpl* m_impl = nullptr;
     };
 
+    class SC_API Reflection
+    {
+    public:
+        class ReflectionImpl;
+        struct VariableDesc;
+
+        class SC_API ConstantBuffer
+        {
+            friend class ReflectionImpl;
+
+        public:
+            ConstantBuffer() noexcept;
+            ConstantBuffer(const ConstantBuffer& other);
+            ConstantBuffer(ConstantBuffer&& other) noexcept;
+            ~ConstantBuffer() noexcept;
+
+            ConstantBuffer& operator=(const ConstantBuffer& other);
+            ConstantBuffer& operator=(ConstantBuffer&& other) noexcept;
+
+            bool Valid() const noexcept;
+
+            const char* Name() const noexcept;
+            uint32_t Size() const noexcept;
+
+            uint32_t NumVariables() const noexcept;
+            const VariableDesc* VariableByIndex(uint32_t index) const noexcept;
+            const VariableDesc* VariableByName(const char* name) const noexcept;
+
+        private:
+            class ConstantBufferImpl;
+            ConstantBufferImpl* m_impl = nullptr;
+        };
+
+        class SC_API VariableType
+        {
+            friend class ConstantBuffer;
+
+        public:
+            enum class DataType
+            {
+                Void,
+
+                Bool,
+                Int,
+                Uint,
+                Float,
+
+                Half,
+                Int16,
+                Uint16,
+
+                Struct,
+            };
+
+        public:
+            VariableType() noexcept;
+            VariableType(const VariableType& other);
+            VariableType(VariableType&& other) noexcept;
+            ~VariableType() noexcept;
+
+            VariableType& operator=(const VariableType& other);
+            VariableType& operator=(VariableType&& other) noexcept;
+
+            bool Valid() const noexcept;
+
+            const char* Name() const noexcept;
+            DataType Type() const noexcept;
+            uint32_t Rows() const noexcept;     // Number of rows (for matrices, 1 for other numeric, 0 if not applicable)
+            uint32_t Columns() const noexcept;  // Number of columns (for vectors & matrices, 1 for other numeric, 0 if not applicable)
+            uint32_t Elements() const noexcept; // Number of elements (0 if not an array)
+            uint32_t ElementStride() const noexcept;
+
+            uint32_t NumMembers() const noexcept;
+            const VariableDesc* MemberByIndex(uint32_t index) const noexcept;
+            const VariableDesc* MemberByName(const char* name) const noexcept;
+
+        private:
+            class VariableTypeImpl;
+            VariableTypeImpl* m_impl = nullptr;
+        };
+
+        struct ResourceDesc
+        {
+            char name[256];          // Name of the resource
+            ShaderResourceType type; // Type of resource (e.g. texture, cbuffer, etc.)
+            uint32_t space;
+            uint32_t bindPoint; // Starting bind point
+            uint32_t bindCount; // Number of contiguous bind points (for arrays)
+        };
+
+        struct VariableDesc
+        {
+            char name[256];
+            VariableType type;
+            uint32_t offset; // Offset in cbuffer or stuct
+            uint32_t size;   // Size of the variable
+        };
+
+        enum class ComponentMask : uint8_t
+        {
+            X = 0x1U,
+            Y = 0x2U,
+            Z = 0x4U,
+            W = 0x8U,
+        };
+
+        struct SignatureParameterDesc
+        {
+            char semantic[256];
+            uint32_t semanticIndex;
+            uint32_t location;
+            VariableType::DataType componentType;
+            ComponentMask mask;
+        };
+
+        enum class PrimitiveTopology
+        {
+            Undefined,
+            Points,
+            Lines,
+            LineStrip,
+            Triangles,
+            TriangleStrip,
+
+            LinesAdj,
+            LineStripAdj,
+            TrianglesAdj,
+            TriangleStripAdj,
+
+            Patches_1_CtrlPoint,
+            Patches_2_CtrlPoint,
+            Patches_3_CtrlPoint,
+            Patches_4_CtrlPoint,
+            Patches_5_CtrlPoint,
+            Patches_6_CtrlPoint,
+            Patches_7_CtrlPoint,
+            Patches_8_CtrlPoint,
+            Patches_9_CtrlPoint,
+            Patches_10_CtrlPoint,
+            Patches_11_CtrlPoint,
+            Patches_12_CtrlPoint,
+            Patches_13_CtrlPoint,
+            Patches_14_CtrlPoint,
+            Patches_15_CtrlPoint,
+            Patches_16_CtrlPoint,
+            Patches_17_CtrlPoint,
+            Patches_18_CtrlPoint,
+            Patches_19_CtrlPoint,
+            Patches_20_CtrlPoint,
+            Patches_21_CtrlPoint,
+            Patches_22_CtrlPoint,
+            Patches_23_CtrlPoint,
+            Patches_24_CtrlPoint,
+            Patches_25_CtrlPoint,
+            Patches_26_CtrlPoint,
+            Patches_27_CtrlPoint,
+            Patches_28_CtrlPoint,
+            Patches_29_CtrlPoint,
+            Patches_30_CtrlPoint,
+            Patches_31_CtrlPoint,
+            Patches_32_CtrlPoint,
+        };
+
+        enum class TessellatorOutputPrimitive
+        {
+            Undefined,
+            Point,
+            Line,
+            TriangleCW,
+            TriangleCCW,
+        };
+
+        enum class TessellatorPartitioning
+        {
+            Undefined,
+            Integer,
+            Pow2,
+            FractionalOdd,
+            FractionalEven,
+        };
+
+        enum class TessellatorDomain
+        {
+            Undefined,
+            Line,
+            Triangle,
+            Quad,
+        };
+
+    public:
+        Reflection() noexcept;
+        Reflection(const Reflection& other);
+        Reflection(Reflection&& other) noexcept;
+        ~Reflection() noexcept;
+
+        Reflection& operator=(const Reflection& other);
+        Reflection& operator=(Reflection&& other) noexcept;
+
+        bool Valid() const noexcept;
+
+        uint32_t NumResources() const noexcept;
+        const ResourceDesc* ResourceByIndex(uint32_t index) const noexcept;
+        const ResourceDesc* ResourceByName(const char* name) const noexcept;
+
+        uint32_t NumConstantBuffers() const noexcept;
+        const ConstantBuffer* ConstantBufferByIndex(uint32_t index) const noexcept;
+        const ConstantBuffer* ConstantBufferByName(const char* name) const noexcept;
+
+        uint32_t NumInputParameters() const noexcept;
+        const SignatureParameterDesc* InputParameter(uint32_t index) const noexcept;
+        uint32_t NumOutputParameters() const noexcept;
+        const SignatureParameterDesc* OutputParameter(uint32_t index) const noexcept;
+
+        PrimitiveTopology GSHSInputPrimitive() const noexcept;
+        PrimitiveTopology GSOutputTopology() const noexcept;
+        uint32_t GSMaxNumOutputVertices() const noexcept;
+        uint32_t GSNumInstances() const noexcept;
+
+        TessellatorOutputPrimitive HSOutputPrimitive() const noexcept;
+        TessellatorPartitioning HSPartitioning() const noexcept;
+
+        TessellatorDomain HSDSTessellatorDomain() const noexcept;
+        uint32_t HSDSNumPatchConstantParameters() const noexcept;
+        const SignatureParameterDesc* HSDSPatchConstantParameter(uint32_t index) const noexcept;
+        uint32_t HSDSNumConrolPoints() const noexcept;
+
+        uint32_t CSBlockSizeX() const noexcept;
+        uint32_t CSBlockSizeY() const noexcept;
+        uint32_t CSBlockSizeZ() const noexcept;
+
+    private:
+        ReflectionImpl* m_impl = nullptr;
+    };
+
     class SC_API Compiler
     {
     public:
@@ -182,6 +416,8 @@ namespace ShaderConductor
             int shiftAllSamplersBindings = 0;
             int shiftAllCBuffersBindings = 0;
             int shiftAllUABuffersBindings = 0;
+
+            bool needReflection = false;
         };
 
         struct TargetDesc
@@ -191,22 +427,6 @@ namespace ShaderConductor
             bool asModule;
         };
 
-        struct ReflectionDesc
-        {
-            char name[256];           // Name of the resource
-            ShaderResourceType type;  // Type of resource (e.g. texture, cbuffer, etc.)
-            uint32_t bufferBindPoint; // Buffer's starting bind point
-            uint32_t bindPoint;       // Starting bind point
-            uint32_t bindCount;       // Number of contiguous bind points (for arrays)
-        };
-
-        struct ReflectionResultDesc
-        {
-            Blob descs; // The underneath type is ReflectionDesc
-            uint32_t descCount = 0;
-            uint32_t instructionCount = 0;
-        };
-
         struct ResultDesc
         {
             Blob target;
@@ -215,7 +435,7 @@ namespace ShaderConductor
             Blob errorWarningMsg;
             bool hasError;
 
-            ReflectionResultDesc reflection;
+            Reflection reflection;
         };
 
         struct DisassembleDesc
@@ -250,6 +470,35 @@ namespace ShaderConductor
         static bool LinkSupport();
         static ResultDesc Link(const LinkDesc& modules, const Options& options, const TargetDesc& target);
     };
+
+    inline Reflection::ComponentMask& operator|=(Reflection::ComponentMask& lhs, Reflection::ComponentMask rhs)
+    {
+        lhs = static_cast<Reflection::ComponentMask>(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
+        return lhs;
+    }
+    inline constexpr Reflection::ComponentMask operator|(Reflection::ComponentMask lhs, Reflection::ComponentMask rhs)
+    {
+        return static_cast<Reflection::ComponentMask>(static_cast<uint8_t>(lhs) | static_cast<uint8_t>(rhs));
+    }
+
+    inline Reflection::ComponentMask& operator&=(Reflection::ComponentMask& lhs, Reflection::ComponentMask rhs)
+    {
+        lhs = static_cast<Reflection::ComponentMask>(static_cast<uint8_t>(lhs) & static_cast<uint8_t>(rhs));
+        return lhs;
+    }
+    inline constexpr Reflection::ComponentMask operator&(Reflection::ComponentMask lhs, Reflection::ComponentMask rhs)
+    {
+        return static_cast<Reflection::ComponentMask>(static_cast<uint8_t>(lhs) & static_cast<uint8_t>(rhs));
+    }
+
+    inline bool HasAllFlags(Reflection::ComponentMask flags, Reflection::ComponentMask contains)
+    {
+        return (static_cast<uint8_t>(flags) & static_cast<uint8_t>(contains)) == static_cast<uint8_t>(contains);
+    }
+    inline bool HasAnyFlags(Reflection::ComponentMask flags, Reflection::ComponentMask contains)
+    {
+        return (static_cast<uint8_t>(flags) & static_cast<uint8_t>(contains)) != 0;
+    }
 } // namespace ShaderConductor
 
 #endif // SHADER_CONDUCTOR_HPP