Afegides les opcions a Service Menu

data/lang/ba_BA.json

@@ -79,8 +79,9 @@
     "[SERVICE_MENU] SHUTDOWN": "Apagar el sistema",
     "[SERVICE_MENU] FULLSCREEN": "Pantalla completa",
     "[SERVICE_MENU] WINDOW_SIZE": "Tamany de la finestra",
-    "[SERVICE_MENU] POSTFX": "PostFX",
+    "[SERVICE_MENU] SHADER": "Shader",
-    "[SERVICE_MENU] POSTFX_PRESET": "Preset PostFX",
+    "[SERVICE_MENU] SHADER_DISABLED": "Desactivat",
+    "[SERVICE_MENU] SHADER_PRESET": "Preset",
     "[SERVICE_MENU] SUPERSAMPLING": "Supermostreig",
     "[SERVICE_MENU] VSYNC": "Sincronisme vertical",
     "[SERVICE_MENU] INTEGER_SCALE": "Escalat sencer",

data/lang/en_UK.json

@@ -78,8 +78,9 @@
     "[SERVICE_MENU] SHUTDOWN": "Shutdown System",
     "[SERVICE_MENU] FULLSCREEN": "Fullscreen",
     "[SERVICE_MENU] WINDOW_SIZE": "Window Zoom",
-    "[SERVICE_MENU] POSTFX": "PostFX",
+    "[SERVICE_MENU] SHADER": "Shader",
-    "[SERVICE_MENU] POSTFX_PRESET": "PostFX Preset",
+    "[SERVICE_MENU] SHADER_DISABLED": "Disabled",
+    "[SERVICE_MENU] SHADER_PRESET": "Preset",
     "[SERVICE_MENU] SUPERSAMPLING": "Supersampling",
     "[SERVICE_MENU] VSYNC": "V-Sync",
     "[SERVICE_MENU] INTEGER_SCALE": "Integer Scale",

data/lang/es_ES.json

@@ -78,8 +78,9 @@
     "[SERVICE_MENU] SHUTDOWN": "Apagar el sistema",
     "[SERVICE_MENU] FULLSCREEN": "Pantalla completa",
     "[SERVICE_MENU] WINDOW_SIZE": "Zoom de ventana",
-    "[SERVICE_MENU] POSTFX": "PostFX",
+    "[SERVICE_MENU] SHADER": "Shader",
-    "[SERVICE_MENU] POSTFX_PRESET": "Preset PostFX",
+    "[SERVICE_MENU] SHADER_DISABLED": "Desactivado",
+    "[SERVICE_MENU] SHADER_PRESET": "Preset",
     "[SERVICE_MENU] SUPERSAMPLING": "Supersampling",
     "[SERVICE_MENU] VSYNC": "Sincronismo vertical",
     "[SERVICE_MENU] INTEGER_SCALE": "Escalado proporcional",

source/screen.cpp

@@ -275,12 +275,18 @@ void Screen::initShaders() {
         self->shader_backend_->setLinearUpscale(Options::video.supersampling.linear_upscale);
         self->shader_backend_->setDownscaleAlgo(Options::video.supersampling.downscale_algo);
         self->shader_backend_->setOversample(Options::video.supersampling.enabled ? 3 : 1);
-        self->shader_backend_->setActiveShader(Options::video.shader.current_shader);
+
-    }
+        if (!Options::video.shader.enabled) {
-    if (Options::video.shader.current_shader == Rendering::ShaderType::CRTPI) {
+            // Passthrough: POSTFX con parámetros a cero
-        self->applyCurrentCrtPiPreset();
+            self->shader_backend_->setActiveShader(Rendering::ShaderType::POSTFX);
-    } else {
+            self->shader_backend_->setPostFXParams(Rendering::PostFXParams{});
-        self->applyCurrentPostFXPreset();
+        } else if (Options::video.shader.current_shader == Rendering::ShaderType::CRTPI) {
+            self->shader_backend_->setActiveShader(Rendering::ShaderType::CRTPI);
+            self->applyCurrentCrtPiPreset();
+        } else {
+            self->shader_backend_->setActiveShader(Rendering::ShaderType::POSTFX);
+            self->applyCurrentPostFXPreset();
+        }
     }
 #endif
 }

source/ui/menu_option.hpp

@@ -217,3 +217,25 @@ class ActionListOption : public MenuOption {
     void updateCurrentIndex();
     [[nodiscard]] auto findCurrentIndex() const -> size_t;
 };
+
+// Opción genérica con callbacks: getter para mostrar, adjuster(bool up) para cambiar valor
+class CallbackOption : public MenuOption {
+   public:
+    CallbackOption(const std::string& cap, ServiceMenu::SettingsGroup grp, std::function<std::string()> getter, std::function<void(bool)> adjuster, std::function<int(Text*)> max_width_fn = nullptr)
+        : MenuOption(cap, grp),
+          getter_(std::move(getter)),
+          adjuster_(std::move(adjuster)),
+          max_width_fn_(std::move(max_width_fn)) {}
+
+    [[nodiscard]] auto getBehavior() const -> Behavior override { return Behavior::ADJUST; }
+    [[nodiscard]] auto getValueAsString() const -> std::string override { return getter_(); }
+    void adjustValue(bool adjust_up) override { adjuster_(adjust_up); }
+    auto getMaxValueWidth(Text* text_renderer) const -> int override {
+        return max_width_fn_ ? max_width_fn_(text_renderer) : 0;
+    }
+
+   private:
+    std::function<std::string()> getter_;
+    std::function<void(bool)> adjuster_;
+    std::function<int(Text*)> max_width_fn_;
+};

