make it compile after saving work, update examples_tests - back to resolving following review comments

Author: AnastaZIuk

3rdparty/CMakeLists.txt

@@ -391,15 +391,29 @@ string(APPEND NBL_IMPL_IMCONFIG_CONTENT
 #include <cstdint>
 
 //! Custom "ImTextureID" info struct for Nabla UI backend purposes about resource sampler & texture descriptor binding's array indicies
+//! must be 4 bytes size & alignment to pass imgui static asserts (it checks for contiguous blocks in memory to make sure it can do some memcpies)
 struct SImResourceInfo 
 { 
 	//! texture descriptor binding's array index
-	uint16_t textureID : 14, 
-	
-	//! sampler descriptor binding's array index, note its only meta for the texture for which we define operators to compare to (so you can specify which sampler ID should be used from the binding array)
-	samplerID : 2;
+    uint32_t textureID : 26; 
+
+	//! sampler descriptor binding's array index
+	uint32_t samplerIx : 6;
+
+    SImResourceInfo() : textureID(0u), samplerIx(0u) {}
+
+    SImResourceInfo(uint32_t texID) 
+    {
+        textureID = texID;
+        samplerIx = 0u;
+    }
+
+	explicit operator intptr_t() const
+	{
+		return static_cast<intptr_t>(textureID);
+	}
 
-	bool operator==(const SImResourceInfo& other) const
+    bool operator==(const SImResourceInfo& other) const
     {
         return textureID == other.textureID;
     }

examples_tests

@@ -9,9 +9,18 @@ namespace nbl::ext::imgui
 class UI final : public core::IReferenceCounted
 {
 	public:
-		//! Reserved font atlas indicies for backend textures & samplers descriptor binding's array, any attempt to hook user defined texture ID == FontAtlasTexId will result in undefined behaviour
+		//! Reserved font atlas indicies for default backend textures & samplers descriptor binding's array
 		static constexpr auto FontAtlasTexId = 0u, FontAtlasSamplerId = 0u;
 
+		//! Reserved indexes for default backend samplers descriptor binding's array - use only if you created your pipeline layout with createDefaultPipelineLayout. If you need more or custom samplers then create the pipeline layout yourself
+		enum class DefaultSamplerIx : uint16_t
+		{
+			FONT_ATLAS = FontAtlasSamplerId,
+			USER,
+
+			COUNT,
+		};
+
 		struct SMdiBuffer
 		{
 			//! composes memory available for the general purpose allocator to suballocate memory ranges
@@ -52,15 +61,6 @@ class UI final : public core::IReferenceCounted
 				bindingIx;
 			};
 
-			//! Reserved indexes for default backend samplers descriptor binding's array - use only if you created your pipeline layout with createDefaultPipelineLayout. If you need more or custom samplers then create the pipeline layout yourself
-			enum class DefaultSamplerIx : uint16_t
-			{
-				FONT_ATLAS = FontAtlasSamplerId,
-				USER,
-
-				COUNT,
-			};
-
 			using binding_flags_t = video::IGPUDescriptorSetLayout::SBinding::E_CREATE_FLAGS;
 
 			//! required textures binding creation flags
@@ -90,13 +90,13 @@ class UI final : public core::IReferenceCounted
 			core::smart_refctd_ptr<video::IUtilities> utilities;
 
 			//! optional, default MDI buffer allocated if not provided	
-			core::smart_refctd_ptr<typename SMdiBuffer::compose_t> const streamingBuffer = nullptr;
+			core::smart_refctd_ptr<typename SMdiBuffer::compose_t> streamingBuffer = nullptr;
 		};
 
 		struct SCreationParameters : public SCachedCreationParams
 		{
 			//! required
-			video::IQueue* const transfer = nullptr;
+			video::IQueue* transfer = nullptr;
 
 			//! required, must declare required UI resources such as textures (required font atlas + optional user defined textures) & samplers
 			core::smart_refctd_ptr<video::IGPUPipelineLayout> pipelineLayout;
@@ -111,7 +111,7 @@ class UI final : public core::IReferenceCounted
 			uint32_t subpassIx = 0u;														
 
 			//! optional, no cache used if not provided
-			core::smart_refctd_ptr<video::IGPUPipelineCache> const pipelineCache = nullptr;
+			core::smart_refctd_ptr<video::IGPUPipelineCache> pipelineCache = nullptr;
 		};
 
 		//! parameters which may change every frame, used with the .update call to interact with ImGuiIO; we require a very *required* minimum - if you need to cover more IO options simply get the IO with ImGui::GetIO() to customize them (they all have default values you can change before calling the .update)
@@ -149,7 +149,7 @@ class UI final : public core::IReferenceCounted
 		void setContext(void* imguiContext);
 
 		//! creates default pipeline layout for the UI resources, "texturesCount" argument is textures descriptor binding's array size. Samplers are immutable and part of the created layout, SResourceParameters::DefaultSamplerIx::COUNT is the size of the samplers descriptor binding's array
-		static core::smart_refctd_ptr<video::IGPUPipelineLayout> createDefaultPipelineLayout(video::IUtilities* const utilities, const SResourceParameters::SBindingInfo texturesInfo = { .setIx = 0u, .bindingIx = 0u }, const SResourceParameters::SBindingInfo samplersInfo = { .setIx = 0u, .bindingIx = 1u }, uint32_t texturesCount = 0x45);
+		static core::smart_refctd_ptr<video::IGPUPipelineLayout> createDefaultPipelineLayout(video::IUtilities* const utilities, const SResourceParameters::SBindingInfo texturesInfo, const SResourceParameters::SBindingInfo samplersInfo, uint32_t texturesCount = 0x45);
 
 		//! creation cached parametrs
 		inline const SCachedCreationParams& getCreationParameters() const { return m_cachedCreationParams; }
@@ -158,7 +158,10 @@ class UI final : public core::IReferenceCounted
 		inline const video::IGPUGraphicsPipeline* getPipeline() const { return m_pipeline.get(); }
 
 		//! image view default font texture
-		inline const video::IGPUImageView* getFontAtlasView() const { return m_fontAtlasTexture.get(); }
+		//! TODO: we cannot expose immutable view of our default font texture because user MUST be able to write a descriptor, 
+		//! we can have mutable getter or we can decide to not create any default font texture at all and force users 
+		//! to do it externally (have a static helper to do it which gives you mutable view)
+		inline video::IGPUImageView* getFontAtlasView() const { return m_fontAtlasTexture.get(); }
 
 		//! mdi streaming buffer
 		inline const typename SMdiBuffer::compose_t* getStreamingBuffer() const { return m_mdi.compose.get(); }

include/nbl/ext/ImGui/ImGui.h

@@ -43,7 +43,7 @@ namespace nbl::ext::imgui
 			return nullptr;
 
 		if (texturesInfo.bindingIx == samplersInfo.bindingIx)
-			return false;
+			return nullptr;
 
 		if (!texturesCount)
 			return nullptr;
@@ -75,9 +75,9 @@ namespace nbl::ext::imgui
 		}
 
 		//! note we use immutable separate samplers and they are part of the descriptor set layout
-		std::array<core::smart_refctd_ptr<IGPUSampler>, (uint32_t)SResourceParameters::DefaultSamplerIx::COUNT> immutableSamplers;
-		immutableSamplers[(uint32_t)SResourceParameters::DefaultSamplerIx::FONT_ATLAS] = smart_refctd_ptr(fontAtlasUISampler);
-		immutableSamplers[(uint32_t)SResourceParameters::DefaultSamplerIx::USER] = smart_refctd_ptr(userTexturesSampler);
+		std::array<core::smart_refctd_ptr<IGPUSampler>, (uint32_t)DefaultSamplerIx::COUNT> immutableSamplers;
+		immutableSamplers[(uint32_t)DefaultSamplerIx::FONT_ATLAS] = smart_refctd_ptr(fontAtlasUISampler);
+		immutableSamplers[(uint32_t)DefaultSamplerIx::USER] = smart_refctd_ptr(userTexturesSampler);
 
 		auto textureBinding = IGPUDescriptorSetLayout::SBinding
 		{
@@ -184,11 +184,12 @@ namespace nbl::ext::imgui
 						std::stringstream stream;
 
 						stream << "// -> this code has been autogenerated with Nabla ImGUI extension\n"
-							<< "#define NBL_TEXTURES_BINDING_IX " << creationParams.resources.textures.bindingIx << "\n"
-							<< "#define NBL_SAMPLER_STATES_BINDING_IX " << creationParams.resources.samplers.bindingIx << "\n"
-							<< "#define NBL_TEXTURES_SET_IX " << creationParams.resources.textures.setIx << "\n"
-							<< "#define NBL_SAMPLER_STATES_SET_IX " << creationParams.resources.samplers.setIx << "\n"
-							<< "#define NBL_RESOURCES_COUNT " << creationParams.resources.count << "\n"
+							<< "#define NBL_TEXTURES_BINDING_IX " << creationParams.resources.texturesInfo.bindingIx << "\n"
+							<< "#define NBL_SAMPLER_STATES_BINDING_IX " << creationParams.resources.samplersInfo.bindingIx << "\n"
+							<< "#define NBL_TEXTURES_SET_IX " << creationParams.resources.texturesInfo.setIx << "\n"
+							<< "#define NBL_SAMPLER_STATES_SET_IX " << creationParams.resources.samplersInfo.setIx << "\n"
+							<< "#define NBL_TEXTURES_COUNT " << creationParams.resources.texturesCount << "\n"
+							<< "#define NBL_SAMPLERS_COUNT " << creationParams.resources.samplersCount << "\n"
 							<< "// <-\n\n";
 
 						const auto newCode = stream.str() + std::string(code);
@@ -329,7 +330,11 @@ namespace nbl::ext::imgui
 		uint8_t* pixels = nullptr;
 		int32_t width, height;
 		io.Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
-		io.Fonts->SetTexID({ .textureID = FontAtlasTexId, .samplerID = FontAtlasSamplerId });
+		SImResourceInfo info;
+		info.textureID = FontAtlasTexId;
+		info.samplerIx = FontAtlasSamplerId;
+
+		io.Fonts->SetTexID(info);
 
 		if (!pixels || width<=0 || height<=0)
 			return IQueue::RESULT::OTHER_ERROR;
@@ -381,15 +386,13 @@ namespace nbl::ext::imgui
 			m_cachedCreationParams.utilities->getLogger()->log("Could not create font image!", system::ILogger::ELL_ERROR);
 			return IQueue::RESULT::OTHER_ERROR;
 		}
-		image->setObjectDebugName("Nabla IMGUI extension Font Image");
+		image->setObjectDebugName("Nabla ImGUI default font");
 
 		if (!m_cachedCreationParams.utilities->getLogicalDevice()->allocate(image->getMemoryReqs(), image.get()).isValid())
 		{
 			m_cachedCreationParams.utilities->getLogger()->log("Could not allocate memory for font image!", system::ILogger::ELL_ERROR);
 			return IQueue::RESULT::OTHER_ERROR;
 		}
-		
-		image->setObjectDebugName("Nabla IMGUI extension Font Atlas");
 
 		SIntendedSubmitInfo sInfo;
 		{
@@ -1023,15 +1026,15 @@ namespace nbl::ext::imgui
 				for (uint32_t i = 0; i < drawData->CmdListsCount; i++)
 				{
 					const ImDrawList* commandList = drawData->CmdLists[i];
-					params.bytesToFill[SMdiBuffer::Content::INDIRECT_STRUCTURES] += commandList->CmdBuffer.Size * sizeof(VkDrawIndexedIndirectCommand);
-					params.bytesToFill[SMdiBuffer::Content::ELEMENT_STRUCTURES] += commandList->CmdBuffer.Size * sizeof(PerObjectData);
+					params.bytesToFill[static_cast<std::underlying_type_t<SMdiBuffer::Content>>(SMdiBuffer::Content::INDIRECT_STRUCTURES)] += commandList->CmdBuffer.Size * sizeof(VkDrawIndexedIndirectCommand);
+					params.bytesToFill[static_cast<std::underlying_type_t<SMdiBuffer::Content>>(SMdiBuffer::Content::ELEMENT_STRUCTURES)] += commandList->CmdBuffer.Size * sizeof(PerObjectData);
 				}
-				params.bytesToFill[SMdiBuffer::Content::VERTEX_BUFFERS] = drawData->TotalVtxCount * sizeof(ImDrawVert);
-				params.bytesToFill[SMdiBuffer::Content::INDEX_BUFFERS] = drawData->TotalIdxCount * sizeof(ImDrawIdx);
+				params.bytesToFill[static_cast<std::underlying_type_t<SMdiBuffer::Content>>(SMdiBuffer::Content::VERTEX_BUFFERS)] = drawData->TotalVtxCount * sizeof(ImDrawVert);
+				params.bytesToFill[static_cast<std::underlying_type_t<SMdiBuffer::Content>>(SMdiBuffer::Content::INDEX_BUFFERS)] = drawData->TotalIdxCount * sizeof(ImDrawIdx);
 
 				// calculate upper bound byte size limit for mdi buffer
 				params.totalByteSizeRequest = std::reduce(std::begin(params.bytesToFill), std::end(params.bytesToFill));
-				params.drawCount = params.bytesToFill[SMdiBuffer::Content::INDIRECT_STRUCTURES] / sizeof(VkDrawIndexedIndirectCommand);
+				params.drawCount = params.bytesToFill[static_cast<std::underlying_type_t<SMdiBuffer::Content>>(SMdiBuffer::Content::INDIRECT_STRUCTURES)] / sizeof(VkDrawIndexedIndirectCommand);
 
 				return std::move(params);
 			}();
@@ -1092,9 +1095,10 @@ namespace nbl::ext::imgui
 
 						auto fillDrawBuffers = [&]<SMdiBuffer::Content type>()
 						{
-							const mdi_size_t globalBlockOffset = offsets[type];
+							const auto underlying_type = static_cast<std::underlying_type_t<SMdiBuffer::Content>>(type);
+							const mdi_size_t globalBlockOffset = offsets[underlying_type];
 
-							if (globalBlockOffset == InvalidAddress or mdiBytesFilled[type])
+							if (globalBlockOffset == InvalidAddress or mdiBytesFilled[underlying_type])
 								return 0u;
 
 							auto* data = mdiData + globalBlockOffset;
@@ -1117,16 +1121,17 @@ namespace nbl::ext::imgui
 								}
 							}
 
