@adatechnology/game-fluids-three 0.4.5 → 0.4.7

package/dist/index.global.js

@@ -1325,11 +1325,231 @@ var GameFluidsThree = (() => {
       glow.outIntensity = glow.i * Math.pow(1 - age, glow.curve) * flicker;
     }
   }
+  var LEHMER_MULTIPLIER = 16807;
+  var LEHMER_MODULUS = 2147483647;
+  var HASH_MIX = 2654435761;
+  function normalizeLehmerSeed(seed) {
+    const whole = Math.floor(Math.abs(seed)) % (LEHMER_MODULUS - 1);
+    return whole === 0 ? 1 : whole;
+  }
+  function lehmer(seed) {
+    let state = normalizeLehmerSeed(seed);
+    const next = () => {
+      state = state * LEHMER_MULTIPLIER % LEHMER_MODULUS;
+      return (state - 1) / (LEHMER_MODULUS - 1);
+    };
+    return {
+      next,
+      between: (min2, max2) => min2 + (max2 - min2) * next(),
+      direction(out) {
+        const up = next() * 2 - 1;
+        const angle = next() * Math.PI * 2;
+        const ring2 = Math.sqrt(1 - up * up);
+        out.x = ring2 * Math.cos(angle);
+        out.y = up;
+        out.z = ring2 * Math.sin(angle);
+        return out;
+      },
+      get state() {
+        return state;
+      }
+    };
+  }
+  function mixEventSeed(eventSeed) {
+    let mixed = Math.imul((eventSeed | 0) ^ HASH_MIX, 2246822507);
+    mixed ^= mixed >>> 13;
+    mixed = Math.imul(mixed, 3266489909);
+    mixed ^= mixed >>> 16;
+    return (mixed >>> 0) % (LEHMER_MODULUS - 1) + 1;
+  }
+  function streamFor(eventSeed) {
+    return lehmer(mixEventSeed(eventSeed));
+  }
+  var SKIN = 5e-3;
+  var MAX_PAD = 0.45;
+  function rotation(q) {
+    const [x, y, z, w] = q ?? [0, 0, 0, 1];
+    const n = Math.hypot(x, y, z, w) || 1;
+    const qx = x / n;
+    const qy = y / n;
+    const qz = z / n;
+    const qw = w / n;
+    return new Float64Array([
+      1 - 2 * (qy * qy + qz * qz),
+      2 * (qx * qy - qz * qw),
+      2 * (qx * qz + qy * qw),
+      2 * (qx * qy + qz * qw),
+      1 - 2 * (qx * qx + qz * qz),
+      2 * (qy * qz - qx * qw),
+      2 * (qx * qz - qy * qw),
+      2 * (qy * qz + qx * qw),
+      1 - 2 * (qx * qx + qy * qy)
+    ]);
+  }
+  var Enclosures = class {
+    constructor(seed = 20973) {
+      __publicField2(this, "spaces", /* @__PURE__ */ new Map());
+      __publicField2(this, "list", []);
+      __publicField2(this, "random");
+      __publicField2(this, "out", { x: 0, y: 0, z: 0, nx: 0, ny: 0, nz: 0 });
+      __publicField2(this, "l0", new Float64Array(3));
+      __publicField2(this, "l1", new Float64Array(3));
+      __publicField2(this, "q", new Float64Array(3));
+      this.random = lehmer(seed);
+    }
+    get empty() {
+      return this.list.length === 0;
+    }
+    get size() {
+      return this.list.length;
+    }
+    /** Declares, moves or (with `null`) ends the space `id`. */
+    set(id, enclosure) {
+      if (!enclosure) {
+        if (this.spaces.delete(id)) this.list = [...this.spaces.values()];
+        return;
+      }
+      const [hx, hy, hz] = enclosure.halfSize;
+      const space = {
+        cx: enclosure.center[0],
+        cy: enclosure.center[1],
+        cz: enclosure.center[2],
+        hx: Math.abs(hx),
+        hy: Math.abs(hy),
+        hz: Math.abs(hz),
+        r: rotation(enclosure.orientation),
+        radius: Math.hypot(hx, hy, hz),
+        openings: enclosure.openings ?? [],
+        leak: Math.max(0, enclosure.leak ?? 0)
+      };
+      const old = this.spaces.get(id);
+      this.spaces.set(id, space);
+      const at3 = old ? this.list.indexOf(old) : -1;
+      if (at3 >= 0) this.list[at3] = space;
+      else this.list.push(space);
+    }
+    get(id) {
+      const s = this.spaces.get(id);
+      if (!s) return void 0;
+      return { center: [s.cx, s.cy, s.cz], halfSize: [s.hx, s.hy, s.hz], openings: s.openings, leak: s.leak };
+    }
+    ids() {
+      return [...this.spaces.keys()];
+    }
+    clear() {
+      this.spaces.clear();
+      this.list = [];
+    }
+    /** Whether a point is inside any space (on the inside of its walls). */
+    inside(x, y, z) {
+      for (const s of this.list) {
+        this.toLocal(s, x, y, z, this.l0);
+        if (Math.abs(this.l0[0]) <= s.hx && Math.abs(this.l0[1]) <= s.hy && Math.abs(this.l0[2]) <= s.hz) return true;
+      }
+      return false;
+    }
+    toLocal(s, x, y, z, out) {
+      const dx = x - s.cx;
+      const dy = y - s.cy;
+      const dz = z - s.cz;
+      const r = s.r;
+      out[0] = r[0] * dx + r[3] * dy + r[6] * dz;
+      out[1] = r[1] * dx + r[4] * dy + r[7] * dz;
+      out[2] = r[2] * dx + r[5] * dy + r[8] * dz;
+    }
+    /** Passes at `rate` per second. */
+    chance(rate, dt) {
+      return rate > 0 && this.random.next() < 1 - Math.exp(-rate * dt);
+    }
+    /** The opening the wall point `q` (local) is in lets it through now. */
+    through(s, q, dt) {
+      for (const o of s.openings) {
+        if (Math.abs(q[0] - o.center[0]) > o.halfSize[0] || Math.abs(q[1] - o.center[1]) > o.halfSize[1] || Math.abs(q[2] - o.center[2]) > o.halfSize[2]) continue;
+        if (o.rate === void 0 || this.chance(o.rate, dt)) return true;
+      }
+      return this.chance(s.leak, dt);
+    }
+    confine(x0, y0, z0, x1, y1, z1, pad, dt) {
+      const list = this.list;
+      if (list.length === 0) return false;
+      const p = Math.min(Math.max(0, pad), MAX_PAD);
+      const l0 = this.l0;
+      const l1 = this.l1;
+      const q = this.q;
+      for (const s of list) {
+        const reach = s.radius + p + 0.05;
+        const dx = x1 - s.cx;
+        const dy = y1 - s.cy;
+        const dz = z1 - s.cz;
+        if (dx * dx + dy * dy + dz * dz > reach * reach) {
+          const ex = x0 - s.cx;
+          const ey = y0 - s.cy;
+          const ez = z0 - s.cz;
+          if (ex * ex + ey * ey + ez * ez > reach * reach) continue;
+        }
+        this.toLocal(s, x0, y0, z0, l0);
+        this.toLocal(s, x1, y1, z1, l1);
+        const h = [s.hx, s.hy, s.hz];
+        const in0 = Math.abs(l0[0]) <= s.hx && Math.abs(l0[1]) <= s.hy && Math.abs(l0[2]) <= s.hz;
+        let axis2 = 0;
+        let sign = 1;
+        if (in0) {
+          if (Math.abs(l1[0]) <= s.hx && Math.abs(l1[1]) <= s.hy && Math.abs(l1[2]) <= s.hz) continue;
+          for (let a = 0; a < 3; a++) q[a] = Math.min(h[a], Math.max(-h[a], l1[a]));
+          if (this.through(s, q, dt)) continue;
+          let worst = -Infinity;
+          for (let a = 0; a < 3; a++) {
+            const over = Math.abs(l1[a]) - h[a];
+            if (over > worst) {
+              worst = over;
+              axis2 = a;
+            }
+          }
+          sign = l1[axis2] < 0 ? -1 : 1;
+          for (let a = 0; a < 3; a++) l1[a] = Math.min(h[a] - SKIN, Math.max(-(h[a] - SKIN), l1[a]));
+          sign = -sign;
+        } else {
+          const padded0 = Math.abs(l0[0]) <= s.hx + p && Math.abs(l0[1]) <= s.hy + p && Math.abs(l0[2]) <= s.hz + p;
+          const bound = padded0 ? 0 : p;
+          if (!(Math.abs(l1[0]) <= s.hx + bound && Math.abs(l1[1]) <= s.hy + bound && Math.abs(l1[2]) <= s.hz + bound)) continue;
+          for (let a = 0; a < 3; a++) q[a] = Math.min(h[a], Math.max(-h[a], l1[a]));
+          if (this.through(s, q, dt)) continue;
+          let worst = -Infinity;
+          for (let a = 0; a < 3; a++) {
+            const over = Math.abs(l0[a]) - (h[a] + bound);
+            if (over > worst) {
+              worst = over;
+              axis2 = a;
+            }
+          }
+          sign = l0[axis2] < 0 ? -1 : 1;
+          l1[axis2] = sign * (h[axis2] + bound + SKIN);
+        }
+        const r = s.r;
+        const out = this.out;
+        out.x = s.cx + r[0] * l1[0] + r[1] * l1[1] + r[2] * l1[2];
+        out.y = s.cy + r[3] * l1[0] + r[4] * l1[1] + r[5] * l1[2];
+        out.z = s.cz + r[6] * l1[0] + r[7] * l1[1] + r[8] * l1[2];
+        out.nx = r[axis2] * sign;
+        out.ny = r[3 + axis2] * sign;
+        out.nz = r[6 + axis2] * sign;
+        return true;
+      }
+      return false;
+    }
+  };
+  function slideAlong(out, vx2, vy2, vz2) {
+    const into = vx2 * out.nx + vy2 * out.ny + vz2 * out.nz;
+    if (into >= 0) return [vx2, vy2, vz2];
+    return [vx2 - into * out.nx, vy2 - into * out.ny, vz2 - into * out.nz];
+  }
   var FLOOR_FRACTION = 0.4;
   var FLOOR_BOUNCE = -0.2;
   var ARRIVAL_FRAME = 30;
   var ARRIVAL_BASE = 0.3;
   var GROWTH_CAP_SECONDS = 3.5;
