feat(bloom): glow separable two-pass amb composite preserve-core i paleta neon

shaders/bloom.frag.glsl

@@ -0,0 +1,71 @@
+#version 450
+
+// Fragment shader del bloom: una passada 1D de blur gaussià separable, amb
+// high-pass opcional. Es crida dues vegades per frame:
+//
+//   Pass H: extract=1.0, direction=(1,0). Llegeix l'escena offscreen i
+//           emet a bloom_texture_a aplicant high-pass + gaussiana horitzontal.
+//   Pass V: extract=0.0, direction=(0,1). Llegeix bloom_texture_a i emet
+//           a bloom_texture_b amb la gaussiana vertical (sense high-pass).
+//
+// Resultat: equivalent matemàtic d'una convolució 2D de 15×15 mostres denses,
+// però només costa 2×15 = 30 mostres per píxel. Sense moiré (samples a
+// distància 1 texel, així que la gaussiana és contínua a l'escala del píxel).
+//
+// El paràmetre `sigma` (en texels) controla l'amplada del halo. Per a sigma=4,
+// el halo cobreix ~12 texels al voltant de cada línia. Pujar sigma engreixa
+// el halo; cal mantenir-lo ≤ ~5-6 perquè el rang de mostreig (±7 taps) cobreixi
+// el 99% del gaussià.
+//
+// Recursos:
+//   set=2, binding=0 → sampler2D (input)
+//   set=3, binding=0 → uniform buffer (paràmetres)
+
+layout(set = 2, binding = 0) uniform sampler2D src;
+
+layout(set = 3, binding = 0) uniform BloomUBO {
+    vec2 texel_size;   // 1.0 / texture_size
+    vec2 direction;    // (1,0) per pass H, (0,1) per pass V
+    float threshold;   // luminància mínima per al high-pass
+    float extract;     // 1.0 = aplica high-pass (pass H), 0.0 = blur pur (pass V)
+    float sigma;       // sigma de la gaussiana en texels
+    float _pad;
+} ubo;
+
+layout(location = 0) in vec2 v_uv;
+layout(location = 0) out vec4 frag;
+
+void main() {
+    vec3 sum = vec3(0.0);
+    float total_weight = 0.0;
+
+    // 15 taps: -7..+7, espaiats 1 texel. Cobreix ±7 texels = ±~2σ per σ=3.5.
+    // Per σ més grans, el cua es retalla una mica però el peso del tap 7 ja és
+    // molt baix; visualment no es nota.
+    const int RADIUS = 7;
+    const float TWO_SIGMA_SQ_FACTOR = 2.0;  // multiplicador per a 2σ² al denominador
+
+    for (int i = -RADIUS; i <= RADIUS; ++i) {
+        vec2 offset = ubo.direction * float(i) * ubo.texel_size;
+        vec3 c = texture(src, v_uv + offset).rgb;
+
+        // High-pass només a la primera passada: a la segona, c ja és el
+        // resultat de la H i no l'hem de tornar a filtrar.
+        if (ubo.extract > 0.5) {
+            float luma = max(c.r, max(c.g, c.b));
+            float high_pass = max(0.0, luma - ubo.threshold);
+            c *= high_pass;
+        }
+
+        float fi = float(i);
+        float w = exp(-(fi * fi) / (TWO_SIGMA_SQ_FACTOR * ubo.sigma * ubo.sigma));
+        sum += c * w;
+        total_weight += w;
+    }
+
+    if (total_weight > 0.0) {
+        sum /= total_weight;
+    }
+
+    frag = vec4(sum, 1.0);
+}

shaders/postfx.frag.glsl

@@ -1,37 +1,37 @@
 #version 450
 
-// Fragment shader del pase de postprocesado.
-// Lee la textura offscreen (escena vectorial sobre fondo negro) y produce
-// el fragmento final aplicando:
-//   1. Bloom kernel 5×5 con high-pass (solo los brillos por encima de
-//      threshold contribuyen).
-//   2. Flicker: multiplicador global de brillo modulado por tiempo
-//      (sustituye al oscilador CPU del legacy).
-//   3. Background pulse: color de fondo que oscila entre min y max y se
-//      suma a la imagen (las líneas brillan por encima).
+// Fragment shader del pase final de composite.
+// Llegeix dos samplers: l'escena vectorial i el bloom ja pre-calculat (resultat
+// del separable blur de dues passes a bloom.frag.glsl). Aplica:
+//   1. Mescla del bloom amb la intensitat configurada.
+//   2. Flicker: multiplicador global de brillo modulat per temps.
+//   3. Background pulse: color de fons additiu que oscil·la entre min/max.
+//
+// L'arquitectura anterior tenia el bloom inline (kernel 7×7 single-pass), que
+// produïa moiré per radis grans. Ara el bloom és pre-computed via separable
+// gaussian (equivalent a kernel 15×15 dens) i aquí només cal samplejar-lo.
 //
 // Resource sets (SDL_gpu):
 //   set=2, binding=0 → sampler2D (escena offscreen)