-							mdiBytesFilled[type] = true;
-							mdiOffsets[type] = globalBlockOffset;
-							return mdiParams.bytesToFill[type];
+							mdiBytesFilled[underlying_type] = true;
+							mdiOffsets[underlying_type] = globalBlockOffset;
+							return mdiParams.bytesToFill[underlying_type];
 						};
 
 						auto fillIndirectStructures = [&]<SMdiBuffer::Content type>()
 						{
-							const mdi_size_t globalBlockOffset = offsets[type];
+							const auto underlying_type = static_cast<std::underlying_type_t<SMdiBuffer::Content>>(type);
+							const mdi_size_t globalBlockOffset = offsets[underlying_type];
 
-							if (globalBlockOffset == InvalidAddress or mdiBytesFilled[type])
+							if (globalBlockOffset == InvalidAddress or mdiBytesFilled[underlying_type])
 								return 0u;
 
 							auto* const data = mdiData + globalBlockOffset;
@@ -1169,7 +1174,8 @@ namespace nbl::ext::imgui
 										element->aabbMin.y = packSnorm16(vMin.y);
 										element->aabbMax.x = packSnorm16(vMax.x);
 										element->aabbMax.y = packSnorm16(vMax.y);
-										element->texId = pcmd->TextureId;
+										element->texId = pcmd->TextureId.textureID;
+										element->samplerIx = pcmd->TextureId.samplerIx;
 									}
 
 									++drawID;
