jaildesigner-jailgames/orni-attack
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Fase 7b+c: swap atomico a SDL3 GPU (Vulkan/Metal, sin SDL_Renderer)

Browse Source 
El runtime de rendering pasa a SDL3 GPU. SDL_Renderer eliminado por
completo del proyecto: SDLManager posee un GpuFrameRenderer y todo
el resto del codigo habla con un Rendering::Renderer* opaco (alias
del GpuFrameRenderer).

Cambios principales:

- core/rendering/render_context.hpp: alias central
  `using Rendering::Renderer = GPU::GpuFrameRenderer;` — punto unico
  de indireccion entre el juego y el backend de dibujo.

- core/rendering/sdl_manager.hpp/cpp: deja de tener SDL_Renderer*;
  contiene un Rendering::Renderer gpu_renderer_. iniciar() ahora hace
  GpuDevice::init + pipeline; clear() llama beginFrame; present()
  llama endFrame. Letterbox se aplica via setViewport tras cada
  begin del render pass. toggleVSync() usa
  SDL_SetGPUSwapchainParameters.

- core/rendering/line_renderer.hpp/cpp: la firma cambia a
  `linea(Renderer*, x1,y1,x2,y2, brightness, thickness)`. La
  implementacion deja de usar SDL_RenderLine: empuja la linea como
  quad extrudido al batch del GpuFrameRenderer. Se anade un grosor
  global configurable via setLineThickness (default 1.5 px). Ya no
  se aplica transform_x/y porque el shader hace logical->NDC y el
  viewport hace el letterbox.

- gpu_frame_renderer: anade setViewport (aplicable mid-frame),
  setVSync (PRESENTMODE_VSYNC/IMMEDIATE) y applyViewport interno
  que re-aplica el viewport tras reabrir el render pass en flushBatch.

- Sed sweep masivo en 19 archivos: SDL_Renderer* -> Rendering::Renderer*
  en headers y .cpp de entities, effects, graphics y title. Los
  archivos solo propagan el puntero — solo line_renderer consume sus
  metodos. SDL_Renderer queda eliminado del proyecto.