-//   set=3, binding=0 → uniform buffer (parámetros del postpro)
+//   set=2, binding=1 → sampler2D (bloom pre-calculat)
+//   set=3, binding=0 → uniform buffer (paràmetres del postpro)
 
 layout(set = 2, binding = 0) uniform sampler2D scene;
+layout(set = 2, binding = 1) uniform sampler2D bloom_tex;
 
 layout(set = 3, binding = 0) uniform PostFxUBO {
     float time;
     float bloom_intensity;
-    float bloom_threshold;
-    float bloom_radius_px;
-
     float flicker_amplitude;
     float flicker_frequency_hz;
+
     float background_pulse_freq_hz;
     float _pad_a;
+    float _pad_b;
+    float _pad_c;
 
     vec4 background_min;   // RGB en [0..1], A=1
     vec4 background_max;   // RGB en [0..1], A=1
-
-    vec2 texel_size;       // 1.0 / texture_size
-    vec2 _pad_b;
 } ubo;
 
 layout(location = 0) in vec2 v_uv;
@@ -40,43 +40,26 @@ layout(location = 0) out vec4 frag;
 const float TAU = 6.28318530718;
 
 void main() {
-    // === BLOOM ===
-    // Kernel 5×5 con muestreo radial y high-pass por luminancia (max RGB).
-    // Pesos gaussianos: w = exp(-(dx²+dy²) / 4).
     vec3 src = texture(scene, v_uv).rgb;
-    vec3 bloom = vec3(0.0);
-    float total_weight = 0.0;
-    for (int dy = -2; dy <= 2; ++dy) {
-        for (int dx = -2; dx <= 2; ++dx) {
-            vec2 offset = vec2(float(dx), float(dy)) * ubo.texel_size * ubo.bloom_radius_px;
-            vec3 c = texture(scene, v_uv + offset).rgb;
-            float luma = max(c.r, max(c.g, c.b));
-            float high_pass = max(0.0, luma - ubo.bloom_threshold);
-            float w = exp(-(float(dx * dx + dy * dy)) / 4.0);
-            bloom += c * high_pass * w;
-            total_weight += w;
-        }
-    }
-    if (total_weight > 0.0) {
-        bloom /= total_weight;
-    }
-    bloom *= ubo.bloom_intensity;
+    vec3 bloom = texture(bloom_tex, v_uv).rgb * ubo.bloom_intensity;
 
     // === FLICKER ===
-    // Multiplicador global de brillo. Oscila entre (1.0 - amplitude) y 1.0.
-    // amplitude=0 → sin flicker; amplitude=1 → pulsa entre apagado y máximo.
+    // Multiplicador global de brillo. Oscil·la entre (1.0 - amplitude) i 1.0.
     float pulse = (sin(ubo.time * ubo.flicker_frequency_hz * TAU) * 0.5) + 0.5;
     float flicker = 1.0 - (ubo.flicker_amplitude * (1.0 - pulse));
 
     // === BACKGROUND PULSE ===
-    // Suma de color de fondo oscilante. min..max se interpolan con sin(t).
     float bg_pulse = (sin(ubo.time * ubo.background_pulse_freq_hz * TAU) * 0.5) + 0.5;
     vec3 background = mix(ubo.background_min.rgb, ubo.background_max.rgb, bg_pulse);
 
-    // === COMPOSICIÓN ===
-    // El offscreen viene con clear=black, por lo que solo las líneas y el
-    // bloom aportan luz. Sumamos el fondo y luego multiplicamos por flicker
-    // para que el pulso afecte a todo (líneas + bloom + bg).
-    vec3 lines_and_glow = (src + bloom) * flicker;
+    // === COMPOSICIÓ (preserve-core) ===
+    // Bloom additiu però atenuat per (1 - luma_src): no contribueix als píxels
+    // on la línia ja és brillant (manté el color del core sense rentar-lo cap a
+    // blanc) i contribueix al màxim als píxels foscos del voltant (halo intens).
+    // El flicker només multiplica (línies + bloom); el fons va a banda perquè
+    // els píxels foscos no han de pulsar.
+    float src_luma = max(src.r, max(src.g, src.b));
+    vec3 bloom_contribution = bloom * (1.0 - src_luma);
+    vec3 lines_and_glow = (src + bloom_contribution) * flicker;
     frag = vec4(background + lines_and_glow, 1.0);
 }