window.cpp

Go to the documentation of this file.

 
#include "window.h"
#include "internal.h"
#include <vulkan/vulkan.h>
#include <GLFW/glfw3.h>
#include <GLFW/glfw3native.h>
 
// Standard Library
#include <stdexcept>
#include <vector>
#include <utility>
#include <optional>
#include <iostream>
#include <unordered_map>
#include <iomanip>
#include <string>
#include <cstring>
#include <algorithm>
#include <functional>
#include <set>
#include <fstream>
 
// Forward declarations so PUBLIC functions can appear first (Nicer to read)
namespace
{
    // Turn validation layers on or off based on if debug build or not
    #ifdef NDEBUG
        const bool enableValidationLayers = false;
    #else
        const bool enableValidationLayers = true;
    #endif
 
    // Constants only needed in this file:
    const std::vector<const char*> deviceExtentions = {
        VK_KHR_SWAPCHAIN_EXTENSION_NAME
    };
    constexpr u16
        DISCRETE_GPU_SCORE_BOOST = 1000,
        MINIMUM_MAX_PUSH_CONSTANTS_SIZE = 64,
        MINIMUM_MAX_SAMPLER_ALLOCATION_COUNT = 4000,
        MINIMUM_MAX_IMAGE_DIMENSION_2D = 4090;
    constexpr u16 MAX_FRAMES_IN_FLIGHT = 3;
 
    // Variables and functions
    u32Vec2 renderResolution { 0, 0 };
    u32Vec2 windowResolution { 0, 0 };
    GLFWwindow* glfwWindow;
    bool isInitialised = false;
    VkInstance instance;
    VkPhysicalDevice physicalDevice; // GPU
    VkDevice device;
    VkQueue graphicsQueue;
    VkDebugUtilsMessengerEXT debugMessenger;
    VkSurfaceKHR surface;
    VkQueue presentQueue;
    VkSwapchainKHR swapChain;
    std::vector<VkImage> swapChainImages;
    VkFormat swapChainImageFormat;
    VkExtent2D swapChainExtent;
    std::vector<VkImageView> swapChainImageViews;
    VkPipelineLayout pipelineLayout;
    VkPipeline graphicsPipeline;
    VkRenderPass renderPass;
    std::vector<VkFramebuffer> swapChainFramebuffers;
    VkCommandPool commandPool;
    std::vector<VkCommandBuffer> commandBuffers;
    
    struct Frame {
        VkSemaphore imageAvailableSemaphore;
        VkSemaphore renderFinishedSemaphore;
        VkFence inFlightFence;
    };
    std::vector<Frame> frames;
    u16 currentFrame = 0;
 
    void CreateInstance();
    void SetupDebugMessenger();
    void PickPhysicalDevice();
    void CreateLogicalDevice();
    void CreateSwapChain();
    void CreateImageViews();
    void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator);
    void CreateSurface();
    void DebugDeviceDetails();
    void ClampSetResolution(u32 *resolution, const u32 maxResolution);
    void Error(const char* msg);
    static std::vector<char> ReadFile(const std::string& filename);
    void CreateGraphicsPipeline();
    void CreateRenderPass();
    void CreateFramebuffers();
    void CreateCommandPool();
    void CreateCommandBuffers();
    void DrawFrame();
    void CreateSyncObjects();
    
    // To run a function at the end of this scope
    class Defer {
        public:
            Defer(std::function<void()> Function) : DeferredFunction(Function) {}
            ~Defer() 
            {
                if (DeferredFunction) DeferredFunction();
            }
        private:
            std::function<void()> DeferredFunction;
    };
    // DEFERED EXIT CALL
    Defer DeferredExitCall([&](){ window::Close(); });
}
 
// Code makes sense to be here as it uses private window variables. though game::Run() makes more sense than window::Run()
namespace internal
{
    void UpdateLoop()
    {
        if (!isInitialised) Error("Winow not initialised - call Window::Init() first");
        if (enableValidationLayers) std::cout << "Main loop has started\n";
        
        // Main loop
        while(!glfwWindowShouldClose(glfwWindow)) 
        {
            glfwPollEvents();
            if (internal::isUpdateFunctionInitialised) internal::UpdateFunction();
            DrawFrame();
        }
 
        vkDeviceWaitIdle(device);
    }
}
// PUBLIC
namespace window
{
    const char* title = "...";
    bool isResizable = false;
    Colour backgroundColour;
 
    void Init()
    {
        if (isInitialised) Error("Winow already initialised - remove secondary call Window::Init()");
 
        // Validate that the window and render size was set
        if (windowResolution.x < 1 || windowResolution.y < 1 ||
            renderResolution.x < 1 || renderResolution.y < 1) Error("window and render resolution has to be set before initialisation - call Window::SetWindowResolution(u32 width, u32 height) and Window::SetRenderResolution(u32 width, u32 height) or directly set Window::windowResolution and Window::renderResolution values first");
 
        // GLFW
        glfwInit();
        glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); // Set API to vulkan
        glfwWindowHint(GLFW_RESIZABLE, isResizable);
 
