path: root/hk21/game/gpu.cpp

#include "hk21/game/gpu.hpp"

#include <asl/buffer.hpp>
#include <asl/log/log.hpp>
#include <asl/format.hpp>

#include <SDL3/SDL_vulkan.h>

#include "hk21/vulkan_loader/api.hpp"

#define VK_ALLOCATOR nullptr

[[maybe_unused]] static void AslFormat(asl::Formatter& formatter, VkResult res)
{
    switch (res) // NOLINT
    {
    case VK_SUCCESS: formatter.write("VK_SUCCESS"); break;
    case VK_NOT_READY: formatter.write("VK_NOT_READY"); break;
    case VK_TIMEOUT: formatter.write("VK_TIMEOUT"); break;
    case VK_EVENT_SET: formatter.write("VK_EVENT_SET"); break;
    case VK_EVENT_RESET: formatter.write("VK_EVENT_RESET"); break;
    case VK_INCOMPLETE: formatter.write("VK_INCOMPLETE"); break;
    case VK_ERROR_OUT_OF_HOST_MEMORY: formatter.write("VK_ERROR_OUT_OF_HOST_MEMORY"); break;
    case VK_ERROR_OUT_OF_DEVICE_MEMORY: formatter.write("VK_ERROR_OUT_OF_DEVICE_MEMORY"); break;
    case VK_ERROR_INITIALIZATION_FAILED: formatter.write("VK_ERROR_INITIALIZATION_FAILED"); break;
    case VK_ERROR_DEVICE_LOST: formatter.write("VK_ERROR_DEVICE_LOST"); break;
    case VK_ERROR_MEMORY_MAP_FAILED: formatter.write("VK_ERROR_MEMORY_MAP_FAILED"); break;
    case VK_ERROR_LAYER_NOT_PRESENT: formatter.write("VK_ERROR_LAYER_NOT_PRESENT"); break;
    case VK_ERROR_EXTENSION_NOT_PRESENT: formatter.write("VK_ERROR_EXTENSION_NOT_PRESENT"); break;
    case VK_ERROR_FEATURE_NOT_PRESENT: formatter.write("VK_ERROR_FEATURE_NOT_PRESENT"); break;
    case VK_ERROR_INCOMPATIBLE_DRIVER: formatter.write("VK_ERROR_INCOMPATIBLE_DRIVER"); break;
    case VK_ERROR_TOO_MANY_OBJECTS: formatter.write("VK_ERROR_TOO_MANY_OBJECTS"); break;
    case VK_ERROR_FORMAT_NOT_SUPPORTED: formatter.write("VK_ERROR_FORMAT_NOT_SUPPORTED"); break;
    case VK_ERROR_FRAGMENTED_POOL: formatter.write("VK_ERROR_FRAGMENTED_POOL"); break;
    case VK_ERROR_UNKNOWN: formatter.write("VK_ERROR_UNKNOWN"); break;
    case VK_ERROR_OUT_OF_POOL_MEMORY: formatter.write("VK_ERROR_OUT_OF_POOL_MEMORY"); break;
    case VK_ERROR_INVALID_EXTERNAL_HANDLE: formatter.write("VK_ERROR_INVALID_EXTERNAL_HANDLE"); break;
    case VK_ERROR_FRAGMENTATION: formatter.write("VK_ERROR_FRAGMENTATION"); break;
    case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: formatter.write("VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"); break;
    case VK_PIPELINE_COMPILE_REQUIRED: formatter.write("VK_PIPELINE_COMPILE_REQUIRED"); break;
    case VK_ERROR_NOT_PERMITTED: formatter.write("VK_ERROR_NOT_PERMITTED"); break;
    case VK_ERROR_SURFACE_LOST_KHR: formatter.write("VK_ERROR_SURFACE_LOST_KHR"); break;
    case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: formatter.write("VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"); break;
    case VK_SUBOPTIMAL_KHR: formatter.write("VK_SUBOPTIMAL_KHR"); break;
    case VK_ERROR_OUT_OF_DATE_KHR: formatter.write("VK_ERROR_OUT_OF_DATE_KHR"); break;
    case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: formatter.write("VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"); break;
    case VK_ERROR_VALIDATION_FAILED_EXT: formatter.write("VK_ERROR_VALIDATION_FAILED_EXT"); break;
    case VK_ERROR_INVALID_SHADER_NV: formatter.write("VK_ERROR_INVALID_SHADER_NV"); break;
    case VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR"); break;
    case VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR"); break;
    case VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR"); break;
    case VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR"); break;
    case VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR"); break;
    case VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: formatter.write("VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR"); break;
    case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: formatter.write("VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"); break;
    case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: formatter.write("VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"); break;
    case VK_THREAD_IDLE_KHR: formatter.write("VK_THREAD_IDLE_KHR"); break;
    case VK_THREAD_DONE_KHR: formatter.write("VK_THREAD_DONE_KHR"); break;
    case VK_OPERATION_DEFERRED_KHR: formatter.write("VK_OPERATION_DEFERRED_KHR"); break;
    case VK_OPERATION_NOT_DEFERRED_KHR: formatter.write("VK_OPERATION_NOT_DEFERRED_KHR"); break;
    case VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR: formatter.write("VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR"); break;
    case VK_ERROR_COMPRESSION_EXHAUSTED_EXT: formatter.write("VK_ERROR_COMPRESSION_EXHAUSTED_EXT"); break;
    case VK_INCOMPATIBLE_SHADER_BINARY_EXT: formatter.write("VK_INCOMPATIBLE_SHADER_BINARY_EXT"); break;
    case VK_PIPELINE_BINARY_MISSING_KHR: formatter.write("VK_PIPELINE_BINARY_MISSING_KHR"); break;
    case VK_ERROR_NOT_ENOUGH_SPACE_KHR: formatter.write("VK_ERROR_NOT_ENOUGH_SPACE_KHR"); break;
    default: formatter.write("Unknown Vulkan error"); break;
    }
}

