createDescriptorSet in terms of createDescriptorSets.

Author: achalpandeyy

include/nbl/video/IDescriptorPool.h

@@ -50,20 +50,19 @@ class NBL_API IDescriptorPool : public core::IReferenceCounted, public IBackendO
             uint32_t data[static_cast<uint32_t>(asset::IDescriptor::E_TYPE::ET_COUNT) + 1];
         };
 
-        inline void createDescriptorSets(uint32_t count, const IGPUDescriptorSetLayout* const* layouts, core::smart_refctd_ptr<IGPUDescriptorSet>* output)
+        inline core::smart_refctd_ptr<IGPUDescriptorSet> createDescriptorSet(core::smart_refctd_ptr<const IGPUDescriptorSetLayout>&& layout)
         {
-            for (uint32_t i = 0u; i < count; ++i)
-            {
-                auto layout = core::smart_refctd_ptr<const IGPUDescriptorSetLayout>(layouts[i]);
-                output[i++] = createDescriptorSet(std::move(layout));
-            }
+            core::smart_refctd_ptr<IGPUDescriptorSet> set;
+            const bool result = createDescriptorSets(1, &layout.get(), &set);
+            if (result)
+                return set;
+            else
+                return nullptr;
         }
 
-        // Returns the offset into the pool's descriptor storage. These offsets will be combined
-        // later with base memory addresses to get the actual memory address where we put the core::smart_refctd_ptr<const IDescriptor>.
-        SDescriptorOffsets allocateDescriptorOffsets(const IGPUDescriptorSetLayout* layout);
+        bool createDescriptorSets(uint32_t count, const IGPUDescriptorSetLayout* const* layouts, core::smart_refctd_ptr<IGPUDescriptorSet>* output);
 
-        core::smart_refctd_ptr<IGPUDescriptorSet> createDescriptorSet(core::smart_refctd_ptr<const IGPUDescriptorSetLayout>&& layout);
+        // TODO(achal): Remove.
         bool freeDescriptorSets(const uint32_t descriptorSetCount, IGPUDescriptorSet* const* const descriptorSets);
 
         inline uint32_t getCapacity() const { return m_maxSets; }
@@ -114,12 +113,16 @@ class NBL_API IDescriptorPool : public core::IReferenceCounted, public IBackendO
 
         virtual ~IDescriptorPool() {}
 
-        virtual core::smart_refctd_ptr<IGPUDescriptorSet> createDescriptorSet_impl(core::smart_refctd_ptr<const IGPUDescriptorSetLayout>&& layout, SDescriptorOffsets&& offsets) = 0;
+        virtual bool createDescriptorSets_impl(uint32_t count, const IGPUDescriptorSetLayout* const* layouts, SDescriptorOffsets* const offsets, core::smart_refctd_ptr<IGPUDescriptorSet>* output) = 0;
         virtual bool freeDescriptorSets_impl(const uint32_t descriptorSetCount, IGPUDescriptorSet* const* const descriptorSets) = 0;
 
         uint32_t m_maxSets;
 
     private:
+        // Returns the offset into the pool's descriptor storage. These offsets will be combined
+        // later with base memory addresses to get the actual memory address where we put the core::smart_refctd_ptr<const IDescriptor>.
+        SDescriptorOffsets allocateDescriptorOffsets(const IGPUDescriptorSetLayout* layout);
+
         const IDescriptorPool::E_CREATE_FLAGS m_flags;
         uint32_t m_maxDescriptorCount[static_cast<uint32_t>(asset::IDescriptor::E_TYPE::ET_COUNT)];
         union

src/nbl/video/CVulkanDescriptorPool.cpp

@@ -26,28 +26,38 @@ void CVulkanDescriptorPool::setObjectDebugName(const char* label) const
 	vkSetDebugUtilsObjectNameEXT(vulkanDevice->getInternalObject(), &nameInfo);
 }
 
