eden/src/yuzu_cmd/emu_window/emu_window_sdl2_vk.cpp

// Copyright 2018 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.

#include <algorithm>
#include <string>
#include <vector>
#include <SDL.h>
#include <SDL_vulkan.h>
#include <fmt/format.h>
#include <vulkan/vulkan.h>
#include "common/assert.h"
#include "common/logging/log.h"
#include "common/scm_rev.h"
#include "core/settings.h"
#include "yuzu_cmd/emu_window/emu_window_sdl2_vk.h"

EmuWindow_SDL2_VK::EmuWindow_SDL2_VK(bool fullscreen) : EmuWindow_SDL2(fullscreen) {
    if (SDL_Vulkan_LoadLibrary(nullptr) != 0) {
        LOG_CRITICAL(Frontend, "SDL failed to load the Vulkan library: {}", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    vkGetInstanceProcAddr =
        reinterpret_cast<PFN_vkGetInstanceProcAddr>(SDL_Vulkan_GetVkGetInstanceProcAddr());
    if (vkGetInstanceProcAddr == nullptr) {
        LOG_CRITICAL(Frontend, "Failed to retrieve Vulkan function pointer!");
        exit(EXIT_FAILURE);
    }

    const std::string window_title = fmt::format("yuzu {} | {}-{} (Vulkan)", Common::g_build_name,
                                                 Common::g_scm_branch, Common::g_scm_desc);
    render_window =
        SDL_CreateWindow(window_title.c_str(),
                         SDL_WINDOWPOS_UNDEFINED, // x position
                         SDL_WINDOWPOS_UNDEFINED, // y position
                         Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height,
                         SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_VULKAN);

    const bool use_standard_layers = UseStandardLayers(vkGetInstanceProcAddr);

    u32 extra_ext_count{};
    if (!SDL_Vulkan_GetInstanceExtensions(render_window, &extra_ext_count, NULL)) {
        LOG_CRITICAL(Frontend, "Failed to query Vulkan extensions count from SDL! {}",
                     SDL_GetError());
        exit(1);
    }

    auto extra_ext_names = std::make_unique<const char* []>(extra_ext_count);
    if (!SDL_Vulkan_GetInstanceExtensions(render_window, &extra_ext_count, extra_ext_names.get())) {
        LOG_CRITICAL(Frontend, "Failed to query Vulkan extensions from SDL! {}", SDL_GetError());
        exit(1);
    }
    std::vector<const char*> enabled_extensions;
    enabled_extensions.insert(enabled_extensions.begin(), extra_ext_names.get(),
                              extra_ext_names.get() + extra_ext_count);

    std::vector<const char*> enabled_layers;
    if (use_standard_layers) {
        enabled_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
        enabled_layers.push_back("VK_LAYER_LUNARG_standard_validation");
    }

    VkApplicationInfo app_info{};
    app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
    app_info.apiVersion = VK_API_VERSION_1_1;
    app_info.applicationVersion = VK_MAKE_VERSION(0, 1, 0);
    app_info.pApplicationName = "yuzu-emu";
    app_info.engineVersion = VK_MAKE_VERSION(0, 1, 0);
    app_info.pEngineName = "yuzu-emu";

    VkInstanceCreateInfo instance_ci{};
    instance_ci.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
    instance_ci.pApplicationInfo = &app_info;
    instance_ci.enabledExtensionCount = static_cast<u32>(enabled_extensions.size());
    instance_ci.ppEnabledExtensionNames = enabled_extensions.data();
    if (Settings::values.renderer_debug) {
        instance_ci.enabledLayerCount = static_cast<u32>(enabled_layers.size());
        instance_ci.ppEnabledLayerNames = enabled_layers.data();
    }

    const auto vkCreateInstance =
        reinterpret_cast<PFN_vkCreateInstance>(vkGetInstanceProcAddr(nullptr, "vkCreateInstance"));
    if (vkCreateInstance == nullptr ||
        vkCreateInstance(&instance_ci, nullptr, &vk_instance) != VK_SUCCESS) {
        LOG_CRITICAL(Frontend, "Failed to create Vulkan instance!");
        exit(EXIT_FAILURE);
    }

    vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(
        vkGetInstanceProcAddr(vk_instance, "vkDestroyInstance"));
    if (vkDestroyInstance == nullptr) {
        LOG_CRITICAL(Frontend, "Failed to retrieve Vulkan function pointer!");
        exit(EXIT_FAILURE);
    }

    if (!SDL_Vulkan_CreateSurface(render_window, vk_instance, &vk_surface)) {
        LOG_CRITICAL(Frontend, "Failed to create Vulkan surface! {}", SDL_GetError());
        exit(EXIT_FAILURE);
    }

    OnResize();
    OnMinimalClientAreaChangeRequest(GetActiveConfig().min_client_area_size);
    SDL_PumpEvents();
    LOG_INFO(Frontend, "yuzu Version: {} | {}-{} (Vulkan)", Common::g_build_name,
             Common::g_scm_branch, Common::g_scm_desc);
}

EmuWindow_SDL2_VK::~EmuWindow_SDL2_VK() {
    vkDestroyInstance(vk_instance, nullptr);
}

void EmuWindow_SDL2_VK::SwapBuffers() {}

void EmuWindow_SDL2_VK::MakeCurrent() {
    // Unused on Vulkan
}

void EmuWindow_SDL2_VK::DoneCurrent() {
    // Unused on Vulkan
}

void EmuWindow_SDL2_VK::RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
                                               void* surface) const {
    const auto instance_proc_addr = vkGetInstanceProcAddr;
    std::memcpy(get_instance_proc_addr, &instance_proc_addr, sizeof(instance_proc_addr));
    std::memcpy(instance, &vk_instance, sizeof(vk_instance));
    std::memcpy(surface, &vk_surface, sizeof(vk_surface));
}

std::unique_ptr<Core::Frontend::GraphicsContext> EmuWindow_SDL2_VK::CreateSharedContext() const {
    return nullptr;
}

bool EmuWindow_SDL2_VK::UseStandardLayers(PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr) const {
    if (!Settings::values.renderer_debug) {
        return false;
    }

    const auto vkEnumerateInstanceLayerProperties =
        reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(
            vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceLayerProperties"));
    if (vkEnumerateInstanceLayerProperties == nullptr) {
        LOG_CRITICAL(Frontend, "Failed to retrieve Vulkan function pointer!");
        return false;
    }

    u32 available_layers_count{};
    if (vkEnumerateInstanceLayerProperties(&available_layers_count, nullptr) != VK_SUCCESS) {
        LOG_CRITICAL(Frontend, "Failed to enumerate Vulkan validation layers!");
        return false;
    }
    std::vector<VkLayerProperties> layers(available_layers_count);
    if (vkEnumerateInstanceLayerProperties(&available_layers_count, layers.data()) != VK_SUCCESS) {
        LOG_CRITICAL(Frontend, "Failed to enumerate Vulkan validation layers!");
        return false;
    }

    return std::find_if(layers.begin(), layers.end(), [&](const auto& layer) {
               return layer.layerName == std::string("VK_LAYER_LUNARG_standard_validation");
           }) != layers.end();
}