src/engine/volfx.js

/* ============================================================================

   VOLUMETRIC FX — raymarched proxy volumes for detonations, dust and plumes

   ----------------------------------------------------------------------------

   Every "volumetric" effect in this renderer before today was a camera-facing

   quad with a soft texture on it. terrain.js:1280 says so in as many words:

   "not a raymarch". This file is the raymarch.



   WHAT IT IS

     A small ring of ANALYTIC VOLUMES — centre, anisotropic half-extents, age,

     density, emission — each drawn as a unit-cube proxy in ONE instanced draw.

     The fragment shader intersects the box in world space, marches the ray

     front-to-back through an ellipsoidal shell modulated by a 3D FBM texture,

     accumulates Beer-Lambert transmittance with a single-scatter term (an

     analytic sun chord weighted by two real density probes — no second

     march), and terminates the march on the scene depth buffer so smoke is cut

     by terrain, hulls and buildings instead of floating through them.



     Total per frame: one bufferSubData, one instanced draw, one fullscreen

     composite. No per-frame allocation, no per-particle GPU state.



   WHAT IT IS NOT — READ THIS BEFORE JUSTIFYING IT ON PERFORMANCE

     It is NOT a fill-rate win over the billboard system, and the measured

     baseline says so plainly. The billboard path is already TWO instanced

     draws for the entire battlefield (billboard.js:135), it already rasterises

     into the half-res scene target on MEDIUM, and the whole billboard system

     costs 0.6-1.2 ms of a 23-25 ms frame. Deleting it outright buys under one

     frame per second. A march step is several times the cost of FSBB's single

     texture fetch plus multiply, so the same explosion costs roughly an order

     of magnitude MORE ALU here than it did as quads.



     What this actually buys:

       - COST BECOMES BOUNDED. steps x pixels, both clamped, instead of scaling

         with the number of simultaneous events. Ten detonations cost the same

         as three, only coarser.

       - Blend BANDWIDTH drops (~39 additive layers on a covered pixel become

         one composited layer), which is the half that matters on a tiler.

       - The SHAPE becomes the effect: a mushroom column really is a column,

         lit from above, self-shadowed, and cut correctly by the ridge in front

         of it. That is a LOOK argument, and it is the honest one.



     So this ships behind a quality gate with the sprite path intact as the

     fallback, and it is OFF on LOW. Do not present it as a speed-up.



   INTEGRATION CONTRACT

     volFxBurst(x, y, worldY, kind, radius, opts)   <- sim, gameplay thread

     volFxActive()                                   <- sim, to gate sprite smoke

     volFxDraw(dtDraw, Sun)                          <- render3d, once per frame

     volFxGLReset()                                  <- glrecover, after a restore

     volFxTelemetry()                                <- probes



     The sim call sites live in src/game/sim.js and are owned elsewhere; this

     file exposes the API and never reaches into the sim. Until those sites are

     wired the ring stays empty and the pass costs one early-out per frame.



   SCOPE COUPLING — everything below is read, never written:

     mesh.js   mkProg, GL_PROG_ERRORS, glEpoch, aoReady, aoW/aoH, aoFB2,

               aoColB, aoDepth, matV, matVP, orthoSpan, gfxTune

     hud.js    fogPointVisible          terrain.js  WATER_Y

     meta.js   GFX (volSteps optional; a preset-derived default is used when

               the key is absent, so this file works before meta.js is updated)

   ============================================================================ */

/* Kinds. Keep these numeric and stable: they are packed into an instance

   attribute and compared as floats in the shader. */
const VOL_BLAST = 0;      // detonation fireball: hot core, fast expansion
const VOL_SMOKE = 1;      // lingering smoke ball
const VOL_DUST  = 2;      // ground-rooted, vertically billowing collapse/shear dust
const VOL_PLUME = 3;      // mushroom column / singularity plume
const VOL_IMPACT= 4;      // compact depth-clipped projectile/beam contact burst
const VOL_TRAIL_ENERGY=5; // experimental swept plasma volume; probe-only until approved
const VOL_TRAIL_SHELL =6; // experimental combustion/soot volume; probe-only until approved
const VOL_TRAIL_CURVE_ENERGY=7; // one proxy sampling a fixed-step history texture
const VOL_TRAIL_CURVE_SHELL =8; // one advected combustion/soot history volume

/* Ring capacity. The arrays are always this size (48 * 16 floats = 3 KB of

   instance data worst case); the LIVE cap is a per-preset runtime limit so

   MEDIUM cannot queue a HIGH-preset workload. */
const VOL_CAP = 48;

/* Struct-of-arrays, allocated once, exactly the discipline sim.js uses for its

   particle ring. Dense prefix: [0, volN) is live, no holes, no GC.

   AXIS NOTE: the sim's (x,y) is the GROUND PLANE and terrainH(x,y) is world Y.

   These arrays store world XYZ with Y genuinely up, so the shader's .y means

   what it says. Callers pass (x, y, worldY) and this file does the swap. */
const volPX   = new Float32Array(VOL_CAP);   // world X
const volPY   = new Float32Array(VOL_CAP);   // world Y (UP)
const volPZ   = new Float32Array(VOL_CAP);   // world Z (the sim's y)
const volR0   = new Float32Array(VOL_CAP);   // spawn radius, world units
const volLife = new Float32Array(VOL_CAP);   // seconds
const volT    = new Float32Array(VOL_CAP);   // elapsed seconds
const volDens = new Float32Array(VOL_CAP);
const volEmis = new Float32Array(VOL_CAP);
const volRise = new Float32Array(VOL_CAP);   // world units/s along +Y
const volDX   = new Float32Array(VOL_CAP);
const volDZ   = new Float32Array(VOL_CAP);
const volSeed = new Float32Array(VOL_CAP);
/* Internal High/Cinematic material profiles.  This travels beside the seed in

   an existing instance lane, so a profile does not become another draw or

   another macro-FX layer. */
const volStyle= new Uint8Array(VOL_CAP);
const volAngle= new Float32Array(VOL_CAP);   // world XZ direction for impacts
/* Probe-only swept-trail axis and half length.  Keeping the full 3D tangent is
   essential: an artillery arc cannot be represented by the yaw-only impact
   orientation without turning each steep segment into a separate upright
   capsule at the RTS camera angle. */
const volTX   = new Float32Array(VOL_CAP);
const volTY   = new Float32Array(VOL_CAP);
const volTZ   = new Float32Array(VOL_CAP);
const volTHalf= new Float32Array(VOL_CAP);
const volAX   = new Float32Array(VOL_CAP);   // aspect
const volAY   = new Float32Array(VOL_CAP);
const volAZ   = new Float32Array(VOL_CAP);
const volKind = new Uint8Array(VOL_CAP);
const volTR   = new Uint8Array(VOL_CAP);
const volTG   = new Uint8Array(VOL_CAP);
const volTB   = new Uint8Array(VOL_CAP);
let   volN    = 0;

/* Draw-side scratch. Preallocated: this is per-frame code. */
const VOL_INST_FLOATS = 20;                                  // 80 B per instance
const volInstData = new Float32Array(VOL_CAP*VOL_INST_FLOATS);
const volOrder    = new Int32Array(VOL_CAP);
/* One bit per live proxy, rebuilt after a successful composite. Render-side

   fallback suppression queries this exact set instead of the old global

   `drawn>0`, which could hide a blast merely because an unrelated dust volume

   happened to render in the same frame. */
const volPresented = new Uint8Array(VOL_CAP);
const VOL_ZERO4   = new Float32Array([0,0,0,0]);
const volKey      = new Float32Array(VOL_CAP);
const volArea     = new Float32Array(VOL_CAP);

/* GL handles. Every one of these is invalidated by a context loss, which is

   what volEpoch is for. */
let volProg=null, volProgUp=null, volVAO=null, volEmptyVAO=null, volCubeVBO=null, volInstVBO=null;
let volNoiseTex=null, volDriverTex=null, volTrailHistoryTex=null, volFB=null, volTex=null;
let volW=0, volH=0, volFailN=0;
let volU={}, volUup={};
/* WHICH GL CONTEXT THESE HANDLES BELONG TO, and whether the build already

   failed on it. Both halves are load-bearing, and gpufx.js:44-48 records why:

   a lost context leaves volProg TRUTHY (so a `if(volProg) return` guard refuses

   to rebuild and the pass drives dead VAOs forever), and a failed build with no

   latch recompiles on EVERY burst on a device that cannot compile it. */
let volEpoch=-1, volInitFailed=false;
let volTime=0;

/* The authored 4x4 density/emission sheet is deliberately a MATERIAL DRIVER,

   not a substitute billboard.  It is sampled through object-space triplanar

   projections inside VOL_FS, where it modulates the existing 3D density and

   combustion field.  A one-pixel neutral texture is installed synchronously;

   decode/upload failure simply leaves driverReady false and the procedural

   raymarch keeps rendering. */
const VOL_DRIVER_UNIT=14;
const VOL_DRIVER_ASSET='assets/textures/vfx/mf-raymarch-density-emission-driver-v1.png';
let volDriverReady=false, volDriverState='uninitialised', volDriverError='';
let volDriverSerial=0;

/* Fixed-step projectile histories. A row is one projectile and a
   texel is one simulation-owned sample: world XYZ plus authored radius. The
   renderer never appends, ages, or reorders this data. RGBA32F is sample-only
   (never a render target), so WebGL2 provides it without a float colour-buffer
   extension. Twelve points keep the fragment loop bounded while remaining
   smooth at the intended tactical/command camera spans. */
const VOL_TRAIL_HISTORY_ROWS=8,VOL_TRAIL_HISTORY_POINTS=12;
const volTrailHistoryData=new Float32Array(VOL_TRAIL_HISTORY_ROWS*VOL_TRAIL_HISTORY_POINTS*4);
const volTrailHistoryUpload=new Float32Array(VOL_TRAIL_HISTORY_ROWS*VOL_TRAIL_HISTORY_POINTS*4);
const volTrailHistoryStamp=new Float32Array(VOL_TRAIL_HISTORY_ROWS*VOL_TRAIL_HISTORY_POINTS);
const volTrailHistoryCount=new Uint8Array(VOL_TRAIL_HISTORY_ROWS);
const volTrailHistoryKind=new Uint8Array(VOL_TRAIL_HISTORY_ROWS);
const volTrailHistoryUsed=new Uint8Array(VOL_TRAIL_HISTORY_ROWS);
const volTrailHistoryTint=new Uint8Array(VOL_TRAIL_HISTORY_ROWS*3);
const volTrailHistorySeed=new Float32Array(VOL_TRAIL_HISTORY_ROWS);
let volTrailHistoryRows=0,volTrailHistoryDirty=true,volTrailHistoryEpoch=-1;
const VOL_TRAIL_HISTORY_TELEM={rows:0,points:0,pushes:0,emits:0,uploads:0,
  pausedStable:0,ready:false,lastError:''};

/* Read-back for probes. Sampled AFTER volFxDraw in the same frame — the counts

   are not zeroed by the draw. (render3d.js:3204-3207 records the opposite

   mistake with bbIcon.n.) */
const VOLFX_TELEMETRY={live:0, drawn:0, steps:0, marchedPx:0, compositePx:0, budget:0,
                       progOK:false, glErr:0, w:0, h:0, culled:0,
                       presentedBlast:0,presentedDust:0,presentedImpact:0,
                       presentedTrailEnergy:0,presentedTrailShell:0,trailDriverReady:false,trailHistoryReady:false,
                       fallbackQueries:0,fallbackHits:0,lastError:'',
                       driverReady:false,driverState:'uninitialised',driverSamples:0,
                       driverAsset:VOL_DRIVER_ASSET,driverError:''};
function volFxTelemetry(){ return VOLFX_TELEMETRY; }
function volFxDriverTelemetry(){
  return {ready:!!volDriverReady,state:volDriverState,error:volDriverError,
    asset:VOL_DRIVER_ASSET,unit:VOL_DRIVER_UNIT,dimensions:[1024,1024],
    grid:[4,4],gutter:4};
}
function volFxPresentedAt(kind,x,y){
  kind=kind|0;x=Number(x);y=Number(y);
  VOLFX_TELEMETRY.fallbackQueries++;
  if(!Number.isFinite(x)||!Number.isFinite(y)) return false;
  for(let i=0;i<volN;i++){
    if(!volPresented[i]||volKind[i]!==kind) continue;
    const reach=Math.max(3,volR0[i]*.72),dx=volPX[i]-x,dy=volPZ[i]-y;
    if(dx*dx+dy*dy<=reach*reach){VOLFX_TELEMETRY.fallbackHits++;return true;}
  }
  return false;
}

/* ---------------------------------------------------------------------------

   QUALITY GATE

   The brief's warning is real: `perfScale > 0.48` is the most common effect

   gate in this codebase and it sits ABOVE the target device (perfScale 0.4125

   on medium), which is exactly the bug sim.js:4849-4854 documents. So

   perfScale appears here ONLY as a multiplier inside the step budget, NEVER as

   an on/off. The on/off gates are deterministic:

     volSteps() > 0   preset / Advanced setting

     aoReady && aoW   no offscreen path -> no sampleable depth -> no pass

     volProg          latched compile failure

   --------------------------------------------------------------------------- */
function volStepCeiling(){
  /* GFX.volSteps when meta.js carries it; otherwise derive from the preset so

     this module is useful before that edit lands. */
  if(typeof GFX!=='undefined'&&GFX&&typeof GFX.volSteps==='number') return GFX.volSteps|0;
  let q='high';
  if(typeof qualityKey==='function'){ try{ q=qualityKey(); }catch(e){} }
  return q==='low'?0 : q==='medium'?16 : q==='cinematic'?32 : 24;
}
/* Simulation intent is deliberately separate from render readiness. An event

   can occur while the AO/depth target is being resized or before the first

   offscreen frame has completed. Queue the density field for every tier that

   requests one; volFxDraw decides whether it can present this frame, while the

   already-armed flipbook remains the atomic failure fallback. */
function volFxEnabled(){ return volStepCeiling()>0; }
function volLiveCap(){ return volStepCeiling()<=16?24:VOL_CAP; }
function volIsTrailKind(k){
  return k===VOL_TRAIL_ENERGY||k===VOL_TRAIL_SHELL||
    k===VOL_TRAIL_CURVE_ENERGY||k===VOL_TRAIL_CURVE_SHELL;
}
function volFxActive(){
  if(!volFxEnabled()) return false;
  if(typeof gl==='undefined'||!gl) return false;
  if(typeof aoReady==='undefined'||!aoReady) return false;
  if(typeof aoW==='undefined'||!(aoW>0)||!(aoH>0)) return false;
  volFxCtxCheck();
  if(volInitFailed) return false;
  if(!volProg) volFxInit();
  return !!volProg;
}

/* ---------------------------------------------------------------------------

   HOP 1 — sim -> ring.  No allocation, no GL.

   --------------------------------------------------------------------------- */
function volFxBurst(x, y, worldY, kind, radius, opts){
  if(!(radius>0)) return -1;
  const o=opts||{};
  const k=kind|0;
  const style=Math.max(0,Math.min(volIsTrailKind(k)?15:3,o.style|0));
  const cap=volLiveCap();

  /* COALESCING. This is what makes the bounded-cost argument true: a cluster

     shell that fires 8 bomblets (sim.js:4959-4966) must produce ONE volume,

     not eight. Merge a same-kind neighbour that is still young. */
  const mergeR=radius*0.6;
  for(let i=0;i<volN;i++){
    /* A profile changes the material inside an otherwise identical volume.

       Do not merge a falling airframe's soot crown into a conventional blast:

       keeping their one-core recipes separate is cheaper and more legible than

       allowing the oldest profile to accidentally repaint the newer event. */
    if(volKind[i]!==k||volStyle[i]!==style) continue;
    const age=volLife[i]>0?volT[i]/volLife[i]:1;
    if(age>=0.25) continue;
    const dx=volPX[i]-x, dy=volPY[i]-worldY, dz=volPZ[i]-y;
    if(dx*dx+dy*dy+dz*dz > mergeR*mergeR) continue;
    volR0[i]=Math.max(volR0[i], radius);
    volDens[i]=Math.min(2.6, volDens[i]+0.18);
    if(o.emis>volEmis[i]) volEmis[i]=o.emis;
    const want=(o.life>0?o.life:volLife[i]);
    volLife[i]=Math.max(volLife[i], volT[i]+want);
    return i;
  }

  let s;
  if(volN<cap){ s=volN++; }
  else{
    /* Evict the OLDEST by age, never the newest. A fresh detonation must always

       be visible; a three-second-old smoke ball losing its last half second is

       something no player will ever see. */
    s=0; let worst=-1;
    for(let i=0;i<volN;i++){
      const age=volLife[i]>0?volT[i]/volLife[i]:1;
      if(age>worst){ worst=age; s=i; }
    }
  }

  /* A NEW or EVICTED slot must never inherit the previous occupant's

     presentation bit. render3d suppresses an event's armed flipbook when the

     matching proxy reports "presented", so a stale bit makes a brand-new

     detonation hide its own fallback for a composite that belonged to a

     different explosion — the frame then shows neither the volume nor the

     card, which is the exact non-atomic failure this bit exists to prevent. */
  volPresented[s]=0;
  const tint=o.tint;
  volPX[s]=x; volPY[s]=worldY; volPZ[s]=y;
  volR0[s]=radius;
  volLife[s]=o.life>0?o.life:(k===VOL_IMPACT?.46:k===VOL_BLAST?2.6:k===VOL_PLUME?7.0:3.4);
  volT[s]=0;
  volKind[s]=k;
  volDens[s]=o.dens>0?o.dens:(k===VOL_DUST?0.85:1.0);
  volEmis[s]=o.emis>0?o.emis:0;
  volRise[s]=(o.rise!=null)?o.rise:(k===VOL_PLUME?26:k===VOL_BLAST?9:k===VOL_IMPACT?2:3);
  volDX[s]=o.drift?o.drift[0]:0;
  volDZ[s]=o.drift?o.drift[1]:0;
  volSeed[s]=Number.isFinite(o.seed)?Math.max(0,Math.min(63.999,o.seed)):Math.random()*64;
  volStyle[s]=style;
  if(o.direction&&Number.isFinite(o.direction[0])&&Number.isFinite(o.direction[1]))
    volAngle[s]=Math.atan2(o.direction[1],o.direction[0]);
  else volAngle[s]=volSeed[s]*1.61803398875;
  if(o.trailAxis&&Number.isFinite(o.trailAxis[0])&&Number.isFinite(o.trailAxis[1])&&
      Number.isFinite(o.trailAxis[2])&&o.trailHalf>0){
    volTX[s]=o.trailAxis[0];volTY[s]=o.trailAxis[1];volTZ[s]=o.trailAxis[2];volTHalf[s]=o.trailHalf;
  }else{
    volTX[s]=0;volTY[s]=0;volTZ[s]=0;volTHalf[s]=0;
  }
  if(o.aspect){ volAX[s]=o.aspect[0]; volAY[s]=o.aspect[1]; volAZ[s]=o.aspect[2]; }
  else if(k===VOL_DUST){ volAX[s]=1.35; volAY[s]=0.85; volAZ[s]=1.35; }
  else if(k===VOL_PLUME){ volAX[s]=1.20; volAY[s]=3.60; volAZ[s]=1.20; }
  else if(k===VOL_IMPACT){ volAX[s]=1.45; volAY[s]=1.65; volAZ[s]=1.45; }
  else { volAX[s]=1.30; volAY[s]=3.20; volAZ[s]=1.30; }
  if(tint){ volTR[s]=tint[0]|0; volTG[s]=tint[1]|0; volTB[s]=tint[2]|0; }
  else if(k===VOL_DUST){ volTR[s]=196; volTG[s]=178; volTB[s]=150; }
  else if(k===VOL_BLAST){ volTR[s]=118; volTG[s]=112; volTB[s]=108; }
  else { volTR[s]=134; volTG[s]=130; volTB[s]=128; }
  return s;
}

