fix: forget to include allocator files

Author: alexcu2718

include/quark/vk/allocator.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <quark/utils/raii.hpp>
+#include <quark/utils/result.hpp>
+#include <vk_mem_alloc.h>
+#include <vulkan/vulkan_core.h>
+
+namespace quark::vk {
+
+class Allocator final {
+public:
+  struct CreateInfo {
+    VkInstance instance{VK_NULL_HANDLE};
+    VkPhysicalDevice physical_device{VK_NULL_HANDLE};
+    VkDevice device{VK_NULL_HANDLE};
+    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_(other.allocator_) {
+    other.allocator_ = nullptr;
+  }
+
+  [[nodiscard]] constexpr Allocator &operator=(Allocator &&other) noexcept {
+    if (this == &other) {
+      return *this;
+    }
+
+    destroy();
+    allocator_ = other.allocator_;
+    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

src/backend/vulkan/device/allocator.cpp

@@ -0,0 +1,53 @@
+#include <quark/utils/diagnostic.hpp>
+#include <quark/vk/allocator.hpp>
+#include <quark/vk/vk_error.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.physical_device != VK_NULL_HANDLE,
+               QUARK_ERR(util::Errc::InvalidArg,
+                         "Allocator physical device must be valid"));
+  QUARK_ENSURE(ci.device != VK_NULL_HANDLE,
+               QUARK_ERR(util::Errc::InvalidArg,
+                         "Allocator logical device must be valid"));
+
+  const VmaAllocatorCreateInfo allocator_info{
+      .flags = 0,
+      .physicalDevice = ci.physical_device,
+      .device = ci.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
+  };
+
+  const VkResult result = vmaCreateAllocator(&allocator_info, &allocator_);
+  if (result != VK_SUCCESS) {
+    return util::unexpected(vk_error(result, "vmaCreateAllocator"));
+  }
+
+  QUARK_OK();
+}
+
+void Allocator::destroy() noexcept {
+  if (allocator_ == nullptr) {
+    return;
+  }
+
+  vmaDestroyAllocator(allocator_);
+  allocator_ = nullptr;
+}
+
+} // namespace quark::vk