pull from asset-conversion-v3

Author: tad1

3rdparty/parallel-hashmap

@@ -89,51 +89,56 @@ class IPipelineLayout
     public:
         static inline constexpr uint32_t DESCRIPTOR_SET_COUNT = 4u;
 
-    const DescLayoutType* getDescriptorSetLayout(uint32_t _set) const { return m_descSetLayouts[_set].get(); }
-    core::SRange<const SPushConstantRange> getPushConstantRanges() const 
-    {
-        if (m_pushConstantRanges)
-            return {m_pushConstantRanges->data(), m_pushConstantRanges->data()+m_pushConstantRanges->size()};
-        else 
-            return {nullptr, nullptr};
-    }
+        std::span<const DescLayoutType* const,DESCRIPTOR_SET_COUNT> getDescriptorSetLayouts() const
+        {
+            return std::span<const DescLayoutType* const,DESCRIPTOR_SET_COUNT>(&m_descSetLayouts[0].get(),DESCRIPTOR_SET_COUNT);
+        }
+        [[deprecated]] const DescLayoutType* getDescriptorSetLayout(uint32_t _set) const { return getDescriptorSetLayouts()[_set]; }
 
-    bool isCompatibleForPushConstants(const IPipelineLayout<DescLayoutType>* _other) const
-    {
-        if (getPushConstantRanges().size() != _other->getPushConstantRanges().size())
-            return false;
+        core::SRange<const SPushConstantRange> getPushConstantRanges() const 
+        {
+            if (m_pushConstantRanges)
+                return {m_pushConstantRanges->data(), m_pushConstantRanges->data()+m_pushConstantRanges->size()};
+            else 
+                return {nullptr, nullptr};
+        }
 
-        const size_t cnt = getPushConstantRanges().size();
-        const SPushConstantRange* lhs = getPushConstantRanges().begin();
-        const SPushConstantRange* rhs = _other->getPushConstantRanges().begin();
-        for (size_t i = 0ull; i < cnt; ++i)
-            if (lhs[i] != rhs[i])
+        bool isCompatibleForPushConstants(const IPipelineLayout<DescLayoutType>* _other) const
+        {
+            if (getPushConstantRanges().size() != _other->getPushConstantRanges().size())
                 return false;
 
-        return true;
-    }
+            const size_t cnt = getPushConstantRanges().size();
+            const SPushConstantRange* lhs = getPushConstantRanges().begin();
+            const SPushConstantRange* rhs = _other->getPushConstantRanges().begin();
+            for (size_t i = 0ull; i < cnt; ++i)
+                if (lhs[i] != rhs[i])
+                    return false;
 
-    //! Checks if `this` and `_other` are compatible for set `_setNum`. See https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#descriptorsets-compatibility for compatiblity rules.
-    /**
-    @returns Max value of `_setNum` for which the two pipeline layouts are compatible or -1 if they're not compatible at all.
-    */
-    int32_t isCompatibleUpToSet(const uint32_t _setNum, const IPipelineLayout<DescLayoutType>* _other) const
-    {
-        if (!_setNum || (_setNum >= DESCRIPTOR_SET_COUNT)) //vulkan would also care about push constant ranges compatibility here
-            return -1;
+            return true;
+        }
 
-		uint32_t i = 0u;
-        for (; i <=_setNum; i++)
+        //! Checks if `this` and `_other` are compatible for set `_setNum`. See https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#descriptorsets-compatibility for compatiblity rules.
+        /**
+        @returns Max value of `_setNum` for which the two pipeline layouts are compatible or -1 if they're not compatible at all.
+        */
+        int32_t isCompatibleUpToSet(const uint32_t _setNum, const IPipelineLayout<DescLayoutType>* _other) const
         {
-            const DescLayoutType* lhs = m_descSetLayouts[i].get();
-            const DescLayoutType* rhs = _other->getDescriptorSetLayout(i);
+            if (!_setNum || (_setNum >= DESCRIPTOR_SET_COUNT)) //vulkan would also care about push constant ranges compatibility here
+                return -1;
 
-            const bool compatible = (lhs == rhs) || (lhs && lhs->isIdenticallyDefined(rhs));
-			if (!compatible)
-				break;
+		    uint32_t i = 0u;
+            for (; i <=_setNum; i++)
+            {
+                const DescLayoutType* lhs = m_descSetLayouts[i].get();
+                const DescLayoutType* rhs = _other->getDescriptorSetLayout(i);
+
+                const bool compatible = (lhs == rhs) || (lhs && lhs->isIdenticallyDefined(rhs));
+			    if (!compatible)
+				    break;
+            }
+            return static_cast<int32_t>(i)-1;
         }
-        return static_cast<int32_t>(i)-1;
-    }
 
     protected:
         IPipelineLayout(

examples_tests

@@ -123,7 +123,8 @@ class IPreHashed : public IAsset
 		virtual void discardContent_impl() = 0;
 
 	private:
-		core::blake3_hash_t m_contentHash = {};
+		// The initial value is a hash of an "as if" of a zero-length array
+		core::blake3_hash_t m_contentHash = static_cast<core::blake3_hash_t>(core::blake3_hasher{});
 };
 }
 

