IShader, no more conversions, stage is now part of spec info.

include/nbl/asset/IAsset.h

@@ -82,7 +82,7 @@ class IAsset : virtual public core::IReferenceCounted
 			ET_SKELETON = 1ull<<7,							    //!< asset::ICPUSkeleton
 			ET_ANIMATION_LIBRARY = 1ull<<8,						//!< asset::ICPUAnimationLibrary
 			ET_PIPELINE_LAYOUT = 1ull<<9,						//!< asset::ICPUPipelineLayout
-			ET_SHADER = 1ull<<10,								//!< asset::ICPUShader
+			ET_SHADER = 1ull<<10,								//!< asset::IShader
 			ET_RENDERPASS_INDEPENDENT_PIPELINE = 1ull<<12,		//!< asset::ICPURenderpassIndependentPipeline
 			ET_RENDERPASS = 1ull<<13,							//!< asset::ICPURenderpass
 			ET_FRAMEBUFFER = 1ull<<14,							//!< asset::ICPUFramebuffer

include/nbl/asset/ICPUComputePipeline.h

@@ -19,7 +19,7 @@ class ICPUComputePipeline : public ICPUPipeline<IPipeline<ICPUPipelineLayout>,1>
     public:
         struct SCreationParams final : IPipeline<ICPUPipelineLayout>::SCreationParams
         {
-            ICPUShader::SSpecInfo shader;
+            SShaderSpecInfo shader;
         };
         static core::smart_refctd_ptr<ICPUComputePipeline> create(const SCreationParams& params)
         {
@@ -41,8 +41,7 @@ class ICPUComputePipeline : public ICPUPipeline<IPipeline<ICPUPipelineLayout>,1>
 		inline size_t getDependantCount() const override {return 2;}
 
         // provide default arg
-        inline IShader::SSpecInfo<ICPUShader> getSpecInfo() {return base_t::getSpecInfo(ICPUShader::E_SHADER_STAGE::ESS_COMPUTE);}
-        inline IShader::SSpecInfo<const ICPUShader> getSpecInfo() const {return base_t::getSpecInfo(ICPUShader::E_SHADER_STAGE::ESS_COMPUTE);}
+        inline IPipelineBase::SShaderSpecInfo getSpecInfo() const {return base_t::getSpecInfo(hlsl::ShaderStage::ESS_COMPUTE);}
 
     protected:
         using base_t::base_t;
@@ -60,9 +59,9 @@ class ICPUComputePipeline : public ICPUPipeline<IPipeline<ICPUPipelineLayout>,1>
             return const_cast<ICPUPipelineLayout*>(m_layout.get());
         }
 
-        inline int8_t stageToIndex(const ICPUShader::E_SHADER_STAGE stage) const override
+        inline int8_t stageToIndex(const hlsl::ShaderStage stage) const override
         {
-            return stage!=ICPUShader::E_SHADER_STAGE::ESS_COMPUTE ? (-1):0;
+            return stage!=hlsl::ShaderStage::ESS_COMPUTE ? (-1):0;
         }
 };
 

include/nbl/asset/ICPUGraphicsPipeline.h

@@ -13,9 +13,9 @@
 namespace nbl::asset
 {
 
-class ICPUGraphicsPipeline final : public ICPUPipeline<IGraphicsPipeline<ICPUPipelineLayout,ICPUShader,ICPURenderpass>,5u>
+class ICPUGraphicsPipeline final : public ICPUPipeline<IGraphicsPipeline<ICPUPipelineLayout,ICPURenderpass>,5u>
 {
-        using pipeline_base_t = IGraphicsPipeline<ICPUPipelineLayout,ICPUShader,ICPURenderpass>;
+        using pipeline_base_t = IGraphicsPipeline<ICPUPipelineLayout,ICPURenderpass>;
         using base_t = ICPUPipeline<pipeline_base_t,5u>;
 
     public:
@@ -32,7 +32,7 @@ class ICPUGraphicsPipeline final : public ICPUPipeline<IGraphicsPipeline<ICPUPip
 		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 ICPUShader::SSpecInfo& info)->bool{return true;}))
