Shader Pipeline

include/IVideoDriver.h

@@ -20,6 +20,11 @@
 
 namespace irr
 {
+namespace asset
+{
+    class ISpecializationInfo;
+}
+
 namespace io
 {
 	class IReadFile;
@@ -34,6 +39,8 @@ namespace video
 	class IImageWriter;
 	class IMaterialRenderer;
 	class IGPUProgrammingServices;
+    class IGPUShader;
+    class IGPUSpecializedShader;
 
 	//! enumeration for geometry transformation states
 	enum E_4X3_TRANSFORMATION_STATE
@@ -115,6 +122,7 @@ namespace video
         virtual bool isAllowedTextureFormat(asset::E_FORMAT _fmt) const = 0;
         virtual bool isHardwareBlendableFormat(asset::E_FORMAT _fmt) const = 0;
 
+        virtual IGPUSpecializedShader* createSpecializedShader(const IGPUShader* _unspecialized, const asset::ISpecializationInfo* _specInfo) = 0;
 
 		//! Applications must call this method before performing any rendering.
 		/** This method can clear the back- and the z-buffer.

include/IrrlichtDevice.h

@@ -274,9 +274,6 @@ namespace irr
         virtual asset::IAssetManager& getAssetManager();
         virtual const asset::IAssetManager& getAssetManager() const;
 
-        virtual asset::IIncludeHandler* getIncludeHandler() { return nullptr; }
-        virtual const asset::IIncludeHandler* getIncludeHandler() const { return nullptr; }
-
     private:
         void addLoadersAndWriters();
 

include/irr/asset/CShaderIntrospector.h

@@ -0,0 +1,103 @@
+#ifndef __IRR_C_SHADER_INTROSPECTOR_H_INCLUDED__
+#define __IRR_C_SHADER_INTROSPECTOR_H_INCLUDED__
+
+#include <cstdint>
+#include "irr/core/Types.h"
+#include "irr/asset/ShaderCommons.h"
+#include "irr/asset/ShaderRes.h"
+#include "irr/asset/ICPUShader.h"
+#include "irr/asset/IGLSLCompiler.h"
+
+namespace spirv_cross
+{
+    class ParsedIR;
+    class Compiler;
+    struct SPIRType;
+}
+namespace irr
+{
+namespace asset
+{
+
+struct SIntrospectionData
+{
+    struct SSpecConstant
+    {
+        enum E_TYPE
+        {
+            ET_U64,
+            ET_I64,
+            ET_U32,
+            ET_I32,
+            ET_F64,
+            ET_F32
+        };
+
+        uint32_t id;
+        size_t byteSize;
+        E_TYPE type;
+        std::string name;
+        union {
+            uint64_t u64;
+            int64_t i64;
+            uint32_t u32;
+            int32_t i32;
+            double f64;
+            float f32;
+        } defaultValue;
+    };
+    //! Sorted by `id`
+    core::vector<SSpecConstant> specConstants;
+    //! Each vector is sorted by `binding`
+    core::vector<SShaderResourceVariant> descriptorSetBindings[4];
+    //! Sorted by `location`
+    core::vector<SShaderInfoVariant> inputOutput;
+
+    struct {
+        bool present;
+        SShaderPushConstant info;
+    } pushConstant;
+
+    bool canSpecializationlesslyCreateDescSetFrom() const
+    {
+        for (const auto& descSet : descriptorSetBindings)
+        {
+            auto found = std::find_if(descSet.begin(), descSet.end(), [](const SShaderResourceVariant& bnd) { return bnd.descCountIsSpecConstant; });
+            if (found != descSet.end())
+                return false;
+        }
+        return true;
+    }
+};
+
+class CShaderIntrospector : public core::Uncopyable
+{
+public:
+    using SEntryPointStagePair = std::pair<std::string, E_SHADER_STAGE>;
+
+    //In the future there's also going list of enabled extensions
+    CShaderIntrospector(const IGLSLCompiler* _glslcomp, const SEntryPointStagePair& _ep) : m_glslCompiler(_glslcomp,core::dont_grab), m_entryPoint(_ep) {}
+    ~CShaderIntrospector() {
+        for (auto& introData : m_introspectionCache)
+            deinitIntrospectionData(introData.second);
+    }
+
+    const SIntrospectionData* introspect(const ICPUShader* _shader);
+private:
+    SIntrospectionData doIntrospection(spirv_cross::Compiler& _comp, const SEntryPointStagePair& _ep) const;
+    void shaderMemBlockIntrospection(spirv_cross::Compiler& _comp, impl::SShaderMemoryBlock& _res, uint32_t _blockBaseTypeID, uint32_t _varID, const core::unordered_map<uint32_t, const SIntrospectionData::SSpecConstant*>& _mapId2sconst) const;
+    size_t calcBytesizeforType(spirv_cross::Compiler& _comp, const spirv_cross::SPIRType& _type) const;
+
+    static void deinitIntrospectionData(SIntrospectionData& _data);
+    static void deinitShdrMemBlock(impl::SShaderMemoryBlock& _res);
+
+private:
+    core::smart_refctd_ptr<const IGLSLCompiler> m_glslCompiler;
+    SEntryPointStagePair m_entryPoint;
+    core::unordered_map<const ICPUShader*, SIntrospectionData> m_introspectionCache;
+};
+
+}//asset
+}//irr
+
+#endif

include/irr/asset/ICPUShader.h

@@ -2,185 +2,53 @@
 #define __IRR_I_CPU_SHADER_H_INCLUDED__
 
 #include <algorithm>
+#include <string>
 #include "irr/asset/IAsset.h"
-#include "irr/asset/ISPIR_VProgram.h"
 #include "irr/asset/ShaderCommons.h"
-#include "irr/asset/ShaderRes.h"
-#include "irr/core/memory/new_delete.h"
-#include "irr/asset/IParsedShaderSource.h"
-#include "irr/asset/IGLSLCompiler.h"
 
 namespace spirv_cross
 {
     class ParsedIR;
     class Compiler;
     struct SPIRType;
 }
-namespace irr 
-{ 
-namespace asset
-{
-    using SEntryPointStagePair = std::pair<std::string, E_SHADER_STAGE>;
-}//asset
-namespace io
-{
-    class IReadFile;
-}//io
-}//irr
-namespace std
-{
-    template<>
-    struct hash<irr::asset::SEntryPointStagePair>
-    {
-        using T = irr::asset::SEntryPointStagePair;
-        // based on boost::hash_combine
-        size_t operator()(const T& x) const
-        {
-            size_t seed = hash<T::first_type>{}(x.first);
-            return seed ^= hash<underlying_type_t<T::second_type>>{}(x.second) + 0x9e3779b9ull + (seed << 6) + (seed >> 2);
-        }
-    };
-}//std
-
 namespace irr { namespace asset
 {
 
-struct SIntrospectionData
-{
-    struct SSpecConstant
-    {
-        enum E_TYPE
-        {
-            ET_U64,
-            ET_I64,
-            ET_U32,
-            ET_I32,
-            ET_F64,
-            ET_F32
-        };
-
-        uint32_t id;
-        size_t byteSize;
-        E_TYPE type;
-        std::string name;
-        union {
-            uint64_t u64;
-            int64_t i64;
-            uint32_t u32;
-            int32_t i32;
-            double f64;
-            float f32;
-        } defaultValue;
-    };
-    //! Sorted by `id`
-    core::vector<SSpecConstant> specConstants;
-    //! Each vector is sorted by `binding`
-    core::vector<SShaderResourceVariant> descriptorSetBindings[4];
-    //! Sorted by `location`
-    core::vector<SShaderInfoVariant> inputOutput;
-
-    struct {
-        bool present;
-        SShaderPushConstant info;
-    } pushConstant;
-
-    bool canSpecializationlesslyCreateDescSetFrom() const
-    {
-        for (const auto& descSet : descriptorSetBindings)
-        {
-            auto found = std::find_if(descSet.begin(), descSet.end(), [](const SShaderResourceVariant& bnd) { return bnd.descCountIsSpecConstant; });
-            if (found != descSet.end())
-                return false;
-        }
-        return true;
-    }
-};
-
 class ICPUShader : public IAsset
 {
 protected:
     virtual ~ICPUShader()
     {
-        if (m_spirvBytecode)
-            m_spirvBytecode->drop();
-        if (m_parsed)
-            m_parsed->drop();
-        for (auto& introData : m_introspectionCache)
-            SIntrospectionPerformer::deinitIntrospectionData(introData.second);
-        if (m_glslCompiler)
-            m_glslCompiler->drop();
+        if (m_code)
+            m_code->drop();
     }
 
 public:
-    ICPUShader(ICPUBuffer* _spirv) : m_glslCompiler(nullptr), m_spirvBytecode(_spirv), m_parsed(new IParsedShaderSource(m_spirvBytecode, core::defer)) 
-    {
-    }
-    //! While creating from GLSL source, entry point name and stage must be given in advance
-    /**
-    Note: file's name (_glsl param) will be used for resolving relative #include directives! See IGLSLCompiler::resolveIncludeDirectives() for more info.
-    */
-    ICPUShader(IGLSLCompiler* _glslcompiler, core::smart_refctd_ptr<io::IReadFile> _glsl, const std::string& _entryPoint, E_SHADER_STAGE _stage);
-    //! While creating from GLSL source, entry point name and stage must be given in advance
-    /**
-    @param _sourceName will be used for resolving relative #include directives! See IGLSLCompiler::resolveIncludeDirectives() for more info.
-    */
-    ICPUShader(IGLSLCompiler* _glslcompiler, const char* _glsl, const char* _sourceName, const std::string& _entryPoint, E_SHADER_STAGE _stage);
+    ICPUShader(ICPUBuffer* _spirv);
+    ICPUShader(const char* _glsl, const std::string& _entryPoint, E_SHADER_STAGE _stage);
 
     IAsset::E_TYPE getAssetType() const override { return IAsset::ET_SHADER; }
     size_t conservativeSizeEstimate() const override 
     { 
-        if (m_glsl.size())
-            return m_glsl.size();
-        else if (m_spirvBytecode)
-            return m_spirvBytecode->conservativeSizeEstimate();
-        return 0u; //shouldnt ever reach this line
-    }
-    void convertToDummyObject() override { m_glsl.clear(); }
-
-    const ICPUBuffer* getSPIR_VBytecode() const { return m_spirvBytecode; };
-
-    void enableIntrospection();
-    const SIntrospectionData* getIntrospectionData(const SEntryPointStagePair& _entryPoint) const
-    {
-        auto found = m_introspectionCache.find(_entryPoint);
-        return found == m_introspectionCache.end() ? nullptr : &found->second;
-    }
-
-    const core::vector<SEntryPointStagePair>& getStageEntryPoints();
-
-    inline const IParsedShaderSource* getParsed() const
-    {
-        obtainSPIRV();
-        return m_parsed;
+        return m_code->getSize();
     }
+    void convertToDummyObject() override { }
 
-protected:
-    const core::vector<SEntryPointStagePair>& getStageEntryPoints(spirv_cross::Compiler& _comp);
-    void obtainSPIRV() const;
+    const ICPUBuffer* getSPVorGLSL() const { return m_code; };
+    bool containsGLSL() const { return m_containsGLSL; }
 
-protected:
-    IGLSLCompiler* m_glslCompiler;
-    //`mutable` implies that POINTER might be altered (specifically it can be null or not-null when object gets created)
-    //`const` (on the left side of `*`) implies that the OBJECT once created, is not modified
-    mutable const ICPUBuffer* m_spirvBytecode = nullptr;
-    mutable const IParsedShaderSource* m_parsed = nullptr;
-    std::string m_glsl;
-    std::string m_glslOriginFilename;
-
-    using CacheKey = SEntryPointStagePair;
-    core::unordered_map<CacheKey, SIntrospectionData> m_introspectionCache;
-    core::vector<SEntryPointStagePair> m_entryPoints;
+    //! Only relevant when containsGLSL returns true
+    const std::string& getGLSLEntryPoint() const { return m_glslEntryPoint; }
+    //! Only relevant when containsGLSL returns true
+    E_SHADER_STAGE getGLSLStage() const { return m_glslStage; }
 
 protected:
-    struct SIntrospectionPerformer
-    {
-        SIntrospectionData doIntrospection(spirv_cross::Compiler& _comp, const SEntryPointStagePair& _ep) const;
-        void shaderMemBlockIntrospection(spirv_cross::Compiler& _comp, impl::SShaderMemoryBlock& _res, uint32_t _blockBaseTypeID, uint32_t _varID, const core::unordered_map<uint32_t, const SIntrospectionData::SSpecConstant*>& _mapId2sconst) const;
-        size_t calcBytesizeforType(spirv_cross::Compiler& _comp, const spirv_cross::SPIRType& _type) const;
-
-        static void deinitIntrospectionData(SIntrospectionData& _data);
-        static void deinitShdrMemBlock(impl::SShaderMemoryBlock& _res);
-    };
+    //! Might be GLSL null-terminated string or SPIR-V bytecode (denoted by m_containsGLSL)
+    ICPUBuffer* m_code;
+    const bool m_containsGLSL;
+    std::string m_glslEntryPoint;
+    E_SHADER_STAGE m_glslStage = ESS_UNKNOWN;
 };
 
 }}

include/irr/asset/ICPUSpecializedShader.h

@@ -33,12 +33,6 @@ class ICPUSpecializedShader : public IAsset
     inline const ISpecializationInfo* getSpecializationInfo() const { return m_specInfo; }
     inline const ICPUShader* getUnspecialized() const { return m_unspecialized; }
 
-    //! If contained unspecialized ICPUShader hasn't enabled introspection, this function will also return nullptr
-    inline const SIntrospectionData* getIntrospectionData() const
-    { 
-        return m_unspecialized->getIntrospectionData({m_specInfo->entryPoint,m_specInfo->shaderStage});
-    }
-
 private:
     const ICPUShader* m_unspecialized;
     const ISpecializationInfo* m_specInfo;