Rework pipeline shader spec info

include/nbl/asset/ICPUComputePipeline.h

@@ -12,57 +12,61 @@ namespace nbl::asset
 {
 
 //! CPU Version of Compute Pipeline
-class ICPUComputePipeline : public ICPUPipeline<IPipeline<ICPUPipelineLayout>,1>
+class ICPUComputePipeline : public ICPUPipeline<IPipeline<ICPUPipelineLayout>>
 {
-        using base_t = ICPUPipeline<IPipeline<ICPUPipelineLayout>,1>;
+        using base_t = ICPUPipeline<IPipeline<ICPUPipelineLayout>>;
 
     public:
-        struct SCreationParams final : IPipeline<ICPUPipelineLayout>::SCreationParams
-        {
-            SShaderSpecInfo 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 base_t* clone_impl(core::smart_refctd_ptr<const ICPUPipelineLayout>&& layout, uint32_t depth) const override final
+        {
+            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; }
 
-        // provide default arg
-        inline IPipelineBase::SShaderSpecInfo getSpecInfo() const {return base_t::getSpecInfo(hlsl::ShaderStage::ESS_COMPUTE);}
+        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;
 
-        base_t* clone_impl(core::smart_refctd_ptr<const ICPUPipelineLayout>&& layout) const override 
-        {
-            return new ICPUComputePipeline(std::move(layout));
-        }
-
-		inline IAsset* getDependant_impl(const size_t ix) override
+        inline IAsset* getDependant_impl(const size_t ix) override
         {
             if (ix!=0)
-                return m_stages[0].shader.get();
+                return m_specInfo.shader.get();
             return const_cast<ICPUPipelineLayout*>(m_layout.get());
         }
 
-        inline int8_t stageToIndex(const hlsl::ShaderStage stage) const override
-        {
-            return stage!=hlsl::ShaderStage::ESS_COMPUTE ? (-1):0;
-        }
+
+    private:
+        SShaderSpecInfo m_specInfo;
+
 };
 
 }

include/nbl/asset/ICPUGraphicsPipeline.h

@@ -13,91 +13,105 @@
 namespace nbl::asset
 {
 
-class ICPUGraphicsPipeline final : public ICPUPipeline<IGraphicsPipeline<ICPUPipelineLayout,ICPURenderpass>,5u>
+class ICPUGraphicsPipeline final : public ICPUPipeline<IGraphicsPipeline<ICPUPipelineLayout,ICPURenderpass>>
 {
-        using pipeline_base_t = IGraphicsPipeline<ICPUPipelineLayout,ICPURenderpass>;
-        using base_t = ICPUPipeline<pipeline_base_t,5u>;
+        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 IPipelineBase::SShaderSpecInfo& info)->bool{return true;}))
-                return nullptr;
-            auto retval = new ICPUGraphicsPipeline(params);
-            for (const auto spec : params.shaders)
-            if (spec.shader)
-				retval->setSpecInfo(spec);
+        explicit ICPUGraphicsPipeline(const ICPUPipelineLayout* layout)
+            : base_t(layout, {}, {})
+            {}
+
+        static core::smart_refctd_ptr<ICPUGraphicsPipeline> create(const ICPUPipelineLayout* layout)
+        {
+            auto retval = new ICPUGraphicsPipeline(layout);
             return core::smart_refctd_ptr<ICPUGraphicsPipeline>(retval,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& stage : m_stages)
-			if (stage.shader)
-				stageCount++;
-			return stageCount;
-		}
-
-		// extras for this class
-		inline const SCachedCreationParams& getCachedCreationParams() const {return base_t::getCachedCreationParams();}
+        }
+
+        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++)
+                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)
+            {
+              if (info.shader)
+                stageCount++;
+            }
+            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;
-
-		base_t* clone_impl(core::smart_refctd_ptr<const ICPUPipelineLayout>&& layout) const override
-		{
-			std::array<IPipelineBase::SShaderSpecInfo,GRAPHICS_SHADER_STAGE_COUNT> _shaders;
-			for (auto i=0; i<GRAPHICS_SHADER_STAGE_COUNT; i++)
-				_shaders[i] = m_stages[i].info;
-			const SCreationParams params = {{
-				.shaders = _shaders,
-				.cached = m_params,
-				.renderpass = m_renderpass.get()
-			}};
-			return new ICPUGraphicsPipeline(params);
-		}
-		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& stage : m_stages)
-			if (stage.shader)
-			if ((stageCount++)==ix-2)
-				return stage.shader.get();
-			return nullptr;
-		}
-
-		inline int8_t stageToIndex(const hlsl::ShaderStage stage) const override
-		{
-			const auto stageIx = hlsl::findLSB(stage);
-			if (stageIx<0 || stageIx>=GRAPHICS_SHADER_STAGE_COUNT || hlsl::bitCount(stage)!=1)
-				return -1;
-			return stageIx;
-		}
+        using base_t::base_t;
+        virtual ~ICPUGraphicsPipeline() override = 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)
+                    if ((stageCount++)==ix-2) return specInfo.shader.get();
+            }
+            return nullptr;
+        }
+
+        std::array<SShaderSpecInfo, GRAPHICS_SHADER_STAGE_COUNT> m_specInfos;
 };
 
 }