PostFXParams/Preset amb chroma_min/max + scan_*; presets P2026 migrats

source/core/rendering/screen.cpp

@@ -590,42 +590,24 @@ auto loadData(const std::string& filepath) -> std::vector<uint8_t> {
     return Resource::Helper::loadFile(filepath);
 }
 
-void Screen::setLinearUpscale(bool linear) {
-    Options::video.supersampling.linear_upscale = linear;
-    if (shader_backend_ && shader_backend_->isHardwareAccelerated()) {
-        shader_backend_->setLinearUpscale(linear);
-    }
-}
-
-void Screen::setDownscaleAlgo(int algo) {
-    Options::video.supersampling.downscale_algo = algo;
-    if (shader_backend_ && shader_backend_->isHardwareAccelerated()) {
-        shader_backend_->setDownscaleAlgo(algo);
-    }
-}
-
-auto Screen::getSsTextureSize() const -> std::pair<int, int> {
-    if (!shader_backend_) { return {0, 0}; }
-    return shader_backend_->getSsTextureSize();
-}
-
-// Activa/desactiva el supersampling global (Ctrl+F4)
-void Screen::toggleSupersampling() {
-    Options::video.supersampling.enabled = !Options::video.supersampling.enabled;
-    if (Options::video.shader.enabled && shader_backend_ && shader_backend_->isHardwareAccelerated()) {
-        applyCurrentPostFXPreset();
-    }
-}
-
 // Aplica los parámetros del preset actual al backend de shaders
 void Screen::applyCurrentPostFXPreset() {
     if (shader_backend_ && !Options::postfx_presets.empty()) {
         const auto& p = Options::postfx_presets[static_cast<size_t>(Options::video.shader.current_postfx_preset)];
-        // Supersampling es un toggle global (Options::video.supersampling.enabled), no por preset.
-        // setOversample primero: puede recrear texturas antes de que setPostFXParams
-        // decida si hornear scanlines en CPU o aplicarlas en GPU.
-        shader_backend_->setOversample(Options::video.supersampling.enabled ? 3 : 1);
-        Rendering::PostFXParams params{.vignette = p.vignette, .scanlines = p.scanlines, .chroma = p.chroma, .mask = p.mask, .gamma = p.gamma, .curvature = p.curvature, .bleeding = p.bleeding, .flicker = p.flicker};
+        Rendering::PostFXParams params{
+            .vignette = p.vignette,
+            .scanlines = p.scanlines,
+            .chroma_min = p.chroma_min,
+            .chroma_max = p.chroma_max,
+            .mask = p.mask,
+            .gamma = p.gamma,
+            .curvature = p.curvature,
+            .bleeding = p.bleeding,
+            .flicker = p.flicker,
+            .scan_dark_ratio = p.scan_dark_ratio,
+            .scan_dark_floor = p.scan_dark_floor,
+            .scan_edge_soft = p.scan_edge_soft,
+        };
         shader_backend_->setPostFXParams(params);
     }
 }