include/nbl/asset/IPipelineLayout.h

@@ -442,6 +442,11 @@ class NBL_API2 IShaderCompiler : public core::IReferenceCounted
 					return found;
 			}
 			auto retVal = compileToSPIRV_impl(code, options, options.writeCache ? &dependencies : nullptr);
+			// compute the SPIR-V shader content hash
+			{
+				auto backingBuffer = retVal->getContent();
+				const_cast<ICPUBuffer*>(backingBuffer)->setContentHash(backingBuffer->computeContentHash());
+			}
 			if (options.writeCache)
 			{
 				entry.dependencies = std::move(dependencies);

include/nbl/asset/IPreHashed.h

@@ -92,7 +92,7 @@ struct blake3_hasher::update_impl<std::span<U,N>,Dummy>
 			hasher.update(input.data(),input.size()*sizeof(U));
 		else // Note ideally I'd have some check for a `trivially_serializable` trait or something
 		for (const auto& item : input)
-			hasher << input;
+			hasher << item;
 
 	}
 };
@@ -116,7 +116,7 @@ struct hash<nbl::core::blake3_hash_t>
 	{
 		auto* as_p_uint64_t = reinterpret_cast<const size_t*>(blake3.data);
 		size_t retval = as_p_uint64_t[0];
-		for (auto i=1; i<BLAKE3_OUT_LEN; i++)
+		for (auto i=1; i<BLAKE3_OUT_LEN/sizeof(size_t); i++)
 			retval ^= as_p_uint64_t[i] + 0x9e3779b97f4a7c15ull + (retval << 6) + (retval >> 2);
 		return retval;
 	}

include/nbl/asset/utils/IShaderCompiler.h

@@ -73,7 +73,11 @@ class NBL_API2 IDescriptorPool : public IBackendObject
                 return nullptr;
         }
 
-        uint32_t createDescriptorSets(uint32_t count, const IGPUDescriptorSetLayout* const* layouts, core::smart_refctd_ptr<IGPUDescriptorSet>* output);
+        uint32_t createDescriptorSets(const std::span<const IGPUDescriptorSetLayout* const> layouts, core::smart_refctd_ptr<IGPUDescriptorSet>* output);
+        [[deprecated]] inline uint32_t createDescriptorSets(uint32_t count, const IGPUDescriptorSetLayout* const* layouts, core::smart_refctd_ptr<IGPUDescriptorSet>* output)
+        {
+            return createDescriptorSets({layouts,count},output);
+        }
 
         bool reset();
 

include/nbl/core/hash/blake.h

@@ -28,8 +28,9 @@ IDescriptorPool::IDescriptorPool(core::smart_refctd_ptr<const ILogicalDevice>&&
     m_descriptorSetAllocator = core::IteratablePoolAddressAllocator<uint32_t>(m_descriptorSetAllocatorReservedSpace.get(), 0, 0, 1, m_creationParameters.maxSets, 1);
 }
 
-uint32_t IDescriptorPool::createDescriptorSets(uint32_t count, const IGPUDescriptorSetLayout* const* layouts, core::smart_refctd_ptr<IGPUDescriptorSet>* output)
+uint32_t IDescriptorPool::createDescriptorSets(const std::span<const IGPUDescriptorSetLayout* const> layouts, core::smart_refctd_ptr<IGPUDescriptorSet>* output)
 {
+    const size_t count = layouts.size();
     core::vector<uint32_t> reverseMap(count,count);
 
     core::vector<const IGPUDescriptorSetLayout*> repackedLayouts;
@@ -73,7 +74,7 @@ uint32_t IDescriptorPool::createDescriptorSets(uint32_t count, const IGPUDescrip
     else
     {
         // Free the allocated offsets for all the successfully allocated descriptor sets and the offset of the descriptor sets themselves.
-        rewindLastStorageAllocations(successCount,offsets.data(),layouts);
+        rewindLastStorageAllocations(successCount,offsets.data(),layouts.data());
         std::fill_n(output,count,nullptr);
         successCount = 0;
     }