treballant en sdl3gpu

source/core/rendering/screen.cpp

@@ -3,6 +3,7 @@
 #include <iostream>
 
 #include "core/rendering/overlay.hpp"
+#include "core/rendering/sdl3gpu/sdl3gpu_shader.hpp"
 #include "game/defines.hpp"
 #include "game/options.hpp"
 
@@ -32,7 +33,7 @@ Screen::Screen() {
     if (zoom_ > max_zoom_) zoom_ = max_zoom_;
 
     int w = GAME_WIDTH * zoom_;
-    int h = GAME_HEIGHT * zoom_;
+    int h = Options::video.aspect_ratio_4_3 ? static_cast<int>(GAME_HEIGHT * 1.2F) * zoom_ : GAME_HEIGHT * zoom_;
 
     window_ = SDL_CreateWindow(Texts::WINDOW_TITLE, w, h, fullscreen_ ? SDL_WINDOW_FULLSCREEN : 0);
     renderer_ = SDL_CreateRenderer(window_, nullptr);
@@ -41,6 +42,9 @@ Screen::Screen() {
     texture_ = SDL_CreateTexture(renderer_, SDL_PIXELFORMAT_ABGR8888, SDL_TEXTUREACCESS_STREAMING, GAME_WIDTH, GAME_HEIGHT);
     SDL_SetTextureScaleMode(texture_, SDL_SCALEMODE_NEAREST);
 
+    // Inicialitza backend GPU si l'acceleració està activada
+    initShaders();
+
     std::cout << "Screen initialized: " << w << "x" << h << " (zoom " << zoom_ << ", max " << max_zoom_ << ")\n";
 }
 
@@ -49,17 +53,74 @@ Screen::~Screen() {
     Options::window.zoom = zoom_;
     Options::window.fullscreen = fullscreen_;
 
+    // Destrueix el backend GPU
+    if (shader_backend_) {
+        auto* gpu = dynamic_cast<Rendering::SDL3GPUShader*>(shader_backend_.get());
+        if (gpu) gpu->destroy();
+        shader_backend_.reset();
+    }
+
     if (texture_) SDL_DestroyTexture(texture_);
     if (renderer_) SDL_DestroyRenderer(renderer_);
     if (window_) SDL_DestroyWindow(window_);
 }
 
+void Screen::initShaders() {
+    if (!Options::video.gpu_acceleration) return;
+
+    shader_backend_ = std::make_unique<Rendering::SDL3GPUShader>();
+
+    const std::string FALLBACK_DRIVER = "none";
+    shader_backend_->setPreferredDriver(
+        Options::video.gpu_acceleration ? "" : FALLBACK_DRIVER);
+
+    // init() rep la finestra i la textura (la textura s'usa com a referència, el GPU fa uploadPixels)
+    if (!shader_backend_->init(window_, texture_, "", "")) {
+        std::cerr << "GPU shader backend initialization failed, using SDL_Renderer fallback\n";
+        shader_backend_.reset();
+        return;
+    }
+
+    auto* gpu = dynamic_cast<Rendering::SDL3GPUShader*>(shader_backend_.get());
+    if (gpu) {
+        std::cout << "GPU driver: " << gpu->getDriverName() << '\n';
+    }
+
+    // Aplica opcions de vídeo
+    shader_backend_->setScaleMode(Options::video.integer_scale);
+    shader_backend_->setStretch4_3(Options::video.aspect_ratio_4_3);
+    shader_backend_->setLinearUpscale(Options::video.linear_upscale);
+    shader_backend_->setDownscaleAlgo(Options::video.downscale_algo);
+
+    if (Options::video.supersampling) {
+        shader_backend_->setOversample(3);
+    }
+
+    // Aplica presets per defecte (de moment hardcoded, futur: YAML)
+    applyCurrentPostFXPreset();
+    applyCurrentCrtPiPreset();
+}
+
 void Screen::present(Uint32* pixel_data) {
     Overlay::render(pixel_data);
-    SDL_UpdateTexture(texture_, nullptr, pixel_data, GAME_WIDTH * sizeof(Uint32));
-    SDL_RenderClear(renderer_);
-    SDL_RenderTexture(renderer_, texture_, nullptr, nullptr);
-    SDL_RenderPresent(renderer_);
+
+    if (shader_backend_ && shader_backend_->isHardwareAccelerated() && Options::video.shader_enabled) {
+        // Path GPU: puja els píxels i renderitza amb shaders
+        shader_backend_->uploadPixels(pixel_data, GAME_WIDTH, GAME_HEIGHT);
+        shader_backend_->render();
+    } else if (shader_backend_ && shader_backend_->isHardwareAccelerated()) {
+        // GPU activa però shaders desactivats: renderitza net (sense efectes)
+        Rendering::PostFXParams clean{};
+        shader_backend_->setPostFXParams(clean);
+        shader_backend_->uploadPixels(pixel_data, GAME_WIDTH, GAME_HEIGHT);
+        shader_backend_->render();
+    } else {
+        // Fallback SDL_Renderer
+        SDL_UpdateTexture(texture_, nullptr, pixel_data, GAME_WIDTH * sizeof(Uint32));
+        SDL_RenderClear(renderer_);
+        SDL_RenderTexture(renderer_, texture_, nullptr, nullptr);
+        SDL_RenderPresent(renderer_);
+    }
 }
 
 void Screen::toggleFullscreen() {
@@ -68,7 +129,6 @@ void Screen::toggleFullscreen() {
     if (!fullscreen_) {
         adjustWindowSize();
     }
-    std::cout << (fullscreen_ ? "Fullscreen ON\n" : "Fullscreen OFF\n");
 }
 
 void Screen::incZoom() {
@@ -89,9 +149,85 @@ void Screen::setZoom(int zoom) {
     adjustWindowSize();
 }
 
+void Screen::toggleShaders() {
+    Options::video.shader_enabled = !Options::video.shader_enabled;
+    if (Options::video.shader_enabled) {
+        applyCurrentPostFXPreset();
+    }
+}
+
+void Screen::toggleSupersampling() {
+    if (!shader_backend_ || !shader_backend_->isHardwareAccelerated()) return;
+    Options::video.supersampling = !Options::video.supersampling;
+    shader_backend_->setOversample(Options::video.supersampling ? 3 : 1);
+}
+
+void Screen::toggleAspectRatio() {
+    Options::video.aspect_ratio_4_3 = !Options::video.aspect_ratio_4_3;
+    if (shader_backend_) {
+        shader_backend_->setStretch4_3(Options::video.aspect_ratio_4_3);
+    }
+    if (!fullscreen_) {
+        adjustWindowSize();
+    }
+}
+
+void Screen::toggleIntegerScale() {
+    Options::video.integer_scale = !Options::video.integer_scale;
+    if (shader_backend_) {
+        shader_backend_->setScaleMode(Options::video.integer_scale);
+    }
+}
+
+void Screen::nextShaderPreset() {
+    if (!shader_backend_ || !shader_backend_->isHardwareAccelerated()) return;
+
+    // Cicla entre PostFX i CrtPi
+    if (shader_backend_->getActiveShader() == Rendering::ShaderType::POSTFX) {
+        shader_backend_->setActiveShader(Rendering::ShaderType::CRTPI);
+        applyCurrentCrtPiPreset();
+    } else {
+        shader_backend_->setActiveShader(Rendering::ShaderType::POSTFX);
+        applyCurrentPostFXPreset();
+    }
+}
+
+void Screen::setActiveShader(Rendering::ShaderType type) {
+    if (shader_backend_) {
+        shader_backend_->setActiveShader(type);
+    }
+}
+
+void Screen::applyCurrentPostFXPreset() {
+    if (!shader_backend_) return;
+    // Preset per defecte "CRT" — futur: carregar des de YAML
+    Rendering::PostFXParams p;
+    p.vignette = 0.4F;
+    p.scanlines = 0.5F;
+    p.chroma = 0.1F;
+    p.mask = 0.0F;
+    p.gamma = 0.0F;
+    p.curvature = 0.0F;
+    p.bleeding = 0.0F;
+    p.flicker = 0.0F;
+    shader_backend_->setPostFXParams(p);
+}
+
+void Screen::applyCurrentCrtPiPreset() {
+    if (!shader_backend_) return;
+    // Preset per defecte — futur: carregar des de YAML
+    Rendering::CrtPiParams p;
+    shader_backend_->setCrtPiParams(p);
+}
+
+auto Screen::isHardwareAccelerated() const -> bool {
+    return shader_backend_ && shader_backend_->isHardwareAccelerated();
+}
+
 void Screen::adjustWindowSize() {
     int w = GAME_WIDTH * zoom_;
-    int h = GAME_HEIGHT * zoom_;
+    // Si 4:3 actiu, l'alçada visual és 240 per zoom (200 * 1.2)
+    int h = Options::video.aspect_ratio_4_3 ? static_cast<int>(GAME_HEIGHT * 1.2F) * zoom_ : GAME_HEIGHT * zoom_;
     SDL_SetWindowSize(window_, w, h);
     SDL_SetWindowPosition(window_, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED);
 }