Fix errors

shaders/phosphor.frag

@@ -2,9 +2,15 @@
  * MIT License
  * Author: Mark Allyn
  *
- * phosphor.frag — maps the single-channel phosphor energy texture to
- * the P7 colour sequence (blue → green → yellow-green → dark) and
- * applies a simple inline bloom (box-filter glow) to bright pixels.
+ * phosphor.frag — maps the two-channel phosphor energy texture to the
+ * P7 colour sequence (blue → green → yellow-green → dark) and applies
+ * a simple inline bloom (box-filter glow) to bright pixels.
+ *
+ * The phosphor FBO is GL_RG32F:
+ *   R channel — signal energy (target echoes, sweep background)
+ *               multiplied by u_gain before display
+ *   G channel — range ring energy, gain-independent; mixed with signal
+ *               after gain is applied so rings never dim with gain
  *
  * Coordinate system: gl_FragCoord.xy in GL viewport pixels (origin
  * bottom-left). Scope centre is passed as u_scopeCenter in the same
@@ -14,17 +20,19 @@
 
 out vec4 fragColor;
 
-uniform sampler2D u_phosphor;   // GL_R32F phosphor energy FBO
+uniform sampler2D u_phosphor;   // GL_RG32F phosphor energy FBO
 uniform vec2  u_scopeCenter;    // scope centre in GL viewport pixels (bottom-left origin)
 uniform float u_scopeRadius;    // scope radius in pixels
-uniform float u_gain;           // receiver gain [0,1] — scales brightness
+uniform float u_gain;           // receiver gain [0,1] — scales signal (R) channel only
 uniform float u_bloomStep;      // UV step for bloom sample (≈ 2.5 / FBO_SIZE)
 uniform float u_bloomStrength;  // additive blend weight for bloom
 
-// P7 energy thresholds (match settings.h)
+// P7 energy thresholds — MUST match settings.h P7_THRESH_* constants.
+// T_YGREE is intentionally low (0.05) to keep most of the decay in the
+// GREEN zone; see the comment in settings.h for the full rationale.
 const float T_BLUE  = 0.82;
 const float T_GREEN = 0.55;
-const float T_YGREE = 0.22;
+const float T_YGREE = 0.05;
 const float T_DARK  = 0.03;
 
 // P7 colour anchors
@@ -34,16 +42,22 @@ const vec3 C_YGREE = vec3(0.50, 1.00, 0.05);
 const vec3 C_YELLW = vec3(0.70, 0.70, 0.00);
 const vec3 C_BLACK = vec3(0.00, 0.00, 0.00);
 
+// P7 colour ramp: hue selected by energy level, then scaled by energy so
+// brightness decreases monotonically from fresh strike (peak) to dark.
+// This prevents intermediate decay colours (yellow-green) from appearing
+// brighter than the initial blue flash.
 vec3 p7Color(float e) {
+    if (e < T_DARK) return C_BLACK;
+    vec3 hue;
     if (e >= T_BLUE)
-        return mix(C_GREEN, C_BLUE,  (e - T_GREEN) / (T_BLUE  - T_GREEN));
-    if (e >= T_GREEN)
-        return mix(C_YGREE, C_GREEN, (e - T_YGREE) / (T_GREEN - T_YGREE));
-    if (e >= T_YGREE)
-        return mix(C_YELLW, C_YGREE, (e - T_DARK ) / (T_YGREE - T_DARK ));
-    if (e >= T_DARK)
-        return mix(C_BLACK, C_YELLW, e / T_DARK);
-    return C_BLACK;
+        hue = C_BLUE;
+    else if (e >= T_GREEN)
+        hue = mix(C_GREEN, C_BLUE,  (e - T_GREEN) / (T_BLUE  - T_GREEN));
+    else if (e >= T_YGREE)
+        hue = mix(C_YGREE, C_GREEN, (e - T_YGREE) / (T_GREEN - T_YGREE));
+    else
+        hue = mix(C_YELLW, C_YGREE, (e - T_DARK)  / (T_YGREE - T_DARK));
+    return hue * e;
 }
 
 void main() {
@@ -57,10 +71,12 @@ void main() {
     }
 
     // Map from PPI delta [-1,+1] to phosphor texture UV [0,1]
-    // delta.x = east, delta.y = north (both y directions already match)
     vec2 uv = delta * 0.5 + 0.5;
 
-    float energy = texture(u_phosphor, uv).r * u_gain;
+    vec2 rg = texture(u_phosphor, uv).rg;
+    // Signal (R): gain-scaled received echoes.
+    // Ring (G): gain-independent timing reference; always at full brightness.
+    float energy = max(rg.r * u_gain, rg.g);
 
     // Inline bloom: weighted box-filter over a 5×5 neighbourhood
     float bloom = 0.0;
@@ -68,7 +84,8 @@ void main() {
     for (int dx = -2; dx <= 2; dx++) {
         for (int dy = -2; dy <= 2; dy++) {
             float w = exp(-float(dx*dx + dy*dy) * 0.45);
-            float e = texture(u_phosphor, uv + vec2(dx, dy) * u_bloomStep).r;
+            vec2 srg = texture(u_phosphor, uv + vec2(dx, dy) * u_bloomStep).rg;
+            float e  = max(srg.r * u_gain, srg.g);
             bloom += e * w;
             wsum  += w;
         }