namespace gpu
{

class GpuImpl : public Gpu
{
    bool m_destroyed{};
    
    VkInstance           m_instance;
    VkSurfaceKHR         m_surface;
    uint32_t             m_queue_family_index;
    VkDevice             m_device;
    VkQueue              m_queue;

public:
    GpuImpl(
        VkInstance instance,
        VkSurfaceKHR surface,
        uint32_t queue_family_index,
        VkDevice device,
        VkQueue queue)
        : m_instance{instance}
        , m_surface{surface}
        , m_queue_family_index{queue_family_index}
        , m_device{device}
        , m_queue{queue}
    {}

    ASL_DELETE_COPY_MOVE(GpuImpl);

    ~GpuImpl() override
    {
        ASL_ASSERT(m_destroyed);
    }
    
    void destroy() override
    {
        ASL_ASSERT(!m_destroyed);
        m_destroyed = true;
        vkDestroyDevice(m_device, VK_ALLOCATOR);
        vkDestroySurfaceKHR(m_instance, m_surface, VK_ALLOCATOR);
        vkDestroyInstance(m_instance, VK_ALLOCATOR);
    }
};

static uint32_t kTargetVersionMajor = 1;
static uint32_t kTargetVersionMinor = 3;
static uint32_t kTargetVersion = VK_MAKE_API_VERSION(0, kTargetVersionMajor, kTargetVersionMinor, 0); // NOLINT

static asl::status_or<VkInstance> create_instance()
{
    asl::buffer<const char*> instance_extensions;
    asl::buffer<const char*> layers;
    {
        uint32_t count = 0;
        const char* const* extensions = SDL_Vulkan_GetInstanceExtensions(&count);
        for (uint32_t i = 0; i < count; ++i)
        {
            instance_extensions.push(extensions[i]); // NOLINT(*-pointer-arithmetic)
        }
    }

    layers.push("VK_LAYER_KHRONOS_validation");
    layers.push("VK_LAYER_LUNARG_monitor");

    instance_extensions.push(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
    
    auto vkGetInstanceProcAddr = asl::bit_cast<PFN_vkGetInstanceProcAddr>(SDL_Vulkan_GetVkGetInstanceProcAddr());
    auto status = vulkan_loader::load_global(vkGetInstanceProcAddr);
    ASL_TRY(status);

    uint32_t version{};
    vkEnumerateInstanceVersion(&version);

    uint32_t vk_major = VK_API_VERSION_MAJOR(version); // NOLINT
    uint32_t vk_minor = VK_API_VERSION_MINOR(version); // NOLINT

    if (vk_major != kTargetVersionMajor || vk_minor < kTargetVersionMinor)
    {
        return asl::runtime_error("Incompatible Vulkan version: {}.{}", vk_major, vk_minor);
    }
    
    VkApplicationInfo app_info{
        .sType                = VK_STRUCTURE_TYPE_APPLICATION_INFO,
        .pNext                = nullptr,
        .pApplicationName     = "HK-21",
        .applicationVersion   = 0,
        .pEngineName          = "Custom",
        .engineVersion        = 0,
        .apiVersion           = kTargetVersion,
    };

    VkInstanceCreateInfo instance_create_info{
        .sType                   = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
        .pNext                   = nullptr,
        .flags                   = 0,
        .pApplicationInfo        = &app_info,
        .enabledLayerCount       = static_cast<uint32_t>(layers.size()),
        .ppEnabledLayerNames     = layers.data(),
        .enabledExtensionCount   = static_cast<uint32_t>(instance_extensions.size()),
        .ppEnabledExtensionNames = instance_extensions.data(),
    };

    VkInstance instance{};
    VkResult res = vkCreateInstance(&instance_create_info, VK_ALLOCATOR, &instance);
    if (res != VK_SUCCESS)
    {
        return asl::runtime_error("Couldn't create Vulkan instance: {}", res);
    }
    
    status = vulkan_loader::load_instance(vkGetInstanceProcAddr, instance);
    ASL_TRY(status);

    ASL_LOG_INFO("Vulkan instance created");

    return instance;
}

static asl::status_or<VkSurfaceKHR> create_surface(SDL_Window* window, VkInstance instance)
{
    VkSurfaceKHR surface{};
    if (!SDL_Vulkan_CreateSurface(window, instance, VK_ALLOCATOR, &surface))
    {
        return asl::runtime_error("Couldn't create Vulkan surface");
    }

    return surface;
}

struct PhysicalDeviceInfo
{
    VkPhysicalDevice physical_device;
    uint32_t queue_family_index;
};

static asl::status_or<PhysicalDeviceInfo> find_physical_device(VkInstance instance)
{
    uint32_t count{};
    asl::buffer<VkPhysicalDevice> physical_devices;
    asl::buffer<VkQueueFamilyProperties> queue_family_prps;
    
    vkEnumeratePhysicalDevices(instance, &count, nullptr);
    physical_devices.resize_zero(count);
    VkResult res = vkEnumeratePhysicalDevices(instance, &count, physical_devices.data());
    if (res != VK_SUCCESS)
    {
        return asl::runtime_error("Couldn't enumerate Vulkan physical devices: {}", res);
    }

    for (auto* physical_device: physical_devices)
    {
        VkPhysicalDeviceProperties prps;
        vkGetPhysicalDeviceProperties(physical_device, &prps);

        asl::string_view name{prps.deviceName, asl::strlen(prps.deviceName)};

        if (prps.apiVersion < kTargetVersion)
        {
            ASL_LOG_INFO("Device {}: invalid supported Vulkan API version", name);
            continue;
        }

        uint32_t queue_family_count{};
        vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, nullptr);
        queue_family_prps.resize_zero(queue_family_count);
        vkGetPhysicalDeviceQueueFamilyProperties(physical_device, &queue_family_count, queue_family_prps.data());

        static constexpr VkQueueFlags kWantedQueueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT;

        for (uint32_t queue_family_index = 0; queue_family_index < queue_family_count; ++queue_family_index)
        {
            if ((queue_family_prps[queue_family_index].queueFlags & kWantedQueueFlags) != kWantedQueueFlags) { continue; }
            if (!SDL_Vulkan_GetPresentationSupport(instance, physical_device, queue_family_index)) { continue; }

            ASL_LOG_INFO("Chosing device \"{}\" with queue family {}", name, queue_family_index);
            return PhysicalDeviceInfo{ physical_device, queue_family_index };
        }

        ASL_LOG_INFO("Device {}: no valid queue found", name);
    }

    return asl::runtime_error("Couldn't find a valid Vulkan physical device");
}

static asl::status_or<VkDevice> create_device(VkPhysicalDevice physical_device, uint32_t queue_family_index)
{
    asl::buffer<const char*> device_extensions;
    device_extensions.push(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
    
    const float queue_priority = 1.0F;
    
    VkDeviceQueueCreateInfo queue_create_info{
        .sType                    = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
        .pNext                    = nullptr,
        .flags                    = 0,
        .queueFamilyIndex         = queue_family_index,
        .queueCount               = 1,
        .pQueuePriorities         = &queue_priority,
    };

    VkDeviceCreateInfo create_info{
        .sType                    = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
        .pNext                    = nullptr,
        .flags                    = 0,
        .queueCreateInfoCount     = 1,
        .pQueueCreateInfos        = &queue_create_info,
        .enabledLayerCount        = 0,
        .ppEnabledLayerNames      = nullptr,
        .enabledExtensionCount    = static_cast<uint32_t>(device_extensions.size()),
        .ppEnabledExtensionNames  = device_extensions.data(),
        .pEnabledFeatures         = nullptr,
    };

    VkDevice device{};
    VkResult res = vkCreateDevice(physical_device, &create_info, VK_ALLOCATOR, &device);
    if (res != VK_SUCCESS)
    {
        return asl::runtime_error("Couldn't create Vulkan device: {}", res);
    }

    ASL_LOG_INFO("Vulkan device created");

    auto status = vulkan_loader::load_device(device);
    ASL_TRY(status);

    return device;
}

asl::status_or<asl::box<Gpu>> init(SDL_Window* window)
{
    auto instance = create_instance();
    ASL_TRY(instance);

    auto surface = create_surface(window, instance.value());
    ASL_TRY(surface);

    auto physical_device_info = find_physical_device(instance.value());
    ASL_TRY(physical_device_info);

    auto device = create_device(
        physical_device_info.value().physical_device,
        physical_device_info.value().queue_family_index);
    ASL_TRY(device);

    VkQueue queue{};
    vkGetDeviceQueue(device.value(), physical_device_info.value().queue_family_index, 0, &queue);

    return asl::make_box<GpuImpl>(
        instance.value(),
        surface.value(),
        physical_device_info.value().queue_family_index,
        device.value(),
        queue);
};

} // namespace gpu