aee-arcade/source/core/rendering/screen.cpp

#include "core/rendering/screen.hpp"

#include <SDL3/SDL.h>

#include <algorithm>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <ranges>

#include "utils/defines.hpp"

namespace {

    auto toSdlPresentation(Defaults::ScalingMode mode) -> SDL_RendererLogicalPresentation {
        switch (mode) {
            case Defaults::ScalingMode::DISABLED:
                return SDL_LOGICAL_PRESENTATION_DISABLED;
            case Defaults::ScalingMode::STRETCH:
                return SDL_LOGICAL_PRESENTATION_STRETCH;
            case Defaults::ScalingMode::LETTERBOX:
                return SDL_LOGICAL_PRESENTATION_LETTERBOX;
            case Defaults::ScalingMode::OVERSCAN:
                return SDL_LOGICAL_PRESENTATION_OVERSCAN;
            case Defaults::ScalingMode::INTEGER:
                return SDL_LOGICAL_PRESENTATION_INTEGER_SCALE;
        }
        return SDL_LOGICAL_PRESENTATION_LETTERBOX;
    }

    auto toSdlScaleMode(Defaults::TextureFilter filter) -> SDL_ScaleMode {
        return filter == Defaults::TextureFilter::LINEAR ? SDL_SCALEMODE_LINEAR : SDL_SCALEMODE_NEAREST;
    }

}  // namespace

auto Screen::get() -> Screen& {
    static Screen instance_;
    return instance_;
}

void Screen::configure(const Config& config) {
    // Inicialitza el subsistema de vídeo la primera volta; reconfiguracions
    // posteriors reutilitzen el subsistema i recreen els recursos SDL.
    if (!subsystem_initialized_) {
        if (!SDL_InitSubSystem(SDL_INIT_VIDEO)) {
            std::fprintf(stderr, "SDL_InitSubSystem(VIDEO) failed: %s\n", SDL_GetError());
            std::exit(EXIT_FAILURE);
        }
        subsystem_initialized_ = true;
        canvas_width_ = GameCanvas::WIDTH;
        canvas_height_ = GameCanvas::HEIGHT;
        canvas_.assign(static_cast<std::size_t>(GameCanvas::WIDTH) * static_cast<std::size_t>(GameCanvas::HEIGHT), 0xFF000000U);
    }
    destroySdl();
    config_ = config;
    createSdl();
}

void Screen::shutdown() {
    destroySdl();
    if (subsystem_initialized_) {
        SDL_QuitSubSystem(SDL_INIT_VIDEO);
        subsystem_initialized_ = false;
    }
}

void Screen::destroySdl() {
    // Ordre per a evitar crashes a Wayland/Vulkan durant el teardown:
    //   1) Alliberar la finestra del GPU device (destrueix el VkSurface).
    //   2) Destruir el GPU device (vkDestroyInstance amb Wayland encara viu).
    //   3) Destruir la finestra SDL (tanca la surface de Wayland al final).
    if (shader_backend_ != nullptr) {
        shader_backend_->releaseWindow();
    }
    shader_backend_.reset();
    if (game_texture_ != nullptr) {
        SDL_DestroyTexture(game_texture_);
        game_texture_ = nullptr;
    }
    if (renderer_ != nullptr) {
        SDL_DestroyRenderer(renderer_);
        renderer_ = nullptr;
    }
    if (window_ != nullptr) {
        SDL_DestroyWindow(window_);
        window_ = nullptr;
    }
}

void Screen::createSdl() {
    const int WIN_W = GameCanvas::WIDTH * config_.zoom;
    const int WIN_H = GameCanvas::HEIGHT * config_.zoom;

    Uint32 win_flags = SDL_WINDOW_RESIZABLE;
    if (config_.fullscreen) { win_flags |= SDL_WINDOW_FULLSCREEN; }

    window_ = SDL_CreateWindow(Texts::WINDOW_TITLE, WIN_W, WIN_H, win_flags);
    if (window_ == nullptr) {
        std::fprintf(stderr, "SDL_CreateWindow failed: %s\n", SDL_GetError());
        std::exit(EXIT_FAILURE);
    }

    // Primer intent: path SDL3 GPU. Si falla, fallback automàtic a SDL_Renderer.
    if (config_.gpu_acceleration) {
        auto backend = Rendering::makeDefaultShaderBackend();
        backend->setPreferredDriver(config_.preferred_driver);
        backend->setVSync(config_.vsync);
        if (backend->init(window_, canvas_width_, canvas_height_)) {
            gpu_driver_ = backend->getDriverName();
            std::cout << "Screen: path GPU actiu (driver: " << gpu_driver_ << ")\n";
            shader_backend_ = std::move(backend);
            return;
        }
        std::cerr << "Screen: GPU no disponible, fallback a SDL_Renderer\n";
    }
    gpu_driver_ = "sdl";

    renderer_ = SDL_CreateRenderer(window_, nullptr);
    if (renderer_ == nullptr) {
        std::fprintf(stderr, "SDL_CreateRenderer failed: %s\n", SDL_GetError());
        std::exit(EXIT_FAILURE);
    }

    SDL_SetRenderVSync(renderer_, config_.vsync ? 1 : 0);
    SDL_SetRenderLogicalPresentation(renderer_, GameCanvas::WIDTH, GameCanvas::HEIGHT, toSdlPresentation(config_.scaling_mode));

    // STREAMING: el framebuffer ARGB del joc s'actualitza per CPU cada frame
    // i s'envia a la GPU via SDL_UpdateTexture en present().
    game_texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, GameCanvas::WIDTH, GameCanvas::HEIGHT);
    if (game_texture_ == nullptr) {
        std::fprintf(stderr, "SDL_CreateTexture failed: %s\n", SDL_GetError());
        std::exit(EXIT_FAILURE);
    }
    SDL_SetTextureScaleMode(game_texture_, toSdlScaleMode(config_.texture_filter));
}

