refactor(audio,transitions): durada de música pre-calculada al loadMusic i Direction (FADE_IN/FADE_OUT) a FadeToBlack

source/core/rendering/transitions/fade_to_black.cpp

@@ -8,9 +8,10 @@
 
 namespace Transitions {
 
-    void FadeToBlack::begin(int duration_ms) {
+    void FadeToBlack::begin(int duration_ms, Direction direction) {
         duration_ms_ = duration_ms;
         elapsed_ms_ = 0;
+        direction_ = direction;
     }
 
     void FadeToBlack::tick(int delta_ms) {
@@ -29,7 +30,11 @@ namespace Transitions {
         // Alpha lineal — sense corba quadràtica (això és prerogativa del
         // dissolve mosaic, on volem que la mascara fosca arribe tard
         // perquè es vegen els blocs). Per al fade net, lineal 0..255.
-        const auto ALPHA = static_cast<std::uint8_t>(std::round(255.0F * P));
+        // Direcció FADE_IN inverteix la rampa: el negre comença opac i
+        // s'esvaeix cap a transparent, deixant veure l'escena pintada
+        // darrere abans de `render()`.
+        const float ALPHA_F = (direction_ == Direction::FADE_IN) ? (1.0F - P) : P;
+        const auto ALPHA = static_cast<std::uint8_t>(std::round(255.0F * ALPHA_F));
         if (ALPHA == 0) { return; }
 
         auto& screen = Screen::get();

source/core/rendering/transitions/fade_to_black.hpp

@@ -1,37 +1,51 @@
 #pragma once
 
+#include <cstdint>
+
 namespace Transitions {
 
-    // Fade-out lineal a negre. A diferència de `Mosaic`, no rebina cap
-    // píxel; només posa una capa negra amb alpha creixent (0 → 255) al
-    // damunt del canvas. És la transició "neta" per defecte; ideal per a
-    // sortides on no convé l'estètica chunky de l'arcade dissolve.
+    // Fade lineal contra negre. A diferència de `Mosaic`, no rebina cap
+    // píxel; només posa una capa negra al damunt del canvas amb alpha
+    // que evoluciona linealment al llarg de la durada. És la transició
+    // "neta" per defecte; ideal per a entrades/sortides on no convé
+    // l'estètica chunky de l'arcade dissolve.
+    //
+    // La direcció controla el sentit de l'alpha:
+    //   FADE_OUT: alpha 0 → 255 (món visible → negre opac)
+    //   FADE_IN:  alpha 255 → 0 (negre opac → món visible)
+    // En tots dos casos `progress()` segueix sent monotònic 0 → 1
+    // (mateixa semàntica per al caller); només el render inverteix.
     //
     // Mateixa interfície que `Mosaic` (begin/tick/render/isActive/
     // isFinished/progress) perquè els llocs de crida puguen escollir-ne
     // una o l'altra sense canviar el patró d'ús.
     class FadeToBlack {
        public:
+        enum class Direction : std::uint8_t { FADE_OUT,
+            FADE_IN };
+
         FadeToBlack() = default;
 
         // Arrenca un fade nou. Si ja n'hi havia un actiu, el reemplaça.
         // `duration_ms <= 0` deixa l'efecte inactiu.
-        void begin(int duration_ms);
+        void begin(int duration_ms, Direction direction = Direction::FADE_OUT);
 
         void tick(int delta_ms);
 
         [[nodiscard]] auto isActive() const -> bool { return duration_ms_ > 0 && elapsed_ms_ < duration_ms_; }
         [[nodiscard]] auto isFinished() const -> bool { return duration_ms_ > 0 && elapsed_ms_ >= duration_ms_; }
         [[nodiscard]] auto progress() const -> float;
+        [[nodiscard]] auto direction() const -> Direction { return direction_; }
 
-        // Pinta la capa negra amb alpha proporcional al `progress()`.
-        // Cridar després del render normal de l'escena, abans de
-        // `Screen::present()`.
+        // Pinta la capa negra amb alpha derivat del `progress()` i la
+        // direcció. Cridar després del render normal de l'escena,
+        // abans de `Screen::present()`.
         void render() const;
 
        private:
         int duration_ms_{0};
         int elapsed_ms_{0};
+        Direction direction_{Direction::FADE_OUT};
     };
 
 }  // namespace Transitions