327 lines
12 KiB
C++
327 lines
12 KiB
C++
#include "core/rendering/screen.hpp"
|
|
|
|
#include <SDL3/SDL.h>
|
|
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <memory>
|
|
|
|
#include "core/rendering/canvas.hpp"
|
|
#include "core/rendering/sdl3gpu/viewport.hpp"
|
|
#include "utils/defines.hpp"
|
|
#include "utils/log.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), Rendering::OPAQUE_ALPHA);
|
|
}
|
|
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();
|
|
Log::info("Screen", "path GPU actiu (driver: {})", gpu_driver_);
|
|
shader_backend_ = std::move(backend);
|
|
return;
|
|
}
|
|
Log::warn("Screen", "GPU no disponible, fallback a SDL_Renderer");
|
|
}
|
|
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 = Rendering::OPAQUE_ALPHA | (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 auto CLIP = Rendering::activeClip();
|
|
const int X0 = std::max(x, CLIP.x);
|
|
const int Y0 = std::max(y, CLIP.y);
|
|
const int X1 = std::min(x + w, CLIP.x + CLIP.w);
|
|
const int Y1 = std::min(y + h, CLIP.y + CLIP.h);
|
|
// Bail-out defensiu: si el rang és buit o invertit després del clip,
|
|
// `std::fill(first, last)` amb `first > last` és UB i a la pràctica
|
|
// entra en bucle infinit (vist en un crash a l'overflow del Notifier
|
|
// quan la caixa quedava més ampla que el canvas). El `blendRect`
|
|
// d'aquí baix ja és segur perquè usa `for(ix; ix < X1; ...)`.
|
|
if (X1 <= X0 || Y1 <= Y0) { return; }
|
|
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::blendRect(int x, int y, int w, int h, std::uint32_t argb, std::uint8_t alpha) {
|
|
if (alpha == 0) { return; }
|
|
if (alpha == 0xFF) {
|
|
fillRect(x, y, w, h, argb);
|
|
return;
|
|
}
|
|
// Mescla linealment src (argb, alpha) sobre dst (el canvas). El canvas
|
|
// és ARGB amb R/G/B als bytes baixos i A fix a 0xFF; fem la mescla per
|
|
// canal i deixem A intacte perquè el backend espera opacitat total.
|
|
const std::uint8_t SA = alpha;
|
|
const std::uint8_t INV = 255 - alpha;
|
|
const std::uint8_t SR = (argb >> 16) & 0xFF;
|
|
const std::uint8_t SG = (argb >> 8) & 0xFF;
|
|
const std::uint8_t SB = argb & 0xFF;
|
|
const auto CLIP = Rendering::activeClip();
|
|
const int X0 = std::max(x, CLIP.x);
|
|
const int Y0 = std::max(y, CLIP.y);
|
|
const int X1 = std::min(x + w, CLIP.x + CLIP.w);
|
|
const int Y1 = std::min(y + h, CLIP.y + CLIP.h);
|
|
for (int iy = Y0; iy < Y1; ++iy) {
|
|
std::uint32_t* row = canvas_.data() + (static_cast<std::ptrdiff_t>(iy) * canvas_width_);
|
|
for (int ix = X0; ix < X1; ++ix) {
|
|
const std::uint32_t DST = row[ix];
|
|
const std::uint8_t DR = (DST >> 16) & 0xFF;
|
|
const std::uint8_t DG = (DST >> 8) & 0xFF;
|
|
const std::uint8_t DB = DST & 0xFF;
|
|
const std::uint8_t R = ((SR * SA) + (DR * INV)) / 255;
|
|
const std::uint8_t G = ((SG * SA) + (DG * INV)) / 255;
|
|
const std::uint8_t B = ((SB * SA) + (DB * INV)) / 255;
|
|
row[ix] = 0xFF000000U | (static_cast<std::uint32_t>(R) << 16) | (static_cast<std::uint32_t>(G) << 8) | static_cast<std::uint32_t>(B);
|
|
}
|
|
}
|
|
}
|
|
|
|
auto Screen::windowToCanvas(float window_x, float window_y) const -> SDL_FPoint {
|
|
// Path fallback: SDL ja porta un helper que desfà el
|
|
// logical_presentation automàticament. Evita que haguem de replicar
|
|
// les regles de letterbox/integer/etc.
|
|
if (renderer_ != nullptr) {
|
|
float cx = 0.0F;
|
|
float cy = 0.0F;
|
|
SDL_RenderCoordinatesFromWindow(renderer_, window_x, window_y, &cx, &cy);
|
|
return {cx, cy};
|
|
}
|
|
// Path GPU: el canvas es pinta al viewport que calcula
|
|
// `computeViewport` a partir del mode d'escalat i la mida del
|
|
// swapchain. Fem el mateix càlcul aquí per trobar la inversa.
|
|
int win_w = 0;
|
|
int win_h = 0;
|
|
SDL_GetWindowSize(window_, &win_w, &win_h);
|
|
if (win_w <= 0 || win_h <= 0) { return {-1.0F, -1.0F}; }
|
|
const auto VP = Rendering::computeViewport(config_.scaling_mode,
|
|
static_cast<std::uint32_t>(win_w),
|
|
static_cast<std::uint32_t>(win_h),
|
|
canvas_width_,
|
|
canvas_height_);
|
|
if (VP.w <= 0.0F || VP.h <= 0.0F) { return {-1.0F, -1.0F}; }
|
|
const float NX = (window_x - VP.x) / VP.w;
|
|
const float NY = (window_y - VP.y) / VP.h;
|
|
return {NX * static_cast<float>(canvas_width_), NY * static_cast<float>(canvas_height_)};
|
|
}
|
|
|
|
void Screen::setOverlayRenderer(std::function<void()> callback) {
|
|
overlay_renderer_ = std::move(callback);
|
|
}
|
|
|
|
void Screen::present() {
|
|
// Overlays (menú de servei, etc.) s'han de pintar al canvas ABANS que
|
|
// shader_backend llegisca els píxels per pujar-los a GPU; si no, queden
|
|
// per sota del postprocés o no apareixen al frame presentat.
|
|
if (overlay_renderer_) { overlay_renderer_(); }
|
|
|
|
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_);
|
|
}
|