void Screen::applyPostFXParams(const Rendering::PostFXParams& params) {
    if (shader_backend_ != nullptr) {
        shader_backend_->setPostFXParams(params);
    }
}

void Screen::setActiveShader(Rendering::ShaderType type) {
    if (shader_backend_ != nullptr) {
        shader_backend_->setActiveShader(type);
    }
}

void Screen::applyCrtPiParams(const Rendering::CrtPiParams& params) {
    if (shader_backend_ != nullptr) {
        shader_backend_->setCrtPiParams(params);
    }
}

void Screen::setWindowZoom(int zoom) {
    config_.zoom = zoom;
    adjustWindowSize();
}

void Screen::setFullscreen(bool fullscreen) {
    config_.fullscreen = fullscreen;
    SDL_SetWindowFullscreen(window_, fullscreen);
    SDL_SyncWindow(window_);
    adjustWindowSize();
}

void Screen::setVSync(bool vsync) {
    config_.vsync = vsync;
    if (shader_backend_ != nullptr) {
        shader_backend_->setVSync(vsync);
    } else if (renderer_ != nullptr) {
        SDL_SetRenderVSync(renderer_, vsync ? 1 : 0);
    }
}

void Screen::setScalingMode(Defaults::ScalingMode mode) {
    config_.scaling_mode = mode;
    if (shader_backend_ != nullptr) {
        shader_backend_->setScalingMode(mode);
    } else if (renderer_ != nullptr) {
        SDL_SetRenderLogicalPresentation(renderer_, GameCanvas::WIDTH, GameCanvas::HEIGHT, toSdlPresentation(mode));
    }
}

// Fullscreen manté la resolució del desktop; en mode finestra recalculem i
// reposicionem. A Wayland el compositor ignora SDL_SetWindowPosition, així
// que allí el reset queda en mans del WM.
void Screen::adjustWindowSize() {
    if (config_.fullscreen) { return; }

    int old_w = 0;
    int old_h = 0;
    SDL_GetWindowSize(window_, &old_w, &old_h);
    int old_x = 0;
    int old_y = 0;
    SDL_GetWindowPosition(window_, &old_x, &old_y);

    const int NEW_W = GameCanvas::WIDTH * config_.zoom;
    const int NEW_H = GameCanvas::HEIGHT * config_.zoom;
    const int NEW_X = old_x + ((old_w - NEW_W) / 2);
    const int NEW_Y = old_y + ((old_h - NEW_H) / 2);

    SDL_SetWindowSize(window_, NEW_W, NEW_H);
    SDL_SyncWindow(window_);

    const char* driver = SDL_GetCurrentVideoDriver();
    const bool IS_WAYLAND = (driver != nullptr && SDL_strcmp(driver, "wayland") == 0);
    if (!IS_WAYLAND) {
        SDL_SetWindowPosition(window_, std::max(NEW_X, 0), std::max(NEW_Y, 0));
    }
}

void Screen::clear(std::uint8_t r, std::uint8_t g, std::uint8_t b) {
    const std::uint32_t COLOR = (0xFFU << 24) | (static_cast<std::uint32_t>(r) << 16) | (static_cast<std::uint32_t>(g) << 8) | static_cast<std::uint32_t>(b);
    std::ranges::fill(canvas_, COLOR);
}

void Screen::fillRect(int x, int y, int w, int h, std::uint32_t argb) {
    const int X0 = std::max(x, 0);
    const int Y0 = std::max(y, 0);
    const int X1 = std::min(x + w, canvas_width_);
    const int Y1 = std::min(y + h, canvas_height_);
    for (int iy = Y0; iy < Y1; ++iy) {
        std::uint32_t* row = canvas_.data() + (static_cast<std::ptrdiff_t>(iy) * canvas_width_);
        std::fill(row + X0, row + X1, argb);
    }
}

void Screen::present() {
    fps_.increment();
    fps_.calculate(SDL_GetTicks());

    if (shader_backend_ != nullptr) {
        shader_backend_->uploadPixels(canvas_.data(), canvas_width_, canvas_height_);
        shader_backend_->render();
        return;
    }

    SDL_UpdateTexture(game_texture_, nullptr, canvas_.data(), canvas_width_ * static_cast<int>(sizeof(std::uint32_t)));
    SDL_SetRenderDrawColor(renderer_, 0x00, 0x00, 0x00, 0xFF);
    SDL_RenderClear(renderer_);
    SDL_RenderTexture(renderer_, game_texture_, nullptr, nullptr);
    SDL_RenderPresent(renderer_);
}