Merge branch 'feat/tri_renderer' into feat/pipeline_abstraction

Author: gituser12981u2

include/quark/vk/allocator.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <quark/utils/raii.hpp>
+#include <quark/utils/result.hpp>
+#include <quark/vk/device/device_view.hpp>
+#include <utility>
+#include <vk_mem_alloc.h>
+#include <vulkan/vulkan_core.h>
+
+namespace quark::vk {
+
+class Allocator final {
+public:
+  struct CreateInfo {
+    VkInstance instance{VK_NULL_HANDLE};
+    DeviceView device{};
+    const VkAllocationCallbacks *allocation_callbacks{nullptr};
+    uint32_t vulkan_api_version{VK_API_VERSION_1_0};
+  };
+
+  Allocator() = default;
+  ~Allocator() { destroy(); }
+
+  QUARK_NO_COPY(Allocator);
+
+  [[nodiscard]] constexpr Allocator(Allocator &&other) noexcept
+      : allocator_(std::exchange(other.allocator_, nullptr)) {}
+
+  [[nodiscard]] constexpr Allocator &operator=(Allocator &&other) noexcept {
+    if (this == &other) {
+      return *this;
+    }
+
+    destroy();
+    allocator_ = std::exchange(other.allocator_, nullptr);
+    return *this;
+  }
+
+  [[nodiscard]] util::Status create(const CreateInfo &ci);
+  void destroy() noexcept;
+
+  [[nodiscard]] bool valid() const noexcept { return allocator_ != nullptr; }
+  [[nodiscard]] VmaAllocator handle() const noexcept { return allocator_; }
+
+private:
+  VmaAllocator allocator_ = nullptr;
+};
+
+} // namespace quark::vk

include/quark/vk/buffer.hpp

@@ -1,9 +1,11 @@
 #pragma once
 
 #include <cstddef>
+#include <memory>
 
 #include <quark/utils/raii.hpp>
 #include <quark/utils/result.hpp>
+#include <quark/vk/allocator.hpp>
 #include <vk_mem_alloc.h>
 #include <vulkan/vulkan_core.h>
 
@@ -13,62 +15,49 @@ class Buffer final {
 
 public:
   struct CreateInfo {
-    VmaAllocator allocator = nullptr;
+    const Allocator *allocator = nullptr;
     VkDeviceSize size{};
     VkBufferUsageFlags usage{};
-    VmaMemoryUsage memory_usage = VMA_MEMORY_USAGE_AUTO;
+    VmaMemoryUsage memory_usage{VMA_MEMORY_USAGE_AUTO};
     VmaAllocationCreateFlags allocation_flags{};
-    VkSharingMode sharing_mode = VK_SHARING_MODE_EXCLUSIVE;
+    VkSharingMode sharing_mode{VK_SHARING_MODE_EXCLUSIVE};
   };
 
   Buffer() = default;
   ~Buffer() { destroy(); }
 
-  QUARK_NO_COPY(Buffer); // do we want copy or not?
-
-  Buffer(Buffer &&other) noexcept
-      : allocator_(other.allocator_), buffer_(other.buffer_),
-        allocation_(other.allocation_), size_(other.size_) {
-    other.allocator_ = nullptr;
-    other.buffer_ = VK_NULL_HANDLE;
-    other.allocation_ = nullptr;
-    other.size_ = 0;
-  }
-
-  Buffer &operator=(Buffer &&other) noexcept {
-    if (this == &other) {
-      return *this;
-    }
-
-    this->destroy();
-    allocator_ = other.allocator_;
-    buffer_ = other.buffer_;
-    allocation_ = other.allocation_;
-    size_ = other.size_;
-
-    other.allocator_ = nullptr;
-    other.buffer_ = VK_NULL_HANDLE;
-    other.allocation_ = nullptr;
-    other.size_ = 0;
-    return *this;
-  }
+  QUARK_MOVE_ONLY(Buffer);
 
   util::Status create(const CreateInfo &ci);
   void destroy() noexcept;
 
   util::Status upload(const void *src, size_t byte_count,
                       VkDeviceSize offset = 0);
 
-  [[nodiscard]] bool valid() noexcept { return buffer_ != VK_NULL_HANDLE; }
+  [[nodiscard]] bool valid() noexcept {
+    return state_ != nullptr && state_->buffer != VK_NULL_HANDLE;
+  }
 
-  [[nodiscard]] VkBuffer handle() const noexcept { return buffer_; }
-  [[nodiscard]] VkDeviceSize size() const noexcept { return size_; }
+  [[nodiscard]] VkBuffer handle() const noexcept {
+    return state_ == nullptr ? VK_NULL_HANDLE : state_->buffer;
+  }
+  [[nodiscard]] VkDeviceSize size() const noexcept {
+    return state_ == nullptr ? 0 : state_->size;
+  }
 
 private:
-  VmaAllocator allocator_{nullptr};
-  VkBuffer buffer_{VK_NULL_HANDLE};
-  VmaAllocation allocation_{nullptr};
-  VkDeviceSize size_{};
+  struct State {
+    VmaAllocator allocator{nullptr};
+    VkBuffer buffer{VK_NULL_HANDLE};
+    VmaAllocation allocation{nullptr};
+    VkDeviceSize size{};
+  };
+
+  struct StateDeleter {
+    void operator()(State *state) const noexcept;
+  };
+
+  std::unique_ptr<State, StateDeleter> state_;
 };
 
 } // namespace quark::vk

