Overdrive cables: remove dead weight from the cable feature (redo)

Redo of the pre-tent-rework cleanup (16be8d501 on cable-cutting) against
current master — the original predates the tent geometry, the coverage-slot
ghost sentinel move and the cableTangent budget work, so it was re-derived
item by item rather than merged. No intended behaviour change; the live
render path is untouched.

- Bubble-phase integration (dead): the FS advects bubbles purely from
  gameTime via the crossfaded speed ladder; the CPU-side integrated phase it
  never read is gone (widthOfCapacity, flowToSpeed, BUBBLE_* constants,
  per-edge bubblePhase/Speed/AnchorTime, both catch-up loops, bubbleBakeTime,
  the commented-out bakeTime uniform plumbing and the FS's dead bakeTime
  declaration). Vertex payload shrinks 10 -> 9 floats: vertGrid is now vec3
  (eff, flow, isOwnAlly/ghost flag) end-to-end — Lua generators + both VBO
  Defines, VS attribute, GS DataVS and ghost checks (.w -> .z); the FS
  already read the flag from .z since the tangent budget commit.
- Grid-efficiency send: EFF_EPSILON/lastSentEff were never read. Deleted, and
  the comment that claimed eff changes force a re-send now documents the
  actual behaviour (eff hue refreshes on the FORCE_SEND_TICKS cadence).
- geomCache: invalidation bookkeeping for a cache that was never implemented.
  Removed the table and all four .valid sites.
- Dead CPU-router remnants: redeclared math locals, unused BRANCH_*/router
  constants (SEG_LENGTH, NOISE_AMP_ABS, MERGE_ANGLE, STEM_FRACTION, Lua
  GROWTH_RATE/WITHER_RATE), Hash/HashUnit/GetTrunkWidth/NoisyPath/
  normalizeAngle, MarkGridDirty, GetNodePcurrent (and now-orphaned
  generatorDefs), the prange column, spGetGroundHeight/MAP_* captures, two
  unused spec captures, the 'old angle clustering' tombstone comment.
- Shaders: drop the twig tipR/twigHWt/CONE_TIP_WIDTH chain (twig is a 3-vert
  triangle; tip emitted as tip3D, geometry identical — header vert counts
  fixed 4 -> 3); delete the unreachable t > 0.90 FS discard (t <= EDGE_BUFFER
  = 0.55 by construction); refresh the comments that described the removed
  CPU phase anchoring.

luacheck: 79 -> 74 warnings; all remaining are the gl/GL unsynced
false-positives and the pre-existing 'edges' shadowing. luac5.1 -p clean.
Shader compile/link still needs a dev run to confirm (GLSL can't be checked
offline).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Anarchid

LuaRules/Gadgets/Shaders/gfx_overdrive_cables.frag.glsl

@@ -6,7 +6,6 @@
 uniform sampler2D infoTex;
 uniform sampler2D cableTex;
 uniform float gameTime;
-uniform float bakeTime;
 uniform float enableFlow;     // 1.0 = full bubble pass; 0.0 = static cables (no animation)
 uniform float ghostsEnabled;  // 1.0 = ghost branch active; 0.0 = enemy OOL discards immediately
 uniform sampler2DShadow shadowTex;  // engine shadow map ($shadow); sampled for shadow reception