/* Age the ring. Swap-down removal keeps the prefix dense with no holes. */
function volFxTick(dt){
  if(!(dt>0)) dt=0;
  volTime+=dt;
  for(let i=0;i<volN;){
    volT[i]+=dt;
    if(volLife[i]<=0||volT[i]>=volLife[i]){
      const j=--volN;
      if(j!==i){
        volPX[i]=volPX[j]; volPY[i]=volPY[j]; volPZ[i]=volPZ[j];
        volR0[i]=volR0[j]; volLife[i]=volLife[j]; volT[i]=volT[j];
        volDens[i]=volDens[j]; volEmis[i]=volEmis[j]; volRise[i]=volRise[j];
        volDX[i]=volDX[j]; volDZ[i]=volDZ[j]; volSeed[i]=volSeed[j]; volStyle[i]=volStyle[j];
        volAngle[i]=volAngle[j];
        volTX[i]=volTX[j];volTY[i]=volTY[j];volTZ[i]=volTZ[j];volTHalf[i]=volTHalf[j];
        volAX[i]=volAX[j]; volAY[i]=volAY[j]; volAZ[i]=volAZ[j];
        volKind[i]=volKind[j]; volTR[i]=volTR[j]; volTG[i]=volTG[j]; volTB[i]=volTB[j];
        /* The presentation bit is indexed by SLOT, so swap-down removal has to

           carry it with the event it describes; otherwise the surviving volume

           inherits a dead neighbour's bit and suppresses the wrong fallback. */
        volPresented[i]=volPresented[j];
      }
      volPresented[j]=0; volStyle[j]=0;
      continue;
    }
    volPY[i]+=volRise[i]*dt;
    volPX[i]+=volDX[i]*dt;
    volPZ[i]+=volDZ[i]*dt;
    volRise[i]*=Math.pow(0.62, dt);          // buoyancy bleeds off
    i++;
  }
}
function volFxClear(){ volN=0;volPresented.fill(0);volStyle.fill(0); }

/* ---------------------------------------------------------------------------
   FIXED-STEP TRAIL HISTORY — simulation writes, renderer reads.
   --------------------------------------------------------------------------- */
function volFxTrailHistoryReset(){
  volTrailHistoryCount.fill(0);volTrailHistoryKind.fill(0);volTrailHistoryUsed.fill(0);
  volTrailHistoryData.fill(0);volTrailHistoryUpload.fill(0);
  volTrailHistoryRows=0;volTrailHistoryDirty=true;
  VOL_TRAIL_HISTORY_TELEM.rows=0;VOL_TRAIL_HISTORY_TELEM.points=0;
  VOL_TRAIL_HISTORY_TELEM.pushes=0;VOL_TRAIL_HISTORY_TELEM.emits=0;
  VOL_TRAIL_HISTORY_TELEM.pausedStable=0;VOL_TRAIL_HISTORY_TELEM.lastError='';
}
function volFxTrailHistoryBegin(kind,opts){
  let row=-1;
  for(let i=0;i<VOL_TRAIL_HISTORY_ROWS;i++)if(!volTrailHistoryUsed[i]){row=i;break;}
  if(row<0)return -1;
  const o=opts||{};volTrailHistoryUsed[row]=1;volTrailHistoryRows=Math.max(volTrailHistoryRows,row+1);
  const k=(kind|0)===VOL_TRAIL_SHELL||(kind|0)===VOL_TRAIL_CURVE_SHELL
    ?VOL_TRAIL_CURVE_SHELL:VOL_TRAIL_CURVE_ENERGY;
  volTrailHistoryKind[row]=k;volTrailHistoryCount[row]=0;
  const rb=row*VOL_TRAIL_HISTORY_POINTS,db=rb*4;
  volTrailHistoryData.fill(0,db,db+VOL_TRAIL_HISTORY_POINTS*4);
  volTrailHistoryUpload.fill(0,db,db+VOL_TRAIL_HISTORY_POINTS*4);
  volTrailHistoryStamp.fill(0,rb,rb+VOL_TRAIL_HISTORY_POINTS);
  const tint=o.tint||(k===VOL_TRAIL_CURVE_ENERGY?[206,132,255]:[255,118,38]);
  const to=row*3;volTrailHistoryTint[to]=tint[0]|0;volTrailHistoryTint[to+1]=tint[1]|0;volTrailHistoryTint[to+2]=tint[2]|0;
  volTrailHistorySeed[row]=Number.isFinite(o.seed)?Math.max(0,Math.min(63.999,o.seed)):7.25;
  let used=0;for(let i=0;i<VOL_TRAIL_HISTORY_ROWS;i++)used+=volTrailHistoryUsed[i]?1:0;
  VOL_TRAIL_HISTORY_TELEM.rows=used;volTrailHistoryDirty=true;return row;
}
function volFxTrailHistoryPush(row,x,z,worldY,stamp){
  row|=0;if(row<0||row>=volTrailHistoryRows||!volTrailHistoryUsed[row])return false;
  if(!Number.isFinite(x)||!Number.isFinite(z)||!Number.isFinite(worldY)||!Number.isFinite(stamp))return false;
  let n=volTrailHistoryCount[row]|0;
  const rb=row*VOL_TRAIL_HISTORY_POINTS,db=rb*4;
  if(n>=VOL_TRAIL_HISTORY_POINTS){
    volTrailHistoryData.copyWithin(db,db+4,db+VOL_TRAIL_HISTORY_POINTS*4);
    volTrailHistoryStamp.copyWithin(rb,rb+1,rb+VOL_TRAIL_HISTORY_POINTS);
    n=VOL_TRAIL_HISTORY_POINTS-1;
  }
  const o=db+n*4;volTrailHistoryData[o]=x;volTrailHistoryData[o+1]=worldY;volTrailHistoryData[o+2]=z;volTrailHistoryData[o+3]=0;
  volTrailHistoryStamp[rb+n]=stamp;volTrailHistoryCount[row]=n+1;
  volTrailHistoryDirty=true;VOL_TRAIL_HISTORY_TELEM.pushes++;
  let total=0;for(let r=0;r<volTrailHistoryRows;r++)total+=volTrailHistoryCount[r];
  VOL_TRAIL_HISTORY_TELEM.points=total;return true;
}
function volFxTrailHistoryEmit(row,opts){
  row|=0;if(row<0||row>=volTrailHistoryRows||!volTrailHistoryUsed[row])return -1;
  const n=volTrailHistoryCount[row]|0;if(n<2)return -1;
  const o=opts||{},k=volTrailHistoryKind[row],rb=row*VOL_TRAIL_HISTORY_POINTS,db=rb*4;
  const widthScale=Math.max(.12,Math.min(2,Number(o.widthScale)||1)),noHead=!!o.noHead;
  const newest=volTrailHistoryStamp[rb+n-1],oldest=volTrailHistoryStamp[rb],duration=Math.max(1e-4,newest-oldest);
  let minX=1e9,minY=1e9,minZ=1e9,maxX=-1e9,maxY=-1e9,maxZ=-1e9,maxR=1;
  /* Keep a small screen-space floor without baking one camera distance into
     the authored history. `orthoSpan / VH` is the engine's established
     world-units-per-CSS-pixel conversion (billboard.js/input.js). The floor is
     evaluated only when the fixed-step history is emitted; rendering paused
     frames still cannot mutate the field or grow the pool. */
  const worldPx=(typeof orthoSpan==='number'&&typeof VH==='number'&&VH>0)
    ?Math.max(.24,orthoSpan/VH):.58;
  for(let i=0;i<n;i++){
    const so=db+i*4,age=Math.max(0,Math.min(1,(newest-volTrailHistoryStamp[rb+i])/duration));
    let x=volTrailHistoryData[so],y=volTrailHistoryData[so+1],z=volTrailHistoryData[so+2];
    /* The uploaded centreline is the projectile's real deterministic history.
       Turbulence belongs in the density field, not in a CPU-side displacement
       that makes the old wake detach from the ballistic arc. */
    const width=(k===VOL_TRAIL_CURVE_ENERGY
      ?Math.max(worldPx*6.40,3.2+2.4*(1-age))
      :Math.max(worldPx*8.80,5.4+5.0*age))*widthScale;
    volTrailHistoryUpload[so]=x;volTrailHistoryUpload[so+1]=y;volTrailHistoryUpload[so+2]=z;volTrailHistoryUpload[so+3]=width;
    minX=Math.min(minX,x-width);maxX=Math.max(maxX,x+width);minY=Math.min(minY,y-width);maxY=Math.max(maxY,y+width);minZ=Math.min(minZ,z-width);maxZ=Math.max(maxZ,z+width);maxR=Math.max(maxR,width);
  }
  /* The projectile/head is an elongated part of the same volume. Give its
     terminal ellipsoid enough proxy room so it cannot be clipped at the last
     history sample. */
  const ho=db+(n-1)*4,hx=volTrailHistoryUpload[ho],hy=volTrailHistoryUpload[ho+1],hz=volTrailHistoryUpload[ho+2];
  const headPad=volTrailHistoryUpload[ho+3]*(noHead?.42:(k===VOL_TRAIL_CURVE_ENERGY?1.85:2.20));
  minX=Math.min(minX,hx-headPad);maxX=Math.max(maxX,hx+headPad);
  minY=Math.min(minY,hy-headPad);maxY=Math.max(maxY,hy+headPad);
  minZ=Math.min(minZ,hz-headPad);maxZ=Math.max(maxZ,hz+headPad);
  const last=db+(n-1)*4;
  for(let i=n;i<VOL_TRAIL_HISTORY_POINTS;i++)volTrailHistoryUpload.set(volTrailHistoryUpload.subarray(last,last+4),db+i*4);
  volTrailHistoryDirty=true;
  const cx=(minX+maxX)*.5,cy=(minY+maxY)*.5,cz=(minZ+maxZ)*.5;
  const tintOff=row*3,tint=[volTrailHistoryTint[tintOff],volTrailHistoryTint[tintOff+1],volTrailHistoryTint[tintOff+2]];
  const life=o.life>0?o.life:.28,dens=o.dens||(k===VOL_TRAIL_CURVE_ENERGY?1.72:2.10),
    emis=o.emis||(k===VOL_TRAIL_CURVE_ENERGY?2.05:1.08),aspect=[Math.max(1,(maxX-minX)*.5),Math.max(1,(maxY-minY)*.5),Math.max(1,(maxZ-minZ)*.5)];
  /* Refresh one proxy per row from fixed-step simulation. Searching the tiny
     bounded volume ring is safer than caching a slot index because volFxTick
     compacts the ring when unrelated smoke expires. No render call can grow
     this pool or advance its lifetime. */
  let slot=-1;
  for(let i=0;i<volN;i++)if(volKind[i]===k&&volStyle[i]===row&&volTX[i]===row){slot=i;break;}
  if(slot<0)slot=volFxBurst(cx,cz,cy,k,1,{life,rise:0,dens,emis,aspect,
    trailAxis:[row,n,noHead?1:0],trailHalf:1,tint,style:row,seed:volTrailHistorySeed[row]});
  else{
    volPresented[slot]=0;volPX[slot]=cx;volPY[slot]=cy;volPZ[slot]=cz;volR0[slot]=1;
    volLife[slot]=life;volT[slot]=0;volDens[slot]=dens;volEmis[slot]=emis;volRise[slot]=0;
    volDX[slot]=volDZ[slot]=0;volTX[slot]=row;volTY[slot]=n;volTZ[slot]=noHead?1:0;volTHalf[slot]=1;
    volAX[slot]=aspect[0];volAY[slot]=aspect[1];volAZ[slot]=aspect[2];
    volTR[slot]=tint[0]|0;volTG[slot]=tint[1]|0;volTB[slot]=tint[2]|0;
  }
  if(slot>=0){volT[slot]=Math.max(0,Math.min(.9,Number(o.age)||0))*volLife[slot];VOL_TRAIL_HISTORY_TELEM.emits++;}
  return slot;
}
function volFxTrailHistoryRelease(row,fade){
  row|=0;if(row<0||row>=VOL_TRAIL_HISTORY_ROWS||!volTrailHistoryUsed[row])return false;
  const k=volTrailHistoryKind[row];
  for(let i=0;i<volN;i++)if(volKind[i]===k&&volStyle[i]===row&&volTX[i]===row){
    const left=Math.max(.04,Number(fade)||.12);volLife[i]=Math.min(volLife[i],volT[i]+left);
  }
  volTrailHistoryUsed[row]=0;volTrailHistoryCount[row]=0;volTrailHistoryDirty=true;
  let used=0,points=0;for(let i=0;i<VOL_TRAIL_HISTORY_ROWS;i++)if(volTrailHistoryUsed[i]){used++;points+=volTrailHistoryCount[i];}
  VOL_TRAIL_HISTORY_TELEM.rows=used;VOL_TRAIL_HISTORY_TELEM.points=points;return true;
}
function volFxTrailHistoryTelemetry(){
  return {rows:VOL_TRAIL_HISTORY_TELEM.rows,points:VOL_TRAIL_HISTORY_TELEM.points,pushes:VOL_TRAIL_HISTORY_TELEM.pushes,
    emits:VOL_TRAIL_HISTORY_TELEM.emits,uploads:VOL_TRAIL_HISTORY_TELEM.uploads,pausedStable:VOL_TRAIL_HISTORY_TELEM.pausedStable,
    ready:VOL_TRAIL_HISTORY_TELEM.ready,lastError:VOL_TRAIL_HISTORY_TELEM.lastError};
}
function volFxTrailHistoryTexture(){
  if(typeof gl==='undefined'||!gl)return null;
  const ep=typeof glEpoch==='number'?glEpoch:0;
  if(volTrailHistoryEpoch!==ep){volTrailHistoryEpoch=ep;volTrailHistoryTex=null;volTrailHistoryDirty=true;}
  const wasActive=gl.getParameter(gl.ACTIVE_TEXTURE);gl.activeTexture(gl.TEXTURE10);const wasTex=gl.getParameter(gl.TEXTURE_BINDING_2D);
  try{
    if(!volTrailHistoryTex){
      volTrailHistoryTex=gl.createTexture();if(!volTrailHistoryTex)throw new Error('trail history texture allocation failed');
      gl.bindTexture(gl.TEXTURE_2D,volTrailHistoryTex);
      gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.NEAREST);gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.NEAREST);
      gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.CLAMP_TO_EDGE);
      gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA32F,VOL_TRAIL_HISTORY_POINTS,VOL_TRAIL_HISTORY_ROWS,0,gl.RGBA,gl.FLOAT,volTrailHistoryUpload);
      volTrailHistoryDirty=false;VOL_TRAIL_HISTORY_TELEM.uploads++;
    }else if(volTrailHistoryDirty){
      gl.bindTexture(gl.TEXTURE_2D,volTrailHistoryTex);
      gl.texSubImage2D(gl.TEXTURE_2D,0,0,0,VOL_TRAIL_HISTORY_POINTS,VOL_TRAIL_HISTORY_ROWS,gl.RGBA,gl.FLOAT,volTrailHistoryUpload);
      volTrailHistoryDirty=false;VOL_TRAIL_HISTORY_TELEM.uploads++;
    }
    VOL_TRAIL_HISTORY_TELEM.ready=true;VOL_TRAIL_HISTORY_TELEM.lastError='';return volTrailHistoryTex;
  }catch(e){VOL_TRAIL_HISTORY_TELEM.ready=false;VOL_TRAIL_HISTORY_TELEM.lastError=String(e&&e.message||e);return null;}
  finally{gl.bindTexture(gl.TEXTURE_2D,wasTex);gl.activeTexture(wasActive);}
}

/* Growth curve per kind. Age is the ONLY animation input the shader gets, so

   the CPU and the GPU must agree on the world extents or the march will start

   outside the density it is looking for. */
function volGrow(kind, age, style){
  if(volIsTrailKind(kind))return 1.0;
  if(kind===VOL_DUST)  return 0.45+1.25*age;
  if(kind===VOL_PLUME) return 0.50+0.95*age;
  if(kind===VOL_BLAST) return 0.50+0.90*age;
  /* A phase contact is a fast, bounded displacement of the field rather than
     a combustion balloon.  The generic impact curve grows 4.1x before it
     dies, which made the late void frames become a large purple sphere.  Hold
     the white-violet contact near its authored scale, then collapse it. */
  if(kind===VOL_IMPACT&&(style|0)===2){
    const ignite=age<=0?0:age>=.32?1:(age/.32)*(age/.32)*(3-2*(age/.32));
    const cq=Math.max(0,Math.min(1,(age-.42)/.50));
    const collapse=cq*cq*(3-2*cq);
    return (.56+.34*ignite)*(1-.32*collapse);
  }
  if(kind===VOL_IMPACT)return 0.35+1.10*Math.min(1,age/.72);
  return 0.55+0.90*age;
}
/* Keep distant High/Cinematic volumes volumetric instead of letting a valid

   proxy collapse below a handful of half-resolution pixels. This is a small

   screen-space floor, capped so it cannot turn a tactical blast into a giant

   strategic cloud. The same value is used for culling and instance packing. */
function volRenderGrow(kind,age,r0,pxPerWorld,ax,ay,az,style){
  let g=volGrow(kind,age,style)*r0;
  const projected=g*Math.max(ax,ay,az)*Math.max(.001,pxPerWorld);
  if(projected<5.5) g*=Math.min(1.65,5.5/Math.max(.25,projected));
  return g;
}

/* ---------------------------------------------------------------------------

   NOISE — 32^3 RGBA8, 131 KB, generated once.

   R/G/B are tileable value noise at lattice 4 / 8 / 16 (three FBM octaves out

   of ONE texture fetch); A is an inverted Worley F1 at lattice 6, which is the

   cauliflower billow on the silhouette. Small enough to sit in texture cache

   for the whole pass, which is why this beats analytic hash noise on a mobile

   ALU budget.

   --------------------------------------------------------------------------- */
