Rework pipeline shader spec info

include/nbl/asset/ICPUComputePipeline.h

@@ -17,71 +17,55 @@ class ICPUComputePipeline : public ICPUPipeline<IPipeline<ICPUPipelineLayout>>
         using base_t = ICPUPipeline<IPipeline<ICPUPipelineLayout>>;
 
     public:
-        struct SCreationParams final : IPipeline<ICPUPipelineLayout>::SCreationParams
-        {
-            IPipelineBase::SShaderSpecInfo<true> shader;
-        };
-        static core::smart_refctd_ptr<ICPUComputePipeline> create(const SCreationParams& params)
+        explicit ICPUComputePipeline(const ICPUPipelineLayout* layout):
+          base_t(core::smart_refctd_ptr<ICPUPipelineLayout>(layout))
+          {}
+
+        static core::smart_refctd_ptr<ICPUComputePipeline> create(const ICPUPipelineLayout* layout)
         {
-            if (!params.layout)
-                return nullptr;
-            auto retval = new ICPUComputePipeline(core::smart_refctd_ptr<const ICPUPipelineLayout>(params.layout));
-
-            if (!retval->setSpecInfo(params.shader))
-            {
-                retval->drop();
-                return nullptr;
-            }
+            auto retval = new ICPUComputePipeline(layout);
             return core::smart_refctd_ptr<ICPUComputePipeline>(retval,core::dont_grab);
         }
 
-        inline core::smart_refctd_ptr<IAsset> clone(uint32_t _depth = ~0u) const override final
+        inline base_t* clone_impl(core::smart_refctd_ptr<const ICPUPipelineLayout>&& layout, uint32_t depth) const override final
         {
-            core::smart_refctd_ptr<ICPUPipelineLayout> layout;
-            if (_depth>0u && m_layout)
-                layout = core::smart_refctd_ptr_static_cast<ICPUPipelineLayout>(m_layout->clone(_depth-1u));
-
-            auto cp = new ICPUComputePipeline(std::move(layout));
-            if (m_specInfo.shader)
-            {
-                SShaderSpecInfo<true> specInfo = m_specInfo;
-                if (_depth > 0u)
-                {
-                  specInfo.shader = core::smart_refctd_ptr_static_cast<IShader>(m_specInfo.shader->clone(_depth - 1u));
-                }
-                cp->setSpecInfo(specInfo);
-            }
-            return core::smart_refctd_ptr<ICPUComputePipeline>(cp,core::dont_grab);
+            auto newPipeline = new ICPUComputePipeline(std::move(layout));
+            newPipeline->m_specInfo = newPipeline->cloneSpecInfo(m_specInfo, depth);
+            return newPipeline;
         }
 
         constexpr static inline auto AssetType = ET_COMPUTE_PIPELINE;
         inline E_TYPE getAssetType() const override { return AssetType; }
 
-		//!
-		inline size_t getDependantCount() const override {return 2;}
+        //!
+        inline size_t getDependantCount() const override { return 2; }
+
+        inline virtual std::span<SShaderSpecInfo> getSpecInfo(hlsl::ShaderStage stage) override final
+        {
+            if (stage==hlsl::ShaderStage::ESS_COMPUTE && isMutable())
+                return {&m_specInfo,1};
+            return {};
+        }
+
+        inline virtual bool valid() const override final
+        {
+            return m_specInfo.valid();
+        }
 
     protected:
         using base_t::base_t;
         virtual ~ICPUComputePipeline() = default;
 
-		inline IAsset* getDependant_impl(const size_t ix) override
+        inline IAsset* getDependant_impl(const size_t ix) override
         {
             if (ix!=0)
                 return m_specInfo.shader.get();
             return const_cast<ICPUPipelineLayout*>(m_layout.get());
         }
 
-        inline bool setSpecInfo(const IPipelineBase::SShaderSpecInfo<true>& info)
-        {
-          const auto specSize = info.valid();
-          if (specSize < 0) return false;
-          if (info.stage != hlsl::ESS_COMPUTE) return false;
-          m_specInfo = info;
-          return true;
-        }
 
     private:
-        SShaderSpecInfo<true> m_specInfo;
+        SShaderSpecInfo m_specInfo;
 
 };
 

include/nbl/asset/ICPUGraphicsPipeline.h

