vulkan-test/src/main.cpp

#include <fmt/format.h>
#include <fstream>
#include <iostream>
#include <set>

#define VULKAN_HPP_DISPATCH_LOADER_DYNAMIC 1
#define VK_ENABLE_BETA_EXTENSIONS
#define VULKAN_HPP_NO_CONSTRUCTORS
#define VULKAN_HPP_NO_EXCEPTIONS
#include <vulkan/vulkan.hpp>

VULKAN_HPP_DEFAULT_DISPATCH_LOADER_DYNAMIC_STORAGE

#include "util/types.h"

#define VKFW_NO_STD_FUNCTION_CALLBACKS
#include "vkfw.hpp"

constexpr i32 WIDTH  = 800;
constexpr i32 HEIGHT = 600;

constexpr i32 MAX_FRAMES_IN_FLIGHT = 2;

constexpr std::array<const char*, 1> validationLayers = { "VK_LAYER_KHRONOS_validation" };

#ifdef __APPLE__
constexpr std::array<const char*, 2> deviceExtensions = { vk::KHRSwapchainExtensionName,
                                                          vk::KHRPortabilitySubsetExtensionName };
#else
constexpr std::array<const char*, 1> deviceExtensions = { vk::KHRSwapchainExtensionName };
#endif

#ifdef NDEBUG
constexpr bool enableValidationLayers = false;
#else
constexpr bool enableValidationLayers = true;
#endif

class VulkanApp {
 public:
  fn run() -> void {
    initWindow();
    initVulkan();
    mainLoop();
  }

 private:
  vkfw::UniqueInstance mGLFWInstance;
  vkfw::UniqueWindow   mWindow;

  vk::UniqueInstance mInstance;

  vk::UniqueDebugUtilsMessengerEXT mDebugMessenger;
  vk::UniqueSurfaceKHR             mSurface;

  vk::PhysicalDevice mPhysicalDevice;
  vk::UniqueDevice   mDevice;

  vk::Queue mGraphicsQueue;
  vk::Queue mPresentQueue;

  vk::UniqueSwapchainKHR             mSwapChain;
  std::vector<vk::Image>             mSwapChainImages;
  vk::Format                         mSwapChainImageFormat;
  vk::Extent2D                       mSwapChainExtent;
  std::vector<vk::UniqueImageView>   mSwapChainImageViews;
  std::vector<vk::UniqueFramebuffer> mSwapChainFramebuffers;

  vk::UniqueRenderPass     mRenderPass;
  vk::UniquePipelineLayout mPipelineLayout;
  vk::UniquePipeline       mGraphicsPipeline;

  vk::UniqueCommandPool                mCommandPool;
  std::vector<vk::UniqueCommandBuffer> mCommandBuffers;

  std::vector<vk::UniqueSemaphore> mImageAvailableSemaphores;
  std::vector<vk::UniqueSemaphore> mRenderFinishedSemaphores;
  std::vector<vk::UniqueFence>     mInFlightFences;

  bool mFramebufferResized = false;
  u32  mCurrentFrame       = 0;

  struct QueueFamilyIndices {
    std::optional<u32> graphics_family;
    std::optional<u32> present_family;

    fn isComplete() -> bool { return graphics_family.has_value() && present_family.has_value(); }
  };

  struct SwapChainSupportDetails {
    vk::SurfaceCapabilitiesKHR        capabilities;
    std::vector<vk::SurfaceFormatKHR> formats;
    std::vector<vk::PresentModeKHR>   present_modes;
  };

  static fn readFile(const std::string& filename) -> std::vector<char> {
    std::ifstream file(filename, std::ios::ate | std::ios::binary);

    if (!file.is_open())
      throw std::runtime_error("Failed to open file! " + filename);

    usize             fileSize = static_cast<usize>(file.tellg());
    std::vector<char> buffer(fileSize);

    file.seekg(0);
    file.read(buffer.data(), static_cast<std::streamsize>(fileSize));

    file.close();

    return buffer;
  }

  fn initWindow() -> void {
    mGLFWInstance = vkfw::initUnique();

    vkfw::WindowHints hints;

    hints.clientAPI = vkfw::ClientAPI::eNone;
    // hints.resizable = false;

    mWindow = vkfw::createWindowUnique(WIDTH, HEIGHT, "Vulkan", hints);
    mWindow->setUserPointer(this);
    mWindow->setFramebufferSizeCallback(framebufferResizeCallback);
  }

  static fn framebufferResizeCallback(GLFWwindow* window, int /*width*/, int /*height*/) -> void {
    auto* app = std::bit_cast<VulkanApp*>(glfwGetWindowUserPointer(window));

    app->mFramebufferResized = true;
  }

  fn initVulkan() -> void {
    createInstance();
    setupDebugMessenger();
    createSurface();
    pickPhysicalDevice();
    createLogicalDevice();
    createSwapChain();
    createImageViews();
    createRenderPass();
    createGraphicsPipeline();
    createFramebuffers();
    createCommandPool();
    createCommandBuffers();
    createSyncObjects();
  }