function volNoiseBuild(){
  const N=32, out=new Uint8Array(N*N*N*4);
  const hash=(a)=>{ a=(a^61)^(a>>>16); a=(a+(a<<3))|0; a^=a>>>4; a=Math.imul(a,0x27d4eb2d); a^=a>>>15; return (a>>>0)/4294967296; };
  const lat=(L,x,y,z)=>hash(((x%L+L)%L) + ((y%L+L)%L)*L + ((z%L+L)%L)*L*L + L*7919);
  const sm=(t)=>t*t*(3-2*t);
  const value=(L,fx,fy,fz)=>{
    const gx=fx*L, gy=fy*L, gz=fz*L;
    const x0=Math.floor(gx), y0=Math.floor(gy), z0=Math.floor(gz);
    const tx=sm(gx-x0), ty=sm(gy-y0), tz=sm(gz-z0);
    const c=(dx,dy,dz)=>lat(L,x0+dx,y0+dy,z0+dz);
    const l=(a,b,t)=>a+(b-a)*t;
    const x00=l(c(0,0,0),c(1,0,0),tx), x10=l(c(0,1,0),c(1,1,0),tx);
    const x01=l(c(0,0,1),c(1,0,1),tx), x11=l(c(0,1,1),c(1,1,1),tx);
    return l(l(x00,x10,ty), l(x01,x11,ty), tz);
  };
  /* Worley feature points, one per cell of a 6^3 lattice, wrapped. */
  const WL=6, fp=new Float32Array(WL*WL*WL*3);
  for(let z=0;z<WL;z++) for(let y=0;y<WL;y++) for(let x=0;x<WL;x++){
    const i=(z*WL*WL+y*WL+x)*3;
    fp[i  ]=(x+hash(i+11))/WL;
    fp[i+1]=(y+hash(i+29))/WL;
    fp[i+2]=(z+hash(i+53))/WL;
  }
  const wrapD=(a,b)=>{ let d=a-b; if(d>0.5) d-=1; else if(d<-0.5) d+=1; return d; };
  for(let z=0;z<N;z++) for(let y=0;y<N;y++) for(let x=0;x<N;x++){
    const fx=x/N, fy=y/N, fz=z/N;
    const o=((z*N+y)*N+x)*4;
    out[o  ]=Math.max(0,Math.min(255, (value( 4,fx,fy,fz)*255)|0));
    out[o+1]=Math.max(0,Math.min(255, (value( 8,fx,fy,fz)*255)|0));
    out[o+2]=Math.max(0,Math.min(255, (value(16,fx,fy,fz)*255)|0));
    let best=4;
    const cx=Math.floor(fx*WL), cy=Math.floor(fy*WL), cz=Math.floor(fz*WL);
    for(let dz=-1;dz<=1;dz++) for(let dy=-1;dy<=1;dy++) for(let dx=-1;dx<=1;dx++){
      const ix=((cx+dx)%WL+WL)%WL, iy=((cy+dy)%WL+WL)%WL, iz=((cz+dz)%WL+WL)%WL;
      const i=(iz*WL*WL+iy*WL+ix)*3;
      const ax=wrapD(fx,fp[i]), ay=wrapD(fy,fp[i+1]), az=wrapD(fz,fp[i+2]);
      const d=ax*ax+ay*ay+az*az;
      if(d<best) best=d;
    }
    const f1=Math.min(1, Math.sqrt(best)*WL*1.15);
    out[o+3]=Math.max(0,Math.min(255,(f1*255)|0));
  }
  return out;
}

/* ---------------------------------------------------------------------------

   SHADERS

   --------------------------------------------------------------------------- */
const VOL_VS=`#version 300 es

layout(location=0) in vec3 aPos;    // unit cube, -1..1, divisor 0

layout(location=1) in vec4 aCtr;    // cx, cy(worldY), cz, ageNorm

layout(location=2) in vec4 aExt;    // half-extents xyz, kind

layout(location=3) in vec4 aPar;    // dens, emis, seed, LIFE SECONDS

layout(location=4) in vec4 aTint;   // albedo rgb, softness
layout(location=5) in vec4 aTrail;  // world tangent xyz, capsule half-length
uniform mat4 uVP;
flat out vec4 vCtr;

flat out vec4 vExt;

flat out vec4 vPar;

flat out vec4 vTint;
flat out vec4 vTrail;
out vec3 vWorld;

void main(){

  vCtr=aCtr; vExt=aExt; vPar=aPar; vTint=aTint; vTrail=aTrail;
  vWorld=aCtr.xyz + aPos*aExt.xyz;

  gl_Position=uVP*vec4(vWorld,1.0);

}`;

/* The march. Everything about this shader is shaped by three facts:

     1. The camera is ORTHOGRAPHIC (mesh.js:3277), so the ray direction is a

        per-frame CONSTANT: no matrix inverse, no perspective divide, and the

        Henyey-Greenstein phase can be evaluated once on the CPU.

     2. Depth is LINEAR in window z under that projection, and the conversion

        constant is far-near = 15000 — the same number FSAO already hardcodes

        as uWorldPerZ (mesh.js:2609). COUPLING: if m4ortho's near/far in

        camUpdateMatrices ever change, BOTH call sites must change.

     3. The target is RGBA8 (it matches aoColB), so the hot core clips to white

        before it reads as hot. That is why this pass is inserted where bloom

        can still see it. */