+            if (!params.impl_valid([](const IPipelineBase::SShaderSpecInfo& info)->bool{return true;}))
                 return nullptr;
             auto retval = new ICPUGraphicsPipeline(params);
             for (const auto spec : params.shaders)
@@ -67,7 +67,7 @@ class ICPUGraphicsPipeline final : public ICPUPipeline<IGraphicsPipeline<ICPUPip
 
 		base_t* clone_impl(core::smart_refctd_ptr<const ICPUPipelineLayout>&& layout) const override
 		{
-			std::array<ICPUShader::SSpecInfo,GRAPHICS_SHADER_STAGE_COUNT> _shaders;
+			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 = {{
@@ -91,7 +91,7 @@ class ICPUGraphicsPipeline final : public ICPUPipeline<IGraphicsPipeline<ICPUPip
 			return nullptr;
 		}
 
-		inline int8_t stageToIndex(const ICPUShader::E_SHADER_STAGE stage) const override
+		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)

include/nbl/asset/ICPUPipeline.h

@@ -8,7 +8,6 @@
 #include "nbl/asset/IAsset.h"
 #include "nbl/asset/IPipeline.h"
 #include "nbl/asset/ICPUPipelineLayout.h"
-#include "nbl/asset/ICPUShader.h"
 
 
 namespace nbl::asset
@@ -34,10 +33,10 @@ class ICPUPipeline : public IAsset, public PipelineNonAssetBase
                 if (shader)
                 {
                     auto stageInfo = m_stages[i].info;
-                    core::smart_refctd_ptr<ICPUShader> newShader;
+                    core::smart_refctd_ptr<IShader> newShader;
                     if (_depth>0u)
                     {
-                        newShader = core::smart_refctd_ptr_static_cast<ICPUShader>(shader->clone(_depth-1u));
+                        newShader = core::smart_refctd_ptr_static_cast<IShader>(shader->clone(_depth-1u));
                         stageInfo.shader = newShader.get();
                     }
                     cp->setSpecInfo(stageInfo);
@@ -61,40 +60,50 @@ class ICPUPipeline : public IAsset, public PipelineNonAssetBase
             PipelineNonAssetBase::m_layout = std::move(_layout);
         }
 
-        // The getters are weird because the shader pointer needs patching
-		inline IShader::SSpecInfo<ICPUShader> getSpecInfo(const ICPUShader::E_SHADER_STAGE stage)
+        // The getters are weird because the shader pointer, spec constant map and entry point needs patching
+        inline IShader* getShader(const hlsl::ShaderStage stage)
+        {
+            assert(isMutable());
+            return const_cast<IShader*>(getSpecInfo(stage).shader);
+        }
+		inline std::string* getEntryPoint(const hlsl::ShaderStage stage)
 		{
-			assert(isMutable());
 			const auto stageIx = stageToIndex(stage);
             if (stageIx<0)
                 return {};
-			return m_stages[stageIx].info;
+			return &m_stages[stageIx].entryPoint;
 		}
-		inline IShader::SSpecInfo<const ICPUShader> getSpecInfo(const ICPUShader::E_SHADER_STAGE stage) const
+        inline IPipelineBase::SShaderSpecInfo::spec_constant_map_t* getSpecConstantMap(const hlsl::ShaderStage stage)
+        {
+            assert(isMutable());
+            return const_cast<IPipelineBase::SShaderSpecInfo::spec_constant_map_t*>(getSpecInfo(stage).entries);
+        }
+        //
+		inline IPipelineBase::SShaderSpecInfo getSpecInfo(const hlsl::ShaderStage stage) const
 		{
 			const auto stageIx = stageToIndex(stage);
             if (stageIx<0)
                 return {};
 			return m_stages[stageIx].info;
 		}
-		inline bool setSpecInfo(const IShader::SSpecInfo<ICPUShader>& info)
+		inline bool setSpecInfo(const IPipelineBase::SShaderSpecInfo& info)
 		{
 			assert(isMutable());
             const int64_t specSize = info.valid();
             if (specSize<0)
                 return false;
-			const auto stage = info.shader->getStage();
-			const auto stageIx = stageToIndex(stage);
+			const auto stageIx = stageToIndex(info.stage);
 			if (stageIx<0)
 				return false;
             auto& outStage = m_stages[stageIx];
 			outStage.info = info;
-			outStage.shader = core::smart_refctd_ptr<ICPUShader>(info.shader);
+            outStage.entryPoint = info.entryPoint;
+			outStage.shader = core::smart_refctd_ptr<IShader>(const_cast<IShader*>(info.shader));
 			outStage.info.shader = outStage.shader.get();
             auto& outEntries = outStage.entries;
             if (specSize>0)
             {
-                outEntries = std::make_unique<ICPUShader::SSpecInfo::spec_constant_map_t>();
+                outEntries = std::make_unique<IPipelineBase::SShaderSpecInfo::spec_constant_map_t>();
                 outEntries->reserve(info.entries->size());
                 std::copy(info.entries->begin(),info.entries->end(),std::insert_iterator(*outEntries,outEntries->begin()));
             }
@@ -103,7 +112,7 @@ class ICPUPipeline : public IAsset, public PipelineNonAssetBase
 			outStage.info.entries = outEntries.get();
 			return true;
 		}
-        inline bool clearStage(const ICPUShader::E_SHADER_STAGE stage)
+        inline bool clearStage(const hlsl::ShaderStage stage)
         {
             assert(isMutable());
             const auto stageIx = stageToIndex(stage);
@@ -118,12 +127,14 @@ class ICPUPipeline : public IAsset, public PipelineNonAssetBase
         virtual ~ICPUPipeline() = default;
 
         virtual this_t* clone_impl(core::smart_refctd_ptr<const ICPUPipelineLayout>&& layout) const = 0;
-        virtual int8_t stageToIndex(const ICPUShader::E_SHADER_STAGE stage) const = 0;
+        virtual int8_t stageToIndex(const hlsl::ShaderStage stage) const = 0;
 
-        struct ShaderStage {
-            core::smart_refctd_ptr<ICPUShader> shader = {};
-            std::unique_ptr<ICPUShader::SSpecInfo::spec_constant_map_t> entries = {};
-            ICPUShader::SSpecInfo info = {};
+        struct ShaderStage
+        {
+            std::string entryPoint = {};
+            core::smart_refctd_ptr<IShader> shader = {};
+            std::unique_ptr<IPipelineBase::SShaderSpecInfo::spec_constant_map_t> entries = {};
+            IPipelineBase::SShaderSpecInfo info = {};
         } m_stages[MaxShaderStageCount] = {};
 };
 

include/nbl/asset/ICPURenderpassIndependentPipeline.h

@@ -6,7 +6,7 @@
 
 #include "nbl/asset/IRenderpassIndependentPipeline.h"
 #include "nbl/asset/ICPUPipelineLayout.h"
-#include "nbl/asset/ICPUShader.h"
+#include "nbl/asset/IShader.h"
 
 namespace nbl::asset
 {
@@ -16,10 +16,8 @@ namespace nbl::asset
 	@see IRenderpassIndependentPipeline
 */
 
-class ICPURenderpassIndependentPipeline : public IRenderpassIndependentPipeline<ICPUShader>, public IAsset
+class ICPURenderpassIndependentPipeline : public IRenderpassIndependentPipeline, public IAsset
 {
-		using base_t = IRenderpassIndependentPipeline<ICPUShader>;
-
 	public:
 		//(TODO) it is true however it causes DSs to not be cached when ECF_DONT_CACHE_TOP_LEVEL is set which isnt really intuitive
 		constexpr static inline uint32_t DESC_SET_HIERARCHYLEVELS_BELOW = 0u;
@@ -38,9 +36,11 @@ class ICPURenderpassIndependentPipeline : public IRenderpassIndependentPipeline<
             if (!_layout || params.shaders.empty())
                 return nullptr;
             auto retval = new ICPURenderpassIndependentPipeline(std::move(_layout),params.cached);
+#if 0
             for (const auto spec : params.shaders)
             if (spec.shader)
 				retval->setSpecInfo(spec);
+#endif
             return core::smart_refctd_ptr<ICPURenderpassIndependentPipeline>(retval,core::dont_grab);
 		}
 
@@ -54,9 +54,11 @@ class ICPURenderpassIndependentPipeline : public IRenderpassIndependentPipeline<
 				layout = m_layout;
 
             auto cp = new ICPURenderpassIndependentPipeline(std::move(layout),m_cachedParams);
+#if 0
             for (const auto spec : m_infos)
             if (spec.shader)
 				cp->setSpecInfo(spec);
+#endif
 
             return core::smart_refctd_ptr<ICPURenderpassIndependentPipeline>(cp,core::dont_grab);
         }
@@ -67,7 +69,7 @@ class ICPURenderpassIndependentPipeline : public IRenderpassIndependentPipeline<
 		inline size_t getDependantCount() const override {return 0;}
 
 		//
-		inline const SCachedCreationParams& getCachedCreationParams() const {return base_t::getCachedCreationParams();}
+		inline const SCachedCreationParams& getCachedCreationParams() const {return IRenderpassIndependentPipeline::getCachedCreationParams();}
 		inline SCachedCreationParams& getCachedCreationParams()
 		{
 			assert(isMutable());
@@ -87,16 +89,17 @@ class ICPURenderpassIndependentPipeline : public IRenderpassIndependentPipeline<
 			m_layout = std::move(_layout);
 		}
 
+#if 0
 		// The getters are weird because the shader pointer needs patching
-		inline IShader::SSpecInfo<ICPUShader> getSpecInfo(const ICPUShader::E_SHADER_STAGE stage)
+		inline IShader::SSpecInfo<ICPUShader> getSpecInfo(const hlsl::ShaderStage stage)
 		{
 			assert(isMutable());
 			const auto stageIx = hlsl::findLSB(stage);
 			if (stageIx<0 || stageIx>=GRAPHICS_SHADER_STAGE_COUNT || hlsl::bitCount(stage)!=1)
 				return {};
 			return m_infos[stageIx];
 		}
-		inline IShader::SSpecInfo<const ICPUShader> getSpecInfo(const ICPUShader::E_SHADER_STAGE stage) const
+		inline IShader::SSpecInfo<const ICPUShader> getSpecInfo(const hlsl::ShaderStage stage) const
 		{
 			const auto stageIx = hlsl::findLSB(stage);
 			if (stageIx<0 || stageIx>=GRAPHICS_SHADER_STAGE_COUNT || hlsl::bitCount(stage)!=1)
@@ -127,18 +130,21 @@ class ICPURenderpassIndependentPipeline : public IRenderpassIndependentPipeline<
 			m_infos[stageIx].entries = m_entries[stageIx].get();
 			return true;
 		}
+#endif
 
 	protected:
-		ICPURenderpassIndependentPipeline(core::smart_refctd_ptr<ICPUPipelineLayout>&& _layout, const base_t::SCachedCreationParams& params)
-			: base_t(params), m_layout(std::move(_layout)) {}
+		ICPURenderpassIndependentPipeline(core::smart_refctd_ptr<ICPUPipelineLayout>&& _layout, const IRenderpassIndependentPipeline::SCachedCreationParams& params)
+			: IRenderpassIndependentPipeline(params), m_layout(std::move(_layout)) {}
 		virtual ~ICPURenderpassIndependentPipeline() = default;
 
 		inline IAsset* getDependant_impl(const size_t ix) override {return nullptr;}
 
 		core::smart_refctd_ptr<ICPUPipelineLayout> m_layout;
-		std::array<core::smart_refctd_ptr<ICPUShader>,GRAPHICS_SHADER_STAGE_COUNT> m_shaders = {};
-		std::array<std::unique_ptr<ICPUShader::SSpecInfo::spec_constant_map_t>,GRAPHICS_SHADER_STAGE_COUNT> m_entries = {};
-		std::array<ICPUShader::SSpecInfo,GRAPHICS_SHADER_STAGE_COUNT> m_infos = {};
+#if 0
+		std::array<core::smart_refctd_ptr<IShader>,GRAPHICS_SHADER_STAGE_COUNT> m_shaders = {};
+		std::array<std::unique_ptr<IPipelineBase::SShaderSpecInfo::spec_constant_map_t>,GRAPHICS_SHADER_STAGE_COUNT> m_entries = {};
+		std::array<IPipelineBase::SShaderSpecInfo,GRAPHICS_SHADER_STAGE_COUNT> m_infos = {};
+#endif
 };
 
 }