mxvk.cpp

Go to the documentation of this file.

#include "mxvk/mxvk.hpp"
#include "mxvk/mxvk_exception.hpp"
#include "mxvk/mxvk_png.hpp"
#include "mxvk/mxvk_shader_module.hpp"
#include <SDL3/SDL_oldnames.h>
#include <SDL3/SDL_video.h>
#include <SDL3/SDL_vulkan.h>
#include <algorithm>
#include <array>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <exception>
#include <filesystem>
#include <format>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <optional>
#include <sstream>
#include <vector>
 
#ifdef _WIN32
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <windows.h>
#endif
 
#ifndef MXVK_SPRITE_SHADER_DIR
#define MXVK_SPRITE_SHADER_DIR "."
#endif
 
#ifndef MXVK_TEXT_SHADER_DIR
#define MXVK_TEXT_SHADER_DIR "."
#endif
 
#ifndef MXVK_DEFAULT_FONT_DIR
#define MXVK_DEFAULT_FONT_DIR "."
#endif
 
namespace mxvk {
    namespace {
        [[nodiscard]] float half_to_float(uint16_t value) noexcept {
            const bool negative = (value & 0x8000U) != 0U;
            const uint32_t exponent = (value >> 10U) & 0x1FU;
            const uint32_t mantissa = value & 0x3FFU;
            float result = 0.0F;
            if (exponent == 0U) {
                result = std::ldexp(static_cast<float>(mantissa), -24);
            } else if (exponent == 31U) {
                result = mantissa == 0U ? std::numeric_limits<float>::infinity() : std::numeric_limits<float>::quiet_NaN();
            } else {
                result = std::ldexp(1.0F + static_cast<float>(mantissa) / 1024.0F, static_cast<int>(exponent) - 15);
            }
            return negative ? -result : result;
        }
 
        bool shouldLogMissingValidationLayer() {
            const char *quiet_missing_validation = std::getenv("MXVK_QUIET_MISSING_VALIDATION");
            return quiet_missing_validation == nullptr || std::strcmp(quiet_missing_validation, "1") != 0;
        }
    } // namespace
 