const VOL_FS=`#version 300 es

precision highp float;

precision highp sampler3D;

precision highp sampler2D;



flat in vec4 vCtr;

flat in vec4 vExt;

flat in vec4 vPar;

flat in vec4 vTint;
flat in vec4 vTrail;
in vec3 vWorld;



uniform sampler3D uNoise;

uniform sampler2D uDep;

/* Packed authored field: R density, G emission, B soot, A support.  It is

   never drawn as a screen-facing image; driverUV receives object-space planes

   below and the result only modulates the procedural 3D material. */

uniform sampler2D uDriver;
uniform float uDriverReady;
uniform sampler2D uTrailDriver;
uniform float uTrailDriverReady;
uniform sampler2D uTrailHistory;
uniform float uTrailHistoryReady;
uniform vec3  uRayDir;

uniform vec3  uSunDir;

uniform vec3  uSunCol;

uniform vec3  uAmbSky;

uniform vec3  uAmbGnd;

uniform vec3  uWind;

uniform vec2  uInvVolSize;
uniform float uWorldPerPx;
uniform float uDepthScale;   // far - near = 15000, see note above

uniform float uSigma;

uniform float uPhase;

uniform float uTime;

uniform float uWaterOn;

uniform float uWaterY;

uniform int   uSteps;

out vec4 o;



/* THE JITTER IS OBJECT-SPACE, NOT A SCREEN GRID.

   This used to be a 4x4 ordered Bayer matrix indexed by gl_FragCoord. At 24-32

   steps over a dense field that printed a visible crosshatch directly onto the

   fireball — the hex/diamond weave in the 02f-02h bombard captures is exactly

   it — and because it was pinned to the screen it slid across the volume as

   the camera moved. Offsetting the first sample by a tileable-noise lookup at

   the ray's OBJECT-SPACE entry point gives a blue-noise-like offset that is

   attached to the volume: it cannot align to the pixel grid and cannot crawl,

   and it is stable frame to frame with no temporal term (mesh.js:2262-2265

   records what per-frame rotation without TAA did last time). */



/* Three FBM octaves out of ONE fetch: R/G/B are tileable value noise at

   lattice 4/8/16, A is an inverted Worley F1 (the cauliflower billow). */

float fbm3(vec4 n){ return n.r*0.52+n.g*0.30+n.b*0.18; }

/* Uniform Catmull-Rom centreline reconstruction. The simulation uploads only
   fixed-step points; the renderer evaluates a C1 curve between them. This
   removes the exposed straight-segment joints without creating more trail
   instances or allowing render cadence to author new history. */
vec3 trailCatmull(vec3 p0,vec3 p1,vec3 p2,vec3 p3,float t){
  float t2=t*t,t3=t2*t;
  return 0.5*((2.0*p1)+(-p0+p2)*t+(2.0*p0-5.0*p1+4.0*p2-p3)*t2+(-p0+3.0*p1-3.0*p2+p3)*t3);
}
vec3 trailCatmullTangent(vec3 p0,vec3 p1,vec3 p2,vec3 p3,float t){
  float t2=t*t;
  return 0.5*((-p0+p2)+2.0*(2.0*p0-5.0*p1+4.0*p2-p3)*t+3.0*(-p0+3.0*p1-3.0*p2+p3)*t2);
}


/* A cell-local UV with a literal four-texel guard band.  The baked atlas is

   4x4 cells at 256px each, with 248px authored content inset by 4px.  Keeping

   every filtered coordinate inside that region prevents frame bleeding without

   needing a second draw or an animated billboard. */

vec2 driverUV(vec2 plane,float frame){

  vec2 inner=vec2(4.5/256.0);

  vec2 scale=vec2(247.0/256.0);

  vec2 local=inner+clamp(plane*0.5+0.5,0.0,1.0)*scale;

  vec2 cell=vec2(mod(frame,4.0),floor(frame*0.25));

  return (cell+local)*0.25;

}



/* Project the same authored density/emission stage along all three local axes.

   The weights are derived from the world/object-space surface coordinate, so

   the art influences a real volume and cannot remain flat to the camera. */

vec4 driverTriplanar(vec3 p,float frame){

  vec3 w=pow(abs(p)+vec3(0.035),vec3(1.35));

  w/=max(1e-4,w.x+w.y+w.z);

  vec4 yz=texture(uDriver,driverUV(vec2(p.z,p.y),frame));

  vec4 xz=texture(uDriver,driverUV(vec2(p.x,p.z),frame));

  vec4 xy=texture(uDriver,driverUV(vec2(p.x,p.y),frame));

  return yz*w.x+xz*w.y+xy*w.z;

}



/* Soft shoulder, with the amount of compression left to the CALLER.

   A single fixed shoulder was wrong in both directions: hard clipping

   flat-topped the fireball into white polygons, but compressing everything

   equally drained the punch out of heavy ordnance. Heavy events pass a small k

   so they can genuinely blow out; light contacts pass a large k and stay

   controlled. */

vec3 shoulder(vec3 c,float k){ return c/(1.0+c*k); }



void main(){

  float kind=vExt.w;

  float age=vCtr.w;

  /* Lane z holds a stable 0..64 noise seed plus a tiny internal material

     profile in 64-wide bands.  Reusing the seed lane keeps the existing

     16-float instance ABI intact: this is still one instanced volume draw. */

  float profile=floor(vPar.z*(1.0/64.0));

  float seed=vPar.z-profile*64.0;



  /* --- slab intersection, world units, sign-agnostic ---------------------

     vWorld is the BACK face of the proxy (we cull FRONT), so both roots are

     negative offsets along uRayDir. */

  vec3 iD=1.0/uRayDir;

  vec3 t0=(vCtr.xyz-vExt.xyz-vWorld)*iD;

  vec3 t1=(vCtr.xyz+vExt.xyz-vWorld)*iD;

  vec3 tn=min(t0,t1), tf=max(t0,t1);

  float tEnter=max(max(tn.x,tn.y),tn.z);

  float tExit =min(min(tf.x,tf.y),tf.z);



  /* --- scene depth termination ------------------------------------------ */

  vec2 uv=gl_FragCoord.xy*uInvVolSize;

  vec2 h=uInvVolSize*0.25;

  float dz=min(min(texture(uDep,uv+vec2( h.x, h.y)).r, texture(uDep,uv+vec2(-h.x, h.y)).r),

               min(texture(uDep,uv+vec2( h.x,-h.y)).r, texture(uDep,uv+vec2(-h.x,-h.y)).r));

  float tHere =gl_FragCoord.z*uDepthScale;

  float tScene=dz*uDepthScale;

  tExit=min(tExit, tScene-tHere);

  if(uWaterOn>0.5&&uRayDir.y<0.0) tExit=min(tExit,(uWaterY-vWorld.y)/uRayDir.y);

  tEnter=max(tEnter,-tHere);

  float span=tExit-tEnter;

  if(span<=0.0) discard;



  float steps=float(uSteps);

  float ds=span/steps;

  /* Object-space blue-noise jitter (see the note above the helpers). */

  vec3 pEnter=vWorld+uRayDir*tEnter;

  vec3 jq=(pEnter-vCtr.xyz)/max(vec3(1e-3),vExt.xyz);

  float jit=texture(uNoise,jq*2.7+vec3(seed*0.37)).g;

  float t=tEnter+ds*clamp(jit,0.02,0.98);



  vec3  acc=vec3(0.0);

  float T=1.0;



  float progress=clamp(age,0.0,1.0);



  /* ---- CHRONOLOGY: ONE core, four explicit stages, ABSOLUTE seconds --------

     vPar.w carries the event's life in seconds (it used to carry a world

     radius that this shader never read). Absolute time is required because a

     100 ms flash is 6% of a 1.6 s bombardment but 22% of a 0.46 s contact hit

     — a single normalised threshold cannot express "sub-100 ms" for both.

       flash       t < ~0.10 s   compact, white-hot, high emission

       combustion  -> ~40% life  orange/yellow rolling fire

       soot        -> ~78% life  lobes separate, fire retreats into cavities

       smoke       -> end        translucent grey that thins rather than

                                 collapsing into an opaque black disc          */

  float life=max(0.08,vPar.w);

  float tSec=progress*life;



  /* ONE CLOCK PER BOUNDARY. sBurn used to RISE on absolute seconds and FALL on

     normalised progress. Below a life of about 0.40 s the fall opened before the

     rise had finished, so combustion never reached full weight — that is exactly

     why small contacts read as having no energy. Both knees are now in seconds,

     with the fall floored so a short event still gets a real burn plateau. */

  float sFlash=1.0-smoothstep(0.040,0.105,tSec);

  float tFall=max(0.34*life,0.18);

  float sBurn =smoothstep(0.03,0.12,tSec)*(1.0-smoothstep(tFall,tFall*1.70,tSec));

  /* sootHold is MONOTONE. The tint, extinction and cavity consumers must not let

     soot brighten back up over the tail — the bump form did, by 23%, directly

     contradicting the "then HOLD" intent written above them. The decaying bump

     survives only as the emission gate, where a fading ember residual is right. */

  float sootHold=smoothstep(0.30,0.60,progress);

  float sSoot =sootHold*(1.0-smoothstep(0.72,0.95,progress));

  float sSmoke=smoothstep(0.62,0.97,progress);



  for(int i=0;i<64;i++){

    if(i>=uSteps) break;

    vec3 p=vWorld+uRayDir*t;

    t+=ds;



    vec3 localP=(p-vCtr.xyz)/vExt.xyz;

    float isImpact=1.0-step(0.45,abs(kind-4.0));
    float isVoidImpact=isImpact*(1.0-step(0.45,abs(profile-2.0)));
    float isDust  =1.0-step(0.45,abs(kind-2.0));

    float isBlast =1.0-step(0.45,abs(kind));
    float isSmoke =1.0-step(0.45,abs(kind-1.0));
    float isCurveEnergy=1.0-step(0.45,abs(kind-7.0));
    float isCurveShell =1.0-step(0.45,abs(kind-8.0));
    float isCurve=max(isCurveEnergy,isCurveShell);
    float isTrailEnergy=max(1.0-step(0.45,abs(kind-5.0)),isCurveEnergy);
    float isTrailShell =max(1.0-step(0.45,abs(kind-6.0)),isCurveShell);
    float isTrail=max(isTrailEnergy,isTrailShell);
    /* Falling airframes are still VOL_BLAST and still one macro core. The

       profile merely folds their generic satellite lobes into a hot inner

       pocket below one tall, cooling soot crown. */

    float isAirCrash=(1.0-step(0.45,abs(profile-1.0)))*isBlast;
    /* The proxy is intentionally a box; the density is the art. A blast is

       spherical during ignition and only stretches into a buoyant crown as

       it cools. An impact rotates into projectile direction and combines a

       compact contact bulb with one short excavating wake. Previously both

       paths marched the same tall mushroom, which made direct hits look like

       tiny copies of strategic explosions. */

    float crown=mix(1.0,0.65+0.45*smoothstep(-0.4,0.6,localP.y),

      smoothstep(0.12,0.70,progress)*(1.0-isImpact));

    /* Collapse dust begins as a grounded shear front, then rolls upward into

       cauliflower lobes. This keeps a real vertical silhouette from the RTS

       camera instead of reproducing the old flat horizontal card. */

    crown=mix(crown,0.72+0.42*smoothstep(-0.72,0.72,localP.y),isDust);

    vec3 q=localP;

    q.xz/=crown;

    float blastY=mix(2.35,1.0,smoothstep(0.18,0.62,progress));

    /* The generic flash starts vertically compressed for an outward blast.

       A falling hull is the opposite silhouette: give its coherent crown

       real vertical depth from the first visible frame, not a ground pancake. */

    blastY=mix(blastY,mix(0.78,0.94,smoothstep(0.04,0.70,progress)),isAirCrash);

    q.y*=mix(1.0,blastY,isBlast);

    float ca=cos(vTint.w),sa=sin(vTint.w);
    vec2 iq=mat2(ca,sa,-sa,ca)*q.xz;
    /* EXPERIMENTAL SWEPT-VOLUME TRAILS. Curve kinds use ONE proxy and measure
       every ray sample against a bounded fixed-step history texture. Legacy
       kinds retain the ten-capsule laboratory path for direct A/B comparison. */
    if(isTrail>0.5){
      float headlessWake=isCurveShell*step(.5,vTrail.z);
      if(isCurve>0.5&&uTrailHistoryReady<0.5)discard;
      float trailU=0.5,localU=0.5,tubeR=1.0,segmentWeight=1.0;
      float headSeg=0.0,headR=1.0;
      vec3 radialVec=vec3(0.0),trailTangent=vec3(1.0,0.0,0.0);
      vec3 trailSide=vec3(0.0,0.0,1.0),trailUp=vec3(0.0,1.0,0.0);
      vec3 headPoint=vCtr.xyz,headAxis=vec3(1.0,0.0,0.0);
      if(isCurve>0.5&&uTrailHistoryReady>0.5){
        int histRow=int(clamp(floor(vTrail.x+0.5),0.0,7.0));
        int histCount=int(clamp(floor(vTrail.y+0.5),2.0,12.0));
        float bestD2=1e30,bestU=0.0,bestR=1.0;vec3 bestPoint=vec3(0.0),bestProbe=p,bestTan=vec3(1.0,0.0,0.0);
        for(int hi=0;hi<11;hi++){
          if(hi>=histCount-1)break;
          int im1=max(0,hi-1),ip2=min(histCount-1,hi+2);
          vec4 h0=texelFetch(uTrailHistory,ivec2(im1,histRow),0);
          vec4 h1=texelFetch(uTrailHistory,ivec2(hi,histRow),0);
          vec4 h2=texelFetch(uTrailHistory,ivec2(hi+1,histRow),0);
          vec4 h3=texelFetch(uTrailHistory,ivec2(ip2,histRow),0);
          vec3 chord=h2.xyz-h1.xyz;
          float h=clamp(dot(p-h1.xyz,chord)/max(1e-5,dot(chord,chord)),0.0,1.0);
          /* Two bounded projection refinements are enough for this smooth,
             sparsely sampled ballistic curve and much cheaper than spawning a
             row of overlapping capsule proxies. */
          for(int refine=0;refine<2;refine++){
            vec3 cp=trailCatmull(h0.xyz,h1.xyz,h2.xyz,h3.xyz,h);
            vec3 ct=trailCatmullTangent(h0.xyz,h1.xyz,h2.xyz,h3.xyz,h);
            h=clamp(h+dot(p-cp,ct)/max(1e-5,dot(ct,ct)),0.0,1.0);
          }
          vec3 nearP=trailCatmull(h0.xyz,h1.xyz,h2.xyz,h3.xyz,h);
          vec3 nearT=trailCatmullTangent(h0.xyz,h1.xyz,h2.xyz,h3.xyz,h);
          /* A 32-step volume march can step completely over a 3–6 world-unit
             trail inside a tall artillery proxy. Measure the complete current
             ray interval against the curve, rather than a single point on that
             interval. This is analytic coverage, not extra particle samples,
             and removes the bright/dark comb tied to march planes. */
          vec3 rayProbe=p+uRayDir*clamp(dot(nearP-p,uRayDir),0.0,ds);
          h=clamp(h+dot(rayProbe-nearP,nearT)/max(1e-5,dot(nearT,nearT)),0.0,1.0);
          nearP=trailCatmull(h0.xyz,h1.xyz,h2.xyz,h3.xyz,h);
          nearT=trailCatmullTangent(h0.xyz,h1.xyz,h2.xyz,h3.xyz,h);
          rayProbe=p+uRayDir*clamp(dot(nearP-p,uRayDir),0.0,ds);
          float d2=dot(rayProbe-nearP,rayProbe-nearP),hs=h*h*(3.0-2.0*h);
          if(d2<bestD2){bestD2=d2;bestPoint=nearP;bestProbe=rayProbe;bestTan=nearT;bestR=mix(h1.w,h2.w,hs);bestU=(float(hi)+h)/float(histCount-1);}
        }
        trailU=clamp(bestU,0.006,0.994);
        tubeR=max(max(0.25,bestR),uWorldPerPx*mix(6.40,8.80,isTrailShell)*mix(1.0,.58,headlessWake));
        trailTangent=normalize(bestTan+vec3(1e-5));
        vec3 axisRef=abs(trailTangent.y)<0.88?vec3(0.0,1.0,0.0):vec3(1.0,0.0,0.0);
        trailSide=normalize(cross(trailTangent,axisRef));trailUp=normalize(cross(trailSide,trailTangent));
        /* The centreline stays ballistic. Only old soot density drifts, with a
           low-frequency bounded curl that cannot expose history spacing. */
        float oldWake=1.0-trailU;
        float curlPhase=trailU*13.0+seed*1.73-uTime*.31;
        vec3 curlOffset=(trailSide*sin(curlPhase)+trailUp*cos(curlPhase*.71))
          *(tubeR*.16*oldWake*oldWake*isTrailShell);
        radialVec=bestProbe-(bestPoint+curlOffset);
        vec4 hpHead=texelFetch(uTrailHistory,ivec2(histCount-1,histRow),0);
        vec4 hpPrev=texelFetch(uTrailHistory,ivec2(histCount-2,histRow),0);
        /* vTrail.z marks headless persistent wakes such as aircraft smoke.
           Their newest history sample is not a projectile and must not grow a
           bright shell/fuse cap that obscures the aircraft. */
        headSeg=1.0-step(.5,vTrail.z);headPoint=hpHead.xyz;headAxis=normalize(hpHead.xyz-hpPrev.xyz+vec3(1e-5));
        headR=max(hpHead.w*mix(.94,1.12,isTrailShell),uWorldPerPx*mix(5.8,8.2,isTrailShell));
      }else{
        float segCount=10.0;
        vec3 trailAxis=normalize(vTrail.xyz);float halfLen=max(0.001,vTrail.w);
        vec3 trailWorld=p-vCtr.xyz;float along=dot(trailWorld,trailAxis);
        localU=clamp(along/(halfLen*2.0)+0.5,0.0,1.0);
        trailU=clamp((profile+localU)/segCount,0.006,0.994);
        vec3 nearest=trailAxis*clamp(along,-halfLen,halfLen);
        vec3 spare=max(vec3(0.001),vExt.xyz-abs(trailAxis)*halfLen);
        tubeR=min(spare.x,min(spare.y,spare.z));
        vec3 axisRef=abs(trailAxis.y)<0.88?vec3(0.0,1.0,0.0):vec3(1.0,0.0,0.0);
        trailSide=normalize(cross(trailAxis,axisRef));trailUp=normalize(cross(trailSide,trailAxis));
        float wakeAgeLegacy=1.0-trailU,curlPhase=trailU*31.0+seed*1.73-uTime*0.58*wakeAgeLegacy;
        vec3 curlOffset=(trailSide*sin(curlPhase)+trailUp*cos(curlPhase*0.83))
          *(tubeR*0.25*wakeAgeLegacy*wakeAgeLegacy*isTrailShell);
        radialVec=trailWorld-nearest-curlOffset;
        headSeg=step(8.5,profile);vec3 headCentre=trailAxis*(halfLen*0.806);
        headPoint=vCtr.xyz+headCentre;headAxis=trailAxis;
        headR=tubeR*mix(.82,.96,isTrailShell);
        float fadeIn=mix(smoothstep(0.0,0.22,localU),1.0,1.0-step(0.5,profile));
        float fadeOut=mix(1.0-smoothstep(0.78,1.0,localU),1.0,step(8.5,profile));
        segmentWeight=fadeIn*fadeOut;
      }
      float radial=length(radialVec);
      float row=mix(0.25,0.75,isTrailShell);
      float crossY=clamp(dot(radialVec,trailUp)/max(0.001,tubeR),-1.0,1.0);
      float crossZ=clamp(dot(radialVec,trailSide)/max(0.001,tubeR),-1.0,1.0);
      vec4 drvY=texture(uTrailDriver,vec2(trailU,row+crossY*0.235));
      vec4 drvZ=texture(uTrailDriver,vec2(trailU,row+crossZ*0.235));
      vec4 drv=max(drvY,drvZ);
      float drvReady=step(0.5,uTrailDriverReady);
      float driverHeat=max(drv.r,max(drv.g,drv.b))*drvReady;
      vec4 tn=texture(uNoise,vec3(trailU*4.1,crossZ,crossY)+vec3(seed*0.19,uTime*0.11,-uTime*0.07));
      /* Energy narrows into a real tail; combustion already receives a wider
         world-space radius from the CPU.  Noise perturbs the density boundary,
         not just its colour, so the silhouette has volume breakup instead of
         reading as a uniformly glowing hose. */
      float wakeAge=1.0-trailU;
      float radiusScale=mix(mix(0.36,0.72,smoothstep(0.02,0.84,trailU)),
        mix(0.56,0.20,smoothstep(0.04,0.94,trailU)),isTrailShell);
      /* Combustion wakes need a connected low-frequency silhouette. The old
         71-cycle modulation made the density read as a spray of orange dots at
         tactical zoom. Two broad, incommensurate waves now shape large rolling
         smoke cells while the 3D field supplies the small turbulent breakup. */
      float lobeWave=0.92+0.10*sin(trailU*11.0+sin(trailU*5.0)*.72)
        +0.07*sin(trailU*17.0+seed*1.7);
      float shellBillow=mix(1.0,lobeWave*(0.97+0.11*smoothstep(0.20,0.84,tn.a)),isTrailShell);
      float energyBreath=.91+.10*sin(trailU*8.0+seed*.37)+.09*(tn.a-.5);
      radiusScale*=mix(energyBreath,shellBillow,isTrailShell);
      float rr=radial/max(0.001,tubeR*radiusScale);
      float edgeNoise=(fbm3(tn)-0.5)*mix(0.54,0.62,isTrailShell)+(drv.a-0.5)*0.08*drvReady;
      float support=1.0-smoothstep(mix(.52,.48,isTrailShell)+edgeNoise,1.02+edgeNoise,rr);
      /* The energy sheath is allowed to curl around the stable filament. It is
         still evaluated inside this one density field; the offset creates ion
         haze and asymmetry without a second ribbon or sprite layer. */
      float ionPhase=trailU*9.0+seed*.63-uTime*.24;
      vec3 ionOffset=(trailSide*sin(ionPhase)+trailUp*cos(ionPhase*.77))
        *(tubeR*(.16+.18*wakeAge));
      float ionRR=length(radialVec-ionOffset)/max(.001,tubeR*radiusScale*1.22);
      float ionEdge=(fbm3(tn)-.5)*.48;
      float ionSupport=1.0-smoothstep(.48+ionEdge,1.08+ionEdge,ionRR);
      support=max(support,ionSupport*.82*(1.0-isTrailShell));
      /* Longitudinal breakup comes from the continuous noise domain, never
         history indices. It can pulse and tear the plasma without restoring
         the twelve-sample knot pattern. */
      vec4 longTex=texture(uNoise,vec3(trailU*9.7+seed*.13,.29+seed*.017,.71-uTime*.05));
      float longNoise=fbm3(longTex);
      float wave=.5+.5*sin(trailU*33.0-uTime*8.0+longNoise*4.2+seed*.31);
      float energyPulse=.18+.82*smoothstep(.36,.72,longNoise*.46+wave*.54);
      /* Five explicit packets travel inside the uninterrupted filament. Their
         axial phase is analytic (rather than a lucky noise maximum), so launch,
         mid-flight and command zoom all expose the same readable cadence. */
      float packetPhase=abs(fract(trailU*5.0-uTime*.58+seed*.071)-.5);
      float energyPacket=(1.0-smoothstep(.055,.145,packetPhase))
        *smoothstep(.10,.24,trailU)*(1.0-smoothstep(.91,.982,trailU));
      float packetEnvelope=(1.0-smoothstep(.03,.46,rr))*energyPacket;
      /* Tear the ion sheath longitudinally while retaining the much narrower
         analytic filament below. The breakup is sampled from continuous
         object-space noise, so its rhythm cannot reveal the 12 history knots. */
      support=mix(max(support*(.38+.62*energyPulse),
        ionSupport*(.22+.78*energyPulse)),support,isTrailShell);

      /* Kinetic smoke is two advected wisps plus a faint connector—not a
         filled cone. Both wisps remain within this one raymarched instance. */
      vec3 wispOffA=(trailSide*sin(trailU*15.0+seed)+trailUp*cos(trailU*9.0+seed*.7))
        *(tubeR*(.15+.23*wakeAge));
      vec3 wispOffB=(trailSide*cos(trailU*11.0+seed*.43)-trailUp*sin(trailU*13.0+seed))
        *(tubeR*(.21+.19*wakeAge));
      float wispRA=length(radialVec-wispOffA)/max(.001,tubeR*radiusScale*1.16);
      float wispRB=length(radialVec-wispOffB)/max(.001,tubeR*radiusScale*1.02);
      float wispA=1.0-smoothstep(.20+edgeNoise*.42,.84+edgeNoise*.34,wispRA);
      float wispB=1.0-smoothstep(.17-edgeNoise*.22,.78+edgeNoise*.28,wispRB);
      float wispGateA=smoothstep(.20,.62,longNoise*.74+tn.g*.26);
      float wispGateB=smoothstep(.24,.66,(1.0-longNoise)*.58+tn.b*.42);
      float wispGate=max(wispGateA,wispGateB*.78);
      float shellConnector=(1.0-smoothstep(.04,.34,rr))*.08;
      /* Three axial windows shape distinct soot lobes. They overlap just enough
         to read as advected smoke, while the independent pressure backbone
         below maintains physical continuity all the way to the shell. */
      float smokeLobeA=smoothstep(.035,.085,trailU)*(1.0-smoothstep(.16,.22,trailU));
      float smokeLobeB=smoothstep(.285,.34,trailU)*(1.0-smoothstep(.43,.49,trailU));
      float smokeLobeC=smoothstep(.535,.59,trailU)*(1.0-smoothstep(.68,.75,trailU));
      float smokeLobes=max(smokeLobeA,max(smokeLobeB,smokeLobeC));
      float lobeDensity=max(wispA,wispB*.82)*smokeLobes*(.44+.56*wispGate);
      float shellWisps=max(shellConnector*.62,lobeDensity);
      /* A pressure-diffused soot envelope joins the displaced wisps. It is
         deliberately soft and low-density, but broad enough to survive grey
         terrain and command zoom; the previous wisp-only field measured as
         present while visually collapsing to a one-pixel brown scratch. */
      float shellHaze=(1.0-smoothstep(.18,.94,rr))*(.22+.34*smoothstep(.24,.82,tn.a))
        *smoothstep(.025,.18,trailU)*(1.0-smoothstep(.88,.985,trailU))*mix(1.0,.22,headlessWake);
      support=mix(support,max(shellWisps,shellHaze),isTrailShell);
      /* Preserve a continuous plasma filament through every history segment.
         Noise is allowed to fray the sheath, never to punch gaps through the
         spine—the dotted tail in the first hardware capture was a density
         failure, not an intended pulse. */
      float filamentSupport=(1.0-smoothstep(.035,.32,rr))
        *mix(.88,1.0,smoothstep(.02,.24,trailU));
      support=max(support,filamentSupport*(1.0-isTrailShell));
      /* One field, two genuinely different terminal forms. Energy ends in a
         contained plasma ellipsoid and ion envelope. Kinetic ends in a compact
         metal projectile with a rear fuse—not a spherical orange fireball. */
      vec3 headProbe=p+uRayDir*clamp(dot(headPoint-p,uRayDir),0.0,ds);
      vec3 headDelta=headProbe-headPoint;
      float headAlong=dot(headDelta,headAxis);
      float headPerp=length(headDelta-headAxis*headAlong);
      float energyHeadMetric=length(vec2(headAlong/max(.001,headR*1.58),headPerp/max(.001,headR*.46)));
      float shellHeadMetric=length(vec2(headAlong/max(.001,headR*2.16),headPerp/max(.001,headR*.46)));
      float energyHead=headSeg*(1.0-smoothstep(.62,1.0,energyHeadMetric));
      float energyCore=headSeg*(1.0-smoothstep(.08,.62,energyHeadMetric));
      float shellBody=headSeg*(1.0-smoothstep(.72,1.0,shellHeadMetric));
      vec3 fusePoint=headPoint-headAxis*(headR*.74);
      vec3 fuseProbe=p+uRayDir*clamp(dot(fusePoint-p,uRayDir),0.0,ds);
      float fuseMetric=length(fuseProbe-fusePoint)/max(.001,headR*.27);
      float fuseSupport=headSeg*(1.0-smoothstep(.32,1.0,fuseMetric));
      float fuseCore=headSeg*(1.0-smoothstep(.04,.38,fuseMetric));
      float compression=smoothstep(.76,.91,trailU)*(1.0-smoothstep(.965,.995,trailU))
        *(1.0-smoothstep(.08,.34,rr))*(1.0-shellBody);
      float pressureWake=smoothstep(.045,.12,trailU)*(1.0-smoothstep(.968,.996,trailU))
        *(1.0-smoothstep(.018,.17,rr));
      float headSupport=mix(energyHead,max(shellBody,fuseSupport),isTrailShell);
      float headCore=mix(energyCore,fuseCore,isTrailShell);
      support=max(support,headSupport);
      /* Partition the 24% proxy overlap. Without this, premultiplied over
         integrates both capsules at every join and the continuous plasma
         spine becomes a row of bright beads. First/last retain their exposed
         cap; internal endpoints cross-fade into their neighbour. */
      segmentWeight=max(headSupport,segmentWeight);
      /* Energy texture supplies only subtle density breakup. Letting its
         bright knots own opacity produced the soft lavender beads/hose seen
         in the rejected capture. Shell smoke may use more of the authored
         alpha because density variation is physically desirable there. */
      float driverDensity=mix(0.88+drv.a*0.06,0.74+drv.a*0.18,isTrailShell);
      float authored=mix(0.80,driverDensity,drvReady);
      authored=max(authored,headSupport*(0.82+0.18*driverHeat));
      float turbulent=mix(0.78+0.30*fbm3(tn),
        0.48+0.38*fbm3(tn)+0.06*(1.0-tn.a),isTrailShell);
      float energyFade=smoothstep(.006,.18,trailU)*(.28+.72*smoothstep(.10,.72,trailU));
      /* Smoke starts as separated old wisps, is strongest through the middle
         of the path, then clears around the projectile so its gunmetal body and
         tiny hot base stay readable instead of living inside a dark cone. */
      float shellFade=smoothstep(.025,.25,trailU)
        *(1.0-.78*smoothstep(.82,.965,trailU));
      float tailFade=mix(energyFade,shellFade,isTrailShell);
      float longitudinal=mix(.30+.70*energyPulse,.58+.42*wispGate,isTrailShell);
      float trailDensity=support*authored*turbulent*vPar.x*segmentWeight*tailFade
        *longitudinal*mix(1.16,1.82,isTrailShell);
      /* A very narrow optical backbone makes sub-pixel kinetic smoke survive
         the half-resolution march. It carries no glow and remains weaker than
         either displaced wisp; its job is continuity, not a filled cone. */
      trailDensity+=shellConnector*vPar.x*shellFade*(.16+.20*wispGate)*isTrailShell;
      trailDensity+=shellBody*vPar.x*2.36*isTrailShell+fuseSupport*vPar.x*.46*isTrailShell;
      trailDensity+=lobeDensity*vPar.x*3.10*shellFade*isTrailShell;
      trailDensity+=pressureWake*vPar.x*.58*isTrailShell;
      /* The continuous energy filament has its own small extinction floor.
         Packets modulate brightness inside it instead of punching opacity holes
         that turn the trail back into isolated particle beads. */
      trailDensity+=filamentSupport*energyFade*segmentWeight*vPar.x
        *(1.18+.18*energyPulse+.34*energyPacket)*(1.0-isTrailShell);
      trailDensity+=packetEnvelope*energyFade*segmentWeight*vPar.x*.42*(1.0-isTrailShell);
      trailDensity+=energyHead*vPar.x*1.24*(1.0-isTrailShell);
      /* ds is in world units. Normalising it by diameter prevents a long ray
         chord from saturating the entire tube to alpha=1, which erased every
         authored and procedural detail in the first probe. */
      float opticalStep=ds/max(1.0,tubeR*2.0);
      float trailAlpha=1.0-exp(-uSigma*trailDensity*opticalStep*mix(5.55,6.20,isTrailShell)*mix(1.0,.72,headlessWake));
      /* The energy profile is a narrow white plasma filament inside a softer
         ionised sheath. Axial turbulence modulates emission rather than radius,
         retaining one continuous beam-like volume without reintroducing beads. */
      float core=max(1.0-smoothstep(0.025,0.22,rr),headCore);
      float spine=max(1.0-smoothstep(0.006,0.105,rr),headCore);
      float ionPulse=0.91+0.09*tn.b;
      float ionFray=smoothstep(0.28,0.92,tn.a)*(1.0-smoothstep(0.72,1.08,ionRR));
      float containmentRim=energyHead*smoothstep(.50,.78,energyHeadMetric)*(1.0-smoothstep(.78,1.02,energyHeadMetric));
      float frontCap=energyHead*smoothstep(.38,.78,headAlong/max(.001,headR*1.58))
        *(1.0-smoothstep(.12,.62,headPerp/max(.001,headR*.46)));
      vec3 energySheath=vTint.rgb*(0.26+0.23*tn.g+0.27*ionFray)*ionPulse*(.30+.70*energyPulse);
      vec3 energyRgb=mix(energySheath,vec3(1.72,1.86,2.18),core*(.18+.82*energyPulse));
      energyRgb=mix(energyRgb,vec3(2.54,2.72,3.08),spine*(.30+.70*energyPulse));
      energyRgb*=0.62+vPar.y*0.24+energyCore*.52;
      float packetGlow=(core*.42+spine*.80)
        *max(smoothstep(.48,.90,energyPulse)*.34,energyPacket);
      energyRgb+=spine*vec3(1.02,1.14,1.34)+packetGlow*vec3(1.72,1.88,2.12);
      energyRgb+=packetEnvelope*vec3(1.44,1.62,1.94);
      energyRgb+=containmentRim*vTint.rgb*.14+energyCore*vec3(2.12,2.22,2.48)+frontCap*vec3(2.9,3.02,3.18);
      vec3 radialN=normalize(radialVec+vec3(1e-4));
      float smokeLight=0.58+0.42*max(0.0,dot(radialN,normalize(uSunDir)));
      float smokeBody=smoothstep(0.10,0.78,wakeAge);
      float smokeEdge=smoothstep(0.34,0.94,rr);
      /* Use translucent, light-scattering grey-brown rather than nearly black
         extinction. Sparse lobes must remain separable over concrete without
         reading as an opaque painted cone or a ground shadow. */
      vec3 shellSmoke=mix(vec3(.075,.072,.068),vec3(.31,.30,.285),
        clamp(smokeEdge*.56+tn.g*.32,0.0,1.0))*mix(.82,1.06,smokeLight);
      shellSmoke=mix(shellSmoke,vec3(.062,.060,.057),smokeBody*.12);
      /* Headless aircraft damage wakes are soot, not pressure-lit ordnance
         plumes. This removes the pale circular fog disk under an airframe while
         retaining a broken, light-responsive volume behind it. */
      vec3 airSoot=mix(vec3(.022,.024,.027),vec3(.13,.14,.15),
        clamp(smokeEdge*.38+tn.g*.30,0.0,1.0))*mix(.72,.92,smokeLight);
      shellSmoke=mix(shellSmoke,airSoot,headlessWake);
      vec3 shellFire=mix(vec3(0.76,0.022,0.001),vec3(2.25,1.16,0.28),core);
      /* Heat belongs close to the travelling shell. The rejected material
         multiplied the driver over most of the history and turned smoke into
         one orange cloud. This transfers monotonically from compact flame to
         neutral soot over the newest ~22% of the wake. */
      /* The shell reference carries a visible combustion-to-soot hand-off,
         not one orange pixel followed by a black hose. Keep the newest third
         hot, then let authored heat and sparse pockets survive into the middle
         third before neutral smoke owns the old wake. */
      float heatZone=smoothstep(0.93,0.992,trailU)
        *(0.96+0.04*driverHeat)*(1.0-smoothstep(.20,.46,rr));
      float combustion=clamp(heatZone,0.0,1.0)*(1.0-headlessWake);
      vec3 shellWake=mix(shellSmoke,shellFire,combustion);
      float pressureHeat=pressureWake*smoothstep(.62,.91,trailU);
      shellWake=mix(shellWake,vec3(.32,.235,.17),pressureWake*.34);
      shellWake=mix(shellWake,vec3(.285,.275,.26),clamp(lobeDensity*.12,0.0,.16));
      shellWake=mix(shellWake,vec3(1.34,.42,.09),pressureHeat*.72);
      shellWake+=compression*vec3(.94,.75,.48);
      float shellRim=shellBody*smoothstep(.42,.84,shellHeadMetric);
      vec3 shellMetal=mix(vec3(.075,.09,.12),vec3(.82,.86,.90),
        .28+.72*max(0.0,dot(normalize(headDelta+vec3(1e-4)),normalize(uSunDir))));
      shellMetal+=shellRim*vec3(.28,.27,.24);
      vec3 shellRgb=mix(shellWake,shellMetal,shellBody);
      shellRgb+=fuseSupport*vec3(1.32,.24,.016)+fuseCore*vec3(2.8,1.72,.48);
      vec3 trailRgb=mix(energyRgb,shellRgb,isTrailShell);
      float ember=isTrailShell*support*smoothstep(0.976,0.998,tn.b)
        *smoothstep(0.89,0.97,trailU)*(1.0-headCore);
      trailRgb+=vec3(1.50,0.22,0.008)*ember*0.08;
      acc+=T*trailRgb*trailAlpha;T*=1.0-trailAlpha;
      if(T<0.015)break;
      continue;
    }
    /* IMPACT: a COMPACT contact bulb plus a short excavating wake.

       The head used to multiply iq.x by 0.84, and a factor BELOW 1 EXTENDS the

       isosurface along that axis. It sat inside a proxy box the weapon profile

       already makes 1.46 long and only 0.62 tall, so two elongations compounded

       on the same axis and the field integrated to a flat directional smear —

       from the RTS camera that is indistinguishable from a ground decal, which

       is exactly what it got mistaken for. The head is now COMPRESSED along the

       axis (>1) and extended in Y (<1) to fight the pancake proxy; the wake

       alone carries the direction. */

    float impactHead=length(vec3((iq.x-.06)*1.22,q.y*0.72,iq.y*1.08));

    float impactWake=length(vec3((iq.x+.30)*0.86,q.y*1.05,iq.y*1.30))

      +max(0.0,-iq.x-.10)*.34;



    /* ---- CAULIFLOWER LOBES WITH REAL ASYMMETRY -----------------------------

       Seven lobes at mixed radii on an IRREGULAR ring — each one displaced by

       its own hash instead of an even angular step, and each with its own

       size. min() unions them so the creases between neighbours survive; the

       old five evenly-spaced same-radius lobes averaged straight back into a

       sphere, which is the smooth blob in the 02f-02h captures. */

    float coreShape=length(q*vec3(1.08,0.92,1.08));

    float radialLobes=100.0;

    /* A conventional blast benefits from an outward cauliflower union. A

       falling airframe does not: even inward-biased satellites still form two

       detached bodies at the oblique RTS camera angle. Its profile below uses

       this one tapered core plus the same 3D turbulence instead. */

    if((isBlast>0.5||isDust>0.5)&&isAirCrash<0.5){

      float expand=smoothstep(0.04,0.62,progress);

      for(int l=0;l<7;l++){

        float fl=float(l);

        float hh=fract(sin(fl*12.9898+seed*7.233)*43758.5453);

        float a=fl*0.8975979+seed*2.39996+hh*0.90;

        vec3 lDir=vec3(cos(a)*0.88,(hh-0.32)*0.86,sin(a)*0.88);

        vec3 lCtr=lDir*mix(0.08,0.60,expand)*(0.62+0.74*hh);

        /* Keep the irregular lobe vocabulary, but join an air crash's outer

           satellites into one crown.  Suppressing only their heat would leave

           a red/orange necklace under the soot at a top-down RTS angle. */

        lCtr.xz*=mix(1.0,0.36,isAirCrash);

        /* A modest upward bias gives the crash a crown, but not a detached

           top balloon. The fire/soot material bridge below supplies the

           continuous vertical hand-off rather than a second lobe. */

        lCtr.y=mix(lCtr.y,0.02+0.20*hh,isAirCrash);

        float lRad=mix(0.30,0.56,expand)*(0.70+0.60*hh)*mix(1.0,1.16,isAirCrash);

        radialLobes=min(radialLobes,length(q-lCtr)/lRad);

      }

    }

    float blastShape=min(coreShape*1.12,radialLobes);

    /* Contact bursts get the SAME cauliflower vocabulary at contact scale.

       The lobe loop above is gated to blast/dust, so an impact previously had

       no internal structure whatsoever — a single smooth ellipsoid, which is

       the other half of why it read as a flat sprite. Three small lobes are

       enough to break the silhouette and give the march something to shade. */

    float impactShape=min(impactHead,impactWake);
    float voidField=0.0,voidCrescent=0.0,voidSpear=0.0,voidForks=0.0;
    if(isImpact>0.5){
      float ex2=smoothstep(0.02,0.55,progress);

      for(int l=0;l<3;l++){

        float fl=float(l);

        float hh=fract(sin(fl*31.7+seed*5.13)*43758.5453);

        float hg=fract(hh*7.31);

        vec3 lc=vec3((hh-0.55)*0.46,0.10+hg*0.34,(hg-0.5)*0.44)*mix(0.30,0.92,ex2);

        impactShape=min(impactShape,

          length(q-lc)/(mix(0.30,0.48,ex2)*(0.80+0.45*hh)));
      }
      /* VOID CONTACT — one genuine density field, not a card or extra layer.
         The short capsule is the incoming phase spear, the clipped shell is an
         asymmetric crescent, and both join a vertically thick contact bloom.
         Their separate clocks change the 3D silhouette while the event fades. */
      /* The centre is deliberately an OFFSET ellipsoid rather than a full
         ball.  It supplies thickness behind the crescent without filling the
         crescent's negative space from the RTS camera. */
      float bloomR=length(vec3((iq.x+.15)*1.30,q.y*.78,iq.y*1.46));
      float bloom=(1.0-smoothstep(.27,.66,bloomR))
        *(1.0-smoothstep(.56,.97,progress));
      /* One incoming spear plus two short forks live in this same density
         field. They are capsules, not emitted particles, so the silhouette is
         directional while the authoritative layer count remains one. */
      float axis=clamp(iq.x,-.96,.18);
      float spearDist=length(vec3(iq.x-axis,q.y*1.58,iq.y*2.72));
      float spearRadius=mix(.045,.145,smoothstep(-.96,.18,axis));
      float spear=(1.0-smoothstep(spearRadius,spearRadius+.065,spearDist))
        *(1.0-smoothstep(.34,.66,progress));
      float forkGate=smoothstep(-.50,-.18,iq.x)*(1.0-smoothstep(.08,.30,iq.x));
      float forkA=1.0-smoothstep(.045,.115,
        length(vec3(q.y*1.80,(iq.y-(iq.x+.30)*.48)*2.65,0.0)));
      float forkB=1.0-smoothstep(.045,.115,
        length(vec3(q.y*1.80,(iq.y+(iq.x+.30)*.48)*2.65,0.0)));
      float forks=max(forkA,forkB)*forkGate*(1.0-smoothstep(.28,.58,progress));
      /* A ground-plane torus section gives the crescent a real hollow centre
         from the oblique RTS camera.  The earlier spherical-shell subtraction
         integrated its front and back caps into two filled balloons. */
      vec2 arcP=vec2((iq.x-.02)*1.02,iq.y*1.12);
      float arcRad=length(arcP);
      float arcTube=sqrt(pow((arcRad-.53)/.145,2.0)+pow(q.y/.30,2.0));
      float crescent=(1.0-smoothstep(.68,1.12,arcTube))
        *smoothstep(-.28,.10,iq.x)*(1.0-smoothstep(.52,.88,progress));
      voidCrescent=crescent;voidSpear=spear;voidForks=forks;
      voidField=max(bloom*.44,max(max(spear,forks),crescent));
      impactShape=mix(impactShape,1.0-voidField,isVoidImpact);
    }

    float r=mix(blastShape,impactShape,isImpact);



    /* ---- two turbulence octaves displace the SURFACE ---------------------- */

    vec3 nq=mix(q,vec3(iq.x,q.y,iq.y),isImpact);

    /* AUTHORED MATERIAL DRIVER — blast and smoke only.  The 4x4 source stages

       follow ignition -> combustion -> soot, while a standalone smoke event

       begins in the soot half of the same chronology.  nq is reconstructed

       from this march sample, not a screen UV, then triplanar-projected through

       the proxy.  Impacts deliberately stay out of this path: VOL_IMPACT keeps

       its compact authored analytic morphology and exact existing budget. */

    float driverKind=max(isBlast,isSmoke);

    float driverProgress=mix(progress,0.54+progress*0.46,isSmoke);

    float driverFrame=floor(clamp(driverProgress,0.0,0.9999)*16.0);

    float driverWeight=driverKind*step(0.5,uDriverReady);

    vec4 driverField=vec4(0.5,0.0,0.5,1.0);

    if(driverWeight>0.5) driverField=driverTriplanar(nq,driverFrame);

    /* Leave a large procedural contribution even inside transparent portions

       of the authored source.  This is a density/emission *modulator*, never

       a rectangular cutout or a replacement sprite. */

    float driverDensity=mix(1.0,mix(0.72,1.22,driverField.r)

      *mix(0.84,1.0,driverField.a),driverWeight);

    float driverSoot=mix(1.0,mix(0.86,1.16,driverField.b),driverWeight);

    float driverHeat=mix(1.0,mix(0.62,1.30,driverField.g),driverWeight);

    vec3 drift=uWind*uTime*0.035

      -vec3(progress*isImpact*.34,uTime*mix(0.08,0.025,isImpact)+progress*.45,0.0);

    vec3 nc=nq*mix(0.42,0.62,isImpact)+drift+vec3(seed);

    vec4 n=texture(uNoise,nc);

    vec4 nw=texture(uNoise,nc*2.15+vec3(seed*1.7));

    float f=mix(fbm3(n),1.0-n.a,0.38)+(fbm3(nw)-0.5)*0.42;



    /* ---- INTERNAL CAVITIES -------------------------------------------------

       Without carved voids the march integrates a solid shell and no amount of

       lighting stops it reading as a painted blob. These holes widen as the

       fireball cools, and they are also what lets combustion still burning in

       the interior show THROUGH the soot rather than being sealed behind it. */

    vec4 nv=texture(uNoise,q*3.3+vec3(seed*1.31)+drift*0.6);

    float voids=smoothstep(0.44,0.88,nv.a)*mix(0.10,0.58,clamp(sootHold+sSmoke,0.0,1.0));

    /* The source alpha records true authored empty space.  Blend that lightly

       into the analytic cavities so it adds fire/smoke breakup without ever

       hollowing an impact or erasing the fallback procedural field. */

    voids+=driverWeight*(1.0-driverField.a)*0.105;



    /* WORLD-SPACE MATERIAL SPLIT. localP is reconstructed from the live march

       sample p, not the screen coordinate or a painted colour ramp. Keep the

       fuel down in the inner/lower body while the lifted outer surface becomes

       soot. The old fire field lit every lobe equally, so a top-down camera

       integrated one opaque yellow pancake even though the density itself had

       cauliflower detail. These masks make the same density field carry a hot

       core, a cooler crown and real creases between them. */

    float crownAge=smoothstep(0.08,0.66,progress)*(1.0-isImpact);

    float crownTop=smoothstep(-0.08,0.74,localP.y);

    float outerShell=smoothstep(0.20,0.88,r);

    float sootCrown=clamp(crownAge*(0.22+0.78*crownTop)

      +outerShell*(0.18+0.32*crownAge)+sootHold*0.16,0.0,1.0);

    /* Air-crash heat belongs in the lower centre.  The rest of the same

       raymarched field becomes the visibly taller dark crown, so this does

       not add a card, plume, or second combustion layer. */

    sootCrown=clamp(sootCrown+isAirCrash*(0.08+0.38*outerShell*(0.34+0.66*crownTop)),0.0,1.0);

    float fuelHeight=mix(1.0-smoothstep(-0.05,0.70,localP.y),

      1.0-smoothstep(0.42,0.96,localP.y),isImpact);

    float fuelRadius=1.0-smoothstep(0.18,0.74,length(q.xz));

    float fuelPocket=clamp(fuelHeight*fuelRadius*(1.0-0.46*sootCrown)

      +voids*0.16,0.0,1.0);

    float crashCore=1.0-smoothstep(0.10,0.50,length(q.xz));

    float crashFuel=crashCore*(1.0-smoothstep(-0.16,0.28,localP.y));

    /* This is a warm, deliberately thinner neck—not another flame lobe. It

       keeps the fuel column visible while it hands off into soot, so the

       tactical camera reads one combustion volume rather than an orange orb

       sitting below a separate grey oval. */

    float crashBridge=crashCore*(1.0-smoothstep(-0.10,0.82,localP.y));

    sootCrown=mix(sootCrown,max(0.0,sootCrown-crashBridge*0.38),isAirCrash);

    fuelPocket=mix(fuelPocket,clamp(fuelPocket*crashFuel+crashBridge*0.42

      +voids*0.040*crashBridge,0.0,1.0),isAirCrash);

    /* A contact is its own compact material event, not a small rising crown.

       Preserve its pre-existing hot density response; only blast/dust samples

       receive the lower-fuel / lifted-soot separation above. */

    sootCrown*=1.0-isImpact;

    fuelPocket=mix(fuelPocket,1.0,isImpact);



    /* ---- Beer-Lambert density ----------------------------------------------

       Extinction now falls stage by stage so late soot stays TRANSLUCENT. The

       old flat 3.2-3.8 gain drove 1-exp(-sigma*d*ds) to 1.0 across the entire

       silhouette, which is why the aftermath was a uniform opaque black disc

       that completely hid the ground beneath it. */

    float d=(0.80-r)+(f-0.5)*0.72-voids;

    /* Break the upper cap with its own 3D field and taper it slightly. This

       changes the true density boundary (not a colour overlay), preventing a

       perfectly oval soot silhouette at the top-down tactical angle. */

    float crashTop=smoothstep(0.08,0.92,localP.y);

    d-=isAirCrash*crashTop*(0.10+0.26*(1.0-fbm3(nw)));

    float erode=1.0-smoothstep(mix(mix(0.80,0.66,isImpact),0.86,isDust),1.06,progress);

    float ext=mix(mix(3.05,3.55,isImpact),1.28,sSmoke)*mix(1.0,0.82,sootHold)

      *mix(1.0,0.62,sFlash);   /* ignition is THIN and hot, not a dense ball */

    float density=clamp(d*3.2,0.0,1.0)*erode*vPar.x*ext;

    /* Let the high soot cap fray into individual 3D filaments instead of

       preserving the old uniformly opaque upper hemisphere. The low fuel core

       stays dense enough to retain its incandescent read. */

    float crownFilaments=mix(1.0,0.66+0.34*smoothstep(0.18,0.86,fbm3(nw)),

      crownAge*crownTop);

    density*=crownFilaments*driverDensity;



    if(density>0.01){

      /* SELF-SHADOWING FROM THE ACTUAL FIELD.

         The old probe was two analytic sphere chords — length() of an offset

         point — so it produced one smooth radial gradient no matter what the

         density was doing. A smooth gradient over a round silhouette is

         precisely what reads as a flat disc. These two chords re-evaluate the

         SAME noise basis the density uses, so a lobe genuinely shadows the

         fold behind it and the eye gets the depth cue it was missing. */

      float shadow=0.0;

      for(int sI=0;sI<2;sI++){

        float sT=(float(sI)+1.0)*0.24;

        vec3 sq=q+uSunDir*sT;

        float sShape=length(sq*vec3(1.08,0.92,1.08))*1.12;

        vec4 sn=texture(uNoise,sq*mix(0.42,0.62,isImpact)+uWind*uTime*0.035+vec3(seed));

        float sf=sn.r*0.52+sn.g*0.28+sn.b*0.20;

        sf=mix(sf,1.0-sn.a,0.38);

        shadow+=clamp(((0.78-sShape)+(sf-0.5)*0.65)*3.5,0.0,1.0)*(sI==0?0.62:0.38);

      }

      float transmittance=exp(-shadow*3.4);



      /* HEMISPHERIC AMBIENT + PHASE-WEIGHTED SUN.

         uAmbSky, uAmbGnd and uPhase were all uploaded every frame and never

         read by this shader. Without a phase function the sun term ignored

         scattering geometry entirely, and without a sky/ground gradient every

         sample got the same colour regardless of which way it faced — so the

         march returned a uniformly shaded blob. uPhase already carries the

         dual-lobe Henyey-Greenstein evaluated on the CPU (free under ortho);

         it is clamped here only so a grazing sun cannot blow out the core. */

      float ph=clamp(uPhase,0.35,2.4);

      vec3 nrmUp=normalize(q+vec3(0.0,1e-4,0.0));

      vec3 ambient=mix(uAmbGnd,uAmbSky,clamp(0.5+0.5*nrmUp.y,0.0,1.0));



      /* SOOT IS DARK, NOT BLACK. 0.035 through a 0.45 mix landed every sample

         below the terrain's own value, so the integral converged to a flat

         black hole in the ground. Lift the floor and let ambient carry it —

         real soot backscatters plenty at this sun angle. */

      vec3 darkSoot=vec3(0.085,0.076,0.070);

      vec3 sunLitSoot=uSunCol*vec3(0.30,0.25,0.20)*transmittance*ph;

      vec3 smoke=mix(darkSoot,sunLitSoot,0.52)+ambient*(0.34+0.26*transmittance);

      if(isDust>0.5){

        smoke=mix(smoke,vTint.rgb*0.85,0.65);

      }else{

        /* The owning combat recipe supplies faction energy as a material

           driver. Keep soot physically dark, but let its hot inner folds carry

           a restrained trace of that spectrum instead of spawning a separate

           coloured flourish around the volume. */

        smoke=mix(smoke,vTint.rgb*0.20,0.14);

      }



      /* Cool toward soot across the middle of the life, then HOLD. Continuing

         to darken into the tail is what produced the opaque late mass. */

       smoke*=mix(1.0,0.72,sootHold)*mix(1.0,0.86,sSmoke)*driverSoot;

       /* The crown has its own physically darker material response; this is

          what separates rising soot from the fire below without a second card

          or a screen-space overlay. */

       smoke=mix(smoke,darkSoot+ambient*(0.18+0.22*transmittance),sootCrown*0.34);



      /* COMBUSTION, BIASED INTO THE CAVITIES. Where density was carved away the

         volume is thin, and that is exactly where interior burn should still

         be visible from outside — fire showing through pockets rather than

         painted onto a shell. */

      /* ENERGY SCALES WITH THE EVENT, and this is the whole point.

         A flat gain is wrong at both ends: crank it and a rifle contact blows

         out like a bunker buster, damp it and a bombardment loses the

         incandescent core that makes heavy ordnance feel heavy. Power is taken

         from the authored emission AND the volume's own world size — vExt is

         in world units, so a bombardment proxy is several times a small

         impact's — and it drives the fire ramp, the white knee and the

         highlight shoulder together. Cavities REVEAL interior fire; they do

         not manufacture it, hence the small 0.30 term. */

      float rWorld=max(vExt.x,max(vExt.y,vExt.z));

      float power=clamp(vPar.y*(0.74+0.78*smoothstep(6.0,46.0,rWorld)),0.0,1.90);

      /* ONE temperature clock. The old -progress*0.55 was a fifth, unnamed cooling

         ramp that the four stage weights knew nothing about, decaying on a

         different schedule than the gate below and fighting it — which is why

         tuning the constants kept swinging between all-white and all-soot. The

         shrinking hot core is now a SHAPE change on the stage clock instead. */

       float fireField=(0.86-r*mix(0.90,1.38,sootHold))+(fbm3(nw)-0.50)*0.85

         +voids*mix(0.22,0.30,isImpact);

       float fireHeat=clamp(fireField*(1.35+1.25*power),0.0,1.0)*(1.0-isDust);

       /* Fire can only occupy the carved fuel pocket. Its lower/central world

          shape makes the volume read as a crown over a burning interior rather

          than a single yellow density blob; the cavity term leaves sparse hot

          glimpses through the soot rather than broadening the whole shell. */

       fireHeat*=mix(0.28,1.0,fuelPocket)*mix(1.0,0.34,sootCrown)*driverHeat;

      /* Do not let the airframe's now-dark outer crown retain the generic

         blast's side fire. This keeps the remaining gold/orange ignition

         localized at the base instead of reading as separate flat lobes. */

      float crashFlame=clamp(crashFuel+crashBridge*0.52,0.0,1.0);

      fireHeat*=mix(1.0,0.64+0.36*crashFlame,isAirCrash);

      /* The flash owns the white region outright; combustion is weighted to top

         out in the golden band so it reads as ROLLING FIRE rather than a white

         plateau with a thin orange rim. */

      fireHeat*=clamp(sFlash*1.25+sBurn*0.70+sSoot*0.30,0.0,1.30);



      // Saturated Fire -> Golden Core -> Blinding Center

      vec3 deepEmber=vec3(0.75,0.14,0.01);

      vec3 brightFlame=vec3(1.00,0.48,0.04);

      vec3 goldenYellow=vec3(1.00,0.85,0.22);

      /* Heavy ordnance gets a genuinely incandescent core; light contacts get

         a hot but bounded one. */

      vec3 coreWhite=mix(vec3(1.22,1.15,0.98),vec3(1.78,1.68,1.44),

        smoothstep(0.60,1.50,power));



      /* Texture/profile-driven combustion: the centre stays incandescent and

         readable, while the cooler outer fire inherits Nova cyan, Legion heat,

         Syndicate phase-green, or Brood bio energy. This is still one density

         field and one logical core layer. */

      vec3 factionFire=clamp(vTint.rgb*1.18,0.0,1.35);

      deepEmber=mix(deepEmber,factionFire*0.52,0.42);

      brightFlame=mix(brightFlame,max(factionFire,vec3(0.08))*1.08,0.48);



      vec3 fireColor=mix(deepEmber,brightFlame,smoothstep(0.02,0.38,fireHeat));

      /* The white knee slides with power: a bombardment reaches incandescence

         across most of its core, a small contact only at its very centre. */

      /* After the flash the knee lifts so combustion sits in the golden band — but

         the lift is SMALLER for heavy ordnance, so a bombardment still reaches an

         incandescent core while a rifle contact never can. */

      float whiteKnee=mix(0.90,0.58,smoothstep(0.50,1.50,power))

        +mix(0.30,0.16,smoothstep(0.60,1.50,power))*(1.0-sFlash);

      fireColor=mix(fireColor,goldenYellow,smoothstep(0.40,0.74,fireHeat));

      float whiteMix=smoothstep(whiteKnee,1.00,fireHeat)*mix(1.0,sFlash,isAirCrash);

      fireColor=mix(fireColor,coreWhite,whiteMix);

      /* Sub-100 ms ignition is the ONLY stage allowed near the ceiling, and

         even it goes through the shoulder rather than clipping flat. */

      fireColor=mix(fireColor,vec3(1.85,1.74,1.52),sFlash*0.80);



       float fireMix=smoothstep(mix(0.10,0.01,isImpact),mix(0.42,0.26,isImpact),fireHeat)

         *mix(1.0,0.44,sootCrown);

       fireMix*=mix(1.0,0.34+0.66*crashFlame,isAirCrash);

       vec3 stepColor=shoulder(mix(smoke,fireColor,fireMix),
         mix(0.40,0.10,smoothstep(0.60,1.50,power))*mix(1.55,1.0,sFlash));
      /* Void energy never passes through the orange combustion/soot ramp. Its
         volume cools from a bounded white-violet centre into a blue-purple
         sheath, while density erosion—not black smoke—ends the contact. */
      float voidHeat=clamp(voidField*(.82+sFlash*.78)+fireHeat*.22
        +voidCrescent*.38+voidSpear*.48+voidForks*.22,0.0,1.35);
      vec3 voidColor=mix(vec3(.075,.035,.34),vec3(.44,.12,1.18),
        smoothstep(.08,.58,voidHeat));
      voidColor=mix(voidColor,vec3(1.58,1.46,1.82),smoothstep(.68,1.12,voidHeat));
      voidColor*=mix(.76,1.12,sFlash);
      stepColor=mix(stepColor,shoulder(voidColor,.12),isVoidImpact);
      float alpha=1.0-exp(-uSigma*density*ds*3.8);



      acc+=T*stepColor*alpha;

      T*=(1.0-alpha);

      if(T<0.015) break;

    }

  }



  float alpha=1.0-T;

  /* TRANSLUCENCY CEILING FOR THE SMOKE STAGE. acc is already premultiplied, so

     scaling colour and alpha together preserves the "over" identity exactly

     while guaranteeing the tail never becomes a solid occluder — terrain and

     structures stay readable through dissipating soot. */

  float aCap=mix(1.0,0.70,sSmoke);

  if(alpha>aCap){ acc*=aCap/max(alpha,1e-4); alpha=aCap; }

  if(alpha<=0.002) discard;

  o=vec4(acc,alpha);

}`;