@@ -1179,9 +1185,9 @@ namespace nbl::ext::imgui
 								cmdListVertexObjectOffset += cmd_list->VtxBuffer.Size;
 							}
 
-							mdiBytesFilled[type] = true;
-							mdiOffsets[type] = globalBlockOffset;
-							return mdiParams.bytesToFill[type];
+							mdiBytesFilled[underlying_type] = true;
+							mdiOffsets[underlying_type] = globalBlockOffset;
+							return mdiParams.bytesToFill[underlying_type];
 						};
 
 						//! from biggest requests to smallest
@@ -1203,12 +1209,12 @@ namespace nbl::ext::imgui
 				return true;
 			}()); // debug check only
 
-			auto mdiBuffer = smart_refctd_ptr<IGPUBuffer>(m_mdi.buffer->getBuffer());
+			auto mdiBuffer = smart_refctd_ptr<IGPUBuffer>(m_mdi.compose->getBuffer());
 			const auto offset = mdiBuffer->getBoundMemory().offset;
 			{
 				const asset::SBufferBinding<const video::IGPUBuffer> binding =
 				{
-					.offset = mdiOffsets[MDI::EBC_INDEX_BUFFERS],
+					.offset = mdiOffsets[static_cast<std::underlying_type_t<SMdiBuffer::Content>>(SMdiBuffer::Content::INDEX_BUFFERS)],
 					.buffer = smart_refctd_ptr(mdiBuffer)
 				};
 
@@ -1222,7 +1228,7 @@ namespace nbl::ext::imgui
 			{
 				const asset::SBufferBinding<const video::IGPUBuffer> bindings[] =
 				{{
-					.offset = mdiOffsets[MDI::EBC_VERTEX_BUFFERS],
+					.offset = mdiOffsets[static_cast<std::underlying_type_t<SMdiBuffer::Content>>(SMdiBuffer::Content::VERTEX_BUFFERS)],
 					.buffer = smart_refctd_ptr(mdiBuffer)
 				}};
 
@@ -1262,19 +1268,19 @@ namespace nbl::ext::imgui
 			{
 				PushConstants constants
 				{
-					.elementBDA = { mdiBuffer->getDeviceAddress() + mdiOffsets[MDI::EBC_ELEMENT_STRUCTURES]},
+					.elementBDA = { mdiBuffer->getDeviceAddress() + mdiOffsets[static_cast<std::underlying_type_t<SMdiBuffer::Content>>( SMdiBuffer::Content::ELEMENT_STRUCTURES )]},
 					.elementCount = { mdiParams.drawCount },
 					.scale = { trs.scale[0u], trs.scale[1u] },
 					.translate = { trs.translate[0u], trs.translate[1u] },
 					.viewport = { viewport.x, viewport.y, viewport.width, viewport.height }
 				};
 
-				commandBuffer->pushConstants(pipeline->getLayout(), IShader::E_SHADER_STAGE::ESS_VERTEX | IShader::E_SHADER_STAGE::ESS_FRAGMENT, 0u, sizeof(constants), &constants);
+				commandBuffer->pushConstants(m_pipeline->getLayout(), IShader::E_SHADER_STAGE::ESS_VERTEX | IShader::E_SHADER_STAGE::ESS_FRAGMENT, 0u, sizeof(constants), &constants);
 			}
 
 			const asset::SBufferBinding<const video::IGPUBuffer> binding =
 			{
-				.offset = mdiOffsets[MDI::EBC_DRAW_INDIRECT_STRUCTURES],
+				.offset = mdiOffsets[static_cast<std::underlying_type_t<SMdiBuffer::Content>>(SMdiBuffer::Content::INDIRECT_STRUCTURES)],
 				.buffer = core::smart_refctd_ptr(mdiBuffer)
 			};
 
@@ -1284,7 +1290,7 @@ namespace nbl::ext::imgui
 		return true;
 	}
 
-	bool UI::update(const S_UPDATE_PARAMETERS& params)
+	bool UI::update(const SUpdateParameters& params)
 	{
 		auto & io = ImGui::GetIO();
 

src/nbl/ext/ImGui/ImGui.cpp

@@ -44,13 +44,12 @@ struct emulated_snorm16_t2
 	}
 	#endif
 
-	int16_t x;
-	int16_t y;
+	int16_t x, y;
 };
 
 struct PerObjectData 
 {
-	emulated_snorm16_t2 aabbMin;
-	emulated_snorm16_t2 aabbMax;
-	uint16_t texId;
+	emulated_snorm16_t2 aabbMin, aabbMax;
+	uint16_t texId : 14;
+	uint16_t samplerIx : 2;
 };

