feat(lighting): flicker proporcional al radi amb overrides per emissor

source/core/rendering/lighting.cpp

@@ -57,9 +57,9 @@ namespace Lighting {
 
         auto activeFlicker() -> FlickerConfig& {
             static FlickerConfig fc_{
-                .wave_amplitude_px = Defaults::Lighting::FLICKER_WAVE_AMPLITUDE_PX,
+                .wave_amplitude_ratio = Defaults::Lighting::FLICKER_WAVE_AMPLITUDE_RATIO,
                 .wave_frequency_hz = Defaults::Lighting::FLICKER_WAVE_FREQUENCY_HZ,
-                .noise_amplitude_px = Defaults::Lighting::FLICKER_NOISE_AMPLITUDE_PX,
+                .noise_amplitude_ratio = Defaults::Lighting::FLICKER_NOISE_AMPLITUDE_RATIO,
                 .noise_frequency_hz = Defaults::Lighting::FLICKER_NOISE_FREQUENCY_HZ,
             };
             return fc_;
@@ -70,13 +70,16 @@ namespace Lighting {
         // identificador estable de l'emissor (no canvia amb la posició) —
         // així el patró no "deriva" quan l'emissor es mou. El factor
         // ~φ (golden ratio) dispersa les fases per a seeds consecutives.
+        // Les amplituds són ràtios sobre el radi base, multiplicades aquí
+        // → mateix percentatge d'oscil·lació per a qualsevol mida.
         auto computeFlickerRadius(int base_radius, int seed, float t_s, const FlickerConfig& fc) -> int {
             constexpr float TWO_PI = 2.0F * std::numbers::pi_v<float>;
             constexpr float GOLDEN_FRACTION = 0.6180339F;
             const float PHASE = static_cast<float>(seed) * GOLDEN_FRACTION;
             const float W1 = std::sin((TWO_PI * fc.wave_frequency_hz * t_s) + PHASE);
             const float W2 = std::sin((TWO_PI * fc.noise_frequency_hz * t_s) + (PHASE * 2.7F));
-            const float DELTA = (fc.wave_amplitude_px * W1) + (fc.noise_amplitude_px * W2);
+            const auto R_F = static_cast<float>(base_radius);
+            const float DELTA = (fc.wave_amplitude_ratio * R_F * W1) + (fc.noise_amplitude_ratio * R_F * W2);
             const int R = base_radius + static_cast<int>(std::lround(DELTA));
             return std::max(1, R);
         }
@@ -251,6 +254,10 @@ namespace Lighting {
         return activeSubtractiveConfig();
     }
 
+    auto flickerConfig() -> const FlickerConfig& {
+        return activeFlicker();
+    }
+
     namespace {
         // Llegeix els 5 camps de `GradientConfig` d'un node YAML — qualsevol
         // camp absent conserva el valor compilat dels defaults. Compartit
@@ -283,9 +290,9 @@ namespace Lighting {
             if (yaml.contains("flicker")) {
                 const auto& f = yaml["flicker"];
                 auto& fc = activeFlicker();
-                readField(f, "wave_amplitude_px", fc.wave_amplitude_px);
+                readField(f, "wave_amplitude_ratio", fc.wave_amplitude_ratio);
                 readField(f, "wave_frequency_hz", fc.wave_frequency_hz);
-                readField(f, "noise_amplitude_px", fc.noise_amplitude_px);
+                readField(f, "noise_amplitude_ratio", fc.noise_amplitude_ratio);
                 readField(f, "noise_frequency_hz", fc.noise_frequency_hz);
             }
         } catch (const std::exception& ex) {
@@ -297,9 +304,17 @@ namespace Lighting {
 
         // Helper: emissor "patxat" amb el radi efectiu (post-flicker) per
         // a aquest frame. Mantenim l'`Emitter` del caller intacte i la
-        // resta de camps (color, seed, ...) propagats.
+        // resta de camps (color, seed, flicker_params, ...) propagats.
         auto withEffectiveRadius(const Emitter& e, int r_eff) -> Emitter {
-            return Emitter{.cx = e.cx, .cy = e.cy, .radius = r_eff, .seed = e.seed, .flicker = e.flicker, .color = e.color};
+            return Emitter{
+                .cx = e.cx,
+                .cy = e.cy,
+                .radius = r_eff,
+                .seed = e.seed,
+                .flicker = e.flicker,
+                .color = e.color,
+                .flicker_params = e.flicker_params,
+            };
         }
 
         // Camí del mode subtractive (històric): omple un buffer de
@@ -312,11 +327,10 @@ namespace Lighting {
             std::ranges::fill(lum, room);
 
             const auto& cfg = activeSubtractiveConfig();
-            const auto& fc = activeFlicker();
             const float T_S = static_cast<float>(SDL_GetTicks()) / 1000.0F;
             for (const auto& e : emitters) {
                 if (e.radius <= 0) { continue; }
-                const int R_EFF = e.flicker ? computeFlickerRadius(e.radius, e.seed, T_S, fc) : e.radius;
+                const int R_EFF = e.flicker ? computeFlickerRadius(e.radius, e.seed, T_S, e.flicker_params) : e.radius;
                 const auto RINGS = computeRings(R_EFF, cfg);
                 const Emitter EFF = withEffectiveRadius(e, R_EFF);
                 rasterizeEmitter(EFF, RINGS, lum.data(), width, height);
@@ -330,11 +344,10 @@ namespace Lighting {
         void applyAdditive(std::uint32_t* canvas, int width, int height, std::uint8_t room, std::span<const Emitter> emitters) {
             darkenCanvas(canvas, width, height, room);
             const auto& cfg = activeAdditiveConfig();
-            const auto& fc = activeFlicker();
             const float T_S = static_cast<float>(SDL_GetTicks()) / 1000.0F;
             for (const auto& e : emitters) {
                 if (e.radius <= 0) { continue; }
-                const int R_EFF = e.flicker ? computeFlickerRadius(e.radius, e.seed, T_S, fc) : e.radius;
+                const int R_EFF = e.flicker ? computeFlickerRadius(e.radius, e.seed, T_S, e.flicker_params) : e.radius;
                 const auto RINGS = computeRings(R_EFF, cfg);
                 const Emitter EFF = withEffectiveRadius(e, R_EFF);
                 rasterizeEmitterAdditive(EFF, RINGS, canvas, width, height);