/* Fullscreen triangle, no vertex buffer — the same gl_VertexID idiom mesh.js

   already uses for VSQ (mesh.js:2296). */
const VOL_VS_UP=`#version 300 es

out vec2 vUv;

void main(){

  vec2 p=vec2((gl_VertexID<<1)&2, gl_VertexID&2);

  vUv=p; gl_Position=vec4(p*2.0-1.0,0.0,1.0);

}`;

/* Bilateral upsample. volTex is NEAREST so the four taps are the actual

   marched texels; the depth key rejects a tap that marched a different

   surface, which is what keeps the half-res result from haloing over a hull.

   uBilateral=0 collapses this to a single tap for the degraded rung. */
const VOL_FS_UP=`#version 300 es

precision highp float;

precision highp sampler2D;

in vec2 vUv;

uniform sampler2D uVol;

uniform sampler2D uDep;

uniform vec2  uVolSize;

uniform vec2  uInvVolSize;

uniform float uDepthScale;

uniform float uBilateral;

out vec4 o;

void main(){

  if(uBilateral<0.5){ o=texture(uVol,vUv); return; }

  float dC=texture(uDep,vUv).r*uDepthScale;

  vec2 f=vUv*uVolSize-0.5;

  vec2 base=floor(f), fr=f-base;

  vec4 sum=vec4(0.0); float wsum=0.0;

  for(int j=0;j<2;j++){

    for(int i=0;i<2;i++){

      vec2 tc=(base+vec2(float(i),float(j))+0.5)*uInvVolSize;

      float wb=(i==0?1.0-fr.x:fr.x)*(j==0?1.0-fr.y:fr.y);

      float dS=texture(uDep,tc).r*uDepthScale;

      float w=wb/(1.0+abs(dC-dS)*0.35);

      sum+=texture(uVol,tc)*w; wsum+=w;

    }

  }

  o=sum/max(wsum,1e-4);

}`;