Smoke test xvfb: backend Vulkan detectado, binario arranca, carga
todos los shapes/audio/title, TitleScene inicializa, termina limpio
con "Adeu!". stderr vacio. Validacion visual pendiente en hardware
real (xvfb VMware sin 3D no muestra el swapchain Vulkan).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Sergio Valor
2026-05-19 14:12:34 +02:00
parent ba6fd00b54
commit fa7da4ca58
26 changed files with 245 additions and 226 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/core/rendering/sdl_manager.cpp
+64 -171
View File
@@ -4,6 +4,8 @@
#include "sdl_manager.hpp"
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <format>
#include <iostream>
@@ -14,9 +16,45 @@
#include "game/options.hpp"
#include "project.h"
namespace {
auto initWindowAndGpu(SDL_Window** out_window,
Rendering::Renderer& gpu_renderer,
int width, int height, bool fullscreen) -> bool {
// Construir título dinámico
const std::string TITLE = std::format("{} v{} ({})", Project::LONG_NAME, Project::VERSION, Project::COPYRIGHT);
SDL_WindowFlags flags = SDL_WINDOW_RESIZABLE;
if (fullscreen) {
flags = static_cast<SDL_WindowFlags>(flags | SDL_WINDOW_FULLSCREEN);
}
SDL_Window* window = SDL_CreateWindow(TITLE.c_str(), width, height, flags);
if (window == nullptr) {
std::cerr << "Error creant finestra: " << SDL_GetError() << '\n';
return false;
}
if (!fullscreen) {
SDL_SetWindowPosition(window, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
}
// Inicializar el FrameRenderer (claim del window + pipeline de líneas).
if (!gpu_renderer.init(window,
static_cast<float>(Defaults::Game::WIDTH),
static_cast<float>(Defaults::Game::HEIGHT))) {
std::cerr << "Error inicialitzant GpuFrameRenderer\n";
SDL_DestroyWindow(window);
return false;
}
gpu_renderer.setVSync(Options::rendering.vsync != 0);
*out_window = window;
return true;
}
} // namespace
SDLManager::SDLManager()
: finestra_(nullptr),
renderer_(nullptr),
fps_accumulator_(0.0F),
fps_frame_count_(0),
fps_display_(0),
@@ -29,58 +67,27 @@ SDLManager::SDLManager()
windowed_width_(Defaults::Window::WIDTH),
windowed_height_(Defaults::Window::HEIGHT),
max_zoom_(1.0F) {
// Inicialitzar SDL3
if (!SDL_Init(SDL_INIT_VIDEO)) {
std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << '\n';
return;
}
// Calcular mida màxima des del display
calculateMaxWindowSize();
// Construir título dinàmic
std::string window_title = std::format("{} v{} ({})", Project::LONG_NAME, Project::VERSION, Project::COPYRIGHT);
// Crear finestra CENTRADA (SDL ho hace automàticament con CENTERED)
finestra_ =
SDL_CreateWindow(window_title.c_str(), current_width_, current_height_,
SDL_WINDOW_RESIZABLE // Permetre resize manual también
);
if (finestra_ == nullptr) {
std::cerr << "Error creant finestra: " << SDL_GetError() << '\n';
if (!initWindowAndGpu(&finestra_, gpu_renderer_, current_width_, current_height_, false)) {
SDL_Quit();
return;
}
// IMPORTANT: Centrar explícitament la finestra
SDL_SetWindowPosition(finestra_, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
// Crear renderer con aceleración
renderer_ = SDL_CreateRenderer(finestra_, nullptr);
if (renderer_ == nullptr) {
std::cerr << "Error creant renderer: " << SDL_GetError() << '\n';
SDL_DestroyWindow(finestra_);
SDL_Quit();
return;
}
// Aplicar configuración de V-Sync
SDL_SetRenderVSync(renderer_, Options::rendering.vsync);
// CRÍTIC: Configurar viewport scaling
updateLogicalPresentation();
updateViewport();
std::cout << "SDL3 inicialitzat: " << current_width_ << "x" << current_height_
<< " (logic: " << Defaults::Game::WIDTH << "x"
<< Defaults::Game::HEIGHT << ")" << '\n';
}
// Constructor con configuración
SDLManager::SDLManager(int width, int height, bool fullscreen)
: finestra_(nullptr),
renderer_(nullptr),
fps_accumulator_(0.0F),
fps_frame_count_(0),
fps_display_(0),
@@ -93,56 +100,21 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
windowed_width_(width),
windowed_height_(height),
max_zoom_(1.0F) {
// Inicialitzar SDL3
if (!SDL_Init(SDL_INIT_VIDEO)) {
std::cerr << "Error inicialitzant SDL3: " << SDL_GetError() << '\n';
return;
}
// Calcular mida màxima des del display
calculateMaxWindowSize();
// Construir título dinàmic
std::string window_title = std::format("{} v{} ({})", Project::LONG_NAME, Project::VERSION, Project::COPYRIGHT);
// Configurar flags de la finestra
SDL_WindowFlags flags = SDL_WINDOW_RESIZABLE;
if (is_fullscreen_) {
flags = static_cast<SDL_WindowFlags>(flags | SDL_WINDOW_FULLSCREEN);
}
// Crear finestra
finestra_ = SDL_CreateWindow(window_title.c_str(), current_width_, current_height_, flags);
if (finestra_ == nullptr) {
std::cerr << "Error creant finestra: " << SDL_GetError() << '\n';
if (!initWindowAndGpu(&finestra_, gpu_renderer_, current_width_, current_height_, is_fullscreen_)) {
SDL_Quit();
return;
}
// Centrar explícitament la finestra (si no es fullscreen)
if (!is_fullscreen_) {
SDL_SetWindowPosition(finestra_, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
}
updateViewport();
// Crear renderer con aceleración
renderer_ = SDL_CreateRenderer(finestra_, nullptr);
if (renderer_ == nullptr) {
std::cerr << "Error creant renderer: " << SDL_GetError() << '\n';
SDL_DestroyWindow(finestra_);
SDL_Quit();
return;
}
// Aplicar configuración de V-Sync
SDL_SetRenderVSync(renderer_, Options::rendering.vsync);
// Configurar viewport scaling
updateLogicalPresentation();
// Inicialitzar sistema de cursor
// En fullscreen: forzar ocultació permanent
// En fullscreen: forzar ocultació permanent del cursor.
if (is_fullscreen_) {
Mouse::setForceHidden(true);
}
@@ -157,10 +129,7 @@ SDLManager::SDLManager(int width, int height, bool fullscreen)
}
SDLManager::~SDLManager() {
if (renderer_ != nullptr) {
SDL_DestroyRenderer(renderer_);
renderer_ = nullptr;
}
gpu_renderer_.destroy();
if (finestra_ != nullptr) {
SDL_DestroyWindow(finestra_);
@@ -183,29 +152,20 @@ void SDLManager::calculateMaxWindowSize() {
<< " (max finestra: " << max_width_ << "x" << max_height_ << ")"
<< '\n';
} else {
// Fallback conservador
max_width_ = 1920;
max_height_ = 1080;
std::cerr << "No s'ha pogut detectar el display, usant fallback: "
<< max_width_ << "x" << max_height_ << '\n';
}
// Calculate max zoom immediately after determining max size
calculateMaxZoom();
}
void SDLManager::calculateMaxZoom() {
// Maximum zoom limited by BOTH width and height (preserves 4:3)
float max_zoom_width = static_cast<float>(max_width_) / Defaults::Window::WIDTH;
float max_zoom_height = static_cast<float>(max_height_) / Defaults::Window::HEIGHT;
// Take smaller constraint
float max_zoom_unrounded = std::min(max_zoom_width, max_zoom_height);
// Round DOWN to nearest 0.1 increment (user preference)
max_zoom_ = std::floor(max_zoom_unrounded / Defaults::Window::ZOOM_INCREMENT) * Defaults::Window::ZOOM_INCREMENT;
// Safety clamp
max_zoom_ = std::max(max_zoom_, Defaults::Window::MIN_ZOOM);
std::cout << "Max zoom: " << max_zoom_ << "x (display: "
@@ -213,37 +173,25 @@ void SDLManager::calculateMaxZoom() {
}
void SDLManager::applyZoom(float new_zoom) {
// Clamp to valid range
new_zoom = std::max(Defaults::Window::MIN_ZOOM,
std::min(new_zoom, max_zoom_));
// Round to nearest 0.1 increment
new_zoom = std::round(new_zoom / Defaults::Window::ZOOM_INCREMENT) * Defaults::Window::ZOOM_INCREMENT;
// No change?
if (std::abs(new_zoom - zoom_factor_) < 0.01F) {
return;
}
zoom_factor_ = new_zoom;
// Calculate physical dimensions (4:3 maintained automatically)
int new_width = static_cast<int>(std::round(
Defaults::Window::WIDTH * zoom_factor_));
int new_height = static_cast<int>(std::round(
Defaults::Window::HEIGHT * zoom_factor_));
int new_width = static_cast<int>(std::round(Defaults::Window::WIDTH * zoom_factor_));
int new_height = static_cast<int>(std::round(Defaults::Window::HEIGHT * zoom_factor_));
// Apply to window (centers via applyWindowSize)
applyWindowSize(new_width, new_height);
// Update viewport for new zoom
updateViewport();
// Update windowed size cache
windowed_width_ = new_width;
windowed_height_ = new_height;
// Persist
Options::window.width = new_width;
Options::window.height = new_height;
Options::window.zoom_factor = zoom_factor_;
@@ -252,30 +200,23 @@ void SDLManager::applyZoom(float new_zoom) {
<< new_width << "x" << new_height << ")" << '\n';
}
void SDLManager::updateLogicalPresentation() {
// CANVIAT: Ya no usem SDL_SetRenderLogicalPresentation
// Ara renderitzem directament a resolució física per evitar pixelació irregular
// El viewport con letterbox es configura a updateViewport()
updateViewport();
}
void SDLManager::updateViewport() {
// Calcular dimensions físiques basades en el zoom
// Cálculo de letterbox: el juego se renderiza a 1280×720 lógicos, pero
// la swapchain tiene el tamaño físico de la ventana. Aplicamos un viewport
// centrado con la proporción 16:9 para preservar aspect ratio.
float scale = zoom_factor_;
int scaled_width = static_cast<int>(std::round(Defaults::Game::WIDTH * scale));
int scaled_height = static_cast<int>(std::round(Defaults::Game::HEIGHT * scale));
// Cálculo de letterbox (centrar l'àrea scaled)
int offset_x = (current_width_ - scaled_width) / 2;
int offset_y = (current_height_ - scaled_height) / 2;
// Evitar offsets negatius
offset_x = std::max(offset_x, 0);
offset_y = std::max(offset_y, 0);
// Configurar viewport per al renderizado
SDL_Rect viewport = {offset_x, offset_y, scaled_width, scaled_height};
SDL_SetRenderViewport(renderer_, &viewport);
gpu_renderer_.setViewport(static_cast<float>(offset_x),
static_cast<float>(offset_y),
static_cast<float>(scaled_width),
static_cast<float>(scaled_height));
std::cout << "Viewport: " << scaled_width << "x" << scaled_height
<< " @ (" << offset_x << "," << offset_y << ") [scale=" << scale << "]"
@@ -283,7 +224,6 @@ void SDLManager::updateViewport() {
}
void SDLManager::updateRenderingContext() const {
// Actualitzar el factor de scale global para todas las funciones de renderizado
Rendering::g_current_scale_factor = zoom_factor_;
}
@@ -291,10 +231,8 @@ void SDLManager::increaseWindowSize() {
if (is_fullscreen_) {
return;
}
float new_zoom = zoom_factor_ + Defaults::Window::ZOOM_INCREMENT;
applyZoom(new_zoom);
std::cout << "F2: Zoom aumentat a " << zoom_factor_ << "x" << '\n';
}
@@ -302,15 +240,12 @@ void SDLManager::decreaseWindowSize() {
if (is_fullscreen_) {
return;
}
float new_zoom = zoom_factor_ - Defaults::Window::ZOOM_INCREMENT;
applyZoom(new_zoom);
std::cout << "F1: Zoom reduït a " << zoom_factor_ << "x" << '\n';
}
void SDLManager::applyWindowSize(int new_width, int new_height) {
// Obtenir posición actual ABANS del resize
int old_x;
int old_y;
SDL_GetWindowPosition(finestra_, &old_x, &old_y);
@@ -318,76 +253,56 @@ void SDLManager::applyWindowSize(int new_width, int new_height) {
int old_width = current_width_;
int old_height = current_height_;
// Actualitzar mida
SDL_SetWindowSize(finestra_, new_width, new_height);
current_width_ = new_width;
current_height_ = new_height;
// CENTRADO INTEL·LIGENT (algoritme de pollo)
// Calcular nueva posición per mantenir la finestra centrada sobre si misma
int delta_width = old_width - new_width;
int delta_height = old_height - new_height;
int new_x = old_x + (delta_width / 2);
int new_y = old_y + (delta_height / 2);
// Evitar que la finestra surti de la pantalla
constexpr int TITLEBAR_HEIGHT = 35; // Alçada aproximada de la barra de título
constexpr int TITLEBAR_HEIGHT = 35;
new_x = std::max(new_x, 0);
new_y = std::max(new_y, TITLEBAR_HEIGHT);
SDL_SetWindowPosition(finestra_, new_x, new_y);
// Actualitzar viewport después del resize
updateViewport();
}
void SDLManager::toggleFullscreen() {
if (!is_fullscreen_) {
// ENTERING FULLSCREEN
windowed_width_ = current_width_;
windowed_height_ = current_height_;
is_fullscreen_ = true;
SDL_SetWindowFullscreen(finestra_, true);
std::cout << "F3: Fullscreen activat (guardada: "
<< windowed_width_ << "x" << windowed_height_ << ")" << '\n';
} else {
// EXITING FULLSCREEN
is_fullscreen_ = false;
SDL_SetWindowFullscreen(finestra_, false);
// CRITICAL: Explicitly restore windowed size
applyWindowSize(windowed_width_, windowed_height_);
std::cout << "F3: Fullscreen desactivat (restaurada: "
<< windowed_width_ << "x" << windowed_height_ << ")" << '\n';
}
Options::window.fullscreen = is_fullscreen_;
// Notificar al mòdul Mouse: Fullscreen requereix ocultació permanent del cursor.
// Cuando es surt de fullscreen, restaurar el comportament normal de auto-ocultació.
Mouse::setForceHidden(is_fullscreen_);
}
bool SDLManager::handleWindowEvent(const SDL_Event& event) {
auto SDLManager::handleWindowEvent(const SDL_Event& event) -> bool {
if (event.type == SDL_EVENT_WINDOW_RESIZED) {
SDL_GetWindowSize(finestra_, &current_width_, &current_height_);
// Calculate zoom from actual size (may not align to 0.1 increments)
float new_zoom = static_cast<float>(current_width_) / Defaults::Window::WIDTH;
zoom_factor_ = std::max(Defaults::Window::MIN_ZOOM,
std::min(new_zoom, max_zoom_));
// Update windowed cache (if not in fullscreen)
if (!is_fullscreen_) {
windowed_width_ = current_width_;
windowed_height_ = current_height_;
}
// Actualitzar viewport después del resize manual
updateViewport();
std::cout << "Finestra redimensionada: " << current_width_
@@ -399,48 +314,35 @@ bool SDLManager::handleWindowEvent(const SDL_Event& event) {
}
void SDLManager::clear(uint8_t r, uint8_t g, uint8_t b) {
if (renderer_ == nullptr) {
return;
}
// [MODIFICAT] Usar color oscil·lat del fons en lloc dels parámetros
// Usar el color oscilatorio de fondo (sustituye los parámetros pasados,
// que solo existían por compatibilidad con la API anterior).
(void)r;
(void)g;
(void)b; // Suprimir warnings
(void)b;
SDL_Color bg = color_oscillator_.getCurrentBackgroundColor();
SDL_SetRenderDrawColor(renderer_, bg.r, bg.g, bg.b, 255);
SDL_RenderClear(renderer_);
gpu_renderer_.beginFrame(static_cast<float>(bg.r) / 255.0F,
static_cast<float>(bg.g) / 255.0F,
static_cast<float>(bg.b) / 255.0F);
}
void SDLManager::present() {
if (renderer_ == nullptr) {
return;
}
SDL_RenderPresent(renderer_);
gpu_renderer_.endFrame();
}
// [NUEVO] Actualitzar colors con oscil·lació
void SDLManager::updateColors(float delta_time) {
color_oscillator_.update(delta_time);
// Actualitzar color global de línies
Rendering::setLineColor(color_oscillator_.getCurrentLineColor());
}
// [NUEVO] Actualitzar counter de FPS
void SDLManager::updateFPS(float delta_time) {
// Acumular time i frames
fps_accumulator_ += delta_time;
fps_frame_count_++;
// Actualitzar display cada 0.5 segons
if (fps_accumulator_ >= 0.5F) {
fps_display_ = static_cast<int>(fps_frame_count_ / fps_accumulator_);
fps_frame_count_ = 0;
fps_accumulator_ = 0.0F;
// Actualitzar título de la finestra
std::string vsync_state = (Options::rendering.vsync == 1) ? "ON" : "OFF";
std::string title = std::format("{} v{} ({}) - {} FPS - VSync: {}",
Project::LONG_NAME,
@@ -455,27 +357,18 @@ void SDLManager::updateFPS(float delta_time) {
}
}
// [NUEVO] Actualitzar título de la finestra
void SDLManager::setWindowTitle(const std::string& title) {
if (finestra_ != nullptr) {
SDL_SetWindowTitle(finestra_, title.c_str());
}
}
// [NUEVO] Toggle V-Sync (F4)
void SDLManager::toggleVSync() {
// Toggle: 1 → 0 → 1
Options::rendering.vsync = (Options::rendering.vsync == 1) ? 0 : 1;
gpu_renderer_.setVSync(Options::rendering.vsync != 0);
// Aplicar a SDL
if (renderer_ != nullptr) {
SDL_SetRenderVSync(renderer_, Options::rendering.vsync);
}
// Reset FPS counter para evitar valores mixtos entre regímenes
fps_accumulator_ = 0.0F;
fps_frame_count_ = 0;
// Guardar configuración
Options::saveToFile();
}