    VKAPI_ATTR VkBool32 VKAPI_CALL VK_Window::debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT severity, [[maybe_unused]] VkDebugUtilsMessageTypeFlagsEXT type, const VkDebugUtilsMessengerCallbackDataEXT *callback_data, [[maybe_unused]] void *user_data) {
        const char *message = (callback_data != nullptr && callback_data->pMessage != nullptr) ? callback_data->pMessage : "Unknown Vulkan validation message";
 
        if ((severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) != 0U) {
            std::cerr << std::format("vk validation error: {}\n", message);
        } else if ((severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) != 0U) {
            std::cerr << std::format("vk validation warning: {}\n", message);
        } else {
            std::cout << std::format("vk validation: {}\n", message);
        }
        return VK_FALSE;
    }
 
    VulkanContext VK_Window::context() const {
        return VulkanContext{
            .device = getDevice(),
            .physical_device = getPhysicalDevice(),
            .graphics_queue = getGraphicsQueue(),
            .command_pool = getCommandPool(),
        };
    }
 
    VK_Window::SwapchainSupport VK_Window::querySwapchainSupport(VkPhysicalDevice device, VkSurfaceKHR surface) {
        std::cout << "vk: querying swapchain support details\n";
        SwapchainSupport support{};
 
        vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &support.capabilities);
 
        uint32_t format_count = 0;
        vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &format_count, nullptr);
        if (format_count > 0U) {
            support.formats.resize(format_count);
            vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &format_count, support.formats.data());
        }
 
        uint32_t present_mode_count = 0;
        vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &present_mode_count, nullptr);
        if (present_mode_count > 0U) {
            support.present_modes.resize(present_mode_count);
            vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &present_mode_count, support.present_modes.data());
        }
 
        return support;
    }
 
    VkSurfaceFormatKHR VK_Window::chooseSurfaceFormat(const std::vector<VkSurfaceFormatKHR> &available_formats) {
        for (const VkSurfaceFormatKHR &format : available_formats) {
            if (format.format == VK_FORMAT_B8G8R8A8_UNORM && format.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
                return format;
            }
        }
 
        return available_formats.front();
    }
 
    VkPresentModeKHR VK_Window::choosePresentMode(const std::vector<VkPresentModeKHR> &available_present_modes) const {
        if (present_mode_preference == PresentModePreference::Vsync) {
            return VK_PRESENT_MODE_FIFO_KHR;
        }
 
        for (const VkPresentModeKHR present_mode : available_present_modes) {
            if (present_mode == VK_PRESENT_MODE_MAILBOX_KHR) {
                return present_mode;
            }
        }
 
        return VK_PRESENT_MODE_FIFO_KHR;
    }
 
    VkExtent2D VK_Window::chooseExtent(const VkSurfaceCapabilitiesKHR &capabilities, SDL_Window *window) {
        if (capabilities.currentExtent.width != UINT32_MAX) {
            return capabilities.currentExtent;
        }
 
        int width = 1;
        int height = 1;
        SDL_GetWindowSizeInPixels(window, &width, &height);
 
        VkExtent2D actual_extent{};
        actual_extent.width = std::clamp(static_cast<uint32_t>(std::max(width, 1)), capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
        actual_extent.height = std::clamp(static_cast<uint32_t>(std::max(height, 1)), capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
 
        return actual_extent;
    }
 
    std::vector<char> VK_Window::loadSpv(const std::string &path) { return mxvk::load_spv(path); }
 
    VkShaderModule VK_Window::createShaderModule(VkDevice device, const std::vector<char> &spv_bytes) { return mxvk::create_shader_module(device, spv_bytes); }
 
    std::string VK_Window::resolveRuntimeShaderPath(const std::string &shaderFileName, const char *fallbackDir) const {
        if (shaderFileName.empty()) {
            throw mxvk::Exception("Shader file name is empty");
        }
 
        std::vector<std::filesystem::path> candidates{};
 
        if (!defaultShaderDirectory().empty()) {
            candidates.push_back(std::filesystem::path(defaultShaderDirectory()) / shaderFileName);
        }
 
        const auto add_executable_candidates = [&candidates, &shaderFileName](const std::filesystem::path &executableDir) {
            candidates.push_back(executableDir / "data" / shaderFileName);
            candidates.push_back(executableDir / shaderFileName);
            candidates.push_back(executableDir.parent_path() / "share" / "mxvk" / "shaders" / shaderFileName);
        };
 
        if (const char *basePath = SDL_GetBasePath(); basePath != nullptr) {
            add_executable_candidates(std::filesystem::path(basePath));
        }
 
#ifdef _WIN32
        std::vector<wchar_t> executableName(MAX_PATH);
        const DWORD executableLength = GetModuleFileNameW(nullptr, executableName.data(), static_cast<DWORD>(executableName.size()));
        if (executableLength > 0U && executableLength < executableName.size() - 1U) {
            add_executable_candidates(std::filesystem::path(std::wstring(executableName.data(), executableLength)).parent_path());
        }
#endif
 
        candidates.push_back(std::filesystem::path("data") / shaderFileName);
 
        if (!font_path.empty()) {
            const std::filesystem::path fontPath(font_path);
            if (fontPath.has_parent_path()) {
                candidates.push_back(fontPath.parent_path() / shaderFileName);
            }
        }
 
        if (fallbackDir != nullptr && fallbackDir[0] != '\0') {
            candidates.push_back(std::filesystem::path(fallbackDir) / shaderFileName);
        }
 
        std::error_code existsError{};
        for (const std::filesystem::path &candidate : candidates) {
            if (std::filesystem::exists(candidate, existsError)) {
                return candidate.string();
            }
            existsError.clear();
        }
 
        throw mxvk::Exception(std::format("Failed to locate shader file '{}'", shaderFileName));
    }
 
    VK_Window::VK_Window(const std::string &title, int width, int height, bool full, bool validiation, PresentModePreference presentModePreference, RuntimeMode runtimeMode) : runtime_mode(runtimeMode), requested_headless_extent{width > 0 ? static_cast<uint32_t>(width) : 0U, height > 0 ? static_cast<uint32_t>(height) : 0U}, present_mode_preference(presentModePreference) {
        if (width <= 0 || height <= 0) {
            throw mxvk::Exception("Render dimensions must be positive");
        }
        setEnableScreenshot(defaultEnableScreenshot());
        screenshot_prefix = defaultExecutableName();
        std::cout << std::format("mxvk: starting VK_Window construction (title='{}', width={}, height={}, fullscreen={}, validation={}, mode={})\n", title, width, height, full, validiation, headless() ? "headless" : "windowed");
        SDL_WindowFlags flags = static_cast<SDL_WindowFlags>(SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE);
        if (full) {
            std::cout << "SDL3: enabling fullscreen window flag\n";
            flags = static_cast<SDL_WindowFlags>(flags | SDL_WINDOW_FULLSCREEN);
        }
 
        if (!headless()) {
            std::cout << "mxvk: initializing window subsystem and creating SDL window\n";
            if (!initWindow(title, width, height, flags)) {
                throw mxvk::Exception("Error on init of Window");
            }
            showCursor(!full);
        } else {
            std::cout << "mxvk: surface-free headless mode; SDL video and window creation skipped\n";
        }
 
        std::cout << "mxvk: initializing Vulkan runtime and rendering resources\n";
        if (!initVulkan(validiation)) {
            release();
            throw mxvk::Exception("Error on init of Vulkan");
        }
        std::cout << "mxvk: VK_Window construction complete\n";
    }
 
    VK_Window::VK_Window(const std::string &title, int width, int height, bool full, bool validiation, bool enableVsync) : VK_Window(title, width, height, full, validiation, enableVsync ? PresentModePreference::Vsync : PresentModePreference::LowLatency) {}
 
    VK_Window::~VK_Window() {
        std::cout << "mxvk: destructor invoked, releasing resources\n";
        release();
    }
 
    void VK_Window::release() {
        std::cout << "mxvk: starting resource teardown\n";
        stopScreenshotWorker();
 
        if (device != VK_NULL_HANDLE) {
            std::cout << "vk: waiting for device idle before teardown\n";
            vkDeviceWaitIdle(device);
        }
 
        destroyFrameReadbackResources();
 
        post_process_sprite = nullptr;
        owned_post_process_sprite = nullptr;
        post_process_present_sprite = nullptr;
        post_process_composite_sprite = nullptr;
        post_process_sprites.clear();
        owned_post_process_sprites.clear();
        post_process_effect_stages.clear();
        post_process_effect_params.clear();
        post_process_effect_time_enabled.clear();
        post_process_effect_start_times.clear();
 
        if (!sprites.empty()) {
            std::cout << std::format("vk: releasing {} sprite(s)\n", sprites.size());
            sprites.clear();
            std::cout << "vk: sprite resources released\n";
        }
        if (!sprites3d.empty()) {
            std::cout << std::format("vk: releasing {} 3D sprite batch(es)\n", sprites3d.size());
            sprites3d.clear();
        }
        sprite_state_dirty = false;
        destroySpritePipeline();
        if (sprite_descriptor_set_layout != VK_NULL_HANDLE && device != VK_NULL_HANDLE) {
            vkDestroyDescriptorSetLayout(device, sprite_descriptor_set_layout, nullptr);
            sprite_descriptor_set_layout = VK_NULL_HANDLE;
        }
 
        if (text_renderer) {
            text_renderer.reset();
        }
        if (preview_text_renderer) {
            preview_text_renderer.reset();
        }
        preview_text_queued = false;
        text_state_dirty = false;
        destroyTextPipeline();
        if (text_descriptor_set_layout != VK_NULL_HANDLE && device != VK_NULL_HANDLE) {
            vkDestroyDescriptorSetLayout(device, text_descriptor_set_layout, nullptr);
            text_descriptor_set_layout = VK_NULL_HANDLE;
        }
 
        cleanupSyncObjects();
 
        if (!retired_swapchains.empty()) {
            for (VkSwapchainKHR retired : retired_swapchains) {
                vkDestroySwapchainKHR(device, retired, nullptr);
            }
            retired_swapchains.clear();
        }
        std::cout << "vk: tearing down swapchain-dependent resources\n";
        cleanupSwapchain(true);
 
        if (command_pool != VK_NULL_HANDLE && device != VK_NULL_HANDLE) {
            std::cout << "vk: destroying command pool\n";
            vkDestroyCommandPool(device, command_pool, nullptr);
            command_pool = VK_NULL_HANDLE;
        }
 
        if (device != VK_NULL_HANDLE) {
            savePipelineCache();
            destroyPipelineCache();
            std::cout << "vk: destroying logical device\n";
            vkDestroyDevice(device, nullptr);
            device = VK_NULL_HANDLE;
            graphics_queue = VK_NULL_HANDLE;
            present_queue = VK_NULL_HANDLE;
        }
 
        graphics_queue_family = invalid_queue_index;
        present_queue_family = invalid_queue_index;
        physical_device = VK_NULL_HANDLE;
 
        if (surface != VK_NULL_HANDLE && instance != VK_NULL_HANDLE) {
            std::cout << "vk: destroying presentation surface\n";
            vkDestroySurfaceKHR(instance, surface, nullptr);
            surface = VK_NULL_HANDLE;
        }
 
        cleanupDebugMessenger();
 
        if (instance != VK_NULL_HANDLE) {
            std::cout << "vk: destroying Vulkan instance\n";
            vkDestroyInstance(instance, nullptr);
            instance = VK_NULL_HANDLE;
        }
 
        if (window != nullptr) {
            std::cout << "SDL3: destroying SDL window handle\n";
            window.reset();
        }
 
        if (vulkan_library_loaded) {
            std::cout << "SDL3: unloading Vulkan loader library\n";
            SDL_Vulkan_UnloadLibrary();
            vulkan_library_loaded = false;
        }
 
        if (sdl_initialized) {
            std::cout << "SDL3: shutting down SDL video/gamepad subsystems\n";
            SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD);
            sdl_initialized = false;
        }
 
        active = false;
        std::cout << "mxvk: resource teardown complete\n";
    }
 
    bool VK_Window::initVulkan(bool validiation) {
        std::cout << std::format("mxvk: entering initVulkan (validation={})\n", validiation);
        validation_enabled = validiation;
 
        if (!headless() && window == nullptr) {
            std::cerr << "mxvk: Cannot initialize Vulkan without an SDL window\n";
            return false;
        }
 
        if (instance != VK_NULL_HANDLE) {
            std::cout << "vk: instance already initialized; skipping initVulkan\n";
            return true;
        }
 
        std::vector<const char *> enabled_extensions{};
        if (headless()) {
            std::cout << "vk: initializing volk directly from the Vulkan loader\n";
            if (volkInitialize() != VK_SUCCESS) {
                std::cerr << "mxvk: failed to initialize the Vulkan loader\n";
                return false;
            }
        } else {
            std::cout << "vk: initializing volk from SDL's Vulkan loader\n";
            const auto get_instance_proc_addr = reinterpret_cast<PFN_vkGetInstanceProcAddr>(SDL_Vulkan_GetVkGetInstanceProcAddr());
            if (get_instance_proc_addr == nullptr) {
                std::cerr << std::format("mxvk: SDL did not provide vkGetInstanceProcAddr: {}\n", SDL_GetError());
                return false;
            }
            volkInitializeCustom(get_instance_proc_addr);
 
            unsigned int extension_count = 0;
            std::cout << "SDL3: querying Vulkan instance extensions required by SDL\n";
            const char *const *extensions = SDL_Vulkan_GetInstanceExtensions(&extension_count);
            if (extensions == nullptr || extension_count == 0U) {
                std::cerr << std::format("mxvk: Failed to get Vulkan instance extensions: {}\n", SDL_GetError());
                return false;
            }
            std::cout << std::format("vk: SDL provided {} required instance extension(s)\n", extension_count);
            enabled_extensions.assign(extensions, extensions + extension_count);
        }
 
#if defined(MXVK_USE_MOLTENVK)
        const auto append_instance_extension_if_missing = [&enabled_extensions](const char *extension_name) {
            const bool exists = std::ranges::any_of(enabled_extensions, [extension_name](const char *existing) { return std::strcmp(existing, extension_name) == 0; });
            if (!exists) {
                enabled_extensions.push_back(extension_name);
            }
        };
        append_instance_extension_if_missing(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
        append_instance_extension_if_missing(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME);
#endif
 
        std::vector<const char *> enabled_layers{};
        VkDebugUtilsMessengerCreateInfoEXT debug_create_info{};
        if (validation_enabled) {
            if (!hasValidationLayerSupport()) {
                if (shouldLogMissingValidationLayer()) {
                    std::cerr << std::format("mxvk: validation layer '{}' is not available; continuing without validation\n", validation_layer_name);
                }
                validation_enabled = false;
            } else {
                enabled_layers.push_back(validation_layer_name);
                enabled_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
                const std::optional<VkDebugUtilsMessengerCreateInfoEXT> maybe_debug_create_info = makeDebugMessengerCreateInfo();
                if (!maybe_debug_create_info.has_value()) {
                    std::cerr << "mxvk: failed to construct debug messenger create info\n";
                    validation_enabled = false;
                    enabled_layers.clear();
                } else {
                    debug_create_info = maybe_debug_create_info.value();
                }
            }
        }
 
        VkApplicationInfo app_info{};
        app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
        app_info.pApplicationName = "mxvk";
        app_info.applicationVersion = VK_MAKE_VERSION(0, 1, 0);
        app_info.pEngineName = "mxvk";
        app_info.engineVersion = VK_MAKE_VERSION(MXVK_VERSION_CODE_MAJOR, MXVK_VERSION_CODE_MINOR, MXVK_VERSION_CODE_PATCH);
        app_info.apiVersion = VK_API_VERSION_1_4;
 
        VkInstanceCreateInfo create_info{};
        create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
        create_info.pApplicationInfo = &app_info;
        create_info.enabledExtensionCount = static_cast<uint32_t>(enabled_extensions.size());
        create_info.ppEnabledExtensionNames = enabled_extensions.data();
        create_info.enabledLayerCount = static_cast<uint32_t>(enabled_layers.size());
        create_info.ppEnabledLayerNames = enabled_layers.empty() ? nullptr : enabled_layers.data();
        create_info.pNext = validation_enabled ? &debug_create_info : nullptr;
 
        create_info.enabledExtensionCount = static_cast<uint32_t>(enabled_extensions.size());
#if defined(MXVK_USE_MOLTENVK)
        create_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR;
#endif
 
        std::cout << "vk: creating Vulkan instance\n";
        if (vkCreateInstance(&create_info, nullptr, &instance) != VK_SUCCESS) {
            std::cerr << "mxvk: Failed to create Vulkan instance\n";
            instance = VK_NULL_HANDLE;
            return false;
        }
 
        std::cout << "vk: loading Vulkan instance function pointers via volk\n";
        volkLoadInstance(instance);
 
        setupDebugMessenger();
 
        uint32_t instanceVersion = 0;
        if (vkEnumerateInstanceVersion != nullptr) {
            vkEnumerateInstanceVersion(&instanceVersion);
        }
        std::cout << "vk: Vulkan instance version: " << VK_VERSION_MAJOR(instanceVersion) << "." << VK_VERSION_MINOR(instanceVersion) << "." << VK_VERSION_PATCH(instanceVersion) << "\n";
        std::cout << "mxvk: engine version: " << MXVK_VERSION_CODE_MAJOR << "." << MXVK_VERSION_CODE_MINOR << "." << MXVK_VERSION_CODE_PATCH << "\n";
 
        if (!headless()) {
            std::cout << "SDL3: creating Vulkan presentation surface from SDL window\n";
            if (!SDL_Vulkan_CreateSurface(window.get(), instance, nullptr, &surface)) {
                std::cerr << std::format("mxvk: Failed to create Vulkan surface: {}\n", SDL_GetError());
                cleanupDebugMessenger();
                vkDestroyInstance(instance, nullptr);
                instance = VK_NULL_HANDLE;
                surface = VK_NULL_HANDLE;
                return false;
            }
        }
 
        std::cout << "mxvk: selecting suitable physical device\n";
        pickDevice();
        if (physical_device == VK_NULL_HANDLE) {
            std::cerr << "mxvk: Failed to find a suitable Vulkan physical device\n";
            return false;
        }
 
        std::cout << "mxvk: creating logical device and queues\n";
        createLogicalDevice();
        if (device == VK_NULL_HANDLE) {
            std::cerr << "mxvk: Failed to create Vulkan logical device\n";
            return false;
        }
        createPipelineCache();
 
        std::cout << "mxvk: deferring swapchain/render/sync resource creation until first frame\n";
 
        std::cout << "mxvk: initVulkan complete\n";
        return true;
    }
 
    std::string VK_Window::pipelineCachePath() const {
        if (physical_device == VK_NULL_HANDLE) {
            return {};
        }
 
        VkPhysicalDeviceProperties properties{};
        vkGetPhysicalDeviceProperties(physical_device, &properties);
 
        char *pref_path = SDL_GetPrefPath("mxvk", "MXVK");
        std::filesystem::path base_path;
        if (pref_path != nullptr) {
            base_path = pref_path;
            SDL_free(pref_path);
        } else {
            base_path = std::filesystem::current_path();
        }
 
        std::error_code ec;
        std::filesystem::create_directories(base_path, ec);
        if (ec) {
            return {};
        }
 
        std::ostringstream filename;
        filename << "pipeline_cache_" << std::hex << std::setfill('0') << properties.vendorID << '_' << properties.deviceID << '_' << properties.driverVersion << '_';
        for (uint8_t byte : properties.pipelineCacheUUID) {
            filename << std::setw(2) << static_cast<unsigned>(byte);
        }
        filename << ".bin";
 
        return (base_path / filename.str()).string();
    }
 
    void VK_Window::createPipelineCache() {
        if (device == VK_NULL_HANDLE || pipeline_cache != VK_NULL_HANDLE) {
            return;
        }
 
        const std::string cache_path = pipelineCachePath();
        std::vector<char> initial_data{};
        if (!cache_path.empty() && std::filesystem::exists(cache_path)) {
            std::ifstream file(cache_path, std::ios::binary);
            if (file) {
                initial_data.assign(std::istreambuf_iterator<char>(file), std::istreambuf_iterator<char>());
            }
        }
 
        VkPipelineCacheCreateInfo create_info{};
        create_info.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
        create_info.initialDataSize = initial_data.size();
        create_info.pInitialData = initial_data.empty() ? nullptr : initial_data.data();
 
        VkResult result = vkCreatePipelineCache(device, &create_info, nullptr, &pipeline_cache);
        if (result != VK_SUCCESS && !initial_data.empty()) {
            std::cerr << "vk: cached pipeline data rejected; creating an empty pipeline cache\n";
            create_info.initialDataSize = 0;
            create_info.pInitialData = nullptr;
            result = vkCreatePipelineCache(device, &create_info, nullptr, &pipeline_cache);
        }
 
        if (result != VK_SUCCESS) {
            pipeline_cache = VK_NULL_HANDLE;
            std::cerr << std::format("vk: failed to create pipeline cache ({})\n", static_cast<int>(result));
            return;
        }
 
        if (!initial_data.empty()) {
            std::cout << std::format("vk: loaded pipeline cache: {} bytes\n", initial_data.size());
        }
    }
 
    void VK_Window::savePipelineCache() const {
        if (device == VK_NULL_HANDLE || pipeline_cache == VK_NULL_HANDLE) {
            return;
        }
 
        size_t data_size = 0;
        VkResult result = vkGetPipelineCacheData(device, pipeline_cache, &data_size, nullptr);
        if (result != VK_SUCCESS || data_size == 0) {
            return;
        }
 
        std::vector<char> data(data_size);
        result = vkGetPipelineCacheData(device, pipeline_cache, &data_size, data.data());
        if (result != VK_SUCCESS || data_size == 0) {
            return;
        }
        data.resize(data_size);
 
        const std::string cache_path = pipelineCachePath();
        if (cache_path.empty()) {
            return;
        }
 
        std::ofstream file(cache_path, std::ios::binary | std::ios::trunc);
        if (!file) {
            std::cerr << std::format("vk: failed to open pipeline cache for writing: {}\n", cache_path);
            return;
        }
 
        file.write(data.data(), static_cast<std::streamsize>(data.size()));
        if (file) {
            std::cout << std::format("vk: saved pipeline cache: {} bytes\n", data.size());
        }
    }
 
    void VK_Window::destroyPipelineCache() {
        if (device != VK_NULL_HANDLE && pipeline_cache != VK_NULL_HANDLE) {
            vkDestroyPipelineCache(device, pipeline_cache, nullptr);
        }
        pipeline_cache = VK_NULL_HANDLE;
    }
 
    void VK_Window::event(SDL_Event &e) {
        switch (e.type) {
        case SDL_EVENT_KEY_DOWN:
            switch (e.key.key) {
            case SDLK_ESCAPE:
                active = false;
                break;
            }
            break;
        }
    }
    void VK_Window::setClearColor(float r, float g, float b, float a) {
        clear_color.float32[0] = std::clamp(r, 0.0f, 1.0f);
        clear_color.float32[1] = std::clamp(g, 0.0f, 1.0f);
        clear_color.float32[2] = std::clamp(b, 0.0f, 1.0f);
        clear_color.float32[3] = std::clamp(a, 0.0f, 1.0f);
    }
 
    void VK_Window::setEnableScreenshot(bool enabled) noexcept {
        screenshot_enabled = enabled;
        if (enabled) {
            frame_readback_enabled = true;
        }
    }
 
    void VK_Window::loop() {
        if (headless()) {
            active = true;
            while (active) {
                proc();
                render();
                maybeTrimMemory();
            }
            flushFrameReadbacks();
            return;
        }
 
        SDL_Event e;
        active = true;
        while (active) {
            while (SDL_PollEvent(&e)) {
                switch (e.type) {
                case SDL_EVENT_QUIT:
                    active = false;
                    break;
                case SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED:
                    if (window != nullptr) {
                        framebuffer_resized = true;
                        last_resize_event_ms = SDL_GetTicks();
                        force_swapchain_recreate = false;
                    }
                    break;
                case SDL_EVENT_KEY_DOWN:
                    if ((e.key.key == SDLK_F12 || e.key.scancode == SDL_SCANCODE_F12) && !e.key.repeat) {
                        toggleFpsCounter();
                    }
                    if (screenshot_enabled && (e.key.key == SDLK_F10 || e.key.scancode == SDL_SCANCODE_F10) && !e.key.repeat) {
                        try {
                            saveScreenshot();
                        } catch (const mxvk::Exception &ex) {
                            std::cerr << std::format("mxvk: screenshot failed: {}\n", ex.text());
                        } catch (const std::exception &ex) {
                            std::cerr << std::format("mxvk: screenshot failed: {}\n", ex.what());
                        }
                        continue;
                    }
                    break;
                default:
                    break;
                }
                event(e);
            }
            if (framebuffer_resized) {
                const uint64_t now_ms = SDL_GetTicks();
                if (!force_swapchain_recreate && last_resize_event_ms != 0 && (now_ms - last_resize_event_ms) < resize_settle_delay_ms) {
                    proc();
                    render();
                    SDL_Delay(1);
                    continue;
                }
                recreateSwapchain();
            }
            proc();
            render();
            maybeTrimMemory();
        }
    }
 
    void VK_Window::saveScreenshot() {
        const std::string path = makeScreenshotPath();
        std::vector<std::uint8_t> rgba{};
        uint32_t width = 0;
        uint32_t height = 0;
        captureSnapshotPixels(rgba, width, height);
        enqueueScreenshotSave(path, std::move(rgba), width, height);
        std::cout << std::format("mxvk: screenshot queued: {}\n", path);
    }
 
    void VK_Window::enqueueScreenshotSave(std::string path, std::vector<std::uint8_t> rgba, uint32_t width, uint32_t height) {
        if (path.empty()) {
            throw mxvk::Exception("enqueueScreenshotSave requires a non-empty output path");
        }
        if (rgba.empty() || width == 0U || height == 0U) {
            throw mxvk::Exception("enqueueScreenshotSave requires non-empty pixel data");
        }
 
        startScreenshotWorker();
 
        {
            std::lock_guard<std::mutex> lock(screenshot_queue_mutex);
            screenshot_save_queue.push_back(ScreenshotSaveTask{
                .path = std::move(path),
                .rgba = std::move(rgba),
                .width = width,
                .height = height,
            });
        }
        screenshot_queue_cv.notify_one();
    }
 
    void VK_Window::startScreenshotWorker() {
        std::lock_guard<std::mutex> lock(screenshot_queue_mutex);
        if (screenshot_worker.joinable()) {
            return;
        }
 
        screenshot_worker_stop = false;
        screenshot_worker = std::thread(&VK_Window::screenshotWorkerLoop, this);
    }
 
    void VK_Window::stopScreenshotWorker() {
        {
            std::lock_guard<std::mutex> lock(screenshot_queue_mutex);
            screenshot_worker_stop = true;
        }
        screenshot_queue_cv.notify_one();
 
        if (screenshot_worker.joinable()) {
            screenshot_worker.join();
        }
 
        screenshot_worker_stop = false;
    }
 
    void VK_Window::screenshotWorkerLoop() {
        while (true) {
            ScreenshotSaveTask task{};
            {
                std::unique_lock<std::mutex> lock(screenshot_queue_mutex);
                screenshot_queue_cv.wait(lock, [&]() { return screenshot_worker_stop || !screenshot_save_queue.empty(); });
 
                if (screenshot_worker_stop && screenshot_save_queue.empty()) {
                    return;
                }
 
                task = std::move(screenshot_save_queue.front());
                screenshot_save_queue.pop_front();
            }
 
            if (!mxvk::SavePNG_RGBA(task.path.c_str(), task.rgba.data(), static_cast<int>(task.width), static_cast<int>(task.height))) {
                std::cerr << std::format("mxvk: screenshot failed to write PNG: {}\n", task.path);
                continue;
            }
            std::cout << std::format("mxvk: screenshot saved: {}\n", task.path);
        }
    }
 
    std::string VK_Window::makeScreenshotPath() {
        const char *home = std::getenv("HOME");
        std::filesystem::path pictures_dir = (home != nullptr && home[0] != '\0') ? std::filesystem::path(home) / "Pictures" : std::filesystem::path("Pictures");
        std::filesystem::create_directories(pictures_dir);
 
        const std::time_t now = std::time(nullptr);
        std::tm local_time{};
#if defined(_WIN32)
        localtime_s(&local_time, &now);
#else
        localtime_r(&now, &local_time);
#endif
 
        std::ostringstream date_stream;
        date_stream << std::put_time(&local_time, "%Y.%m.%d");
        std::ostringstream time_stream;
        time_stream << std::put_time(&local_time, "%H.%M.%S");
 
        const std::string prefix = std::format("{}.screenshot.{}.{}.{}x{}-", screenshot_prefix.empty() ? "mxvk" : screenshot_prefix, date_stream.str(), time_stream.str(), swapchain_extent.width, swapchain_extent.height);
 
        for (uint32_t attempt = 0; attempt < 10000U; ++attempt) {
            const uint32_t index = screenshot_index++;
            std::filesystem::path path = pictures_dir / std::format("{}{}.png", prefix, index);
            if (!std::filesystem::exists(path)) {
                return path.string();
            }
        }
 
        return (pictures_dir / std::format("{}{}.png", prefix, screenshot_index++)).string();
    }
 
    void VK_Window::render() { drawFrame(); }
 
    void VK_Window::saveSnapshot(const std::string &path) {
        if (path.empty()) {
            throw mxvk::Exception("saveSnapshot requires a non-empty output path");
        }
 
        std::vector<std::uint8_t> rgba{};
        uint32_t width = 0;
        uint32_t height = 0;
        captureSnapshotPixels(rgba, width, height);
 
        if (!mxvk::SavePNG_RGBA(path.c_str(), rgba.data(), static_cast<int>(width), static_cast<int>(height))) {
            throw mxvk::Exception("saveSnapshot failed to write PNG: " + path);
        }
    }
 
    void VK_Window::captureSnapshotPixels(std::vector<std::uint8_t> &rgba_pixels, uint32_t &width, uint32_t &height) {
        if (!latest_frame_readback_rgba.empty()) {
            rgba_pixels = latest_frame_readback_rgba;
            width = latest_frame_readback_width;
            height = latest_frame_readback_height;
            return;
        }
        if (!latest_frame_readback_rgba16.empty()) {
            rgba_pixels.resize(latest_frame_readback_rgba16.size());
            std::transform(latest_frame_readback_rgba16.begin(), latest_frame_readback_rgba16.end(), rgba_pixels.begin(), [](std::uint16_t value) { return static_cast<std::uint8_t>((static_cast<std::uint32_t>(value) + 128U) / 257U); });
            width = latest_frame_readback_width;
            height = latest_frame_readback_height;
            return;
        }
        if (device == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE || graphics_queue == VK_NULL_HANDLE) {
            throw mxvk::Exception("captureSnapshotPixels called before Vulkan render resources are ready");
        }
        if (last_presented_image_index == invalid_queue_index || last_presented_image_index >= swapchain_images.size() || last_presented_image_index >= image_fences.size()) {
            throw mxvk::Exception("captureSnapshotPixels called before a frame has been presented");
        }
        const bool capture_offscreen = render_extent_override.width > 0U && render_extent_override.height > 0U && !post_process_images.empty() && !post_process_initialized.empty() && last_presented_image_index < post_process_images.front().size() && last_presented_image_index < post_process_initialized.front().size() && post_process_images.front()[last_presented_image_index] != VK_NULL_HANDLE && post_process_initialized.front()[last_presented_image_index];
        if (!capture_offscreen && !swapchain_supports_transfer_src) {
            throw mxvk::Exception("captureSnapshotPixels requires swapchain transfer-source support");
        }
        const VkExtent2D source_extent = capture_offscreen ? getRenderExtent() : swapchain_extent;
        const VkImage source_image = capture_offscreen ? post_process_images.front()[last_presented_image_index] : swapchain_images[last_presented_image_index];
        const VkImageLayout source_layout = capture_offscreen ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : headless() ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
        if (source_extent.width == 0U || source_extent.height == 0U) {
            throw mxvk::Exception("captureSnapshotPixels cannot capture an empty swapchain extent");
        }
 
        const bool format_is_bgra = swapchain_format == VK_FORMAT_B8G8R8A8_UNORM || swapchain_format == VK_FORMAT_B8G8R8A8_SRGB;
        const bool format_is_rgba = swapchain_format == VK_FORMAT_R8G8B8A8_UNORM || swapchain_format == VK_FORMAT_R8G8B8A8_SRGB;
        if (!format_is_bgra && !format_is_rgba) {
            throw mxvk::Exception(std::format("captureSnapshotPixels unsupported swapchain format: {}", static_cast<int>(swapchain_format)));
        }
 
        const VkDeviceSize row_bytes = static_cast<VkDeviceSize>(source_extent.width) * 4U;
        const VkDeviceSize image_bytes = row_bytes * static_cast<VkDeviceSize>(source_extent.height);
 
        VkBuffer readback_buffer = VK_NULL_HANDLE;
        VkDeviceMemory readback_memory = VK_NULL_HANDLE;
        VkCommandBuffer command_buffer = VK_NULL_HANDLE;
        VkFence copy_fence = VK_NULL_HANDLE;
 
        auto cleanup = [&]() {
            if (copy_fence != VK_NULL_HANDLE) {
                vkDestroyFence(device, copy_fence, nullptr);
            }
            if (command_buffer != VK_NULL_HANDLE) {
                vkFreeCommandBuffers(device, command_pool, 1, &command_buffer);
            }
            if (readback_buffer != VK_NULL_HANDLE) {
                vkDestroyBuffer(device, readback_buffer, nullptr);
            }
            if (readback_memory != VK_NULL_HANDLE) {
                vkFreeMemory(device, readback_memory, nullptr);
            }
        };
 
        try {
            VkBufferCreateInfo buffer_info{};
            buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
            buffer_info.size = image_bytes;
            buffer_info.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
            buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
            if (vkCreateBuffer(device, &buffer_info, nullptr, &readback_buffer) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to create readback buffer");
            }
 
            VkMemoryRequirements memory_requirements{};
            vkGetBufferMemoryRequirements(device, readback_buffer, &memory_requirements);
 
            VkPhysicalDeviceMemoryProperties memory_properties{};
            vkGetPhysicalDeviceMemoryProperties(physical_device, &memory_properties);
            uint32_t memory_type_index = invalid_queue_index;
            constexpr VkMemoryPropertyFlags REQUIRED_PROPERTIES = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
            constexpr VkMemoryPropertyFlags PREFERRED_PROPERTIES = REQUIRED_PROPERTIES | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
            for (VkMemoryPropertyFlags properties : {PREFERRED_PROPERTIES, REQUIRED_PROPERTIES}) {
                for (uint32_t index = 0; index < memory_properties.memoryTypeCount; ++index) {
                    const bool type_matches = (memory_requirements.memoryTypeBits & (1U << index)) != 0U;
                    const bool properties_match = (memory_properties.memoryTypes[index].propertyFlags & properties) == properties;
                    if (type_matches && properties_match) {
                        memory_type_index = index;
                        break;
                    }
                }
                if (memory_type_index != invalid_queue_index) {
                    break;
                }
            }
            if (memory_type_index == invalid_queue_index) {
                throw mxvk::Exception("captureSnapshotPixels failed to find host-visible coherent memory");
            }
 
            VkMemoryAllocateInfo allocation_info{};
            allocation_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
            allocation_info.allocationSize = memory_requirements.size;
            allocation_info.memoryTypeIndex = memory_type_index;
            if (vkAllocateMemory(device, &allocation_info, nullptr, &readback_memory) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to allocate readback memory");
            }
            if (vkBindBufferMemory(device, readback_buffer, readback_memory, 0) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to bind readback memory");
            }
 
            VkCommandBufferAllocateInfo command_buffer_info{};
            command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
            command_buffer_info.commandPool = command_pool;
            command_buffer_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
            command_buffer_info.commandBufferCount = 1;
            if (vkAllocateCommandBuffers(device, &command_buffer_info, &command_buffer) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to allocate command buffer");
            }
 
            VkFenceCreateInfo fence_info{};
            fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
            if (vkCreateFence(device, &fence_info, nullptr, &copy_fence) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to create copy fence");
            }
 
            VkFence source_fence = image_fences[last_presented_image_index];
            if (source_fence != VK_NULL_HANDLE) {
                const VkResult wait_result = vkWaitForFences(device, 1, &source_fence, VK_TRUE, UINT64_MAX);
                if (wait_result != VK_SUCCESS) {
                    throw mxvk::Exception(std::format("captureSnapshotPixels failed waiting for rendered frame: {}", static_cast<int>(wait_result)));
                }
            }
 
            const VkResult idle_result = vkDeviceWaitIdle(device);
            if (idle_result != VK_SUCCESS) {
                throw mxvk::Exception(std::format("captureSnapshotPixels failed waiting for device idle: {}", static_cast<int>(idle_result)));
            }
 
            VkCommandBufferBeginInfo begin_info{};
            begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
            begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
            if (vkBeginCommandBuffer(command_buffer, &begin_info) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to begin copy command buffer");
            }
 
            VkImageMemoryBarrier2 to_transfer_barrier{};
            to_transfer_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
            to_transfer_barrier.srcStageMask = capture_offscreen ? VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT : headless() ? VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT : VK_PIPELINE_STAGE_2_NONE;
            to_transfer_barrier.srcAccessMask = capture_offscreen ? VK_ACCESS_2_SHADER_SAMPLED_READ_BIT : headless() ? VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT : VK_ACCESS_2_NONE;
            to_transfer_barrier.dstStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
            to_transfer_barrier.dstAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT;
            to_transfer_barrier.oldLayout = source_layout;
            to_transfer_barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
            to_transfer_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_transfer_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_transfer_barrier.image = source_image;
            to_transfer_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            to_transfer_barrier.subresourceRange.baseMipLevel = 0;
            to_transfer_barrier.subresourceRange.levelCount = 1;
            to_transfer_barrier.subresourceRange.baseArrayLayer = 0;
            to_transfer_barrier.subresourceRange.layerCount = 1;
 
            VkDependencyInfo to_transfer_dependency{};
            to_transfer_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
            to_transfer_dependency.imageMemoryBarrierCount = 1;
            to_transfer_dependency.pImageMemoryBarriers = &to_transfer_barrier;
            vkCmdPipelineBarrier2(command_buffer, &to_transfer_dependency);
 
            VkBufferImageCopy copy_region{};
            copy_region.bufferOffset = 0;
            copy_region.bufferRowLength = 0;
            copy_region.bufferImageHeight = 0;
            copy_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            copy_region.imageSubresource.mipLevel = 0;
            copy_region.imageSubresource.baseArrayLayer = 0;
            copy_region.imageSubresource.layerCount = 1;
            copy_region.imageOffset = {0, 0, 0};
            copy_region.imageExtent = {source_extent.width, source_extent.height, 1};
            vkCmdCopyImageToBuffer(command_buffer, source_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, readback_buffer, 1, &copy_region);
 
            VkImageMemoryBarrier2 to_present_barrier{};
            to_present_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
            to_present_barrier.srcStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
            to_present_barrier.srcAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT;
            to_present_barrier.dstStageMask = capture_offscreen ? VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT : headless() ? VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT : VK_PIPELINE_STAGE_2_NONE;
            to_present_barrier.dstAccessMask = capture_offscreen ? VK_ACCESS_2_SHADER_SAMPLED_READ_BIT : headless() ? VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT : VK_ACCESS_2_NONE;
            to_present_barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
            to_present_barrier.newLayout = source_layout;
            to_present_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_present_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_present_barrier.image = source_image;
            to_present_barrier.subresourceRange = to_transfer_barrier.subresourceRange;
 
            VkDependencyInfo to_present_dependency{};
            to_present_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
            to_present_dependency.imageMemoryBarrierCount = 1;
            to_present_dependency.pImageMemoryBarriers = &to_present_barrier;
            vkCmdPipelineBarrier2(command_buffer, &to_present_dependency);
 
            if (vkEndCommandBuffer(command_buffer) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to end copy command buffer");
            }
 
            VkCommandBufferSubmitInfo command_submit_info{};
            command_submit_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
            command_submit_info.commandBuffer = command_buffer;
 
            VkSubmitInfo2 submit_info{};
            submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2;
            submit_info.commandBufferInfoCount = 1;
            submit_info.pCommandBufferInfos = &command_submit_info;
 
            const VkResult submit_result = vkQueueSubmit2(graphics_queue, 1, &submit_info, copy_fence);
            if (submit_result != VK_SUCCESS) {
                throw mxvk::Exception(std::format("captureSnapshotPixels failed to submit copy command: {}", static_cast<int>(submit_result)));
            }
            const VkResult copy_wait_result = vkWaitForFences(device, 1, &copy_fence, VK_TRUE, UINT64_MAX);
            if (copy_wait_result != VK_SUCCESS) {
                throw mxvk::Exception(std::format("captureSnapshotPixels failed waiting for copy: {}", static_cast<int>(copy_wait_result)));
            }
 
            void *mapped = nullptr;
            if (vkMapMemory(device, readback_memory, 0, image_bytes, 0, &mapped) != VK_SUCCESS) {
                throw mxvk::Exception("captureSnapshotPixels failed to map readback memory");
            }
 
            const auto *src = static_cast<const std::uint8_t *>(mapped);
            rgba_pixels.resize(static_cast<std::size_t>(image_bytes));
            for (std::size_t i = 0; i < rgba_pixels.size(); i += 4U) {
                if (format_is_bgra) {
                    rgba_pixels[i + 0U] = src[i + 2U];
                    rgba_pixels[i + 1U] = src[i + 1U];
                    rgba_pixels[i + 2U] = src[i + 0U];
                    rgba_pixels[i + 3U] = src[i + 3U];
                } else {
                    rgba_pixels[i + 0U] = src[i + 0U];
                    rgba_pixels[i + 1U] = src[i + 1U];
                    rgba_pixels[i + 2U] = src[i + 2U];
                    rgba_pixels[i + 3U] = src[i + 3U];
                }
            }
            vkUnmapMemory(device, readback_memory);
            width = source_extent.width;
            height = source_extent.height;
        } catch (...) {
            cleanup();
            throw;
        }
 
        cleanup();
    }
 
    void VK_Window::onFrameReadback([[maybe_unused]] std::vector<std::uint8_t> &rgba_pixels, [[maybe_unused]] uint32_t width, [[maybe_unused]] uint32_t height) {}
 
    void VK_Window::onFrameReadbackRgba16([[maybe_unused]] std::vector<std::uint16_t> &rgba_pixels, [[maybe_unused]] uint32_t width, [[maybe_unused]] uint32_t height) {}
 
    void VK_Window::onFrameReadbackScheduled() {}
 
    void VK_Window::dispatchFrameReadback(FrameReadbackSlot &slot) {
        if (!slot.pending) {
            return;
        }
        if (slot.mapped == nullptr || slot.width == 0U || slot.height == 0U) {
            slot.pending = false;
            return;
        }
 
        if (slot.format == VK_FORMAT_R16G16B16A16_SFLOAT) {
            const auto *source = static_cast<const std::uint16_t *>(slot.mapped);
            const std::size_t component_count = static_cast<std::size_t>(slot.width) * slot.height * 4U;
            latest_frame_readback_rgba16.resize(component_count);
            for (std::size_t component = 0; component < component_count; ++component) {
                const float normalized = std::clamp(half_to_float(source[component]), 0.0F, 1.0F);
                latest_frame_readback_rgba16[component] = static_cast<std::uint16_t>(std::lround(normalized * 65535.0F));
            }
            latest_frame_readback_width = slot.width;
            latest_frame_readback_height = slot.height;
            slot.pending = false;
            onFrameReadbackRgba16(latest_frame_readback_rgba16, latest_frame_readback_width, latest_frame_readback_height);
            return;
        }
 
        const auto *source = static_cast<const std::uint8_t *>(slot.mapped);
        const std::size_t pixel_bytes = static_cast<std::size_t>(slot.width) * slot.height * 4U;
        latest_frame_readback_rgba.resize(pixel_bytes);
        const bool format_is_bgra = slot.format == VK_FORMAT_B8G8R8A8_UNORM || slot.format == VK_FORMAT_B8G8R8A8_SRGB;
        for (std::size_t offset = 0; offset < pixel_bytes; offset += 4U) {
            if (format_is_bgra) {
                latest_frame_readback_rgba[offset + 0U] = source[offset + 2U];
                latest_frame_readback_rgba[offset + 1U] = source[offset + 1U];
                latest_frame_readback_rgba[offset + 2U] = source[offset + 0U];
                latest_frame_readback_rgba[offset + 3U] = source[offset + 3U];
            } else {
                latest_frame_readback_rgba[offset + 0U] = source[offset + 0U];
                latest_frame_readback_rgba[offset + 1U] = source[offset + 1U];
                latest_frame_readback_rgba[offset + 2U] = source[offset + 2U];
                latest_frame_readback_rgba[offset + 3U] = source[offset + 3U];
            }
        }
 
        latest_frame_readback_width = slot.width;
        latest_frame_readback_height = slot.height;
        slot.pending = false;
        onFrameReadback(latest_frame_readback_rgba, latest_frame_readback_width, latest_frame_readback_height);
    }
 
    void VK_Window::flushFrameReadbacks() {
        if (device == VK_NULL_HANDLE) {
            return;
        }
        const bool has_pending = std::ranges::any_of(frame_readback_slots, [](const FrameReadbackSlot &slot) { return slot.pending; });
        if (!has_pending) {
            return;
        }
 
        const VkResult wait_result = vkDeviceWaitIdle(device);
        if (wait_result != VK_SUCCESS) {
            throw mxvk::Exception(std::format("frame readback flush failed waiting for the device (VkResult={})", static_cast<int>(wait_result)));
        }
        for (uint32_t offset = 0; offset < max_frames_in_flight; ++offset) {
            const uint32_t slot_index = (current_frame + offset) % max_frames_in_flight;
            dispatchFrameReadback(frame_readback_slots[slot_index]);
        }
    }
 
    void VK_Window::ensureFrameReadbackResources() {
        if (!frame_readback_enabled) {
            return;
        }
        if (!swapchain_supports_transfer_src) {
            throw mxvk::Exception("frame readback requires swapchain transfer-source support");
        }
 
        const VkExtent2D readback_extent = getRenderExtent();
        const VkDeviceSize required_size = static_cast<VkDeviceSize>(readback_extent.width) * readback_extent.height * (frame_readback_rgba16_enabled ? 8U : 4U);
        if (required_size == 0U) {
            throw mxvk::Exception("frame readback cannot use an empty swapchain extent");
        }
        const bool resources_ready = std::ranges::all_of(frame_readback_slots, [&](const FrameReadbackSlot &slot) { return slot.buffer != VK_NULL_HANDLE && slot.mapped != nullptr && slot.size >= required_size; });
        if (resources_ready) {
            return;
        }
 
        if (device != VK_NULL_HANDLE) {
            flushFrameReadbacks();
            vkDeviceWaitIdle(device);
        }
        destroyFrameReadbackResources();
 
        VkBufferCreateInfo buffer_info{};
        buffer_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
        buffer_info.size = required_size;
        buffer_info.usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT;
        buffer_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
        VkPhysicalDeviceMemoryProperties memory_properties{};
        vkGetPhysicalDeviceMemoryProperties(physical_device, &memory_properties);
        constexpr VkMemoryPropertyFlags REQUIRED_PROPERTIES = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
        constexpr VkMemoryPropertyFlags PREFERRED_PROPERTIES = REQUIRED_PROPERTIES | VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
        bool memory_type_logged = false;
        try {
            for (FrameReadbackSlot &slot : frame_readback_slots) {
                if (vkCreateBuffer(device, &buffer_info, nullptr, &slot.buffer) != VK_SUCCESS) {
                    throw mxvk::Exception("failed to create pipelined frame-readback buffer");
                }
 
                VkMemoryRequirements memory_requirements{};
                vkGetBufferMemoryRequirements(device, slot.buffer, &memory_requirements);
                uint32_t memory_type_index = invalid_queue_index;
                for (VkMemoryPropertyFlags properties : {PREFERRED_PROPERTIES, REQUIRED_PROPERTIES}) {
                    for (uint32_t index = 0; index < memory_properties.memoryTypeCount; ++index) {
                        const bool type_matches = (memory_requirements.memoryTypeBits & (1U << index)) != 0U;
                        const bool properties_match = (memory_properties.memoryTypes[index].propertyFlags & properties) == properties;
                        if (type_matches && properties_match) {
                            memory_type_index = index;
                            break;
                        }
                    }
                    if (memory_type_index != invalid_queue_index) {
                        break;
                    }
                }
                if (memory_type_index == invalid_queue_index) {
                    throw mxvk::Exception("failed to find host-visible frame-readback memory");
                }
                if (!memory_type_logged) {
                    const VkMemoryPropertyFlags selected_properties = memory_properties.memoryTypes[memory_type_index].propertyFlags;
                    std::cout << std::format("mxvk: frame readback memory type {} ({})\n", memory_type_index, (selected_properties & VK_MEMORY_PROPERTY_HOST_CACHED_BIT) != 0U ? "host cached" : "host coherent fallback");
                    memory_type_logged = true;
                }
 
                VkMemoryAllocateInfo allocation_info{};
                allocation_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
                allocation_info.allocationSize = memory_requirements.size;
                allocation_info.memoryTypeIndex = memory_type_index;
                if (vkAllocateMemory(device, &allocation_info, nullptr, &slot.memory) != VK_SUCCESS) {
                    throw mxvk::Exception("failed to allocate frame-readback memory");
                }
                if (vkBindBufferMemory(device, slot.buffer, slot.memory, 0) != VK_SUCCESS) {
                    throw mxvk::Exception("failed to bind frame-readback memory");
                }
                if (vkMapMemory(device, slot.memory, 0, required_size, 0, &slot.mapped) != VK_SUCCESS) {
                    throw mxvk::Exception("failed to map frame-readback memory");
                }
                slot.size = required_size;
            }
        } catch (...) {
            destroyFrameReadbackResources();
            throw;
        }
        latest_frame_readback_rgba.clear();
        latest_frame_readback_rgba16.clear();
        latest_frame_readback_width = 0;
        latest_frame_readback_height = 0;
    }
 
    void VK_Window::destroyFrameReadbackResources() {
        for (FrameReadbackSlot &slot : frame_readback_slots) {
            if (device != VK_NULL_HANDLE && slot.mapped != nullptr && slot.memory != VK_NULL_HANDLE) {
                vkUnmapMemory(device, slot.memory);
            }
            slot.mapped = nullptr;
            if (device != VK_NULL_HANDLE && slot.buffer != VK_NULL_HANDLE) {
                vkDestroyBuffer(device, slot.buffer, nullptr);
            }
            slot.buffer = VK_NULL_HANDLE;
            if (device != VK_NULL_HANDLE && slot.memory != VK_NULL_HANDLE) {
                vkFreeMemory(device, slot.memory, nullptr);
            }
            slot.memory = VK_NULL_HANDLE;
            slot.size = 0;
            slot.width = 0;
            slot.height = 0;
            slot.format = VK_FORMAT_UNDEFINED;
            slot.pending = false;
        }
        latest_frame_readback_rgba.clear();
        latest_frame_readback_rgba16.clear();
        latest_frame_readback_width = 0;
        latest_frame_readback_height = 0;
    }
 
    void VK_Window::proc() {}
 
    void VK_Window::trimMemory() {
        if (device == VK_NULL_HANDLE || command_pool == VK_NULL_HANDLE || vkTrimCommandPool == nullptr) {
            return;
        }
 
        vkTrimCommandPool(device, command_pool, 0);
    }
 
    void VK_Window::maybeTrimMemory() {
        const auto now = std::chrono::steady_clock::now();
        if ((now - last_memory_trim_time) < MEMORY_TRIM_INTERVAL) {
            return;
        }
 
        trimMemory();
        last_memory_trim_time = now;
    }
 
    bool VK_Window::initWindow(const std::string &title, int width, int height, SDL_WindowFlags flags) {
        std::cout << std::format("mxvk: entering initWindow (title='{}', width={}, height={})\n", title, width, height);
        if (width <= 0 || height <= 0) {
            std::cerr << "mxvk: Window dimensions must be positive\n";
            return false;
        }
 
        if (!sdl_initialized) {
            constexpr SDL_InitFlags sdlInitFlags = SDL_INIT_VIDEO | SDL_INIT_GAMEPAD;
            std::cout << "SDL3: initializing video/gamepad subsystems\n";
            if (!SDL_Init(sdlInitFlags)) {
                std::cerr << "mxvk: Error on SDL init: " << SDL_GetError() << "\n";
                return false;
            }
            sdl_initialized = true;
            SDL_SetGamepadEventsEnabled(true);
            SDL_SetJoystickEventsEnabled(true);
            std::cout << "SDL3: video/gamepad subsystems initialized\n";
        }
 
        if (!vulkan_library_loaded) {
            std::cout << "SDL3: loading the Vulkan loader library\n";
            if (!SDL_Vulkan_LoadLibrary(nullptr)) {
                std::cerr << std::format("mxvk: SDL_Vulkan_LoadLibrary failed: {}\n", SDL_GetError());
                SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD);
                sdl_initialized = false;
                return false;
            }
            vulkan_library_loaded = true;
        }
 
        const bool fullscreen = (flags & SDL_WINDOW_FULLSCREEN) != 0;
        const SDL_DisplayMode *fullscreen_mode = nullptr;
        if (fullscreen) {
            const SDL_DisplayID display = SDL_GetPrimaryDisplay();
            fullscreen_mode = display != 0 ? SDL_GetCurrentDisplayMode(display) : nullptr;
            if (fullscreen_mode != nullptr && fullscreen_mode->w > 0 && fullscreen_mode->h > 0) {
                width = fullscreen_mode->w;
                height = fullscreen_mode->h;
                std::cout << std::format("SDL3: using current display mode for fullscreen window: {}x{}\n", width, height);
            }
        }
 
        std::cout << "SDL3: creating SDL window with Vulkan capability\n";
        SDL_Window *raw_window = SDL_CreateWindow(title.c_str(), width, height, flags);
        if (raw_window == nullptr) {
            std::cerr << std::format("Error creating window: {}\n", SDL_GetError());
            SDL_Vulkan_UnloadLibrary();
            vulkan_library_loaded = false;
            std::cout << "SDL3: rolling back SDL video/gamepad subsystems after window creation failure\n";
            SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD);
            sdl_initialized = false;
            return false;
        }
 
        window.reset(raw_window);
        if (fullscreen && fullscreen_mode != nullptr && !SDL_SetWindowFullscreenMode(window.get(), fullscreen_mode)) {
            std::cerr << std::format("mxvk: SDL_SetWindowFullscreenMode failed: {}\n", SDL_GetError());
        }
        std::cout << "SDL3: showing created window\n";
        SDL_ShowWindow(window.get());
        if (fullscreen && !SDL_SyncWindow(window.get())) {
            std::cerr << std::format("mxvk: SDL_SyncWindow failed after fullscreen show: {}\n", SDL_GetError());
        }
        if (fullscreen) {
            for (int attempt = 0; attempt < 50; ++attempt) {
                int pixel_width = 0;
                int pixel_height = 0;
                SDL_GetWindowSizeInPixels(window.get(), &pixel_width, &pixel_height);
                if (pixel_width == width && pixel_height == height) {
                    break;
                }
                SDL_PumpEvents();
                SDL_Delay(10);
            }
        }
        std::cout << "mxvk: initWindow complete\n";
        return true;
    }
 
    void VK_Window::exit() { active = false; }
 
    void VK_Window::onSwapchainAboutToRecreate() {}
 
    void VK_Window::onSwapchainRecreated() {}
 
    void VK_Window::onPrepareFrameRendering([[maybe_unused]] VkCommandBuffer cmd, [[maybe_unused]] uint32_t image_index) {}
 
    void VK_Window::onRecordCustomRendering([[maybe_unused]] VkCommandBuffer cmd, [[maybe_unused]] uint32_t image_index) {}
 
    void VK_Window::onRecordPostProcessingTexture([[maybe_unused]] VkCommandBuffer cmd, [[maybe_unused]] uint32_t image_index, [[maybe_unused]] VkImageView texture_view, [[maybe_unused]] VkExtent2D texture_extent) {}
 
    void VK_Window::onConfigureDepthStencilAttachments([[maybe_unused]] VkRenderingAttachmentInfo &depth_attachment, [[maybe_unused]] VkRenderingAttachmentInfo &stencil_attachment, [[maybe_unused]] uint32_t image_index) {}
 
    void VK_Window::renderStandaloneSprite(VK_Sprite &sprite, VkCommandBuffer cmd) { renderStandaloneSprite(sprite, cmd, swapchain_extent); }
 
    void VK_Window::renderStandaloneSprite(VK_Sprite &sprite, VkCommandBuffer cmd, VkExtent2D extent) {
        if (device == VK_NULL_HANDLE || extent.width == 0U || extent.height == 0U) {
            return;
        }
 
        if (sprite_pipeline == VK_NULL_HANDLE) {
            return;
        }
        vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, sprite_pipeline);
        sprite.renderSprites(cmd, sprite_pipeline_layout, extent.width, extent.height);
    }
 
    void VK_Window::setRenderExtent(uint32_t width, uint32_t height) {
        if ((width == 0U) != (height == 0U)) {
            throw mxvk::Exception("render extent requires two positive dimensions or two zeros");
        }
        if (render_extent_override.width == width && render_extent_override.height == height) {
            return;
        }
        if (headless()) {
            if (width == 0U && height == 0U) {
                return;
            }
            if (requested_headless_extent.width == width && requested_headless_extent.height == height) {
                return;
            }
            if (device != VK_NULL_HANDLE) {
                vkDeviceWaitIdle(device);
                onSwapchainAboutToRecreate();
                destroyFrameReadbackResources();
                cleanupSyncObjects();
                cleanupSwapchain(false);
            }
            requested_headless_extent = {width, height};
            render_extent_override = {};
            sprite_state_dirty = true;
            text_state_dirty = true;
            if (device != VK_NULL_HANDLE) {
                createDevice();
                onSwapchainRecreated();
            }
            std::cout << std::format("mxvk: surface-free render extent {}x{}\n", width, height);
            return;
        }
        if (device != VK_NULL_HANDLE && swapchain != VK_NULL_HANDLE) {
            vkDeviceWaitIdle(device);
            destroyFrameReadbackResources();
            destroyPostProcessTargets();
        }
        render_extent_override = {width, height};
        sprite_state_dirty = true;
        if (device != VK_NULL_HANDLE && !swapchain_images.empty() && !post_process_sprites.empty()) {
            createPostProcessTargets();
        }
        std::cout << std::format("mxvk: fixed render extent {}\n", width > 0U ? std::format("{}x{}", width, height) : "disabled");
    }
 
    VkExtent2D VK_Window::getRenderExtent() const noexcept { return render_extent_override.width > 0U && render_extent_override.height > 0U ? render_extent_override : swapchain_extent; }
 
    void VK_Window::setHdrRenderIntermediatesEnabled(bool enabled) {
        if (hdr_render_intermediates_enabled == enabled) {
            return;
        }
        if (device != VK_NULL_HANDLE) {
            vkDeviceWaitIdle(device);
            destroyPostProcessTargets();
        }
        hdr_render_intermediates_enabled = enabled;
        sprite_state_dirty = true;
        if (device != VK_NULL_HANDLE && !swapchain_images.empty() && !post_process_sprites.empty()) {
            createPostProcessTargets();
        }
        std::cout << "mxvk: HDR render intermediates " << (enabled ? "enabled (RGBA16F)\n" : "disabled (RGBA8)\n");
    }
 
    VK_Sprite *VK_Window::attachPostProcessingShader(const std::string &fragmentShaderPath, float p1, float p2, float p3, float p4) {
        const std::vector<VK_Sprite *> sprites = attachPostProcessingShaders({PostProcessingEffect{fragmentShaderPath, {p1, p2, p3, p4}, false}});
        return sprites.empty() ? nullptr : sprites.front();
    }
 
    std::vector<VK_Sprite *> VK_Window::attachPostProcessingShaders(const std::vector<PostProcessingEffect> &effects) {
        detachPostProcessingShader();
 
        std::vector<VK_Sprite *> attachedSprites;
        attachedSprites.reserve(effects.size());
        for (size_t effect_index = 0; effect_index < effects.size(); ++effect_index) {
            const PostProcessingEffect &effect = effects[effect_index];
            if (effect.fragmentShaderPath.empty()) {
                throw mxvk::Exception("Cannot attach a post-processing pass with an empty shader path");
            }
 
            const ShaderModuleInfo module_info = inspect_spirv(load_spv(effect.fragmentShaderPath));
            const ShaderStage stage = effect.stage == ShaderStage::Unknown ? module_info.stage : effect.stage;
            if (stage != ShaderStage::Fragment && stage != ShaderStage::Compute) {
                throw mxvk::Exception("Post-processing shaders must contain a fragment or compute entry point");
            }
            if (effect.stage != ShaderStage::Unknown && effect.stage != module_info.stage) {
                throw mxvk::Exception("Post-processing shader stage does not match its SPIR-V entry point");
            }
 
            VK_Sprite *sprite = createSprite(1, 1, resolveRuntimeShaderPath("sprite.vert.spv", MXVK_SPRITE_SHADER_DIR), "", effect.spectrumBinCount, effect.spectrumHistoryLayerCount);
            sprite->enableExtendedUBO();
            if (effect.historySource != nullptr) {
                sprite->shareHistoryTexture(*effect.historySource);
            }
            const bool final_fragment = stage == ShaderStage::Fragment && effect_index + 1U == effects.size();
            if (stage == ShaderStage::Fragment) {
                if (!final_fragment || hdr_render_intermediates_enabled) {
                    sprite->setColorAttachmentFormat(postProcessIntermediateFormat());
                }
                sprite->setFragmentShaderPath(effect.fragmentShaderPath);
            } else if (stage == ShaderStage::Compute) {
                const StorageImageFormat required_format = hdr_render_intermediates_enabled ? StorageImageFormat::Rgba16Float : StorageImageFormat::Rgba8;
                if (module_info.storageImageFormat != required_format) {
                    throw mxvk::Exception(std::format("Compute shader '{}' must declare layout({}) for the "
                                                      "active {} render path",
                                                      effect.fragmentShaderPath,
                                                      hdr_render_intermediates_enabled ? "rgba16f" : "rgba8",
                                                      hdr_render_intermediates_enabled ? "HDR" : "SDR"));
                }
                sprite->enableComputeShader(effect.fragmentShaderPath, module_info.localSizeX, module_info.localSizeY, module_info.localSizeZ);
            }
            const uint32_t black_pixel = 0xFF000000u;
            sprite->updateTexture(&black_pixel, 1, 1);
            sprite->setShaderParams(effect.params[0], effect.params[1], effect.params[2], effect.params[3]);
 
            attachedSprites.push_back(sprite);
            owned_post_process_sprites.push_back(sprite);
            post_process_sprites.push_back(sprite);
            post_process_effect_params.push_back(effect.params);
            post_process_effect_time_enabled.push_back(effect.timeEnabled);
            post_process_effect_start_times.push_back(std::chrono::steady_clock::now());
            post_process_effect_stages.push_back(stage);
        }
 
        if (!post_process_effect_stages.empty()) {
            post_process_present_sprite = createSprite(1, 1, resolveRuntimeShaderPath("sprite.vert.spv", MXVK_SPRITE_SHADER_DIR));
            const uint32_t black_pixel = 0xFF000000u;
            post_process_present_sprite->updateTexture(&black_pixel, 1, 1);
            if (!post_process_present_shader_path.empty()) {
                post_process_present_sprite->setFragmentShaderPath(post_process_present_shader_path);
            }
            owned_post_process_sprites.push_back(post_process_present_sprite);
 
            post_process_composite_sprite = createSprite(1, 1);
            post_process_composite_sprite->updateTexture(&black_pixel, 1, 1);
            owned_post_process_sprites.push_back(post_process_composite_sprite);
        }
 
        post_process_sprite = attachedSprites.empty() ? nullptr : attachedSprites.front();
        owned_post_process_sprite = post_process_sprite;
        post_process_params = post_process_effect_params.empty() ? std::array<float, 4>{} : post_process_effect_params.front();
        post_process_time_enabled = !post_process_effect_time_enabled.empty() && post_process_effect_time_enabled.front();
        post_process_start_time = post_process_effect_start_times.empty() ? std::chrono::steady_clock::now() : post_process_effect_start_times.front();
        if (device != VK_NULL_HANDLE && !swapchain_images.empty()) {
            createPostProcessTargets();
        }
        sprite_state_dirty = true;
        return attachedSprites;
    }
 
    void VK_Window::setPostProcessingPresentFragmentShader(const std::string &path) {
        if (post_process_present_shader_path == path) {
            return;
        }
        post_process_present_shader_path = path;
        if (post_process_present_sprite != nullptr) {
            post_process_present_sprite->setFragmentShaderPath(path);
            sprite_state_dirty = true;
        }
    }
 
    void VK_Window::detachPostProcessingShader() {
        if (device != VK_NULL_HANDLE && !post_process_sprites.empty()) {
            vkDeviceWaitIdle(device);
        }
 
        post_process_sprite = nullptr;
        destroyPostProcessTargets();
        post_process_present_sprite = nullptr;
        post_process_composite_sprite = nullptr;
        post_process_time_enabled = false;
 
        if (!owned_post_process_sprites.empty()) {
            const std::vector<VK_Sprite *> sprites_to_remove = owned_post_process_sprites;
            sprites.erase(std::remove_if(sprites.begin(), sprites.end(), [&sprites_to_remove](const std::unique_ptr<VK_Sprite> &sprite) { return std::ranges::find(sprites_to_remove, sprite.get()) != sprites_to_remove.end(); }), sprites.end());
            sprite_state_dirty = true;
        }
        owned_post_process_sprite = nullptr;
        owned_post_process_sprites.clear();
        post_process_sprites.clear();
        post_process_effect_params.clear();
        post_process_effect_time_enabled.clear();
        post_process_effect_start_times.clear();
        post_process_effect_stages.clear();
    }
 
    void VK_Window::setPostProcessingShaderParams(float p1, float p2, float p3, float p4) {
        post_process_params = {p1, p2, p3, p4};
        if (post_process_sprites.empty()) {
            return;
        }
        setPostProcessingShaderParams(0, p1, p2, p3, p4);
    }
 
    void VK_Window::setPostProcessingShaderParams(size_t effectIndex, float p1, float p2, float p3, float p4) {
        if (effectIndex >= post_process_sprites.size()) {
            return;
        }
        post_process_params = {p1, p2, p3, p4};
        if (effectIndex < post_process_effect_params.size()) {
            post_process_effect_params[effectIndex] = post_process_params;
        }
        if (post_process_sprites[effectIndex] != nullptr) {
            post_process_sprites[effectIndex]->setShaderParams(p1, p2, p3, p4);
        }
    }
 
    void VK_Window::setPostProcessingShaderTimeEnabled(bool enabled) {
        post_process_time_enabled = enabled;
        post_process_start_time = std::chrono::steady_clock::now();
        if (post_process_sprites.empty()) {
            return;
        }
        setPostProcessingShaderTimeEnabled(0, enabled);
    }
 
    void VK_Window::setPostProcessingShaderTimeEnabled(size_t effectIndex, bool enabled) {
        if (effectIndex >= post_process_sprites.size()) {
            return;
        }
        post_process_time_enabled = enabled;
        post_process_start_time = std::chrono::steady_clock::now();
        if (effectIndex < post_process_effect_time_enabled.size()) {
            post_process_effect_time_enabled[effectIndex] = enabled;
        }
        if (effectIndex < post_process_effect_start_times.size()) {
            post_process_effect_start_times[effectIndex] = post_process_start_time;
        }
    }
 
    void VK_Window::enablePostProcessing(VK_Sprite *sprite) {
        if (owned_post_process_sprite != nullptr && sprite != owned_post_process_sprite) {
            std::vector<VK_Sprite *> sprites_to_remove = owned_post_process_sprites;
            if (sprites_to_remove.empty()) {
                sprites_to_remove.push_back(owned_post_process_sprite);
            }
            sprites.erase(std::remove_if(sprites.begin(), sprites.end(), [&sprites_to_remove](const std::unique_ptr<VK_Sprite> &existing_sprite) { return std::ranges::find(sprites_to_remove, existing_sprite.get()) != sprites_to_remove.end(); }), sprites.end());
            owned_post_process_sprite = nullptr;
            owned_post_process_sprites.clear();
            sprite_state_dirty = true;
        }
        post_process_sprite = sprite;
        post_process_sprites = sprite == nullptr ? std::vector<VK_Sprite *>{} : std::vector<VK_Sprite *>{sprite};
        post_process_effect_params.assign(post_process_sprites.size(), post_process_params);
        post_process_effect_time_enabled.assign(post_process_sprites.size(), post_process_time_enabled);
        post_process_effect_start_times.assign(post_process_sprites.size(), post_process_start_time);
        if (device != VK_NULL_HANDLE && !swapchain_images.empty()) {
            createPostProcessTargets();
        }
    }
 
    bool VK_Window::isPostProcessSprite(const VK_Sprite *sprite) const { return sprite != nullptr && (sprite == post_process_present_sprite || sprite == post_process_composite_sprite || std::ranges::find(post_process_sprites, sprite) != post_process_sprites.end()); }
 
    void VK_Window::destroyPostProcessTargets() {
        for (VK_Sprite *sprite : post_process_sprites) {
            if (sprite != nullptr) {
                sprite->clearExternalTextureDescriptors();
            }
        }
        if (post_process_present_sprite != nullptr) {
            post_process_present_sprite->clearExternalTextureDescriptors();
        }
        if (post_process_composite_sprite != nullptr) {
            post_process_composite_sprite->clearExternalTextureDescriptors();
        }
        for (const std::vector<VkImageView> &views : post_process_views) {
            for (VkImageView view : views) {
                if (view != VK_NULL_HANDLE) {
                    vkDestroyImageView(device, view, nullptr);
                }
            }
        }
        for (const std::vector<VkImage> &images : post_process_images) {
            for (VkImage image : images) {
                if (image != VK_NULL_HANDLE) {
                    vkDestroyImage(device, image, nullptr);
                }
            }
        }
        for (const std::vector<VkDeviceMemory> &memories : post_process_memories) {
            for (VkDeviceMemory memory : memories) {
                if (memory != VK_NULL_HANDLE) {
                    vkFreeMemory(device, memory, nullptr);
                }
            }
        }
        post_process_views.clear();
        post_process_images.clear();
        post_process_memories.clear();
        post_process_initialized.clear();
    }
 
    void VK_Window::createPostProcessTargets() {
        destroyPostProcessTargets();
        if (post_process_sprites.empty() || swapchain_images.empty()) {
            return;
        }
        const bool has_compute = std::ranges::find(post_process_effect_stages, ShaderStage::Compute) != post_process_effect_stages.end();
        const bool detached_render = render_extent_override.width > 0U && render_extent_override.height > 0U;
        size_t target_count = 1U;
        if (hdr_render_intermediates_enabled) {
            target_count = 4U;
        } else if (detached_render || has_compute || post_process_sprites.size() > 1) {
            target_count = 3U;
        }
        const VkExtent2D render_extent = getRenderExtent();
        if (hdr_render_intermediates_enabled || has_compute) {
            VkFormatProperties format_properties{};
            vkGetPhysicalDeviceFormatProperties(physical_device, postProcessIntermediateFormat(), &format_properties);
            VkFormatFeatureFlags required_features = VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
            if (has_compute) {
                required_features |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
            }
            if ((format_properties.optimalTilingFeatures & required_features) != required_features) {
                throw mxvk::Exception("The selected compute post-processing format is unsupported on this device");
            }
        }
        post_process_images.assign(target_count, std::vector<VkImage>(swapchain_images.size(), VK_NULL_HANDLE));
        post_process_memories.assign(target_count, std::vector<VkDeviceMemory>(swapchain_images.size(), VK_NULL_HANDLE));
        post_process_views.assign(target_count, std::vector<VkImageView>(swapchain_images.size(), VK_NULL_HANDLE));
        post_process_initialized.assign(target_count, std::vector<bool>(swapchain_images.size(), false));
        VkPhysicalDeviceMemoryProperties memory_properties{};
        vkGetPhysicalDeviceMemoryProperties(physical_device, &memory_properties);
        try {
            for (size_t target = 0; target < target_count; ++target) {
                for (size_t i = 0; i < swapchain_images.size(); ++i) {
                    VkImageCreateInfo image_info{};
                    image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
                    image_info.imageType = VK_IMAGE_TYPE_2D;
                    image_info.extent = {render_extent.width, render_extent.height, 1};
                    image_info.mipLevels = 1;
                    image_info.arrayLayers = 1;
                    image_info.format = target == 0U ? swapchain_format : postProcessIntermediateFormat();
                    image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
                    image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
                    image_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
                    if (target != 0U && has_compute) {
                        image_info.usage |= VK_IMAGE_USAGE_STORAGE_BIT;
                    }
                    image_info.samples = VK_SAMPLE_COUNT_1_BIT;
                    image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
                    if (vkCreateImage(device, &image_info, nullptr, &post_process_images[target][i]) != VK_SUCCESS) {
                        throw mxvk::Exception("Failed to create post-process image");
                    }
                    VkMemoryRequirements requirements{};
                    vkGetImageMemoryRequirements(device, post_process_images[target][i], &requirements);
                    uint32_t memory_type = UINT32_MAX;
                    for (uint32_t type = 0; type < memory_properties.memoryTypeCount; ++type) {
                        if ((requirements.memoryTypeBits & (1U << type)) != 0U && (memory_properties.memoryTypes[type].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0U) {
                            memory_type = type;
                            break;
                        }
                    }
                    if (memory_type == UINT32_MAX) {
                        throw mxvk::Exception("Failed to find post-process image memory type");
                    }
                    VkMemoryAllocateInfo allocation{};
                    allocation.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
                    allocation.allocationSize = requirements.size;
                    allocation.memoryTypeIndex = memory_type;
                    if (vkAllocateMemory(device, &allocation, nullptr, &post_process_memories[target][i]) != VK_SUCCESS || vkBindImageMemory(device, post_process_images[target][i], post_process_memories[target][i], 0) != VK_SUCCESS) {
                        throw mxvk::Exception("Failed to allocate post-process image memory");
                    }
                    VkImageViewCreateInfo view_info{};
                    view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
                    view_info.image = post_process_images[target][i];
                    view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
                    view_info.format = target == 0U ? swapchain_format : postProcessIntermediateFormat();
                    view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
                    view_info.subresourceRange.levelCount = 1;
                    view_info.subresourceRange.layerCount = 1;
                    if (vkCreateImageView(device, &view_info, nullptr, &post_process_views[target][i]) != VK_SUCCESS) {
                        throw mxvk::Exception("Failed to create post-process image view");
                    }
                }
            }
        } catch (...) {
            destroyPostProcessTargets();
            throw;
        }
    }
 
    bool VK_Window::ensureRenderResources() {
        const auto sync_ready = [this]() { return std::ranges::all_of(image_available.begin(), image_available.end(), [](VkSemaphore semaphore) { return semaphore != VK_NULL_HANDLE; }) && render_finished.size() == swapchain_images.size() && std::ranges::all_of(render_finished.begin(), render_finished.end(), [](VkSemaphore semaphore) { return semaphore != VK_NULL_HANDLE; }) && std::ranges::all_of(in_flight_fences.begin(), in_flight_fences.end(), [](VkFence fence) { return fence != VK_NULL_HANDLE; }); };
 
        if (device == VK_NULL_HANDLE) {
            return false;
        }
 
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE || command_buffers.empty() || !sync_ready() || image_fences.size() != swapchain_images.size()) {
            createDevice();
        }
 
        return (renderTargetsReady() && command_pool != VK_NULL_HANDLE && !command_buffers.empty() && sync_ready() && image_fences.size() == swapchain_images.size());
    }
 
    bool VK_Window::renderTargetsReady() const noexcept {
        if (headless()) {
            return !swapchain_images.empty() && swapchain_images.size() == swapchain_image_views.size() && swapchain_images.size() == headless_image_memories.size();
        }
        return swapchain != VK_NULL_HANDLE;
    }
 
    void VK_Window::pickDevice() {
        std::cout << "mxvk: entering pickDevice\n";
        if (instance == VK_NULL_HANDLE || (!headless() && surface == VK_NULL_HANDLE)) {
            std::cout << "vk: cannot pick device because required instance state is missing\n";
            return;
        }
 
        uint32_t device_count = 0;
        std::cout << "vk: enumerating physical devices\n";
        vkEnumeratePhysicalDevices(instance, &device_count, nullptr);
        if (device_count == 0U) {
            std::cout << "vk: no physical devices found\n";
            return;
        }
        std::cout << std::format("vk: found {} physical device(s)\n", device_count);
 
        std::vector<VkPhysicalDevice> devices(device_count);
        vkEnumeratePhysicalDevices(instance, &device_count, devices.data());
 
        for (const VkPhysicalDevice candidate : devices) {
            std::cout << "vk: evaluating candidate physical device\n";
            uint32_t queue_family_count = 0;
            vkGetPhysicalDeviceQueueFamilyProperties(candidate, &queue_family_count, nullptr);
            std::vector<VkQueueFamilyProperties> queue_families(queue_family_count);
            vkGetPhysicalDeviceQueueFamilyProperties(candidate, &queue_family_count, queue_families.data());
 
            uint32_t candidate_graphics = invalid_queue_index;
            uint32_t candidate_present = invalid_queue_index;
 
            for (uint32_t i = 0; i < queue_family_count; ++i) {
                if ((queue_families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) != 0U) {
                    candidate_graphics = i;
                }
 
                if (!headless()) {
                    VkBool32 present_support = VK_FALSE;
                    vkGetPhysicalDeviceSurfaceSupportKHR(candidate, i, surface, &present_support);
                    if (present_support == VK_TRUE) {
                        candidate_present = i;
                    }
                }
            }
 
            if (headless()) {
                candidate_present = candidate_graphics;
            }
 
            if (candidate_graphics == invalid_queue_index || candidate_present == invalid_queue_index) {
                std::cout << "vk: candidate rejected due to missing graphics/present queue support\n";
                continue;
            }
 
            if (!headless()) {
                const SwapchainSupport swapchain_support = querySwapchainSupport(candidate, surface);
                if (swapchain_support.formats.empty() || swapchain_support.present_modes.empty()) {
                    std::cout << "vk: candidate rejected due to incomplete swapchain support\n";
                    continue;
                }
            }
 
            VkPhysicalDeviceProperties properties{};
            vkGetPhysicalDeviceProperties(candidate, &properties);
 
            const char *device_type = "unknown";
            switch (properties.deviceType) {
            case VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU:
                device_type = "integrated";
                break;
            case VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU:
                device_type = "discrete";
                break;
            case VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU:
                device_type = "virtual";
                break;
            case VK_PHYSICAL_DEVICE_TYPE_CPU:
                device_type = "cpu";
                break;
            default:
                break;
            }
 
            physical_device = candidate;
            graphics_queue_family = candidate_graphics;
            present_queue_family = candidate_present;
            std::cout << std::format("vk: selected GPU='{}' type={} vendor=0x{:04x} device=0x{:04x}\n", properties.deviceName, device_type, properties.vendorID, properties.deviceID);
            return;
        }
 
        std::cout << "vk: no suitable physical device selected\n";
    }
    void VK_Window::createLogicalDevice() {
        std::cout << "mxvk: entering createLogicalDevice\n";
        if (physical_device == VK_NULL_HANDLE) {
            std::cout << "vk: cannot create logical device without a selected physical device\n";
            return;
        }
 
        std::vector<uint32_t> queue_families{};
        queue_families.push_back(graphics_queue_family);
        if (present_queue_family != graphics_queue_family) {
            queue_families.push_back(present_queue_family);
        }
 
        constexpr float queue_priority = 1.0f;
        std::vector<VkDeviceQueueCreateInfo> queue_create_infos{};
        queue_create_infos.reserve(queue_families.size());
        for (const uint32_t family : queue_families) {
            VkDeviceQueueCreateInfo queue_create_info{};
            queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
            queue_create_info.queueFamilyIndex = family;
            queue_create_info.queueCount = 1;
            queue_create_info.pQueuePriorities = &queue_priority;
            queue_create_infos.push_back(queue_create_info);
        }
        uint32_t device_extension_count = 0;
        vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &device_extension_count, nullptr);
        std::vector<VkExtensionProperties> device_extensions(device_extension_count);
        if (device_extension_count > 0U) {
            vkEnumerateDeviceExtensionProperties(physical_device, nullptr, &device_extension_count, device_extensions.data());
        }
 
        [[maybe_unused]] const auto has_device_extension = [&device_extensions](const char *extension_name) { return std::ranges::any_of(device_extensions, [extension_name](const VkExtensionProperties &ext) { return std::strcmp(ext.extensionName, extension_name) == 0; }); };
 
        std::vector<const char *> required_device_extensions{};
        if (!headless()) {
            required_device_extensions.push_back(VK_KHR_SWAPCHAIN_EXTENSION_NAME);
        }