source/ui/service_menu.cpp

@@ -363,18 +363,76 @@ void ServiceMenu::initializeOptions() {
         Options::window.max_zoom,
         1));
 
-    options_.push_back(std::make_unique<BoolOption>(
+    // Shader: Desactivat / PostFX / CrtPi
-        Lang::getText("[SERVICE_MENU] POSTFX"),
+    {
-        SettingsGroup::VIDEO,
+        const std::string DISABLED_TEXT = Lang::getText("[SERVICE_MENU] SHADER_DISABLED");
-        &Options::video.shader.enabled));
+        std::vector<std::string> shader_values = {DISABLED_TEXT, "PostFX", "CrtPi"};
+        auto shader_getter = [DISABLED_TEXT]() -> std::string {
+            if (!Options::video.shader.enabled) { return DISABLED_TEXT; }
+            return (Options::video.shader.current_shader == Rendering::ShaderType::CRTPI) ? "CrtPi" : "PostFX";
+        };
+        auto shader_setter = [DISABLED_TEXT](const std::string& val) {
+            if (val == DISABLED_TEXT) {
+                Options::video.shader.enabled = false;
+            } else {
+                Options::video.shader.enabled = true;
+                const auto TYPE = (val == "CrtPi") ? Rendering::ShaderType::CRTPI : Rendering::ShaderType::POSTFX;
+                Options::video.shader.current_shader = TYPE;
+                auto* screen = Screen::get();
+                if (screen != nullptr) {
+                    screen->applySettings();
+                }
+            }
+            Screen::initShaders();
+        };
+        options_.push_back(std::make_unique<ListOption>(
+            Lang::getText("[SERVICE_MENU] SHADER"),
+            SettingsGroup::VIDEO,
+            shader_values,
+            shader_getter,
+            shader_setter));
+    }
 
-    options_.push_back(std::make_unique<IntOption>(
+    // Preset: muestra nombre, cicla circularmente entre presets del shader activo
-        Lang::getText("[SERVICE_MENU] POSTFX_PRESET"),
+    {
-        SettingsGroup::VIDEO,
+        auto preset_getter = []() -> std::string {
-        &Options::video.shader.current_postfx_preset,
+            if (Options::video.shader.current_shader == Rendering::ShaderType::CRTPI) {
-        0,
+                if (Options::crtpi_presets.empty()) { return ""; }
-        static_cast<int>(Options::postfx_presets.size()) - 1,
+                return Options::crtpi_presets.at(static_cast<size_t>(Options::video.shader.current_crtpi_preset)).name;
-        1));
+            }
+            if (Options::postfx_presets.empty()) { return ""; }
+            return Options::postfx_presets.at(static_cast<size_t>(Options::video.shader.current_postfx_preset)).name;
+        };
+        auto preset_adjuster = [](bool up) {
+            if (Options::video.shader.current_shader == Rendering::ShaderType::CRTPI) {
+                if (Options::crtpi_presets.empty()) { return; }
+                const int SIZE = static_cast<int>(Options::crtpi_presets.size());
+                Options::video.shader.current_crtpi_preset = up
+                    ? (Options::video.shader.current_crtpi_preset + 1) % SIZE
+                    : (Options::video.shader.current_crtpi_preset + SIZE - 1) % SIZE;
+            } else {
+                if (Options::postfx_presets.empty()) { return; }
+                const int SIZE = static_cast<int>(Options::postfx_presets.size());
+                Options::video.shader.current_postfx_preset = up
+                    ? (Options::video.shader.current_postfx_preset + 1) % SIZE
+                    : (Options::video.shader.current_postfx_preset + SIZE - 1) % SIZE;
+            }
+            Screen::initShaders();
+        };
+        auto preset_max_width = [](Text* text) -> int {
+            int max_w = 0;
+            for (const auto& p : Options::postfx_presets) { max_w = std::max(max_w, text->length(p.name, -2)); }
+            for (const auto& p : Options::crtpi_presets) { max_w = std::max(max_w, text->length(p.name, -2)); }
+            return max_w;
+        };
+
+        options_.push_back(std::make_unique<CallbackOption>(
+            Lang::getText("[SERVICE_MENU] SHADER_PRESET"),
+            SettingsGroup::VIDEO,
+            preset_getter,
+            preset_adjuster,
+            preset_max_width));
+    }
 
     options_.push_back(std::make_unique<BoolOption>(
         Lang::getText("[SERVICE_MENU] SUPERSAMPLING"),
@@ -569,6 +627,20 @@ void ServiceMenu::setHiddenOptions() {
         }
     }
 
+    {
+        auto* option = getOptionByCaption(Lang::getText("[SERVICE_MENU] SHADER_PRESET"));
+        if (option != nullptr) {
+            option->setHidden(!Options::video.shader.enabled);
+        }
+    }
+
+    {
+        auto* option = getOptionByCaption(Lang::getText("[SERVICE_MENU] SUPERSAMPLING"));
+        if (option != nullptr) {
+            option->setHidden(!Options::video.shader.enabled || Options::video.shader.current_shader != Rendering::ShaderType::POSTFX);
+        }
+    }
+
     updateMenu();  // El menú debe refrescarse si algo se oculta
 }