/* ---------------------------------------------------------------------------

   INIT / TEARDOWN

   --------------------------------------------------------------------------- */
function volFxCtxCheck(){
  const ep=(typeof glEpoch!=='undefined')?glEpoch:0;
  if(volEpoch===ep) return;
  volEpoch=ep;
  volInitFailed=false;
  volFxGLReset();
}
function volFxGLReset(){
  volProg=volProgUp=volVAO=volEmptyVAO=volCubeVBO=volInstVBO=null;
  volNoiseTex=volDriverTex=volTrailHistoryTex=volFB=volTex=null;
  volTrailHistoryEpoch=-1;volTrailHistoryDirty=true;VOL_TRAIL_HISTORY_TELEM.ready=false;
  volW=volH=0; volFailN=0;
  volU={}; volUup={};
  volDriverReady=false; volDriverState='uninitialised'; volDriverError='';
  volDriverSerial++;
  VOLFX_TELEMETRY.progOK=false;
  VOLFX_TELEMETRY.driverReady=false;
  VOLFX_TELEMETRY.driverState=volDriverState;
  VOLFX_TELEMETRY.driverSamples=0;
  VOLFX_TELEMETRY.driverError='';
  VOLFX_TELEMETRY.trailHistoryReady=false;
}

function volDriverTelemetrySync(){
  VOLFX_TELEMETRY.driverReady=!!volDriverReady;
  VOLFX_TELEMETRY.driverState=volDriverState;
  VOLFX_TELEMETRY.driverError=volDriverError;
}

/* Keep a complete neutral sampler resident before asynchronous image decode.

   uDriverReady remains zero until the authored sheet uploads, so this value is

   never a visual fallback by itself; it only keeps the sampler valid on every

   ANGLE implementation while the existing procedural density is authoritative. */
function volDriverNeutral(tex){
  if(!tex||typeof gl==='undefined'||!gl) return false;
  const wasActive=gl.getParameter(gl.ACTIVE_TEXTURE);
  gl.activeTexture(gl.TEXTURE0+VOL_DRIVER_UNIT);
  const wasTex=gl.getParameter(gl.TEXTURE_BINDING_2D);
  let ok=false;
  try{
    gl.getError();
    gl.bindTexture(gl.TEXTURE_2D,tex);
    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,false);
    gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL,gl.NONE);
    gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA8,1,1,0,gl.RGBA,gl.UNSIGNED_BYTE,
      new Uint8Array([128,0,128,255]));
    gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.LINEAR);
    gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.LINEAR);
    gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);
    gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.CLAMP_TO_EDGE);
    ok=gl.getError()===gl.NO_ERROR;
  }catch(e){ ok=false; }
  gl.bindTexture(gl.TEXTURE_2D,wasTex);
  gl.activeTexture(wasActive);
  return ok;
}

function volDriverCurrent(tex,epoch,serial){
  return !!gl&&volDriverTex===tex&&volEpoch===epoch&&volDriverSerial===serial;
}

function volDriverFail(tex,epoch,serial,message){
  if(!volDriverCurrent(tex,epoch,serial)) return;
  /* Restore the known complete 1x1 sampler if upload itself was the failure.

     The shader consequently takes uDriverReady==0 and retains the procedural

     raymarch; it never presents a blank volume or a second billboard. */
  volDriverNeutral(tex);
  volDriverReady=false;
  volDriverState='procedural-fallback';
  volDriverError=String(message||'driver load failed').slice(0,180);
  volDriverTelemetrySync();
}

function volDriverLoad(){
  const tex=volDriverTex,epoch=volEpoch,serial=++volDriverSerial;
  volDriverReady=false;
  volDriverState='loading';
  volDriverError='';
  volDriverTelemetrySync();
  if(!tex||typeof Image==='undefined'){
    volDriverFail(tex,epoch,serial,'Image decode API is unavailable');
    return;
  }
  const img=new Image();
  img.decoding='async';
  img.onload=()=>{
    if(!volDriverCurrent(tex,epoch,serial)) return;
    if(img.naturalWidth!==1024||img.naturalHeight!==1024){
      volDriverFail(tex,epoch,serial,'invalid driver dimensions '+img.naturalWidth+'x'+img.naturalHeight);
      return;
    }
    const wasActive=gl.getParameter(gl.ACTIVE_TEXTURE);
    gl.activeTexture(gl.TEXTURE0+VOL_DRIVER_UNIT);
    const wasTex=gl.getParameter(gl.TEXTURE_BINDING_2D);
    const wasFlip=gl.getParameter(gl.UNPACK_FLIP_Y_WEBGL);
    const wasPremul=gl.getParameter(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL);
    const wasCS=gl.getParameter(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL);
    let ok=false;
    try{
      gl.getError();
      gl.bindTexture(gl.TEXTURE_2D,tex);
      /* Data texture: preserve packed density/emission values exactly.  The

         atlas owns its guard band, so linear base-level filtering is deliberate

         and avoids mip levels blending separate animation cells together. */
      gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,false);
      gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,false);
      gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL,gl.NONE);
      gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA8,gl.RGBA,gl.UNSIGNED_BYTE,img);
      gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.LINEAR);
      gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.LINEAR);
      gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);
      gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.CLAMP_TO_EDGE);
      ok=gl.getError()===gl.NO_ERROR;
    }catch(e){ ok=false; }
    gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL,wasFlip);
    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL,wasPremul);
    gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL,wasCS);
    gl.bindTexture(gl.TEXTURE_2D,wasTex);
    gl.activeTexture(wasActive);
    if(!volDriverCurrent(tex,epoch,serial)) return;
    if(!ok){ volDriverFail(tex,epoch,serial,'GPU upload failed'); return; }
    volDriverReady=true;
    volDriverState='ready';
    volDriverError='';
    volDriverTelemetrySync();
  };
  img.onerror=()=>volDriverFail(tex,epoch,serial,'image decode failed');
  try{
    img.src=(typeof mf2AssetURL==='function')?mf2AssetURL(VOL_DRIVER_ASSET):('./'+VOL_DRIVER_ASSET);
  }catch(e){ volDriverFail(tex,epoch,serial,e&&e.message||e); }
}

function volFxInit(){
  if(volProg||volInitFailed) return;
  if(typeof gl==='undefined'||!gl) return;
  if(typeof mkProg!=='function'){ volInitFailed=true; return; }

  volProg=mkProg(VOL_VS,VOL_FS,'volfx');
  volProgUp=mkProg(VOL_VS_UP,VOL_FS_UP,'volfx-upsample');
  /* mkProg() defers link validation (mesh.js). This latch must know NOW, and

     both programs are validated explicitly so neither is left pending. */
  const volOk=mfProgOk(volProg), volUpOk=mfProgOk(volProgUp);
  if(!volOk||!volUpOk){
    /* One may have linked. Release it rather than orphaning it, and LATCH so

       the next detonation does not recompile the pair (gpufx.js:44-48). */
    if(volProg) gl.deleteProgram(volProg);
    if(volProgUp) gl.deleteProgram(volProgUp);
    volProg=volProgUp=null; volInitFailed=true;
    VOLFX_TELEMETRY.progOK=false;
    return;
  }
  for(const k of ['uVP','uNoise','uDep','uDriver','uDriverReady','uTrailDriver','uTrailDriverReady','uTrailHistory','uTrailHistoryReady','uRayDir','uSunDir','uSunCol','uAmbSky','uAmbGnd',
                  'uWind','uInvVolSize','uWorldPerPx','uDepthScale','uSigma','uPhase','uTime',
                  'uWaterOn','uWaterY','uSteps'])
    volU[k]=gl.getUniformLocation(volProg,k);
  for(const k of ['uVol','uDep','uVolSize','uInvVolSize','uDepthScale','uBilateral'])
    volUup[k]=gl.getUniformLocation(volProgUp,k);

  /* PIN THE SAMPLER UNITS AT LINK TIME, not just per draw. Until a uniform is

     written, every sampler reads unit 0 — and this program has a sampler3D

     and a sampler2D, so before the first volFxDraw the program is in the

     state ANGLE reports as "Two textures of different types use the same

     sampler location": VALIDATE_STATUS false and undefined behaviour for any

     draw that slipped in first. Caught by the bring-up probe, which asserts

     VALIDATE_STATUS rather than trusting LINK_STATUS alone. Same fix, same

     save/restore of CURRENT_PROGRAM, as gpufx.js:196-200. */
  {
    const wasP=gl.getParameter(gl.CURRENT_PROGRAM);
    gl.useProgram(volProg);
    if(volU.uNoise) gl.uniform1i(volU.uNoise,12);
    if(volU.uDep)   gl.uniform1i(volU.uDep,4);
    if(volU.uDriver) gl.uniform1i(volU.uDriver,VOL_DRIVER_UNIT);
    if(volU.uDriverReady) gl.uniform1f(volU.uDriverReady,0);
    if(volU.uTrailDriver) gl.uniform1i(volU.uTrailDriver,11);
    if(volU.uTrailDriverReady) gl.uniform1f(volU.uTrailDriverReady,0);
    if(volU.uTrailHistory) gl.uniform1i(volU.uTrailHistory,10);
    if(volU.uTrailHistoryReady) gl.uniform1f(volU.uTrailHistoryReady,0);
    gl.useProgram(volProgUp);
    if(volUup.uVol) gl.uniform1i(volUup.uVol,13);
    if(volUup.uDep) gl.uniform1i(volUup.uDep,4);
    if(wasP) gl.useProgram(wasP); else gl.useProgram(null);
  }

  /* Unit cube, 36 non-indexed verts (432 B). Boxes not spheres: one mesh

     covers ball, dome and column, and the anisotropic extents give the plume

     its aspect for free. */
  const C=new Float32Array(108);
  {
    const F=[[0,1,2,3],[5,4,7,6],[4,5,1,0],[3,2,6,7],[4,0,3,7],[1,5,6,2]];
    const V=[[-1,-1,1],[1,-1,1],[1,1,1],[-1,1,1],[-1,-1,-1],[1,-1,-1],[1,1,-1],[-1,1,-1]];
    let w=0;
    for(const f of F){
      const idx=[f[0],f[1],f[2], f[0],f[2],f[3]];
      for(const q of idx){ C[w++]=V[q][0]; C[w++]=V[q][1]; C[w++]=V[q][2]; }
    }
  }
  volCubeVBO=gl.createBuffer();
  gl.bindBuffer(gl.ARRAY_BUFFER,volCubeVBO);
  gl.bufferData(gl.ARRAY_BUFFER,C,gl.STATIC_DRAW);
  volInstVBO=gl.createBuffer();
  gl.bindBuffer(gl.ARRAY_BUFFER,volInstVBO);
  gl.bufferData(gl.ARRAY_BUFFER,volInstData.byteLength,gl.DYNAMIC_DRAW);

  volVAO=gl.createVertexArray();
  gl.bindVertexArray(volVAO);
  gl.bindBuffer(gl.ARRAY_BUFFER,volCubeVBO);
  gl.enableVertexAttribArray(0); gl.vertexAttribPointer(0,3,gl.FLOAT,false,12,0);
  gl.vertexAttribDivisor(0,0);
  gl.bindBuffer(gl.ARRAY_BUFFER,volInstVBO);
  const ST=VOL_INST_FLOATS*4;
  for(let a=1;a<=5;a++){
    gl.enableVertexAttribArray(a);
    gl.vertexAttribPointer(a,4,gl.FLOAT,false,ST,(a-1)*16);
    gl.vertexAttribDivisor(a,1);
  }
  gl.bindVertexArray(null);
  gl.bindBuffer(gl.ARRAY_BUFFER,null);

  /* The composite is a gl_VertexID fullscreen triangle with no attributes.

     It gets its own empty VAO rather than riding the default one, so a stray

     enabled attribute array left by another pass cannot fail the draw. */
  volEmptyVAO=gl.createVertexArray();

  volNoiseTex=gl.createTexture();
  gl.activeTexture(gl.TEXTURE12);
  gl.bindTexture(gl.TEXTURE_3D,volNoiseTex);
  gl.texImage3D(gl.TEXTURE_3D,0,gl.RGBA8,32,32,32,0,gl.RGBA,gl.UNSIGNED_BYTE,volNoiseBuild());
  gl.texParameteri(gl.TEXTURE_3D,gl.TEXTURE_MIN_FILTER,gl.LINEAR);
  gl.texParameteri(gl.TEXTURE_3D,gl.TEXTURE_MAG_FILTER,gl.LINEAR);
  gl.texParameteri(gl.TEXTURE_3D,gl.TEXTURE_WRAP_S,gl.REPEAT);
  gl.texParameteri(gl.TEXTURE_3D,gl.TEXTURE_WRAP_T,gl.REPEAT);
  gl.texParameteri(gl.TEXTURE_3D,gl.TEXTURE_WRAP_R,gl.REPEAT);
  gl.bindTexture(gl.TEXTURE_3D,null);
  gl.activeTexture(gl.TEXTURE0);

  /* The placeholder must exist before the asynchronous decode starts.  If a

     device cannot allocate even this 1x1 sampler, mark the whole volume pass

     unavailable so the already-armed single flipbook remains the atomic

     fallback instead of attempting an incomplete sampler draw. */
  volDriverTex=gl.createTexture();
  if(!volDriverTex||!volDriverNeutral(volDriverTex)){
    volDriverTex=null;
    volDriverReady=false;
    volDriverState='unavailable';
    volDriverError='could not allocate neutral driver sampler';
    volDriverTelemetrySync();
    volInitFailed=true;
    VOLFX_TELEMETRY.progOK=false;
    return;
  }
  volDriverLoad();

  VOLFX_TELEMETRY.progOK=true;
}

