add a general binding info

Author: devsh

include/nbl/asset/IPipelineLayout.h

@@ -4,12 +4,14 @@
 #ifndef _NBL_ASSET_I_PIPELINE_LAYOUT_H_INCLUDED_
 #define _NBL_ASSET_I_PIPELINE_LAYOUT_H_INCLUDED_
 
+#include "nbl/macros.h"
+#include "nbl/core/declarations.h"
 
 #include <algorithm>
 #include <array>
 
-#include "nbl/macros.h"
-#include "nbl/core/declarations.h"
+#include "nbl/asset/IDescriptorSetLayout.h"
+#include "nbl/builtin/hlsl/binding_info.hlsl"
 
 
 namespace nbl::asset
@@ -21,7 +23,7 @@ namespace nbl::asset
     however they serve as a fast path with regard to data upload from the
     CPU and data access from the GPU. 
     
-    Note that IrrlichtBaW limits push constant size to 128 bytes.
+    Note that Nabla limits push constant size to 128 bytes.
 
     Push Constants are an alternative to an UBO where it performs really poorly,
     mostly very small and very frequent updates. Examples of which are:
@@ -140,6 +142,44 @@ class IPipelineLayout
             return static_cast<int32_t>(i)-1;
         }
 
+        // utility function, if you compile shaders for specific layouts, not create layouts given shaders
+        using desc_type_bitset_t = std::bitset<static_cast<size_t>(IDescriptor::E_TYPE::ET_COUNT)>;
+        // TODO: add constraints for stage and creation flags, or just return the storage index & redirect?
+        core::string getBindingInfoForHLSL(const hlsl::SBindingInfo& info, const desc_type_bitset_t allowedTypes=desc_type_bitset_t().set()) const
+        {
+            if (info.set>=DESCRIPTOR_SET_COUNT)
+                return "#error \"::nbl::hlsl::SBindingInfo::set out of range!\"";
+            const auto* layout = m_descSetLayouts[info.set];
+            if (!layout)
+                return "#error \"::nbl::hlsl::SBindingInfo::set layout is nullptr!\"";
+            //
+            using redirect_t = IDescriptorSetLayoutBase::CBindingRedirect;
+            using storage_range_index_t = redirect_t::storage_range_index_t;
+            const redirect_t* redirect;
+            storage_range_index_t found;
+            {
+                const redirect_t::binding_number_t binding(info.binding);
+                for (auto t=0u; t<static_cast<size_t>(IDescriptor::E_TYPE::ET_COUNT); t++)
+                if (allowedTypes.test(t))
+                {
+                    redirect = &layout->getDescriptorRedirect(static_cast<IDescriptor::E_TYPE>(t));
+                    found = redirect->findBindingStorageIndex(binding);
+                    if (found)
+                        break;
+                }
+                if (!found && allowedTypes.test(static_cast<size_t>(IDescriptor::E_TYPE::ET_SAMPLER)))
+                {
+                    redirect = &layout->getImmutableSamplerRedirect();
+                    found = redirect->findBindingStorageIndex(binding);
+                }
+                if (!found)
+                    return "#error \"Could not find `::nbl::hlsl::SBindingInfo::binding` in `::nbl::hlsl::SBindingInfo::set`'s layout!\"";
+            }
+            const auto count = redirect->getCount(found);
+            assert(count); // this layout should have never passed validation
+            return "::nbl::hlsl::ConstevalBindingInfo<"+std::to_string(info.set)+","+std::to_string(info.binding)+","+std::to_string(count)+">";
+        }
+
     protected:
         IPipelineLayout(
             const std::span<const asset::SPushConstantRange> _pcRanges,

include/nbl/builtin/hlsl/binding_info.hlsl

@@ -19,6 +19,15 @@ struct ConstevalBindingInfo
 	NBL_CONSTEXPR_STATIC_INLINE uint32_t Count = count;
 };
 
+// used for descriptor set layout lookups
+struct SBindingInfo
+{
+	//! binding index for a given resource
+	uint32_t binding : 29;
+	//! descriptor set index for a resource
+	uint32_t set : 3;
+};
+
 }
 }
 #endif

include/nbl/ext/ImGui/ImGui.h