include/quark/vk/device/details/device.hpp

@@ -3,9 +3,9 @@
 #include <cstdint>
 #include <quark/utils/raii.hpp>
 #include <quark/utils/result.hpp>
+#include <quark/vk/allocator.hpp>
 #include <quark/vk/device/details/device_capabilities.hpp>
 #include <vector>
-#include <vk_mem_alloc.h>
 #include <vulkan/vulkan_core.h>
 
 namespace quark::vk::details {
@@ -65,10 +65,14 @@ class Device final {
     return capabilities_;
   }
 
-  [[nodiscard]] VmaAllocator vma_allocator() const noexcept {
+  [[nodiscard]] const Allocator &allocator() const noexcept {
     return allocator_;
   }
 
+  [[nodiscard]] VmaAllocator vma_allocator() const noexcept {
+    return allocator_.handle();
+  }
+
 private:
   struct DeviceSelection {
     VkPhysicalDevice physical_device{VK_NULL_HANDLE};
@@ -106,7 +110,7 @@ class Device final {
   uint32_t graphics_queue_family_index_ = 0;
   uint32_t present_queue_family_index_ = 0;
   const VkAllocationCallbacks *alloc_ = nullptr;
-  VmaAllocator allocator_ = nullptr;
+  Allocator allocator_;
   DeviceCapabilities capabilities_{};
 };
 

include/quark/vk/device/device_bundle.hpp

@@ -2,6 +2,7 @@
 
 #include <quark/utils/raii.hpp>
 #include <quark/utils/result.hpp>
+#include <quark/vk/allocator.hpp>
 #include <quark/vk/device/details/device.hpp>
 #include <quark/vk/device/details/device_capabilities.hpp>
 #include <vulkan/vulkan_core.h>
@@ -35,6 +36,7 @@ class DeviceBundle final {
   [[nodiscard]] uint32_t graphics_queue_family_index() const noexcept;
   [[nodiscard]] uint32_t present_queue_family_index() const noexcept;
   [[nodiscard]] details::DeviceCapabilities capabilities() const noexcept;
+  [[nodiscard]] const Allocator &allocator() const noexcept;
   [[nodiscard]] VmaAllocator vma_allocator() const noexcept;
 
 private:

include/quark/vk/triangle_renderer.hpp

@@ -6,10 +6,10 @@
 #include <quark/platform/shader/details/shader_registry.hpp>
 #include <quark/utils/raii.hpp>
 #include <quark/utils/result.hpp>
+#include <quark/vk/allocator.hpp>
 #include <quark/vk/device/device_view.hpp>
 #include <quark/vk/pipeline/graphics_pipeline_desc.hpp>
 #include <quark/vk/triangle_vertex_buffer.hpp>
-#include <vk_mem_alloc.h>
 #include <vulkan/vulkan_core.h>
 
 namespace quark::vk {
@@ -18,7 +18,7 @@ class TriangleRenderer final {
 public:
   struct CreateInfo {
     DeviceView device{};
-    VmaAllocator allocator = nullptr;
+    const Allocator *allocator = nullptr;
     RetirementQueue *retire_queue = nullptr;
     VkExtent2D extent{};
     VkFormat color_format{VK_FORMAT_UNDEFINED};

include/quark/vk/triangle_vertex_buffer.hpp

@@ -4,6 +4,7 @@
 
 #include <quark/utils/raii.hpp>
 #include <quark/utils/result.hpp>
+#include <quark/vk/allocator.hpp>
 #include <quark/vk/buffer.hpp>
 
 namespace quark::vk {
@@ -15,7 +16,7 @@ class TriangleVertexBuffer final {
 
   QUARK_NO_COPY_NO_MOVE(TriangleVertexBuffer);
 
-  util::Status create(VmaAllocator allocator);
+  util::Status create(const Allocator &allocator);
   void destroy() noexcept;
 
   void bind(VkCommandBuffer command_buffer) const noexcept;

src/backend/vulkan/device/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_library(
   quark_backend_vulkan_device STATIC
+  allocator.cpp
   device.cpp
   device_feature_chain_builder.cpp
   device_bundle.cpp

src/backend/vulkan/device/allocator.cpp

@@ -0,0 +1,49 @@
+#include <quark/vk/allocator.hpp>
+#include <quark/vk/diagnostic_prelude.hpp>
+
+namespace quark::vk {
+
+util::Status Allocator::create(const Allocator::CreateInfo &ci) {
+  destroy();
+
+  QUARK_ENSURE(
+      ci.instance != VK_NULL_HANDLE,
+      QUARK_ERR(util::Errc::InvalidArg, "Allocator instance must be valid"));
+  QUARK_ENSURE(ci.device.physical_device != VK_NULL_HANDLE,
+               QUARK_ERR(util::Errc::InvalidArg,
+                         "Allocator physical device must be valid"));
+  QUARK_ENSURE(ci.device.device != VK_NULL_HANDLE,
+               QUARK_ERR(util::Errc::InvalidArg,
+                         "Allocator logical device must be valid"));
+
+  const VmaAllocatorCreateInfo allocator_info{
+      .flags = 0,
+      .physicalDevice = ci.device.physical_device,
+      .device = ci.device.device,
+      .preferredLargeHeapBlockSize = 0,
+      .pAllocationCallbacks = ci.allocation_callbacks,
+      .pDeviceMemoryCallbacks = nullptr,
+      .pHeapSizeLimit = nullptr,
+      .pVulkanFunctions = nullptr,
+      .instance = ci.instance,
+      .vulkanApiVersion = ci.vulkan_api_version,
+#if VMA_EXTERNAL_MEMORY
+      .pTypeExternalMemoryHandleTypes = nullptr,
+#endif
+  };
+
+  QUARK_VK_TRY(vmaCreateAllocator(&allocator_info, &allocator_));
+
+  QUARK_OK();
+}
+
+void Allocator::destroy() noexcept {
+  if (allocator_ == nullptr) {
+    return;
+  }
+
+  vmaDestroyAllocator(allocator_);
+  allocator_ = nullptr;
+}
+
+} // namespace quark::vk

src/backend/vulkan/device/buffer.cpp

@@ -7,16 +7,34 @@
 
 namespace quark::vk {
 
+void Buffer::StateDeleter::operator()(State *state) const noexcept {
+  if (state == nullptr) {
+    return;
+  }
+
+  if (state->allocator != nullptr && state->buffer != VK_NULL_HANDLE &&
+      state->allocation != nullptr) {
+    vmaDestroyBuffer(state->allocator, state->buffer, state->allocation);
+  }
+
+  delete state;
+}
+
 util::Status Buffer::create(const Buffer::CreateInfo &ci) {
   destroy();
 
   QUARK_ENSURE(ci.allocator != nullptr,
                QUARK_ERR(util::Errc::InvalidArg, "Buffer allocator is null"));
+  QUARK_ENSURE(
+      ci.allocator->valid(),
+      QUARK_ERR(util::Errc::InvalidArg, "Buffer allocator is not created"));
   QUARK_ENSURE(ci.size > 0,
                QUARK_ERR(util::Errc::InvalidArg, "Buffer size must be > 0"));
   QUARK_ENSURE(ci.usage != 0,
                QUARK_ERR(util::Errc::InvalidArg, "Buffer usage must be set"));
 
+  VmaAllocator allocator = ci.allocator->handle();
+
   VkBufferCreateInfo buffer_info{};
   buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
   buffer_info.size = ci.size;
@@ -27,45 +45,40 @@ util::Status Buffer::create(const Buffer::CreateInfo &ci) {
   alloc_info.usage = ci.memory_usage;
   alloc_info.flags = ci.allocation_flags;
 
-  QUARK_VK_TRY(vmaCreateBuffer(ci.allocator, &buffer_info, &alloc_info,
-                               &buffer_, &allocation_, nullptr));
+  auto state = std::unique_ptr<State, StateDeleter>(new State{});
+  state->allocator = allocator;
 
-  allocator_ = ci.allocator;
-  size_ = ci.size;
-  QUARK_OK();
-}
+  QUARK_VK_TRY(vmaCreateBuffer(allocator, &buffer_info, &alloc_info,
+                               &state->buffer, &state->allocation, nullptr));
 
-void Buffer::destroy() noexcept {
-  if (allocator_ != nullptr && buffer_ != VK_NULL_HANDLE &&
-      allocation_ != nullptr) {
-    vmaDestroyBuffer(allocator_, buffer_, allocation_);
-  }
+  state->size = ci.size;
+  state_ = std::move(state);
 
-  allocator_ = nullptr;
-  buffer_ = VK_NULL_HANDLE;
-  allocation_ = nullptr;
-  size_ = 0;
+  QUARK_OK();
 }
 
+void Buffer::destroy() noexcept { state_.reset(); }
+
 util::Status Buffer::upload(const void *src, size_t byte_count,
                             VkDeviceSize offset) {
   QUARK_ENSURE(valid(),
                QUARK_ERR(util::Errc::InvalidState, "Buffer is not created"));
   QUARK_ENSURE(src != nullptr,
                QUARK_ERR(util::Errc::InvalidArg, "Upload source is null"));
-  QUARK_ENSURE(offset <= size_, QUARK_ERR(util::Errc::InvalidArg,
-                                          "Upload offset exceeds buffer size"));
+  QUARK_ENSURE(
+      offset <= state_->size,
+      QUARK_ERR(util::Errc::InvalidArg, "Upload offset exceeds buffer size"));
   QUARK_ENSURE(byte_count <= (std::numeric_limits<VkDeviceSize>::max)(),
                QUARK_ERR(util::Errc::InvalidArg,
                          "Upload byte_count exceeds VkDeviceSize"));
 
   const VkDeviceSize copy_size = static_cast<VkDeviceSize>(byte_count);
   QUARK_ENSURE(
-      copy_size <= (size_ - offset),
+      copy_size <= (state_->size - offset),
       QUARK_ERR(util::Errc::InvalidArg, "Upload range exceeds buffer size"));
 
-  QUARK_VK_TRY(vmaCopyMemoryToAllocation(allocator_, src, allocation_, offset,
-                                         copy_size));
+  QUARK_VK_TRY(vmaCopyMemoryToAllocation(
+      state_->allocator, src, state_->allocation, offset, copy_size));
   QUARK_OK();
 }