Unify vkb::allocated::Allocated and vkb::allocated::HPPAllocated into vkb::allocated::Allocated<bindingType>

Author: asuessenbach

framework/CMakeLists.txt

@@ -251,7 +251,6 @@ set(CORE_FILES
     core/render_pass.h
     core/query_pool.h
     core/acceleration_structure.h
-    core/hpp_allocated.h
     core/hpp_command_buffer.h
     core/hpp_command_pool.h
     core/hpp_debug.h

framework/core/allocated.cpp

@@ -17,6 +17,7 @@
  */
 
 #include "allocated.h"
+#include "common/error.h"
 
 namespace vkb
 {
@@ -52,182 +53,5 @@ void shutdown()
 	}
 }
 
-AllocatedBase::AllocatedBase(const VmaAllocationCreateInfo &alloc_create_info) :
-    alloc_create_info(alloc_create_info)
-{
-}
-
-AllocatedBase::AllocatedBase(AllocatedBase &&other) noexcept :
-    alloc_create_info(std::exchange(other.alloc_create_info, {})),
-    allocation(std::exchange(other.allocation, {})),
-    mapped_data(std::exchange(other.mapped_data, {})),
-    coherent(std::exchange(other.coherent, {})),
-    persistent(std::exchange(other.persistent, {}))
-{
-}
-
-const uint8_t *AllocatedBase::get_data() const
-{
-	return mapped_data;
-}
-
-VkDeviceMemory AllocatedBase::get_memory() const
-{
-	VmaAllocationInfo alloc_info;
-	vmaGetAllocationInfo(get_memory_allocator(), allocation, &alloc_info);
-	return alloc_info.deviceMemory;
-}
-
-void AllocatedBase::flush(VkDeviceSize offset, VkDeviceSize size)
-{
-	if (!coherent)
-	{
-		vmaFlushAllocation(get_memory_allocator(), allocation, offset, size);
-	}
-}
-
-uint8_t *AllocatedBase::map()
-{
-	if (!persistent && !mapped())
-	{
-		VK_CHECK(vmaMapMemory(get_memory_allocator(), allocation, reinterpret_cast<void **>(&mapped_data)));
-		assert(mapped_data);
-	}
-	return mapped_data;
-}
-
-void AllocatedBase::unmap()
-{
-	if (!persistent && mapped())
-	{
-		vmaUnmapMemory(get_memory_allocator(), allocation);
-		mapped_data = nullptr;
-	}
-}
-
-size_t AllocatedBase::update(const uint8_t *data, size_t size, size_t offset)
-{
-	if (persistent)
-	{
-		std::copy(data, data + size, mapped_data + offset);
-		flush();
-	}
-	else
-	{
-		map();
-		std::copy(data, data + size, mapped_data + offset);
-		flush();
-		unmap();
-	}
-	return size;
-}
-
-size_t AllocatedBase::update(void const *data, size_t size, size_t offset)
-{
-	return update(reinterpret_cast<const uint8_t *>(data), size, offset);
-}
-
-void AllocatedBase::post_create(VmaAllocationInfo const &allocation_info)
-{
-	VkMemoryPropertyFlags memory_properties;
-	vmaGetAllocationMemoryProperties(get_memory_allocator(), allocation, &memory_properties);
-	coherent    = (memory_properties & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT) == VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
-	mapped_data = static_cast<uint8_t *>(allocation_info.pMappedData);
-	persistent  = mapped();
-}
-
-[[nodiscard]] VkBuffer AllocatedBase::create_buffer(VkBufferCreateInfo const &create_info)
-{
-	VkBuffer          handleResult = VK_NULL_HANDLE;
-	VmaAllocationInfo allocation_info{};
-
-	auto result = vmaCreateBuffer(
-	    get_memory_allocator(),
-	    &create_info,
-	    &alloc_create_info,
-	    &handleResult,
-	    &allocation,
-	    &allocation_info);
-
-	if (result != VK_SUCCESS)
-	{
-		throw VulkanException{result, "Cannot create Buffer"};
-	}
-	post_create(allocation_info);
-	return handleResult;
-}
-
-[[nodiscard]] VkImage AllocatedBase::create_image(VkImageCreateInfo const &create_info)
-{
-	assert(0 < create_info.mipLevels && "Images should have at least one level");
-	assert(0 < create_info.arrayLayers && "Images should have at least one layer");
-	assert(0 < create_info.usage && "Images should have at least one usage type");
-
-	VkImage           handleResult = VK_NULL_HANDLE;
-	VmaAllocationInfo allocation_info{};
-
-#if 0
-		// If the image is an attachment, prefer dedicated memory
-		constexpr VkImageUsageFlags attachment_only_flags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
-		if (create_info.usage & attachment_only_flags)
-		{
-			alloc_create_info.flags |= VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT;
-		}
-
-		if (create_info.usage & VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT)
-		{
-			alloc_create_info.preferredFlags |= VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT;
-		}
-#endif
-
-	auto result = vmaCreateImage(
-	    get_memory_allocator(),
-	    &create_info,
-	    &alloc_create_info,
-	    &handleResult,
-	    &allocation,
-	    &allocation_info);
-
-	if (result != VK_SUCCESS)
-	{
-		throw VulkanException{result, "Cannot create Image"};
-	}
-
-	post_create(allocation_info);
-	return handleResult;
-}
-
-void AllocatedBase::destroy_buffer(VkBuffer handle)
-{
-	if (handle != VK_NULL_HANDLE && allocation != VK_NULL_HANDLE)
-	{
-		unmap();
-		vmaDestroyBuffer(get_memory_allocator(), handle, allocation);
-		clear();
-	}
-}
-
-void AllocatedBase::destroy_image(VkImage image)
-{
-	if (image != VK_NULL_HANDLE && allocation != VK_NULL_HANDLE)
-	{
-		unmap();
-		vmaDestroyImage(get_memory_allocator(), image, allocation);
-		clear();
-	}
-}
-
-bool AllocatedBase::mapped() const
-{
-	return mapped_data != nullptr;
-}
-
-void AllocatedBase::clear()
-{
-	mapped_data       = nullptr;
-	persistent        = false;
-	alloc_create_info = {};
-}
-
 }        // namespace allocated
 }        // namespace vkb