+  var CARRIED_KINDS = [true, true, false, true, false];
+  var PAD_OF_SIZE = 0.35;
   function createPuffPool(capacity) {
     const placeholder = { next: () => 0, between: (min2) => min2, direction: (out) => out, state: 0 };
     return new OrderedPool(capacity, () => ({
@@ -1424,13 +1644,24 @@ var GameFluidsThree = (() => {
       if (puff3.vy < 0) puff3.vy *= FLOOR_BOUNCE;
     }
   }
-  function updatePuffs(pool, dt, wind) {
+  function updatePuffs(pool, dt, wind, confiner) {
     pool.compact(ageOrKeep2, dt);
+    const confining = confiner !== void 0 && !confiner.empty;
     for (const puff3 of pool.items) {
       const age = puff3.t / puff3.life;
       const heat = puff3.h0 > 0 ? puff3.h0 * Math.pow(Math.max(0, 1 - puff3.t / puff3.hl), 1.25) : 0;
+      const x0 = puff3.x;
+      const y0 = puff3.y;
+      const z0 = puff3.z;
       if (puff3.ring) moveOnRing(puff3, puff3.ring, wind);
       else moveFree(puff3, dt, age, heat, wind);
+      if (confining && CARRIED_KINDS[puff3.kind] && confiner.confine(x0, y0, z0, puff3.x, puff3.y, puff3.z, puff3.size * PAD_OF_SIZE, dt)) {
+        const out = confiner.out;
+        puff3.x = out.x;
+        puff3.y = out.y;
+        puff3.z = out.z;
+        [puff3.vx, puff3.vy, puff3.vz] = slideAlong(out, puff3.vx, puff3.vy, puff3.vz);
+      }
       const size = puff3.s0 + (puff3.s1 - puff3.s0) * (1 - Math.exp(-puff3.t * puff3.gk)) + puff3.sg * Math.min(puff3.t, GROWTH_CAP_SECONDS);
       puff3.size = size * Math.min(1, puff3.t * ARRIVAL_FRAME + ARRIVAL_BASE);
       puff3.age = age;
@@ -1956,10 +2187,10 @@ var GameFluidsThree = (() => {
       ])
     ]
   };
-  function localToWorld(translation, rotation, local2) {
+  function localToWorld(translation, rotation2, local2) {
     const [x, y, z] = local2;
-    const [a, c, e] = [Math.cos(rotation[0]), Math.cos(rotation[1]), Math.cos(rotation[2])];
-    const [b, d, f] = [Math.sin(rotation[0]), Math.sin(rotation[1]), Math.sin(rotation[2])];
+    const [a, c, e] = [Math.cos(rotation2[0]), Math.cos(rotation2[1]), Math.cos(rotation2[2])];
+    const [b, d, f] = [Math.sin(rotation2[0]), Math.sin(rotation2[1]), Math.sin(rotation2[2])];
     const [ae, af, be, bf] = [a * e, a * f, b * e, b * f];
     return [
       c * e * x + -c * f * y + d * z + translation[0],
@@ -3622,46 +3853,6 @@ var GameFluidsThree = (() => {
   var ALL_EFFECTS = [BLOOD_HIT, HEADSHOT, DISMEMBER, BLOATER_CLOUD, SCREAMER_SHRIEK, CORPSE_DECAY, REANIMATION, EYES_IN_FOG, MUZZLE_FLASH, IMPACT_BY_MATERIAL, PENETRATION, CASINGS_AND_MAGAZINE, MOLOTOV, GRENADE, EXPLOSIVE_BARREL, SHOPFRONT_GLASS, DOOR_STAGES, BUILDING_COLLAPSE, BLOCK_WALL, METAL_DOOR_EFFECT, IRON_RAILING, WOODEN_FENCE, HIT_POINT_BREAKAGE, PRESSURE_CYLINDERS, BUILDING_FIRE, RAIN_AND_PUDDLES, FOG_AND_ASH, SCRAPING_SPARKS, ENGINE_SMOKE, FUEL_LEAK, CAR_EXPLOSION, WINDSHIELD, HEADLIGHTS_IN_RAIN, DAMAGE_AND_BITE, INFECTION_PHASES, PANIC, BLOATER_BLINDNESS, CAMPFIRE, COUGH_AND_BREATH];
   var WORKSHOP_EFFECTS = Object.fromEntries(ALL_EFFECTS.map((effect) => [effect.id, effect]));
   var GAME_EFFECTS = { ...WORKSHOP_EFFECTS, ...Object.fromEntries([...EVENT_EFFECTS, ...VIEWMODEL_EFFECTS, ...VEHICLE_EFFECTS].map((effect) => [effect.id, effect])) };
-  var LEHMER_MULTIPLIER = 16807;
-  var LEHMER_MODULUS = 2147483647;
-  var HASH_MIX = 2654435761;
-  function normalizeLehmerSeed(seed) {
-    const whole = Math.floor(Math.abs(seed)) % (LEHMER_MODULUS - 1);
-    return whole === 0 ? 1 : whole;
-  }
-  function lehmer(seed) {
-    let state = normalizeLehmerSeed(seed);
-    const next = () => {
-      state = state * LEHMER_MULTIPLIER % LEHMER_MODULUS;
-      return (state - 1) / (LEHMER_MODULUS - 1);
-    };
-    return {
-      next,
-      between: (min2, max2) => min2 + (max2 - min2) * next(),
-      direction(out) {
-        const up = next() * 2 - 1;
-        const angle = next() * Math.PI * 2;
-        const ring2 = Math.sqrt(1 - up * up);
-        out.x = ring2 * Math.cos(angle);
-        out.y = up;
-        out.z = ring2 * Math.sin(angle);
-        return out;
-      },
-      get state() {
-        return state;
-      }
-    };
-  }
-  function mixEventSeed(eventSeed) {
-    let mixed = Math.imul((eventSeed | 0) ^ HASH_MIX, 2246822507);
-    mixed ^= mixed >>> 13;
-    mixed = Math.imul(mixed, 3266489909);
-    mixed ^= mixed >>> 16;
-    return (mixed >>> 0) % (LEHMER_MODULUS - 1) + 1;
-  }
-  function streamFor(eventSeed) {
-    return lehmer(mixEventSeed(eventSeed));
-  }
   var TABLE = {
     concrete: { dust: 9078138, chip: 7236195, spark: 2 },
     metal: { dust: 0, chip: 0, spark: 18 },
@@ -4965,8 +5156,8 @@ var GameFluidsThree = (() => {
   function addScorch(store, random, x, z, radius) {
     const variant = Math.floor(random.next() * SCORCH_VARIANTS);
     const lift = 0.03 + nextLift(store) * 1e-3;
-    const rotation = random.next() * 6;
-    store.add({ kind: "scorch", x, z, radius, variant, lift, rotation });
+    const rotation2 = random.next() * 6;
+    store.add({ kind: "scorch", x, z, radius, variant, lift, rotation: rotation2 });
   }
   function addRimRocks(store, ground, random, x, z, radius) {
     const count = Math.round(6 + radius * 7);
@@ -4995,8 +5186,8 @@ var GameFluidsThree = (() => {
   function addCrater(store, ground, random, spec) {
     ground?.dent(random, spec.x, spec.z, spec.radius, spec.depth);
     if (!spec.marks) return;
-    const rotation = random.next() * 6;
-    store.add({ kind: "dirt", x: spec.x, z: spec.z, radius: spec.radius * 1.02, lift: 0.045, rotation });
+    const rotation2 = random.next() * 6;
+    store.add({ kind: "dirt", x: spec.x, z: spec.z, radius: spec.radius * 1.02, lift: 0.045, rotation: rotation2 });
     addRimRocks(store, ground, random, spec.x, spec.z, spec.radius);
   }
   function addBloodSplat(store, ground, random, spec) {
@@ -5552,6 +5743,7 @@ var GameFluidsThree = (() => {
     state.gas = Math.max(0, state.gas - dt / DECAY.gasSeconds);
     state.beat *= Math.exp(-DECAY.beat * dt);
   }
+  var PAD_OF_SIZE2 = 0.35;
   var clamp4 = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
   var lerp4 = (a, b, t) => a + (b - a) * t;
   function rgb(hex) {
@@ -5711,9 +5903,20 @@ var GameFluidsThree = (() => {
           vy2 *= k;
           vz2 *= k;
         }
-        const x = this.position[i3] + vx2 * dt;
+        let x = this.position[i3] + vx2 * dt;
         let y = this.position[i3 + 1] + vy2 * dt;
-        const z = this.position[i3 + 2] + vz2 * dt;
+        let z = this.position[i3 + 2] + vz2 * dt;
+        const confiner = host.confiner;
+        if (def.carried && confiner && !confiner.empty) {
+          const pad = this.size0[i] * lerp4(1, def.grow, t) * PAD_OF_SIZE2;
+          if (confiner.confine(this.position[i3], this.position[i3 + 1], this.position[i3 + 2], x, y, z, pad, dt)) {
+            const out = confiner.out;
+            x = out.x;
+            y = out.y;
+            z = out.z;
+            [vx2, vy2, vz2] = slideAlong(out, vx2, vy2, vz2);
+          }
+        }
         if (def.ground !== "none") {
           const own = this.floor[i];
           const gy = Number.isNaN(own) ? host.groundAt(x, z) + 5e-3 : own;
@@ -5799,7 +6002,8 @@ var GameFluidsThree = (() => {
       alpha: 0.35,
       fadeIn: 0.15,
       cone: 0.6,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     sparks: {
       id: "sparks",
@@ -5843,7 +6047,8 @@ var GameFluidsThree = (() => {
       alpha: 0.4,
       fadeIn: 0.1,
       cone: 0.4,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     shards: {
       id: "shards",
@@ -6001,7 +6206,8 @@ var GameFluidsThree = (() => {
       fadeIn: 0.1,
       cone: 0.5,
       ground: "stop",
-      flutter: 0.6
+      flutter: 0.6,
+      carried: true
     },
     steam: {
       id: "steam",
@@ -6023,7 +6229,8 @@ var GameFluidsThree = (() => {
       alpha: 0.35,
       fadeIn: 0.15,
       cone: 0.6,
-      ground: "none"
+      ground: "none",
+      carried: true
     },
     flash: {
       id: "flash",
@@ -6156,7 +6363,8 @@ var GameFluidsThree = (() => {
       const host = {
         groundAt: this.options.groundAt,
         gravity: this.options.gravity,
-        land: (owner, x, y, z, color, tag) => this.listeners.get(owner)?.(x, y, z, color, tag)
+        land: (owner, x, y, z, color, tag) => this.listeners.get(owner)?.(x, y, z, color, tag),
+        ...this.options.confiner ? { confiner: this.options.confiner } : {}
       };
       if (this.additive.live > 0 || this.additive.drawCount > 0) this.additive.update(dt, host);
       if (this.normal.live > 0 || this.normal.drawCount > 0) this.normal.update(dt, host);
@@ -6362,8 +6570,8 @@ var GameFluidsThree = (() => {
      * Takes away the marks inside a box: world `center`, `half` extents along the axes of the world `rotation` (a quaternion, x y z w; none means the
      * world axes). The surface they were on is gone (a brick came out of a wall with its bullet holes). Returns how many went.
      */
-    clearInside(center, half, rotation = [0, 0, 0, 1]) {
-      const qx = -rotation[0], qy = -rotation[1], qz = -rotation[2], qw = rotation[3];
+    clearInside(center, half, rotation2 = [0, 0, 0, 1]) {
+      const qx = -rotation2[0], qy = -rotation2[1], qz = -rotation2[2], qw = rotation2[3];
       let gone = 0;
       for (const decal2 of this.decals) {
         if (!decal2.on) continue;
@@ -6484,10 +6692,14 @@ var GameFluidsThree = (() => {
   var DEFAULT_FADE_IN = 0.1;
   var FLOATS_PER_VECTOR = 3;
   var BYTE_MAX2 = 255;
+  var CARRIED_GRAVITY = 3;
+  var PAD_OF_SIZE3 = 0.35;
   var SpritePool = class {
-    constructor(capacity, context) {
+    /** `carried`: the normal-blend pool (smoke, dust, steam), whose light sprites go round the closed spaces; the additive one (flames, sparks) does not. */
+    constructor(capacity, context, carried = false) {
       __publicField2(this, "capacity", capacity);
       __publicField2(this, "context", context);
+      __publicField2(this, "carried", carried);
       __publicField2(this, "count", 0);
       __publicField2(this, "position");
       __publicField2(this, "velocity");
@@ -6587,6 +6799,7 @@ var GameFluidsThree = (() => {
     }
     update(dt, leaveDecal) {
       const { position, velocity } = this;
+      const confiner = this.context.confiner;
       for (let index = this.count - 1; index >= 0; index--) {
         this.life[index] -= dt;
         if (this.life[index] <= 0) {
@@ -6600,9 +6813,25 @@ var GameFluidsThree = (() => {
         velocity[offset] *= factor;
         velocity[offset + 1] *= factor;
         velocity[offset + 2] *= factor;
+        const x0 = position[offset];
+        const y0 = position[offset + 1];
+        const z0 = position[offset + 2];
         position[offset] += velocity[offset] * dt;
         position[offset + 1] += velocity[offset + 1] * dt;
         position[offset + 2] += velocity[offset + 2] * dt;
+        if (this.carried && confiner && !confiner.empty && Math.abs(this.gravity[index]) < CARRIED_GRAVITY) {
+          const size = this.startSize[index] * (1 + (this.growth[index] - 1) * age);
+          if (confiner.confine(x0, y0, z0, position[offset], position[offset + 1], position[offset + 2], size * PAD_OF_SIZE3, dt)) {
+            const out = confiner.out;
+            position[offset] = out.x;
+            position[offset + 1] = out.y;
+            position[offset + 2] = out.z;
+            const [vx2, vy2, vz2] = slideAlong(out, velocity[offset], velocity[offset + 1], velocity[offset + 2]);
+            velocity[offset] = vx2;
+            velocity[offset + 1] = vy2;
+            velocity[offset + 2] = vz2;
+          }
+        }
         const mode = this.groundMode[index];
         if (mode) {
           const groundHeight = this.context.groundAt(position[offset], position[offset + 2]);
@@ -6879,9 +7108,9 @@ var GameFluidsThree = (() => {
       __publicField2(this, "placement");
       __publicField2(this, "accumulators", /* @__PURE__ */ new Map());
       const profile = options.profile ?? PROFILES.high;
-      this.context = { random: options.random, groundAt: options.groundAt ?? workshopGround, quality: { level: 0, mult: 1 }, trace: options.trace };
+      this.context = { random: options.random, groundAt: options.groundAt ?? workshopGround, quality: { level: 0, mult: 1 }, trace: options.trace, ...options.confiner ? { confiner: options.confiner } : {} };
       this.add = new SpritePool(profile.sprites.add, this.context);
-      this.normal = new SpritePool(profile.sprites.normal, this.context);
+      this.normal = new SpritePool(profile.sprites.normal, this.context, true);
       this.streaks = new StreakPool(profile.streaks, this.context);
       this.debris = new DebrisPool(this.context);
       this.decals = new DecalPool(this.context);
@@ -7069,12 +7298,14 @@ var GameFluidsThree = (() => {
     const groundAt = options.groundAt ?? (ground ? (x, z) => ground.heightAt(x, z) : () => 0);
     const handles = { next: 0, events: 0 };
     const low = options.profile === "low";
+    const enclosures = new Enclosures(20973 + (options.seed ?? 0));
     const spriteSystem = new SpriteKindSystem({
       capacity: options.sprites?.capacity ?? (low ? 1250 : 2500),
       density: options.sprites?.density ?? (low ? 0.6 : 1),
       seed: 2654435761 + (options.seed ?? 0),
       groundAt,
       gravity: options.gravity ?? DEFAULT_GRAVITY,
+      confiner: enclosures,
       ...options.sprites?.kinds ? { kinds: options.sprites.kinds } : {}
     });
     const core = {
@@ -7124,7 +7355,7 @@ var GameFluidsThree = (() => {
       return [camera2.x, camera2.y, camera2.z];
     }, forward: (local2) => [local2[0] ?? 0, local2[1] ?? 0, local2[2] ?? 0] };
     function workshop() {
-      return engine ?? (engine = new WorkshopEngine({ random: sharedRandom, profile, groundAt }));
+      return engine ?? (engine = new WorkshopEngine({ random: sharedRandom, profile, groundAt, confiner: enclosures }));
     }
     function effectPlayer() {
       return player ?? (player = createEffectPlayer({ engine: workshop(), effects, view }));
@@ -7183,6 +7414,10 @@ var GameFluidsThree = (() => {
           puff3.vz += dz * strength;
         }
       },
+      enclose(id, enclosure) {
+        enclosures.set(id, enclosure);
+      },
+      enclosures: () => enclosures,
       stop(handle) {
         player?.stop(handle);
         const fires = core.fires;
@@ -7210,7 +7445,7 @@ var GameFluidsThree = (() => {
         core.clock.time += dt;
         core.schedule.update(core.clock.time);
         updateRings(core.rings, dt);
-        updatePuffs(core.puffs, dt, wind);
+        updatePuffs(core.puffs, dt, wind, enclosures);
         updateSparks(core.sparks, { dt, groundAt });
         updateGlows(core.glows, dt);
         updateShocks(core.shocks, core.puffs.items, dt);
@@ -7688,6 +7923,11 @@ void main(){
   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);
@@ -7711,110 +7951,168 @@ void main(){
     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 rockMaterials = /* @__PURE__ */ new Map();
-    const blood = [];
-    let meshCount = 0;
-    function rockMaterial(color) {
-      let material = rockMaterials.get(color);
-      if (!material) {
-        material = new THREE.MeshStandardMaterial({ color, roughness: 0.9, metalness: 0, flatShading: true });
-        rockMaterials.set(color, material);
-        owned.push(material);
+    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 material;
+      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(mesh2, castShadow = false) {
+      mesh2.castShadow = castShadow;
+      group.add(mesh2);
+      return mesh2;
+    }
+    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 scale2 = new THREE.Vector3();
+    const color = new THREE.Color();
+    const up = new THREE.Vector3(0, 1, 0);
+    function createInstanced(geometry, material, capacity) {
+      const mesh2 = new THREE.InstancedMesh(geometry, material, capacity);
+      mesh2.count = 0;
+      mesh2.frustumCulled = false;
+      mesh2.receiveShadow = true;
+      return mesh2;
+    }
+    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)));
-      const geometry = new THREE.PlaneGeometry(2, 2, steps, steps).rotateX(-Math.PI / 2);
-      const position = geometry.attributes.position;
+      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 cos2 = Math.cos(mark.rotation);
       const sin2 = Math.sin(mark.rotation);
-      for (let index = 0; index < position.count; index++) {
-        const localX = position.getX(index) * radius;
-        const localZ = position.getZ(index) * radius;
+      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 * cos2 - localZ * sin2;
         const worldZ = mark.z + localX * sin2 + localZ * cos2;
-        position.setXYZ(index, worldX, (options.ground?.heightAt(worldX, worldZ) ?? 0) + mark.lift, worldZ);
+        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 mesh2 = new THREE.Mesh(geometry, material);
       mesh2.receiveShadow = true;
-      return mesh2;
+      group.add(mesh2);
+      groundMarks.push({ mesh: mesh2, steps });
     }
     function addRock(mark) {
-      const mesh2 = new THREE.Mesh(mark.plate ? options.plateGeometry : options.rockGeometry, rockMaterial(mark.color));
-      mesh2.position.set(mark.x, mark.y, mark.z);
-      mesh2.scale.set(mark.scale[0], mark.scale[1], mark.scale[2]);
-      mesh2.rotation.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]);
-      mesh2.castShadow = true;
-      mesh2.receiveShadow = true;
-      return mesh2;
+      const mesh2 = mark.plate ? plateMesh() : rockMesh();
+      const slot = mark.plate ? "plate" : "rock";
+      const index = placed[slot]++ % mesh2.instanceMatrix.count;
+      quaternion.setFromEuler(euler.set(mark.rotation[0], mark.rotation[1], mark.rotation[2]));
+      mesh2.setMatrixAt(index, matrix.compose(position.set(mark.x, mark.y, mark.z), quaternion, scale2.set(mark.scale[0], mark.scale[1], mark.scale[2])));
+      mesh2.setColorAt(index, color.set(mark.color));
+      mesh2.count = Math.min(placed[slot], mesh2.instanceMatrix.count);
+      mesh2.instanceMatrix.needsUpdate = true;
+      mesh2.instanceColor.needsUpdate = true;
+    }
+    function writeBlood(index, drawn, growth) {
+      quaternion.setFromAxisAngle(up, drawn.rotation);
+      const mesh2 = bloodMesh();
+      mesh2.setMatrixAt(index, matrix.compose(position.set(drawn.position[0], drawn.position[1], drawn.position[2]), quaternion, scale2.set(drawn.scaleX * growth, 1, drawn.scaleZ * growth)));
+      mesh2.instanceMatrix.needsUpdate = true;
     }
     function addBlood(mark) {
-      const mesh2 = new THREE.Mesh(bloodGeometry, bloodMaterial);
-      mesh2.position.set(mark.x, mark.y, mark.z);
-      mesh2.scale.set(mark.scaleX, 1, mark.scaleZ);
-      mesh2.rotation.y = mark.rotation;
-      mesh2.receiveShadow = true;
-      mesh2.scale.multiplyScalar(0.05);
-      blood.push({ mesh: mesh2, scaleX: mark.scaleX, scaleZ: mark.scaleZ, age: 0 });
-      return mesh2;
+      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") return conform(mark, scorchMaterials[mark.variant]);
-      if (mark.kind === "dirt") return conform(mark, dirtMaterial);
-      if (mark.kind === "rock") return addRock(mark);
-      return addBlood(mark);
-    }
-    function clearMeshes() {
-      for (const child of [...group.children]) {
-        group.remove(child);
-        const geometry = child.geometry;
-        if (geometry !== options.rockGeometry && geometry !== options.plateGeometry && geometry !== bloodGeometry) geometry.dispose();
-      }
+      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;
-      meshCount = 0;
+      placed.blood = placed.rock = placed.plate = 0;
+      for (const mesh2 of [instanced.blood, instanced.rock, instanced.plate]) if (mesh2) mesh2.count = 0;
     }
     return {
       group,
       handle(event) {
-        if (event.type === "clear") {
-          clearMeshes();
-          return;
-        }
-        group.add(build(event.mark));
-        meshCount++;
+        if (event.type === "clear") clearMarks();
+        else build(event.mark);
+      },
+      prepare() {
+        bloodMesh();
+        rockMesh();
+        plateMesh();
       },
       update(dt) {
-        for (const drawn of blood) {
-          if (drawn.age > 1) continue;
+        for (let index = 0; index < blood.length; index++) {
+          const drawn = blood[index];
+          if (!drawn || drawn.age > 1) continue;
           drawn.age += dt * BLOOD_GROW_RATE;
-          const ease3 = 1 - Math.pow(1 - Math.min(1, drawn.age), 2.5);
-          drawn.mesh.scale.set(drawn.scaleX * Math.max(0.05, ease3), 1, drawn.scaleZ * Math.max(0.05, ease3));
+          writeBlood(index, drawn, Math.max(BLOOD_START_GROWTH, 1 - Math.pow(1 - Math.min(1, drawn.age), 2.5)));
         }
       },
-      count: () => meshCount,
+      count: () => groundMarks.length + [instanced.blood, instanced.rock, instanced.plate].filter((mesh2) => mesh2 && mesh2.count > 0).length,
       dispose() {
-        clearMeshes();
+        clearMarks();
+        for (const mesh2 of [instanced.blood, instanced.rock, instanced.plate]) mesh2?.dispose();
         for (const item of owned) item.dispose();
       }
     };
   }
   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(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, false);
+        return new THREE.ConeGeometry(1, 1, particle.segments || void 0, particle.segments2 || 1, false);
       case "cone_open":
-        return new THREE.ConeGeometry(particle.radius, particle.height, particle.segments || void 0, particle.segments2 || 1, true);
+        return new THREE.ConeGeometry(1, 1, particle.segments || void 0, particle.segments2 || 1, true);
       case "sphere":
-        return new THREE.SphereGeometry(particle.radius, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
+        return new THREE.SphereGeometry(1, particle.segments || SPHERE_DEFAULT_WIDTH, particle.segments2 || SPHERE_DEFAULT_HEIGHT);
       case "icosahedron":
-        return new THREE.IcosahedronGeometry(particle.radius, particle.segments);
+        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 } : {} });
@@ -7825,51 +8123,82 @@ void main(){
       (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();
-    function release(mesh2) {
-      mesh2.removeFromParent();
-      mesh2.geometry.dispose();
-      mesh2.material.dispose();
+    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 mesh2 = parked.get(parkingKey)?.pop() ?? new THREE.Mesh(geometryFor(particle), materialOf(THREE, particle));
+      mesh2.material.color.set(particle.color);
+      mesh2.frustumCulled = false;
+      mesh2.renderOrder = particle.additive ? 5 : 3;
+      group.add(mesh2);
+      return { mesh: mesh2, 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() {
-        const live = /* @__PURE__ */ new Set();
+        stamp++;
         for (const particle of pool.particles) {
-          live.add(particle.id);
-          let mesh2 = drawn.get(particle.id);
-          if (!mesh2) {
-            mesh2 = new THREE.Mesh(geometryOf(THREE, particle), materialOf(THREE, particle));
-            mesh2.frustumCulled = false;
-            mesh2.renderOrder = particle.additive ? 5 : 3;
-            drawn.set(particle.id, mesh2);
-            group.add(mesh2);
+          let entry = drawn.get(particle.id);
+          if (!entry) {
+            entry = acquire(particle);
+            drawn.set(particle.id, entry);
           }
+          entry.stamp = stamp;
+          const mesh2 = 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);
           mesh2.position.set(particle.x + offset.x, particle.y + offset.y, particle.z + offset.z);
           turn.setFromEuler(euler.set(particle.rx, particle.ry, particle.rz));
           mesh2.quaternion.copy(frame).multiply(turn);
-          mesh2.scale.setScalar(particle.scale);
+          mesh2.scale.set(particle.radius * particle.scale, (isCone(particle) ? particle.height : particle.radius) * particle.scale, particle.radius * particle.scale);
           mesh2.material.opacity = particle.opacity;
         }
-        for (const [id, mesh2] of drawn) {
-          if (live.has(id)) continue;
-          release(mesh2);
+        for (const [id, entry] of drawn) {
+          if (entry.stamp === stamp) continue;
+          park(entry);
           drawn.delete(id);
         }
         return pool.count;
       },
       dispose() {
-        for (const mesh2 of drawn.values()) release(mesh2);
+        for (const entry of drawn.values()) park(entry);
         drawn.clear();
+        for (const free of parked.values()) for (const mesh2 of free) mesh2.material.dispose();
+        parked.clear();
+        for (const geometry of geometries.values()) geometry.dispose();
+        geometries.clear();
         group.removeFromParent();
       }
     };
@@ -8437,7 +8766,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     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 });
+    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;
@@ -8463,6 +8792,16 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       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();
@@ -8471,15 +8810,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       lastDrawn.shocks = shocks.sync();
       lastDrawn.sprites = sprites.sync();
       lights.sync();
-      const engine = world.peekWorkshop();
-      if (engine && engine !== workshopEngine) {
-        workshopLayers?.dispose();
-        if (workshopLayers) root.remove(workshopLayers.group);
-        workshopEngine = engine;
-        workshopLayers = createWorkshopLayers(THREE, engine, options.pointScale ?? 700, 1);
-        root.add(workshopLayers.group);
-        applyLayers();
-      }
+      attachWorkshopLayers();
       const workshopCalls = workshopLayers?.sync() ?? 0;
       const glow = pools.lights.glow;
       uniforms.uGlowPos.value.set(glow.x, glow.y, glow.z);
@@ -8507,6 +8838,8 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
         });
       },
       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);
@@ -8532,6 +8865,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
       },
       warmUpProbes() {
         releaseAnchors();
+        marks.prepare();
+        world.workshop();
+        attachWorkshopLayers();
         const meshes = createMeshLayerProbes(THREE);
         for (const mesh2 of meshes) mesh2.frustumCulled = false;
         const group = new THREE.Group();
@@ -10574,7 +10910,7 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
     const direction = new THREE.Vector3();
     const location = new THREE.Vector3();
     const scale2 = new THREE.Vector3();
-    const rotation = new THREE.Quaternion();
+    const rotation2 = new THREE.Quaternion();
     const matrix = new THREE.Matrix4();
     return {
       drops,
@@ -10594,9 +10930,9 @@ void main(){vec2 d=gl_PointCoord-.5;float r=length(d)*2.;if(r>1.)discard;float a
           const o = i * 3;
           const speed = Math.hypot(velocity[o], velocity[o + 1], velocity[o + 2]);
           direction.set(velocity[o], velocity[o + 1], velocity[o + 2]).normalize();
-          rotation.setFromUnitVectors(up, direction);
+          rotation2.setFromUnitVectors(up, direction);
           const size = radius[i] * METRES_PER_MM;
-          matrix.compose(location.set(position[o], position[o + 1], position[o + 2]), rotation, scale2.set(size, size * (1 + Math.min(MAX_STRETCH, speed * STRETCH_PER_SPEED)), size));
+          matrix.compose(location.set(position[o], position[o + 1], position[o + 2]), rotation2, scale2.set(size, size * (1 + Math.min(MAX_STRETCH, speed * STRETCH_PER_SPEED)), size));
           drops.setMatrixAt(i, matrix);
           drawn++;
         }