#if defined(MXVK_CUDA) && defined(__linux__)
        if (has_device_extension(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME)) {
            if (has_device_extension(VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME)) {
                required_device_extensions.push_back(VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME);
            }
            required_device_extensions.push_back(VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME);
            std::cout << "vk: enabling external memory FD support for CUDA interop\n";
        } else {
            std::cout << "vk: external memory FD support unavailable; CUDA texture interop will fall back\n";
        }
#endif
 
#if defined(MXVK_USE_MOLTENVK)
        const bool has_portability_subset = std::ranges::any_of(device_extensions, [](const VkExtensionProperties &ext) { return std::strcmp(ext.extensionName, VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME) == 0; });
 
        if (has_portability_subset) {
            required_device_extensions.push_back(VK_KHR_PORTABILITY_SUBSET_EXTENSION_NAME);
        }
#endif
        VkPhysicalDeviceFeatures2 features2{};
        features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
        VkPhysicalDeviceVulkan13Features supported_vulkan13_features{};
        supported_vulkan13_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
        features2.pNext = &supported_vulkan13_features;
        vkGetPhysicalDeviceFeatures2(physical_device, &features2);
 
        std::cout << std::format("vk: feature support - synchronization2={}, dynamicRendering={}, shaderFloat64={}, fillModeNonSolid={}, samplerAnisotropy={}\n", supported_vulkan13_features.synchronization2 == VK_TRUE ? "true" : "false", supported_vulkan13_features.dynamicRendering == VK_TRUE ? "true" : "false", features2.features.shaderFloat64 == VK_TRUE ? "true" : "false", features2.features.fillModeNonSolid == VK_TRUE ? "true" : "false", features2.features.samplerAnisotropy == VK_TRUE ? "true" : "false");
 
        if (supported_vulkan13_features.synchronization2 != VK_TRUE) {
            std::cout << "vk: synchronization2 is unsupported on selected physical device\n";
            return;
        }
        if (supported_vulkan13_features.dynamicRendering != VK_TRUE) {
            std::cout << "vk: dynamic rendering is unsupported on selected physical device\n";
            return;
        }
        VkPhysicalDeviceVulkan13Features vulkan13_features{};
        vulkan13_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES;
        vulkan13_features.synchronization2 = VK_TRUE;
        vulkan13_features.dynamicRendering = VK_TRUE;
 
        VkPhysicalDeviceFeatures2 enabled_features2{};
        enabled_features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
        enabled_features2.features.shaderFloat64 = features2.features.shaderFloat64;
        enabled_features2.features.fillModeNonSolid = features2.features.fillModeNonSolid;
        enabled_features2.features.samplerAnisotropy = features2.features.samplerAnisotropy;
 
        enabled_features2.pNext = &vulkan13_features;
 
        VkDeviceCreateInfo create_info{};
        create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
        create_info.pNext = &enabled_features2;
        create_info.queueCreateInfoCount = static_cast<uint32_t>(queue_create_infos.size());
        create_info.pQueueCreateInfos = queue_create_infos.data();
        create_info.enabledExtensionCount = static_cast<uint32_t>(required_device_extensions.size());
        create_info.ppEnabledExtensionNames = required_device_extensions.data();
        create_info.enabledLayerCount = 0;
        create_info.ppEnabledLayerNames = nullptr;
        create_info.pEnabledFeatures = nullptr;
 
        std::cout << "vk: creating logical device\n";
        const VkResult create_device_result = vkCreateDevice(physical_device, &create_info, nullptr, &device);
        if (create_device_result != VK_SUCCESS) {
            std::cerr << std::format("vk: logical device creation failed (VkResult={})", static_cast<int>(create_device_result));
            if (!required_device_extensions.empty()) {
                std::cerr << "; requested extensions:";
                for (const char *extension_name : required_device_extensions) {
                    std::cerr << ' ' << extension_name;
                }
            }
            std::cerr << '\n';
            device = VK_NULL_HANDLE;
            return;
        }
 
        std::cout << "vk: loading device-level function pointers via volk\n";
        volkLoadDevice(device);
        if (vkQueueSubmit2 == nullptr || vkCmdBeginRendering == nullptr || vkCmdEndRendering == nullptr || vkCmdPipelineBarrier2 == nullptr) {
            std::cout << "vk: required dynamic rendering/synchronization function pointers are unavailable\n";
            vkDestroyDevice(device, nullptr);
            device = VK_NULL_HANDLE;
            return;
        }
        std::cout << (headless() ? "vk: retrieving graphics queue\n" : "vk: retrieving graphics and present queues\n");
        vkGetDeviceQueue(device, graphics_queue_family, 0, &graphics_queue);
        if (headless()) {
            present_queue = graphics_queue;
        } else {
            vkGetDeviceQueue(device, present_queue_family, 0, &present_queue);
        }
        std::cout << "mxvk: createLogicalDevice complete\n";
    }
 
    void VK_Window::createDevice() {
        std::cout << "mxvk: entering createDevice\n";
        if (device == VK_NULL_HANDLE) {
            std::cout << "vk: skipping createDevice because logical device is null\n";
            return;
        }
 
        const bool sync_ready = std::ranges::all_of(image_available.begin(), image_available.end(), [](VkSemaphore semaphore) { return semaphore != VK_NULL_HANDLE; }) && render_finished.size() == swapchain_images.size() && std::ranges::all_of(render_finished.begin(), render_finished.end(), [](VkSemaphore semaphore) { return semaphore != VK_NULL_HANDLE; }) && std::ranges::all_of(in_flight_fences.begin(), in_flight_fences.end(), [](VkFence fence) { return fence != VK_NULL_HANDLE; });
 
        if (renderTargetsReady() && command_pool != VK_NULL_HANDLE && !command_buffers.empty() && sync_ready && image_fences.size() == swapchain_images.size()) {
            std::cout << "vk: createDevice skipped because render resources are already initialized\n";
            return;
        }
 
        if (headless()) {
            std::cout << "vk: creating surface-free color targets\n";
            if (!createHeadlessTargets()) {
                std::cout << "vk: createHeadlessTargets failed\n";
                return;
            }
        } else {
            std::cout << "vk: creating swapchain\n";
            if (!createSwapchain(VK_NULL_HANDLE)) {
                std::cout << "vk: createSwapchain failed\n";
                return;
            }
        }
 
        std::cout << "vk: creating render resources\n";
        if (!createRenderResources()) {
            std::cout << "vk: createRenderResources failed\n";
            return;
        }
 
        std::cout << "vk: creating synchronization objects\n";
        if (!createSyncObjects()) {
            std::cout << "vk: createSyncObjects failed\n";
            return;
        }
 
        std::cout << "mxvk: createDevice complete\n";
    }
 
    bool VK_Window::createSwapchain(VkSwapchainKHR old_swapchain) {
        std::cout << "vk: entering createSwapchain\n";
        SwapchainSupport support = querySwapchainSupport(physical_device, surface);
        if (support.formats.empty() || support.present_modes.empty()) {
            std::cout << "vk: cannot create swapchain because support is incomplete\n";
            return false;
        }
 
        const VkSurfaceFormatKHR surface_format = chooseSurfaceFormat(support.formats);
        const VkPresentModeKHR present_mode = choosePresentMode(support.present_modes);
        auto clampedWindowPixelExtent = [this, &support]() -> std::optional<VkExtent2D> {
            if (window == nullptr) {
                return std::nullopt;
            }
            int pixel_w = 0;
            int pixel_h = 0;
            SDL_GetWindowSizeInPixels(window.get(), &pixel_w, &pixel_h);
            if (pixel_w <= 0 || pixel_h <= 0) {
                return std::nullopt;
            }
            return VkExtent2D{
                .width = std::clamp(static_cast<uint32_t>(pixel_w), support.capabilities.minImageExtent.width, support.capabilities.maxImageExtent.width),
                .height = std::clamp(static_cast<uint32_t>(pixel_h), support.capabilities.minImageExtent.height, support.capabilities.maxImageExtent.height),
            };
        };
        auto extentMatchesWindowPixels = [&clampedWindowPixelExtent](const VkExtent2D extent) {
            const std::optional<VkExtent2D> target_extent = clampedWindowPixelExtent();
            return !target_extent.has_value() || (extent.width == target_extent->width && extent.height == target_extent->height);
        };
 
        VkExtent2D extent = chooseExtent(support.capabilities, window.get());
        for (int attempt = 0; attempt < 50 && !extentMatchesWindowPixels(extent); ++attempt) {
            SDL_PumpEvents();
            SDL_Delay(10);
            vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, surface, &support.capabilities);
            extent = chooseExtent(support.capabilities, window.get());
        }
        if (!extentMatchesWindowPixels(extent)) {
            const std::optional<VkExtent2D> target_extent = clampedWindowPixelExtent();
            if (target_extent.has_value()) {
                std::cout << std::format("vk: delaying swapchain creation until surface extent catches up to window pixels (surface={}x{}, window={}x{})\n", extent.width, extent.height, target_extent->width, target_extent->height);
            }
            return false;
        }
 
        uint32_t image_count = support.capabilities.minImageCount + 1;
        if (support.capabilities.maxImageCount > 0U && image_count > support.capabilities.maxImageCount) {
            image_count = support.capabilities.maxImageCount;
        }
 
        VkSwapchainCreateInfoKHR create_info{};
        create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
        create_info.surface = surface;
        create_info.minImageCount = image_count;
        create_info.imageFormat = surface_format.format;
        create_info.imageColorSpace = surface_format.colorSpace;
        create_info.imageExtent = extent;
        create_info.imageArrayLayers = 1;
        create_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
        swapchain_supports_transfer_src = (support.capabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) != 0U;
        if (swapchain_supports_transfer_src) {
            create_info.imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
        } else {
            std::cerr << "mxvk: swapchain does not support transfer-source usage; saveSnapshot is unavailable\n";
        }
 
        const uint32_t queue_family_indices[] = {graphics_queue_family, present_queue_family};
        if (graphics_queue_family != present_queue_family) {
            create_info.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
            create_info.queueFamilyIndexCount = 2;
            create_info.pQueueFamilyIndices = queue_family_indices;
        } else {
            create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
            create_info.queueFamilyIndexCount = 0;
            create_info.pQueueFamilyIndices = nullptr;
        }
 
        create_info.preTransform = support.capabilities.currentTransform;
        create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
        create_info.presentMode = present_mode;
        create_info.clipped = VK_TRUE;
        create_info.oldSwapchain = old_swapchain;
 
        std::cout << "vk: creating swapchain object\n";
        if (vkCreateSwapchainKHR(device, &create_info, nullptr, &swapchain) != VK_SUCCESS) {
            swapchain = VK_NULL_HANDLE;
            return false;
        }
 
        std::cout << "vk: querying swapchain images\n";
        vkGetSwapchainImagesKHR(device, swapchain, &image_count, nullptr);
        swapchain_images.resize(image_count);
        vkGetSwapchainImagesKHR(device, swapchain, &image_count, swapchain_images.data());
        swapchain_image_initialized.assign(swapchain_images.size(), false);
 
        swapchain_format = surface_format.format;
        swapchain_extent = extent;
        last_presented_image_index = invalid_queue_index;
 
        swapchain_image_views.resize(swapchain_images.size());
        for (size_t i = 0; i < swapchain_images.size(); ++i) {
            VkImageViewCreateInfo view_info{};
            view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
            view_info.image = swapchain_images[i];
            view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
            view_info.format = swapchain_format;
            view_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
            view_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
            view_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
            view_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
            view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            view_info.subresourceRange.baseMipLevel = 0;
            view_info.subresourceRange.levelCount = 1;
            view_info.subresourceRange.baseArrayLayer = 0;
            view_info.subresourceRange.layerCount = 1;
 
            std::cout << std::format("vk: creating image view for swapchain image {}\n", i);
            if (vkCreateImageView(device, &view_info, nullptr, &swapchain_image_views[i]) != VK_SUCCESS) {
                for (VkImageView image_view : swapchain_image_views) {
                    if (image_view != VK_NULL_HANDLE) {
                        vkDestroyImageView(device, image_view, nullptr);
                    }
                }
                swapchain_image_views.clear();
                swapchain_images.clear();
                swapchain_image_initialized.clear();
                last_presented_image_index = invalid_queue_index;
                vkDestroySwapchainKHR(device, swapchain, nullptr);
                swapchain = VK_NULL_HANDLE;
                swapchain_format = VK_FORMAT_UNDEFINED;
                swapchain_extent = {};
                swapchain_supports_transfer_src = false;
                return false;
            }
        }
 
        std::cout << "vk: createSwapchain complete\n";
        return true;
    }
 
    bool VK_Window::createHeadlessTargets() {
        if (!headless() || device == VK_NULL_HANDLE || physical_device == VK_NULL_HANDLE || requested_headless_extent.width == 0U || requested_headless_extent.height == 0U) {
            return false;
        }
        if (renderTargetsReady()) {
            return true;
        }
 
        swapchain_format = VK_FORMAT_R8G8B8A8_UNORM;
        swapchain_extent = requested_headless_extent;
        swapchain_supports_transfer_src = true;
        constexpr size_t HEADLESS_TARGET_COUNT = max_frames_in_flight;
        swapchain_images.assign(HEADLESS_TARGET_COUNT, VK_NULL_HANDLE);
        headless_image_memories.assign(HEADLESS_TARGET_COUNT, VK_NULL_HANDLE);
        swapchain_image_views.assign(HEADLESS_TARGET_COUNT, VK_NULL_HANDLE);
        swapchain_image_initialized.assign(HEADLESS_TARGET_COUNT, false);
 
        VkPhysicalDeviceMemoryProperties memory_properties{};
        vkGetPhysicalDeviceMemoryProperties(physical_device, &memory_properties);
        try {
            for (size_t index = 0; index < HEADLESS_TARGET_COUNT; ++index) {
                VkImageCreateInfo image_info{};
                image_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
                image_info.imageType = VK_IMAGE_TYPE_2D;
                image_info.extent = {swapchain_extent.width, swapchain_extent.height, 1};
                image_info.mipLevels = 1;
                image_info.arrayLayers = 1;
                image_info.format = swapchain_format;
                image_info.tiling = VK_IMAGE_TILING_OPTIMAL;
                image_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
                image_info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
                image_info.samples = VK_SAMPLE_COUNT_1_BIT;
                image_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
                if (vkCreateImage(device, &image_info, nullptr, &swapchain_images[index]) != VK_SUCCESS) {
                    throw mxvk::Exception("Failed to create a headless color image");
                }
 
                VkMemoryRequirements requirements{};
                vkGetImageMemoryRequirements(device, swapchain_images[index], &requirements);
                uint32_t memory_type = invalid_queue_index;
                for (uint32_t type = 0; type < memory_properties.memoryTypeCount; ++type) {
                    const bool type_matches = (requirements.memoryTypeBits & (1U << type)) != 0U;
                    const bool device_local = (memory_properties.memoryTypes[type].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0U;
                    if (type_matches && device_local) {
                        memory_type = type;
                        break;
                    }
                }
                if (memory_type == invalid_queue_index) {
                    throw mxvk::Exception("Failed to find headless image memory");
                }
 
                VkMemoryAllocateInfo allocation_info{};
                allocation_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
                allocation_info.allocationSize = requirements.size;
                allocation_info.memoryTypeIndex = memory_type;
                if (vkAllocateMemory(device, &allocation_info, nullptr, &headless_image_memories[index]) != VK_SUCCESS) {
                    throw mxvk::Exception("Failed to allocate headless image memory");
                }
                if (vkBindImageMemory(device, swapchain_images[index], headless_image_memories[index], 0) != VK_SUCCESS) {
                    throw mxvk::Exception("Failed to bind headless image memory");
                }
 
                VkImageViewCreateInfo view_info{};
                view_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
                view_info.image = swapchain_images[index];
                view_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
                view_info.format = swapchain_format;
                view_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
                view_info.subresourceRange.levelCount = 1;
                view_info.subresourceRange.layerCount = 1;
                if (vkCreateImageView(device, &view_info, nullptr, &swapchain_image_views[index]) != VK_SUCCESS) {
                    throw mxvk::Exception("Failed to create a headless image view");
                }
            }
        } catch (const mxvk::Exception &ex) {
            std::cerr << std::format("mxvk: {}\n", ex.text());
            cleanupSwapchain(false);
            return false;
        }
 
        next_headless_image = 0;
        last_presented_image_index = invalid_queue_index;
        std::cout << std::format("vk: created {} surface-free color targets ({}x{}, RGBA8)\n", HEADLESS_TARGET_COUNT, swapchain_extent.width, swapchain_extent.height);
        return true;
    }
 
    bool VK_Window::createRenderResources() {
        std::cout << "vk: entering createRenderResources\n";
        const auto cleanup_render_resource_failure = [this]() {
            if (command_pool != VK_NULL_HANDLE && !command_buffers.empty()) {
                vkFreeCommandBuffers(device, command_pool, static_cast<uint32_t>(command_buffers.size()), command_buffers.data());
                command_buffers.clear();
            }
            if (!depth_image_views.empty()) {
                for (VkImageView &view : depth_image_views) {
                    if (view != VK_NULL_HANDLE) {
                        vkDestroyImageView(device, view, nullptr);
                        view = VK_NULL_HANDLE;
                    }
                }
            }
            if (!depth_images.empty()) {
                for (VkImage &image : depth_images) {
                    if (image != VK_NULL_HANDLE) {
                        vkDestroyImage(device, image, nullptr);
                        image = VK_NULL_HANDLE;
                    }
                }
            }
            if (!depth_image_memories.empty()) {
                for (VkDeviceMemory &memory : depth_image_memories) {
                    if (memory != VK_NULL_HANDLE) {
                        vkFreeMemory(device, memory, nullptr);
                        memory = VK_NULL_HANDLE;
                    }
                }
            }
            depth_image_views.clear();
            depth_images.clear();
            depth_image_memories.clear();
            depth_image_initialized.clear();
            depth_format = VK_FORMAT_UNDEFINED;
            destroyPostProcessTargets();
        };
 
        if (command_pool == VK_NULL_HANDLE) {
            VkCommandPoolCreateInfo pool_info{};
            pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
            pool_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
            pool_info.queueFamilyIndex = graphics_queue_family;
 
            std::cout << "vk: creating command pool\n";
            if (vkCreateCommandPool(device, &pool_info, nullptr, &command_pool) != VK_SUCCESS) {
                return false;
            }
        }
 
        if (!command_buffers.empty()) {
            std::cout << "vk: freeing stale command buffers before reallocation\n";
            vkFreeCommandBuffers(device, command_pool, static_cast<uint32_t>(command_buffers.size()), command_buffers.data());
            command_buffers.clear();
        }
 
        command_buffers.resize(swapchain_images.size());
        VkCommandBufferAllocateInfo alloc_info{};
        alloc_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
        alloc_info.commandPool = command_pool;
        alloc_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
        alloc_info.commandBufferCount = static_cast<uint32_t>(command_buffers.size());
 
        std::cout << "vk: allocating command buffers\n";
        if (vkAllocateCommandBuffers(device, &alloc_info, command_buffers.data()) != VK_SUCCESS) {
            command_buffers.clear();
            return false;
        }
 
        auto findDepthFormat = [&](VkPhysicalDevice gpu) -> VkFormat {
            const std::array<VkFormat, 2> candidates = {
                VK_FORMAT_D32_SFLOAT,
                VK_FORMAT_D16_UNORM,
            };
 
            for (const VkFormat format : candidates) {
                VkFormatProperties props{};
                vkGetPhysicalDeviceFormatProperties(gpu, format, &props);
                if ((props.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) != 0U) {
                    return format;
                }
            }
 
            return VK_FORMAT_UNDEFINED;
        };
 
        depth_format = findDepthFormat(physical_device);
        if (depth_format == VK_FORMAT_UNDEFINED) {
            std::cerr << "mxvk: failed to find a supported depth format\n";
            cleanup_render_resource_failure();
            return false;
        }
 
        depth_images.resize(max_frames_in_flight, VK_NULL_HANDLE);
        depth_image_memories.resize(max_frames_in_flight, VK_NULL_HANDLE);
        depth_image_views.resize(max_frames_in_flight, VK_NULL_HANDLE);
        depth_image_initialized.assign(max_frames_in_flight, false);
 
        const VkExtent2D render_extent = getRenderExtent();
        for (size_t i = 0; i < depth_images.size(); ++i) {
            std::cout << std::format("vk: creating depth image for frame {}\n", i);
            VkImageCreateInfo imageInfo{};
            imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
            imageInfo.imageType = VK_IMAGE_TYPE_2D;
            imageInfo.extent.width = render_extent.width;
            imageInfo.extent.height = render_extent.height;
            imageInfo.extent.depth = 1;
            imageInfo.mipLevels = 1;
            imageInfo.arrayLayers = 1;
            imageInfo.format = depth_format;
            imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
            imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
            imageInfo.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
            imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
            imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
 
            if (vkCreateImage(device, &imageInfo, nullptr, &depth_images[i]) != VK_SUCCESS) {
                std::cerr << std::format("mxvk: failed to create depth image {}\n", i);
                cleanup_render_resource_failure();
                return false;
            }
 
            VkMemoryRequirements memReq{};
            vkGetImageMemoryRequirements(device, depth_images[i], &memReq);
 
            VkPhysicalDeviceMemoryProperties memProps{};
            vkGetPhysicalDeviceMemoryProperties(physical_device, &memProps);
            uint32_t memoryTypeIndex = UINT32_MAX;
            for (uint32_t t = 0; t < memProps.memoryTypeCount; ++t) {
                if (((memReq.memoryTypeBits & (1u << t)) != 0U) && ((memProps.memoryTypes[t].propertyFlags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0U)) {
                    memoryTypeIndex = t;
                    break;
                }
            }
            if (memoryTypeIndex == UINT32_MAX) {
                std::cerr << "mxvk: failed to find depth image memory type\n";
                cleanup_render_resource_failure();
                return false;
            }
 
            std::cout << std::format("vk: allocating depth image memory for frame {}\n", i);
            VkMemoryAllocateInfo allocInfo{};
            allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
            allocInfo.allocationSize = memReq.size;
            allocInfo.memoryTypeIndex = memoryTypeIndex;
 
            if (vkAllocateMemory(device, &allocInfo, nullptr, &depth_image_memories[i]) != VK_SUCCESS) {
                std::cerr << std::format("mxvk: failed to allocate depth image memory {}\n", i);
                cleanup_render_resource_failure();
                return false;
            }
 
            if (vkBindImageMemory(device, depth_images[i], depth_image_memories[i], 0) != VK_SUCCESS) {
                std::cerr << std::format("mxvk: failed to bind depth image memory {}\n", i);
                cleanup_render_resource_failure();
                return false;
            }
 
            std::cout << std::format("vk: creating depth image view for frame {}\n", i);
            VkImageViewCreateInfo viewInfo{};
            viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
            viewInfo.image = depth_images[i];
            viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
            viewInfo.format = depth_format;
            viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
            viewInfo.subresourceRange.baseMipLevel = 0;
            viewInfo.subresourceRange.levelCount = 1;
            viewInfo.subresourceRange.baseArrayLayer = 0;
            viewInfo.subresourceRange.layerCount = 1;
 
            if (vkCreateImageView(device, &viewInfo, nullptr, &depth_image_views[i]) != VK_SUCCESS) {
                std::cerr << std::format("mxvk: failed to create depth image view {}\n", i);
                cleanup_render_resource_failure();
                return false;
            }
        }
 
        if (!post_process_sprites.empty()) {
            try {
                createPostProcessTargets();
            } catch (const mxvk::Exception &ex) {
                std::cerr << std::format("mxvk: {}\n", ex.text());
                cleanup_render_resource_failure();
                return false;
            }
        }
 
        std::cout << "vk: createRenderResources complete\n";
        return true;
    }
 
    bool VK_Window::createSyncObjects() {
        std::cout << "vk: entering createSyncObjects\n";
        if (swapchain_images.empty()) {
            std::cerr << "mxvk: cannot create sync objects without swapchain images\n";
            return false;
        }
 
        cleanupSyncObjects();
 
        VkSemaphoreCreateInfo semaphore_info{};
        semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
 
        VkFenceCreateInfo fence_info{};
        fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
        fence_info.flags = VK_FENCE_CREATE_SIGNALED_BIT;
 
        render_finished.assign(swapchain_images.size(), VK_NULL_HANDLE);
 
        for (uint32_t frame = 0; frame < max_frames_in_flight; ++frame) {
            std::cout << std::format("vk: creating image-available semaphore for frame {}\n", frame);
            if (vkCreateSemaphore(device, &semaphore_info, nullptr, &image_available[frame]) != VK_SUCCESS) {
                cleanupSyncObjects();
                return false;
            }
 
            std::cout << std::format("vk: creating in-flight fence for frame {}\n", frame);
            if (vkCreateFence(device, &fence_info, nullptr, &in_flight_fences[frame]) != VK_SUCCESS) {
                cleanupSyncObjects();
                return false;
            }
        }
 
        for (size_t image_index = 0; image_index < render_finished.size(); ++image_index) {
            std::cout << std::format("vk: creating render-finished semaphore for swapchain image {}\n", image_index);
            if (vkCreateSemaphore(device, &semaphore_info, nullptr, &render_finished[image_index]) != VK_SUCCESS) {
                cleanupSyncObjects();
                return false;
            }
        }
 
        image_fences.assign(swapchain_images.size(), VK_NULL_HANDLE);
        current_frame = 0;
 
        std::cout << "vk: createSyncObjects complete\n";
        return true;
    }
 
    void VK_Window::cleanupSyncObjects() {
        if (device == VK_NULL_HANDLE) {
            return;
        }
 
        const bool has_in_flight_fences = std::ranges::any_of(in_flight_fences.begin(), in_flight_fences.end(), [](VkFence fence) { return fence != VK_NULL_HANDLE; });
        const bool has_render_finished = std::ranges::any_of(render_finished.begin(), render_finished.end(), [](VkSemaphore semaphore) { return semaphore != VK_NULL_HANDLE; });
        const bool has_image_available = std::ranges::any_of(image_available.begin(), image_available.end(), [](VkSemaphore semaphore) { return semaphore != VK_NULL_HANDLE; });
 
        if (!has_in_flight_fences && !has_render_finished && !has_image_available) {
            image_fences.clear();
            current_frame = 0;
            return;
        }
 
        if (has_in_flight_fences) {
            std::cout << "vk: destroying in-flight fences\n";
            for (VkFence &fence : in_flight_fences) {
                if (fence != VK_NULL_HANDLE) {
                    vkDestroyFence(device, fence, nullptr);
                    fence = VK_NULL_HANDLE;
                }
            }
        }
 
        if (has_render_finished) {
            std::cout << "vk: destroying render-finished semaphores\n";
            for (VkSemaphore &semaphore : render_finished) {
                if (semaphore != VK_NULL_HANDLE) {
                    vkDestroySemaphore(device, semaphore, nullptr);
                    semaphore = VK_NULL_HANDLE;
                }
            }
        }
 
        if (has_image_available) {
            std::cout << "vk: destroying image-available semaphores\n";
            for (VkSemaphore &semaphore : image_available) {
                if (semaphore != VK_NULL_HANDLE) {
                    vkDestroySemaphore(device, semaphore, nullptr);
                    semaphore = VK_NULL_HANDLE;
                }
            }
        }
 
        image_fences.clear();
        render_finished.clear();
        current_frame = 0;
    }
 
    void VK_Window::recreateSwapchain() {
        if (device == VK_NULL_HANDLE || window == nullptr) {
            return;
        }
        int pixel_w = 0;
        int pixel_h = 0;
        SDL_GetWindowSizeInPixels(window.get(), &pixel_w, &pixel_h);
        VkSurfaceCapabilitiesKHR surface_capabilities{};
        vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physical_device, surface, &surface_capabilities);
 
        VkExtent2D new_extent{};
 
        if (surface_capabilities.currentExtent.width != 0xFFFFFFFFU) {
            new_extent = surface_capabilities.currentExtent;
        } else {
            new_extent.width = std::clamp(static_cast<uint32_t>(pixel_w), surface_capabilities.minImageExtent.width, surface_capabilities.maxImageExtent.width);
 
            new_extent.height = std::clamp(static_cast<uint32_t>(pixel_h), surface_capabilities.minImageExtent.height, surface_capabilities.maxImageExtent.height);
        }
 
        if (new_extent.width == 0 || new_extent.height == 0) {
            return;
        }
 
        const uint32_t target_w = std::clamp(static_cast<uint32_t>(pixel_w), surface_capabilities.minImageExtent.width, surface_capabilities.maxImageExtent.width);
        const uint32_t target_h = std::clamp(static_cast<uint32_t>(pixel_h), surface_capabilities.minImageExtent.height, surface_capabilities.maxImageExtent.height);
 
        if (new_extent.width != target_w || new_extent.height != target_h) {
            return;
        }
 
        if (!force_swapchain_recreate && swapchain_extent.width == new_extent.width && swapchain_extent.height == new_extent.height) {
            return;
        }
 
        if (!force_swapchain_recreate && swapchain_extent.width == new_extent.width && swapchain_extent.height == new_extent.height) {
            return;
        }
 
        std::cout << std::format("mxvk: recreating swapchain for {}x{} window\n", new_extent.width, new_extent.height);
        vkDeviceWaitIdle(device);
        onSwapchainAboutToRecreate();
 
        for (const std::unique_ptr<VK_Sprite> &sprite : sprites) {
            if (sprite) {
                sprite->releaseUploadResources();
            }
        }
 
        sprite_state_dirty = true;
        text_state_dirty = true;
        destroySpritePipeline();
        destroyTextPipeline();
        cleanupSyncObjects();
        VkSwapchainKHR old_swapchain = swapchain;
        cleanupSwapchain(false);
        if (!createSwapchain(old_swapchain) || !createRenderResources() || !createSyncObjects()) {
            std::cerr << "mxvk: failed to recreate swapchain after resize\n";
            if (old_swapchain != VK_NULL_HANDLE) {
                retired_swapchains.push_back(old_swapchain);
                // vkDestroySwapchainKHR(device, old_swapchain, nullptr);
            }
            return;
        }
        if (old_swapchain != VK_NULL_HANDLE) {
            // vkDestroySwapchainKHR(device, old_swapchain, nullptr);
            retired_swapchains.push_back(old_swapchain);
        }
 
        for (const std::unique_ptr<VK_Sprite> &sprite : sprites) {
            if (sprite) {
                sprite->setCommandPool(command_pool);
            }
        }
        for (const std::unique_ptr<VK_Sprite3D> &sprite : sprites3d) {
            if (sprite) {
                sprite->resize(this);
            }
        }
 
        onSwapchainRecreated();
        force_swapchain_recreate = false;
        framebuffer_resized = false;
        std::cout << "mxvk: swapchain recreation complete\n";
    }
 
    void VK_Window::cleanupSwapchain(bool destroy_swapchain_handle) {
        std::cout << "vk: entering cleanupSwapchain\n";
        if (device == VK_NULL_HANDLE) {
            return;
        }
 
        destroyPostProcessTargets();
 
        if (!swapchain_image_views.empty()) {
            std::cout << "vk: destroying swapchain image views\n";
            for (VkImageView image_view : swapchain_image_views) {
                if (image_view != VK_NULL_HANDLE) {
                    vkDestroyImageView(device, image_view, nullptr);
                }
            }
        }
        swapchain_image_views.clear();
 
        if (!headless_image_memories.empty()) {
            std::cout << "vk: destroying surface-free color images\n";
            for (VkImage image : swapchain_images) {
                if (image != VK_NULL_HANDLE) {
                    vkDestroyImage(device, image, nullptr);
                }
            }
            std::cout << "vk: freeing surface-free color image memory\n";
            for (VkDeviceMemory memory : headless_image_memories) {
                if (memory != VK_NULL_HANDLE) {
                    vkFreeMemory(device, memory, nullptr);
                }
            }
            headless_image_memories.clear();
        }
 
        if (!depth_image_views.empty()) {
            std::cout << "vk: destroying depth image views\n";
            for (VkImageView view : depth_image_views) {
                if (view != VK_NULL_HANDLE) {
                    vkDestroyImageView(device, view, nullptr);
                }
            }
        }
        depth_image_views.clear();
 
        if (!depth_images.empty()) {
            std::cout << "vk: destroying depth images\n";
            for (VkImage image : depth_images) {
                if (image != VK_NULL_HANDLE) {
                    vkDestroyImage(device, image, nullptr);
                }
            }
        }
        depth_images.clear();
 
        if (!depth_image_memories.empty()) {
            std::cout << "vk: freeing depth image memory\n";
            for (VkDeviceMemory memory : depth_image_memories) {
                if (memory != VK_NULL_HANDLE) {
                    vkFreeMemory(device, memory, nullptr);
                }
            }
        }
        depth_image_memories.clear();
        depth_image_initialized.clear();
 
        swapchain_images.clear();
        swapchain_image_initialized.clear();
        last_presented_image_index = invalid_queue_index;
        swapchain_supports_transfer_src = false;
        depth_format = VK_FORMAT_UNDEFINED;
        next_headless_image = 0;
 
        // This guard prevents destroying the active swapchain during a live resize
        if (destroy_swapchain_handle && swapchain != VK_NULL_HANDLE) {
            std::cout << "vk: destroying swapchain\n";
            vkDestroySwapchainKHR(device, swapchain, nullptr);
            swapchain = VK_NULL_HANDLE;
        }
        std::cout << "vk: cleanupSwapchain complete\n";
    }
 
    void VK_Window::drawFrame() {
        if (device == VK_NULL_HANDLE) {
            return;
        }
 
        int pixel_w = 0;
        int pixel_h = 0;
        if (!headless()) {
            if (window != nullptr) {
                SDL_GetWindowSizeInPixels(window.get(), &pixel_w, &pixel_h);
            }
            if (pixel_w <= 0 || pixel_h <= 0) {
                framebuffer_resized = true;
                return;
            }
        }
 
        if (!headless() && swapchain_extent.width != 0 && swapchain_extent.height != 0) {
            if (swapchain_extent.width != static_cast<uint32_t>(pixel_w) || swapchain_extent.height != static_cast<uint32_t>(pixel_h)) {
                std::cout << std::format("mxvk: requesting swapchain recreation because window pixels changed from {}x{} to {}x{}\n", swapchain_extent.width, swapchain_extent.height, pixel_w, pixel_h);
                framebuffer_resized = true;
                force_swapchain_recreate = true;
                return;
            }
        }
 
        if (!ensureRenderResources()) {
            std::cout << "mxvk: creating deferred swapchain/render/sync resources\n";
            if (!ensureRenderResources()) {
                std::cerr << "mxvk: deferred resource creation failed; skipping frame\n";
                return;
            }
        }
 
        const bool sync_ready = std::ranges::all_of(image_available.begin(), image_available.end(), [](VkSemaphore semaphore) { return semaphore != VK_NULL_HANDLE; }) && std::ranges::all_of(render_finished.begin(), render_finished.end(), [](VkSemaphore semaphore) { return semaphore != VK_NULL_HANDLE; }) && std::ranges::all_of(in_flight_fences.begin(), in_flight_fences.end(), [](VkFence fence) { return fence != VK_NULL_HANDLE; });
        if (!sync_ready) {
            return;
        }
 
        if (sprite_state_dirty && !sprites.empty() && swapchain_format != VK_FORMAT_UNDEFINED) {
            for (const std::unique_ptr<VK_Sprite> &sprite : sprites) {
                if (!sprite) {
                    continue;
                }
                VkFormat sprite_color_format = swapchain_format;
                const auto post_process_match = std::ranges::find(post_process_sprites, sprite.get());
                if (post_process_match != post_process_sprites.end()) {
                    const size_t effect_index = static_cast<size_t>(std::distance(post_process_sprites.begin(), post_process_match));
                    if (hdr_render_intermediates_enabled || effect_index + 1U < post_process_sprites.size() || (render_extent_override.width > 0U && render_extent_override.height > 0U)) {
                        sprite_color_format = postProcessIntermediateFormat();
                    }
                } else if (hdr_render_intermediates_enabled && !post_process_sprites.empty() && !isPostProcessSprite(sprite.get())) {
                    sprite_color_format = postProcessIntermediateFormat();
                }
                sprite->setColorAttachmentFormat(sprite_color_format);
                sprite->setDepthAttachmentFormat(depth_format);
                sprite->setDescriptorSetLayout(sprite_descriptor_set_layout);
                sprite->rebuildPipeline();
                sprite->rebuildInstancedPipeline();
            }
            try {
                createSpritePipeline();
            } catch (const std::exception &ex) {
                std::cerr << std::format("mxvk: sprite pipeline build skipped: {}\n", ex.what());
            }
            sprite_state_dirty = false;
        }
 
        if (fps_counter_enabled) {
            updateFpsCounter();
        }
 
        if (text_state_dirty && (text_renderer || preview_text_renderer) && swapchain_format != VK_FORMAT_UNDEFINED) {
            if (text_renderer) {
                text_renderer->setDescriptorSetLayout(text_descriptor_set_layout);
            }
            if (preview_text_renderer) {
                preview_text_renderer->setDescriptorSetLayout(text_descriptor_set_layout);
            }
            try {
                createTextPipeline();
            } catch (const std::exception &ex) {
                std::cerr << std::format("mxvk: text pipeline build skipped: {}\n", ex.what());
            }
            text_state_dirty = false;
        }
 
        VkFence &frame_fence = in_flight_fences[current_frame];
        VkSemaphore &acquire_semaphore = image_available[current_frame];
        const size_t depth_slot = static_cast<size_t>(current_frame);
 
        const VkResult wait_result = vkWaitForFences(device, 1, &frame_fence, VK_TRUE, UINT64_MAX);
        if (wait_result == VK_ERROR_DEVICE_LOST) {
            std::cerr << "mxvk: device lost while waiting for frame fence; stopping render loop\n";
            active = false;
            return;
        }
        if (wait_result != VK_SUCCESS) {
            std::cerr << std::format("mxvk: Failed waiting for frame fence (VkResult={})\n", static_cast<int>(wait_result));
            framebuffer_resized = true;
            return;
        }
 
        dispatchFrameReadback(frame_readback_slots[current_frame]);
 
        if (frame_readback_enabled) {
            ensureFrameReadbackResources();
        }
 
        uint32_t image_index = 0;
        VkResult acquire_result = VK_SUCCESS;
        if (headless()) {
            image_index = next_headless_image % static_cast<uint32_t>(swapchain_images.size());
            next_headless_image = (next_headless_image + 1U) % static_cast<uint32_t>(swapchain_images.size());
        } else {
            const uint64_t acquire_timeout_ns = 100000000ULL; // 100 ms avoids UINT64_MAX forward-progress VUIDs.
            acquire_result = vkAcquireNextImageKHR(device, swapchain, acquire_timeout_ns, acquire_semaphore, VK_NULL_HANDLE, &image_index);
        }
 
        static VkResult last_acquire_error = VK_SUCCESS;
        static uint32_t repeated_acquire_errors = 0;
 
        if (acquire_result == VK_ERROR_OUT_OF_DATE_KHR) {
            last_acquire_error = VK_SUCCESS;
            repeated_acquire_errors = 0;
            std::cout << "mxvk: requesting swapchain recreation because acquire returned VK_ERROR_OUT_OF_DATE_KHR\n";
            force_swapchain_recreate = true;
            framebuffer_resized = true;
            return;
        }
 
        if (acquire_result == VK_ERROR_SURFACE_LOST_KHR) {
            if (last_acquire_error != acquire_result) {
                std::cerr << "mxvk: swapchain surface lost during acquire; requesting swapchain recreation\n";
                last_acquire_error = acquire_result;
                repeated_acquire_errors = 0;
            }
            std::cout << "mxvk: requesting swapchain recreation because acquire returned VK_ERROR_SURFACE_LOST_KHR\n";
            force_swapchain_recreate = true;
            framebuffer_resized = true;
            return;
        }
 
        if (acquire_result == VK_TIMEOUT || acquire_result == VK_NOT_READY) {
            // Non-fatal: no image available this frame.
            return;
        }
 
        if (acquire_result != VK_SUCCESS && acquire_result != VK_SUBOPTIMAL_KHR) {
            if (last_acquire_error == acquire_result) {
                ++repeated_acquire_errors;
                if ((repeated_acquire_errors % 120U) == 0U) {
                    std::cerr << std::format("mxvk: repeated swapchain acquire failures continue (VkResult={})\n", static_cast<int>(acquire_result));
                }
            } else {
                last_acquire_error = acquire_result;
                repeated_acquire_errors = 0;
                std::cerr << std::format("mxvk: Failed to acquire swapchain image (VkResult={})\n", static_cast<int>(acquire_result));
            }
 
            if (acquire_result == VK_ERROR_DEVICE_LOST) {
                std::cerr << "mxvk: device lost; stopping render loop\n";
                active = false;
            }
            return;
        }
 
        last_acquire_error = VK_SUCCESS;
        repeated_acquire_errors = 0;
 
        if (image_index >= command_buffers.size() || image_index >= swapchain_images.size() || image_index >= swapchain_image_views.size()) {
            return;
        }
 
        if (image_index >= image_fences.size()) {
            std::cerr << "mxvk: acquired image index exceeds tracked in-flight image count\n";
            return;
        }
 
        if (image_index >= render_finished.size() || render_finished[image_index] == VK_NULL_HANDLE) {
            std::cerr << "mxvk: acquired image index exceeds render-finished semaphore count\n";
            return;
        }
 
        VkSemaphore &present_semaphore = render_finished[image_index];
 
        if (image_fences[image_index] != VK_NULL_HANDLE && image_fences[image_index] != frame_fence) {
            const VkResult image_wait_result = vkWaitForFences(device, 1, &image_fences[image_index], VK_TRUE, UINT64_MAX);
            if (image_wait_result == VK_ERROR_DEVICE_LOST) {
                std::cerr << "mxvk: device lost while waiting on acquired image fence; stopping render loop\n";
                active = false;
                return;
            }
            if (image_wait_result != VK_SUCCESS) {
                std::cerr << std::format("mxvk: Failed waiting for acquired image fence (VkResult={})\n", static_cast<int>(image_wait_result));
                framebuffer_resized = true;
                return;
            }
        }
 
        const VkCommandBuffer cmd = command_buffers[image_index];
        vkResetCommandBuffer(cmd, 0);
 
        VkCommandBufferBeginInfo begin_info{};
        begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
        if (vkBeginCommandBuffer(cmd, &begin_info) != VK_SUCCESS) {
            std::cerr << "mxvk: Failed to begin command buffer\n";
            framebuffer_resized = true;
            return;
        }
 
        VkClearValue clear_value{};
        clear_value.color = clear_color;
        const bool detached_render = render_extent_override.width > 0U && render_extent_override.height > 0U;
        const VkExtent2D render_extent = getRenderExtent();
        const bool use_post_process = post_process_enabled && !post_process_sprites.empty() && !post_process_images.empty() && !post_process_views.empty() && !post_process_initialized.empty() && image_index < post_process_images.front().size() && image_index < post_process_views.front().size() && image_index < post_process_initialized.front().size();
        const bool use_offscreen_target = use_post_process || detached_render;
        const bool consume_post_process = use_post_process && post_process_texture_consumer_enabled;
        const size_t scene_target = hdr_render_intermediates_enabled ? 1U : 0U;
        VkImage rgba16_readback_image = VK_NULL_HANDLE;
 
        VkImageMemoryBarrier2 to_color_barrier{};
        to_color_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
        to_color_barrier.srcStageMask = VK_PIPELINE_STAGE_2_NONE;
        to_color_barrier.srcAccessMask = VK_ACCESS_2_NONE;
        to_color_barrier.dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
        to_color_barrier.dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
        to_color_barrier.oldLayout = swapchain_image_initialized[image_index] ? (headless() ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_PRESENT_SRC_KHR) : VK_IMAGE_LAYOUT_UNDEFINED;
        to_color_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        to_color_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        to_color_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        to_color_barrier.image = swapchain_images[image_index];
        to_color_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        to_color_barrier.subresourceRange.baseMipLevel = 0;
        to_color_barrier.subresourceRange.levelCount = 1;
        to_color_barrier.subresourceRange.baseArrayLayer = 0;
        to_color_barrier.subresourceRange.layerCount = 1;
 
        VkDependencyInfo pre_render_dependency{};
        pre_render_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
        pre_render_dependency.imageMemoryBarrierCount = 1;
        pre_render_dependency.pImageMemoryBarriers = &to_color_barrier;
        vkCmdPipelineBarrier2(cmd, &pre_render_dependency);
 
        if (use_offscreen_target) {
            VkImageMemoryBarrier2 post_target_barrier{};
            post_target_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
            post_target_barrier.srcStageMask = post_process_initialized[scene_target][image_index] ? VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT : VK_PIPELINE_STAGE_2_NONE;
            post_target_barrier.srcAccessMask = post_process_initialized[scene_target][image_index] ? VK_ACCESS_2_SHADER_SAMPLED_READ_BIT : VK_ACCESS_2_NONE;
            post_target_barrier.dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
            post_target_barrier.dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
            post_target_barrier.oldLayout = post_process_initialized[scene_target][image_index] ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED;
            post_target_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
            post_target_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            post_target_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            post_target_barrier.image = post_process_images[scene_target][image_index];
            post_target_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            post_target_barrier.subresourceRange.levelCount = 1;
            post_target_barrier.subresourceRange.layerCount = 1;
            VkDependencyInfo post_target_dependency{};
            post_target_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
            post_target_dependency.imageMemoryBarrierCount = 1;
            post_target_dependency.pImageMemoryBarriers = &post_target_barrier;
            vkCmdPipelineBarrier2(cmd, &post_target_dependency);
        }
 
        VkImageMemoryBarrier2 to_depth_barrier{};
        to_depth_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
        to_depth_barrier.srcStageMask = VK_PIPELINE_STAGE_2_NONE;
        to_depth_barrier.srcAccessMask = VK_ACCESS_2_NONE;
        to_depth_barrier.dstStageMask = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT;
        to_depth_barrier.dstAccessMask = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
        to_depth_barrier.oldLayout = (depth_slot < depth_image_initialized.size() && depth_image_initialized[depth_slot]) ? VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED;
        to_depth_barrier.newLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
        to_depth_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        to_depth_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        if (depth_slot < depth_images.size()) {
            to_depth_barrier.image = depth_images[depth_slot];
        }
        to_depth_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
        to_depth_barrier.subresourceRange.baseMipLevel = 0;
        to_depth_barrier.subresourceRange.levelCount = 1;
        to_depth_barrier.subresourceRange.baseArrayLayer = 0;
        to_depth_barrier.subresourceRange.layerCount = 1;
 
        if (to_depth_barrier.image != VK_NULL_HANDLE) {
            VkDependencyInfo pre_depth_dependency{};
            pre_depth_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
            pre_depth_dependency.imageMemoryBarrierCount = 1;
            pre_depth_dependency.pImageMemoryBarriers = &to_depth_barrier;
            vkCmdPipelineBarrier2(cmd, &pre_depth_dependency);
        }
 
        onPrepareFrameRendering(cmd, image_index);
        for (const std::unique_ptr<VK_Sprite> &sprite : sprites) {
            if (sprite) {
                sprite->prepareForRendering(cmd);
            }
        }
 
        VkRenderingAttachmentInfo color_attachment{};
        color_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
        color_attachment.imageView = use_offscreen_target ? post_process_views[scene_target][image_index] : swapchain_image_views[image_index];
        color_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        color_attachment.resolveMode = VK_RESOLVE_MODE_NONE;
        color_attachment.resolveImageView = VK_NULL_HANDLE;
        color_attachment.resolveImageLayout = VK_IMAGE_LAYOUT_UNDEFINED;
        color_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
        color_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
        color_attachment.clearValue = clear_value;
 
        VkClearValue depth_clear_value{};
        depth_clear_value.depthStencil = {1.0f, 0};
 
        VkRenderingAttachmentInfo depth_attachment{};
        depth_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
        if (depth_slot < depth_image_views.size()) {
            depth_attachment.imageView = depth_image_views[depth_slot];
        }
        depth_attachment.imageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
        depth_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
        depth_attachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
        depth_attachment.clearValue = depth_clear_value;
 
        VkRenderingAttachmentInfo stencil_attachment{};
        stencil_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
        onConfigureDepthStencilAttachments(depth_attachment, stencil_attachment, image_index);
 
        VkRenderingInfo rendering_info{};
        rendering_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
        rendering_info.renderArea.offset = {0, 0};
        rendering_info.renderArea.extent = use_offscreen_target ? render_extent : swapchain_extent;
        rendering_info.layerCount = 1;
        rendering_info.viewMask = 0;
        rendering_info.colorAttachmentCount = 1;
        rendering_info.pColorAttachments = &color_attachment;
        rendering_info.pDepthAttachment = (depth_attachment.imageView != VK_NULL_HANDLE) ? &depth_attachment : nullptr;
        rendering_info.pStencilAttachment = (stencil_attachment.imageView != VK_NULL_HANDLE) ? &stencil_attachment : nullptr;
 
        vkCmdBeginRendering(cmd, &rendering_info);
 
        VkViewport viewport{};
        viewport.x = 0.0F;
        viewport.y = 0.0F;
        viewport.width = static_cast<float>(rendering_info.renderArea.extent.width);
        viewport.height = static_cast<float>(rendering_info.renderArea.extent.height);
        viewport.minDepth = 0.0F;
        viewport.maxDepth = 1.0F;
        vkCmdSetViewport(cmd, 0, 1, &viewport);
 
        VkRect2D scissor{};
        scissor.offset = {0, 0};
        scissor.extent = rendering_info.renderArea.extent;
        vkCmdSetScissor(cmd, 0, 1, &scissor);
 
        onRecordCustomRendering(cmd, image_index);
 
        // Draw 2D overlays after custom scene rendering so HUD/text stays on top.
        if (!sprites.empty()) {
            for (const std::unique_ptr<VK_Sprite> &sprite : sprites) {
                if (!sprite || isPostProcessSprite(sprite.get())) {
                    continue;
                }
                if (sprite_pipeline != VK_NULL_HANDLE) {
                    vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, sprite_pipeline);
                }
                sprite->renderSprites(cmd, sprite_pipeline_layout, rendering_info.renderArea.extent.width, rendering_info.renderArea.extent.height);
            }
        }
 
        if (!use_post_process && text_renderer && text_pipeline != VK_NULL_HANDLE) {
            vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, text_pipeline);
            text_renderer->renderText(cmd, text_pipeline_layout, rendering_info.renderArea.extent.width, rendering_info.renderArea.extent.height);
        }
 
        vkCmdEndRendering(cmd);
        if (depth_slot < depth_image_initialized.size()) {
            depth_image_initialized[depth_slot] = true;
        }
 
        if (use_post_process) {
            VkImageMemoryBarrier2 post_target_barrier{};
            post_target_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
            post_target_barrier.srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
            post_target_barrier.srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
            post_target_barrier.dstStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
            post_target_barrier.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
            post_target_barrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
            post_target_barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
            post_target_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            post_target_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            post_target_barrier.image = post_process_images[scene_target][image_index];
            post_target_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            post_target_barrier.subresourceRange.levelCount = 1;
            post_target_barrier.subresourceRange.layerCount = 1;
            VkDependencyInfo post_target_dependency{};
            post_target_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
            post_target_dependency.imageMemoryBarrierCount = 1;
            post_target_dependency.pImageMemoryBarriers = &post_target_barrier;
            vkCmdPipelineBarrier2(cmd, &post_target_dependency);
            post_process_initialized[scene_target][image_index] = true;
 
            size_t source_target = scene_target;
            for (size_t effect_index = 0; effect_index < post_process_sprites.size(); ++effect_index) {
                VK_Sprite *effect_sprite = post_process_sprites[effect_index];
                if (effect_sprite == nullptr) {
                    continue;
                }
 
                if (effect_index < post_process_effect_time_enabled.size() && post_process_effect_time_enabled[effect_index]) {
                    post_process_effect_params[effect_index][0] = std::chrono::duration<float>(std::chrono::steady_clock::now() - post_process_effect_start_times[effect_index]).count();
                }
                if (effect_index < post_process_effect_params.size()) {
                    const std::array<float, 4> &params = post_process_effect_params[effect_index];
                    effect_sprite->setShaderParams(params[0], params[1], params[2], params[3]);
                }
 
                const bool compute_effect = effect_index < post_process_effect_stages.size() && post_process_effect_stages[effect_index] == ShaderStage::Compute;
                const bool final_effect = (effect_index + 1U) == post_process_sprites.size();
                const size_t destination_target = hdr_render_intermediates_enabled ? (source_target == 2U ? 3U : 2U) : (source_target == 1U ? 2U : 1U);
 
                if (compute_effect) {
                    VkImageMemoryBarrier2 storage_target_barrier{};
                    storage_target_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
                    storage_target_barrier.srcStageMask = post_process_initialized[destination_target][image_index] ? VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT : VK_PIPELINE_STAGE_2_NONE;
                    storage_target_barrier.srcAccessMask = post_process_initialized[destination_target][image_index] ? VK_ACCESS_2_SHADER_SAMPLED_READ_BIT : VK_ACCESS_2_NONE;
                    storage_target_barrier.dstStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
                    storage_target_barrier.dstAccessMask = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
                    storage_target_barrier.oldLayout = post_process_initialized[destination_target][image_index] ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED;
                    storage_target_barrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
                    storage_target_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
                    storage_target_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
                    storage_target_barrier.image = post_process_images[destination_target][image_index];
                    storage_target_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
                    storage_target_barrier.subresourceRange.levelCount = 1;
                    storage_target_barrier.subresourceRange.layerCount = 1;
                    VkDependencyInfo storage_target_dependency{};
                    storage_target_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
                    storage_target_dependency.imageMemoryBarrierCount = 1;
                    storage_target_dependency.pImageMemoryBarriers = &storage_target_barrier;
                    vkCmdPipelineBarrier2(cmd, &storage_target_dependency);
 
                    effect_sprite->dispatchCompute(cmd, post_process_views[source_target][image_index], post_process_views[destination_target][image_index], render_extent.width, render_extent.height);
 
                    VkImageMemoryBarrier2 sampled_target_barrier{};
                    sampled_target_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
                    sampled_target_barrier.srcStageMask = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
                    sampled_target_barrier.srcAccessMask = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
                    sampled_target_barrier.dstStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
                    sampled_target_barrier.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
                    sampled_target_barrier.oldLayout = VK_IMAGE_LAYOUT_GENERAL;
                    sampled_target_barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
                    sampled_target_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
                    sampled_target_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
                    sampled_target_barrier.image = post_process_images[destination_target][image_index];
                    sampled_target_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
                    sampled_target_barrier.subresourceRange.levelCount = 1;
                    sampled_target_barrier.subresourceRange.layerCount = 1;
                    VkDependencyInfo sampled_target_dependency{};
                    sampled_target_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
                    sampled_target_dependency.imageMemoryBarrierCount = 1;
                    sampled_target_dependency.pImageMemoryBarriers = &sampled_target_barrier;
                    vkCmdPipelineBarrier2(cmd, &sampled_target_dependency);
                    post_process_initialized[destination_target][image_index] = true;
                    source_target = destination_target;
 
                    if (final_effect && !hdr_render_intermediates_enabled && !detached_render && !consume_post_process && post_process_present_sprite != nullptr) {
                        VkRenderingAttachmentInfo post_attachment{};
                        post_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
                        post_attachment.imageView = swapchain_image_views[image_index];
                        post_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
                        post_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
                        post_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
                        VkRenderingInfo post_info{};
                        post_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
                        post_info.renderArea.extent = swapchain_extent;
                        post_info.layerCount = 1;
                        post_info.colorAttachmentCount = 1;
                        post_info.pColorAttachments = &post_attachment;
                        vkCmdBeginRendering(cmd, &post_info);
                        post_process_present_sprite->setExternalTexture(post_process_views[source_target][image_index], static_cast<int>(swapchain_extent.width), static_cast<int>(swapchain_extent.height));
                        post_process_present_sprite->drawSpriteRect(0, 0, static_cast<int>(swapchain_extent.width), static_cast<int>(swapchain_extent.height));
                        renderStandaloneSprite(*post_process_present_sprite, cmd);
                        vkCmdEndRendering(cmd);
                    }
                    continue;
                }
 
                const VkImageView destination_view = final_effect && !hdr_render_intermediates_enabled && !detached_render && !consume_post_process ? swapchain_image_views[image_index] : post_process_views[destination_target][image_index];
                if (!final_effect || hdr_render_intermediates_enabled || detached_render || consume_post_process) {
                    VkImageMemoryBarrier2 next_target_barrier{};
                    next_target_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
                    next_target_barrier.srcStageMask = post_process_initialized[destination_target][image_index] ? VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT : VK_PIPELINE_STAGE_2_NONE;
                    next_target_barrier.srcAccessMask = post_process_initialized[destination_target][image_index] ? VK_ACCESS_2_SHADER_SAMPLED_READ_BIT : VK_ACCESS_2_NONE;
                    next_target_barrier.dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
                    next_target_barrier.dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
                    next_target_barrier.oldLayout = post_process_initialized[destination_target][image_index] ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED;
                    next_target_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
                    next_target_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
                    next_target_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
                    next_target_barrier.image = post_process_images[destination_target][image_index];
                    next_target_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
                    next_target_barrier.subresourceRange.levelCount = 1;
                    next_target_barrier.subresourceRange.layerCount = 1;
                    VkDependencyInfo next_target_dependency{};
                    next_target_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
                    next_target_dependency.imageMemoryBarrierCount = 1;
                    next_target_dependency.pImageMemoryBarriers = &next_target_barrier;
                    vkCmdPipelineBarrier2(cmd, &next_target_dependency);
                }
 
                VkRenderingAttachmentInfo post_attachment{};
                post_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
                post_attachment.imageView = destination_view;
                post_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
                post_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
                post_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
                VkRenderingInfo post_info{};
                post_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
                post_info.renderArea.extent = detached_render ? render_extent : swapchain_extent;
                post_info.layerCount = 1;
                post_info.colorAttachmentCount = 1;
                post_info.pColorAttachments = &post_attachment;
                vkCmdBeginRendering(cmd, &post_info);
 
                effect_sprite->setExternalTexture(post_process_views[source_target][image_index], static_cast<int>(render_extent.width), static_cast<int>(render_extent.height));
                effect_sprite->drawSpriteRect(0, 0, static_cast<int>(render_extent.width), static_cast<int>(render_extent.height));
                renderStandaloneSprite(*effect_sprite, cmd, detached_render ? render_extent : swapchain_extent);
                vkCmdEndRendering(cmd);
 
                if (!final_effect || hdr_render_intermediates_enabled || detached_render || consume_post_process) {
                    VkImageMemoryBarrier2 sampled_target_barrier{};
                    sampled_target_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
                    sampled_target_barrier.srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
                    sampled_target_barrier.srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
                    sampled_target_barrier.dstStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
                    sampled_target_barrier.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
                    sampled_target_barrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
                    sampled_target_barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
                    sampled_target_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
                    sampled_target_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
                    sampled_target_barrier.image = post_process_images[destination_target][image_index];
                    sampled_target_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
                    sampled_target_barrier.subresourceRange.levelCount = 1;
                    sampled_target_barrier.subresourceRange.layerCount = 1;
                    VkDependencyInfo sampled_target_dependency{};
                    sampled_target_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
                    sampled_target_dependency.imageMemoryBarrierCount = 1;
                    sampled_target_dependency.pImageMemoryBarriers = &sampled_target_barrier;
                    vkCmdPipelineBarrier2(cmd, &sampled_target_dependency);
                    post_process_initialized[destination_target][image_index] = true;
                    source_target = destination_target;
                }
            }
 
            bool hdr_consumer_rendered = false;
            if (consume_post_process && hdr_render_intermediates_enabled) {
                const size_t consumer_target = source_target == 2U ? 3U : 2U;
                VkImageMemoryBarrier2 consumer_target_barrier{};
                consumer_target_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
                consumer_target_barrier.srcStageMask = post_process_initialized[consumer_target][image_index] ? VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT : VK_PIPELINE_STAGE_2_NONE;
                consumer_target_barrier.srcAccessMask = post_process_initialized[consumer_target][image_index] ? VK_ACCESS_2_SHADER_SAMPLED_READ_BIT : VK_ACCESS_2_NONE;
                consumer_target_barrier.dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
                consumer_target_barrier.dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
                consumer_target_barrier.oldLayout = post_process_initialized[consumer_target][image_index] ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_UNDEFINED;
                consumer_target_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
                consumer_target_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
                consumer_target_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
                consumer_target_barrier.image = post_process_images[consumer_target][image_index];
                consumer_target_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
                consumer_target_barrier.subresourceRange.levelCount = 1;
                consumer_target_barrier.subresourceRange.layerCount = 1;
                VkDependencyInfo consumer_target_dependency{};
                consumer_target_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
                consumer_target_dependency.imageMemoryBarrierCount = 1;
                consumer_target_dependency.pImageMemoryBarriers = &consumer_target_barrier;
                vkCmdPipelineBarrier2(cmd, &consumer_target_dependency);
 
                VkRenderingAttachmentInfo consumer_attachment{};
                consumer_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
                consumer_attachment.imageView = post_process_views[consumer_target][image_index];
                consumer_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
                consumer_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
                consumer_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
                VkRenderingInfo consumer_info{};
                consumer_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
                consumer_info.renderArea.extent = render_extent;
                consumer_info.layerCount = 1;
                consumer_info.colorAttachmentCount = 1;
                consumer_info.pColorAttachments = &consumer_attachment;
                consumer_info.pDepthAttachment = depth_attachment.imageView != VK_NULL_HANDLE ? &depth_attachment : nullptr;
                vkCmdBeginRendering(cmd, &consumer_info);
                vkCmdSetViewport(cmd, 0, 1, &viewport);
                vkCmdSetScissor(cmd, 0, 1, &scissor);
                onRecordPostProcessingTexture(cmd, image_index, post_process_views[source_target][image_index], render_extent);
                vkCmdEndRendering(cmd);
 
                VkImageMemoryBarrier2 sampled_consumer_barrier = consumer_target_barrier;
                sampled_consumer_barrier.srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
                sampled_consumer_barrier.srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
                sampled_consumer_barrier.dstStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
                sampled_consumer_barrier.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
                sampled_consumer_barrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
                sampled_consumer_barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
                VkDependencyInfo sampled_consumer_dependency{};
                sampled_consumer_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
                sampled_consumer_dependency.imageMemoryBarrierCount = 1;
                sampled_consumer_dependency.pImageMemoryBarriers = &sampled_consumer_barrier;
                vkCmdPipelineBarrier2(cmd, &sampled_consumer_dependency);
                post_process_initialized[consumer_target][image_index] = true;
                source_target = consumer_target;
                hdr_consumer_rendered = true;
            }
 
            if (frame_readback_rgba16_enabled && hdr_render_intermediates_enabled) {
                rgba16_readback_image = post_process_images[source_target][image_index];
            }
 
            if (hdr_render_intermediates_enabled && !detached_render && (!consume_post_process || hdr_consumer_rendered) && post_process_present_sprite != nullptr) {
                VkRenderingAttachmentInfo present_attachment{};
                present_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
                present_attachment.imageView = swapchain_image_views[image_index];
                present_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
                present_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
                present_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
                VkRenderingInfo present_info{};
                present_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
                present_info.renderArea.extent = swapchain_extent;
                present_info.layerCount = 1;
                present_info.colorAttachmentCount = 1;
                present_info.pColorAttachments = &present_attachment;
                vkCmdBeginRendering(cmd, &present_info);
                post_process_present_sprite->setExternalTexture(post_process_views[source_target][image_index], static_cast<int>(render_extent.width), static_cast<int>(render_extent.height));
                post_process_present_sprite->drawSpriteRect(0, 0, static_cast<int>(swapchain_extent.width), static_cast<int>(swapchain_extent.height));
                renderStandaloneSprite(*post_process_present_sprite, cmd);
                post_process_present_sprite->clearQueue();
                vkCmdEndRendering(cmd);
            }
 
            if (detached_render && post_process_composite_sprite != nullptr) {
                VkImageMemoryBarrier2 composite_target_barrier{};
                composite_target_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
                composite_target_barrier.srcStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
                composite_target_barrier.srcAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
                composite_target_barrier.dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
                composite_target_barrier.dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
                composite_target_barrier.oldLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
                composite_target_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
                composite_target_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
                composite_target_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
                composite_target_barrier.image = post_process_images[0][image_index];
                composite_target_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
                composite_target_barrier.subresourceRange.levelCount = 1;
                composite_target_barrier.subresourceRange.layerCount = 1;
                VkDependencyInfo composite_dependency{};
                composite_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
                composite_dependency.imageMemoryBarrierCount = 1;
                composite_dependency.pImageMemoryBarriers = &composite_target_barrier;
                vkCmdPipelineBarrier2(cmd, &composite_dependency);
 
                VkRenderingAttachmentInfo composite_attachment{};
                composite_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
                composite_attachment.imageView = post_process_views[0][image_index];
                composite_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
                composite_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
                composite_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
                VkRenderingInfo composite_info{};
                composite_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
                composite_info.renderArea.extent = render_extent;
                composite_info.layerCount = 1;
                composite_info.colorAttachmentCount = 1;
                composite_info.pColorAttachments = &composite_attachment;
                composite_info.pDepthAttachment = consume_post_process && !hdr_consumer_rendered && depth_attachment.imageView != VK_NULL_HANDLE ? &depth_attachment : nullptr;
                vkCmdBeginRendering(cmd, &composite_info);
                if (consume_post_process && !hdr_consumer_rendered) {
                    vkCmdSetViewport(cmd, 0, 1, &viewport);
                    vkCmdSetScissor(cmd, 0, 1, &scissor);
                    onRecordPostProcessingTexture(cmd, image_index, post_process_views[source_target][image_index], render_extent);
                } else {
                    post_process_composite_sprite->setExternalTexture(post_process_views[source_target][image_index], static_cast<int>(render_extent.width), static_cast<int>(render_extent.height));
                    post_process_composite_sprite->drawSpriteRect(0, 0, static_cast<int>(render_extent.width), static_cast<int>(render_extent.height));
                    renderStandaloneSprite(*post_process_composite_sprite, cmd, render_extent);
                    post_process_composite_sprite->clearQueue();
                }
                vkCmdEndRendering(cmd);
            } else if (consume_post_process && !hdr_consumer_rendered) {
                VkRenderingAttachmentInfo consumer_attachment{};
                consumer_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
                consumer_attachment.imageView = swapchain_image_views[image_index];
                consumer_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
                consumer_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
                consumer_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
                VkRenderingInfo consumer_info{};
                consumer_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
                consumer_info.renderArea.extent = swapchain_extent;
                consumer_info.layerCount = 1;
                consumer_info.colorAttachmentCount = 1;
                consumer_info.pColorAttachments = &consumer_attachment;
                consumer_info.pDepthAttachment = depth_attachment.imageView != VK_NULL_HANDLE ? &depth_attachment : nullptr;
                vkCmdBeginRendering(cmd, &consumer_info);
                vkCmdSetViewport(cmd, 0, 1, &viewport);
                vkCmdSetScissor(cmd, 0, 1, &scissor);
                onRecordPostProcessingTexture(cmd, image_index, post_process_views[source_target][image_index], render_extent);
                vkCmdEndRendering(cmd);
            }
        }
 
        // Post-processing owns the final swapchain color until this point. Draw
        // queued text in a load-preserving pass so HUD and watermark text stay
        // crisp and are included in the final readback without being sampled by
        // the effect chain.
        if (use_post_process && text_renderer && text_pipeline != VK_NULL_HANDLE) {
            VkImageMemoryBarrier2 to_text_barrier{};
            to_text_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
            to_text_barrier.srcStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
            to_text_barrier.srcAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
            to_text_barrier.dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
            to_text_barrier.dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
            to_text_barrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
            to_text_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
            to_text_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_text_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_text_barrier.image = detached_render ? post_process_images[0][image_index] : swapchain_images[image_index];
            to_text_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            to_text_barrier.subresourceRange.levelCount = 1;
            to_text_barrier.subresourceRange.layerCount = 1;
            VkDependencyInfo to_text_dependency{};
            to_text_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
            to_text_dependency.imageMemoryBarrierCount = 1;
            to_text_dependency.pImageMemoryBarriers = &to_text_barrier;
            vkCmdPipelineBarrier2(cmd, &to_text_dependency);
 
            VkRenderingAttachmentInfo text_attachment{};
            text_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
            text_attachment.imageView = detached_render ? post_process_views[0][image_index] : swapchain_image_views[image_index];
            text_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
            text_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
            text_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
            VkRenderingInfo text_info{};
            text_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
            text_info.renderArea.extent = detached_render ? render_extent : swapchain_extent;
            text_info.layerCount = 1;
            text_info.colorAttachmentCount = 1;
            text_info.pColorAttachments = &text_attachment;
            vkCmdBeginRendering(cmd, &text_info);
            vkCmdSetViewport(cmd, 0, 1, &viewport);
            vkCmdSetScissor(cmd, 0, 1, &scissor);
            vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, text_pipeline);
            text_renderer->renderText(cmd, text_pipeline_layout, text_info.renderArea.extent.width, text_info.renderArea.extent.height);
            vkCmdEndRendering(cmd);
        }
 
        const bool use_rgba16_readback = frame_readback_enabled && rgba16_readback_image != VK_NULL_HANDLE;
        const bool use_output_readback = frame_readback_enabled && !use_rgba16_readback;
        if (frame_readback_enabled) {
            const VkImage readback_image = use_rgba16_readback ? rgba16_readback_image : detached_render ? post_process_images[0][image_index] : swapchain_images[image_index];
            VkImageMemoryBarrier2 to_readback_barrier{};
            to_readback_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
            to_readback_barrier.srcStageMask = use_rgba16_readback ? VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT : VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
            to_readback_barrier.srcAccessMask = use_rgba16_readback ? VK_ACCESS_2_SHADER_SAMPLED_READ_BIT : VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
            to_readback_barrier.dstStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
            to_readback_barrier.dstAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT;
            to_readback_barrier.oldLayout = use_rgba16_readback ? VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
            to_readback_barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
            to_readback_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_readback_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_readback_barrier.image = readback_image;
            to_readback_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            to_readback_barrier.subresourceRange.baseMipLevel = 0;
            to_readback_barrier.subresourceRange.levelCount = 1;
            to_readback_barrier.subresourceRange.baseArrayLayer = 0;
            to_readback_barrier.subresourceRange.layerCount = 1;
 
            VkDependencyInfo to_readback_dependency{};
            to_readback_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
            to_readback_dependency.imageMemoryBarrierCount = 1;
            to_readback_dependency.pImageMemoryBarriers = &to_readback_barrier;
            vkCmdPipelineBarrier2(cmd, &to_readback_dependency);
 
            VkBufferImageCopy readback_region{};
            readback_region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            readback_region.imageSubresource.mipLevel = 0;
            readback_region.imageSubresource.baseArrayLayer = 0;
            readback_region.imageSubresource.layerCount = 1;
            readback_region.imageExtent = {use_rgba16_readback || detached_render ? render_extent.width : swapchain_extent.width, use_rgba16_readback || detached_render ? render_extent.height : swapchain_extent.height, 1};
            vkCmdCopyImageToBuffer(cmd, readback_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, frame_readback_slots[current_frame].buffer, 1, &readback_region);
 
            if (use_rgba16_readback) {
                VkImageMemoryBarrier2 restore_readback_barrier = to_readback_barrier;
                restore_readback_barrier.srcStageMask = VK_PIPELINE_STAGE_2_TRANSFER_BIT;
                restore_readback_barrier.srcAccessMask = VK_ACCESS_2_TRANSFER_READ_BIT;
                restore_readback_barrier.dstStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
                restore_readback_barrier.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
                restore_readback_barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
                restore_readback_barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
                VkDependencyInfo restore_readback_dependency{};
                restore_readback_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
                restore_readback_dependency.imageMemoryBarrierCount = 1;
                restore_readback_dependency.pImageMemoryBarriers = &restore_readback_barrier;
                vkCmdPipelineBarrier2(cmd, &restore_readback_dependency);
            }
        }
 
        if (!headless() && detached_render && post_process_present_sprite != nullptr) {
            VkImageMemoryBarrier2 to_sample_barrier{};
            to_sample_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
            to_sample_barrier.srcStageMask = use_output_readback ? VK_PIPELINE_STAGE_2_TRANSFER_BIT : VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
            to_sample_barrier.srcAccessMask = use_output_readback ? VK_ACCESS_2_TRANSFER_READ_BIT : VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
            to_sample_barrier.dstStageMask = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT;
            to_sample_barrier.dstAccessMask = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
            to_sample_barrier.oldLayout = use_output_readback ? VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
            to_sample_barrier.newLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
            to_sample_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_sample_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_sample_barrier.image = post_process_images[0][image_index];
            to_sample_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            to_sample_barrier.subresourceRange.levelCount = 1;
            to_sample_barrier.subresourceRange.layerCount = 1;
            VkDependencyInfo to_sample_dependency{};
            to_sample_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
            to_sample_dependency.imageMemoryBarrierCount = 1;
            to_sample_dependency.pImageMemoryBarriers = &to_sample_barrier;
            vkCmdPipelineBarrier2(cmd, &to_sample_dependency);
 
            VkRenderingAttachmentInfo present_attachment{};
            present_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
            present_attachment.imageView = swapchain_image_views[image_index];
            present_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
            present_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
            present_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
            present_attachment.clearValue = clear_value;
            VkRenderingInfo present_info{};
            present_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
            present_info.renderArea.extent = swapchain_extent;
            present_info.layerCount = 1;
            present_info.colorAttachmentCount = 1;
            present_info.pColorAttachments = &present_attachment;
            vkCmdBeginRendering(cmd, &present_info);
 
            VkViewport present_viewport{};
            present_viewport.width = static_cast<float>(swapchain_extent.width);
            present_viewport.height = static_cast<float>(swapchain_extent.height);
            present_viewport.maxDepth = 1.0F;
            vkCmdSetViewport(cmd, 0, 1, &present_viewport);
            VkRect2D present_scissor{};
            present_scissor.extent = swapchain_extent;
            vkCmdSetScissor(cmd, 0, 1, &present_scissor);
 
            const double preview_scale = std::min(static_cast<double>(swapchain_extent.width) / render_extent.width, static_cast<double>(swapchain_extent.height) / render_extent.height);
            const int preview_width = std::max(1, static_cast<int>(std::lround(render_extent.width * preview_scale)));
            const int preview_height = std::max(1, static_cast<int>(std::lround(render_extent.height * preview_scale)));
            const int preview_x = (static_cast<int>(swapchain_extent.width) - preview_width) / 2;
            const int preview_y = (static_cast<int>(swapchain_extent.height) - preview_height) / 2;
            post_process_present_sprite->setExternalTexture(post_process_views[0][image_index], static_cast<int>(render_extent.width), static_cast<int>(render_extent.height));
            post_process_present_sprite->drawSpriteRect(preview_x, preview_y, preview_width, preview_height);
            renderStandaloneSprite(*post_process_present_sprite, cmd);
            post_process_present_sprite->clearQueue();
            vkCmdEndRendering(cmd);
        }
 
        const bool render_preview_text = !headless() && preview_text_queued && preview_text_renderer && text_pipeline != VK_NULL_HANDLE;
        if (render_preview_text) {
            VkImageMemoryBarrier2 to_preview_barrier{};
            to_preview_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
            to_preview_barrier.srcStageMask = use_output_readback && !detached_render ? VK_PIPELINE_STAGE_2_TRANSFER_BIT : VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
            to_preview_barrier.srcAccessMask = use_output_readback && !detached_render ? VK_ACCESS_2_TRANSFER_READ_BIT : VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
            to_preview_barrier.dstStageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
            to_preview_barrier.dstAccessMask = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
            to_preview_barrier.oldLayout = use_output_readback && !detached_render ? VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
            to_preview_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
            to_preview_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_preview_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
            to_preview_barrier.image = swapchain_images[image_index];
            to_preview_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
            to_preview_barrier.subresourceRange.levelCount = 1;
            to_preview_barrier.subresourceRange.layerCount = 1;
            VkDependencyInfo to_preview_dependency{};
            to_preview_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
            to_preview_dependency.imageMemoryBarrierCount = 1;
            to_preview_dependency.pImageMemoryBarriers = &to_preview_barrier;
            vkCmdPipelineBarrier2(cmd, &to_preview_dependency);
 
            VkRenderingAttachmentInfo preview_attachment{};
            preview_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
            preview_attachment.imageView = swapchain_image_views[image_index];
            preview_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
            preview_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
            preview_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
            VkRenderingInfo preview_info{};
            preview_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
            preview_info.renderArea.extent = swapchain_extent;
            preview_info.layerCount = 1;
            preview_info.colorAttachmentCount = 1;
            preview_info.pColorAttachments = &preview_attachment;
            vkCmdBeginRendering(cmd, &preview_info);
            viewport.width = static_cast<float>(swapchain_extent.width);
            viewport.height = static_cast<float>(swapchain_extent.height);
            scissor.extent = swapchain_extent;
            vkCmdSetViewport(cmd, 0, 1, &viewport);
            vkCmdSetScissor(cmd, 0, 1, &scissor);
            vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, text_pipeline);
            preview_text_renderer->renderText(cmd, text_pipeline_layout, swapchain_extent.width, swapchain_extent.height);
            vkCmdEndRendering(cmd);
        }
 
        VkImageMemoryBarrier2 to_present_barrier{};
        to_present_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
        to_present_barrier.srcStageMask = render_preview_text ? VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT : use_output_readback && !detached_render ? VK_PIPELINE_STAGE_2_TRANSFER_BIT : VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
        to_present_barrier.srcAccessMask = render_preview_text ? VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT : use_output_readback && !detached_render ? VK_ACCESS_2_TRANSFER_READ_BIT : VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
        to_present_barrier.dstStageMask = VK_PIPELINE_STAGE_2_NONE;
        to_present_barrier.dstAccessMask = VK_ACCESS_2_NONE;
        to_present_barrier.oldLayout = render_preview_text ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL : use_output_readback && !detached_render ? VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
        to_present_barrier.newLayout = headless() ? VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
        to_present_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        to_present_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        to_present_barrier.image = swapchain_images[image_index];
        to_present_barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
        to_present_barrier.subresourceRange.baseMipLevel = 0;
        to_present_barrier.subresourceRange.levelCount = 1;
        to_present_barrier.subresourceRange.baseArrayLayer = 0;
        to_present_barrier.subresourceRange.layerCount = 1;
 
        VkDependencyInfo post_render_dependency{};
        post_render_dependency.sType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
        post_render_dependency.imageMemoryBarrierCount = 1;
        post_render_dependency.pImageMemoryBarriers = &to_present_barrier;
        vkCmdPipelineBarrier2(cmd, &post_render_dependency);
 
        if (vkEndCommandBuffer(cmd) != VK_SUCCESS) {
            std::cerr << "mxvk: Failed to end command buffer\n";
            framebuffer_resized = true;
            return;
        }
 
        VkSemaphoreSubmitInfo wait_semaphore_info{};
        wait_semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO;
        wait_semaphore_info.semaphore = acquire_semaphore;
        wait_semaphore_info.value = 0;
        wait_semaphore_info.stageMask = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
        wait_semaphore_info.deviceIndex = 0;
 
        VkCommandBufferSubmitInfo command_buffer_info{};
        command_buffer_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
        command_buffer_info.commandBuffer = cmd;
        command_buffer_info.deviceMask = 0;
 
        VkSemaphoreSubmitInfo signal_semaphore_info{};
        signal_semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO;
        signal_semaphore_info.semaphore = present_semaphore;
        signal_semaphore_info.value = 0;
        signal_semaphore_info.stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
        signal_semaphore_info.deviceIndex = 0;
 
        VkSubmitInfo2 submit_info{};
        submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2;
        submit_info.waitSemaphoreInfoCount = headless() ? 0U : 1U;
        submit_info.pWaitSemaphoreInfos = headless() ? nullptr : &wait_semaphore_info;
        submit_info.commandBufferInfoCount = 1;
        submit_info.pCommandBufferInfos = &command_buffer_info;
        submit_info.signalSemaphoreInfoCount = headless() ? 0U : 1U;
        submit_info.pSignalSemaphoreInfos = headless() ? nullptr : &signal_semaphore_info;
 
        const VkResult fence_reset_result = vkResetFences(device, 1, &frame_fence);
        if (fence_reset_result == VK_ERROR_DEVICE_LOST) {
            std::cerr << "mxvk: device lost while resetting frame fence; stopping render loop\n";
            active = false;
            return;
        }
        if (fence_reset_result != VK_SUCCESS) {
            std::cerr << std::format("mxvk: Failed to reset frame fence (VkResult={})\n", static_cast<int>(fence_reset_result));
            framebuffer_resized = true;
            return;
        }
 
        const VkResult submit_result = vkQueueSubmit2(graphics_queue, 1, &submit_info, frame_fence);
        if (submit_result == VK_ERROR_DEVICE_LOST) {
            std::cerr << "mxvk: device lost during queue submit; stopping render loop\n";
            active = false;
            return;
        }
        if (submit_result != VK_SUCCESS) {
            std::cerr << std::format("mxvk: Failed to submit draw command (VkResult={})\n", static_cast<int>(submit_result));
            // We already acquired an image this frame. Force swapchain recreation so we do not reuse
            // a signaled acquire semaphore that never got consumed by a successful submit.
            framebuffer_resized = true;
            return;
        }
        image_fences[image_index] = frame_fence;
        swapchain_image_initialized[image_index] = true;
 
        VkResult present_result = VK_SUCCESS;
        if (!headless()) {
            VkPresentInfoKHR present_info{};
            present_info.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
            present_info.waitSemaphoreCount = 1;
            present_info.pWaitSemaphores = &present_semaphore;
            present_info.swapchainCount = 1;
            present_info.pSwapchains = &swapchain;
            present_info.pImageIndices = &image_index;
            present_result = vkQueuePresentKHR(present_queue, &present_info);
        }
        if (present_result == VK_SUCCESS || present_result == VK_SUBOPTIMAL_KHR) {
            last_presented_image_index = image_index;
            if (frame_readback_enabled) {
                FrameReadbackSlot &slot = frame_readback_slots[current_frame];
                slot.width = use_rgba16_readback || detached_render ? render_extent.width : swapchain_extent.width;
                slot.height = use_rgba16_readback || detached_render ? render_extent.height : swapchain_extent.height;
                slot.format = use_rgba16_readback ? VK_FORMAT_R16G16B16A16_SFLOAT : swapchain_format;
                slot.pending = true;
                onFrameReadbackScheduled();
            }
        }
 
        if (present_result == VK_ERROR_OUT_OF_DATE_KHR) {
            std::cout << "mxvk: requesting swapchain recreation because present returned VK_ERROR_OUT_OF_DATE_KHR\n";
            force_swapchain_recreate = true;
            last_resize_event_ms = SDL_GetTicks();
            framebuffer_resized = true;
        } else if (present_result == VK_SUBOPTIMAL_KHR) {
            int present_pixel_w = 0;
            int present_pixel_h = 0;
            if (window != nullptr) {
                SDL_GetWindowSizeInPixels(window.get(), &present_pixel_w, &present_pixel_h);
            }
            const bool known_present_extent = present_pixel_w > 0 && present_pixel_h > 0;
            const bool present_extent_changed = known_present_extent && (swapchain_extent.width != static_cast<uint32_t>(present_pixel_w) || swapchain_extent.height != static_cast<uint32_t>(present_pixel_h));
            if (!known_present_extent || present_extent_changed) {
                std::cout << "mxvk: requesting swapchain recreation because present returned VK_SUBOPTIMAL_KHR with changed window extent\n";
                last_resize_event_ms = SDL_GetTicks();
                framebuffer_resized = true;
                force_swapchain_recreate = true;
            }
        } else if (present_result != VK_SUCCESS) {
            std::cerr << "mxvk: Failed to present swapchain image\n";
        }
 
        for (const std::unique_ptr<VK_Sprite> &sprite : sprites) {
            if (sprite) {
                sprite->clearQueue();
            }
        }
        if (text_renderer) {
            text_renderer->clearQueue();
        }
        if (preview_text_renderer) {
            preview_text_renderer->clearQueue();
        }
        preview_text_queued = false;
 
        current_frame = (current_frame + 1U) % max_frames_in_flight;
        if (!retired_swapchains.empty() && (present_result == VK_SUCCESS || present_result == VK_SUBOPTIMAL_KHR)) {
            for (VkSwapchainKHR retired : retired_swapchains) {
                vkDestroySwapchainKHR(device, retired, nullptr);
            }
            retired_swapchains.clear();
        }
    }
 
    bool VK_Window::validationEnabled() const { return validation_enabled; }
 
    bool VK_Window::hasValidationLayerSupport() {
        uint32_t layer_count = 0;
        const VkResult count_result = vkEnumerateInstanceLayerProperties(&layer_count, nullptr);
        if (count_result != VK_SUCCESS) {
            std::cerr << std::format("mxvk: Failed to query validation layer count (VkResult={})\n", static_cast<int>(count_result));
            return false;
        }
 
        if (layer_count == 0U) {
            return false;
        }
 
        std::vector<VkLayerProperties> available_layers(layer_count);
        const VkResult layers_result = vkEnumerateInstanceLayerProperties(&layer_count, available_layers.data());
        if (layers_result != VK_SUCCESS) {
            std::cerr << std::format("mxvk: Failed to enumerate validation layers (VkResult={})\n", static_cast<int>(layers_result));
            return false;
        }
 
        return std::ranges::any_of(available_layers, [](const VkLayerProperties &layer) { return std::strcmp(layer.layerName, validation_layer_name) == 0; });
    }
 
    std::optional<VkDebugUtilsMessengerCreateInfoEXT> VK_Window::makeDebugMessengerCreateInfo() {
        VkDebugUtilsMessengerCreateInfoEXT create_info{};
        create_info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
        create_info.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;
        create_info.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;
        create_info.pfnUserCallback = debugCallback;
        create_info.pUserData = nullptr;
        return create_info;
    }
 
    void VK_Window::setupDebugMessenger() {
        if (!validation_enabled || instance == VK_NULL_HANDLE) {
            return;
        }
 
        const std::optional<VkDebugUtilsMessengerCreateInfoEXT> maybe_create_info = makeDebugMessengerCreateInfo();
        if (!maybe_create_info.has_value()) {
            std::cerr << "mxvk: unable to build debug messenger create info\n";
            return;
        }
 
        const VkResult result = vkCreateDebugUtilsMessengerEXT(instance, &maybe_create_info.value(), nullptr, &debug_messenger);
        if (result != VK_SUCCESS) {
            std::cerr << "mxvk: failed to create Vulkan debug messenger\n";
            debug_messenger = VK_NULL_HANDLE;
        }
    }
 
    void VK_Window::cleanupDebugMessenger() {
        if (debug_messenger != VK_NULL_HANDLE && instance != VK_NULL_HANDLE) {
            std::cout << "vk: destroying debug messenger\n";
            vkDestroyDebugUtilsMessengerEXT(instance, debug_messenger, nullptr);
            debug_messenger = VK_NULL_HANDLE;
        }
    }
 
    void VK_Window::setFont(const std::string &fontPath, int fontSize) {
        if (fontPath.empty() || fontSize <= 0) {
            throw mxvk::Exception("setFont requires a non-empty path and positive font size");
        }
 
        font_path = fontPath;
        font_size = fontSize;
        font_configured = true;
 
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot set font before Vulkan device initialization");
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot initialize text renderer before swapchain and command resources are available");
        }
 
        if (!text_renderer) {
            ensureTextRenderer();
        } else {
            text_renderer->setFont(font_path, font_size);
        }
        if (preview_text_renderer) {
            preview_text_renderer->setFont(font_path, font_size);
        }
        text_state_dirty = true;
    }
 
    void VK_Window::setPreviewFont(const std::string &fontPath, int fontSize) {
        if (fontPath.empty() || fontSize <= 0) {
            throw mxvk::Exception("setPreviewFont requires a non-empty path and positive font size");
        }
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot set preview font before Vulkan device initialization");
        }
        if (!preview_text_renderer) {
            ensurePreviewTextRenderer(fontPath, fontSize);
        }
        if (!preview_text_renderer) {
            throw mxvk::Exception("Cannot initialize preview text renderer");
        }
        preview_text_renderer->setFont(fontPath, fontSize);
        text_state_dirty = true;
    }
 
    void VK_Window::printText(const std::string &text, int x, int y, const SDL_Color &col) {
        if (text.empty()) {
            return;
        }
 
        if (!font_configured) {
            throw mxvk::Exception("printText requires setFont() to be called first");
        }
 
        ensureTextRenderer();
        text_renderer->printTextG_Solid(text, x, y, col);
    }
 
    void VK_Window::printText(const std::string &text, int x, int y, const SDL_Color &col, TTF_Font *font) {
        if (text.empty()) {
            return;
        }
 
        if (font == nullptr) {
            throw mxvk::Exception("printText requires a non-null TTF_Font");
        }
 
        ensureTextRenderer(resolveDefaultFontPath(), font_size);
        if (!text_renderer) {
            throw mxvk::Exception("printText with an explicit font could not initialize the text renderer");
        }
        text_renderer->printTextG_Solid(text, x, y, col, font);
    }
 
    void VK_Window::printText(const std::string &text, int x, int y, const SDL_Color &col, const Font &font) {
        if (text.empty()) {
            return;
        }
 
        if (!font) {
            throw mxvk::Exception("printText requires a valid mxvk::Font");
        }
 
        ensureTextRenderer(font.path(), font.size());
        if (!text_renderer) {
            throw mxvk::Exception("printText with an explicit font could not initialize the text renderer");
        }
        text_renderer->printTextG_Solid(text, x, y, col, font);
    }
 
    void VK_Window::clearTextQueue() {
        if (text_renderer) {
            text_renderer->clearQueue();
        }
        if (preview_text_renderer) {
            preview_text_renderer->clearQueue();
        }
        preview_text_queued = false;
    }
 
    void VK_Window::printPreviewText(const std::string &text, int x, int y, const SDL_Color &col) {
        if (text.empty()) {
            return;
        }
        if (!font_configured) {
            throw mxvk::Exception("printPreviewText requires setFont() to be called first");
        }
        ensurePreviewTextRenderer();
        if (!preview_text_renderer) {
            throw mxvk::Exception("printPreviewText could not initialize the text renderer");
        }
        preview_text_renderer->printTextG_Solid(text, x, y, col);
        preview_text_queued = true;
    }
 
    void VK_Window::printPreviewText(const std::string &text, int x, int y, const SDL_Color &col, const Font &font) {
        if (text.empty()) {
            return;
        }
        if (!font) {
            throw mxvk::Exception("printPreviewText requires a valid mxvk::Font");
        }
        ensurePreviewTextRenderer(font.path(), font.size());
        if (!preview_text_renderer) {
            throw mxvk::Exception("printPreviewText could not initialize the text renderer");
        }
        preview_text_renderer->printTextG_Solid(text, x, y, col, font);
        preview_text_queued = true;
    }
 
    bool VK_Window::getTextDimensions(const std::string &text, int &width, int &height) {
        if (!font_configured) {
            throw mxvk::Exception("getTextDimensions requires setFont() to be called first");
        }
 
        if (!text_renderer) {
            ensureTextRenderer();
        }
        if (!text_renderer) {
            width = 0;
            height = 0;
            return false;
        }
        return text_renderer->getTextDimensions(text, width, height);
    }
 
    bool VK_Window::getTextDimensions(const std::string &text, int &width, int &height, TTF_Font *font) {
        if (font == nullptr) {
            width = 0;
            height = 0;
            return false;
        }
 
        ensureTextRenderer(resolveDefaultFontPath(), font_size);
        if (!text_renderer) {
            width = 0;
            height = 0;
            return false;
        }
        return text_renderer->getTextDimensions(text, width, height, font);
    }
 
    bool VK_Window::getTextDimensions(const std::string &text, int &width, int &height, const Font &font) {
        if (!font) {
            width = 0;
            height = 0;
            return false;
        }
 
        ensureTextRenderer(font.path(), font.size());
        if (!text_renderer) {
            width = 0;
            height = 0;
            return false;
        }
        return text_renderer->getTextDimensions(text, width, height, font);
    }
 
    void VK_Window::ensureTextRenderer() {
        if (text_renderer) {
            return;
        }
 
        if (!font_configured || font_path.empty() || font_size <= 0) {
            return;
        }
 
        if (device == VK_NULL_HANDLE) {
            return;
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            return;
        }
 
        if (text_descriptor_set_layout == VK_NULL_HANDLE) {
            createTextDescriptorSetLayout();
        }
 
        text_renderer = std::make_unique<VK_Text>(device, physical_device, graphics_queue, command_pool, font_path, font_size);
        text_renderer->setDescriptorSetLayout(text_descriptor_set_layout);
        text_state_dirty = true;
    }
 
    void VK_Window::ensurePreviewTextRenderer() {
        if (preview_text_renderer) {
            return;
        }
        if (!font_configured || font_path.empty() || font_size <= 0 || device == VK_NULL_HANDLE) {
            return;
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            return;
        }
        if (text_descriptor_set_layout == VK_NULL_HANDLE) {
            createTextDescriptorSetLayout();
        }
        preview_text_renderer = std::make_unique<VK_Text>(device, physical_device, graphics_queue, command_pool, font_path, font_size);
        preview_text_renderer->setDescriptorSetLayout(text_descriptor_set_layout);
        text_state_dirty = true;
    }
 
    void VK_Window::ensurePreviewTextRenderer(const std::string &fallbackFontPath, int fallbackFontSize) {
        if (preview_text_renderer) {
            return;
        }
        if (device == VK_NULL_HANDLE) {
            return;
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            return;
        }
        const std::string renderer_font_path = font_configured ? font_path : fallbackFontPath;
        const int renderer_font_size = font_configured ? font_size : fallbackFontSize;
        if (renderer_font_path.empty() || renderer_font_size <= 0) {
            return;
        }
        if (text_descriptor_set_layout == VK_NULL_HANDLE) {
            createTextDescriptorSetLayout();
        }
        preview_text_renderer = std::make_unique<VK_Text>(device, physical_device, graphics_queue, command_pool, renderer_font_path, renderer_font_size);
        preview_text_renderer->setDescriptorSetLayout(text_descriptor_set_layout);
        text_state_dirty = true;
    }
 
    void VK_Window::ensureTextRenderer(const std::string &fallbackFontPath, int fallbackFontSize) {
        if (text_renderer) {
            return;
        }
 
        if (device == VK_NULL_HANDLE) {
            return;
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            return;
        }
 
        const std::string renderer_font_path = font_configured ? font_path : fallbackFontPath;
        const int renderer_font_size = font_configured ? font_size : fallbackFontSize;
        if (renderer_font_path.empty() || renderer_font_size <= 0) {
            return;
        }
 
        if (text_descriptor_set_layout == VK_NULL_HANDLE) {
            createTextDescriptorSetLayout();
        }
 
        text_renderer = std::make_unique<VK_Text>(device, physical_device, graphics_queue, command_pool, renderer_font_path, renderer_font_size);
        text_renderer->setDescriptorSetLayout(text_descriptor_set_layout);
        text_state_dirty = true;
    }
 
    std::string VK_Window::resolveDefaultFontPath() const {
        std::vector<std::filesystem::path> candidates{};
 
        if (const char *basePath = SDL_GetBasePath(); basePath != nullptr) {
            const std::filesystem::path executableDir(basePath);
            candidates.push_back(executableDir / "data" / "default.ttf");
            candidates.push_back(executableDir / "default.ttf");
        }
 
        candidates.push_back(std::filesystem::path("data") / "default.ttf");
 
        if (!font_path.empty()) {
            const std::filesystem::path configured_font_path(font_path);
            if (configured_font_path.has_parent_path()) {
                candidates.push_back(configured_font_path.parent_path() / "default.ttf");
            }
        }
 
        candidates.push_back(std::filesystem::path(MXVK_DEFAULT_FONT_DIR) / "default.ttf");
 
        std::error_code exists_error{};
        for (const std::filesystem::path &candidate : candidates) {
            if (std::filesystem::exists(candidate, exists_error)) {
                return candidate.string();
            }
            exists_error.clear();
        }
 
        return {};
    }
 
    void VK_Window::toggleFpsCounter() {
        fps_counter_enabled = !fps_counter_enabled;
        fps_counter_frame_count = 0;
        fps_counter_sample_time = std::chrono::steady_clock::now();
        fps_counter_text = "FPS: --";
        std::cout << std::format("mxvk: FPS counter {}\n", fps_counter_enabled ? "enabled" : "disabled");
 
        if (!fps_counter_enabled) {
            return;
        }
 
        if (!fps_counter_font_ready) {
            const std::string default_font_path = resolveDefaultFontPath();
            if (default_font_path.empty()) {
                std::cerr << "mxvk: F12 FPS counter could not locate data/default.ttf\n";
                fps_counter_enabled = false;
                return;
            }
            fps_counter_font.reset(default_font_path, 18);
            fps_counter_font_ready = true;
        }
    }
 
    void VK_Window::updateFpsCounter() {
        if (!fps_counter_enabled) {
            return;
        }
 
        if (!fps_counter_font_ready) {
            const std::string default_font_path = resolveDefaultFontPath();
            if (default_font_path.empty()) {
                std::cerr << "mxvk: F12 FPS counter could not locate data/default.ttf\n";
                fps_counter_enabled = false;
                return;
            }
            fps_counter_font.reset(default_font_path, 18);
            fps_counter_font_ready = true;
        }
 
        ++fps_counter_frame_count;
        const auto now = std::chrono::steady_clock::now();
        const double elapsed = std::chrono::duration<double>(now - fps_counter_sample_time).count();
        if (elapsed >= 0.5) {
            const double fps = static_cast<double>(fps_counter_frame_count) / elapsed;
            fps_counter_frame_count = 0;
            fps_counter_sample_time = now;
            fps_counter_text = std::format("FPS: {:.1f}", fps);
        }
 
        printPreviewText(fps_counter_text, 12, 10, SDL_Color{255, 255, 255, 255}, fps_counter_font);
    }
 
    void VK_Window::createTextDescriptorSetLayout() {
        if (device == VK_NULL_HANDLE || text_descriptor_set_layout != VK_NULL_HANDLE) {
            return;
        }
 
        VkDescriptorSetLayoutBinding sampler_binding{};
        sampler_binding.binding = 0;
        sampler_binding.descriptorCount = 1;
        sampler_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
        sampler_binding.pImmutableSamplers = nullptr;
        sampler_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
 
        VkDescriptorSetLayoutCreateInfo layout_info{};
        layout_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
        layout_info.bindingCount = 1;
        layout_info.pBindings = &sampler_binding;
 
        if (vkCreateDescriptorSetLayout(device, &layout_info, nullptr, &text_descriptor_set_layout) != VK_SUCCESS) {
            throw mxvk::Exception("Failed to create text descriptor set layout");
        }
    }
 
    void VK_Window::destroyTextPipeline() {
        if (device == VK_NULL_HANDLE) {
            text_pipeline = VK_NULL_HANDLE;
            text_pipeline_layout = VK_NULL_HANDLE;
            return;
        }
 
        if (text_pipeline != VK_NULL_HANDLE) {
            std::cout << "vk: destroying text pipeline\n";
            vkDestroyPipeline(device, text_pipeline, nullptr);
            text_pipeline = VK_NULL_HANDLE;
        }
        if (text_pipeline_layout != VK_NULL_HANDLE) {
            std::cout << "vk: destroying text pipeline layout\n";
            vkDestroyPipelineLayout(device, text_pipeline_layout, nullptr);
            text_pipeline_layout = VK_NULL_HANDLE;
        }
    }
 
    void VK_Window::createTextPipeline() {
        if (device == VK_NULL_HANDLE || swapchain_format == VK_FORMAT_UNDEFINED || text_descriptor_set_layout == VK_NULL_HANDLE) {
            return;
        }
 
        destroyTextPipeline();
 
        const std::vector<char> vert_shader = loadSpv(resolveRuntimeShaderPath("text.vert.spv", MXVK_TEXT_SHADER_DIR));
        const std::vector<char> frag_shader = loadSpv(resolveRuntimeShaderPath("text.frag.spv", MXVK_TEXT_SHADER_DIR));
 
        const VkShaderModule vert_module = createShaderModule(device, vert_shader);
        VkShaderModule frag_module = VK_NULL_HANDLE;
 
        try {
            frag_module = createShaderModule(device, frag_shader);
 
            VkPipelineShaderStageCreateInfo vert_stage{};
            vert_stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
            vert_stage.stage = VK_SHADER_STAGE_VERTEX_BIT;
            vert_stage.module = vert_module;
            vert_stage.pName = "main";
 
            VkPipelineShaderStageCreateInfo frag_stage{};
            frag_stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
            frag_stage.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
            frag_stage.module = frag_module;
            frag_stage.pName = "main";
 
            const VkPipelineShaderStageCreateInfo shader_stages[] = {vert_stage, frag_stage};
 
            VkVertexInputBindingDescription binding_description{};
            binding_description.binding = 0;
            binding_description.stride = sizeof(float) * 4;
            binding_description.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
 
            std::array<VkVertexInputAttributeDescription, 2> attributes{};
            attributes[0].binding = 0;
            attributes[0].location = 0;
            attributes[0].format = VK_FORMAT_R32G32_SFLOAT;
            attributes[0].offset = 0;
            attributes[1].binding = 0;
            attributes[1].location = 1;
            attributes[1].format = VK_FORMAT_R32G32_SFLOAT;
            attributes[1].offset = sizeof(float) * 2;
 
            VkPipelineVertexInputStateCreateInfo vertex_input{};
            vertex_input.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
            vertex_input.vertexBindingDescriptionCount = 1;
            vertex_input.pVertexBindingDescriptions = &binding_description;
            vertex_input.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributes.size());
            vertex_input.pVertexAttributeDescriptions = attributes.data();
 
            VkPipelineInputAssemblyStateCreateInfo input_assembly{};
            input_assembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
            input_assembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
            input_assembly.primitiveRestartEnable = VK_FALSE;
 
            const std::array<VkDynamicState, 2> dynamic_states = {
                VK_DYNAMIC_STATE_VIEWPORT,
                VK_DYNAMIC_STATE_SCISSOR,
            };
            VkPipelineDynamicStateCreateInfo dynamic_state{};
            dynamic_state.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
            dynamic_state.dynamicStateCount = static_cast<uint32_t>(dynamic_states.size());
            dynamic_state.pDynamicStates = dynamic_states.data();
 
            VkPipelineViewportStateCreateInfo viewport_state{};
            viewport_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
            viewport_state.viewportCount = 1;
            viewport_state.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_NONE;
            rasterizer.frontFace = VK_FRONT_FACE_COUNTER_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;
 
            VkPipelineDepthStencilStateCreateInfo depth_stencil{};
            depth_stencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
            depth_stencil.depthTestEnable = VK_FALSE;
            depth_stencil.depthWriteEnable = VK_FALSE;
 
            VkPipelineColorBlendAttachmentState color_attachment{};
            color_attachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
            color_attachment.blendEnable = VK_TRUE;
            color_attachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
            color_attachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
            color_attachment.colorBlendOp = VK_BLEND_OP_ADD;
            color_attachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
            color_attachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
            color_attachment.alphaBlendOp = VK_BLEND_OP_ADD;
 
            VkPipelineColorBlendStateCreateInfo color_blending{};
            color_blending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
            color_blending.logicOpEnable = VK_FALSE;
            color_blending.attachmentCount = 1;
            color_blending.pAttachments = &color_attachment;
 
            VkPushConstantRange push_constant_range{};
            push_constant_range.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
            push_constant_range.offset = 0;
            push_constant_range.size = sizeof(float) * 4;
 
            VkPipelineLayoutCreateInfo pipeline_layout_info{};
            pipeline_layout_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
            pipeline_layout_info.setLayoutCount = 1;
            pipeline_layout_info.pSetLayouts = &text_descriptor_set_layout;
            pipeline_layout_info.pushConstantRangeCount = 1;
            pipeline_layout_info.pPushConstantRanges = &push_constant_range;
 
            if (vkCreatePipelineLayout(device, &pipeline_layout_info, nullptr, &text_pipeline_layout) != VK_SUCCESS) {
                throw mxvk::Exception("Failed to create text pipeline layout");
            }
 
            VkPipelineRenderingCreateInfo rendering_info{};
            rendering_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
            rendering_info.viewMask = 0;
            rendering_info.colorAttachmentCount = 1;
            rendering_info.pColorAttachmentFormats = &swapchain_format;
            if (depth_format != VK_FORMAT_UNDEFINED) {
                rendering_info.depthAttachmentFormat = depth_format;
            }
 
            VkGraphicsPipelineCreateInfo pipeline_info{};
            pipeline_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
            pipeline_info.pNext = &rendering_info;
            pipeline_info.stageCount = 2;
            pipeline_info.pStages = shader_stages;
            pipeline_info.pVertexInputState = &vertex_input;
            pipeline_info.pInputAssemblyState = &input_assembly;
            pipeline_info.pViewportState = &viewport_state;
            pipeline_info.pRasterizationState = &rasterizer;
            pipeline_info.pMultisampleState = &multisampling;
            pipeline_info.pDepthStencilState = &depth_stencil;
            pipeline_info.pColorBlendState = &color_blending;
            pipeline_info.pDynamicState = &dynamic_state;
            pipeline_info.layout = text_pipeline_layout;
            pipeline_info.renderPass = VK_NULL_HANDLE;
            pipeline_info.subpass = 0;
            pipeline_info.basePipelineHandle = VK_NULL_HANDLE;
            pipeline_info.basePipelineIndex = -1;
 
            if (vkCreateGraphicsPipelines(device, pipeline_cache, 1, &pipeline_info, nullptr, &text_pipeline) != VK_SUCCESS) {
                throw mxvk::Exception("Failed to create text graphics pipeline");
            }
        } catch (...) {
            if (text_pipeline != VK_NULL_HANDLE) {
                vkDestroyPipeline(device, text_pipeline, nullptr);
                text_pipeline = VK_NULL_HANDLE;
            }
            if (text_pipeline_layout != VK_NULL_HANDLE) {
                vkDestroyPipelineLayout(device, text_pipeline_layout, nullptr);
                text_pipeline_layout = VK_NULL_HANDLE;
            }
            if (frag_module != VK_NULL_HANDLE) {
                vkDestroyShaderModule(device, frag_module, nullptr);
            }
            vkDestroyShaderModule(device, vert_module, nullptr);
            throw;
        }
 
        vkDestroyShaderModule(device, frag_module, nullptr);
        vkDestroyShaderModule(device, vert_module, nullptr);
    }
 
    VK_Sprite *VK_Window::createSprite(const std::string &pngPath, const std::string &vertexShaderPath, const std::string &fragmentShaderPath) {
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create sprite before Vulkan device initialization");
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create sprite before swapchain and command resources are available");
        }
 
        if (sprite_descriptor_set_layout == VK_NULL_HANDLE) {
            createSpriteDescriptorSetLayout();
        }
 
        auto sprite = std::make_unique<VK_Sprite>(device, physical_device, graphics_queue, command_pool);
        sprite->setPipelineCache(pipeline_cache);
        sprite->setDescriptorSetLayout(sprite_descriptor_set_layout);
        sprite->setColorAttachmentFormat(swapchain_format);
        sprite->setDepthAttachmentFormat(depth_format);
 
        if (!vertexShaderPath.empty()) {
            sprite->setVertexShaderPath(vertexShaderPath);
        }
 
        sprite->loadSprite(pngPath, fragmentShaderPath);
 
        VK_Sprite *const sprite_ptr = sprite.get();
        sprites.push_back(std::move(sprite));
        sprite_state_dirty = true;
        return sprite_ptr;
    }
 
    VK_Sprite *VK_Window::createSprite(SDL_Surface *surface, const std::string &vertexShaderPath, const std::string &fragmentShaderPath) {
        if (surface == nullptr) {
            throw mxvk::Exception("Cannot create sprite from a null SDL surface");
        }
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create sprite before Vulkan device initialization");
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create sprite before swapchain and command resources are available");
        }
 
        if (sprite_descriptor_set_layout == VK_NULL_HANDLE) {
            createSpriteDescriptorSetLayout();
        }
 
        auto sprite = std::make_unique<VK_Sprite>(device, physical_device, graphics_queue, command_pool);
        sprite->setPipelineCache(pipeline_cache);
        sprite->setDescriptorSetLayout(sprite_descriptor_set_layout);
        sprite->setColorAttachmentFormat(swapchain_format);
        sprite->setDepthAttachmentFormat(depth_format);
 
        if (!vertexShaderPath.empty()) {
            sprite->setVertexShaderPath(vertexShaderPath);
        }
        if (!fragmentShaderPath.empty()) {
            sprite->enableExtendedUBO();
        }
 
        sprite->loadSprite(surface, fragmentShaderPath);
 
        VK_Sprite *const sprite_ptr = sprite.get();
        sprites.push_back(std::move(sprite));
        sprite_state_dirty = true;
        return sprite_ptr;
    }
 
    VK_Sprite *VK_Window::createSprite(int width, int height, const std::string &vertexShaderPath, const std::string &fragmentShaderPath, uint32_t spectrumBinCount) { return createSprite(width, height, vertexShaderPath, fragmentShaderPath, spectrumBinCount, 0); }
 
    VK_Sprite *VK_Window::createSprite(int width, int height, const std::string &vertexShaderPath, const std::string &fragmentShaderPath, uint32_t spectrumBinCount, uint32_t spectrumHistoryLayerCount) {
        if (width <= 0 || height <= 0) {
            throw mxvk::Exception("Sprite dimensions must be positive");
        }
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create sprite before Vulkan device initialization");
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create sprite before swapchain and command resources are available");
        }
 
        if (sprite_descriptor_set_layout == VK_NULL_HANDLE) {
            createSpriteDescriptorSetLayout();
        }
 
        auto sprite = std::make_unique<VK_Sprite>(device, physical_device, graphics_queue, command_pool);
        sprite->setPipelineCache(pipeline_cache);
        sprite->setDescriptorSetLayout(sprite_descriptor_set_layout);
        sprite->setColorAttachmentFormat(swapchain_format);
        sprite->setDepthAttachmentFormat(depth_format);
        if (!fragmentShaderPath.empty()) {
            sprite->enableExtendedUBO();
        }
        if (spectrumBinCount > 0) {
            sprite->enableSpectrumTexture(spectrumBinCount);
        }
        if (spectrumHistoryLayerCount > 0) {
            if (spectrumBinCount == 0) {
                throw mxvk::Exception("Spectrum history requires a positive spectrum bin count");
            }
            sprite->enableSpectrumHistoryTexture(spectrumBinCount, spectrumHistoryLayerCount);
        }
 
        sprite->createEmptySprite(width, height, vertexShaderPath, fragmentShaderPath);
 
        VK_Sprite *const sprite_ptr = sprite.get();
        sprites.push_back(std::move(sprite));
        sprite_state_dirty = true;
        return sprite_ptr;
    }
 
    VK_Sprite3D *VK_Window::createSprite3D(const std::string &pngPath, const std::string &vertexShaderPath, const std::string &fragmentShaderPath) {
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create 3D sprite before Vulkan device initialization");
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create 3D sprite before swapchain and command resources are available");
        }
 
        const std::string vertPath = vertexShaderPath.empty() ? resolveRuntimeShaderPath("sprite3d.vert.spv", MXVK_SPRITE3D_SHADER_DIR) : vertexShaderPath;
        const std::string fragPath = fragmentShaderPath.empty() ? resolveRuntimeShaderPath("sprite3d.frag.spv", MXVK_SPRITE3D_SHADER_DIR) : fragmentShaderPath;
 
        auto sprite = std::make_unique<VK_Sprite3D>();
        sprite->load(this, pngPath, vertPath, fragPath);
 
        VK_Sprite3D *const sprite_ptr = sprite.get();
        sprites3d.push_back(std::move(sprite));
        return sprite_ptr;
    }
 
    VK_Sprite3D *VK_Window::createSprite3D(SDL_Surface *surface, const std::string &vertexShaderPath, const std::string &fragmentShaderPath) {
        if (surface == nullptr) {
            throw mxvk::Exception("Cannot create 3D sprite from a null SDL surface");
        }
        if (device == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create 3D sprite before Vulkan device initialization");
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            createDevice();
        }
        if (!renderTargetsReady() || command_pool == VK_NULL_HANDLE) {
            throw mxvk::Exception("Cannot create 3D sprite before swapchain and command resources are available");
        }
 
        const std::string vertPath = vertexShaderPath.empty() ? resolveRuntimeShaderPath("sprite3d.vert.spv", MXVK_SPRITE3D_SHADER_DIR) : vertexShaderPath;
        const std::string fragPath = fragmentShaderPath.empty() ? resolveRuntimeShaderPath("sprite3d.frag.spv", MXVK_SPRITE3D_SHADER_DIR) : fragmentShaderPath;
 
        auto sprite = std::make_unique<VK_Sprite3D>();
        sprite->load(this, surface, vertPath, fragPath);
 
        VK_Sprite3D *const sprite_ptr = sprite.get();
        sprites3d.push_back(std::move(sprite));
        return sprite_ptr;
    }
 
    void VK_Window::showCursor(bool on) {
        if (on)
            SDL_ShowCursor();
        else
            SDL_HideCursor();
    }
 
    void VK_Window::createSpriteDescriptorSetLayout() {
        if (device == VK_NULL_HANDLE || sprite_descriptor_set_layout != VK_NULL_HANDLE) {
            return;
        }
 
        VkDescriptorSetLayoutBinding sampler_binding{};
        sampler_binding.binding = 0;
        sampler_binding.descriptorCount = 1;
        sampler_binding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
        sampler_binding.pImmutableSamplers = nullptr;
        sampler_binding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
 
        VkDescriptorSetLayoutCreateInfo layout_info{};
        layout_info.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
        layout_info.bindingCount = 1;
        layout_info.pBindings = &sampler_binding;
 
        if (vkCreateDescriptorSetLayout(device, &layout_info, nullptr, &sprite_descriptor_set_layout) != VK_SUCCESS) {
            throw mxvk::Exception("Failed to create sprite descriptor set layout");
        }
    }
 
    void VK_Window::destroySpritePipeline() {
        if (device == VK_NULL_HANDLE) {
            sprite_pipeline = VK_NULL_HANDLE;
            sprite_pipeline_layout = VK_NULL_HANDLE;
            return;
        }
 
        if (sprite_pipeline != VK_NULL_HANDLE) {
            std::cout << "vk: destroying sprite pipeline\n";
            vkDestroyPipeline(device, sprite_pipeline, nullptr);
            sprite_pipeline = VK_NULL_HANDLE;
        }
        if (sprite_pipeline_layout != VK_NULL_HANDLE) {
            std::cout << "vk: destroying sprite pipeline layout\n";
            vkDestroyPipelineLayout(device, sprite_pipeline_layout, nullptr);
            sprite_pipeline_layout = VK_NULL_HANDLE;
        }
    }
 
    void VK_Window::createSpritePipeline() {
        if (device == VK_NULL_HANDLE || swapchain_format == VK_FORMAT_UNDEFINED) {
            return;
        }
        if (sprite_descriptor_set_layout == VK_NULL_HANDLE) {
            createSpriteDescriptorSetLayout();
        }
 
        destroySpritePipeline();
 
        const std::vector<char> vert_shader = loadSpv(resolveRuntimeShaderPath("sprite.vert.spv", MXVK_SPRITE_SHADER_DIR));
        const std::vector<char> frag_shader = loadSpv(resolveRuntimeShaderPath("sprite.frag.spv", MXVK_SPRITE_SHADER_DIR));
 
        const VkShaderModule vert_module = createShaderModule(device, vert_shader);
        VkShaderModule frag_module = VK_NULL_HANDLE;
 
        try {
            frag_module = createShaderModule(device, frag_shader);
 
            VkPipelineShaderStageCreateInfo vert_stage{};
            vert_stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
            vert_stage.stage = VK_SHADER_STAGE_VERTEX_BIT;
            vert_stage.module = vert_module;
            vert_stage.pName = "main";
 
            VkPipelineShaderStageCreateInfo frag_stage{};
            frag_stage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
            frag_stage.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
            frag_stage.module = frag_module;
            frag_stage.pName = "main";
 
            const VkPipelineShaderStageCreateInfo shader_stages[] = {vert_stage, frag_stage};
 
            VkVertexInputBindingDescription binding_description{};
            binding_description.binding = 0;
            binding_description.stride = sizeof(float) * 4;
            binding_description.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
 
            std::array<VkVertexInputAttributeDescription, 2> attributes{};
            attributes[0].binding = 0;
            attributes[0].location = 0;
            attributes[0].format = VK_FORMAT_R32G32_SFLOAT;
            attributes[0].offset = 0;
            attributes[1].binding = 0;
            attributes[1].location = 1;
            attributes[1].format = VK_FORMAT_R32G32_SFLOAT;
            attributes[1].offset = sizeof(float) * 2;
 
            VkPipelineVertexInputStateCreateInfo vertex_input{};
            vertex_input.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
            vertex_input.vertexBindingDescriptionCount = 1;
            vertex_input.pVertexBindingDescriptions = &binding_description;
            vertex_input.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributes.size());
            vertex_input.pVertexAttributeDescriptions = attributes.data();
 
            VkPipelineInputAssemblyStateCreateInfo input_assembly{};
            input_assembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
            input_assembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
            input_assembly.primitiveRestartEnable = VK_FALSE;
 
            const std::array<VkDynamicState, 2> dynamic_states = {
                VK_DYNAMIC_STATE_VIEWPORT,
                VK_DYNAMIC_STATE_SCISSOR,
            };
            VkPipelineDynamicStateCreateInfo dynamic_state{};
            dynamic_state.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
            dynamic_state.dynamicStateCount = static_cast<uint32_t>(dynamic_states.size());
            dynamic_state.pDynamicStates = dynamic_states.data();
 
            VkPipelineViewportStateCreateInfo viewport_state{};
            viewport_state.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
            viewport_state.viewportCount = 1;
            viewport_state.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_NONE;
            rasterizer.frontFace = VK_FRONT_FACE_COUNTER_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;
 
            VkPipelineDepthStencilStateCreateInfo depth_stencil{};
            depth_stencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
            depth_stencil.depthTestEnable = VK_FALSE;
            depth_stencil.depthWriteEnable = VK_FALSE;
 
            VkPipelineColorBlendAttachmentState color_attachment{};
            color_attachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
            color_attachment.blendEnable = VK_TRUE;
            color_attachment.srcColorBlendFactor = VK_BLEND_FACTOR_SRC_ALPHA;
            color_attachment.dstColorBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
            color_attachment.colorBlendOp = VK_BLEND_OP_ADD;
            color_attachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
            color_attachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
            color_attachment.alphaBlendOp = VK_BLEND_OP_ADD;
 
            VkPipelineColorBlendStateCreateInfo color_blending{};
            color_blending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
            color_blending.logicOpEnable = VK_FALSE;
            color_blending.attachmentCount = 1;
            color_blending.pAttachments = &color_attachment;
 
            VkPushConstantRange push_constant_range{};
            push_constant_range.stageFlags = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
            push_constant_range.offset = 0;
            push_constant_range.size = sizeof(float) * 12;
 
            VkPipelineLayoutCreateInfo pipeline_layout_info{};
            pipeline_layout_info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
            pipeline_layout_info.setLayoutCount = 1;
            pipeline_layout_info.pSetLayouts = &sprite_descriptor_set_layout;
            pipeline_layout_info.pushConstantRangeCount = 1;
            pipeline_layout_info.pPushConstantRanges = &push_constant_range;
 
            if (vkCreatePipelineLayout(device, &pipeline_layout_info, nullptr, &sprite_pipeline_layout) != VK_SUCCESS) {
                throw mxvk::Exception("Failed to create sprite pipeline layout");
            }
 
            VkPipelineRenderingCreateInfo rendering_info{};
            rendering_info.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
            rendering_info.viewMask = 0;
            rendering_info.colorAttachmentCount = 1;
            rendering_info.pColorAttachmentFormats = &swapchain_format;
            if (depth_format != VK_FORMAT_UNDEFINED) {
                rendering_info.depthAttachmentFormat = depth_format;
            }
 
            VkGraphicsPipelineCreateInfo pipeline_info{};
            pipeline_info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
            pipeline_info.pNext = &rendering_info;
            pipeline_info.stageCount = 2;
            pipeline_info.pStages = shader_stages;
            pipeline_info.pVertexInputState = &vertex_input;
            pipeline_info.pInputAssemblyState = &input_assembly;
            pipeline_info.pViewportState = &viewport_state;
            pipeline_info.pRasterizationState = &rasterizer;
            pipeline_info.pMultisampleState = &multisampling;
            pipeline_info.pDepthStencilState = &depth_stencil;
            pipeline_info.pColorBlendState = &color_blending;
            pipeline_info.pDynamicState = &dynamic_state;
            pipeline_info.layout = sprite_pipeline_layout;
            pipeline_info.renderPass = VK_NULL_HANDLE;
            pipeline_info.subpass = 0;
            pipeline_info.basePipelineHandle = VK_NULL_HANDLE;
            pipeline_info.basePipelineIndex = -1;
 
            if (vkCreateGraphicsPipelines(device, pipeline_cache, 1, &pipeline_info, nullptr, &sprite_pipeline) != VK_SUCCESS) {
                throw mxvk::Exception("Failed to create sprite graphics pipeline");
            }
        } catch (...) {
            if (sprite_pipeline != VK_NULL_HANDLE) {
                vkDestroyPipeline(device, sprite_pipeline, nullptr);
                sprite_pipeline = VK_NULL_HANDLE;
            }
            if (sprite_pipeline_layout != VK_NULL_HANDLE) {
                vkDestroyPipelineLayout(device, sprite_pipeline_layout, nullptr);
                sprite_pipeline_layout = VK_NULL_HANDLE;
            }
            if (frag_module != VK_NULL_HANDLE) {
                vkDestroyShaderModule(device, frag_module, nullptr);
            }
            vkDestroyShaderModule(device, vert_module, nullptr);
            throw;
        }
 
        vkDestroyShaderModule(device, frag_module, nullptr);
        vkDestroyShaderModule(device, vert_module, nullptr);
    }
} // namespace mxvk