@@ -13,135 +13,105 @@
 namespace nbl::asset
 {
 
-class ICPUGraphicsPipeline final : public ICPUPipeline<IGraphicsPipeline<IPipelineBase::SShaderSpecInfo<true>, ICPUPipelineLayout,ICPURenderpass>>
+class ICPUGraphicsPipeline final : public ICPUPipeline<IGraphicsPipeline<ICPUPipelineLayout,ICPURenderpass>>
 {
-        using pipeline_base_t = IGraphicsPipeline<SShaderSpecInfo<true>,ICPUPipelineLayout, ICPURenderpass>;
+        using pipeline_base_t = IGraphicsPipeline<ICPUPipelineLayout, ICPURenderpass>;
         using base_t = ICPUPipeline<pipeline_base_t>;
 
     public:
-		struct SCreationParams final : pipeline_base_t::SCreationParams
-		{
-			private:
-				friend class ICPUGraphicsPipeline;
-				template<typename ExtraLambda>
-				inline bool impl_valid(ExtraLambda&& extra) const
-				{
-					return pipeline_base_t::SCreationParams::impl_valid(std::move(extra));
-				}
-		};
-
-		static core::smart_refctd_ptr<ICPUGraphicsPipeline> create(const SCreationParams& params)
-		{
-			// we'll validate the specialization info later when attempting to set it
-        if (!params.impl_valid([](const SShaderSpecInfo<true>& info)->bool{return true;}))
-            return nullptr;
-        auto retval = new ICPUGraphicsPipeline(params);
-        for (const auto spec : params.shaders)
+        explicit ICPUGraphicsPipeline(const ICPUPipelineLayout* layout)
+            : base_t(layout, {}, {})
+            {}
+
+        static core::smart_refctd_ptr<ICPUGraphicsPipeline> create(const ICPUPipelineLayout* layout)
         {
-            if (spec.shader) retval->setSpecInfo(spec);
+            auto retval = new ICPUGraphicsPipeline(layout);
+            return core::smart_refctd_ptr<ICPUGraphicsPipeline>(retval,core::dont_grab);
         }
-        return core::smart_refctd_ptr<ICPUGraphicsPipeline>(retval,core::dont_grab);
-		}
-
-    inline core::smart_refctd_ptr<IAsset> clone(uint32_t _depth = ~0u) const override final
-    {
-        core::smart_refctd_ptr<ICPUPipelineLayout> layout;
-        if (_depth>0u && m_layout) 
-					layout = core::smart_refctd_ptr_static_cast<ICPUPipelineLayout>(m_layout->clone(_depth-1u));
 
-				auto* cp = [&] {
-            std::array<SShaderSpecInfo<true>, GRAPHICS_SHADER_STAGE_COUNT> _shaders;
+        inline base_t* clone_impl(core::smart_refctd_ptr<const ICPUPipelineLayout>&& layout, uint32_t depth) const override final
+        {
+            auto* newPipeline = new ICPUGraphicsPipeline(layout.get());
             for (auto i = 0; i < GRAPHICS_SHADER_STAGE_COUNT; i++)
-              _shaders[i] = m_specInfos[i];
-            const SCreationParams params = { {
-              .shaders = _shaders,
-              .cached = m_params,
-              .renderpass = m_renderpass.get()
-            } };
-            return new ICPUGraphicsPipeline(params);
-				}();
-				for (auto specInfo : m_specInfos)
-				{
-            if (specInfo.shader)
+                newPipeline->m_specInfos[i] = m_specInfos[i];
+            newPipeline->m_params = m_params;
+            newPipeline->m_renderpass = m_renderpass;
+
+            for (auto specInfo_i = 0u; specInfo_i < m_specInfos.size(); specInfo_i++)
+            {
+                newPipeline->m_specInfos[specInfo_i] = newPipeline->cloneSpecInfo(m_specInfos[specInfo_i], depth);
+            }
+
+            return newPipeline;
+        }
+
+        constexpr static inline auto AssetType = ET_GRAPHICS_PIPELINE;
+        inline E_TYPE getAssetType() const override { return AssetType; }
+
+        inline size_t getDependantCount() const override
+        {
+            auto stageCount = 2; // the layout and renderpass
+            for (const auto& info : m_specInfos)
             {
-                auto newSpecInfo = specInfo;
-                if (_depth>0u)
-                {
-                    newSpecInfo.shader = core::smart_refctd_ptr_static_cast<IShader>(specInfo.shader->clone(_depth-1u));
-                }
-                cp->setSpecInfo(newSpecInfo);
+              if (info.shader)
+                stageCount++;
             }
-				}
-
-        return core::smart_refctd_ptr<ICPUGraphicsPipeline>(cp,core::dont_grab);
-    }
-
-
-		constexpr static inline auto AssetType = ET_GRAPHICS_PIPELINE;
-		inline E_TYPE getAssetType() const override { return AssetType; }
-
-		inline size_t getDependantCount() const override
-		{
-			auto stageCount = 2; // the layout and renderpass
-			for (const auto& info : m_specInfos)
-			{
-        if (info.shader)
-          stageCount++;
-			}
-			return stageCount;
-		}
-
-		// extras for this class
-		inline const SCachedCreationParams& getCachedCreationParams() const {return base_t::getCachedCreationParams();}
+            return stageCount;
+        }
+
         inline SCachedCreationParams& getCachedCreationParams()
         {
             assert(isMutable());
             return m_params;
         }
 
+        inline virtual std::span<SShaderSpecInfo> getSpecInfo(hlsl::ShaderStage stage) override final
+        {
+            const auto stageIndex = stageToIndex(stage);
+            if (isMutable() && stageIndex != -1)
+            {
+                return { &m_specInfos[stageIndex], 1 };
+            }
+            return {};
+        }
+
+        inline virtual bool valid() const override final
+        {
+            if (!m_layout) return false;
+
+            // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkGraphicsPipelineCreateInfo.html#VUID-VkGraphicsPipelineCreateInfo-dynamicRendering-06576
+            if (!m_renderpass || m_params.subpassIx >= m_renderpass->getSubpassCount()) return false;
+
+            core::bitflag<hlsl::ShaderStage> stagePresence = {};
+            for (auto shader_i = 0u; shader_i < m_specInfos.size(); shader_i++)
+            {
+                const auto& info = m_specInfos[shader_i];
+                if (info.shader)
+                    stagePresence |= indexToStage(shader_i);
+            }
+            return isValidStagePresence(stagePresence, m_params.primitiveAssembly.primitiveType);
+        }
+
     protected:
-		using base_t::base_t;
-        ~ICPUGraphicsPipeline() = default;
-
-		inline IAsset* getDependant_impl(const size_t ix) override
-		{
-			if (ix==0)
-				return const_cast<ICPUPipelineLayout*>(m_layout.get());
-			if (ix==1)
-				return m_renderpass.get();
-			size_t stageCount = 0;
-			for (auto& specInfo : m_specInfos)
-			{
-        if (specInfo.shader)
+        using base_t::base_t;
+        virtual ~ICPUGraphicsPipeline() override = default;
+
+        inline IAsset* getDependant_impl(const size_t ix) override
         {
-          if ((stageCount++)==ix-2)
-            return specInfo.shader.get();
+            if (ix==0)
+                return const_cast<ICPUPipelineLayout*>(m_layout.get());
+            if (ix==1)
+                return m_renderpass.get();
+            size_t stageCount = 0;
+            for (auto& specInfo : m_specInfos)
+            {
+                if (specInfo.shader)
+                    if ((stageCount++)==ix-2) return specInfo.shader.get();
+            }
+            return nullptr;
         }
-			}
-			return nullptr;
-		}
-
-		inline int8_t stageToIndex(const hlsl::ShaderStage stage) const
-		{
-			const auto stageIx = hlsl::findLSB(stage);
-			if (stageIx<0 || stageIx>= GRAPHICS_SHADER_STAGE_COUNT || hlsl::bitCount(stage)!=1)
-				return -1;
-			return stageIx;
-		}
-
-    inline bool setSpecInfo(const SShaderSpecInfo<true>& info)
-		{
-			assert(isMutable());
-      const auto specSize = info.valid();
-      if (specSize<0) return false;
-			const auto stage = info.stage;
-			const auto stageIx = stageToIndex(stage);
-			if (stageIx<0) return false;
-			m_specInfos[stageIx] = info;
-			return true;
-		}
-
-		SShaderSpecInfo<true> m_specInfos[GRAPHICS_SHADER_STAGE_COUNT];
+
+        std::array<SShaderSpecInfo, GRAPHICS_SHADER_STAGE_COUNT> m_specInfos;
 };
 
 }