@@ -26,7 +25,7 @@ in DataGS {
 	float width;
 	vec2 cableUV;
 	vec2 timeData;
-	vec3 gridData;          // was vec4; .z was unused, dropped to fund cableTangent (see GS BUDGET NOTE). Old .w (isOwnAlly / ghost flag) is now .z.
+	vec3 gridData;          // (gridEfficiency, flow, isOwnAlly / ghost flag); see GS BUDGET NOTE
 	vec3 cableTangent;      // smooth per-vertex cable along-direction; interpolated → drives the lit frame below
 	float spawnAlongMain;   // overloaded: main ribbon → lenPerSeg; twig → twig-along
 	flat int gsSlot;
@@ -39,9 +38,10 @@ in DataGS {
 // Pure aesthetic constants; nothing here changes geometry or topology.
 // =====================================================================
 
-// Grow/wither animation rates (elmos/s) — must match unsynced GROWTH_RATE/
-// WITHER_RATE so the CPU-side bubble phase anchor and the FS-side growth
-// front sweep at the same speed.
+// Grow/wither animation rates (elmos/s). The CPU only supplies appear/wither
+// timestamps (timeData); the fronts sweep entirely FS-side. The unsynced
+// WITHER_HOLD_FRAMES must stay generous relative to worst-case cable length /
+// WITHER_RATE so geometry outlives the animation.
 const float GROWTH_RATE        = 250.0;
 const float WITHER_RATE        = 400.0;
 
@@ -100,8 +100,9 @@ const float SIZE_4 = 1.32;
 // dimFactor instead but always render.
 const float ENEMY_LOS_CUT      = 0.1;
 
-// Bubble flow mapping. Must mirror Lua flowToSpeed() exactly for CPU-baked
-// phase anchoring + FS extrapolation to remain continuous across baking.
+// Bubble flow mapping. Advection is FS-only: phase derives purely from
+// gameTime via the crossfaded speed ladder in main() — nothing is
+// CPU-integrated, so there is no bake to stay continuous across.
 const float MAX_SPEED          = 130.0;
 const float MAX_DENSITY_FLOW   = 100.0;
 const float MIN_TRUNK_W        = 3.0;
@@ -176,10 +177,9 @@ float hash1(float n) {
 // Shading: faint inner glow + Fresnel rim + small offset highlight, all with
 // smoothstep edges to avoid pixelation at oblique camera angles. Returns
 // (body, specular).
-// `phase` is the integrated travel distance baked + extrapolated by the
-// caller (CPU integrates ∫ speed dt, shader extrapolates the last segment
-// with the current speed). Subtracting from `along` advects bubbles smoothly
-// across speed changes.
+// `phase` is the travel distance the caller derives from gameTime (via the
+// crossfaded speed ladder in main(), so subtle flow changes can't teleport
+// bubbles). Subtracting it from `along` advects the bubbles.
 //
 // Returns vec3: (body, specular, halo). Caller composites all three with
 // possibly different colour weights for richer look.
@@ -299,7 +299,6 @@ float getShadowCoeff(vec3 wp, float NdotL) {
 void main() {
 	float v = cableUV.y * EDGE_BUFFER;
 	float t = abs(v);
-	if (t > 0.90) discard;
 
 	// Visual grow/wither: cableUV.x is distance along cable in elmos.
 	// Growth front advances from u=0 forward.
@@ -566,14 +565,12 @@ void main() {
 	//   - Two layered streams of bubbles (big + small) with random per-bubble
 	//     size + cross-axis offset, so the cable looks like a real bubbly
 	//     slurry instead of a metronome of identical dots.
-	// Bubble speed/density mapping. MUST match the CPU's flowToSpeed for the
-	// integrated phase anchoring to stay consistent.
 	//
 	// Cable thickness conveys capacity (orthogonal);
 	float flow = gridData.y;
 	// Linear thickness divisor: a cable 4× thicker than min gets its flow
 	// signal scaled to 1/4 before the sqrt → ~0.5× visual liveliness. Slight
-	// negative bias for thick cables, matching the CPU's flowToSpeed.
+	// negative bias for thick cables ("wide pipe, same flow, calmer look").
 	float thicknessRatio = max(1.0, width / MIN_TRUNK_W);
 	float effFlow = max(flow, 0.0) / thicknessRatio;
 	float flowFactor = min(1.0, sqrt(effFlow / MAX_DENSITY_FLOW));

LuaRules/Gadgets/Shaders/gfx_overdrive_cables.geom.glsl

@@ -9,7 +9,7 @@
 // max_vertices budget, so we can:
 //   invocation 0          → left tent slope  (ridge→ground, SEGMENTS+1 × 2 verts)
 //   invocation 1          → right tent slope (ridge→ground, SEGMENTS+1 × 2 verts)
-//   invocations 2..N-1    → one twig each (4 verts), conditional on a hash
+//   invocations 2..N-1    → one twig each (3 verts), conditional on a hash
 // Splitting the cross-section into two single-sheet slopes (one per invocation)
 // is what lets the full raised-ridge tent fit: each slope gets its own
 // GL_MAX_GEOMETRY_OUTPUT_COMPONENTS budget, so neither busts the 1024 ceiling a
@@ -21,7 +21,7 @@ layout (lines, invocations = 5) in;
 // 46 verts/invocation fits the min-spec total-components budget once the
 // per-vertex cableTangent varying is included (46 × 22 = 1012 ≤ 1024). The
 // tent-slope invocations use the full 46 (= 23 boundaries × 2); twig
-// invocations use 4.
+// invocations use 3.
 layout (triangle_strip, max_vertices = 46) out;
 
 uniform sampler2D heightmapTex;
@@ -42,7 +42,7 @@ layout (std430, binding = 6) coherent buffer cableCoverageBuffer {
 in DataVS {
 	vec2 vsWorldXZ;
 	vec3 vsCableData;
-	vec4 vsGridData;
+	vec3 vsGridData;
 	flat int vsSlot;
 } dataIn[];
 
@@ -52,11 +52,12 @@ in DataVS {
 // pulse animation). For main-ribbon fragments (isBranch<0.5) it carries the
 // cable's len-per-segment so the FS can derive a per-segment bit index for
 // the coverage SSBO. The two semantics are disjoint by isBranch so no conflict.
-// BUDGET NOTE: `gridData` is a vec3 (was vec4 — the .z component was never read
-// by the FS). Shrinking it reclaimed one component so `cableTangent` could be
-// added without busting GL_MAX_GEOMETRY_OUTPUT_COMPONENTS' total budget: with
-// the tangent the per-vertex count is 22 (incl. gl_Position), so max_vertices
-// drops 50→46 to keep 46 × 22 = 1012 ≤ 1024 (min-spec).
+// BUDGET NOTE: `gridData` is a vec3 (eff, flow, isOwnAlly/ghost flag). It was a
+// vec4 whose .z carried a CPU-integrated bubble phase the FS never read;
+// dropping that float (now removed end-to-end — the CPU sends 3 floats)
+// reclaimed the component that funds `cableTangent`: with the tangent the
+// per-vertex count is 22 (incl. gl_Position), so max_vertices is 46 to keep
+// 46 × 22 = 1012 ≤ 1024 (min-spec GL_MAX_GEOMETRY_OUTPUT_COMPONENTS).
 out DataGS {
 	vec3 worldPos;
 	float capacity;
@@ -162,14 +163,13 @@ const int   PLACEMENT_OVERSAMPLE = 2;
 const int   MAX_GRID             = MAX_SEGMENTS * 2;   // local-array bound for the scan
 const float KINK_GAIN            = 0.15;
 
-// Twig parameters mirror the Lua-side BRANCH_* constants.
+// Twig parameters (chance/geometry of the small side branches).
 const float BRANCH_CHANCE     = 0.85;
 const float BRANCH_LEN_MIN    = 6.0;
 const float BRANCH_LEN_MAX    = 8.0;
 const float BRANCH_ANGLE_MIN  = 1.2;
 const float BRANCH_ANGLE_MAX  = 1.5;
 const float BRANCH_WIDTH      = 2.1;
-const float CONE_TIP_WIDTH    = 0.0;
 const float BRANCH_WIDTH_TWIG_LENGTH_FACTOR = 2.0;
 
 // Clearance over the heightmap, applied along the cable's chord-averaged surface
@@ -196,14 +196,14 @@ float gOutSpawnAlong = 0.0;
 int   gOutSlot       = -1;
 
 void emitVtx(vec3 wp, vec3 tangent3D, vec2 cuv,
-             float w, vec4 grid, vec2 td, float cap) {
+             float w, vec3 grid, vec2 td, float cap) {
 	worldPos = wp;
 	capacity = cap;
 	isBranch = gOutBranch;
 	width = w;
 	cableUV = cuv;
 	timeData = td;
-	gridData = grid.xyw;          // .z dropped (unused by FS); see DataGS BUDGET NOTE
+	gridData = grid;
 	cableTangent = tangent3D;     // smooth along-dir → FS interpolates the lit frame
 	spawnAlongMain = gOutSpawnAlong;
 	gsSlot = gOutSlot;
@@ -455,7 +455,7 @@ int placeRibbonVertices(vec2 a, vec2 d, vec2 perpAB, float lenAB, float arcDh,
 // verts/boundary), so the full tent only costs one extra invocation.
 void emitTentHalf(float side, vec2 a, vec2 d, vec2 perpAB,
                   float halfW, float widthVal, float effAmp, float seed,
-                  vec4 gridD, vec2 timeD, float cap, int numSeg, float arcDh) {
+                  vec3 gridD, vec2 timeD, float cap, int numSeg, float arcDh) {
 	gOutBranch = 0.0;
 	float tentHeight = halfW * TENT_HEIGHT_FACTOR;
 	// `along` is fed into the FS as cableUV.x and drives bubble advection.
@@ -594,7 +594,7 @@ void emitTentHalf(float side, vec2 a, vec2 d, vec2 perpAB,
 // hash says "no twig here" — leaving an empty primitive, which is a no-op.
 void emitTwig(vec2 a, vec2 d, vec2 perpAB,
               float halfMainW, float widthVal, float effAmp, float seed,
-              vec4 gridD, vec2 timeD, float cap, float tCenter,
+              vec3 gridD, vec2 timeD, float cap, float tCenter,
               float spawnAlongMain, int twigIdx, float arcDh, int numSeg,
               vec3 railPrev, vec3 railCenter) {
 	// Resolve spawn point on the wiggly main path at tCenter so twigs root on
@@ -624,19 +624,14 @@ void emitTwig(vec2 a, vec2 d, vec2 perpAB,
 	float bLen = BRANCH_LEN_MIN + widthVal*BRANCH_WIDTH_TWIG_LENGTH_FACTOR +
 		gsHashU(spawn.x, spawn.y, twigSeed + 3.0) * (BRANCH_LEN_MAX - BRANCH_LEN_MIN);
 
+	// The twig is a 3-vertex triangle: a full-width root edge tapering to a
+	// point at tip3D. The WIDTH varying passed to the FS stays UNIFORM at
+	// `twigW` along the whole twig, so bubble math sees constant halfWidthE
+	// and bubble radius/spacing don't change with along position; the visible
+	// bubble simply projects smaller near the point. This decouples "bubble
+	// flow looks uniform" from "twig has a cone shape".
 	float twigW    = max(2.5, widthVal * BRANCH_WIDTH);
 	float twigHWr  = min(twigW, widthVal * 0.55) * BRANCH_WIDTH;
-	// Geometric cone taper at 0.45 — visible shape narrows toward the tip
-	// (looks like a branch, not a tube). The WIDTH varying we pass to the FS
-	// stays UNIFORM at `twigW` along the entire twig, so bubble math sees
-	// constant halfWidthE and bubble radius/spacing don't change with along
-	// position. The visible bubble naturally fits the tapered geometry: in v
-	// space the bubble keeps the same cross-axis extent (relative to the
-	// cable's UV cross), which projects to a smaller world-cross at the
-	// thinner tip. At the very end the cable's `t > 0.9` cross discard clips
-	// any bubble that runs off the tip. This decouples "bubble flow looks
-	// uniform" from "twig has cone shape".
-	float twigHWt  = twigHWr * CONE_TIP_WIDTH;
 
 	// Build the twig as a flat ribbon in the slope's local tangent plane at
 	// the spawn point. This way, viewing perpendicular to the slope, the twig
@@ -689,19 +684,17 @@ void emitTwig(vec2 a, vec2 d, vec2 perpAB,
 
 	vec3 rootL = root3D - twigPerp3D * twigHWr;
 	vec3 rootR = root3D + twigPerp3D * twigHWr;
-	vec3 tipL  = tip3D  - twigPerp3D * twigHWt;
-	vec3 tipR  = tip3D  + twigPerp3D * twigHWt;
 
 	// cableUV.x carries the cable-wide along distance so the FS growth gate
 	// hides this twig until the main growth front has reached spawnAlongMain.
 	// vsTangent for twigs is the twigDir3D (the twig's along-direction); the
 	// FS derives perp3D from cross(worldUp, vsTangent) so cylindrical lighting
 	// follows the twig's pointing direction.
 	gOutBranch = 1.0;
-	gOutSpawnAlong = spawnAlongMain;   // shared by all 4 twig vertices; lets FS compute twig-local along
-	emitVtx(rootL, twigDir3D, vec2(spawnAlongMain,        -1.0), twigW,        gridD, timeD, cap);
-	emitVtx(rootR, twigDir3D, vec2(spawnAlongMain,         1.0), twigW,        gridD, timeD, cap);
-	emitVtx(tipL,  twigDir3D, vec2(spawnAlongMain + bLen, -1.0), twigW, gridD, timeD, cap);
+	gOutSpawnAlong = spawnAlongMain;   // shared by all 3 twig vertices; lets FS compute twig-local along
+	emitVtx(rootL, twigDir3D, vec2(spawnAlongMain,        -1.0), twigW, gridD, timeD, cap);
+	emitVtx(rootR, twigDir3D, vec2(spawnAlongMain,         1.0), twigW, gridD, timeD, cap);
+	emitVtx(tip3D, twigDir3D, vec2(spawnAlongMain + bLen, -1.0), twigW, gridD, timeD, cap);
 	EndPrimitive();
 	gOutSpawnAlong = 0.0;
 }
@@ -723,15 +716,15 @@ void main() {
 
 	float cap   = dataIn[0].vsCableData.x;
 	vec2  timeD = dataIn[0].vsCableData.yz;
-	vec4  gridD = dataIn[0].vsGridData;
+	vec3  gridD = dataIn[0].vsGridData;
 
-	// Ghost edges (gridData.w = -1.0) emit the same two tent slopes as live
+	// Ghost edges (gridData.z = -1.0) emit the same two tent slopes as live
 	// (no twigs), using the SAME wiggly path so the live→ghost transition has
 	// no visual snap. Ghost FS path is fast (no lighting/bubble math), and the
 	// GS still skips the 3 twig invocations. Coverage updates use the live
 	// atomicAnd path with the wiggly samples → consistent with what the player
 	// visually sees.
-	bool isGhostEdge = gridD.w < -0.5;
+	bool isGhostEdge = gridD.z < -0.5;
 	if (isGhostEdge && gl_InvocationID > 1) return;
 
 	float widthVal = MIN_TRUNK_WIDTH +
@@ -797,8 +790,8 @@ void main() {
 
 	if (gl_InvocationID == 0) {
 		// Coverage SSBO update — once per cable per frame, not per fragment.
-		// Live edges (gridData.w >= -0.5) atomicOr bits for segments currently
-		// in LOS; ghost edges (gridData.w < -0.5) atomicAnd to clear bits the
+		// Live edges (gridData.z >= -0.5) atomicOr bits for segments currently
+		// in LOS; ghost edges (gridData.z < -0.5) atomicAnd to clear bits the
 		// player has re-scouted. Sampling along the actual wiggly path keeps
 		// reveal accurate even with arc bias on slopes.
 		//
@@ -814,7 +807,7 @@ void main() {
 		// second per-frame update would risk double-clearing ghost bits.
 #if !defined(SHADOW_PASS) && !defined(DEFERRED_PASS)
 		int slot = dataIn[0].vsSlot;
-		bool isGhost = gridD.w < -0.5;
+		bool isGhost = gridD.z < -0.5;
 		// Hard gate on the user-facing ghosts toggle — skip ALL coverage
 		// bookkeeping (the n-tap LOS scan, atomic ops, even the SSBO read)
 		// when ghosts are off. Restores live-only perf parity with pre-slice-1.

LuaRules/Gadgets/Shaders/gfx_overdrive_cables.vert.glsl

@@ -10,7 +10,7 @@
 
 layout (location = 0) in vec2 vertPos;     // (x, z) world coords
 layout (location = 1) in vec3 vertData;    // (capacity, appearTime, witherTime)
-layout (location = 2) in vec4 vertGrid;    // (gridEfficiency, flow, bubblePhase, isOwnAlly)
+layout (location = 2) in vec3 vertGrid;    // (gridEfficiency, flow, isOwnAlly / ghost flag)
 layout (location = 3) in float vertSlot;   // coverage SSBO slot (-1 = disabled)
 
 out gl_PerVertex {
@@ -20,7 +20,7 @@ out gl_PerVertex {
 out DataVS {
 	vec2 vsWorldXZ;
 	vec3 vsCableData;
-	vec4 vsGridData;
+	vec3 vsGridData;
 	flat int vsSlot;
 };