@@ -698,11 +680,9 @@ void Screen::initShaders() {
     shader_backend_->init(window_, tex, "", "");
     gpu_driver_ = shader_backend_->getDriverName();
 
-    // Propagar flags de vsync, integer scale, upscale y downscale al backend GPU
+    // Propagar flags de vsync e integer scale al backend GPU
     shader_backend_->setVSync(Options::video.vertical_sync);
     shader_backend_->setScaleMode(Options::video.integer_scale);
-    shader_backend_->setLinearUpscale(Options::video.supersampling.linear_upscale);
-    shader_backend_->setDownscaleAlgo(Options::video.supersampling.downscale_algo);
 
     if (Options::video.shader.enabled) {
         applyCurrentPostFXPreset();

source/core/rendering/sdl3gpu/sdl3gpu_shader.hpp

@@ -7,20 +7,28 @@
 
 // PostFX uniforms pushed to fragment stage each frame.
 // Must match the MSL struct and GLSL uniform block layout.
-// 12 floats = 48 bytes — meets Metal/Vulkan 16-byte alignment requirement.
+// 16 floats = 64 bytes (4 × vec4) — meets Metal/Vulkan 16-byte alignment.
 struct PostFXUniforms {
+    // vec4 #0
     float vignette_strength;  // 0 = none, ~0.8 = subtle
-    float chroma_strength;    // 0 = off, ~0.2 = subtle chromatic aberration
+    float chroma_min;         // aberració cromàtica mínima (sempre present)
     float scanline_strength;  // 0 = off, 1 = full
     float screen_height;      // logical height in pixels (used by bleeding effect)
-    float mask_strength;      // 0 = off, 1 = full phosphor dot mask
-    float gamma_strength;     // 0 = off, 1 = full gamma 2.4/2.2 correction
-    float curvature;          // 0 = flat, 1 = max barrel distortion
-    float bleeding;           // 0 = off, 1 = max NTSC chrominance bleeding
-    float pixel_scale;        // physical pixels per logical pixel (vh / tex_height_)
-    float time;               // seconds since SDL init (SDL_GetTicks() / 1000.0f)
-    float oversample;         // supersampling factor (1.0 = off, 3.0 = 3×SS)
-    float flicker;            // 0 = off, 1 = phosphor flicker ~50 Hz — keep struct at 48 bytes (3 × 16)
+    // vec4 #1
+    float mask_strength;   // 0 = off, 1 = full phosphor dot mask
+    float gamma_strength;  // 0 = off, 1 = full gamma 2.4/2.2 correction
+    float curvature;       // 0 = flat, 1 = max barrel distortion
+    float bleeding;        // 0 = off, 1 = max NTSC chrominance bleeding
+    // vec4 #2
+    float pixel_scale;  // physical pixels per logical pixel (vh / tex_height_)
+    float time;         // seconds since SDL init (SDL_GetTicks() / 1000.0f)
+    float flicker;      // 0 = off, 1 = phosphor flicker ~50 Hz
+    float chroma_max;   // si == chroma_min queda estàtic; si != pulsa sinusoidalment
+    // vec4 #3 — paràmetres de forma de les scanlines (exposats per preset)
+    float scan_dark_ratio;  // fracció de subfila fosca (1/3 = 0.333 per defecte)
+    float scan_dark_floor;  // brillantor de la subfila fosca (0.42 per defecte)
+    float scan_edge_soft;   // suavitzat de la transició (0 = step dur, 1 = 1px físic)
+    float pad3;
 };
 
 // CrtPi uniforms pushed to fragment stage each frame.
@@ -49,15 +57,6 @@ struct CrtPiUniforms {
     float texture_height;  // Alto del canvas en píxeles (inyectado en render)
 };
 
-// Downscale uniforms pushed to the Lanczos downscale fragment stage.
-// 1 int + 3 floats = 16 bytes — meets Metal/Vulkan alignment.
-struct DownscaleUniforms {
-    int algorithm;  // 0 = Lanczos2 (ventana 2), 1 = Lanczos3 (ventana 3)
-    float pad0;
-    float pad1;
-    float pad2;
-};
-
 namespace Rendering {
 
     /**
@@ -99,18 +98,6 @@ namespace Rendering {
         // Activa/desactiva escalado entero (integer scale)
         void setScaleMode(bool integer_scale) override;
 
-        // Establece factor de supersampling (1 = off, 3 = 3×SS)
-        void setOversample(int factor) override;
-
-        // Activa/desactiva interpolación LINEAR en el upscale (false = NEAREST)
-        void setLinearUpscale(bool linear) override;
-
-        // Selecciona algoritmo de downscale: 0=bilinear legacy, 1=Lanczos2, 2=Lanczos3
-        void setDownscaleAlgo(int algo) override;
-
-        // Devuelve las dimensiones de la textura de supersampling (0,0 si SS desactivado)
-        [[nodiscard]] auto getSsTextureSize() const -> std::pair<int, int> override;
-
         // Selecciona el shader de post-procesado activo (POSTFX o CRTPI)
         void setActiveShader(ShaderType type) override;
 
@@ -137,42 +124,30 @@ namespace Rendering {
             Uint32 num_uniform_buffers) -> SDL_GPUShader*;
 
         auto createPipeline() -> bool;
-        auto createCrtPiPipeline() -> bool;              // Pipeline dedicado para el shader CrtPi
-        auto reinitTexturesAndBuffer() -> bool;          // Recrea scene_texture_ y upload_buffer_
-        auto recreateScaledTexture(int factor) -> bool;  // Recrea scaled_texture_ para factor dado
-        static auto calcSsFactor(float zoom) -> int;     // Primer múltiplo de 3 >= zoom (mín 3)
+        auto createCrtPiPipeline() -> bool;      // Pipeline dedicado para el shader CrtPi
+        auto reinitTexturesAndBuffer() -> bool;  // Recrea scene_texture_ y upload_buffer_
         // Devuelve el mejor present mode disponible: IMMEDIATE > MAILBOX > VSYNC
         [[nodiscard]] auto bestPresentMode(bool vsync) const -> SDL_GPUPresentMode;
 
         SDL_Window* window_ = nullptr;
         SDL_GPUDevice* device_ = nullptr;
-        SDL_GPUGraphicsPipeline* pipeline_ = nullptr;                   // PostFX pass (→ swapchain o → postfx_texture_)
-        SDL_GPUGraphicsPipeline* crtpi_pipeline_ = nullptr;             // CrtPi pass (→ swapchain directo, sin SS)
-        SDL_GPUGraphicsPipeline* postfx_offscreen_pipeline_ = nullptr;  // PostFX → postfx_texture_ (B8G8R8A8, solo con Lanczos)
-        SDL_GPUGraphicsPipeline* upscale_pipeline_ = nullptr;           // Upscale pass (solo con SS)
-        SDL_GPUGraphicsPipeline* downscale_pipeline_ = nullptr;         // Lanczos downscale (solo con SS + algo > 0)
-        SDL_GPUTexture* scene_texture_ = nullptr;                       // Canvas del juego (game_width_ × game_height_)
-        SDL_GPUTexture* scaled_texture_ = nullptr;                      // Upscale target (game×factor), solo con SS
-        SDL_GPUTexture* postfx_texture_ = nullptr;                      // PostFX output a resolución escalada, solo con Lanczos
+        SDL_GPUGraphicsPipeline* pipeline_ = nullptr;        // PostFX pass → swapchain
+        SDL_GPUGraphicsPipeline* crtpi_pipeline_ = nullptr;  // CrtPi pass → swapchain
+        SDL_GPUTexture* scene_texture_ = nullptr;            // Canvas del juego (game_width_ × game_height_)
         SDL_GPUTransferBuffer* upload_buffer_ = nullptr;
-        SDL_GPUSampler* sampler_ = nullptr;         // NEAREST
-        SDL_GPUSampler* linear_sampler_ = nullptr;  // LINEAR
+        SDL_GPUSampler* sampler_ = nullptr;  // NEAREST
 
-        PostFXUniforms uniforms_{.vignette_strength = 0.6F, .chroma_strength = 0.15F, .scanline_strength = 0.7F, .screen_height = 192.0F, .pixel_scale = 1.0F, .oversample = 1.0F};
+        PostFXUniforms uniforms_{.vignette_strength = 0.6F, .chroma_min = 0.15F, .scanline_strength = 0.7F, .screen_height = 192.0F, .pixel_scale = 1.0F, .chroma_max = 0.15F, .scan_dark_ratio = 0.333F, .scan_dark_floor = 0.42F, .scan_edge_soft = 1.0F};
         CrtPiUniforms crtpi_uniforms_{.scanline_weight = 6.0F, .scanline_gap_brightness = 0.12F, .bloom_factor = 3.5F, .input_gamma = 2.4F, .output_gamma = 2.2F, .mask_brightness = 0.80F, .curvature_x = 0.05F, .curvature_y = 0.10F, .mask_type = 2, .enable_scanlines = 1, .enable_multisample = 1, .enable_gamma = 1};
         ShaderType active_shader_ = ShaderType::POSTFX;  // Shader de post-procesado activo
 
         int game_width_ = 0;  // Dimensiones originales del canvas
         int game_height_ = 0;
-        int ss_factor_ = 0;       // Factor SS activo (3, 6, 9...) o 0 si SS desactivado
-        int oversample_ = 1;      // SS on/off (1 = off, >1 = on)
-        int downscale_algo_ = 1;  // 0 = bilinear legacy, 1 = Lanczos2, 2 = Lanczos3
         std::string driver_name_;
         std::string preferred_driver_;  // Driver preferido; vacío = auto (SDL elige)
         bool is_initialized_ = false;
         bool vsync_ = true;
         bool integer_scale_ = false;
-        bool linear_upscale_ = false;  // Upscale NEAREST (false) o LINEAR (true)
     };
 
 }  // namespace Rendering

source/core/rendering/shader_backend.hpp

@@ -19,12 +19,19 @@ namespace Rendering {
     struct PostFXParams {
         float vignette = 0.0F;   // Intensidad de la viñeta
         float scanlines = 0.0F;  // Intensidad de las scanlines
-        float chroma = 0.0F;     // Aberración cromática
+        // Aberració cromàtica — varia entre min i max via sinusoidal; si coincideixen
+        // queda estàtica. min > 0 garanteix que la imatge mai sigui lliure de chroma.
+        float chroma_min = 0.0F;
+        float chroma_max = 0.0F;
         float mask = 0.0F;       // Máscara de fósforo RGB
         float gamma = 0.0F;      // Corrección gamma (blend 0=off, 1=full)
         float curvature = 0.0F;  // Curvatura barrel CRT
         float bleeding = 0.0F;   // Sangrado de color NTSC
         float flicker = 0.0F;    // Parpadeo de fósforo CRT ~50 Hz
+        // Forma de les scanlines — 3 subpíxels per fila lògica per defecte.
+        float scan_dark_ratio = 0.333F;  // fracció obscura (1/3)
+        float scan_dark_floor = 0.42F;   // brillantor subfila fosca
+        float scan_edge_soft = 1.0F;     // 0 = step dur; 1 = suavitzat 1 px físic
     };
 
     /**
@@ -110,34 +117,6 @@ namespace Rendering {
          */
         virtual void setScaleMode(bool /*integer_scale*/) {}
 
-        /**
-         * @brief Establece el factor de supersampling (1 = off, 3 = 3× SS)
-         * Con factor > 1, la textura GPU se crea a game×factor resolución y
-         * las scanlines se hornean en CPU (uploadPixels). El sampler usa LINEAR.
-         */
-        virtual void setOversample(int /*factor*/) {}
-
-        /**
-         * @brief Activa/desactiva interpolación LINEAR en el paso de upscale (SS).
-         * Por defecto NEAREST (false). Solo tiene efecto con supersampling activo.
-         */
-        virtual void setLinearUpscale(bool /*linear*/) {}
-        [[nodiscard]] virtual auto isLinearUpscale() const -> bool { return false; }
-
-        /**
-         * @brief Selecciona el algoritmo de downscale tras el PostFX (SS activo).
-         * 0 = bilinear legacy (comportamiento actual, sin textura intermedia),
-         * 1 = Lanczos2 (ventana 2, ~25 muestras), 2 = Lanczos3 (ventana 3, ~49 muestras).
-         */
-        virtual void setDownscaleAlgo(int /*algo*/) {}
-        [[nodiscard]] virtual auto getDownscaleAlgo() const -> int { return 0; }
-
-        /**
-         * @brief Devuelve las dimensiones de la textura de supersampling.
-         * @return Par (ancho, alto) en píxeles; (0, 0) si SS está desactivado.
-         */
-        [[nodiscard]] virtual auto getSsTextureSize() const -> std::pair<int, int> { return {0, 0}; }
-
         /**
          * @brief Verifica si el backend está usando aceleración por hardware
          * @return true si usa aceleración (OpenGL/Metal/Vulkan)