@adatechnology/game-vfx-three 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,1796 +1,25 @@
-// src/renderer.ts
-import { markKitOrigin } from "@adatechnology/game-contracts";
-import { colorOfChunk, createVfx, hexToLinearRgb } from "@adatechnology/game-vfx";
-
-// src/shaders/glow.ts
-var GLOW_VERTEX = `attribute vec4 aP;attribute vec4 aC;varying vec2 vU;varying vec4 vC;
-void main(){vec3 R=vec3(viewMatrix[0][0],viewMatrix[1][0],viewMatrix[2][0]);vec3 Up=vec3(viewMatrix[0][1],viewMatrix[1][1],viewMatrix[2][1]);
-vec3 wp=aP.xyz+(R*position.x+Up*position.y)*aP.w;vU=position.xy;vC=aC;gl_Position=projectionMatrix*viewMatrix*vec4(wp,1.);}`;
-var GLOW_FRAGMENT = `varying vec2 vU;varying vec4 vC;void main(){float r=dot(vU,vU);if(r>1.)discard;float f=exp(-r*4.2)-.015;gl_FragColor=vec4(vC.rgb*vC.a*max(f,0.),1.);
-  #include <tonemapping_fragment>
-  #include <colorspace_fragment>
-}`;
-
-// src/shaders/noise.ts
-var GL_NOISE = `
-float h3(vec3 p){p=fract(p*.3183099+.1);p*=17.0;return fract(p.x*p.y*p.z*(p.x+p.y+p.z));}
-float vn(vec3 x){vec3 i=floor(x),f=fract(x);f=f*f*(3.-2.*f);
- return mix(mix(mix(h3(i),h3(i+vec3(1,0,0)),f.x),mix(h3(i+vec3(0,1,0)),h3(i+vec3(1,1,0)),f.x),f.y),
-            mix(mix(h3(i+vec3(0,0,1)),h3(i+vec3(1,0,1)),f.x),mix(h3(i+vec3(0,1,1)),h3(i+vec3(1,1,1)),f.x),f.y),f.z);}
-`;
-
-// src/shaders/puff.ts
-var PUFF_VERTEX = `${GL_NOISE}
-attribute vec4 aP;attribute vec4 aD;attribute vec3 aC;
-varying vec3 vWP;varying vec3 vL;varying vec4 vD;varying vec3 vC;
-void main(){
-  vec3 p=position;
-  float s=aD.z;
-  float n=vn(p*1.6+vec3(s*11.0,s*7.0,s*3.0));
-  p*=0.78+0.5*n;
-  float a=s*6.2831;float c=cos(a),si=sin(a);p.xz=mat2(c,-si,si,c)*p.xz;
-  vL=p;
-  vec3 wp=aP.xyz+p*aP.w;
-  vWP=wp;vD=aD;vC=aC;
-  gl_Position=projectionMatrix*viewMatrix*vec4(wp,1.0);
-}`;
-var PUFF_FRAGMENT = `${GL_NOISE}
-uniform vec3 uLight;uniform vec3 uSky;uniform vec3 uGround;uniform vec3 uGlowPos;uniform vec3 uGlowCol;uniform float uGlowI;
-varying vec3 vWP;varying vec3 vL;varying vec4 vD;varying vec3 vC;
-vec3 L(vec3 c){return pow(c,vec3(2.2));}
-vec3 ramp(float h){
-  vec3 c0=L(vec3(.36,.07,.03)),c1=L(vec3(.76,.21,.1)),c2=L(vec3(1.,.54,.16)),c3=L(vec3(1.,.83,.42)),c4=L(vec3(1.,.96,.84));
-  if(h<.25)return mix(c0,c1,h/.25);
-  if(h<.5)return mix(c1,c2,(h-.25)/.25);
-  if(h<.8)return mix(c2,c3,(h-.5)/.3);
-  return mix(c3,c4,clamp((h-.8)/.4,0.,1.));
-}
-void main(){
-  vec3 N=normalize(cross(dFdx(vWP),dFdy(vWP)));
-  float age=vD.x,heat=vD.y,kind=vD.w;
-  float n=vn(vL*2.4+vD.z*13.0);
-  float diss=smoothstep(.5,1.,age);
-  if(n<diss*1.08-.04)discard;
-  float lam=max(dot(N,uLight),0.);
-  float band=lam>.55?1.:lam>.15?.68:.42;
-  vec3 col=vC*(vec3(.5,.56,.7)*band*1.05+vec3(.2,.19,.18)+uGround*(.4-.4*N.y));
-  vec3 tg=uGlowPos-vWP;float dg=length(tg)+.001;
-  float gi=uGlowI/(1.+dg*dg*.05)*(.3+.7*max(dot(N,tg/dg),0.));
-  col+=uGlowCol*gi*vC*1.6;
-  float h=heat*(.72+.56*n)+heat*(-N.y)*.18;
-  if(h>.05){
-    float hq=floor(h*5.+.5)/5.;
-    vec3 fc=ramp(clamp(hq,0.,1.2))*(1.1+3.1*hq);
-    col=mix(col,fc,smoothstep(.04,.2,h));
-  }
-  if(kind>2.5&&kind<3.5){col+=vec3(.02,.025,.03);}
-  gl_FragColor=vec4(col,1.);
-  #include <tonemapping_fragment>
-  #include <colorspace_fragment>
-}`;
-
-// src/shaders/spark.ts
-var SPARK_VERTEX = `
-attribute vec3 aPos;attribute vec3 aVel;attribute vec4 aE;varying vec2 vU;varying vec4 vE;
-void main(){
-  float sp=length(aVel)+1e-4;vec3 d=aVel/sp;
-  vec3 tc=normalize(cameraPosition-aPos);
-  vec3 sd=normalize(cross(d,tc)+vec3(1e-5));
-  float len=max(aE.y*2.5,min(sp*aE.z,2.2));
-  vec3 wp=aPos+sd*position.x*aE.y-d*position.y*len;
-  vU=position.xy;vE=aE;
-  gl_Position=projectionMatrix*viewMatrix*vec4(wp,1.);
-}`;
-var SPARK_FRAGMENT = `
-varying vec2 vU;varying vec4 vE;
-void main(){
-  float age=vE.x,k=vE.w;
-  float w=1.-abs(vU.x)*2.;w=w*w;
-  float tail=1.-vU.y;
-  vec3 c;
-  if(k<.5){c=mix(vec3(4.,3.3,2.2),vec3(2.4,.7,.12),smoothstep(0.,.55,age));c=mix(c,vec3(.5,.06,.02),smoothstep(.55,1.,age));}
-  else if(k<1.5){c=mix(vec3(1.6,1.6,1.6),vec3(.35,.35,.36),smoothstep(0.,.4,age));}
-  else if(k<2.5){c=mix(vec3(5.,5.,6.),vec3(1.,1.3,2.),smoothstep(0.,.5,age));}
-  else if(k<3.5){c=vec3(.9,1.2,1.4)*(1.-age);}
-  else {c=mix(vec3(3.2,1.4,.3),vec3(1.2,.25,.05),age);}
-  float a=w*(.35+.65*tail)*(1.-smoothstep(.75,1.,age));
-  gl_FragColor=vec4(c*a,1.);
-  #include <tonemapping_fragment>
-  #include <colorspace_fragment>
-}`;
-
-// src/instanced.ts
-function dynamic(THREE, array, size) {
-  return new THREE.InstancedBufferAttribute(array, size).setUsage(THREE.DynamicDrawUsage);
-}
-function createPuffLayer(THREE, pool, uniforms) {
-  const capacity = pool.capacity;
-  const geometry = new THREE.InstancedBufferGeometry();
-  geometry.setAttribute("position", new THREE.IcosahedronGeometry(1, 1).getAttribute("position"));
-  const a = new Float32Array(capacity * 4);
-  const d = new Float32Array(capacity * 4);
-  const c = new Float32Array(capacity * 3);
-  const attributes = [dynamic(THREE, a, 4), dynamic(THREE, d, 4), dynamic(THREE, c, 3)];
-  geometry.setAttribute("aP", attributes[0]);
-  geometry.setAttribute("aD", attributes[1]);
-  geometry.setAttribute("aC", attributes[2]);
-  geometry.instanceCount = 0;
-  const material = new THREE.ShaderMaterial({ uniforms, vertexShader: PUFF_VERTEX, fragmentShader: PUFF_FRAGMENT });
-  const mesh = new THREE.Mesh(geometry, material);
-  mesh.name = "vfx-puffs";
-  mesh.frustumCulled = false;
-  return {
-    mesh,
-    sync() {
-      let n = 0;
-      for (const p of pool.items) {
-        a[n * 4] = p.x;
-        a[n * 4 + 1] = p.y;
-        a[n * 4 + 2] = p.z;
-        a[n * 4 + 3] = p.size;
-        d[n * 4] = p.age;
-        d[n * 4 + 1] = p.heat;
-        d[n * 4 + 2] = p.seed;
-        d[n * 4 + 3] = p.kind;
-        c[n * 3] = p.color[0];
-        c[n * 3 + 1] = p.color[1];
-        c[n * 3 + 2] = p.color[2];
-        n++;
-      }
-      geometry.instanceCount = n;
-      for (const attribute of attributes) attribute.needsUpdate = true;
-      return n;
-    },
-    dispose() {
-      geometry.dispose();
-      material.dispose();
-    }
-  };
-}
-function createSparkLayer(THREE, pool) {
-  const capacity = pool.capacity;
-  const geometry = new THREE.InstancedBufferGeometry();
-  geometry.setAttribute("position", new THREE.Float32BufferAttribute([-0.5, 0, 0, 0.5, 0, 0, 0.5, 1, 0, -0.5, 1, 0], 3));
-  geometry.setIndex([0, 1, 2, 0, 2, 3]);
-  const position = new Float32Array(capacity * 3);
-  const velocity = new Float32Array(capacity * 3);
-  const extra = new Float32Array(capacity * 4);
-  const attributes = [dynamic(THREE, position, 3), dynamic(THREE, velocity, 3), dynamic(THREE, extra, 4)];
-  geometry.setAttribute("aPos", attributes[0]);
-  geometry.setAttribute("aVel", attributes[1]);
-  geometry.setAttribute("aE", attributes[2]);
-  geometry.instanceCount = 0;
-  const material = new THREE.ShaderMaterial({ transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, vertexShader: SPARK_VERTEX, fragmentShader: SPARK_FRAGMENT });
-  const mesh = new THREE.Mesh(geometry, material);
-  mesh.name = "vfx-sparks";
-  mesh.frustumCulled = false;
-  mesh.renderOrder = 5;
-  return {
-    mesh,
-    sync() {
-      let n = 0;
-      for (const s of pool.items) {
-        position[n * 3] = s.x;
-        position[n * 3 + 1] = s.y;
-        position[n * 3 + 2] = s.z;
-        velocity[n * 3] = s.vx;
-        velocity[n * 3 + 1] = s.vy;
-        velocity[n * 3 + 2] = s.vz;
-        extra[n * 4] = s.age;
-        extra[n * 4 + 1] = s.w;
-        extra[n * 4 + 2] = s.st;
-        extra[n * 4 + 3] = s.kind;
-        n++;
-      }
-      geometry.instanceCount = n;
-      for (const attribute of attributes) attribute.needsUpdate = true;
-      return n;
-    },
-    dispose() {
-      geometry.dispose();
-      material.dispose();
-    }
-  };
-}
-function createGlowLayer(THREE, pool) {
-  const capacity = pool.capacity;
-  const geometry = new THREE.InstancedBufferGeometry();
-  geometry.setAttribute("position", new THREE.Float32BufferAttribute([-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0], 3));
-  geometry.setIndex([0, 1, 2, 0, 2, 3]);
-  const where = new Float32Array(capacity * 4);
-  const color = new Float32Array(capacity * 4);
-  const attributes = [dynamic(THREE, where, 4), dynamic(THREE, color, 4)];
-  geometry.setAttribute("aP", attributes[0]);
-  geometry.setAttribute("aC", attributes[1]);
-  geometry.instanceCount = 0;
-  const material = new THREE.ShaderMaterial({ transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, vertexShader: GLOW_VERTEX, fragmentShader: GLOW_FRAGMENT });
-  const mesh = new THREE.Mesh(geometry, material);
-  mesh.name = "vfx-glows";
-  mesh.frustumCulled = false;
-  mesh.renderOrder = 6;
-  return {
-    mesh,
-    sync() {
-      let n = 0;
-      for (const g of pool.items) {
-        where[n * 4] = g.outX;
-        where[n * 4 + 1] = g.outY;
-        where[n * 4 + 2] = g.outZ;
-        where[n * 4 + 3] = g.outSize;
-        color[n * 4] = g.color[0];
-        color[n * 4 + 1] = g.color[1];
-        color[n * 4 + 2] = g.color[2];
-        color[n * 4 + 3] = g.outIntensity;
-        n++;
-      }
-      geometry.instanceCount = n;
-      for (const attribute of attributes) attribute.needsUpdate = true;
-      return n;
-    },
-    dispose() {
-      geometry.dispose();
-      material.dispose();
-    }
-  };
-}
-function createChunkLayer(THREE, pool, shapes, colorOf) {
-  const capacity = pool.capacity;
-  const rockMaterial = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.85, flatShading: true });
-  const plateMaterial = rockMaterial.clone();
-  const make = (geometry, material) => {
-    const mesh = new THREE.InstancedMesh(geometry, material, capacity);
-    mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-    mesh.castShadow = true;
-    mesh.receiveShadow = true;
-    mesh.frustumCulled = false;
-    mesh.count = 0;
-    mesh.setColorAt(0, new THREE.Color(1, 1, 1));
-    return mesh;
-  };
-  const rocks = make(shapes.rock, rockMaterial);
-  const plates = make(shapes.plate, plateMaterial);
-  const matrix = new THREE.Matrix4();
-  const quaternion = new THREE.Quaternion();
-  const euler = new THREE.Euler();
-  const position = new THREE.Vector3();
-  const scale = new THREE.Vector3();
-  return {
-    rocks,
-    plates,
-    sync() {
-      let rockCount = 0;
-      let plateCount = 0;
-      for (const chunk of pool.items) {
-        euler.set(chunk.rx, chunk.ry, chunk.rz);
-        quaternion.setFromEuler(euler);
-        matrix.compose(position.set(chunk.x, chunk.y, chunk.z), quaternion, scale.set(chunk.sx, chunk.sy, chunk.sz));
-        const mesh = chunk.plate ? plates : rocks;
-        const index = chunk.plate ? plateCount++ : rockCount++;
-        mesh.setMatrixAt(index, matrix);
-        const color = colorOf(chunk);
-        const colors = mesh.instanceColor.array;
-        colors[index * 3] = color[0];
-        colors[index * 3 + 1] = color[1];
-        colors[index * 3 + 2] = color[2];
-      }
-      rocks.count = rockCount;
-      plates.count = plateCount;
-      for (const mesh of [rocks, plates]) {
-        mesh.instanceMatrix.needsUpdate = true;
-        mesh.instanceColor.needsUpdate = true;
-      }
-      return rockCount + plateCount;
-    },
-    dispose() {
-      rockMaterial.dispose();
-      plateMaterial.dispose();
-      rocks.dispose();
-      plates.dispose();
-    }
-  };
-}
-
-// src/lights.ts
-function createLightLayer(THREE, pool, scale) {
-  const group = new THREE.Group();
-  const blast = pool.blast.map(() => {
-    const light = new THREE.PointLight(16752720, 0, 30, 2);
-    light.position.set(0, -50, 0);
-    group.add(light);
-    return light;
-  });
-  const fire = pool.fire.map(() => {
-    const light = new THREE.PointLight(16742954, 0, 16, 2);
-    light.position.set(0, -50, 0);
-    group.add(light);
-    return light;
-  });
-  return {
-    group,
-    sync() {
-      let lit = 0;
-      pool.blast.forEach((entry, index) => {
-        const light = blast[index];
-        light.position.set(entry.x, entry.y, entry.z);
-        light.distance = entry.distance;
-        light.color.setRGB(entry.color[0], entry.color[1], entry.color[2], THREE.LinearSRGBColorSpace);
-        light.intensity = entry.intensity * scale;
-        if (entry.intensity > 0.05) lit++;
-      });
-      pool.fire.forEach((entry, index) => {
-        const light = fire[index];
-        light.position.set(entry.x, entry.y, entry.z);
-        light.distance = entry.distance;
-        light.intensity = entry.intensity * scale;
-        if (entry.intensity > 0.05) lit++;
-      });
-      return lit;
-    },
-    dispose() {
-      for (const light of [...blast, ...fire]) light.dispose();
-    }
-  };
-}
-
-// src/canvas.ts
-import { lehmer } from "@adatechnology/game-vfx";
-var SCORCH_SEED = 5;
-var TEXTURE_SIZE = 256;
-var FULL_TURN = Math.PI * 2;
-function createTextureStream() {
-  return lehmer(SCORCH_SEED);
-}
-function blankCanvas() {
-  return { width: 0, height: 0, getContext: () => null };
-}
-function defaultCanvas() {
-  if (typeof document === "undefined") return blankCanvas();
-  return document.createElement("canvas");
-}
-function paint(createCanvas, draw) {
-  const canvas = createCanvas();
-  canvas.width = TEXTURE_SIZE;
-  canvas.height = TEXTURE_SIZE;
-  const context = canvas.getContext("2d");
-  if (context) draw(context, TEXTURE_SIZE);
-  return canvas;
-}
-function drawScorch(context, size, random) {
-  context.clearRect(0, 0, size, size);
-  const center = size / 2;
-  for (let ray = 0; ray < 60; ray++) {
-    const angle = random.next() * FULL_TURN;
-    const length = center * (0.55 + random.next() * 0.42);
-    context.strokeStyle = `rgba(8,6,5,${0.25 + random.next() * 0.35})`;
-    context.lineWidth = 2 + random.next() * 6;
-    context.beginPath();
-    context.moveTo(center, center);
-    context.lineTo(center + Math.cos(angle) * length, center + Math.sin(angle) * length);
-    context.stroke();
-  }
-  const gradient = context.createRadialGradient(center, center, 0, center, center, center * 0.72);
-  gradient.addColorStop(0, "rgba(4,3,3,.96)");
-  gradient.addColorStop(0.55, "rgba(10,8,7,.85)");
-  gradient.addColorStop(1, "rgba(14,11,9,0)");
-  context.fillStyle = gradient;
-  context.fillRect(0, 0, size, size);
-  for (let spot = 0; spot < 26; spot++) {
-    context.fillStyle = `rgba(60,40,28,${0.15 + random.next() * 0.2})`;
-    context.beginPath();
-    context.arc(center + random.between(-0.4, 0.4) * center, center + random.between(-0.4, 0.4) * center, 2 + random.next() * 7, 0, 7);
-    context.fill();
-  }
-}
-function drawDirt(context, size, random) {
-  const center = size / 2;
-  context.clearRect(0, 0, size, size);
-  const gradient = context.createRadialGradient(center, center, 0, center, center, center);
-  gradient.addColorStop(0, "rgba(92,72,52,1)");
-  gradient.addColorStop(0.6, "rgba(118,92,64,1)");
-  gradient.addColorStop(0.82, "rgba(80,64,50,.8)");
-  gradient.addColorStop(1, "rgba(40,36,34,0)");
-  context.fillStyle = gradient;
-  context.fillRect(0, 0, size, size);
-  for (let speck = 0; speck < 420; speck++) {
-    const angle = random.next() * FULL_TURN;
-    const distance = Math.sqrt(random.next()) * center * 0.8;
-    context.fillStyle = random.next() < 0.5 ? "rgba(40,30,22,.5)" : "rgba(160,132,96,.5)";
-    context.beginPath();
-    context.arc(center + Math.cos(angle) * distance, center + Math.sin(angle) * distance, 1 + random.next() * 3.5, 0, 7);
-    context.fill();
-  }
-}
-function createMarkTextures(THREE, createCanvas) {
-  const make = createCanvas ?? defaultCanvas;
-  const random = createTextureStream();
-  const texture = (canvas) => {
-    const result = new THREE.CanvasTexture(canvas);
-    result.colorSpace = THREE.SRGBColorSpace;
-    result.anisotropy = 4;
-    return result;
-  };
-  const scorch = [0, 1, 2].map(() => texture(paint(make, (context, size) => drawScorch(context, size, random))));
-  const dirt = texture(paint(make, (context, size) => drawDirt(context, size, random)));
-  return { scorch, dirt };
-}
-
-// src/marks.ts
-var MAX_CONFORM_STEPS = 48;
-var MIN_CONFORM_STEPS = 16;
-var BLOOD_GROW_RATE = 1.2;
-var BLOOD_START_GROWTH = 0.05;
-var DEFAULT_MAX_GROUND_MARKS = 64;
-var DEFAULT_MAX_ROCKS = 512;
-var DEFAULT_MAX_BLOOD = 256;
-var MAX_SPARE_GROUND_GEOMETRIES = 16;
-function createMarkLayer(THREE, options) {
-  const group = new THREE.Group();
-  const textures = createMarkTextures(THREE, options.createCanvas);
-  const owned = [...textures.scorch, textures.dirt];
-  const scorchMaterials = textures.scorch.map((map) => {
-    const material = new THREE.MeshStandardMaterial({ map, transparent: true, depthWrite: false, roughness: 1, polygonOffset: true, polygonOffsetFactor: -2, polygonOffsetUnits: -2 });
-    owned.push(material);
-    return material;
-  });
-  const dirtMaterial = new THREE.MeshStandardMaterial({
-    map: textures.dirt,
-    transparent: true,
-    depthWrite: false,
-    roughness: 1,
-    flatShading: true,
-    polygonOffset: true,
-    polygonOffsetFactor: -1,
-    polygonOffsetUnits: -1
-  });
-  owned.push(dirtMaterial);
-  const bloodMaterial = new THREE.MeshStandardMaterial({ color: 6031882, roughness: 0.15, metalness: 0.1, polygonOffset: true, polygonOffsetFactor: -3, polygonOffsetUnits: -3 });
-  const bloodGeometry = new THREE.CircleGeometry(0.5, 9).rotateX(-Math.PI / 2);
-  owned.push(bloodMaterial, bloodGeometry);
-  const maxGroundMarks = options.maxGroundMarks ?? DEFAULT_MAX_GROUND_MARKS;
-  const instanced = {};
-  function rockMaterial() {
-    if (!instanced.rockMaterial) {
-      instanced.rockMaterial = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.9, metalness: 0, flatShading: true });
-      owned.push(instanced.rockMaterial);
-    }
-    return instanced.rockMaterial;
-  }
-  function bloodMesh() {
-    return instanced.blood ?? (instanced.blood = attach(createInstanced(bloodGeometry, bloodMaterial, options.maxBlood ?? DEFAULT_MAX_BLOOD)));
-  }
-  function rockMesh() {
-    return instanced.rock ?? (instanced.rock = attach(createInstanced(options.rockGeometry, rockMaterial(), options.maxRocks ?? DEFAULT_MAX_ROCKS), true));
-  }
-  function plateMesh() {
-    return instanced.plate ?? (instanced.plate = attach(createInstanced(options.plateGeometry, rockMaterial(), options.maxRocks ?? DEFAULT_MAX_ROCKS), true));
-  }
-  function attach(mesh, castShadow = false) {
-    mesh.castShadow = castShadow;
-    group.add(mesh);
-    return mesh;
-  }
-  const groundMarks = [];
-  const spareGeometries = [];
-  const blood = [];
-  const placed = { blood: 0, rock: 0, plate: 0 };
-  const matrix = new THREE.Matrix4();
-  const position = new THREE.Vector3();
-  const quaternion = new THREE.Quaternion();
-  const euler = new THREE.Euler();
-  const scale = new THREE.Vector3();
-  const color = new THREE.Color();
-  const up = new THREE.Vector3(0, 1, 0);
-  function createInstanced(geometry, material, capacity) {
-    const mesh = new THREE.InstancedMesh(geometry, material, capacity);
-    mesh.count = 0;
-    mesh.frustumCulled = false;
-    mesh.receiveShadow = true;
-    return mesh;
-  }
-  function takeSpare(vertexCount) {
-    const found = spareGeometries.findIndex((geometry) => geometry.getAttribute("position").count === vertexCount);
-    return found < 0 ? void 0 : spareGeometries.splice(found, 1)[0];
-  }
-  function evictOldestGroundMark() {
-    const oldest = groundMarks.shift();
-    group.remove(oldest.mesh);
-    spareGeometries.push(oldest.mesh.geometry);
-    if (spareGeometries.length > MAX_SPARE_GROUND_GEOMETRIES) spareGeometries.shift().dispose();
-  }
-  function conform(mark, material) {
-    const radius = mark.radius;
-    const steps = Math.max(MIN_CONFORM_STEPS, Math.min(MAX_CONFORM_STEPS, Math.round(radius * 8)));
-    if (groundMarks.length >= maxGroundMarks) evictOldestGroundMark();
-    const geometry = takeSpare((steps + 1) * (steps + 1)) ?? new THREE.PlaneGeometry(2, 2, steps, steps).rotateX(-Math.PI / 2);
-    const grid = geometry.attributes.position;
-    const cell = 2 / steps;
-    const cos = Math.cos(mark.rotation);
-    const sin = Math.sin(mark.rotation);
-    for (let index = 0; index < grid.count; index++) {
-      const localX = Math.fround(index % (steps + 1) * cell - 1) * radius;
-      const localZ = Math.fround(Math.floor(index / (steps + 1)) * cell - 1) * radius;
-      const worldX = mark.x + localX * cos - localZ * sin;
-      const worldZ = mark.z + localX * sin + localZ * cos;
-      grid.setXYZ(index, worldX, (options.ground?.heightAt(worldX, worldZ) ?? 0) + mark.lift, worldZ);
-    }
-    grid.needsUpdate = true;
-    geometry.computeVertexNormals();
-    geometry.attributes.normal.needsUpdate = true;
-    geometry.boundingSphere = null;
-    geometry.boundingBox = null;
-    const mesh = new THREE.Mesh(geometry, material);
-    mesh.receiveShadow = true;
-    group.add(mesh);
-    groundMarks.push({ mesh, steps });
-  }
-  function addRock(mark) {
-    const mesh = mark.plate ? plateMesh() : rockMesh();
-    const slot = mark.plate ? "plate" : "rock";
-    const index = placed[slot]++ % mesh.instanceMatrix.count;
-    quaternion.setFromEuler(euler.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]));
-    mesh.setMatrixAt(index, matrix.compose(position.set(mark.x, mark.y, mark.z), quaternion, scale.set(mark.scale[0], mark.scale[1], mark.scale[2])));
-    mesh.setColorAt(index, color.set(mark.color));
-    mesh.count = Math.min(placed[slot], mesh.instanceMatrix.count);
-    mesh.instanceMatrix.needsUpdate = true;
-    mesh.instanceColor.needsUpdate = true;
-  }
-  function writeBlood(index, drawn, growth) {
-    quaternion.setFromAxisAngle(up, drawn.rotation);
-    const mesh = bloodMesh();
-    mesh.setMatrixAt(index, matrix.compose(position.set(drawn.position[0], drawn.position[1], drawn.position[2]), quaternion, scale.set(drawn.scaleX * growth, 1, drawn.scaleZ * growth)));
-    mesh.instanceMatrix.needsUpdate = true;
-  }
-  function addBlood(mark) {
-    const index = placed.blood++ % bloodMesh().instanceMatrix.count;
-    const drawn = { position: [mark.x, mark.y, mark.z], rotation: mark.rotation, scaleX: mark.scaleX, scaleZ: mark.scaleZ, age: 0 };
-    blood[index] = drawn;
-    writeBlood(index, drawn, BLOOD_START_GROWTH);
-    bloodMesh().count = Math.min(placed.blood, bloodMesh().instanceMatrix.count);
-  }
-  function build(mark) {
-    if (mark.kind === "scorch") conform(mark, scorchMaterials[mark.variant]);
-    else if (mark.kind === "dirt") conform(mark, dirtMaterial);
-    else if (mark.kind === "rock") addRock(mark);
-    else addBlood(mark);
-  }
-  function clearMarks() {
-    for (const drawn of groundMarks) group.remove(drawn.mesh);
-    for (const drawn of groundMarks) drawn.mesh.geometry.dispose();
-    groundMarks.length = 0;
-    for (const geometry of spareGeometries) geometry.dispose();
-    spareGeometries.length = 0;
-    blood.length = 0;
-    placed.blood = placed.rock = placed.plate = 0;
-    for (const mesh of [instanced.blood, instanced.rock, instanced.plate]) if (mesh) mesh.count = 0;
-  }
-  return {
-    group,
-    handle(event) {
-      if (event.type === "clear") clearMarks();
-      else build(event.mark);
-    },
-    prepare() {
-      bloodMesh();
-      rockMesh();
-      plateMesh();
-    },
-    update(dt) {
-      for (let index = 0; index < blood.length; index++) {
-        const drawn = blood[index];
-        if (!drawn || drawn.age > 1) continue;
-        drawn.age += dt * BLOOD_GROW_RATE;
-        writeBlood(index, drawn, Math.max(BLOOD_START_GROWTH, 1 - Math.pow(1 - Math.min(1, drawn.age), 2.5)));
-      }
-    },
-    count: () => groundMarks.length + [instanced.blood, instanced.rock, instanced.plate].filter((mesh) => mesh && mesh.count > 0).length,
-    dispose() {
-      clearMarks();
-      for (const mesh of [instanced.blood, instanced.rock, instanced.plate]) mesh?.dispose();
-      for (const item of owned) item.dispose();
-    }
-  };
-}
-
-// src/mesh-layer.ts
-var SPHERE_DEFAULT_WIDTH = 8;
-var SPHERE_DEFAULT_HEIGHT = 6;
-var MAX_PARKED_MESHES_PER_KIND = 256;
-function geometryOf(THREE, particle) {
-  switch (particle.shape) {
-    case "cone":
-      return new THREE.ConeGeometry(1, 1, particle.segments || void 0, particle.segments2 || 1, false);
-    case "cone_open":
-      return new THREE.ConeGeometry(1, 1, particle.segments || void 0, particle.segments2 || 1, true);
-    case "sphere":
-      return new THREE.SphereGeometry(1, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
-    case "icosahedron":
-      return new THREE.IcosahedronGeometry(1, particle.segments);
-  }
-}
-function isCone(particle) {
-  return particle.shape === "cone" || particle.shape === "cone_open";
-}
-function materialOf(THREE, particle) {
-  if (particle.lit) return new THREE.MeshStandardMaterial({ color: particle.color, roughness: 1, metalness: 0, transparent: true, opacity: particle.opacity, depthWrite: false });
-  return new THREE.MeshBasicMaterial({ color: particle.color, transparent: true, opacity: particle.opacity, depthWrite: false, ...particle.additive ? { blending: THREE.AdditiveBlending } : {} });
-}
-function createMeshLayerProbes(THREE) {
-  const geometry = new THREE.BoxGeometry(1e-3, 1e-3, 1e-3);
-  return [{ lit: true, additive: false }, { lit: false, additive: false }, { lit: false, additive: true }].map(
-    (kind) => new THREE.Mesh(geometry, materialOf(THREE, { ...kind, color: 8421504, opacity: 0.5 }))
-  );
-}
-function geometryKeyOf(particle) {
-  return `${particle.shape}:${particle.segments}:${particle.segments2}`;
-}
-function createMeshLayer(THREE, pool) {
-  const group = new THREE.Group();
-  group.name = "workshop-meshes";
-  const drawn = /* @__PURE__ */ new Map();
-  const geometries = /* @__PURE__ */ new Map();
-  const parked = /* @__PURE__ */ new Map();
-  const frame = new THREE.Quaternion();
-  const euler = new THREE.Euler();
-  const turn = new THREE.Quaternion();
-  const offset = new THREE.Vector3();
-  let stamp = 0;
-  function geometryFor(particle) {
-    const key = geometryKeyOf(particle);
-    let geometry = geometries.get(key);
-    if (!geometry) {
-      geometry = geometryOf(THREE, particle);
-      geometries.set(key, geometry);
-    }
-    return geometry;
-  }
-  function acquire(particle) {
-    const parkingKey = `${geometryKeyOf(particle)}|${particle.lit}|${particle.additive}`;
-    const mesh = parked.get(parkingKey)?.pop() ?? new THREE.Mesh(geometryFor(particle), materialOf(THREE, particle));
-    mesh.material.color.set(particle.color);
-    mesh.frustumCulled = false;
-    mesh.renderOrder = particle.additive ? 5 : 3;
-    group.add(mesh);
-    return { mesh, parkingKey, stamp };
-  }
-  function park(entry) {
-    entry.mesh.removeFromParent();
-    let free = parked.get(entry.parkingKey);
-    if (!free) {
-      free = [];
-      parked.set(entry.parkingKey, free);
-    }
-    if (free.length < MAX_PARKED_MESHES_PER_KIND) free.push(entry.mesh);
-    else entry.mesh.material.dispose();
-  }
-  return {
-    group,
-    sync() {
-      stamp++;
-      for (const particle of pool.particles) {
-        let entry = drawn.get(particle.id);
-        if (!entry) {
-          entry = acquire(particle);
-          drawn.set(particle.id, entry);
-        }
-        entry.stamp = stamp;
-        const mesh = entry.mesh;
-        frame.set(particle.frame[0], particle.frame[1], particle.frame[2], particle.frame[3]);
-        offset.set(particle.at[0], particle.at[1], particle.at[2]).multiplyScalar(particle.scale).applyQuaternion(frame);
-        mesh.position.set(particle.x + offset.x, particle.y + offset.y, particle.z + offset.z);
-        turn.setFromEuler(euler.set(particle.rx, particle.ry, particle.rz));
-        mesh.quaternion.copy(frame).multiply(turn);
-        mesh.scale.set(particle.radius * particle.scale, (isCone(particle) ? particle.height : particle.radius) * particle.scale, particle.radius * particle.scale);
-        mesh.material.opacity = particle.opacity;
-      }
-      for (const [id, entry] of drawn) {
-        if (entry.stamp === stamp) continue;
-        park(entry);
-        drawn.delete(id);
-      }
-      return pool.count;
-    },
-    dispose() {
-      for (const entry of drawn.values()) park(entry);
-      drawn.clear();
-      for (const free of parked.values()) for (const mesh of free) mesh.material.dispose();
-      parked.clear();
-      for (const geometry of geometries.values()) geometry.dispose();
-      geometries.clear();
-      group.removeFromParent();
-    }
-  };
-}
-
-// src/screen-overlay.ts
-var clamp = (value, min, max) => value < min ? min : value > max ? max : value;
-function layer(container, name, blend) {
-  const element = container.ownerDocument.createElement("div");
-  element.dataset.vfxOverlay = name;
-  Object.assign(element.style, { position: "absolute", inset: "0", pointerEvents: "none", opacity: "0" });
-  if (blend) element.style.mixBlendMode = blend;
-  container.appendChild(element);
-  return element;
-}
-function createScreenOverlay(container) {
-  const flash = layer(container, "flash", "screen");
-  flash.style.background = "#fff";
-  const white = layer(container, "white");
-  const red = layer(container, "red");
-  const sides = layer(container, "sides");
-  const gas = layer(container, "gas");
-  const elements = [flash, white, red, sides, gas];
-  return {
-    update(state) {
-      flash.style.opacity = clamp(state.flash, 0, 1).toFixed(3);
-      white.style.opacity = "1";
-      white.style.background = `rgba(235,240,255,${clamp(state.white, 0, 1).toFixed(2)})`;
-      red.style.opacity = "1";
-      red.style.background = `radial-gradient(ellipse at center, transparent 40%, rgba(170,16,12,${(clamp(state.red, 0, 1) * 0.85).toFixed(2)}) 100%)`;
-      sides.style.opacity = "1";
-      sides.style.background = `linear-gradient(90deg, rgba(190,20,14,${(state.directionLeft * 0.8).toFixed(2)}) 0%, transparent 35%, transparent 65%, rgba(190,20,14,${(state.directionRight * 0.8).toFixed(2)}) 100%)`;
-      gas.style.opacity = "1";
-      gas.style.background = state.gas > 0.01 ? `rgba(90,130,40,${(state.gas * 0.55).toFixed(2)})` : "transparent";
-    },
-    dispose() {
-      for (const element of elements) element.remove();
-    }
-  };
-}
-
-// src/shaders/shock.ts
-var SHELL_VERTEX = `varying vec3 vN;varying vec3 vV;void main(){vec4 wp=modelMatrix*vec4(position,1.);vN=normalize(mat3(modelMatrix)*normal);vV=normalize(cameraPosition-wp.xyz);gl_Position=projectionMatrix*viewMatrix*wp;}`;
-var SHELL_FRAGMENT = `uniform float uA;varying vec3 vN;varying vec3 vV;void main(){float f=1.-abs(dot(vN,vV));f=pow(f,5.);gl_FragColor=vec4(vec3(1.,.93,.82)*f*uA*.45,1.);
-  #include <tonemapping_fragment>
-  #include <colorspace_fragment>
-}`;
-var RING_VERTEX = `varying vec2 vU;void main(){vU=position.xz;gl_Position=projectionMatrix*viewMatrix*modelMatrix*vec4(position,1.);}`;
-var RING_FRAGMENT = `uniform float uA;uniform float uW;uniform vec3 uC;varying vec2 vU;
-  float h(vec2 p){return fract(sin(dot(p,vec2(12.9898,78.233)))*43758.5453);}
-  void main(){float r=length(vU);float b=smoothstep(1.,1.-uW,r)*smoothstep(1.-uW*3.5,1.-uW,r);float a=atan(vU.y,vU.x);float n=.7+.3*h(vec2(floor(a*14.),1.));gl_FragColor=vec4(uC,b*uA*n);
-  #include <tonemapping_fragment>
-  #include <colorspace_fragment>
-}`;
-
-// src/shocks.ts
-var RING_HEIGHT = 0.05;
-function createShockLayer(THREE, pool) {
-  const group = new THREE.Group();
-  const shellGeometry = new THREE.SphereGeometry(1, 28, 18);
-  const ringGeometry = new THREE.PlaneGeometry(2, 2).rotateX(-Math.PI / 2);
-  const pairs = [];
-  function makePair() {
-    const shellAlpha = { value: 0 };
-    const ringAlpha = { value: 0 };
-    const shellMaterial = new THREE.ShaderMaterial({ transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, uniforms: { uA: shellAlpha }, vertexShader: SHELL_VERTEX, fragmentShader: SHELL_FRAGMENT });
-    const ringMaterial = new THREE.ShaderMaterial({
-      transparent: true,
-      depthWrite: false,
-      uniforms: { uA: ringAlpha, uW: { value: 0.12 }, uC: { value: new THREE.Color(0.55, 0.5, 0.44) } },
-      vertexShader: RING_VERTEX,
-      fragmentShader: RING_FRAGMENT
-    });
-    const shell = new THREE.Mesh(shellGeometry, shellMaterial);
-    shell.renderOrder = 4;
-    const ring = new THREE.Mesh(ringGeometry, ringMaterial);
-    ring.renderOrder = 3;
-    group.add(shell, ring);
-    return { shell, ring, shellAlpha, ringAlpha };
-  }
-  return {
-    group,
-    sync() {
-      const shocks = pool.items;
-      for (let index = 0; index < shocks.length; index++) {
-        const pair = pairs[index] ?? (pairs[index] = makePair());
-        const shock = shocks[index];
-        pair.shell.visible = pair.ring.visible = true;
-        pair.shell.position.set(shock.x, shock.y, shock.z);
-        pair.shell.scale.setScalar(shock.shellScale);
-        pair.shellAlpha.value = shock.shellAlpha;
-        pair.ring.position.set(shock.x, RING_HEIGHT, shock.z);
-        pair.ring.scale.setScalar(shock.ringScale);
-        pair.ringAlpha.value = shock.ringAlpha;
-      }
-      for (let index = shocks.length; index < pairs.length; index++) pairs[index].shell.visible = pairs[index].ring.visible = false;
-      return shocks.length;
-    },
-    dispose() {
-      for (const pair of pairs) {
-        ;
-        pair.shell.material.dispose();
-        pair.ring.material.dispose();
-      }
-      shellGeometry.dispose();
-      ringGeometry.dispose();
-    }
-  };
-}
-
-// src/shaders/sprite.ts
-var SPRITE_VERTEX = `
-uniform float uScale;
-attribute float size;
-attribute float alpha;
-attribute vec3 pcolor;
-varying float vAlpha;
-varying vec3 vColor;
-void main() {
-  vAlpha = alpha;
-  vColor = pcolor;
-  vec4 mv = modelViewMatrix * vec4(position, 1.0);
-  gl_PointSize = min(size * uScale / max(0.1, -mv.z), 256.0);
-  gl_Position = projectionMatrix * mv;
-}`;
-var SPRITE_FRAGMENT = `
-varying float vAlpha;
-varying vec3 vColor;
-void main() {
-  float d = length(gl_PointCoord - vec2(0.5)) * 2.0;
-  float a = (1.0 - smoothstep(0.35, 1.0, d)) * vAlpha;
-  if (a < 0.004) discard;
-  gl_FragColor = vec4(vColor, a);
-}`;
-
-// src/sprites.ts
-function drawPool(THREE, pool, additive, pointScale) {
-  const geometry = new THREE.BufferGeometry();
-  const attributes = [["position", pool.position, 3], ["pcolor", pool.color, 3], ["alpha", pool.alpha, 1], ["size", pool.size, 1]];
-  const buffers = attributes.map(([name, array, size]) => {
-    const attribute = new THREE.BufferAttribute(array, size).setUsage(THREE.DynamicDrawUsage);
-    geometry.setAttribute(name, attribute);
-    return attribute;
-  });
-  geometry.setDrawRange(0, 0);
-  const material = new THREE.ShaderMaterial({
-    uniforms: { uScale: { value: pointScale } },
-    vertexShader: SPRITE_VERTEX,
-    fragmentShader: SPRITE_FRAGMENT,
-    transparent: true,
-    depthWrite: false,
-    blending: additive ? THREE.AdditiveBlending : THREE.NormalBlending
-  });
-  const points = new THREE.Points(geometry, material);
-  points.frustumCulled = false;
-  points.name = additive ? "vfx-sprites-additive" : "vfx-sprites";
-  points.renderOrder = additive ? 11 : 10;
-  return {
-    points,
-    sync() {
-      geometry.setDrawRange(0, pool.drawCount);
-      for (const buffer of buffers) buffer.needsUpdate = true;
-      return pool.drawCount;
-    },
-    dispose() {
-      geometry.dispose();
-      material.dispose();
-    }
-  };
-}
-function createSpriteLayer(THREE, system, pointScale) {
-  const additive = drawPool(THREE, system.additive, true, pointScale);
-  const normal = drawPool(THREE, system.normal, false, pointScale);
-  return {
-    additive: additive.points,
-    normal: normal.points,
-    sync: () => additive.sync() + normal.sync(),
-    dispose() {
-      additive.dispose();
-      normal.dispose();
-    }
-  };
-}
-
-// src/shaders/workshop-sprite.ts
-var WORKSHOP_SPRITE_VERTEX = `attribute float size;attribute float alpha;attribute vec3 pcol;varying vec3 vC;varying float vA;uniform float uScale;
-void main(){vC=pcol;vA=alpha;vec4 mv=modelViewMatrix*vec4(position,1.);gl_PointSize=clamp(size*uScale/-mv.z,1.,512.);gl_Position=projectionMatrix*mv;}`;
-var WORKSHOP_SPRITE_FRAGMENT = `uniform float uSoft;varying vec3 vC;varying float vA;
-void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a=mix(smoothstep(1.,.78,r),pow(1.-r,1.5),uSoft);gl_FragColor=vec4(vC,vA*a);}`;
-
-// src/workshop-layers.ts
-var DEBRIS_CAPACITY = 500;
-var DECAL_CAPACITY = 400;
-var RING_CAPACITY = 120;
-var RIPPLE_SEGMENTS = 12;
-var FADE_SECONDS = 0.5;
-var FIRE_LIGHT_COLOR = 16742954;
-var FIRE_LIGHT_DISTANCE = 14;
-var GLOSS_DRIED_AT = 0.85;
-var BROWN = 2758160;
-var GROUND_COLOR = 8947848;
-var FUEL_DRIED = 8947848;
-var clamp2 = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
-function spriteLayer(THREE, pool, additive, soft, scale) {
-  const geometry = new THREE.BufferGeometry();
-  const arrays = [["position", pool.position, 3], ["pcol", pool.color, 3], ["size", pool.size, 1], ["alpha", pool.alpha, 1]];
-  const buffers = arrays.map(([name, array, size]) => {
-    const attribute = new THREE.BufferAttribute(array, size).setUsage(THREE.DynamicDrawUsage);
-    geometry.setAttribute(name, attribute);
-    return attribute;
-  });
-  geometry.setDrawRange(0, 0);
-  const material = new THREE.ShaderMaterial({
-    uniforms: { uScale: { value: scale }, uSoft: { value: soft } },
-    vertexShader: WORKSHOP_SPRITE_VERTEX,
-    fragmentShader: WORKSHOP_SPRITE_FRAGMENT,
-    transparent: true,
-    depthWrite: false,
-    blending: additive ? THREE.AdditiveBlending : THREE.NormalBlending
-  });
-  const points = new THREE.Points(geometry, material);
-  points.frustumCulled = false;
-  points.renderOrder = additive ? 3 : 2;
-  points.name = additive ? "workshop-add" : "workshop-normal";
-  return {
-    object: points,
-    sync() {
-      geometry.setDrawRange(0, pool.count);
-      for (const buffer of buffers) buffer.needsUpdate = true;
-      return pool.count > 0;
-    },
-    dispose() {
-      geometry.dispose();
-      material.dispose();
-    }
-  };
-}
-function streakLayer(THREE, pool) {
-  const geometry = new THREE.BufferGeometry();
-  const position = new THREE.BufferAttribute(pool.segment, 3).setUsage(THREE.DynamicDrawUsage);
-  const color = new THREE.BufferAttribute(pool.segmentColor, 3).setUsage(THREE.DynamicDrawUsage);
-  geometry.setAttribute("position", position);
-  geometry.setAttribute("color", color);
-  geometry.setDrawRange(0, 0);
-  const material = new THREE.LineBasicMaterial({ vertexColors: true, transparent: true, blending: THREE.AdditiveBlending, depthWrite: false });
-  const lines = new THREE.LineSegments(geometry, material);
-  lines.frustumCulled = false;
-  lines.renderOrder = 4;
-  lines.name = "workshop-streaks";
-  return {
-    object: lines,
-    sync() {
-      geometry.setDrawRange(0, pool.count * 2);
-      position.needsUpdate = color.needsUpdate = true;
-      return pool.count > 0;
-    },
-    dispose() {
-      geometry.dispose();
-      material.dispose();
-    }
-  };
-}
-function rainLayer(THREE, rain) {
-  const geometry = new THREE.BufferGeometry();
-  const position = new THREE.BufferAttribute(rain.positions, 3).setUsage(THREE.DynamicDrawUsage);
-  geometry.setAttribute("position", position);
-  geometry.setDrawRange(0, 0);
-  const material = new THREE.LineBasicMaterial({ color: 10466255, transparent: true, opacity: 0.35, depthWrite: false });
-  const lines = new THREE.LineSegments(geometry, material);
-  lines.frustumCulled = false;
-  lines.name = "workshop-rain";
-  return {
-    object: lines,
-    sync() {
-      const drawn = rain.on && rain.count > 0;
-      lines.visible = drawn;
-      geometry.setDrawRange(0, drawn ? rain.count * 2 : 0);
-      position.needsUpdate = true;
-      return drawn;
-    },
-    dispose() {
-      geometry.dispose();
-      material.dispose();
-    }
-  };
-}
-function debrisLayer(THREE, pool) {
-  const geometry = new THREE.BoxGeometry(1, 1, 1);
-  const material = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.45, metalness: 0.25, flatShading: true });
-  const mesh = new THREE.InstancedMesh(geometry, material, DEBRIS_CAPACITY);
-  mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-  mesh.frustumCulled = false;
-  mesh.name = "workshop-debris";
-  const euler = new THREE.Euler();
-  const quaternion = new THREE.Quaternion();
-  const position = new THREE.Vector3();
-  const scale = new THREE.Vector3();
-  const matrix = new THREE.Matrix4();
-  const colour = new THREE.Color();
-  const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
-  for (let index = 0; index < DEBRIS_CAPACITY; index++) mesh.setMatrixAt(index, hidden);
-  mesh.setColorAt(0, colour.setHex(16777215));
-  return {
-    object: mesh,
-    sync() {
-      let drawn = false;
-      for (let index = 0; index < DEBRIS_CAPACITY; index++) {
-        const piece = pool.pieces[index];
-        if (!piece.on) {
-          mesh.setMatrixAt(index, hidden);
-          continue;
-        }
-        drawn = true;
-        const shrink = Math.min(1, piece.life / FADE_SECONDS);
-        euler.set(piece.rx, piece.ry, piece.rz);
-        quaternion.setFromEuler(euler);
-        matrix.compose(position.set(piece.x, piece.y, piece.z), quaternion, scale.set(piece.sx * shrink, piece.sy * shrink, piece.sz * shrink));
-        mesh.setMatrixAt(index, matrix);
-        mesh.setColorAt(index, colour.setHex(piece.color));
-      }
-      mesh.instanceMatrix.needsUpdate = true;
-      if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
-      return drawn;
-    },
-    dispose() {
-      geometry.dispose();
-      material.dispose();
-    }
-  };
-}
-function decalLook(decal, colour, dryColour, brown, ground, index) {
-  const grown = decal.grow > 0 ? 1 - Math.pow(1 - Math.min(1, decal.t / decal.grow), 2.4) : 1;
-  let sx = decal.sx * grown;
-  let sy = decal.sy * grown;
-  colour.setHex(decal.color);
-  let dried = false;
-  const fluid = decal.fluid;
-  if (fluid) {
-    const creep = fluid === "oil" ? 0.5 : fluid === "fuel" ? 0.7 : fluid === "bile" ? 0.25 : fluid === "water" ? 0.2 : 0.3;
-    const age = decal.t;
-    if (decal.dryTime > 0) {
-      const k = clamp2((age - decal.dryAt) / decal.dryTime, 0, 1);
-      if (decal.dryColor >= 0) dryColour.setHex(decal.dryColor);
-      else dryColour.copy(colour).multiplyScalar(0.45).lerp(brown, 0.45);
-      dried = k > GLOSS_DRIED_AT;
-      const spread = dried ? 1 + creep : 1 + creep * (1 - Math.exp(-age / 6));
-      sx *= dried ? spread : spread * (1 + 0.04 * Math.sin(age * 1.9 + index));
-      sy *= dried ? spread : spread * (1 + 0.04 * Math.cos(age * 1.5 + index * 0.7));
-      colour.lerp(dryColour, k);
-    } else {
-      const spread = 1 + creep * (1 - Math.exp(-age / 6));
-      sx *= spread * (1 + 0.04 * Math.sin(age * 1.9 + index));
-      sy *= spread * (1 + 0.04 * Math.cos(age * 1.5 + index * 0.7));
-      if (fluid === "fuel" || fluid === "water") {
-        const [wait, span] = fluid === "fuel" ? [6, 5] : [40, 20];
-        const gone = clamp2((age - wait) / span, 0, 1);
-        sx *= 1 - gone * 0.85;
-        sy *= 1 - gone * 0.85;
-        colour.lerp(ground.setHex(fluid === "fuel" ? FUEL_DRIED : GROUND_COLOR), gone * 0.8);
-        if (gone >= 1) return null;
-      }
-    }
-  }
-  return { sx, sy, dried };
-}
-function decalLayer(THREE, pool) {
-  const geometry = new THREE.CircleGeometry(0.5, RIPPLE_SEGMENTS);
-  const positions = geometry.getAttribute("position");
-  for (let index = 1; index < positions.count; index++) {
-    const k = 0.72 + (index * 2654435761 >>> 0) / 4294967296 * 0.4;
-    positions.setXY(index, positions.getX(index) * k, positions.getY(index) * k);
-  }
-  const wet = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 0.1, metalness: 0.3, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 });
-  const dry = new THREE.MeshStandardMaterial({ color: 16777215, roughness: 1, metalness: 0, flatShading: true, polygonOffset: true, polygonOffsetFactor: -4, polygonOffsetUnits: -4 });
-  const wetMesh = new THREE.InstancedMesh(geometry, wet, DECAL_CAPACITY);
-  const dryMesh = new THREE.InstancedMesh(geometry, dry, DECAL_CAPACITY);
-  const group = new THREE.Group();
-  group.name = "workshop-decals";
-  for (const mesh of [wetMesh, dryMesh]) {
-    mesh.frustumCulled = false;
-    mesh.renderOrder = 1;
-    mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-    group.add(mesh);
-  }
-  const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
-  const colour = new THREE.Color();
-  const dryColour = new THREE.Color();
-  const brown = new THREE.Color(BROWN);
-  const ground = new THREE.Color();
-  const normal = new THREE.Vector3();
-  const forward = new THREE.Vector3(0, 0, 1);
-  const turn = new THREE.Quaternion();
-  const quaternion = new THREE.Quaternion();
-  const position = new THREE.Vector3();
-  const scale = new THREE.Vector3();
-  const matrix = new THREE.Matrix4();
-  wetMesh.setColorAt(0, colour.setHex(0));
-  dryMesh.setColorAt(0, colour.setHex(0));
-  for (let index = 0; index < DECAL_CAPACITY; index++) {
-    wetMesh.setMatrixAt(index, hidden);
-    dryMesh.setMatrixAt(index, hidden);
-  }
-  return {
-    object: group,
-    sync() {
-      let drawn = false;
-      for (let index = 0; index < DECAL_CAPACITY; index++) {
-        const decal = pool.decals[index];
-        wetMesh.setMatrixAt(index, hidden);
-        dryMesh.setMatrixAt(index, hidden);
-        if (!decal.on || decal.t < 0) continue;
-        const look = decalLook(decal, colour, dryColour, brown, ground, index);
-        if (!look) continue;
-        drawn = true;
-        normal.set(decal.normal[0], decal.normal[1], decal.normal[2]);
-        quaternion.setFromUnitVectors(forward, normal);
-        quaternion.multiply(turn.setFromAxisAngle(forward, index * 2.399963));
-        const offset = 4e-3 + index % 40 * 4e-4;
-        matrix.compose(position.set(decal.x + normal.x * offset, decal.y + normal.y * offset, decal.z + normal.z * offset), quaternion, scale.set(look.sx, look.sy, 1));
-        const mesh = look.dried ? dryMesh : wetMesh;
-        mesh.setMatrixAt(index, matrix);
-        mesh.setColorAt(index, colour);
-      }
-      for (const mesh of [wetMesh, dryMesh]) {
-        mesh.instanceMatrix.needsUpdate = true;
-        if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
-      }
-      return drawn;
-    },
-    dispose() {
-      geometry.dispose();
-      wet.dispose();
-      dry.dispose();
-    }
-  };
-}
-function ringLayer(THREE, pool) {
-  const geometry = new THREE.RingGeometry(0.86, 1, 40);
-  const material = new THREE.MeshBasicMaterial({ color: 16777215, transparent: true, blending: THREE.AdditiveBlending, depthWrite: false, side: THREE.DoubleSide });
-  const mesh = new THREE.InstancedMesh(geometry, material, RING_CAPACITY);
-  mesh.frustumCulled = false;
-  mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-  mesh.name = "workshop-rings";
-  const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
-  const colour = new THREE.Color();
-  const normal = new THREE.Vector3();
-  const forward = new THREE.Vector3(0, 0, 1);
-  const quaternion = new THREE.Quaternion();
-  const position = new THREE.Vector3();
-  const scale = new THREE.Vector3();
-  const matrix = new THREE.Matrix4();
-  mesh.setColorAt(0, colour.setHex(0));
-  for (let index = 0; index < RING_CAPACITY; index++) mesh.setMatrixAt(index, hidden);
-  return {
-    object: mesh,
-    sync() {
-      let drawn = false;
-      for (let index = 0; index < RING_CAPACITY; index++) {
-        const ring = pool.rings[index];
-        if (!ring.on) {
-          mesh.setMatrixAt(index, hidden);
-          continue;
-        }
-        drawn = true;
-        const k = Math.min(1, ring.t / ring.duration);
-        const radius = ring.from + (ring.to - ring.from) * (1 - Math.pow(1 - k, 2));
-        quaternion.setFromUnitVectors(forward, normal.set(ring.normal[0], ring.normal[1], ring.normal[2]));
-        matrix.compose(position.set(ring.point[0], ring.point[1], ring.point[2]), quaternion, scale.set(radius, radius, 1));
-        mesh.setMatrixAt(index, matrix);
-        mesh.setColorAt(index, colour.setHex(ring.color).multiplyScalar(ring.hold ? ring.hold : 1 - k));
-      }
-      mesh.instanceMatrix.needsUpdate = true;
-      if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
-      return drawn;
-    },
-    dispose() {
-      geometry.dispose();
-      material.dispose();
-    }
-  };
-}
-function createWorkshopLayers(THREE, engine, pointScale, lightScale) {
-  const group = new THREE.Group();
-  group.name = "workshop";
-  const layers = [
-    spriteLayer(THREE, engine.add, true, 1, pointScale),
-    spriteLayer(THREE, engine.normal, false, 0.55, pointScale),
-    streakLayer(THREE, engine.streaks),
-    rainLayer(THREE, engine.rain),
-    debrisLayer(THREE, engine.debris),
-    decalLayer(THREE, engine.decals),
-    ringLayer(THREE, engine.rings)
-  ];
-  for (const layer2 of layers) group.add(layer2.object);
-  const meshes = createMeshLayer(THREE, engine.meshes);
-  group.add(meshes.group);
-  const flashLights = engine.lights.lights.map(() => new THREE.PointLight(16760944, 0, 14));
-  const fireLights = engine.lights.fire.map(() => new THREE.PointLight(FIRE_LIGHT_COLOR, 0, FIRE_LIGHT_DISTANCE));
-  for (const light of [...flashLights, ...fireLights]) group.add(light);
-  return {
-    group,
-    sync() {
-      let drawCalls = 0;
-      for (const layer2 of layers) if (layer2.sync()) drawCalls++;
-      drawCalls += meshes.sync();
-      engine.lights.lights.forEach((source, index) => {
-        const light = flashLights[index];
-        light.position.set(source.x, source.y, source.z);
-        light.color.setHex(source.color);
-        light.distance = source.distance;
-        light.intensity = source.intensity * lightScale;
-      });
-      engine.lights.fire.forEach((source, index) => {
-        const light = fireLights[index];
-        light.position.set(source.x, source.y, source.z);
-        light.intensity = source.intensity * lightScale;
-      });
-      return drawCalls;
-    },
-    dispose() {
-      for (const layer2 of layers) layer2.dispose();
-      meshes.dispose();
-      group.clear();
-    }
-  };
-}
-
-// src/renderer.ts
-var LAB_LIGHT_DIRECTION = [-14, 26, 12];
-var SKY_COLOR = 7306386;
-var GROUND_COLOR2 = 2761759;
-var LOD_BANDS = { auto: null, near: 1, middle: 0.5, far: 0.2 };
-var QUALITY_LEVELS = { high: 0, medium: 1, low: 2 };
-var VFX_LAYERS = ["puffs", "sparks", "glows", "debris", "shock", "sprites"];
-var LAYER_PREFIX = "layer_";
-var SHAKE_REACH = 0.18;
-var SHAKE_FLOOR = 1e-3;
-function isWorld(value) {
-  return typeof value === "object" && value !== null && "explosion" in value && typeof value.explosion === "function";
-}
-function mergeScreens(lab, workshop) {
-  if (!workshop) return lab;
-  const merged = { ...lab };
-  for (const key of Object.keys(lab)) merged[key] = Math.max(lab[key], workshop[key]);
-  return merged;
-}
-function prefersReducedMotion() {
-  return typeof matchMedia === "function" && matchMedia("(prefers-reduced-motion: reduce)").matches;
-}
-function createVfxRenderer(THREE, options) {
-  const reducedMotion = options.reducedMotion ?? prefersReducedMotion();
-  const requested = options.vfx;
-  const world = isWorld(requested) ? requested : createVfx({ profile: options.quality ?? "medium", reducedMotion, ...requested });
-  const pools = world.pools();
-  let anchors;
-  const releaseAnchors = () => {
-    if (!anchors) return;
-    anchors.meshes[0]?.geometry.dispose();
-    for (const mesh of anchors.meshes) mesh.material.dispose();
-    anchors = void 0;
-  };
-  const root = markKitOrigin(new THREE.Group(), { owner: "game-vfx-three", kind: "effect" });
-  options.scene.add(root);
-  const direction = new THREE.Vector3(...options.lightDirection ?? LAB_LIGHT_DIRECTION).normalize();
-  const sky = hexToLinearRgb(SKY_COLOR);
-  const ground = hexToLinearRgb(GROUND_COLOR2);
-  const uniforms = {
-    uLight: { value: direction },
-    uSky: { value: new THREE.Vector3(sky[0] * 0.55, sky[1] * 0.55, sky[2] * 0.55) },
-    uGround: { value: new THREE.Vector3(ground[0] * 0.6, ground[1] * 0.6, ground[2] * 0.6) },
-    uGlowPos: { value: new THREE.Vector3() },
-    uGlowCol: { value: new THREE.Vector3(1, 0.5, 0.2) },
-    uGlowI: { value: 0 },
-    uTime: { value: 0 }
-  };
-  const puffs = createPuffLayer(THREE, pools.puffs, uniforms);
-  const sparks = createSparkLayer(THREE, pools.sparks);
-  const glows = createGlowLayer(THREE, pools.glows);
-  const rockGeometry = new THREE.DodecahedronGeometry(0.5, 0);
-  const plateGeometry = new THREE.BoxGeometry(1, 1, 1);
-  const chunks = createChunkLayer(THREE, pools.chunks, { rock: rockGeometry, plate: plateGeometry }, colorOfChunk);
-  const shocks = createShockLayer(THREE, pools.shocks);
-  const sprites = createSpriteLayer(THREE, world.sprites(), options.pointScale ?? 700);
-  const lights = createLightLayer(THREE, pools.lights, options.lightScale ?? Math.PI);
-  const marks = createMarkLayer(THREE, { ground: pools.ground, createCanvas: options.createCanvas, rockGeometry, plateGeometry, ...options.markLimits });
-  root.add(puffs.mesh, sparks.mesh, glows.mesh, chunks.rocks, chunks.plates, shocks.group, lights.group, sprites.additive, sprites.normal, marks.group);
-  const stopMarks = world.onMarks((event) => marks.handle(event));
-  const overlay = options.overlay ? createScreenOverlay(options.overlay) : void 0;
-  let drawCalls = 0;
-  let workshopLayers;
-  let workshopEngine;
-  const layerOn = /* @__PURE__ */ new Map();
-  const layerObjects = () => ({
-    puffs: [puffs.mesh],
-    sparks: [sparks.mesh],
-    glows: [glows.mesh],
-    debris: [chunks.rocks, chunks.plates],
-    shock: [shocks.group],
-    sprites: [sprites.additive, sprites.normal, ...workshopLayers ? [workshopLayers.group] : []]
-  });
-  const applyLayers = () => {
-    for (const [id, objects] of Object.entries(layerObjects())) for (const object of objects) object.visible = layerOn.get(id) !== false;
-  };
-  const screenNow = () => mergeScreens(world.screen(), world.peekWorkshop()?.screen);
-  let clock = 0;
-  const lastDrawn = { puffs: 0, sparks: 0, glows: 0, chunks: 0, shocks: 0, sprites: 0 };
-  function followCamera() {
-    const position = options.camera.position;
-    world.setCamera([position.x, position.y, position.z]);
-  }
-  function attachWorkshopLayers() {
-    const engine = world.peekWorkshop();
-    if (!engine || engine === workshopEngine) return;
-    workshopLayers?.dispose();
-    if (workshopLayers) root.remove(workshopLayers.group);
-    workshopEngine = engine;
-    workshopLayers = createWorkshopLayers(THREE, engine, options.pointScale ?? 700, 1);
-    root.add(workshopLayers.group);
-    applyLayers();
-  }
-  function syncAll() {
-    lastDrawn.puffs = puffs.sync();
-    lastDrawn.sparks = sparks.sync();
-    lastDrawn.glows = glows.sync();
-    lastDrawn.chunks = chunks.sync();
-    lastDrawn.shocks = shocks.sync();
-    lastDrawn.sprites = sprites.sync();
-    lights.sync();
-    attachWorkshopLayers();
-    const workshopCalls = workshopLayers?.sync() ?? 0;
-    const glow = pools.lights.glow;
-    uniforms.uGlowPos.value.set(glow.x, glow.y, glow.z);
-    uniforms.uGlowCol.value.set(glow.color[0], glow.color[1], glow.color[2]);
-    uniforms.uGlowI.value = glow.intensity;
-    drawCalls = Number(lastDrawn.puffs > 0) + Number(lastDrawn.sparks > 0) + Number(lastDrawn.glows > 0) + Number(chunks.rocks.count > 0) + Number(chunks.plates.count > 0) + Number(sprites.additive.geometry.drawRange.count > 0) + Number(sprites.normal.geometry.drawRange.count > 0) + lastDrawn.shocks * 2 + marks.count() + workshopCalls;
-  }
-  return {
-    world,
-    play(request) {
-      followCamera();
-      const explosion = world.explosion(request.effect, request.point, {
-        ...request.direction ? { direction: request.direction } : {},
-        ...request.seed !== void 0 ? { seed: request.seed } : {},
-        ...request.scale !== void 0 ? { scale: request.scale } : {}
-      });
-      if (explosion !== null) return explosion;
-      return world.play(request.effect, request.point, {
-        ...request.direction ? { direction: request.direction } : {},
-        ...request.normal ? { normal: request.normal } : {},
-        ...request.orientation ? { orientation: request.orientation } : {},
-        ...request.seed !== void 0 ? { seed: request.seed } : {},
-        ...request.param !== void 0 ? { param: request.param } : {},
-        ...request.values ? { values: request.values } : {}
-      });
-    },
-    stop: (handle) => world.stop(handle),
-    // a module's closed space (a shut car's cabin): the world's smoke, dust and steam go round it
-    enclose: (id, enclosure) => world.enclose(id, enclosure),
-    configure(settings) {
-      const band = settings.lod_band;
-      if (typeof band === "string" && band in LOD_BANDS) world.forceLod(LOD_BANDS[band] ?? null);
-      const quality = settings.quality;
-      if (typeof quality === "string" && quality in QUALITY_LEVELS) world.workshop().setQuality(QUALITY_LEVELS[quality] ?? 0);
-      let layersChanged = false;
-      for (const [key, value] of Object.entries(settings)) {
-        if (!key.startsWith(LAYER_PREFIX) || typeof value !== "boolean") continue;
-        layerOn.set(key.slice(LAYER_PREFIX.length), value);
-        layersChanged = true;
-      }
-      if (layersChanged) applyLayers();
-    },
-    catalog: () => [...world.catalog(), ...world.effectIds()],
-    update(dt) {
-      clock += dt;
-      uniforms.uTime.value = clock;
-      followCamera();
-      world.update(dt);
-      marks.update(dt);
-      syncAll();
-      overlay?.update(screenNow());
-    },
-    warmUpProbes() {
-      releaseAnchors();
-      marks.prepare();
-      world.workshop();
-      attachWorkshopLayers();
-      const meshes = createMeshLayerProbes(THREE);
-      for (const mesh of meshes) mesh.frustumCulled = false;
-      const group = new THREE.Group();
-      group.add(...meshes);
-      anchors = { meshes, group };
-      return { group, dispose: () => {
-      } };
-    },
-    applyCamera() {
-      const shake = screenNow().shake;
-      if (reducedMotion || !(shake > SHAKE_FLOOR)) return () => {
-      };
-      const camera = options.camera;
-      const base = camera.position.clone();
-      const reach = shake * SHAKE_REACH;
-      camera.position.x += Math.sin(clock * 71) * reach;
-      camera.position.y += Math.sin(clock * 53 + 1) * reach * 0.7;
-      camera.position.z += Math.sin(clock * 67 + 2) * reach;
-      return () => camera.position.copy(base);
-    },
-    stats() {
-      const { lastBlast, ...counters } = world.stats();
-      return { ...counters, last_puffs: lastBlast.puffs, last_sparks: lastBlast.sparks, last_chunks: lastBlast.chunks, last_lights: lastBlast.lights, drawCalls };
-    },
-    screen: screenNow,
-    dispose() {
-      releaseAnchors();
-      stopMarks();
-      overlay?.dispose();
-      workshopLayers?.dispose();
-      for (const layer2 of [puffs, sparks, glows, chunks, shocks, lights, marks, sprites]) layer2.dispose();
-      rockGeometry.dispose();
-      plateGeometry.dispose();
-      options.scene.remove(root);
-    }
-  };
-}
-
-// src/bench/module.ts
 import {
-  EVENT_BUDGET,
-  EXPLOSIONS,
-  GAME_EFFECTS,
-  estimateCost,
-  resolveStrings
-} from "@adatechnology/game-vfx";
-
-// src/bench/text.ts
-var benchTexts = {
-  en: {
-    module: "Effects",
-    controls: { effect: "Effect", variant: "Variant", replay: "Replay", auto_repeat: "Auto replay", distance: "Distance", lod_band: "LOD band", quality: "Quality" },
-    lod: { auto: "Auto", near: "Near", middle: "Middle", far: "Far" },
-    quality: { high: "High", medium: "Medium", low: "Low" },
-    layers: { puffs: "Smoke and fire", sparks: "Sparks", glows: "Glows", debris: "Debris", shock: "Shock wave", sprites: "Droplets and recipes" },
-    metrics: { puffs: "Puffs", sparks: "Sparks", debris: "Debris", lights: "Lights", budget_particles: "Particles of the effect", lod: "LOD scale", phase: "Time since replay", blast_time: "Time since the blast" },
-    sheet: { explosion: "Explosion", lethal: "Lethal radius", injury: "Injury radius", radius: "Fireball", fireballs: "Fireballs", particles: "Particles", scale: "Scale" },
-    none: "None"
-  },
-  "pt-BR": {
-    module: "Efeitos",
-    controls: { effect: "Efeito", variant: "Variante", replay: "Repetir", auto_repeat: "Repeti\xE7\xE3o autom\xE1tica", distance: "Dist\xE2ncia", lod_band: "Faixa de LOD", quality: "Qualidade" },
-    lod: { auto: "Autom\xE1tico", near: "Perto", middle: "Meio", far: "Longe" },
-    quality: { high: "Alta", medium: "M\xE9dia", low: "Baixa" },
-    layers: { puffs: "Fuma\xE7a e fogo", sparks: "Fa\xEDscas", glows: "Brilhos", debris: "Destro\xE7os", shock: "Onda de choque", sprites: "Gotas e receitas" },
-    metrics: { puffs: "Nuvens", sparks: "Fa\xEDscas", debris: "Destro\xE7os", lights: "Luzes", budget_particles: "Part\xEDculas do efeito", lod: "Escala de LOD", phase: "Tempo desde a repeti\xE7\xE3o", blast_time: "Tempo desde a explos\xE3o" },
-    sheet: { explosion: "Explos\xE3o", lethal: "Raio letal", injury: "Raio de ferimento", radius: "Bola de fogo", fireballs: "Bolas de fogo", particles: "Part\xEDculas", scale: "Escala" },
-    none: "Nenhuma"
-  }
-};
-var benchText = (locale) => benchTexts[locale] ?? benchTexts.en;
-
-// src/bench/module.ts
-var DEFAULT_EFFECT = "m67";
-var FALLBACK_EXPLOSION = "generic";
-var NO_VARIANT = "none";
-var BLAST_POINT = [0, 0.1, 0];
-var DEFAULT_DISTANCE = 14;
-var DEFAULT_REPEAT_SECONDS = 4;
-var LIGHT_BUDGET = EVENT_BUDGET.blastLights + EVENT_BUDGET.fireLights;
-var SEGMENT_COLORS = ["#ffb347", "#ff7a2a", "#8a8f98", "#5c6370"];
-var TEAMS = [
-  "creatures",
-  "weapons",
-  "destruction",
-  "world",
-  "vehicles",
-  "screen"
-];
-var LAYER_ID = "show_";
-var humanize = (id) => id.replace(/_/g, " ");
-var eyeFor = (distance) => [
-  distance * 0.6,
-  distance * 0.35 + 1.4,
-  distance * 0.8
-];
-function timelineOf(explosion, recipe, metric) {
-  if (explosion) {
-    const flash = explosion.flash.life ?? 0.2;
-    const smoke = Math.max(explosion.smoke.life, 1);
-    return {
-      segments: [
-        { name: "flash", start: 0, end: flash, color: SEGMENT_COLORS[0] },
-        {
-          name: "fireball",
-          start: 0,
-          end: Math.min(smoke, 2.4),
-          color: SEGMENT_COLORS[1]
-        },
-        { name: "smoke", start: 0.4, end: smoke, color: SEGMENT_COLORS[2] }
-      ],
-      ticks: Array.from({ length: Math.ceil(smoke) }, (_, index) => index + 1),
-      metric
-    };
-  }
-  const span = recipe?.loop && recipe.loop > 0 ? recipe.loop : 4;
-  return {
-    segments: [
-      { name: recipe?.id ?? "", start: 0, end: span, color: SEGMENT_COLORS[1] }
-    ],
-    ticks: Array.from({ length: Math.floor(span) }, (_, index) => index + 1),
-    metric
-  };
-}
-function createVfxTestModule(options = {}) {
-  const locale = options.locale ?? "en";
-  const recipes = options.effects ?? GAME_EFFECTS;
-  const explosions = options.explosions ?? EXPLOSIONS;
-  const text = benchText(locale);
-  const strings = resolveStrings(locale);
-  const effectOptions = () => [
-    ...Object.keys(explosions).filter((id) => id !== FALLBACK_EXPLOSION).map((id) => ({
-      id,
-      name: humanize(id),
-      group: strings.groups.explosions ?? text.sheet.explosion
-    })),
-    // an id the explosions already use is the explosion's: the sink tries the explosions first, so the recipe of the same name could not be reached
-    ...TEAMS.flatMap(
-      (team) => Object.values(recipes).filter((def) => def.team === team && !(def.id in explosions)).map((def) => ({
-        id: def.id,
-        name: strings.effects[def.id]?.name ?? humanize(def.id),
-        group: strings.groups[def.team] ?? def.team
-      }))
-    )
-  ];
-  const sheetFor = (id) => {
-    const explosion = explosions[id];
-    if (explosion) {
-      return {
-        kicker: strings.groups.explosions ?? text.sheet.explosion,
-        title: humanize(id),
-        facts: [
-          { label: text.sheet.lethal, value: `${explosion.lethal} m` },
-          { label: text.sheet.injury, value: `${explosion.injury} m` },
-          { label: text.sheet.radius, value: `${explosion.visualRadius} m` },
-          { label: text.sheet.fireballs, value: String(explosion.fireballs) },
-          {
-            label: text.sheet.particles,
-            value: `${estimateCost(explosion)} / ${EVENT_BUDGET.particles}`
-          }
-        ],
-        timeline: timelineOf(explosion, void 0, "blast_time")
-      };
-    }
-    const recipe = recipes[id];
-    const words = strings.effects[id];
-    const labels = strings.sheet;
-    return {
-      kicker: recipe ? strings.groups[recipe.team] ?? recipe.team : void 0,
-      title: words?.name ?? humanize(id),
-      ...words ? { body: words.short } : {},
-      facts: words ? [{ label: labels.budget, value: `${words.cost} \xB7 ${words.costNote}` }] : [],
-      steps: words ? [
-        { at: labels.when, text: words.when },
-        { at: labels.look, text: words.look },
-        { at: labels.budget, text: words.budget },
-        { at: labels.network, text: words.network }
-      ] : [],
-      timeline: timelineOf(void 0, recipe, "phase")
-    };
-  };
-  const controls = () => [
-    {
-      kind: "choice",
-      id: "effect",
-      name: text.controls.effect,
-      options: effectOptions(),
-      default: DEFAULT_EFFECT in explosions ? DEFAULT_EFFECT : effectOptions()[0].id
-    },
-    {
-      kind: "choice",
-      id: "variant",
-      name: text.controls.variant,
-      options: [{ id: NO_VARIANT, name: text.none }],
-      default: NO_VARIANT,
-      hidden: true
-    },
-    { kind: "action", id: "replay", name: text.controls.replay },
-    {
-      kind: "boolean",
-      id: "auto_repeat",
-      name: text.controls.auto_repeat,
-      default: false
-    },
-    {
-      kind: "number",
-      id: "distance",
-      name: text.controls.distance,
-      min: 4,
-      max: 120,
-      step: 1,
-      unit: "m",
-      default: DEFAULT_DISTANCE
-    },
-    {
-      kind: "choice",
-      id: "lod_band",
-      name: text.controls.lod_band,
-      options: ["auto", "near", "middle", "far"].map((id) => ({
-        id,
-        name: text.lod[id]
-      })),
-      default: "auto"
-    },
-    {
-      kind: "choice",
-      id: "quality",
-      name: text.controls.quality,
-      options: ["high", "medium", "low"].map((id) => ({
-        id,
-        name: text.quality[id]
-      })),
-      default: "high"
-    }
-  ];
-  const layers = () => VFX_LAYERS.map((id) => ({ id: `${LAYER_ID}${id}`, name: text.layers[id] }));
-  let read = () => ({ stats: {}, phase: 0, budget: 0 });
-  const metrics = () => [
-    {
-      id: "puffs",
-      name: text.metrics.puffs,
-      digits: 0,
-      read: () => read().stats.puffs ?? 0
-    },
-    {
-      id: "sparks",
-      name: text.metrics.sparks,
-      digits: 0,
-      read: () => read().stats.sparks ?? 0
-    },
-    {
-      id: "debris",
-      name: text.metrics.debris,
-      digits: 0,
-      max: EVENT_BUDGET.debris,
-      read: () => read().stats.chunks ?? 0
-    },
-    {
-      id: "lights",
-      name: text.metrics.lights,
-      digits: 0,
-      max: LIGHT_BUDGET,
-      read: () => (read().stats.blastLights ?? 0) + (read().stats.fireLights ?? 0)
-    },
-    {
-      id: "budget_particles",
-      name: text.metrics.budget_particles,
-      digits: 0,
-      max: EVENT_BUDGET.particles,
-      read: () => read().budget
-    },
-    {
-      id: "lod",
-      name: text.metrics.lod,
-      digits: 2,
-      read: () => read().stats.lod ?? 1
-    },
-    {
-      id: "phase",
-      name: text.metrics.phase,
-      unit: "s",
-      digits: 2,
-      read: () => read().phase
-    },
-    {
-      id: "blast_time",
-      name: text.metrics.blast_time,
-      unit: "s",
-      digits: 2,
-      read: () => Math.max(0, read().stats.blastTime ?? 0)
-    }
-  ];
-  return {
-    id: "vfx",
-    name: text.module,
-    ground: { surface: "dirt" },
-    group: "effects",
-    items: () => [],
-    controls,
-    layers,
-    metrics,
-    // opening the effects area puts the camera at the bench view (the initial distance does not move it: that would take the player's view on load)
-    area: () => ({
-      placements: [],
-      view: { eye: eyeFor(DEFAULT_DISTANCE), target: [0, 1.2, 0] }
-    }),
-    attach(host) {
-      const bench = host.bench;
-      let own;
-      let sink = host.effects;
-      if (!sink) {
-        own = createVfxRenderer(host.THREE, {
-          scene: host.scene,
-          camera: host.camera
-        });
-        sink = own;
-      }
-      const effects = sink;
-      let effect = "m67";
-      let variant = NO_VARIANT;
-      let distance = DEFAULT_DISTANCE;
-      let auto = false;
-      let phase = 0;
-      let handle = null;
-      let sinceRepeat = 0;
-      let live = false;
-      read = () => {
-        const def = explosions[effect];
-        const recipe = recipes[effect];
-        const budget = def ? estimateCost(def) : recipe?.budget.particles ?? 0;
-        return { stats: effects.stats?.() ?? {}, phase, budget };
-      };
-      function replay() {
-        if (handle !== null) effects.stop(handle);
-        phase = 0;
-        sinceRepeat = 0;
-        handle = effects.play({
-          effect,
-          point: [BLAST_POINT[0], BLAST_POINT[1], BLAST_POINT[2]],
-          direction: [1, 0.2, 0.4],
-          normal: [0, 1, 0],
-          ...variant !== NO_VARIANT && recipes[effect]?.params?.options.includes(variant) ? { param: variant } : {}
-        });
-      }
-      function choose(id) {
-        effect = id;
-        const params = recipes[id]?.params;
-        variant = params ? params.options[params.default] ?? params.options[0] ?? NO_VARIANT : NO_VARIANT;
-        bench?.patch(
-          "variant",
-          params ? {
-            hidden: false,
-            options: params.options.map((option) => ({
-              id: option,
-              name: option
-            })),
-            value: variant
-          } : {
-            hidden: true,
-            options: [{ id: NO_VARIANT, name: text.none }],
-            value: NO_VARIANT
-          }
-        );
-        bench?.sheet?.(sheetFor(id));
-        if (live) replay();
-      }
-      function look() {
-        const eye = eyeFor(distance);
-        bench?.look(eye, [0, 1.2, 0]);
-      }
-      const apply = (change) => {
-        if (change.kind === "layer")
-          effects.configure?.({
-            [`layer_${change.id.slice(LAYER_ID.length)}`]: change.on
-          });
-        else if (change.kind === "action") {
-          if (change.id === "replay") replay();
-        } else if (change.id === "effect" && typeof change.value === "string")
-          choose(change.value);
-        else if (change.id === "variant" && typeof change.value === "string") {
-          variant = change.value;
-          if (live && recipes[effect]?.params) replay();
-        } else if (change.id === "auto_repeat") auto = change.value === true;
-        else if (change.id === "distance" && typeof change.value === "number") {
-          distance = change.value;
-          look();
-        } else if (change.id === "lod_band" || change.id === "quality")
-          effects.configure?.({ [change.id]: change.value });
-      };
-      const offChange = bench?.onChange(apply);
-      const offFrame = host.onFrame((dt) => {
-        live = true;
-        phase += dt;
-        sinceRepeat += dt;
-        own?.update(dt);
-        if (auto && sinceRepeat >= (options.repeatSeconds ?? DEFAULT_REPEAT_SECONDS))
-          replay();
-      });
-      return () => {
-        offChange?.();
-        offFrame();
-        if (handle !== null) effects.stop(handle);
-        bench?.sheet?.(null);
-        own?.dispose();
-        read = () => ({ stats: {}, phase: 0, budget: 0 });
-      };
-    }
-  };
-}
+  GLOW_FRAGMENT,
+  GLOW_VERTEX,
+  PUFF_FRAGMENT,
+  PUFF_VERTEX,
+  RING_FRAGMENT,
+  RING_VERTEX,
+  SHELL_FRAGMENT,
+  SHELL_VERTEX,
+  SPARK_FRAGMENT,
+  SPARK_VERTEX,
+  SPRITE_FRAGMENT,
+  SPRITE_VERTEX,
+  VFX_LAYERS,
+  benchText,
+  benchTexts,
+  createMarkLayer,
+  createScreenOverlay,
+  createSpriteLayer,
+  createVfxRenderer,
+  createVfxTestModule
+} from "./chunk-ALDCQ5RH.js";
 
 // src/ground-patch.ts
 var DEFAULT_TEXTURE_METRES = 17;