Fix errors

shaders/sweep.frag

@@ -4,13 +4,16 @@
  *
  * sweep.frag — phosphor accumulation update shader.
  *
- * For each texel in the 1024×1024 phosphor FBO:
- *   1. Decay the previous frame's energy by u_decayFactor.
- *   2. If the texel's PPI bearing falls within the current sweep arc
- *      [u_beamAnglePrev, u_beamAngle], add contributions from:
- *        - range rings (beam-painted per the P7 spec)
- *        - target echoes
- *   3. Output the updated single-channel energy value.
+ * The FBO is GL_RG32F (two independent energy channels):
+ *   R — signal energy: target echoes + sweep-background glow.
+ *       Multiplied by u_gain in the display pass so operators can
+ *       adjust received-signal brightness without touching rings.
+ *   G — range-ring energy: written at u_ringBrightness; NOT scaled
+ *       by gain.  Rings are a precision timing reference, not a
+ *       received echo.  Both channels decay at the same P7 rate.
+ *
+ * The sweep background (u_sweepBg) goes into the G channel so the
+ * rotating beam is always visible regardless of the gain setting.
  *
  * PPI convention: north = +y, east = +x; bearing = atan2(x, y)
  * in degrees, clockwise from north.
@@ -19,17 +22,18 @@
 
 in vec2 vTexCoord;
 
-layout(location = 0) out vec4 fragOut;  // .r = energy; .gba unused
+layout(location = 0) out vec4 fragOut;  // .r = signal; .g = ring+sweep; .ba unused
 
-uniform sampler2D u_prevPhosphor;  // previous frame's energy texture (GL_R32F)
+uniform sampler2D u_prevPhosphor;  // previous frame's energy texture (GL_RG32F)
 uniform float u_decayFactor;       // exp(-decay_rate * dt)
 uniform float u_beamAngle;         // current beam angle, degrees CW from north
 uniform float u_beamAnglePrev;     // beam angle at previous frame
-uniform float u_sweepBg;           // ambient sweep-line energy (makes beam visible)
+uniform float u_sweepBg;           // ambient sweep-line energy (gain-independent)
 uniform float u_halfBeamDeg;       // half-beamwidth for target blobs (display widening)
 
-// Targets: .x = range_norm (0-1), .y = bearing_deg, .z = brightness, .w = size_norm
+// Targets: .x = range_norm (0-1), .y = bearing_deg, .z = brightness, .w = radial_size_norm
 uniform vec4  u_targets[32];
+uniform float u_targetAngHalfDeg[32]; // per-target azimuthal half-width (degrees)
 uniform int   u_targetCount;
 
 // Range rings: up to 4 normalised radii
@@ -59,8 +63,8 @@ bool inSweep(float b, float prev, float curr) {
 // ----------------------------------------------------------------
 
 void main() {
-    vec2 pos   = vTexCoord * 2.0 - 1.0;   // PPI coords: (-1,-1) SW … (+1,+1) NE
-    float rng  = length(pos);
+    vec2 pos  = vTexCoord * 2.0 - 1.0;   // PPI coords: (-1,-1) SW … (+1,+1) NE
+    float rng = length(pos);
 
     if (rng > 1.0) {
         fragOut = vec4(0.0);
@@ -71,23 +75,25 @@ void main() {
     float brg = degrees(atan(pos.x, pos.y));
     if (brg < 0.0) brg += 360.0;
 
-    // Decay previous value
-    float energy = texture(u_prevPhosphor, vTexCoord).r * u_decayFactor;
+    vec2  prev   = texture(u_prevPhosphor, vTexCoord).rg;
+    float signal = prev.r * u_decayFactor;
+    float ring   = prev.g * u_decayFactor;
 
     if (inSweep(brg, u_beamAnglePrev, u_beamAngle)) {
 
-        float contrib = u_sweepBg;   // beam passage gives a faint ambient glow
-
-        // ---- Range rings (painted at every bearing as beam sweeps) ----
+        // ---- Range rings → G channel (gain-independent) ----
+        float ringContrib = u_sweepBg;   // sweep-background glow also in G channel
         for (int i = 0; i < u_ringCount; i++) {
             float d = abs(rng - u_ringRadii[i]);
             if (d < u_ringWidth) {
                 float w = 1.0 - d / u_ringWidth;
-                contrib = max(contrib, u_ringBrightness * w * w);
+                ringContrib = max(ringContrib, u_ringBrightness * w * w);
             }
         }
+        ring = max(ring, ringContrib);
 
-        // ---- Target echoes ----
+        // ---- Target echoes → R channel (gain-scaled in display pass) ----
+        float sigContrib = 0.0;
         for (int i = 0; i < u_targetCount; i++) {
             float tRng  = u_targets[i].x;
             float tBrg  = u_targets[i].y;
@@ -96,21 +102,19 @@ void main() {
 
             if (tRng <= 0.0 || tBrt <= 0.0) continue;
 
-            // Angular proximity: beam must be sweeping over the target's bearing
+            float tAngHalf = u_targetAngHalfDeg[i];
             float dBrg = angleDiff(brg, tBrg);
-            if (dBrg >= u_halfBeamDeg) continue;
+            if (dBrg >= tAngHalf) continue;
 
-            // Range proximity: pixel must be within the target blob
             float dRng = abs(rng - tRng);
             if (dRng >= tSize) continue;
 
-            float bw = 1.0 - dBrg / u_halfBeamDeg;         // angular taper
-            float rw = 1.0 - dRng / tSize;                  // range taper
-            contrib = max(contrib, tBrt * bw * rw);
+            float bw = 1.0 - dBrg / tAngHalf;
+            float rw = 1.0 - dRng / tSize;
+            sigContrib = max(sigContrib, tBrt * bw * rw);
         }
-
-        energy = max(energy, contrib);
+        signal = max(signal, sigContrib);
     }
 
-    fragOut = vec4(clamp(energy, 0.0, 1.0), 0.0, 0.0, 1.0);
+    fragOut = vec4(clamp(signal, 0.0, 1.0), clamp(ring, 0.0, 1.0), 0.0, 1.0);
 }