@@ -24,6 +24,7 @@ class UI final : public core::IReferenceCounted
 		struct SResourceParameters
 		{
 				//! for a given pipeline layout we need to know what is intended for UI resources
+				// TODO: introduce a common type between ImGUI and Blit for the descriptor infos "binding_info.hlsl"
 				struct SBindingInfo
 				{
 					//! descriptor set index for a resource

include/nbl/video/utilities/CComputeBlit.h

@@ -47,16 +47,34 @@ class NBL_API2 CComputeBlit : public core::IReferenceCounted
 			core::smart_refctd_ptr<system::ILogger>&& logger=nullptr
 		);
 
-		// if you set the balues too small, we'll correct them ourselves anyway
-		struct STask
+		// create your pipelines
+		struct SPipelines
 		{
+			core::smart_refctd_ptr<IGPUComputePipeline> blit;
+			core::smart_refctd_ptr<IGPUComputePipeline> coverage;
+		};
+		struct SPipelinesCreateInfo
+		{
+			// required
+			CAssetConverter* converter;
+			// in theory we _could_ accept either pipeline layout type (or just the base) and make the CPU one back from the GPU
+			const asset::ICPUPipelineLayout* layout;
+			// must be Uniform Texel Buffer descriptor type
+			hlsl::SBindingInfo kernelWeights;
+			// must be Sampled Image descriptor type
+			hlsl::SBindingInfo inputs;
+			// must be Sampler descriptor type
+			hlsl::SBindingInfo samplers;
+			// must be Storage Image descriptor type
+			hlsl::SBindingInfo outputs;
+			//! If you set the balues too small, we'll correct them ourselves anyway
+			// needs to be at least as big as the maximum subgroup size 
 			uint32_t workgroupSizeLog2 : 4 = 0;
-			// the TRUE output format, not the storage view format you might manually encode into
-			hlsl::format::TexelBlockFormat outputFormat : 8 = hlsl::format::TexelBlockFormat::TBF_UNKNOWN;
+			//
 			uint32_t sharedMemoryPerInvocation : 6 = 0;
-			uint32_t unused : 14 = 0;
 		};
-		
+		SPipelines createAndCachePipelines(const SPipelinesCreateInfo& info);
+
 		//! Returns the original format if supports STORAGE_IMAGE otherwise returns a format in its compat class which supports STORAGE_IMAGE.
 		inline asset::E_FORMAT getOutputViewFormat(const asset::E_FORMAT format)
 		{
@@ -585,8 +603,6 @@ class NBL_API2 CComputeBlit : public core::IReferenceCounted
 			EBT_COUNT
 		};
 
-		void createAndCachePipelines(CAssetConverter* converter, core::smart_refctd_ptr<IGPUComputePipeline>* pipelines, const std::span<const STask> tasks);
-
 		core::smart_refctd_ptr<ILogicalDevice> m_device;
 		system::logger_opt_smart_ptr m_logger;
 		core::smart_refctd_ptr<asset::IShaderCompiler::CCache> m_shaderCache;

src/nbl/ext/ImGui/ImGui.cpp

@@ -221,6 +221,7 @@ core::smart_refctd_ptr<video::IGPUGraphicsPipeline> UI::createPipeline(SCreation
 
 					std::stringstream stream;
 
+					// TODO: Use the `ConstevalBindingInfo`
 					stream << "// -> this code has been autogenerated with Nabla ImGUI extension\n"
 						<< "#define NBL_TEXTURES_BINDING_IX " << creationParams.resources.texturesInfo.bindingIx << "\n"
 						<< "#define NBL_SAMPLER_STATES_BINDING_IX " << creationParams.resources.samplersInfo.bindingIx << "\n"

src/nbl/video/utilities/CComputeBlit.cpp

@@ -20,8 +20,9 @@ CComputeBlit::CComputeBlit(smart_refctd_ptr<ILogicalDevice>&& logicalDevice, sma
 		m_shaderCache = make_smart_refctd_ptr<IShaderCompiler::CCache>();
 }
 
-void CComputeBlit::createAndCachePipelines(CAssetConverter* converter, smart_refctd_ptr<IGPUComputePipeline>* pipelines, const std::span<const STask> tasks)
+auto CComputeBlit::createAndCachePipelines(const SPipelinesCreateInfo& info) -> SPipelines
 {
+	SPipelines retval;
 	core::vector<smart_refctd_ptr<ICPUComputePipeline>> cpuPplns;
 	cpuPplns.reserve(tasks.size());
 
@@ -50,12 +51,6 @@ void CComputeBlit::createAndCachePipelines(CAssetConverter* converter, smart_ref
 		}
 		const auto common = [&]()->std::string
 		{
-			// TODO: introduce a common type between ImGUI and Blit for the descriptor infos
-			auto serializeBindingInfo = [](const hlsl::SBindingInfo& info={})->std::string
-			{
-				return "ConstevalBindingInfo<"+std::to_string(info.Set)+","+std::to_string(info.Set)+","+std::to_string(info.Count)+">";
-			};
-
 			std::ostringstream tmp;
 			tmp << R"===(
 #include "nbl/builtin/hlsl/binding_info.hlsl"
@@ -67,7 +62,7 @@ using namespace nbl::hlsl;
 struct ConstevalParameters
 {
 	NBL_CONSTEXPR_STATIC_INLINE uint32_t WorkGroupSize = )===" << (0x1u<<task.workgroupSizeLog2) << R"===(;
-    using kernel_weight_binding_t = )===" << serializeBindingInfo() << R"===(;
+    using kernel_weight_binding_t = )===" << layout->getBindingInfoForHLSL() << R"===(;
     using input_sampler_binding_t = )===" << serializeBindingInfo() << R"===(;
     using input_image_binding_t = )===" << serializeBindingInfo() << R"===(;
     using output_binding_t = )===" << serializeBindingInfo() << R"===(;
@@ -122,6 +117,7 @@ struct ConstevalParameters
 		auto convertResults = reserveResults.convert(params);
 		assert(!convertResults.blocking());
 	}
+	return retval;
 }
 
 #if 0