/* Half-res colour target. This mirrors aoAlloc's discipline verbatim

   (mesh.js:2380-2450) and for the same reason: detach BEFORE deleting, do not

   commit the cached size until the framebuffer reports COMPLETE, and bound the

   retry. A single failed alloc once latched AO off for 316 straight frames. */
function volAlloc(w,h){
  w=Math.max(1,w|0); h=Math.max(1,h|0);
  if(volW===w&&volH===h&&volTex&&volFB) return true;
  if(volFailN>=4&&volW===w&&volH===h) return false;
  /* This runs MID-FRAME with aoFB2 bound. Binding the default target and

     returning would send water and every additive pass to the canvas, so the

     caller's framebuffer is saved and put back on BOTH exits. */
  const wasFB=gl.getParameter(gl.FRAMEBUFFER_BINDING);
  if(volFB){
    /* Detach BEFORE deleting: aoAlloc does the same and for the same reason. */
    gl.bindFramebuffer(gl.FRAMEBUFFER,volFB);
    gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,null,0);
  }
  if(volTex) gl.deleteTexture(volTex);
  volTex=gl.createTexture();
  gl.bindTexture(gl.TEXTURE_2D,volTex);
  /* RGBA8 to match aoColB (mesh.js:2410). NEAREST because the bilateral

     upsample must see the texels that were actually marched. */
  gl.texImage2D(gl.TEXTURE_2D,0,gl.RGBA8,w,h,0,gl.RGBA,gl.UNSIGNED_BYTE,null);
  gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MIN_FILTER,gl.NEAREST);
  gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_MAG_FILTER,gl.NEAREST);
  gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_S,gl.CLAMP_TO_EDGE);
  gl.texParameteri(gl.TEXTURE_2D,gl.TEXTURE_WRAP_T,gl.CLAMP_TO_EDGE);
  gl.bindTexture(gl.TEXTURE_2D,null);
  if(!volFB) volFB=gl.createFramebuffer();

  gl.bindFramebuffer(gl.FRAMEBUFFER,volFB);
  gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.COLOR_ATTACHMENT0,gl.TEXTURE_2D,volTex,0);
  const ok=gl.checkFramebufferStatus(gl.FRAMEBUFFER)===gl.FRAMEBUFFER_COMPLETE;
  gl.bindFramebuffer(gl.FRAMEBUFFER,wasFB);
  if(ok){ volW=w; volH=h; volFailN=0; return true; }
  volFailN++;
  if(volFailN>=4){ volW=w; volH=h; }        // stop retrying every frame
  return false;
}

/* ---------------------------------------------------------------------------

   HOP 2 — ring -> GPU, once per frame.

   CALLED FROM render3d.js immediately BEFORE aoExtractBloom(), which is the

   last point in the frame where a pass can still reach the bright pass

   (render3d.js:2743-2747). At that instant the bound FBO is aoFB2 with

   aoColB + aoDepth, viewport aoW x aoH, scissor already disabled, and

   blend off / depth test on / depthMask true / cull on. This function must

   leave EXACTLY that.

   --------------------------------------------------------------------------- */
