Fase 8c: postpro (bloom + flicker + background) en SDL_gpu

Renderiza la escena de líneas a una textura offscreen y aplica un pase
final de postpro que compone la imagen al swapchain. El shader del
postpro hace tres cosas:

- Bloom: kernel gaussiano 5×5 con high-pass por luminancia. Configurable
  vía intensity, threshold y radius_px.
- Flicker: multiplicador global de brillo modulado por sin(time*freq).
  Sustituye al antiguo ColorOscillator CPU; eliminados oscillator.{hpp,cpp}
  y Defaults::Color. SDLManager::updateColors queda como no-op para no
  tocar las escenas que lo invocaban.
- Background pulse: color de fondo aditivo entre color_min y color_max,
  pulsando en el tiempo.

Parámetros expuestos en data/config/postfx.yaml y cargados con fkYAML.
Si el archivo falta o falla, se usan defaults built-in. UV.y invertida
en el vertex shader del postpro para compensar la convención de
muestreo de SDL_gpu/Vulkan (el line shader sigue con su ndc.y flip).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

shaders/postfx.frag.glsl

@@ -0,0 +1,82 @@
+#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).
+//
+// Resource sets (SDL_gpu):
+//   set=2, binding=0 → sampler2D (escena offscreen)
+//   set=3, binding=0 → uniform buffer (parámetros del postpro)
+
+layout(set = 2, binding = 0) uniform sampler2D scene;
+
+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;
+
+    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;
+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;
+
+    // === 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.
+    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;
+    frag = vec4(background + lines_and_glow, 1.0);
+}

shaders/postfx.vert.glsl

@@ -0,0 +1,28 @@
+#version 450
+
+// Vertex shader del pase de postprocesado.
+// Emite un solo triángulo que cubre toda la pantalla (técnica del "fullscreen
+// triangle"): tres vértices en (-1,-1), (3,-1), (-1,3) → la región visible
+// [-1..1]² queda completamente cubierta y el clip recorta el resto. No hace
+// falta vertex buffer; el draw es DrawPrimitives(vertex_count=3).
+
+layout(location = 0) out vec2 v_uv;
+
+void main() {
+    vec2 positions[3] = vec2[3](
+        vec2(-1.0, -1.0),
+        vec2( 3.0, -1.0),
+        vec2(-1.0,  3.0)
+    );
+    // UV.y invertida para compensar la diferencia entre la convención de
+    // clip-space del line shader (ndc.y flipeado, GL-style) y la convención
+    // de muestreo de SDL_gpu/Vulkan (origen de textura en top-left). Sin esta
+    // inversión, el offscreen se ve cabeza-abajo en el composite.
+    vec2 uvs[3] = vec2[3](
+        vec2(0.0, 1.0),
+        vec2(2.0, 1.0),
+        vec2(0.0, -1.0)
+    );
+    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
+    v_uv = uvs[gl_VertexIndex];
+}