        // CREATE WINDOW
        glfwWindow = glfwCreateWindow(windowResolution.x, windowResolution.y, title, nullptr, nullptr);
        if (!glfwWindow) Error("GLFW failed to create window");
 
        // VULKAN
        CreateInstance();
        SetupDebugMessenger();
        CreateSurface();
        PickPhysicalDevice();
        CreateLogicalDevice();
        CreateSwapChain();
        CreateImageViews();
        CreateRenderPass();
        CreateGraphicsPipeline();
        CreateFramebuffers();
        CreateCommandPool();
        CreateCommandBuffers();
        CreateSyncObjects();
 
        // GENERAL
        isInitialised = true;
 
        // DEBUG OUTPUT
        if (enableValidationLayers)
        {
            DebugDeviceDetails();
            std::cout << "Window is initialised\n";
        }
    }
    void Close() 
    {
        if (!isInitialised) return; // Don't cause error when calling close multiple times
 
        // Debug
        if (enableValidationLayers) DestroyDebugUtilsMessengerEXT(instance, debugMessenger, nullptr);
 
        // Vulkan cleanup
        for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++)
        {
            if (frames[i].imageAvailableSemaphore) vkDestroySemaphore(device, frames[i].imageAvailableSemaphore, nullptr);
            if (frames[i].renderFinishedSemaphore) vkDestroySemaphore(device, frames[i].renderFinishedSemaphore, nullptr);
            if           (frames[i].inFlightFence) vkDestroyFence(device, frames[i].inFlightFence, nullptr);
        }
        
        if (commandPool) vkDestroyCommandPool(device, commandPool, nullptr);
 
        for (auto frambuffer : swapChainFramebuffers) vkDestroyFramebuffer(device, frambuffer, nullptr);
 
        if (graphicsPipeline) vkDestroyPipeline(device, graphicsPipeline, nullptr);
        if   (pipelineLayout) vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
        if       (renderPass) vkDestroyRenderPass(device, renderPass, nullptr);
 
        for (auto imageView : swapChainImageViews) vkDestroyImageView(device, imageView, nullptr);
        if (swapChain) vkDestroySwapchainKHR(device, swapChain, nullptr);
        if    (device) vkDestroyDevice(device, nullptr);
        if   (surface) vkDestroySurfaceKHR(instance, surface, nullptr);
        if  (instance) vkDestroyInstance(instance, nullptr);
 
        // Other
        if (glfwWindow) glfwDestroyWindow(glfwWindow);
        glfwTerminate();
        isInitialised = false;
        if (enableValidationLayers) std::cout << "Window has been closed\n";
    }
    void SetWindowResolution(u32 width, u32 height)
    {
        ClampSetResolution(&width, INT_MAX);
        ClampSetResolution(&height, INT_MAX);
 
        windowResolution.x = width;
        windowResolution.y = height;
 
        if (isInitialised)
        {
            // TODO: change size of window
        }
    }
    void SetRenderResolution(u32 width, u32 height)
    {
        ClampSetResolution(&width, INT_MAX);
        ClampSetResolution(&height, INT_MAX);
        
        renderResolution.x = width;
        renderResolution.y = height;
    }
    u32Vec2 GetRenderResolution() { return renderResolution; }
    u32Vec2 GetWindowResolution() { return windowResolution; }
}
 
// PRIVATE
// Boiler plate code based of https://vulkan-tutorial.com
namespace 
{
    //      -------------------------------------
    //       Validation Layers
    //      -------------------------------------
    const std::vector<const char*> validationLayers = {
        "VK_LAYER_KHRONOS_validation"
    };
 