  fn mainLoop() -> void {
    while (!mWindow->shouldClose()) {
      vkfw::waitEvents();
      drawFrame();
    }

    auto result = mDevice->waitIdle();

    if (result != vk::Result::eSuccess)
      throw std::runtime_error("Failed to wait for idle!");
  }

  fn cleanupSwapChain() -> void {
    for (vk::UniqueFramebuffer& mSwapChainFramebuffer : mSwapChainFramebuffers) {
      mSwapChainFramebuffer.reset();
    }
    for (vk::UniqueImageView& mSwapChainImageView : mSwapChainImageViews) { mSwapChainImageView.reset(); }

    mSwapChain.reset();
  }

  fn recreateSwapChain() -> void {
    u32 width = 0, height = 0;
    std::tie(width, height) = mWindow->getFramebufferSize();

    while (width == 0 || height == 0) {
      std::tie(width, height) = mWindow->getFramebufferSize();
      vkfw::waitEvents();
    }

    auto result = mDevice->waitIdle();

    if (result != vk::Result::eSuccess)
      throw std::runtime_error("Failed to wait for idle!");

    cleanupSwapChain();

    createSwapChain();
    createImageViews();
    createFramebuffers();
  }

  fn createInstance() -> void {
    if (enableValidationLayers && !checkValidationLayerSupport())
      throw std::runtime_error("Validation layers requested, but not available!");

    vk::ApplicationInfo appInfo { .pApplicationName   = "Hello Triangle",
                                  .applicationVersion = 1,
                                  .pEngineName        = "No Engine",
                                  .engineVersion      = 1,
                                  .apiVersion         = vk::ApiVersion12 };

    // Retrieve extensions using custom function
    std::vector<const char*> extensions = getRequiredExtensions();

#ifdef __APPLE__
    // Enable the portability extension and set flags
    extensions.emplace_back(vk::KHRPortabilityEnumerationExtensionName);
    // Technically deprecated but vulkan complains if I don't include it for macOS
    // So instead of using the vk::KHRPortabilitySubsetExtensionName, I just use
    // the direct string.
    extensions.emplace_back("VK_KHR_get_physical_device_properties2");
#endif

    vk::InstanceCreateInfo createInfo {
#ifdef __APPLE__
      .flags = vk::InstanceCreateFlagBits::eEnumeratePortabilityKHR,
#endif
      .pApplicationInfo        = &appInfo,
      .enabledLayerCount       = enableValidationLayers ? static_cast<u32>(validationLayers.size()) : 0,
      .ppEnabledLayerNames     = enableValidationLayers ? validationLayers.data() : nullptr,
      .enabledExtensionCount   = static_cast<u32>(extensions.size()),
      .ppEnabledExtensionNames = extensions.data()
    };

#ifndef NDEBUG
    fmt::println("Available extensions:");

    for (const char* extension : extensions) fmt::println("\t{}", extension);
#endif

    vk::Result         instanceResult = vk::Result::eSuccess;
    vk::UniqueInstance instanceValue;

    std::tie(instanceResult, instanceValue) = vk::createInstanceUnique(createInfo).asTuple();

    if (instanceResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to create instance!");

    mInstance = std::move(instanceValue);

    VULKAN_HPP_DEFAULT_DISPATCHER.init(mInstance.get());
  }

  fn setupDebugMessenger() -> void {
    if (!enableValidationLayers)
      return;

    vk::DebugUtilsMessengerCreateInfoEXT messengerCreateInfo {
      .messageSeverity = vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose |
                         vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning |
                         vk::DebugUtilsMessageSeverityFlagBitsEXT::eError,
      .messageType = vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral |
                     vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation |
                     vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance,
      .pfnUserCallback = debugCallback,
    };

    vk::Result                       debugMessengerResult = vk::Result::eSuccess;
    vk::UniqueDebugUtilsMessengerEXT debugMessengerValue;

    std::tie(debugMessengerResult, debugMessengerValue) =
      mInstance->createDebugUtilsMessengerEXTUnique(messengerCreateInfo, nullptr).asTuple();

    if (debugMessengerResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to set up debug messenger!");

    mDebugMessenger = std::move(debugMessengerValue);
  }

  fn createSurface() -> void { mSurface = vkfw::createWindowSurfaceUnique(mInstance.get(), mWindow.get()); }

  fn pickPhysicalDevice() -> void {
    vk::Result                      devicesResult = vk::Result::eSuccess;
    std::vector<vk::PhysicalDevice> devicesValue;
    std::tie(devicesResult, devicesValue) = mInstance->enumeratePhysicalDevices();

    if (devicesResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to enumerate physical devices!");

    if (devicesValue.empty())
      throw std::runtime_error("Failed to find GPUs with Vulkan support!");

#ifndef NDEBUG
    fmt::println("Available devices:");
#endif

    for (const vk::PhysicalDevice& device : devicesValue) {
#ifndef NDEBUG
      vk::PhysicalDeviceProperties properties = device.getProperties();
      fmt::println("\t{}", properties.deviceName.data());
#endif

      if (isDeviceSuitable(device)) {
        mPhysicalDevice = device;
        break;
      }
    }

    if (!mPhysicalDevice)
      throw std::runtime_error("Failed to find a suitable GPU!");
  }

  fn createLogicalDevice() -> void {
    QueueFamilyIndices indices = findQueueFamilies(mPhysicalDevice);

    std::vector<vk::DeviceQueueCreateInfo> queueCreateInfos;
    std::set<u32> uniqueQueueFamilies = { indices.graphics_family.value(), indices.present_family.value() };

    f32 queuePriority = 1.0F;

    for (u32 queueFamily : uniqueQueueFamilies) {
      vk::DeviceQueueCreateInfo queueCreateInfo { .queueFamilyIndex = queueFamily,
                                                  .queueCount       = 1,
                                                  .pQueuePriorities = &queuePriority };

      queueCreateInfos.emplace_back(queueCreateInfo);
    }

    vk::PhysicalDeviceFeatures deviceFeatures;

    vk::DeviceCreateInfo createInfo { .queueCreateInfoCount    = static_cast<u32>(queueCreateInfos.size()),
                                      .pQueueCreateInfos       = queueCreateInfos.data(),
                                      .enabledExtensionCount   = static_cast<u32>(deviceExtensions.size()),
                                      .ppEnabledExtensionNames = deviceExtensions.data(),
                                      .pEnabledFeatures        = &deviceFeatures };

    vk::Result       createDeviceResult = vk::Result::eSuccess;
    vk::UniqueDevice createDeviceValue;

    std::tie(createDeviceResult, createDeviceValue) =
      mPhysicalDevice.createDeviceUnique(createInfo).asTuple();

    if (createDeviceResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to create logical device!");

    mDevice = std::move(createDeviceValue);

    mGraphicsQueue = mDevice->getQueue(indices.graphics_family.value(), 0);
    mPresentQueue  = mDevice->getQueue(indices.present_family.value(), 0);
  }

  fn createSwapChain() -> void {
    SwapChainSupportDetails swapChainSupport = querySwapChainSupport(mPhysicalDevice);

    vk::SurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
    vk::PresentModeKHR   presentMode   = chooseSwapPresentMode(swapChainSupport.present_modes);
    vk::Extent2D         extent        = chooseSwapExtent(swapChainSupport.capabilities);

    u32 imageCount = swapChainSupport.capabilities.minImageCount + 1;

    if (swapChainSupport.capabilities.maxImageCount > 0 &&
        imageCount > swapChainSupport.capabilities.maxImageCount)
      imageCount = swapChainSupport.capabilities.maxImageCount;

    QueueFamilyIndices indices            = findQueueFamilies(mPhysicalDevice);
    std::array<u32, 2> queueFamilyIndices = { indices.graphics_family.value(),
                                              indices.present_family.value() };

    vk::SwapchainCreateInfoKHR createInfo {
      .surface          = mSurface.get(),
      .minImageCount    = imageCount,
      .imageFormat      = surfaceFormat.format,
      .imageColorSpace  = surfaceFormat.colorSpace,
      .imageExtent      = extent,
      .imageArrayLayers = 1,
      .imageUsage       = vk::ImageUsageFlagBits::eColorAttachment,
      .imageSharingMode = indices.graphics_family != indices.present_family ? vk::SharingMode::eConcurrent
                                                                            : vk::SharingMode::eExclusive,
      .queueFamilyIndexCount = static_cast<u32>(indices.graphics_family != indices.present_family ? 2 : 0),
      .pQueueFamilyIndices =
        indices.graphics_family != indices.present_family ? queueFamilyIndices.data() : nullptr,
      .preTransform   = swapChainSupport.capabilities.currentTransform,
      .compositeAlpha = vk::CompositeAlphaFlagBitsKHR::eOpaque,
      .presentMode    = presentMode,
      .clipped        = vk::True,
      .oldSwapchain   = nullptr,
    };

    vk::Result             swapChainResult = vk::Result::eSuccess;
    vk::UniqueSwapchainKHR swapChainValue;

    std::tie(swapChainResult, swapChainValue) = mDevice->createSwapchainKHRUnique(createInfo).asTuple();

    if (swapChainResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to create swap chain!");

    mSwapChain = std::move(swapChainValue);

    vk::Result             swapChainImagesResult = vk::Result::eSuccess;
    std::vector<vk::Image> mSwapChainImagesValue;
    std::tie(swapChainImagesResult, mSwapChainImagesValue) = mDevice->getSwapchainImagesKHR(mSwapChain.get());

    if (swapChainImagesResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to get swap chain images!");

    mSwapChainImages      = std::move(mSwapChainImagesValue);
    mSwapChainImageFormat = surfaceFormat.format;
    mSwapChainExtent      = extent;
  }

  fn createImageViews() -> void {
    mSwapChainImageViews.resize(mSwapChainImages.size());

    for (u32 i = 0; i < mSwapChainImages.size(); i++) {
      vk::ImageViewCreateInfo createInfo {
        .image    = mSwapChainImages[i],
        .viewType = vk::ImageViewType::e2D,
        .format   = mSwapChainImageFormat,
        // clang-format off
        .components       = { .r = vk::ComponentSwizzle::eIdentity,
                              .g = vk::ComponentSwizzle::eIdentity,
                              .b = vk::ComponentSwizzle::eIdentity,
                              .a = vk::ComponentSwizzle::eIdentity },
        .subresourceRange = { .aspectMask     = vk::ImageAspectFlagBits::eColor,
                              .baseMipLevel   = 0,
                              .levelCount     = 1,
                              .baseArrayLayer = 0,
                              .layerCount     = 1 },
        // clang-format on
      };

      vk::Result          createImageViewResult = vk::Result::eSuccess;
      vk::UniqueImageView imageViewValue;

      std::tie(createImageViewResult, imageViewValue) = mDevice->createImageViewUnique(createInfo).asTuple();

      if (createImageViewResult != vk::Result::eSuccess)
        throw std::runtime_error("Failed to create image views!");

      mSwapChainImageViews[i] = std::move(imageViewValue);
    }
  }

  fn createRenderPass() -> void {
    vk::AttachmentDescription colorAttachment {
      .format         = mSwapChainImageFormat,
      .samples        = vk::SampleCountFlagBits::e1,
      .loadOp         = vk::AttachmentLoadOp::eClear,
      .storeOp        = vk::AttachmentStoreOp::eStore,
      .stencilLoadOp  = vk::AttachmentLoadOp::eDontCare,
      .stencilStoreOp = vk::AttachmentStoreOp::eDontCare,
      .initialLayout  = vk::ImageLayout::eUndefined,
      .finalLayout    = vk::ImageLayout::ePresentSrcKHR,
    };

    vk::AttachmentReference colorAttachmentRef {
      .attachment = 0,
      .layout     = vk::ImageLayout::eColorAttachmentOptimal,
    };

    vk::SubpassDescription subpass {
      .pipelineBindPoint    = vk::PipelineBindPoint::eGraphics,
      .colorAttachmentCount = 1,
      .pColorAttachments    = &colorAttachmentRef,
    };

    vk::RenderPassCreateInfo renderPassInfo {
      .attachmentCount = 1,
      .pAttachments    = &colorAttachment,
      .subpassCount    = 1,
      .pSubpasses      = &subpass,
    };

    vk::Result           renderPassResult = vk::Result::eSuccess;
    vk::UniqueRenderPass renderPassValue;

    std::tie(renderPassResult, renderPassValue) = mDevice->createRenderPassUnique(renderPassInfo).asTuple();

    if (renderPassResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to create render pass!");

    mRenderPass = std::move(renderPassValue);
  }

  fn createGraphicsPipeline() -> void {
    std::vector<char> vertShaderCode = readFile("src/shaders/vert.spv");
    std::vector<char> fragShaderCode = readFile("src/shaders/frag.spv");

    vk::UniqueShaderModule vertShaderModule = createShaderModule(vertShaderCode);
    vk::UniqueShaderModule fragShaderModule = createShaderModule(fragShaderCode);

    vk::PipelineShaderStageCreateInfo vertShaderStageInfo {
      .stage  = vk::ShaderStageFlagBits::eVertex,
      .module = vertShaderModule.get(),
      .pName  = "main",
    };

    vk::PipelineShaderStageCreateInfo fragShaderStageInfo {
      .stage  = vk::ShaderStageFlagBits::eFragment,
      .module = fragShaderModule.get(),
      .pName  = "main",
    };

    std::array<vk::PipelineShaderStageCreateInfo, 2> shaderStages = { vertShaderStageInfo,
                                                                      fragShaderStageInfo };

    vk::PipelineVertexInputStateCreateInfo vertexInputInfo {
      .vertexBindingDescriptionCount   = 0,
      .pVertexBindingDescriptions      = nullptr,
      .vertexAttributeDescriptionCount = 0,
      .pVertexAttributeDescriptions    = nullptr,
    };

    vk::PipelineInputAssemblyStateCreateInfo inputAssembly {
      .topology               = vk::PrimitiveTopology::eTriangleList,
      .primitiveRestartEnable = vk::False,
    };

    vk::PipelineViewportStateCreateInfo viewportState {
      .viewportCount = 1,
      .scissorCount  = 1,
    };

    vk::PipelineRasterizationStateCreateInfo rasterizer {
      .depthClampEnable        = vk::False,
      .rasterizerDiscardEnable = vk::False,
      .polygonMode             = vk::PolygonMode::eFill,
      .cullMode                = vk::CullModeFlagBits::eBack,
      .frontFace               = vk::FrontFace::eClockwise,
      .depthBiasEnable         = vk::False,
      .lineWidth               = 1.0F,
    };

    vk::PipelineMultisampleStateCreateInfo multisampling {
      .rasterizationSamples = vk::SampleCountFlagBits::e1,
      .sampleShadingEnable  = vk::False,
    };

    vk::PipelineColorBlendAttachmentState colorBlendAttachment {
      .blendEnable    = vk::False,
      .colorWriteMask = vk::ColorComponentFlagBits::eR | vk::ColorComponentFlagBits::eG |
                        vk::ColorComponentFlagBits::eB | vk::ColorComponentFlagBits::eA,
    };

    vk::PipelineColorBlendStateCreateInfo colorBlending {
      .logicOpEnable   = vk::False,
      .logicOp         = vk::LogicOp::eCopy,
      .attachmentCount = 1,
      .pAttachments    = &colorBlendAttachment,
      .blendConstants  = std::array<float, 4> { 0.0F, 0.0F, 0.0F, 0.0F },
    };
    std::vector<vk::DynamicState> dynamicStates = { vk::DynamicState::eViewport, vk::DynamicState::eScissor };

    vk::PipelineDynamicStateCreateInfo dynamicState {
      .dynamicStateCount = static_cast<u32>(dynamicStates.size()),
      .pDynamicStates    = dynamicStates.data(),
    };

    vk::PipelineLayoutCreateInfo pipelineLayoutInfo {
      .setLayoutCount         = 0,
      .pushConstantRangeCount = 0,
    };

    vk::Result               pipelineLayoutResult = vk::Result::eSuccess;
    vk::UniquePipelineLayout pipelineLayoutValue;

    std::tie(pipelineLayoutResult, pipelineLayoutValue) =
      mDevice->createPipelineLayoutUnique(pipelineLayoutInfo).asTuple();

    if (pipelineLayoutResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to create pipeline layout!");

    mPipelineLayout = std::move(pipelineLayoutValue);

    vk::GraphicsPipelineCreateInfo pipelineInfo {
      .stageCount          = static_cast<u32>(shaderStages.size()),
      .pStages             = shaderStages.data(),
      .pVertexInputState   = &vertexInputInfo,
      .pInputAssemblyState = &inputAssembly,
      .pViewportState      = &viewportState,
      .pRasterizationState = &rasterizer,
      .pMultisampleState   = &multisampling,
      .pColorBlendState    = &colorBlending,
      .pDynamicState       = &dynamicState,
      .layout              = mPipelineLayout.get(),
      .renderPass          = mRenderPass.get(),
      .subpass             = 0,
    };

    vk::Result         graphicsPipelineResult = vk::Result::eSuccess;
    vk::UniquePipeline graphicsPipelineValue;

    std::tie(graphicsPipelineResult, graphicsPipelineValue) =
      mDevice->createGraphicsPipelineUnique(nullptr, pipelineInfo).asTuple();

    if (graphicsPipelineResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to create graphics pipeline!");

    mGraphicsPipeline = std::move(graphicsPipelineValue);
  }

  fn createFramebuffers() -> void {
    mSwapChainFramebuffers.resize(mSwapChainImageViews.size());

    for (usize i = 0; i < mSwapChainImageViews.size(); i++) {
      vk::FramebufferCreateInfo framebufferInfo {
        .renderPass      = mRenderPass.get(),
        .attachmentCount = 1,
        .pAttachments    = &mSwapChainImageViews[i].get(),
        .width           = mSwapChainExtent.width,
        .height          = mSwapChainExtent.height,
        .layers          = 1,
      };

      vk::Result            framebufferResult = vk::Result::eSuccess;
      vk::UniqueFramebuffer framebufferValue;

      std::tie(framebufferResult, framebufferValue) =
        mDevice->createFramebufferUnique(framebufferInfo).asTuple();

      if (framebufferResult != vk::Result::eSuccess)
        throw std::runtime_error("Failed to create framebuffer!");

      mSwapChainFramebuffers[i] = std::move(framebufferValue);
    }
  }

  fn createCommandPool() -> void {
    QueueFamilyIndices queueFamilyIndices = findQueueFamilies(mPhysicalDevice);

    vk::CommandPoolCreateInfo poolInfo {
      .flags            = vk::CommandPoolCreateFlagBits::eResetCommandBuffer,
      .queueFamilyIndex = queueFamilyIndices.graphics_family.value(),
    };

    vk::Result            commandPoolResult = vk::Result::eSuccess;
    vk::UniqueCommandPool commandPoolValue;

    std::tie(commandPoolResult, commandPoolValue) = mDevice->createCommandPoolUnique(poolInfo).asTuple();

    if (commandPoolResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to create command pool!");

    mCommandPool = std::move(commandPoolValue);
  }

  fn createCommandBuffers() -> void {
    mCommandBuffers.resize(MAX_FRAMES_IN_FLIGHT);

    vk::CommandBufferAllocateInfo allocInfo { .commandPool = mCommandPool.get(),
                                              .level       = vk::CommandBufferLevel::ePrimary,
                                              .commandBufferCount =
                                                static_cast<u32>(mCommandBuffers.size()) };

    vk::Result                           commandBufferResult = vk::Result::eSuccess;
    std::vector<vk::UniqueCommandBuffer> commandBufferValue;

    std::tie(commandBufferResult, commandBufferValue) =
      mDevice->allocateCommandBuffersUnique(allocInfo).asTuple();

    if (commandBufferResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to allocate command buffers!");

    mCommandBuffers = std::move(commandBufferValue);
  }

  fn recordCommandBuffer(vk::CommandBuffer commandBuffer, u32 imageIndex) -> void {
    vk::CommandBufferBeginInfo beginInfo {};

    vk::Result beginResult = commandBuffer.begin(beginInfo);

    if (beginResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to begin command buffer!");

    vk::ClearValue clearColor { .color = { .float32 = std::array<float, 4> { 0.0F, 0.0F, 0.0F, 1.0F } } };

    vk::RenderPassBeginInfo renderPassInfo {
      .renderPass      = mRenderPass.get(),
      .framebuffer     = mSwapChainFramebuffers[imageIndex].get(),
      .renderArea      = { .offset = { .x = 0, .y = 0 }, .extent = mSwapChainExtent },
      .clearValueCount = 1,
      .pClearValues    = &clearColor,
    };

    commandBuffer.beginRenderPass(renderPassInfo, vk::SubpassContents::eInline);
    commandBuffer.bindPipeline(vk::PipelineBindPoint::eGraphics, mGraphicsPipeline.get());

    vk::Viewport viewport {
      .x        = 0.0F,
      .y        = 0.0F,
      .width    = static_cast<f32>(mSwapChainExtent.width),
      .height   = static_cast<f32>(mSwapChainExtent.height),
      .minDepth = 0.0F,
      .maxDepth = 1.0F,
    };
    vk::Rect2D scissor {
      .offset = { 0, 0 },
      .extent = mSwapChainExtent,
    };

    commandBuffer.setViewport(0, viewport);
    commandBuffer.setScissor(0, scissor);

    commandBuffer.draw(3, 1, 0, 0);

    commandBuffer.endRenderPass();

    vk::Result endResult = commandBuffer.end();

    if (endResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to end command buffer!");
  }

  fn createSyncObjects() -> void {
    mImageAvailableSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
    mRenderFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
    mInFlightFences.resize(MAX_FRAMES_IN_FLIGHT);

    vk::SemaphoreCreateInfo semaphoreInfo {};
    vk::FenceCreateInfo     fenceInfo { .flags = vk::FenceCreateFlagBits::eSignaled };

    for (usize idx = 0; idx < MAX_FRAMES_IN_FLIGHT; idx++) {
      vk::Result          imageAvailableSemaphoreResult = vk::Result::eSuccess;
      vk::UniqueSemaphore imageAvailableSemaphoreValue;

      std::tie(imageAvailableSemaphoreResult, imageAvailableSemaphoreValue) =
        mDevice->createSemaphoreUnique(semaphoreInfo).asTuple();

      if (imageAvailableSemaphoreResult != vk::Result::eSuccess)
        throw std::runtime_error("Failed to create semaphores!");

      mImageAvailableSemaphores[idx] = std::move(imageAvailableSemaphoreValue);

      vk::Result          renderFinishedSemaphoreResult = vk::Result::eSuccess;
      vk::UniqueSemaphore renderFinishedSemaphoreValue;

      std::tie(renderFinishedSemaphoreResult, renderFinishedSemaphoreValue) =
        mDevice->createSemaphoreUnique(semaphoreInfo).asTuple();

      if (imageAvailableSemaphoreResult != vk::Result::eSuccess)
        throw std::runtime_error("Failed to create semaphores!");

      mRenderFinishedSemaphores[idx] = std::move(renderFinishedSemaphoreValue);

      vk::Result      fenceResult = vk::Result::eSuccess;
      vk::UniqueFence fenceValue;

      std::tie(fenceResult, fenceValue) = mDevice->createFenceUnique(fenceInfo).asTuple();

      if (fenceResult != vk::Result::eSuccess)
        throw std::runtime_error("Failed to create fences!");

      mInFlightFences[idx] = std::move(fenceValue);
    }
  }

  fn drawFrame() -> void {
    vk::Result result =
      mDevice->waitForFences(mInFlightFences[mCurrentFrame].get(), vk::Bool32(vk::True), UINT64_MAX);

    if (result != vk::Result::eSuccess)
      throw std::runtime_error("Failed to wait for fences!");

    vk::Result imageIndexResult = vk::Result::eSuccess;
    u32        imageIndexValue  = 0;

    std::tie(imageIndexResult, imageIndexValue) = mDevice->acquireNextImageKHR(
      mSwapChain.get(), UINT64_MAX, mImageAvailableSemaphores[mCurrentFrame].get(), nullptr
    );

    if (imageIndexResult == vk::Result::eErrorOutOfDateKHR) {
      recreateSwapChain();
      return;
    }

    if (imageIndexResult != vk::Result::eSuccess && imageIndexResult != vk::Result::eSuboptimalKHR)
      throw std::runtime_error("Failed to acquire swap chain image!");

    mDevice->resetFences(mInFlightFences[mCurrentFrame].get());

    mCommandBuffers[mCurrentFrame]->reset(vk::CommandBufferResetFlagBits::eReleaseResources);
    recordCommandBuffer(mCommandBuffers[mCurrentFrame].get(), imageIndexValue);

    std::array<vk::PipelineStageFlags, 1> waitStages = { vk::PipelineStageFlagBits::eColorAttachmentOutput };

    vk::SubmitInfo submitInfo {
      .waitSemaphoreCount   = 1,
      .pWaitSemaphores      = &mImageAvailableSemaphores[mCurrentFrame].get(),
      .pWaitDstStageMask    = waitStages.data(),
      .commandBufferCount   = 1,
      .pCommandBuffers      = &mCommandBuffers[mCurrentFrame].get(),
      .signalSemaphoreCount = 1,
      .pSignalSemaphores    = &mRenderFinishedSemaphores[mCurrentFrame].get(),
    };

    vk::Result submitResult = mGraphicsQueue.submit(submitInfo, mInFlightFences[mCurrentFrame].get());

    if (submitResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to submit draw command buffer!");

    vk::PresentInfoKHR presentInfo {
      .waitSemaphoreCount = 1,
      .pWaitSemaphores    = &mRenderFinishedSemaphores[mCurrentFrame].get(),
      .swapchainCount     = 1,
      .pSwapchains        = &mSwapChain.get(),
      .pImageIndices      = &imageIndexValue,
    };

    vk::Result presentResult = mPresentQueue.presentKHR(presentInfo);

    if (presentResult == vk::Result::eErrorOutOfDateKHR || presentResult == vk::Result::eSuboptimalKHR ||
        mFramebufferResized) {
      mFramebufferResized = false;
      recreateSwapChain();
    } else if (presentResult != vk::Result::eSuccess) {
      throw std::runtime_error("Failed to present swap chain image!");
    }

    mCurrentFrame = (mCurrentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
  }

  fn createShaderModule(const std::vector<char>& code) -> vk::UniqueShaderModule {
    vk::ShaderModuleCreateInfo createInfo { .codeSize = code.size(),
                                            .pCode    = std::bit_cast<const u32*>(code.data()) };

    vk::Result             shaderModuleResult = vk::Result::eSuccess;
    vk::UniqueShaderModule shaderModuleValue;

    std::tie(shaderModuleResult, shaderModuleValue) = mDevice->createShaderModuleUnique(createInfo).asTuple();

    if (shaderModuleResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to create shader module!");

    return shaderModuleValue;
  }

  static fn chooseSwapSurfaceFormat(const std::vector<vk::SurfaceFormatKHR>& availableFormats
  ) -> vk::SurfaceFormatKHR {
    for (const auto& availableFormat : availableFormats)
      if (availableFormat.format == vk::Format::eB8G8R8A8Srgb &&
          availableFormat.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear)
        return availableFormat;

    return availableFormats[0];
  }

  static fn chooseSwapPresentMode(const std::vector<vk::PresentModeKHR>& availablePresentModes
  ) -> vk::PresentModeKHR {
    for (const auto& availablePresentMode : availablePresentModes)
      if (availablePresentMode == vk::PresentModeKHR::eMailbox)
        return availablePresentMode;

    return vk::PresentModeKHR::eFifo;
  }

  fn chooseSwapExtent(const vk::SurfaceCapabilitiesKHR capabilities) -> vk::Extent2D {
    if (capabilities.currentExtent.width != UINT32_MAX)
      return capabilities.currentExtent;

    u32 width = 0, height = 0;
    std::tie(width, height) = mWindow->getFramebufferSize();

    vk::Extent2D actualExtent = { width, height };

    actualExtent.width =
      std::clamp(actualExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
    actualExtent.height =
      std::clamp(actualExtent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);

    return actualExtent;
  }

  fn querySwapChainSupport(vk::PhysicalDevice device) -> SwapChainSupportDetails {
    SwapChainSupportDetails details;

    vk::Result                 surfaceCapabilitiesResult = vk::Result::eSuccess;
    vk::SurfaceCapabilitiesKHR surfaceCapabilitiesValue;

    std::tie(surfaceCapabilitiesResult, surfaceCapabilitiesValue) =
      device.getSurfaceCapabilitiesKHR(mSurface.get());

    if (surfaceCapabilitiesResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to get surface capabilities!");

    details.capabilities = surfaceCapabilitiesValue;

    vk::Result                        surfaceFormatsResult = vk::Result::eSuccess;
    std::vector<vk::SurfaceFormatKHR> surfaceFormatsValue;

    std::tie(surfaceFormatsResult, surfaceFormatsValue) = device.getSurfaceFormatsKHR(mSurface.get());

    if (surfaceFormatsResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to get surface formats!");

    details.formats = surfaceFormatsValue;

    vk::Result                      presentModesResult = vk::Result::eSuccess;
    std::vector<vk::PresentModeKHR> presentModesValue;

    std::tie(presentModesResult, presentModesValue) = device.getSurfacePresentModesKHR(mSurface.get());

    if (presentModesResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to get surface present modes!");

    details.present_modes = presentModesValue;

    return details;
  }

  fn isDeviceSuitable(vk::PhysicalDevice device) -> bool {
    QueueFamilyIndices indices = findQueueFamilies(device);

    bool extensionsSupported = checkDeviceExtensionSupport(device);

    bool swapChainAdequate = false;

    if (extensionsSupported) {
      SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
      swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.present_modes.empty();
    }

    return indices.isComplete() && extensionsSupported && swapChainAdequate;
  }

  static fn checkDeviceExtensionSupport(vk::PhysicalDevice device) -> bool {
    vk::Result                           availableExtensionsResult = vk::Result::eSuccess;
    std::vector<vk::ExtensionProperties> availableExtensionsValue;

    std::tie(availableExtensionsResult, availableExtensionsValue) =
      device.enumerateDeviceExtensionProperties();

    if (availableExtensionsResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to enumerate device extensions!");

    std::set<string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());

    for (const vk::ExtensionProperties& extension : availableExtensionsValue)
      requiredExtensions.erase(extension.extensionName);

    return requiredExtensions.empty();
  }

  fn findQueueFamilies(vk::PhysicalDevice device) -> QueueFamilyIndices {
    QueueFamilyIndices indices;

    std::vector<vk::QueueFamilyProperties> queueFamilies = device.getQueueFamilyProperties();

    for (u32 i = 0; i < queueFamilies.size(); i++) {
      if (queueFamilies[i].queueFlags & vk::QueueFlagBits::eGraphics)
        indices.graphics_family = i;

      vk::Result queuePresentSupportResult = vk::Result::eSuccess;
      vk::Bool32 queuePresentSupportValue  = 0;

      std::tie(queuePresentSupportResult, queuePresentSupportValue) =
        device.getSurfaceSupportKHR(i, mSurface.get());

      if (queuePresentSupportResult != vk::Result::eSuccess)
        throw std::runtime_error("Failed to get surface support!");

      if (queuePresentSupportValue)
        indices.present_family = i;

      if (indices.isComplete())
        break;
    }

    return indices;
  }

  static fn getRequiredExtensions() -> std::vector<const char*> {
    std::span<const char*> extensionsSpan = vkfw::getRequiredInstanceExtensions();

    std::vector extensions(extensionsSpan.begin(), extensionsSpan.end());

    if (enableValidationLayers)
      extensions.emplace_back(vk::EXTDebugUtilsExtensionName);

    return extensions;
  }

  static fn checkValidationLayerSupport() -> bool {
    vk::Result                       availableLayersResult = vk::Result::eSuccess;
    std::vector<vk::LayerProperties> availableLayersValue;
    std::tie(availableLayersResult, availableLayersValue) = vk::enumerateInstanceLayerProperties();

    if (availableLayersResult != vk::Result::eSuccess)
      throw std::runtime_error("Failed to enumerate validation layers!");

    for (const char* layerName : validationLayers) {
      bool layerFound = false;

      for (const vk::LayerProperties& layerProperties : availableLayersValue)
        if (strcmp(layerName, layerProperties.layerName) == 0) {
          layerFound = true;
          break;
        }

      if (!layerFound)
        return false;
    }

    return true;
  }

  static VKAPI_ATTR fn VKAPI_CALL debugCallback(
    VkDebugUtilsMessageSeverityFlagBitsEXT /*messageSeverity*/,
    VkDebugUtilsMessageTypeFlagsEXT /*messageType*/,
    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
    void* /*pUserData*/
  ) -> vk::Bool32 {
    fmt::println("Validation layer: {}", pCallbackData->pMessage);

    return vk::False;
  }
};

fn main() -> i32 {
  vk::DynamicLoader dynamicLoader;
  auto              vkGetInstanceProcAddr =
    dynamicLoader.getProcAddress<PFN_vkGetInstanceProcAddr>("vkGetInstanceProcAddr");
  VULKAN_HPP_DEFAULT_DISPATCHER.init(vkGetInstanceProcAddr);

  VulkanApp app;

  try {
    app.run();
  } catch (const std::exception& e) {
    fmt::println("{}", e.what());
    return EXIT_FAILURE;
  }

  return EXIT_SUCCESS;
}