function volFxDraw(dtDraw,Sun,canPresent){
  volPresented.fill(0);
  VOLFX_TELEMETRY.live=volN;
  VOLFX_TELEMETRY.drawn=0; VOLFX_TELEMETRY.culled=0;
  VOLFX_TELEMETRY.marchedPx=0; VOLFX_TELEMETRY.compositePx=0; VOLFX_TELEMETRY.steps=0;
  VOLFX_TELEMETRY.presentedBlast=0;VOLFX_TELEMETRY.presentedDust=0;
  VOLFX_TELEMETRY.presentedImpact=0;
  VOLFX_TELEMETRY.presentedTrailEnergy=0;VOLFX_TELEMETRY.presentedTrailShell=0;
  VOLFX_TELEMETRY.trailDriverReady=false;VOLFX_TELEMETRY.trailHistoryReady=false;
  VOLFX_TELEMETRY.fallbackQueries=0;VOLFX_TELEMETRY.fallbackHits=0;
  VOLFX_TELEMETRY.driverSamples=0;
  volDriverTelemetrySync();
  volFxSyncRay();
  /* MAINTENANCE PATH — this function is called EVERY frame, including frames

     where the offscreen/AO target was never bound. Clearing the presentation

     bits above is the whole reason: those bits are what suppress the armed

     flipbook, so a bit left over from the last composited frame would also

     suppress the fallback on a frame that cannot composite, and the detonation

     would render as nothing at all. Everything below needs the offscreen

     colour+depth, so on those frames the correct behaviour is to leave with

     the bits cleared and let the flipbook own the frame. */
  if(canPresent===false) return;
  if(!volFxActive()) return;
  if(volN<=0) return;
  /* Thin ordnance wakes lose their white core and scalloped soot boundary in
     the shared half-resolution blast target. Trail kinds remain probe-only,
     so evaluate them at scene resolution while their cost/quality is being
     measured; production explosions retain the established half-res path. */
  let trailFullRes=false,curveTrail=false;
  for(let vi=0;vi<volN;vi++)if(volIsTrailKind(volKind[vi])){
    trailFullRes=true;if(volKind[vi]===VOL_TRAIL_CURVE_ENERGY||volKind[vi]===VOL_TRAIL_CURVE_SHELL)curveTrail=true;
  }
  if(!volAlloc(Math.max(1,trailFullRes?aoW:aoW>>1), Math.max(1,trailFullRes?aoH:aoH>>1))) return;

  /* ---- cull + project ------------------------------------------------- */
  const cb=(typeof camBounds==='function')?camBounds():null;
  const pxPerWorld=volH/Math.max(1,(typeof orthoSpan==='number'?orthoSpan:1500));
  let n=0, area=0;
  /* Phase B used to run its five-tap bilateral upsample over the entire AO

     target even when three tactical volumes covered <0.2% of it. Project the

     accepted proxy boxes once and scissor the composite to their exact union.

     The march remains half-resolution and depth-aware, and the preset still

     owns the same 24/32 maximum steps; this only removes guaranteed-zero

     fullscreen work. Coordinates stay in GL's bottom-left framebuffer space. */
  let compX0=aoW,compY0=aoH,compX1=0,compY1=0;
  for(let i=0;i<volN;i++){
    const life=volLife[i]; if(!(life>0)) continue;
    const age=Math.min(1,volT[i]/life);
    const g=volRenderGrow(volKind[i],age,volR0[i],pxPerWorld,
      volAX[i],volAY[i],volAZ[i],volStyle[i]);
    const ex=g*volAX[i], ey=g*volAY[i], ez=g*volAZ[i];
    const rad=Math.max(ex,Math.max(ey,ez));
    /* Fog disclosure is a GROUND-PLANE question: what the player would see is

       this volume's footprint on the terrain. Using the 3D radius let a tall

       plume's vertical half-extent (aspect y up to 3.6) inflate the test by

       several times the real footprint, so a volume whose ground position was

       well inside the fog could still be judged visible. */
    const radXZ=Math.max(ex,ez);
    if(cb){
      if(volPX[i]+rad<cb.x0||volPX[i]-rad>cb.x1) { VOLFX_TELEMETRY.culled++; continue; }
      if(volPZ[i]+rad<cb.y0||volPZ[i]-rad>cb.y1) { VOLFX_TELEMETRY.culled++; continue; }
    }
    /* Fog of war owns disclosure. A volume must not draw an enemy detonation

       the player has no vision of — the same rule every other FX loop in

       render3d.js applies. */
    const fogVisible=typeof fogFxFootprintVisible==='function'
      ?fogFxFootprintVisible(volPX[i],volPZ[i],radXZ)
      :(typeof fogPointVisible!=='function'||fogPointVisible(volPX[i],volPZ[i]));
    if(!fogVisible){
      VOLFX_TELEMETRY.culled++; continue;
    }
    for(let cz=-1;cz<=1;cz+=2)for(let cy=-1;cy<=1;cy+=2)for(let cx=-1;cx<=1;cx+=2){
      const wx=volPX[i]+ex*cx,wy=volPY[i]+ey*cy,wz=volPZ[i]+ez*cz;
      const cw=matVP[3]*wx+matVP[7]*wy+matVP[11]*wz+matVP[15];
      if(Math.abs(cw)<1e-5)continue;
      const sx=((matVP[0]*wx+matVP[4]*wy+matVP[8]*wz+matVP[12])/cw*.5+.5)*aoW;
      const sy=((matVP[1]*wx+matVP[5]*wy+matVP[9]*wz+matVP[13])/cw*.5+.5)*aoH;
      compX0=Math.min(compX0,sx);compX1=Math.max(compX1,sx);
      compY0=Math.min(compY0,sy);compY1=Math.max(compY1,sy);
    }
    volOrder[n]=i;
    /* Ortho: the camera ray is constant, so a depth key of dot(centre,rayDir)

       is EXACT and a descending insertion sort over <=48 entries is free.

       Required because each volume's own march emits premultiplied "over", so

       cross-volume compositing has to be back-to-front. */
    volKey[n]=volPX[i]*volRayX+volPY[i]*volRayY+volPZ[i]*volRayZ;
    volArea[n]=Math.PI*ex*ez*pxPerWorld*pxPerWorld;
    area+=volArea[n];
    n++;
  }
  if(n<=0) return;

  /* A ready driver is sampled only by the blast/smoke density material.  This

     is telemetry for the runtime probe, not an additional event/layer count. */
  if(volDriverReady){
    for(let s=0;s<n;s++){
      const k=volKind[volOrder[s]];
      if(k===VOL_BLAST||k===VOL_SMOKE) VOLFX_TELEMETRY.driverSamples++;
    }
  }

  /* ---- sort far -> near (descending along the view ray) ---------------- */
  for(let a=1;a<n;a++){
    const ki=volKey[a], oi=volOrder[a], ai=volArea[a];
    let b=a-1;
    while(b>=0&&volKey[b]<ki){ volKey[b+1]=volKey[b]; volOrder[b+1]=volOrder[b]; volArea[b+1]=volArea[b]; b--; }
    volKey[b+1]=ki; volOrder[b+1]=oi; volArea[b+1]=ai;
  }

  /* ---- step budget: ONE uniform, never a boolean gate ------------------

     perfScale appears here and nowhere else, as a multiplier. The effect never

     disappears under load; it gets coarser. */
  const ps=(typeof perfScale==='number'?perfScale:1);
  const budget=volW*volH*(4.0+8.0*Math.max(0.25,Math.min(1,ps)));
  const ceil=volStepCeiling();
  const steps=Math.max(6,Math.min(ceil,Math.floor(budget/Math.max(1,area))));

  /* ---- pack instances -------------------------------------------------- */
  for(let s=0;s<n;s++){
    const i=volOrder[s], o=s*VOL_INST_FLOATS;
    const life=volLife[i];
    const age=Math.min(1,volT[i]/life);
    const g=volRenderGrow(volKind[i],age,volR0[i],pxPerWorld,
      volAX[i],volAY[i],volAZ[i],volStyle[i]);
    /* NO SECOND TAIL FADE HERE. The march already dissolves the field with an

       age-driven erosion threshold that is shape-aware (it eats the thin

       edges first and leaves the dense core last). Multiplying a second

       smoothstep on top of it made the two fades compound: by 62% of life the

       core was being attenuated twice and the blast visually disappeared while

       its own clock still had a third of the burn left to run, which is the

       "late-life double fade" the audit saw. One fade, owned by the shader. */
    volInstData[o  ]=volPX[i];
    volInstData[o+1]=volPY[i];
    volInstData[o+2]=volPZ[i];
    volInstData[o+3]=age;
    volInstData[o+4]=g*volAX[i];
    volInstData[o+5]=g*volAY[i];
    volInstData[o+6]=g*volAZ[i];
    volInstData[o+7]=volKind[i];
    volInstData[o+8]=volDens[i];
    volInstData[o+9]=volEmis[i];
    /* Lane 10 was a 0..64 seed. Pack the tiny internal material profile above

       that range so the shader can recover both without widening the instance

       struct or introducing another volume draw. */
    volInstData[o+10]=volSeed[i]+volStyle[i]*64;
    /* LANE 11 CARRIES LIFE IN SECONDS, not the world radius it used to hold.

       The shader never read that radius (its `rMax` was dead), and the march

       needs ABSOLUTE time: "sub-100 ms flash" is 6% of a 1.6 s bombardment but

       22% of a 0.46 s contact hit, so no normalised threshold can express it

       for both. Extents already carry the size, so nothing is lost. */
    volInstData[o+11]=life;
    volInstData[o+12]=volTR[i]/255;
    volInstData[o+13]=volTG[i]/255;
    volInstData[o+14]=volTB[i]/255;
    volInstData[o+15]=volAngle[i];
    volInstData[o+16]=volTX[i];
    volInstData[o+17]=volTY[i];
    volInstData[o+18]=volTZ[i];
    volInstData[o+19]=volTHalf[i]*g;
  }

  /* ---- state save ------------------------------------------------------

     EVERY piece of state this pass mutates is captured, and the restore runs

     from a finally. The depth attachment is the dangerous one: Phase B detaches

     aoDepth from aoFB2 to break a feedback loop, and a throw anywhere between

     the detach and the re-attach used to leave the scene's own framebuffer with

     NO depth buffer — the additive block and the billboard pass both depth-test

     against it, so a single bad frame silently removed depth from everything

     drawn after this point. The old restore also assumed it knew what the

     caller's state was ("EXACTLY what render3d left") and hardcoded cullFace

     BACK plus a specific blendFunc; it now puts back what was actually there. */
  const wasFB=gl.getParameter(gl.FRAMEBUFFER_BINDING);
  const wasVP=gl.getParameter(gl.VIEWPORT);
  const wasScBox=gl.getParameter(gl.SCISSOR_BOX);
  const wasScissor=gl.isEnabled(gl.SCISSOR_TEST);
  const wasProg=gl.getParameter(gl.CURRENT_PROGRAM);
  const wasVAO=gl.getParameter(gl.VERTEX_ARRAY_BINDING);
  const wasArr=gl.getParameter(gl.ARRAY_BUFFER_BINDING);
  const wasActive=gl.getParameter(gl.ACTIVE_TEXTURE);
  const wasBlend=gl.isEnabled(gl.BLEND), wasCull=gl.isEnabled(gl.CULL_FACE);
  const wasDepth=gl.isEnabled(gl.DEPTH_TEST), wasMask=gl.getParameter(gl.DEPTH_WRITEMASK);
  const wasCullMode=gl.getParameter(gl.CULL_FACE_MODE);
  const wasSrcRGB=gl.getParameter(gl.BLEND_SRC_RGB),wasDstRGB=gl.getParameter(gl.BLEND_DST_RGB);
  const wasSrcA=gl.getParameter(gl.BLEND_SRC_ALPHA),wasDstA=gl.getParameter(gl.BLEND_DST_ALPHA);
  const wasEqRGB=gl.getParameter(gl.BLEND_EQUATION_RGB),wasEqA=gl.getParameter(gl.BLEND_EQUATION_ALPHA);
  gl.activeTexture(gl.TEXTURE0);  const wasTex0=gl.getParameter(gl.TEXTURE_BINDING_2D);
  gl.activeTexture(gl.TEXTURE4);  const wasTex4=gl.getParameter(gl.TEXTURE_BINDING_2D);
  gl.activeTexture(gl.TEXTURE10); const wasTex10=gl.getParameter(gl.TEXTURE_BINDING_2D);
  gl.activeTexture(gl.TEXTURE11); const wasTex11=gl.getParameter(gl.TEXTURE_BINDING_2D);
  gl.activeTexture(gl.TEXTURE13); const wasTex13=gl.getParameter(gl.TEXTURE_BINDING_2D);
  gl.activeTexture(gl.TEXTURE0+VOL_DRIVER_UNIT); const wasTexDriver=gl.getParameter(gl.TEXTURE_BINDING_2D);
  gl.activeTexture(wasActive);
  /* Drain any pre-existing error so the NO_ERROR gate below judges THIS pass

     rather than inheriting a flag another system left set. */
  gl.getError();
  let composited=false;
  /* Declared out here because the telemetry write below the finally reads

     them, and a throw must still leave them defined. */
  let compSW=0,compSH=0;
  try{

  /* ================= PHASE A — march into volFB =========================

     Sampling aoDepth HERE is safe: the feedback rule applies only to the

     currently bound DRAW framebuffer, and aoDepth is attached to aoFB2, which

     is not bound. */
  gl.bindFramebuffer(gl.FRAMEBUFFER,volFB);
  gl.viewport(0,0,volW,volH);
  gl.disable(gl.SCISSOR_TEST);
  /* clearBufferfv, NOT clearColor+clear: this runs mid-frame and must not

     leave a different clear colour behind for whoever clears next. */
  gl.clearBufferfv(gl.COLOR,0,VOL_ZERO4);
  gl.disable(gl.DEPTH_TEST);
  gl.depthMask(false);
  gl.enable(gl.CULL_FACE);
  gl.cullFace(gl.FRONT);                 // rasterise BACK faces: works inside the box too
  gl.enable(gl.BLEND);
  gl.blendFunc(gl.ONE,gl.ONE_MINUS_SRC_ALPHA);   // premultiplied over: what the march emits

  gl.useProgram(volProg);
  gl.bindBuffer(gl.ARRAY_BUFFER,volInstVBO);
  gl.bufferSubData(gl.ARRAY_BUFFER,0,volInstData,0,n*VOL_INST_FLOATS);

  gl.activeTexture(gl.TEXTURE12); gl.bindTexture(gl.TEXTURE_3D,volNoiseTex);
  gl.activeTexture(gl.TEXTURE4);  gl.bindTexture(gl.TEXTURE_2D,aoDepth);
  gl.activeTexture(gl.TEXTURE0+VOL_DRIVER_UNIT); gl.bindTexture(gl.TEXTURE_2D,volDriverTex);
  const trailDriverTex=typeof mfOrdnanceTrailDriverTexture==='function'?mfOrdnanceTrailDriverTexture():null;
  gl.activeTexture(gl.TEXTURE11);gl.bindTexture(gl.TEXTURE_2D,trailDriverTex);
  const trailHistoryTex=curveTrail?volFxTrailHistoryTexture():null;
  gl.activeTexture(gl.TEXTURE10);gl.bindTexture(gl.TEXTURE_2D,trailHistoryTex);
  gl.uniform1i(volU.uNoise,12);
  gl.uniform1i(volU.uDep,4);
  gl.uniform1i(volU.uDriver,VOL_DRIVER_UNIT);
  gl.uniform1f(volU.uDriverReady,volDriverReady?1:0);
  gl.uniform1i(volU.uTrailDriver,11);
  gl.uniform1f(volU.uTrailDriverReady,trailDriverTex?1:0);
  gl.uniform1i(volU.uTrailHistory,10);
  gl.uniform1f(volU.uTrailHistoryReady,trailHistoryTex?1:0);
  VOLFX_TELEMETRY.trailHistoryReady=!!trailHistoryTex;
  VOLFX_TELEMETRY.trailDriverReady=!!trailDriverTex;
  gl.uniformMatrix4fv(volU.uVP,false,matVP);
  gl.uniform3f(volU.uRayDir,volRayX,volRayY,volRayZ);

  const sd=(Sun&&Sun.dir)?Sun.dir:[0.4,0.8,0.45];
  const sc=(Sun&&Sun.col)?Sun.col:[1,0.95,0.86];
  const sk=(Sun&&Sun.sky)?Sun.sky:[0.4,0.45,0.55];
  const gn=(Sun&&Sun.gnd)?Sun.gnd:[0.22,0.22,0.25];
  gl.uniform3f(volU.uSunDir,sd[0],sd[1],sd[2]);
  gl.uniform3f(volU.uSunCol,sc[0],sc[1],sc[2]);
  gl.uniform3f(volU.uAmbSky,sk[0],sk[1],sk[2]);
  gl.uniform3f(volU.uAmbGnd,gn[0],gn[1],gn[2]);
  gl.uniform3f(volU.uWind,0.35,0,0.18);
  gl.uniform2f(volU.uInvVolSize,1/volW,1/volH);
  gl.uniform1f(volU.uWorldPerPx,Math.max(.24,(typeof orthoSpan==='number'?orthoSpan:500)/Math.max(1,typeof VH==='number'?VH:852)));
  /* 15000 = far - near from m4ortho(-6000, 9000) in camUpdateMatrices

     (mesh.js:3277). FSAO hardcodes the same constant as uWorldPerZ at

     mesh.js:2611. COUPLING: change the ortho near/far and BOTH must change. */
  gl.uniform1f(volU.uDepthScale,15000.0);
  /* Extinction. 0.055 marched to a translucent film that read as a flat

     layer, not a mass — the frame-02 critique. 0.12 puts real optical depth

     in the interior: the silhouette occludes, the blackbody core still burns

     through the thin pockets, and the sun-side/far-side probe shading above

     has something to bite on. */
  gl.uniform1f(volU.uSigma,0.12);
  /* Henyey-Greenstein is a per-frame CONSTANT under ortho (both uRayDir and

     uSunDir are constant), so it is evaluated once here instead of per step —

     a genuine orthographic win. DUAL LOBE: this camera looks DOWN at smoke

     lit from ABOVE, i.e. permanent backscatter geometry, and a single

     forward lobe (g=0.35) evaluated there starved the sun term to ~0.2 and

     the whole volume went black. Real soot backscatters (multiple

     scattering folded into a negative-g lobe), so mix a forward and a

     backward lobe the way every dual-lobe HG media model does. */
  {
    const cosT=volRayX*sd[0]+volRayY*sd[1]+volRayZ*sd[2];
    const HG=(g)=>(1-g*g)/Math.pow(Math.max(1e-3,1+g*g-2*g*cosT),1.5);
    gl.uniform1f(volU.uPhase,0.5*(0.65*HG(0.5)+0.35*HG(-0.2)));
  }
  gl.uniform1f(volU.uTime,volTime);
  gl.uniform1f(volU.uWaterOn,(typeof waterIdxCount!=='undefined'&&waterIdxCount>0)?1:0);
  gl.uniform1f(volU.uWaterY,(typeof WATER_Y!=='undefined')?WATER_Y:0);
  gl.uniform1i(volU.uSteps,steps);

  gl.bindVertexArray(volVAO);
  gl.drawArraysInstanced(gl.TRIANGLES,0,36,n);
  gl.bindVertexArray(null);
  gl.bindBuffer(gl.ARRAY_BUFFER,null);

  /* ================= PHASE B — composite into aoFB2 =====================

     aoDepth IS attached to aoFB2 and the bilateral upsample samples it: that

     is a framebuffer feedback loop. csmApply has the identical situation and

     records the consequence at mesh.js:3052-3055 — "ANGLE D3D11 returns

     INVALID_OPERATION (1282) and the multiply is undefined". Detach, draw,

     RE-ATTACH; the re-attach is mandatory because the additive effects block

     (render3d.js:2166) and the billboard pass both depth-test against it. */
  gl.bindFramebuffer(gl.FRAMEBUFFER,aoFB2);
  gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.DEPTH_ATTACHMENT,gl.TEXTURE_2D,null,0);
  gl.viewport(0,0,aoW,aoH);
  const compPad=6;
  const compSX=Math.max(0,Math.floor(compX0)-compPad),compSY=Math.max(0,Math.floor(compY0)-compPad);
  const compEX=Math.min(aoW,Math.ceil(compX1)+compPad),compEY=Math.min(aoH,Math.ceil(compY1)+compPad);
  compSW=Math.max(0,compEX-compSX);compSH=Math.max(0,compEY-compSY);
  gl.enable(gl.SCISSOR_TEST);
  gl.scissor(compSX,compSY,compSW,compSH);
  /* CULLING OFF FOR THE COMPOSITE. Phase A left cullFace(FRONT) so the box

     BACK faces rasterise. The fullscreen triangle is wound CCW, i.e. FRONT

     facing, so leaving that state on culls the composite entirely: volTex

     fills correctly, the draw reports no GL error, and absolutely nothing

     reaches aoColB. Measured exactly that — 719 non-zero half-res texels in

     volTex against a 0-pixel delta in aoColB. aoResolve disables culling

     around its own fullscreen triangle for the same reason (mesh.js:2596). */
  gl.disable(gl.CULL_FACE);
  gl.useProgram(volProgUp);
  gl.activeTexture(gl.TEXTURE13); gl.bindTexture(gl.TEXTURE_2D,volTex);
  gl.activeTexture(gl.TEXTURE4);  gl.bindTexture(gl.TEXTURE_2D,aoDepth);
  gl.uniform1i(volUup.uVol,13);
  gl.uniform1i(volUup.uDep,4);
  gl.uniform2f(volUup.uVolSize,volW,volH);
  gl.uniform2f(volUup.uInvVolSize,1/volW,1/volH);
  gl.uniform1f(volUup.uDepthScale,15000.0);
  gl.uniform1f(volUup.uBilateral,volBilateral?1:0);
  gl.blendFunc(gl.ONE,gl.ONE_MINUS_SRC_ALPHA);
  gl.bindVertexArray(volEmptyVAO);
  gl.drawArrays(gl.TRIANGLES,0,3);
  gl.bindVertexArray(null);
  gl.disable(gl.SCISSOR_TEST);
  gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.DEPTH_ATTACHMENT,gl.TEXTURE_2D,aoDepth,0);
  /* EVERY input this pass depends on must still be real, the composite must

     have covered a positive area, and the driver must report NO_ERROR. Any one

     of these failing means the frame did not actually put a volume on screen,

     and claiming presentation would suppress the armed flipbook as well —

     leaving the detonation invisible. Draw-time gl.getError() is read here

     rather than under a debug flag because it is the only signal that

     separates "composited" from "silently produced nothing". */
  composited=(compSW>0&&compSH>0)
    &&!!volProg&&!!volProgUp&&!!volVAO&&!!volEmptyVAO&&!!volInstVBO
    &&!!volNoiseTex&&!!volDriverTex&&!!volTex&&!!volFB&&(!curveTrail||!!trailHistoryTex)
    &&(typeof aoDepth!=='undefined'&&!!aoDepth)
    &&gl.getError()===gl.NO_ERROR;

  }catch(e){
    composited=false;
    VOLFX_TELEMETRY.lastError='draw: '+String(e&&e.message||e).slice(0,150);
  }finally{
    /* Depth goes back FIRST and unconditionally: everything downstream of this

       pass depth-tests against aoDepth. */
    try{
      gl.bindFramebuffer(gl.FRAMEBUFFER,aoFB2);
      gl.framebufferTexture2D(gl.FRAMEBUFFER,gl.DEPTH_ATTACHMENT,gl.TEXTURE_2D,aoDepth,0);
    }catch(_){}
    gl.bindFramebuffer(gl.FRAMEBUFFER,wasFB);
    gl.viewport(wasVP[0],wasVP[1],wasVP[2],wasVP[3]);
    gl.scissor(wasScBox[0],wasScBox[1],wasScBox[2],wasScBox[3]);
    if(wasScissor) gl.enable(gl.SCISSOR_TEST); else gl.disable(gl.SCISSOR_TEST);
    gl.activeTexture(gl.TEXTURE12); gl.bindTexture(gl.TEXTURE_3D,null);
    gl.activeTexture(gl.TEXTURE10); gl.bindTexture(gl.TEXTURE_2D,wasTex10);
    gl.activeTexture(gl.TEXTURE11); gl.bindTexture(gl.TEXTURE_2D,wasTex11);
    gl.activeTexture(gl.TEXTURE13); gl.bindTexture(gl.TEXTURE_2D,wasTex13);
    gl.activeTexture(gl.TEXTURE0+VOL_DRIVER_UNIT); gl.bindTexture(gl.TEXTURE_2D,wasTexDriver);
    gl.activeTexture(gl.TEXTURE4);  gl.bindTexture(gl.TEXTURE_2D,wasTex4);
    gl.activeTexture(gl.TEXTURE0);  gl.bindTexture(gl.TEXTURE_2D,wasTex0);
    gl.activeTexture(wasActive);
    gl.bindVertexArray(wasVAO);
    gl.bindBuffer(gl.ARRAY_BUFFER,wasArr);
    gl.useProgram(wasProg);
    gl.cullFace(wasCullMode);
    gl.blendFuncSeparate(wasSrcRGB,wasDstRGB,wasSrcA,wasDstA);
    gl.blendEquationSeparate(wasEqRGB,wasEqA);
    if(wasDepth) gl.enable(gl.DEPTH_TEST); else gl.disable(gl.DEPTH_TEST);
    if(wasCull) gl.enable(gl.CULL_FACE); else gl.disable(gl.CULL_FACE);
    if(wasBlend) gl.enable(gl.BLEND); else gl.disable(gl.BLEND);
    gl.depthMask(wasMask);
  }

  /* ATOMIC PRESENTATION. A partial pass claims nothing, so render3d reveals

     exactly one armed flipbook instead of showing both or neither. */
  if(!composited){ volPresented.fill(0); VOLFX_TELEMETRY.drawn=0; VOLFX_TELEMETRY.driverSamples=0; return; }
  for(let s=0;s<n;s++){
    const i=volOrder[s];volPresented[i]=1;
    if(volKind[i]===VOL_BLAST)VOLFX_TELEMETRY.presentedBlast++;
    else if(volKind[i]===VOL_DUST)VOLFX_TELEMETRY.presentedDust++;
    else if(volKind[i]===VOL_IMPACT)VOLFX_TELEMETRY.presentedImpact++;
    else if(volKind[i]===VOL_TRAIL_ENERGY||volKind[i]===VOL_TRAIL_CURVE_ENERGY)VOLFX_TELEMETRY.presentedTrailEnergy++;
    else if(volKind[i]===VOL_TRAIL_SHELL||volKind[i]===VOL_TRAIL_CURVE_SHELL)VOLFX_TELEMETRY.presentedTrailShell++;
  }
  VOLFX_TELEMETRY.drawn=n;
  VOLFX_TELEMETRY.steps=steps;
  VOLFX_TELEMETRY.budget=budget;
  VOLFX_TELEMETRY.marchedPx=area;
  VOLFX_TELEMETRY.compositePx=compSW*compSH;
  VOLFX_TELEMETRY.w=volW; VOLFX_TELEMETRY.h=volH;
  if(volCheckErr) VOLFX_TELEMETRY.glErr=gl.getError();
}

/* The camera ray under ortho: view-forward is the NEGATION of the third row of

   m4look's basis (mesh.js:54-56), which is matV[2], matV[6], matV[10].

   Recomputed once per frame in volFxDraw's caller order — cheap enough to just

   do it at the top of the draw. */
let volRayX=0, volRayY=-1, volRayZ=0;
let volBilateral=true;
let volCheckErr=false;
function volFxSyncRay(){
  if(typeof matV==='undefined'||!matV) return;
  let x=-matV[2], y=-matV[6], z=-matV[10];
  const l=Math.hypot(x,y,z)||1;
  volRayX=x/l; volRayY=y/l; volRayZ=z/l;
}
function volSmooth(a,b,x){
  const t=Math.max(0,Math.min(1,(x-a)/((b-a)||1e-6)));
  return t*t*(3-2*t);
}

/* Probe knobs. These exist so the design's bring-up controls are runnable

   without editing this file: each one is a single uniform or preset value, and

   none of them forks a code path.

     volFxSetBilateral(false)  -> 1-fetch upsample (the degraded rung)

     volFxSetErrCheck(true)    -> read gl.getError() into telemetry each frame

     volFxDebugBurst(...)      -> queue a volume without the sim  */
function volFxSetBilateral(on){ volBilateral=!!on; }
function volFxSetErrCheck(on){ volCheckErr=!!on; }
function volFxDebugBurst(x,y,worldY,kind,radius,opts){ return volFxBurst(x,y,worldY,kind,radius,opts); }
function volFxDebugTrail(x0,z0,y0,x1,z1,y1,kind,opts){
  const o=opts||{},k=kind|0;if(k!==VOL_TRAIL_ENERGY&&k!==VOL_TRAIL_SHELL)return [];
  const count=10,arc=Number.isFinite(o.arc)?o.arc:150,life=o.life>0?o.life:8,age=Math.max(0,Math.min(.9,Number(o.age)||.18));
  const headQ=Math.max(.08,Math.min(1,Number.isFinite(o.headQ)?o.headQ:.86));
  const span=Math.max(.08,Math.min(headQ,Number.isFinite(o.span)?o.span:(k===VOL_TRAIL_ENERGY?.62:.54)));
  const qStart=headQ-span;
  const tint=o.tint||(k===VOL_TRAIL_ENERGY?[96,220,255]:[255,118,38]),ids=[];
  const point=(q)=>[x0+(x1-x0)*q,y0+(y1-y0)*q+Math.sin(q*Math.PI)*arc,z0+(z1-z0)*q];
  for(let j=0;j<count;j++){
    const q0=qStart+span*(j/count),q1=qStart+span*((j+1)/count);
    const u0=j/count,u1=(j+1)/count,a=point(q0),b=point(q1);
    /* Deposited shell exhaust leaves the ballistic centreline. Its oldest
       samples rise and move with a restrained cross-wind while the hot end
       remains attached to the shell. This is deterministic history shaping,
       not render-loop emission. */
    if(k===VOL_TRAIL_SHELL){
      const wa=(1-u0)*(1-u0),wb=(1-u1)*(1-u1);
      a[0]+=wa*8.0;a[1]+=wa*13.0;a[2]-=wa*5.0;
      b[0]+=wb*8.0;b[1]+=wb*13.0;b[2]-=wb*5.0;
    }
    const dx=b[0]-a[0],dy=b[1]-a[1],dz=b[2]-a[2];
    const q=(j+.5)/count,thick=k===VOL_TRAIL_ENERGY?7.0:16.0-q*8.0;
    const segLen=Math.hypot(dx,dy,dz),ux=dx/segLen,uy=dy/segLen,uz=dz/segLen;
    /* Twelve percent overlap at both ends closes filtering/jitter cracks while
       keeping ten independently culled proxies for the curved history. */
    const halfLen=segLen*.62;
    const ex=Math.abs(ux)*halfLen+thick,ey=Math.abs(uy)*halfLen+thick,ez=Math.abs(uz)*halfLen+thick;
    const s=volFxBurst((a[0]+b[0])*.5,(a[2]+b[2])*.5,(a[1]+b[1])*.5,k,1,{
      life,rise:0,dens:(o.dens||(k===VOL_TRAIL_ENERGY?1.42:1.55))*(0.58+0.42*q),
      emis:(o.emis||(k===VOL_TRAIL_ENERGY?1.65:.92))*(0.72+0.28*q),
      direction:[dx,dz],aspect:[ex,ey,ez],trailAxis:[ux,uy,uz],trailHalf:halfLen,
      tint,style:j,seed:(o.seed||7.25)%64
    });
    if(s>=0){volT[s]=age*life;ids.push(s);}
  }
  return ids;
}

/* Self-initialise at the end of our own file. There is no GL context at load

   time, so this only primes the ray basis and the epoch latch; the programs,

   buffers and 3D noise are built lazily on first use, exactly like gpfxInit.

   The bundle gate (tools/bundle.mjs:91) requires a file that declares init

   functions to call one of them here rather than relying on main.js. */
function volFxBoot(){
  volEpoch=-1;
  volInitFailed=false;
  volN=0;
  volFxSyncRay();
}
volFxBoot();