    static VKAPI_ATTR VkBool32 VKAPI_CALL DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, void* pUserData)
    {
        std::cerr <<"validation layer: " << pCallbackData->pMessage << "\n";
 
        return VK_FALSE;
    }
    bool CheckValidationLayerSupport() 
    {
        u32 layerCount;
        if (vkEnumerateInstanceLayerProperties(&layerCount, nullptr) != VK_SUCCESS) Error("No validation layer properties, try running not in debug mode");
    
        std::vector<VkLayerProperties> availableLayers(layerCount);
        if (vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data()) != VK_SUCCESS) Error("No validation layer layers, try running not in debug mode");
    
        for (const char* layerName : validationLayers) 
        {
            bool layerFound = false;
    
            for (const auto& layerProperties : availableLayers)
                if (strcmp(layerName, layerProperties.layerName) == 0) 
                {
                    layerFound = true;
                    break;
                }
    
            if (!layerFound) return false;
        }
    
        return true;
    }
    VkResult CreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger) 
    {
        auto func = (PFN_vkCreateDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
        if (func != nullptr) return func(instance, pCreateInfo, pAllocator, pDebugMessenger);
        else return VK_ERROR_EXTENSION_NOT_PRESENT;
    }
    void DestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) 
    {
        auto func = (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
        if (func != nullptr) func(instance, debugMessenger, pAllocator);
    }
    void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT& createInfo) 
    {
        createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
        createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
        createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
        createInfo.pfnUserCallback = DebugCallback;
    }
    void SetupDebugMessenger()
    {
        if (!enableValidationLayers) return;
        
        VkDebugUtilsMessengerCreateInfoEXT createInfo {};
        populateDebugMessengerCreateInfo(createInfo);
        
        if (CreateDebugUtilsMessengerEXT(instance, &createInfo, nullptr, &debugMessenger) != VK_SUCCESS) Error("failed to set up debug messenger!");
    }
    std::vector<const char*> GetRequiredExtensions() 
    {
        u32 glfwExtensionCount = 0;
        const char** glfwExtensions;
        glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
    
        std::vector<const char*> extensions(glfwExtensions, glfwExtensions + glfwExtensionCount);
 
        if (enableValidationLayers) extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
    
        return extensions;
    }
 
    //      -------------------------------------
    //       Create Vulkan Instance
    //      -------------------------------------
    void CreateInstance()
    {
        // Debug error handling
        if (enableValidationLayers && !CheckValidationLayerSupport()) Error("DEBUG: validation layers are not available");
 
        // Metadata for Vulkan
        VkApplicationInfo appInfo {};
        appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
        appInfo.pApplicationName = window::title;
        appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0); // TODO: allow game developer to set version of their game here
        appInfo.pEngineName = ENGINE_NAME;
        appInfo.engineVersion = VK_MAKE_VERSION(UPDATE_MAJOR, UPDATE_MINOR, UPDATE_PATCH);
        appInfo.apiVersion = VK_API_VERSION_1_0;
 
        // GLFW extention
        VkInstanceCreateInfo createInfo {};
        createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
        createInfo.pApplicationInfo = &appInfo;
 
        auto glfwExtensions = GetRequiredExtensions();
 
        createInfo.enabledExtensionCount = static_cast<u32>(glfwExtensions.size());
        createInfo.ppEnabledExtensionNames = glfwExtensions.data();
        // If debug mode is on, turn on validation layers
        if (enableValidationLayers) 
        {
            createInfo.enabledLayerCount = static_cast<u32>(validationLayers.size());
            createInfo.ppEnabledLayerNames = validationLayers.data();
        } 
        else createInfo.enabledLayerCount = 0;
 
 
        // Create Vulkan instance itself
        if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) Error("failed to create Vulkan instance :(");
        
        // Validation Layers
        VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo{};
        if (enableValidationLayers) 
        {
            createInfo.enabledLayerCount = static_cast<u32>(validationLayers.size());
            createInfo.ppEnabledLayerNames = validationLayers.data();
    
            populateDebugMessengerCreateInfo(debugCreateInfo);
            createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT*) &debugCreateInfo;
        } 
        else 
        {
            createInfo.enabledLayerCount = 0;
            createInfo.pNext = nullptr;
        }
    }
    
    //      -------------------------------------
    //       Swap Chain
    //      -------------------------------------    
    struct SwapChainSupportDetails {
        VkSurfaceCapabilitiesKHR capabilities;
        std::vector<VkSurfaceFormatKHR> formats;
        std::vector<VkPresentModeKHR> presentModes;
    };
    SwapChainSupportDetails QuerySwapChainSupport(VkPhysicalDevice device) 
    {
        SwapChainSupportDetails details;
        vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);
        u32 formatCount;
        vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);
 
        if (formatCount != 0) {
            details.formats.resize(formatCount);
            vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
        }
        u32 presentModeCount;
        vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);
 
        if (presentModeCount != 0) {
            details.presentModes.resize(presentModeCount);
            vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
        }
        
        return details;
    }
    VkSurfaceFormatKHR ChooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats) {
        for (const auto& availableFormat : availableFormats) 
        {
            if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR)
            {
                return availableFormat;
            }
        }
    
        return availableFormats[0];
    }
    VkPresentModeKHR ChooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes) 
    {
        for (const auto& availablePresentMode : availablePresentModes) {
            if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR) return availablePresentMode;
        }
    
        return VK_PRESENT_MODE_FIFO_KHR;
    }
    VkExtent2D ChooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities) 
    {
        if (capabilities.currentExtent.width != std::numeric_limits<u32>::max()) return capabilities.currentExtent;
        else 
        {
            int width, height;
            glfwGetFramebufferSize(glfwWindow, &width, &height);
    
            VkExtent2D actualExtent = {
                static_cast<u32>(width),
                static_cast<u32>(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;
        }
    }
    struct QueueFamilyIndices 
    {
        std::optional<u32> graphicsFamily;
        std::optional<u32> presentFamily;
        
        bool isComplete() 
        {
            return graphicsFamily.has_value() && presentFamily.has_value();
        }
    };
    QueueFamilyIndices FindQueueFamilies(VkPhysicalDevice device)
    {
        QueueFamilyIndices indices {};
        
        u32 queueFamilyCount = 0;
        vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);
        std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
        vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());
        
        u32 i = 0;
        for (const auto& queueFamily : queueFamilies)
        {
            // Graphics family
            if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) indices.graphicsFamily = i;
 
            // present family
            VkBool32 presentSupport = false;
            vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &presentSupport);
            if (presentSupport) indices.presentFamily = i;
 
            if (indices.isComplete()) break;;
        }
 
        return indices;
    }
    void CreateSwapChain() 
    {
        SwapChainSupportDetails swapChainSupport = QuerySwapChainSupport(physicalDevice);
 
        VkSurfaceFormatKHR surfaceFormat = ChooseSwapSurfaceFormat(swapChainSupport.formats);
        VkPresentModeKHR presentMode = ChooseSwapPresentMode(swapChainSupport.presentModes);
        VkExtent2D extent = ChooseSwapExtent(swapChainSupport.capabilities);
 
        u32 imageCount = swapChainSupport.capabilities.minImageCount + 1;
        if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount)
            imageCount = swapChainSupport.capabilities.maxImageCount;
 
        VkSwapchainCreateInfoKHR createInfo{};
        createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
        createInfo.surface = surface;
        createInfo.minImageCount = imageCount;
        createInfo.imageFormat = surfaceFormat.format;
        createInfo.imageColorSpace = surfaceFormat.colorSpace;
        createInfo.imageExtent = extent;
        createInfo.imageArrayLayers = 1;
        createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
 
        QueueFamilyIndices indices = FindQueueFamilies(physicalDevice);
        u32 queueFamilyIndices[] = {indices.graphicsFamily.value(), indices.presentFamily.value()};
 
        if (indices.graphicsFamily != indices.presentFamily) 
        {
            createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
            createInfo.queueFamilyIndexCount = 2;
            createInfo.pQueueFamilyIndices = queueFamilyIndices;
        } 
        else 
        {
            createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
            createInfo.queueFamilyIndexCount = 0;
            createInfo.pQueueFamilyIndices = nullptr;
        }
        createInfo.preTransform = swapChainSupport.capabilities.currentTransform;
        createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
 
        createInfo.presentMode = presentMode;
        createInfo.clipped = VK_TRUE;
        createInfo.oldSwapchain = VK_NULL_HANDLE;
 
        if (vkCreateSwapchainKHR(device, &createInfo, nullptr, &swapChain) != VK_SUCCESS) Error("Failed to create swap chain");
 
        vkGetSwapchainImagesKHR(device, swapChain, &imageCount, nullptr);
        swapChainImages.resize(imageCount);
        vkGetSwapchainImagesKHR(device, swapChain, &imageCount, swapChainImages.data());
 
        swapChainImageFormat = surfaceFormat.format;
        swapChainExtent = extent;
    }
    
    //      -------------------------------------
    //       Image Views
    //      -------------------------------------
    void CreateImageViews()
    {
        swapChainImageViews.resize(swapChainImages.size());
        for (size_t i = 0; i < swapChainImages.size(); i++)
        {
            VkImageViewCreateInfo createInfo {};
            createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
            createInfo.image = swapChainImages[i];
            createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
            createInfo.format = swapChainImageFormat;
            createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
            createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
            createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
            createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
            createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            createInfo.subresourceRange.baseMipLevel = 0;
            createInfo.subresourceRange.levelCount = 1;
            createInfo.subresourceRange.baseArrayLayer = 0;
            createInfo.subresourceRange.layerCount = 1;
 
            if (vkCreateImageView(device, &createInfo, nullptr, &swapChainImageViews[i]) != VK_SUCCESS) Error("Failed to create image views");
        }
    }
 
    //      -------------------------------------
    //       Select GPU
    //      -------------------------------------
    bool CheckDeviceExtensionSupport(VkPhysicalDevice device)
    {
        u32 extensionCount;
        vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);
 
        std::vector<VkExtensionProperties> availableExtensions(extensionCount);
        vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data());
 
        std::set<std::string> requiredExtentions(deviceExtentions.begin(), deviceExtentions.end());
 
        for (const auto& extension : availableExtensions) requiredExtentions.erase(extension.extensionName);
        return requiredExtentions.empty();
    }
    std::pair<u32, VkPhysicalDevice> RateDeviceSuitability(VkPhysicalDevice device)
    {        
        VkPhysicalDeviceProperties properties;
        vkGetPhysicalDeviceProperties(device, &properties);
        VkPhysicalDeviceFeatures features;
        vkGetPhysicalDeviceFeatures(device, &features);
 
        u32 score = 1; // if score is equal to zero then device doesn't meet minimum requirements
        const std::pair BELOW_MINIMUM_SPEC = std::make_pair((u32)0, device);
            
        // Dedicated GPUs 90% of the time are faster
        if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) score += DISCRETE_GPU_SCORE_BOOST;
 
        // Maximum size of textures is a good measure of GPU performance
        score += properties.limits.maxImageDimension2D;
 
        // Debug output device scores
        if (enableValidationLayers) 
        {
            VkPhysicalDeviceProperties deviceProperties;
            vkGetPhysicalDeviceProperties(device, &deviceProperties);
            std::cout << "Device and its score: " << deviceProperties.deviceName << " : " << score << '\n';
        }
 
        // Check swap chain
        if (!CheckDeviceExtensionSupport(device)) return BELOW_MINIMUM_SPEC;
        SwapChainSupportDetails swapChainSupport = QuerySwapChainSupport(device);
        if (swapChainSupport.formats.empty() || swapChainSupport.presentModes.empty()) return BELOW_MINIMUM_SPEC;
 
        // Minimum specifications
        if 
        (
            !features.geometryShader ||
 
            properties.limits.maxPushConstantsSize < MINIMUM_MAX_PUSH_CONSTANTS_SIZE ||
            properties.limits.maxSamplerAllocationCount < MINIMUM_MAX_SAMPLER_ALLOCATION_COUNT ||
            properties.limits.maxImageDimension2D < MINIMUM_MAX_IMAGE_DIMENSION_2D
        )   return BELOW_MINIMUM_SPEC;
 
        if (!FindQueueFamilies(device).graphicsFamily.has_value()) return BELOW_MINIMUM_SPEC;
 
        return std::make_pair(score, device);
    }
    void PickPhysicalDevice()
    {
        u32 deviceCount = 0;
        vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);
 
        if (deviceCount == 0) Error("Couldn't find any GPU with Vulkan support :(");
 
        std::vector<VkPhysicalDevice> devices(deviceCount);
        vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());
 
        std::vector<std::pair<u32, VkPhysicalDevice>> candidates;
 
        // Checks for GPUs that supports Vulkan
        for (const auto& device : devices) candidates.push_back(RateDeviceSuitability(device));
 
        auto selectedDevice = std::max_element(
            candidates.begin(), 
            candidates.end(), 
            [](const auto& a, const auto& b)
            {
                return a.first < b.first;
            }
        );
        if ((*selectedDevice).first == 0) Error("Couldn't find suitable GPU :(");
 
        physicalDevice = (*selectedDevice).second;
    }
    
    //      -------------------------------------
    //       Create Device
    //      -------------------------------------
    void CreateLogicalDevice()
    {
        QueueFamilyIndices indices = FindQueueFamilies(physicalDevice);
 
        std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
        std::set<u32> uniqueQueueFamilies = { indices.graphicsFamily.value(), indices.presentFamily.value() };
 
        float queuePriority = 1.0f;
        for (u32 queueFamily : uniqueQueueFamilies) {
            VkDeviceQueueCreateInfo queueCreateInfo{};
            queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
            queueCreateInfo.queueFamilyIndex = queueFamily;
            queueCreateInfo.queueCount = 1;
            queueCreateInfo.pQueuePriorities = &queuePriority;
            queueCreateInfos.push_back(queueCreateInfo);
        }
        
        VkDeviceQueueCreateInfo queueCreateInfo{};
        queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
        queueCreateInfo.queueFamilyIndex = indices.graphicsFamily.value();
        queueCreateInfo.queueCount = 1;
        
        queueCreateInfo.pQueuePriorities = &queuePriority;
        
        VkPhysicalDeviceFeatures deviceFeatures{};
        
        VkDeviceCreateInfo createInfo{};
        createInfo.queueCreateInfoCount = static_cast<u32>(queueCreateInfos.size());
        createInfo.pQueueCreateInfos = queueCreateInfos.data();
 
        createInfo.pEnabledFeatures = &deviceFeatures;
 
        createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
        createInfo.pQueueCreateInfos = &queueCreateInfo;
        createInfo.queueCreateInfoCount = 1;
        
        createInfo.enabledExtensionCount = static_cast<u32>(deviceExtentions.size());
        createInfo.ppEnabledExtensionNames = deviceExtentions.data();
 
        if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &device) != VK_SUCCESS) Error("failed to create logical device");
        vkGetDeviceQueue(device, indices.graphicsFamily.value(), 0, &graphicsQueue);
        vkGetDeviceQueue(device, indices.presentFamily.value(), 0, &presentQueue);
    }
    
    //      -------------------------------------
    //       Surface
    //      -------------------------------------
    void CreateSurface()
    {
        // Using glfw should mean its not OS dependent
        if (glfwCreateWindowSurface(instance, glfwWindow, NULL, &surface) != VK_SUCCESS)
        {
            Error("Failed to create window surface");
        }
    }
 
    //      -------------------------------------
    //       Graphics pipeline and render pass
    //      -------------------------------------
    VkShaderModule CreateShaderModule(const std::vector<char>& code)
    {
        VkShaderModuleCreateInfo createInfo {};
        createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
        createInfo.codeSize = code.size();
        createInfo.pCode = reinterpret_cast<const u32*>(code.data());
        
        VkShaderModule shaderModule;
        if (vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule) != VK_SUCCESS) Error("failed to create shader module");
        return shaderModule;
    }
    void CreateGraphicsPipeline()
    {
        auto vertShaderCode = ReadFile("shaders/vert.spv");
        auto fragShaderCode = ReadFile("shaders/frag.spv");
 
        VkShaderModule vertShaderModule = CreateShaderModule(vertShaderCode);
        VkShaderModule fragShaderModule = CreateShaderModule(fragShaderCode);
 
        VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
        vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
        vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
        vertShaderStageInfo.module = vertShaderModule;
        vertShaderStageInfo.pName = "main";
 
        VkPipelineShaderStageCreateInfo fragShaderStageInfo{};
        fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
        fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
        fragShaderStageInfo.module = fragShaderModule;
        fragShaderStageInfo.pName = "main";
 
        VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};
 
        VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
        vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
        vertexInputInfo.vertexBindingDescriptionCount = 0;
        vertexInputInfo.vertexAttributeDescriptionCount = 0;
 
        VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
        inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
        inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
        inputAssembly.primitiveRestartEnable = VK_FALSE;
 
        VkPipelineViewportStateCreateInfo viewportState{};
        viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
        viewportState.viewportCount = 1;
        viewportState.scissorCount = 1;
 
        VkPipelineRasterizationStateCreateInfo rasterizer{};
        rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
        rasterizer.depthClampEnable = VK_FALSE;
        rasterizer.rasterizerDiscardEnable = VK_FALSE;
        rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
        rasterizer.lineWidth = 1.0f;
        rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
        rasterizer.frontFace = VK_FRONT_FACE_CLOCKWISE;
        rasterizer.depthBiasEnable = VK_FALSE;
 
        VkPipelineMultisampleStateCreateInfo multisampling{};
        multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
        multisampling.sampleShadingEnable = VK_FALSE;
        multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
 
        VkPipelineColorBlendAttachmentState colorBlendAttachment{};
        colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
        colorBlendAttachment.blendEnable = VK_FALSE;
 
        VkPipelineColorBlendStateCreateInfo colorBlending{};
        colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
        colorBlending.logicOpEnable = VK_FALSE;
        colorBlending.logicOp = VK_LOGIC_OP_COPY;
        colorBlending.attachmentCount = 1;
        colorBlending.pAttachments = &colorBlendAttachment;
        colorBlending.blendConstants[0] = 0.0f;
        colorBlending.blendConstants[1] = 0.0f;
        colorBlending.blendConstants[2] = 0.0f;
        colorBlending.blendConstants[3] = 0.0f;
 
        std::vector<VkDynamicState> dynamicStates = {
            VK_DYNAMIC_STATE_VIEWPORT,
            VK_DYNAMIC_STATE_SCISSOR
        };
        VkPipelineDynamicStateCreateInfo dynamicState{};
        dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
        dynamicState.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size());
        dynamicState.pDynamicStates = dynamicStates.data();
 
        VkPipelineLayoutCreateInfo pipelineLayoutInfo {};
        pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
        pipelineLayoutInfo.setLayoutCount = 0;
        pipelineLayoutInfo.pushConstantRangeCount = 0;
 
        if (vkCreatePipelineLayout(device, &pipelineLayoutInfo, nullptr, &pipelineLayout) != VK_SUCCESS) Error("failed to create pipeline layout");
 
        VkGraphicsPipelineCreateInfo pipelineInfo{};
        pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
        pipelineInfo.stageCount = 2;
        pipelineInfo.pStages = shaderStages;
        pipelineInfo.pVertexInputState = &vertexInputInfo;
        pipelineInfo.pInputAssemblyState = &inputAssembly;
        pipelineInfo.pViewportState = &viewportState;
        pipelineInfo.pRasterizationState = &rasterizer;
        pipelineInfo.pMultisampleState = &multisampling;
        pipelineInfo.pColorBlendState = &colorBlending;
        pipelineInfo.pDynamicState = &dynamicState;
        pipelineInfo.layout = pipelineLayout;
        pipelineInfo.renderPass = renderPass;
        pipelineInfo.subpass = 0;
        pipelineInfo.basePipelineHandle = VK_NULL_HANDLE;
 
        if (vkCreateGraphicsPipelines(device, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline) != VK_SUCCESS) Error("failed to create graphics pipeline");
 
        vkDestroyShaderModule(device, fragShaderModule, nullptr);
        vkDestroyShaderModule(device, vertShaderModule, nullptr);
    }
    void CreateRenderPass()
    {
        VkAttachmentDescription colorAttachment{};
        colorAttachment.format = swapChainImageFormat;
        colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
        colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
        colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
        colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
        colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
        colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
 
        VkAttachmentReference colorAttachmentRef{};
        colorAttachmentRef.attachment = 0;
        colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
 
        VkSubpassDescription subpass{};
        subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
        subpass.colorAttachmentCount = 1;
        subpass.pColorAttachments = &colorAttachmentRef;
 
        VkSubpassDependency dependency{};
        dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
        dependency.dstSubpass = 0;
        dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
        dependency.srcAccessMask = 0;
        dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
        dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
 
        VkRenderPassCreateInfo renderPassInfo{};
        renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
        renderPassInfo.attachmentCount = 1;
        renderPassInfo.pAttachments = &colorAttachment;
        renderPassInfo.subpassCount = 1;
        renderPassInfo.pSubpasses = &subpass;
        renderPassInfo.dependencyCount = 1;
        renderPassInfo.pDependencies = &dependency;
 
        if (vkCreateRenderPass(device, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) Error("failed to create render pass");
    }
 
    //      -------------------------------------
    //       Frame and command buffers
    //      -------------------------------------
    void CreateFramebuffers() 
    {
        swapChainFramebuffers.resize(swapChainImageViews.size());
 
        for (size_t i = 0; i < swapChainImageViews.size(); i++) {
            VkImageView attachments[] = {
                swapChainImageViews[i]
            };
 
            VkFramebufferCreateInfo framebufferInfo{};
            framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
            framebufferInfo.renderPass = renderPass;
            framebufferInfo.attachmentCount = 1;
            framebufferInfo.pAttachments = attachments;
            framebufferInfo.width = swapChainExtent.width;
            framebufferInfo.height = swapChainExtent.height;
            framebufferInfo.layers = 1;
 
            if (vkCreateFramebuffer(device, &framebufferInfo, nullptr, &swapChainFramebuffers[i]) != VK_SUCCESS) Error("failed to create framebuffer");
        }
    }
    void CreateCommandPool() 
    {
        QueueFamilyIndices queueFamilyIndices = FindQueueFamilies(physicalDevice);
 
        VkCommandPoolCreateInfo poolInfo{};
        poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
        poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
        poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
 
        if (vkCreateCommandPool(device, &poolInfo, nullptr, &commandPool) != VK_SUCCESS) Error("Failed to create command pool");
    }
    void CreateCommandBuffers()
    {
        commandBuffers.resize(MAX_FRAMES_IN_FLIGHT);
 
        VkCommandBufferAllocateInfo allocInfo {};
        allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
        allocInfo.commandPool = commandPool;
        allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
        allocInfo.commandBufferCount = (u32)commandBuffers.size();
        
        if (vkAllocateCommandBuffers(device, &allocInfo, commandBuffers.data()) != VK_SUCCESS) Error("failed to allocate command buffers");
    }
    VkClearColorValue ConvertBackgroundColour()
    {
        return {{
            (static_cast<float>(window::backgroundColour.r) / 255),
            (static_cast<float>(window::backgroundColour.g) / 255),
            (static_cast<float>(window::backgroundColour.b) / 255),
            (static_cast<float>(window::backgroundColour.a) / 255)
        }};
    }
    void RecordCommandBuffer(VkCommandBuffer commandBuffer, u32 imageIndex) 
    {
        VkCommandBufferBeginInfo beginInfo{};
        beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
        beginInfo.flags = 0; // Optional
        beginInfo.pInheritanceInfo = nullptr; // Optional
 
        if (vkBeginCommandBuffer(commandBuffer, &beginInfo) != VK_SUCCESS) Error("failed to begin recording command buffer");
 
        VkRenderPassBeginInfo renderPassInfo{};
        renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
        renderPassInfo.renderPass = renderPass;
        renderPassInfo.framebuffer = swapChainFramebuffers[imageIndex];
        renderPassInfo.renderArea.offset = {0, 0};
        renderPassInfo.renderArea.extent = swapChainExtent;
        VkClearValue clearColor = { ConvertBackgroundColour() };
        renderPassInfo.clearValueCount = 1;
        renderPassInfo.pClearValues = &clearColor;
        vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);
 
        vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);
        VkViewport viewport{};
        viewport.x = 0.0f;
        viewport.y = 0.0f;
        viewport.width = static_cast<float>(swapChainExtent.width);
        viewport.height = static_cast<float>(swapChainExtent.height);
        viewport.minDepth = 0.0f;
        viewport.maxDepth = 1.0f;
        vkCmdSetViewport(commandBuffer, 0, 1, &viewport);
 
        VkRect2D scissor{};
        scissor.offset = {0, 0};
        scissor.extent = swapChainExtent;
        vkCmdSetScissor(commandBuffer, 0, 1, &scissor);
 
        // draw triangle
        vkCmdDraw(commandBuffer, 3, 1, 0, 0);
 
        vkCmdEndRenderPass(commandBuffer);
        if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) Error("failed to record command buffer");
    }
 
    //      -------------------------------------
    //       Draw frame
    //      -------------------------------------
    void CreateSyncObjects()
    {
        frames.resize(MAX_FRAMES_IN_FLIGHT);
 
        VkSemaphoreCreateInfo semaphoreInfo {};
        semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
 
        VkFenceCreateInfo fenceInfo {};
        fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
        fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
 
        for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) 
            if (vkCreateSemaphore(device, &semaphoreInfo, nullptr, &frames[i].imageAvailableSemaphore) != VK_SUCCESS 
            || vkCreateSemaphore(device, &semaphoreInfo, nullptr, &frames[i].renderFinishedSemaphore) != VK_SUCCESS 
            || vkCreateFence(device, &fenceInfo, nullptr, &frames[i].inFlightFence) != VK_SUCCESS) Error("failed to create semaphores");
    }
    void DrawFrame()
    {
        vkWaitForFences(device, 1, &frames[currentFrame].inFlightFence, VK_TRUE, UINT64_MAX);
        vkResetFences(device, 1, &frames[currentFrame].inFlightFence);
 
        uint32_t imageIndex;
        vkAcquireNextImageKHR(device, swapChain, UINT64_MAX, frames[currentFrame].imageAvailableSemaphore, VK_NULL_HANDLE, &imageIndex);
 
        vkResetCommandBuffer(commandBuffers[currentFrame], 0);
        RecordCommandBuffer(commandBuffers[currentFrame], imageIndex);
 
        VkSubmitInfo submitInfo {};
        submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
 
        VkSemaphore waitSemaphores[] = { frames[currentFrame].imageAvailableSemaphore };
        VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT };
        submitInfo.waitSemaphoreCount = 1;
        submitInfo.pWaitSemaphores = waitSemaphores;
        submitInfo.pWaitDstStageMask = waitStages;
        submitInfo.commandBufferCount = 1;
        submitInfo.pCommandBuffers = &commandBuffers[currentFrame];
 
        VkSemaphore signalSemaphores[] = { frames[currentFrame].renderFinishedSemaphore };
        submitInfo.signalSemaphoreCount = 1;
        submitInfo.pSignalSemaphores = signalSemaphores;
 
        if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, frames[currentFrame].inFlightFence) != VK_SUCCESS) Error("failed to submit draw command buffer");
 
        VkSubpassDependency dependency{};
        dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
        dependency.dstSubpass = 0;
        dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
        dependency.srcAccessMask = 0;
        dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
        dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
        
        VkPresentInfoKHR presentInfo{};
        presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
 
        presentInfo.waitSemaphoreCount = 1;
        presentInfo.pWaitSemaphores = signalSemaphores;
 
        VkSwapchainKHR swapChains[] = { swapChain };
        presentInfo.swapchainCount = 1;
        presentInfo.pSwapchains = swapChains;
        presentInfo.pImageIndices = &imageIndex;
        presentInfo.pResults = nullptr;
 
        vkQueuePresentKHR(presentQueue, &presentInfo);
        currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
    }
    
    //      -------------------------------------
    //       Debug and Miscellaneous
    //      -------------------------------------
    void DebugDeviceDetails()
    {
        VkPhysicalDeviceProperties deviceProperties;
        vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
 
        static const std::unordered_map<u32, const char*> gpuVendors = {
            { 4098, "AMD" },
            { 4318, "NVIDIA" },
            { 32902, "INTEL" },
            { 5045, "ARM "}
        };
 
        static const u8 LABEL_WIDTH = 15,
                        VALUE_WIDTH = 35;
        auto PrintDetail = [](const char* label, const auto& value) 
        {
            std::cout << std::setw(LABEL_WIDTH) << std::left << label << ": " 
                      << std::setw(VALUE_WIDTH) << std::left << value << "\n";
        };
 
        PrintDetail("GPU selected", deviceProperties.deviceName);
        PrintDetail("API version", std::to_string(deviceProperties.apiVersion) + " (" +
            std::to_string(VK_VERSION_MAJOR(deviceProperties.apiVersion)) + "." +
            std::to_string(VK_VERSION_MINOR(deviceProperties.apiVersion)) + "." +
            std::to_string(VK_VERSION_PATCH(deviceProperties.apiVersion)) + ")");
 
        PrintDetail("Driver version", deviceProperties.driverVersion);
        PrintDetail("Device ID", deviceProperties.deviceID);
 
        u32 vendorID = deviceProperties.vendorID;
        std::string vendorName = gpuVendors.count(vendorID) ? gpuVendors.at(vendorID) : "Unknown";
        PrintDetail("Vendor ID", std::to_string(vendorID) + " (" + vendorName + ")");
    }
    void ClampSetResolution(u32 *resolution, const u32 maxResolution)
    {
        // Floors the value
        *resolution = *resolution < maxResolution ? *resolution : maxResolution;
    }
    void Error(const char* msg)
    {
        if (enableValidationLayers) std::cerr << "Error: " << msg << '\n';
        window::Close();
        throw std::runtime_error(msg);
    }
    static std::vector<char> ReadFile(const std::string& filename)
    {
        // TODO: probably don't use this
        std::ifstream file(filename, std::ios::ate | std::ios::binary);
    
        if (!file.is_open()) Error("failed to open file!");
 
        size_t fileSize = (size_t) file.tellg();
        std::vector<char> buffer(fileSize);
        
        file.seekg(0);
        file.read(buffer.data(), fileSize);
 
        file.close();
 
        return buffer;
    }
}