-core::smart_refctd_ptr<IGPUDescriptorSet> CVulkanDescriptorPool::createDescriptorSet_impl(core::smart_refctd_ptr<const IGPUDescriptorSetLayout>&& layout, SDescriptorOffsets&& offsets)
+bool CVulkanDescriptorPool::createDescriptorSets_impl(uint32_t count, const IGPUDescriptorSetLayout* const* layouts, SDescriptorOffsets* const offsets, core::smart_refctd_ptr<IGPUDescriptorSet>* output)
 {
-    if (layout->getAPIType() != EAT_VULKAN)
-        return nullptr;
-
     VkDescriptorSetAllocateInfo vk_allocateInfo = { VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO };
     vk_allocateInfo.pNext = nullptr; // pNext must be NULL or a pointer to a valid instance of VkDescriptorSetVariableDescriptorCountAllocateInfo
 
     vk_allocateInfo.descriptorPool = m_descriptorPool;
-    vk_allocateInfo.descriptorSetCount = 1u;
+    vk_allocateInfo.descriptorSetCount = count;
 
-    VkDescriptorSetLayout vk_dsLayout = IBackendObject::device_compatibility_cast<const CVulkanDescriptorSetLayout*>(layout.get(), getOriginDevice())->getInternalObject();
-    vk_allocateInfo.pSetLayouts = &vk_dsLayout;
+    core::vector<VkDescriptorSetLayout> vk_dsLayouts(count);
+    for (uint32_t i = 0; i < count; ++i)
+    {
+        if (layouts[i]->getAPIType() != EAT_VULKAN)
+            return false;
+
+        vk_dsLayouts[i] = IBackendObject::device_compatibility_cast<const CVulkanDescriptorSetLayout*>(layouts[i], getOriginDevice())->getInternalObject();
+    }
 
-    VkDescriptorSet vk_descriptorSet;
+    vk_allocateInfo.pSetLayouts = vk_dsLayouts.data();
+
+    core::vector<VkDescriptorSet> vk_descriptorSets(count);
 
     const auto* vulkanDevice = static_cast<const CVulkanLogicalDevice*>(getOriginDevice());
     auto* vk = vulkanDevice->getFunctionTable();
-    if (vk->vk.vkAllocateDescriptorSets(vulkanDevice->getInternalObject(), &vk_allocateInfo, &vk_descriptorSet) == VK_SUCCESS)
-        return core::make_smart_refctd_ptr<CVulkanDescriptorSet>(std::move(layout), core::smart_refctd_ptr<IDescriptorPool>(this), std::move(offsets), vk_descriptorSet);
+    if (vk->vk.vkAllocateDescriptorSets(vulkanDevice->getInternalObject(), &vk_allocateInfo, vk_descriptorSets.data()) == VK_SUCCESS)
+    {
+        for (uint32_t i = 0; i < count; ++i)
+            output[i] = core::make_smart_refctd_ptr<CVulkanDescriptorSet>(core::smart_refctd_ptr<const IGPUDescriptorSetLayout>(layouts[i]), core::smart_refctd_ptr<IDescriptorPool>(this), std::move(offsets[i]), vk_descriptorSets[i]);
+
+        return true;
+    }
 
-    return nullptr;
+    return false;
 }
 
 bool CVulkanDescriptorPool::freeDescriptorSets_impl(const uint32_t descriptorSetCount, IGPUDescriptorSet* const* const descriptorSets)

src/nbl/video/CVulkanDescriptorPool.h

@@ -23,7 +23,7 @@ class CVulkanDescriptorPool : public IDescriptorPool
     void setObjectDebugName(const char* label) const override;
 
 private:
-    core::smart_refctd_ptr<IGPUDescriptorSet> createDescriptorSet_impl(core::smart_refctd_ptr<const IGPUDescriptorSetLayout>&& layout, SDescriptorOffsets&& offsets) override;
+    bool createDescriptorSets_impl(uint32_t count, const IGPUDescriptorSetLayout* const* layouts, SDescriptorOffsets *const offsets, core::smart_refctd_ptr<IGPUDescriptorSet>* output) override;
     bool freeDescriptorSets_impl(const uint32_t descriptorSetCount, IGPUDescriptorSet* const* const descriptorSets) final override;
 
     VkDescriptorPool m_descriptorPool;

src/nbl/video/IDescriptorPool.cpp

@@ -4,14 +4,19 @@
 namespace nbl::video
 {
 
-core::smart_refctd_ptr<IGPUDescriptorSet> IDescriptorPool::createDescriptorSet(core::smart_refctd_ptr<const IGPUDescriptorSetLayout>&& layout)
+bool IDescriptorPool::createDescriptorSets(uint32_t count, const IGPUDescriptorSetLayout* const* layouts, core::smart_refctd_ptr<IGPUDescriptorSet>* output)
 {
-    if (!isCompatibleDevicewise(layout.get()))
-        return nullptr;
+    core::vector<SDescriptorOffsets> descriptorOffsets(count);
 
-    auto offsets = allocateDescriptorOffsets(layout.get());
+    for (uint32_t i = 0u; i < count; ++i)
+    {
+        if (!isCompatibleDevicewise(layouts[i]))
+            return false;
+        
+        descriptorOffsets[i] = allocateDescriptorOffsets(layouts[i]);
+    }
 
-    return createDescriptorSet_impl(std::move(layout), std::move(offsets));
+    return createDescriptorSets_impl(count, layouts, descriptorOffsets.data(), output);
 }
 
 IDescriptorPool::SDescriptorOffsets IDescriptorPool::allocateDescriptorOffsets(const IGPUDescriptorSetLayout* layout)