@adatechnology/game-fluids-three 0.4.6 → 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);
@@ -8603,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);
@@ -10673,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,
@@ -10693,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++;
         }