feat(demo): transició per fosa a/desde negre en el salt títol→demo

source/core/defaults/game.hpp

@@ -39,6 +39,12 @@ namespace Defaults::Game {
     constexpr float LEVEL_COMPLETED_DURATION = 3.0F;       // Duración total
     constexpr float LEVEL_COMPLETED_TYPING_RATIO = 0.05F;  // ~150ms de typewriter (escan ràpid però visible)
 
+    // Attract mode: durada de la fosa a/desde negre a les transicions de demo.
+    namespace Fade {
+        constexpr float DEMO_OUT_DURATION = 0.6F;  // TÍTOL → DEMO (fosa a negre abans del salt)
+        constexpr float DEMO_IN_DURATION = 0.6F;   // DEMO: fosa des de negre sobre el joc ja en marxa
+    }  // namespace Fade
+
     // Transición INIT_HUD (animación inicial del HUD)
     constexpr float INIT_HUD_DURATION = 3.0F;  // Duración total del estado
 

source/core/graphics/screen_fade.cpp

@@ -0,0 +1,62 @@
+// screen_fade.cpp - Implementació de la fosa a/desde negre
+// © 2026 JailDesigner
+
+#include "core/graphics/screen_fade.hpp"
+
+#include <algorithm>
+#include <cmath>
+
+#include "core/defaults/game.hpp"
+
+namespace Graphics {
+
+    ScreenFade::ScreenFade(Rendering::Renderer* renderer)
+        : renderer_(renderer) {}
+
+    void ScreenFade::start(float from, float to, float duration) {
+        from_ = from;
+        to_ = to;
+        duration_ = duration;
+        elapsed_ = 0.0F;
+        active_ = true;
+    }
+
+    void ScreenFade::update(float delta_time) {
+        if (!active_) {
+            return;
+        }
+        elapsed_ += delta_time;
+    }
+
+    auto ScreenFade::alpha() const -> float {
+        if (!active_) {
+            return 0.0F;
+        }
+        if (duration_ <= 0.0F) {
+            return to_;
+        }
+        const float T = std::clamp(elapsed_ / duration_, 0.0F, 1.0F);
+        return std::lerp(from_, to_, T);
+    }
+
+    auto ScreenFade::isDone() const -> bool {
+        return !active_ || elapsed_ >= duration_;
+    }
+
+    void ScreenFade::draw() const {
+        const float A = alpha();
+        if (A <= 0.0F) {
+            return;
+        }
+        renderer_->pushRect(
+            0.0F,
+            0.0F,
+            static_cast<float>(Defaults::Game::WIDTH),
+            static_cast<float>(Defaults::Game::HEIGHT),
+            0.0F,
+            0.0F,
+            0.0F,
+            A);
+    }
+
+}  // namespace Graphics

source/core/graphics/screen_fade.hpp

@@ -0,0 +1,43 @@
+// screen_fade.hpp - Fosa a/desde negre per a transicions d'escena
+// © 2026 JailDesigner
+//
+// Rect negre a pantalla completa amb l'alpha animat linealment. L'escena que el
+// posseeix l'actualitza cada frame i el dibuixa l'ÚLTIM (per damunt de tot). En
+// repòs (default-construït o fosa acabada amb alpha 0) el draw() és un no-op.
+
+#pragma once
+
+#include "core/rendering/render_context.hpp"
+
+namespace Graphics {
+
+    class ScreenFade {
+       public:
+        explicit ScreenFade(Rendering::Renderer* renderer);
+
+        // Arrenca una fosa lineal d'alpha 'from' a 'to' en 'duration' segons.
+        void start(float from, float to, float duration);
+
+        // Avança el temporitzador intern.
+        void update(float delta_time);
+
+        // Dibuixa el rect negre a pantalla completa amb l'alpha actual.
+        // No fa res si l'alpha és ~0 (estalvia el pushRect).
+        void draw() const;
+
+        // Cert quan la fosa ha acabat (o no s'ha arrencat mai).
+        [[nodiscard]] auto isDone() const -> bool;
+
+        // Alpha actual ∈ [0, 1].
+        [[nodiscard]] auto alpha() const -> float;
+
+       private:
+        Rendering::Renderer* renderer_;
+        float from_{0.0F};
+        float to_{0.0F};
+        float duration_{0.0F};
+        float elapsed_{0.0F};
+        bool active_{false};
+    };
+
+}  // namespace Graphics