src/nbl/ext/ImGui/shaders/common.hlsl

@@ -14,17 +14,21 @@
 #error "NBL_SAMPLER_STATES_SET_IX must be defined!"
 #endif
 
-#ifndef NBL_RESOURCES_COUNT
-#error "NBL_RESOURCES_COUNT must be defined!"
+#ifndef NBL_TEXTURES_COUNT
+#error "NBL_TEXTURES_COUNT must be defined!"
+#endif
+
+#ifndef NBL_SAMPLERS_COUNT
+#error "NBL_SAMPLERS_COUNT must be defined!"
 #endif
 
 #include "common.hlsl"
 
 [[vk::push_constant]] struct PushConstants pc;
 
 // separable image samplers to handle textures we do descriptor-index
-[[vk::binding(NBL_TEXTURES_BINDING_IX, NBL_TEXTURES_SET_IX)]] Texture2D textures[NBL_RESOURCES_COUNT];
-[[vk::binding(NBL_SAMPLER_STATES_BINDING_IX, NBL_SAMPLER_STATES_SET_IX)]] SamplerState samplerStates[NBL_RESOURCES_COUNT];
+[[vk::binding(NBL_TEXTURES_BINDING_IX, NBL_TEXTURES_SET_IX)]] Texture2D textures[NBL_TEXTURES_COUNT];
+[[vk::binding(NBL_SAMPLER_STATES_BINDING_IX, NBL_SAMPLER_STATES_SET_IX)]] SamplerState samplerStates[NBL_SAMPLERS_COUNT];
 
 /*
     we use Indirect Indexed draw call to render whole GUI, note we do a cross 
@@ -37,5 +41,5 @@ float4 PSMain(PSInput input) : SV_Target0
     // BDA for requesting object data
     const PerObjectData self = vk::RawBufferLoad<PerObjectData>(pc.elementBDA + sizeof(PerObjectData)* input.drawID);
 
-    return textures[NonUniformResourceIndex(self.texId)].Sample(samplerStates[self.texId], input.uv) * input.color;
+    return textures[NonUniformResourceIndex(self.texId)].Sample(samplerStates[self.samplerIx], input.uv) * input.color;
 }