@adatechnology/game-fluids-three 0.1.8 → 0.2.1

package/dist/index.js

@@ -2,6 +2,10 @@ var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
+// src/renderer.ts
+import { createVfx } from "@adatechnology/game-vfx";
+import { createVfxRenderer } from "@adatechnology/game-vfx-three";
+
 // src/clip.ts
 var sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
 var cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
@@ -360,207 +364,65 @@ var MaterialCache = class {
   }
 };
 
-// src/particles.ts
-var VERTEX = (
-  /* glsl */
-  `
-attribute float aSize;
-attribute vec4 aColor;
-attribute float aSoft;
-uniform float uScale;
-varying vec4 vColor;
-varying float vSoft;
-void main() {
-  vColor = aColor;
-  vSoft = aSoft;
-  vec4 mv = modelViewMatrix * vec4(position, 1.0);
-  gl_PointSize = aSize * uScale / max(0.1, -mv.z);
-  gl_Position = projectionMatrix * mv;
-}
-`
-);
-var FRAGMENT = (
-  /* glsl */
-  `
-varying vec4 vColor;
-varying float vSoft;
-void main() {
-  float d = length(gl_PointCoord - vec2(0.5)) * 2.0;
-  if (d > 1.0 || vColor.a <= 0.001) discard;
-  float edge = mix(smoothstep(1.0, 0.8, d), 1.0 - d, vSoft);
-  gl_FragColor = vec4(vColor.rgb, vColor.a * edge);
-}
-`
-);
-var ParticlePool = class {
-  constructor(THREE, capacity, pointScale) {
-    __publicField(this, "THREE", THREE);
-    __publicField(this, "points");
-    __publicField(this, "geometry");
-    __publicField(this, "material");
-    __publicField(this, "capacity");
-    __publicField(this, "next", 0);
-    __publicField(this, "pos");
-    __publicField(this, "size");
-    __publicField(this, "color");
-    __publicField(this, "soft");
-    __publicField(this, "vel");
-    __publicField(this, "life");
-    __publicField(this, "maxLife");
-    __publicField(this, "size0");
-    __publicField(this, "size1");
-    __publicField(this, "alpha");
-    __publicField(this, "floorY");
-    __publicField(this, "kind");
-    __publicField(this, "rgb");
+// src/quality.ts
+var PROFILES = {
+  low: { bodySegments: 10, streamSamples: 8, streamSides: 4, thinDrops: 4, stainSubdiv: 1, maxStains: 24, maxStreams: 12, maxParticles: 96, steamRate: 4, splashDroplets: 5 },
+  medium: { bodySegments: 14, streamSamples: 12, streamSides: 5, thinDrops: 6, stainSubdiv: 2, maxStains: 48, maxStreams: 24, maxParticles: 256, steamRate: 8, splashDroplets: 9 },
+  high: { bodySegments: 20, streamSamples: 20, streamSides: 8, thinDrops: 8, stainSubdiv: 4, maxStains: 96, maxStreams: 48, maxParticles: 512, steamRate: 14, splashDroplets: 14 }
+};
+var profileOf = (q) => PROFILES[q ?? "medium"] ?? PROFILES.medium;
+
+// src/sprites.ts
+var FluidSprites = class {
+  constructor(vfx, owner) {
+    __publicField(this, "vfx", vfx);
+    __publicField(this, "owner", owner);
     __publicField(this, "rng", new Rng(1234567));
-    __publicField(this, "alive", 0);
-    this.capacity = capacity;
-    this.pos = new Float32Array(capacity * 3);
-    this.size = new Float32Array(capacity);
-    this.color = new Float32Array(capacity * 4);
-    this.soft = new Float32Array(capacity);
-    this.vel = new Float32Array(capacity * 3);
-    this.life = new Float32Array(capacity);
-    this.maxLife = new Float32Array(capacity);
-    this.size0 = new Float32Array(capacity);
-    this.size1 = new Float32Array(capacity);
-    this.alpha = new Float32Array(capacity);
-    this.floorY = new Float32Array(capacity);
-    this.kind = new Uint8Array(capacity);
-    this.rgb = new Float32Array(capacity * 3);
-    this.life.fill(0);
-    const T = THREE;
-    this.geometry = new T.BufferGeometry();
-    const attr = (array, n) => {
-      const a = new T.BufferAttribute(array, n);
-      a.setUsage(T.DynamicDrawUsage);
-      return a;
-    };
-    this.geometry.setAttribute("position", attr(this.pos, 3));
-    this.geometry.setAttribute("aSize", attr(this.size, 1));
-    this.geometry.setAttribute("aColor", attr(this.color, 4));
-    this.geometry.setAttribute("aSoft", attr(this.soft, 1));
-    this.material = new T.ShaderMaterial({
-      vertexShader: VERTEX,
-      fragmentShader: FRAGMENT,
-      uniforms: { uScale: { value: pointScale } },
-      transparent: true,
-      depthWrite: false
-    });
-    this.points = new T.Points(this.geometry, this.material);
-    this.points.frustumCulled = false;
-    this.points.renderOrder = 4;
-    this.points.name = "fluid_particles";
-  }
-  get count() {
-    return this.alive;
+    __publicField(this, "thrown", 0);
   }
-  slot() {
-    const i = this.next;
-    this.next = (this.next + 1) % this.capacity;
-    return i;
-  }
-  setColor(i, hex) {
-    this.rgb[i * 3] = (hex >> 16 & 255) / 255;
-    this.rgb[i * 3 + 1] = (hex >> 8 & 255) / 255;
-    this.rgb[i * 3 + 2] = (hex & 255) / 255;
-  }
-  /** Droplets thrown up by an impact; `floorY` is the height they stop at. */
+  /** Droplets thrown up by an impact; they stop at `point[1]`. */
   splash(point, intensity, hex, opacity, count) {
-    const rng = new Rng(hashPoint(point[0], point[1], point[2]) ^ this.next);
+    const rng = new Rng(hashPoint(point[0], point[1], point[2]) ^ this.thrown);
     const n = Math.max(2, Math.round(count * (0.35 + 0.65 * clamp(intensity, 0, 1))));
+    this.thrown += n;
     for (let k = 0; k < n; k++) {
-      const i = this.slot();
       const a = rng.next() * Math.PI * 2;
       const h = (0.25 + rng.next() * 0.9) * (0.4 + intensity);
       const up = (0.7 + rng.next() * 1.5) * (0.5 + intensity);
-      this.pos.set([point[0], point[1] + 0.01, point[2]], i * 3);
-      this.vel.set([Math.cos(a) * h, up, Math.sin(a) * h], i * 3);
-      this.life[i] = this.maxLife[i] = 0.45 + rng.next() * 0.45;
-      this.size0[i] = 0.012 + rng.next() * 0.014;
-      this.size1[i] = this.size0[i] * 0.7;
-      this.alpha[i] = clamp(opacity + 0.2, 0.35, 1);
-      this.soft[i] = 0;
-      this.kind[i] = 0;
-      this.floorY[i] = point[1];
-      this.setColor(i, hex);
+      const life = 0.45 + rng.next() * 0.45;
+      const size = 0.012 + rng.next() * 0.014;
+      this.vfx.spawn("drips", [point[0], point[1] + 0.01, point[2]], [Math.cos(a) * h, up, Math.sin(a) * h], {
+        color: hex,
+        life: life / DRIP_LIFE,
+        size: size / DRIP_SIZE,
+        alpha: clamp(opacity + 0.2, 0.35, 1),
+        floor: point[1]
+      });
     }
   }
   /** One puff of steam rising from `point`. */
   steam(point) {
-    const i = this.slot();
     const r = this.rng;
-    this.pos.set([point[0] + (r.next() - 0.5) * 0.04, point[1], point[2] + (r.next() - 0.5) * 0.04], i * 3);
-    this.vel.set([(r.next() - 0.5) * 0.06, 0.22 + r.next() * 0.12, (r.next() - 0.5) * 0.06], i * 3);
-    this.life[i] = this.maxLife[i] = 1.2 + r.next() * 0.6;
-    this.size0[i] = 0.03;
-    this.size1[i] = 0.1;
-    this.alpha[i] = 0.24;
-    this.soft[i] = 1;
-    this.kind[i] = 1;
-    this.floorY[i] = -1e9;
-    this.setColor(i, 16054527);
-  }
-  update(dt, gravity) {
-    let alive = 0;
-    for (let i = 0; i < this.capacity; i++) {
-      if (this.life[i] <= 0) {
-        this.size[i] = 0;
-        this.color[i * 4 + 3] = 0;
-        continue;
-      }
-      this.life[i] -= dt;
-      const k = 1 - this.life[i] / this.maxLife[i];
-      if (this.life[i] <= 0) {
-        this.size[i] = 0;
-        this.color[i * 4 + 3] = 0;
-        continue;
-      }
-      alive++;
-      if (this.kind[i] === 0) {
-        this.vel[i * 3 + 1] -= gravity * dt;
-      } else {
-        this.vel[i * 3] += Math.sin((k + i) * 7) * 0.02 * dt;
-      }
-      this.pos[i * 3] += this.vel[i * 3] * dt;
-      this.pos[i * 3 + 1] += this.vel[i * 3 + 1] * dt;
-      this.pos[i * 3 + 2] += this.vel[i * 3 + 2] * dt;
-      if (this.kind[i] === 0 && this.pos[i * 3 + 1] < this.floorY[i]) {
-        this.life[i] = 0;
-        alive--;
-        this.size[i] = 0;
-        this.color[i * 4 + 3] = 0;
-        continue;
-      }
-      this.size[i] = this.size0[i] + (this.size1[i] - this.size0[i]) * k;
-      const fade = this.kind[i] === 1 ? Math.min(1, k * 4) * (1 - k) : 1 - k * k;
-      this.color[i * 4] = this.rgb[i * 3];
-      this.color[i * 4 + 1] = this.rgb[i * 3 + 1];
-      this.color[i * 4 + 2] = this.rgb[i * 3 + 2];
-      this.color[i * 4 + 3] = this.alpha[i] * fade;
-    }
-    this.alive = alive;
-    for (const name of ["position", "aSize", "aColor", "aSoft"]) this.geometry.getAttribute(name).needsUpdate = true;
-  }
-  clear() {
-    this.life.fill(0);
-    this.alive = 0;
-    this.update(0, 0);
+    this.vfx.spawn("steam", [point[0] + (r.next() - 0.5) * 0.04, point[1], point[2] + (r.next() - 0.5) * 0.04], [(r.next() - 0.5) * 0.06, 0.22 + r.next() * 0.12, (r.next() - 0.5) * 0.06], {
+      color: STEAM_COLOR,
+      life: (1.2 + r.next() * 0.6) / STEAM_LIFE,
+      size: STEAM_SIZE_FACTOR,
+      alpha: STEAM_ALPHA,
+      rise: STEAM_RISE
+    });
   }
-  dispose() {
-    this.geometry.dispose();
-    this.material.dispose();
+  /** The sprites alive in the world (a shared world counts everyone's). */
+  get count() {
+    return this.vfx.sprites().live;
   }
 };
-
-// src/quality.ts
-var PROFILES = {
-  low: { bodySegments: 10, streamSamples: 8, streamSides: 4, thinDrops: 4, stainSubdiv: 1, maxStains: 24, maxStreams: 12, maxParticles: 96, steamRate: 4, splashDroplets: 5 },
-  medium: { bodySegments: 14, streamSamples: 12, streamSides: 5, thinDrops: 6, stainSubdiv: 2, maxStains: 48, maxStreams: 24, maxParticles: 256, steamRate: 8, splashDroplets: 9 },
-  high: { bodySegments: 20, streamSamples: 20, streamSides: 8, thinDrops: 8, stainSubdiv: 4, maxStains: 96, maxStreams: 48, maxParticles: 512, steamRate: 14, splashDroplets: 14 }
-};
-var profileOf = (q) => PROFILES[q ?? "medium"] ?? PROFILES.medium;
+var DRIP_LIFE = 2.5;
+var DRIP_SIZE = 0.03;
+var STEAM_LIFE = 1.5;
+var STEAM_COLOR = 16054527;
+var STEAM_SIZE_FACTOR = 0.2;
+var STEAM_ALPHA = 0.24 / 0.35;
+var STEAM_RISE = 0.3;
 
 // src/stains.ts
 import { STAIN_SAMPLES } from "@adatechnology/game-fluids";
@@ -650,7 +512,7 @@ var StainVisual = class {
     const mean = stain.front.reduce((s, v) => s + v, 0) / stain.front.length;
     const wet = clamp(stain.wetness, 0, 1);
     const soakRatio = stain.soaked / (stain.soaked + stain.liters + 1e-6);
-    this.tint.setHex(stainColorOf(def));
+    this.tint.setHex(stain.tint?.dry ?? stainColorOf(def));
     const dark = 1 - 0.3 * wet - 0.2 * soakRatio;
     const markAlpha = def.leavesMark ? 0.34 : 0.1;
     const aMid = (markAlpha + (0.62 - markAlpha) * wet) * (0.75 + 0.25 * Math.min(1, stain.liters * 20 + soakRatio));
@@ -660,7 +522,7 @@ var StainVisual = class {
     const showInner = wr > 0.05 && wet > 0.03;
     this.inner.mesh.visible = showInner;
     if (showInner) {
-      this.tint.setHex(def.color);
+      this.tint.setHex(stain.tint?.fresh ?? def.color);
       const shift = stain.flow ? -mean * 0.1 * (1 - wr) : 0;
       const centre = stain.flow ? [stain.center[0] + stain.flow[0] * shift, stain.center[1] + stain.flow[1] * shift, stain.center[2] + stain.flow[2] * shift] : stain.center;
       const a = clamp(def.opacity, 0.2, 0.85) * wet * 0.8;
@@ -905,6 +767,7 @@ var StreamVisual = class {
 };
 
 // src/renderer.ts
+var rendererCount = 0;
 function createFluidRenderer(THREE, options) {
   const { scene, fluids } = options;
   const quality = options.quality ?? "medium";
@@ -913,8 +776,9 @@ function createFluidRenderer(THREE, options) {
   const root = new THREE.Group();
   root.name = "fluid_renderer";
   scene.add(root);
-  const particles = new ParticlePool(THREE, profile.maxParticles, options.pointScale ?? 600);
-  root.add(particles.points);
+  const vfx = options.vfx ?? createVfx({ profile: quality, gravity: fluids.gravity, sprites: { capacity: profile.maxParticles } });
+  const ownVfx = options.vfx ? void 0 : createVfxRenderer(THREE, { scene, camera: options.camera ?? new THREE.PerspectiveCamera(), vfx, pointScale: options.pointScale ?? 600 });
+  const particles = new FluidSprites(vfx, `fluids-${++rendererCount}`);
   const dropGeometry = new THREE.SphereGeometry(1, 8, 6);
   const bodies = /* @__PURE__ */ new Map();
   const streamsActive = /* @__PURE__ */ new Map();
@@ -1023,7 +887,7 @@ function createFluidRenderer(THREE, options) {
       for (const body of bodies.values()) body.update(dt, fluids, materials, profile, particles);
       syncStreams(dt);
       syncStains();
-      particles.update(dt, fluids.gravity);
+      ownVfx?.update(dt);
     },
     clear() {
       for (const v of [...streamsActive.values()]) releaseStream(v);
@@ -1032,7 +896,8 @@ function createFluidRenderer(THREE, options) {
         stainsActive.delete(id);
         stainsFree.push(v);
       }
-      particles.clear();
+      if (ownVfx) vfx.clear();
+      else vfx.sprites().clear();
     },
     dispose() {
       if (disposed) return;
@@ -1046,7 +911,7 @@ function createFluidRenderer(THREE, options) {
       stainsActive.clear();
       streamsFree.length = 0;
       stainsFree.length = 0;
-      particles.dispose();
+      ownVfx?.dispose();
       dropGeometry.dispose();
       materials.dispose();
       scene.remove(root);
@@ -1074,8 +939,777 @@ function createFluidRenderer(THREE, options) {
   };
   return renderer;
 }
+
+// src/film/manager.ts
+import { FILM_PROFILES, filmProfileOf, layoutFromSurfaces } from "@adatechnology/game-fluids";
+
+// src/film/grid.ts
+import { createFilm } from "@adatechnology/game-fluids";
+
+// src/film/drops.ts
+var METRES_PER_MM = 13e-4;
+var STRETCH_PER_SPEED = 0.35;
+var MAX_STRETCH = 3.5;
+var BEAD_HANG = 12e-4;
+var BEAD_SCALE = 11e-4;
+function createFilmDrops(THREE, capacity, profile) {
+  const material = new THREE.MeshStandardMaterial({ color: profile.dropColor, roughness: 0.12, metalness: 0.15, transparent: true, opacity: profile.dropOpacity });
+  const geometry = new THREE.IcosahedronGeometry(1, 1);
+  const drops = new THREE.InstancedMesh(geometry, material, capacity);
+  drops.frustumCulled = false;
+  drops.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
+  drops.name = "film_drops";
+  const beadGeometry = new THREE.SphereGeometry(1, 10, 8);
+  const bead = new THREE.Mesh(beadGeometry, material);
+  bead.visible = false;
+  bead.name = "film_bead";
+  const hidden = new THREE.Matrix4().makeScale(0, 0, 0);
+  for (let i = 0; i < capacity; i++) drops.setMatrixAt(i, hidden);
+  const up = new THREE.Vector3(0, 1, 0);
+  const direction = new THREE.Vector3();
+  const location = new THREE.Vector3();
+  const scale = new THREE.Vector3();
+  const rotation = new THREE.Quaternion();
+  const matrix = new THREE.Matrix4();
+  return {
+    drops,
+    bead,
+    setProfile(next) {
+      material.color.setHex(next.dropColor);
+      material.opacity = next.dropOpacity;
+    },
+    sync(film) {
+      const { active, position, velocity, radius } = film.drops;
+      let drawn = 0;
+      for (let i = 0; i < capacity; i++) {
+        if (!active[i]) {
+          drops.setMatrixAt(i, hidden);
+          continue;
+        }
+        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);
+        const size = radius[i] * METRES_PER_MM;
+        matrix.compose(location.set(position[o], position[o + 1], position[o + 2]), rotation, scale.set(size, size * (1 + Math.min(MAX_STRETCH, speed * STRETCH_PER_SPEED)), size));
+        drops.setMatrixAt(i, matrix);
+        drawn++;
+      }
+      drops.instanceMatrix.needsUpdate = true;
+      const state = film.bead;
+      bead.visible = state.visible;
+      if (state.visible) {
+        const r = state.radius;
+        bead.position.set(state.position[0], state.position[1] - r * BEAD_HANG, state.position[2]);
+        bead.scale.set(r * BEAD_SCALE, r * BEAD_SCALE * (1 + state.swell * 0.7), r * BEAD_SCALE);
+      }
+      return drawn;
+    },
+    dispose() {
+      geometry.dispose();
+      beadGeometry.dispose();
+      material.dispose();
+    }
+  };
+}
+
+// src/film/shader.ts
+var FILM_VERTEX = `attribute vec3 aB;attribute vec3 aT;varying vec2 vUv;varying vec3 vPos;varying vec3 vN;varying vec3 vB;varying vec3 vT;
+void main(){vUv=uv;vPos=position;vN=normal;vB=aB;vT=aT;gl_Position=projectionMatrix*viewMatrix*vec4(position,1.);}`;
+var FILM_FRAGMENT = `precision highp float;
+uniform sampler2D tF;uniform vec2 tx;uniform vec2 uGrid;uniform float uSpan;uniform float uT;uniform int uFl;uniform vec3 cThin,cThick,cDry,cDryThin,uBase;uniform float opK,F0,nrm,dbg;
+uniform vec3 camP,lampP,flashP,flashD;varying vec2 vUv;varying vec3 vPos;varying vec3 vN;varying vec3 vB;varying vec3 vT;
+float hsh(vec2 p){p=fract(p*vec2(123.34,456.21));p+=dot(p,p+45.32);return fract(p.x*p.y);}
+vec2 hsh2(vec2 p){return vec2(hsh(p),hsh(p+17.7));}
+float nz(vec2 p){vec2 i=floor(p),f=fract(p);f=f*f*(3.-2.*f);return mix(mix(hsh(i),hsh(i+vec2(1,0)),f.x),mix(hsh(i+vec2(0,1)),hsh(i+vec2(1,1)),f.x),f.y);}
+float vor(vec2 p){vec2 i=floor(p),f=fract(p);float d1=8.,d2=8.;for(int y=-1;y<=1;y++)for(int x=-1;x<=1;x++){vec2 o=vec2(float(x),float(y));vec2 r=o+hsh2(i+o)-f;float d=dot(r,r);if(d<d1){d2=d1;d1=d;}else if(d<d2)d2=d;}return sqrt(d2)-sqrt(d1);}
+float hs(vec2 u){float r=texture2D(tF,u).r;return r*r*6.;}
+void main(){
+  vec4 S=texture2D(tF,vUv);vec2 q=tx*.5;float h=.25*(hs(vUv+q)+hs(vUv-q)+hs(vUv+vec2(q.x,-q.y))+hs(vUv+vec2(-q.x,q.y)));float dry=S.g;float wg=S.b;
+  vec2 o1=vec2(tx.x*1.5,0.),o2=vec2(0.,tx.y*1.5);
+  float hl=hs(vUv-o1),hr=hs(vUv+o1),hd=hs(vUv-o2),hu=hs(vUv+o2);
+  vec2 g=vec2(hr-hl,hu-hd)/37.5;
+  vec2 cellp=vUv*uGrid;
+  float n1=nz(cellp*2.3),n2=nz(cellp*7.1);
+  float hn=h+(n1-.5)*.045+(n2-.5)*.02;
+  float m=smoothstep(.035,.08,hn);
+  if(uFl==4){float wa=.25*(texture2D(tF,vUv+q).b+texture2D(tF,vUv-q).b+texture2D(tF,vUv+vec2(q.x,-q.y)).b+texture2D(tF,vUv+vec2(-q.x,q.y)).b);m=smoothstep(.35,.75,wa+(n1-.5)*.25)*smoothstep(.0,.012,h);wg=smoothstep(.2,.8,wa+(n1-.5)*.2);}
+  vec2 p=vec2(dot(vPos,normalize(vT)),vUv.y*uSpan);
+  vec3 base=uBase;
+  vec3 T=normalize(vT),Bv=normalize(vB),N0=normalize(vN);
+  vec3 nt=vec3(-g*nrm*m,1.);
+  float dryM=smoothstep(.5,.95,dry);
+  float wet=(1.-dryM)*m;
+  // bile bubbles
+  float bub=0.;
+  if(uFl==2){vec2 bp=cellp/2.6;vec2 bi=floor(bp);vec2 bf=fract(bp)-.5;float rnd=hsh(bi);
+    if(rnd>.5&&h>1.1){float t=fract(uT*(.18+.25*hsh(bi+3.1))+rnd*7.);float rad=.42*smoothstep(0.,.8,t);float d=length(bf-(hsh2(bi+9.)-.5)*.2);
+      if(t<.86&&d<rad){float z=sqrt(max(0.,rad*rad-d*d));nt.xy+=(bf/max(rad,.01))*2.2*(1.-dryM);bub=z/rad;}
+      else if(t>=.86){float rr=.42*1.15;float ring=1.-smoothstep(0.,.07,abs(d-rr*(.9+(t-.86)*.8)));nt.xy-=normalize(bf+.0001)*ring*.8*(1.-dryM);bub=-ring;}}}
+  if(uFl==4){vec2 wp=p;nt.xy+=.05*m*vec2(nz(wp*9.+vec2(uT*1.7,0.))-.5,nz(wp*9.+vec2(0.,uT*1.4)+7.)-.5)*2.;}
+  vec3 Nf=normalize(T*nt.x+Bv*nt.y+N0*nt.z);
+  // albedo
+  float th=smoothstep(.1,1.7,h);
+  vec3 fc=mix(cThin,cThick,th);
+  float op=clamp(1.-exp(-h*opK),0.,1.);
+  vec3 alb;
+  if(uFl==4){alb=base*mix(vec3(1.),cThin*1.15,clamp(h*.9,0.,1.));}
+  else{alb=mix(base*mix(vec3(1.),fc*1.6,clamp(h*2.,0.,1.)),fc,op);}
+  if(uFl==2&&bub>0.)alb=mix(alb,cThin*1.25,bub*.5);
+  // dried look: matte, darker rim, cracks where it was thick
+  float rim=smoothstep(.01,.05,length(g))*(1.-smoothstep(.4,1.,h));
+  vec3 dc=mix(cDryThin,cDry,smoothstep(.06,.8,h))*(1.-.42*rim);
+  float crk=(1.-smoothstep(.015,.05,vor(p*(uFl==2?34.:52.))))*smoothstep(.9,1.6,h);
+  dc=mix(dc,base*.55,crk*.75);
+  if(uFl!=3&&uFl!=4)alb=mix(alb,mix(base,dc,clamp(.4+h*1.4,0.,1.)),dryM);
+  // gasoline darkens the ground while wet
+  float gw=0.;if(uFl==4){gw=wg*(1.-m*.0);base*=mix(1.,.45,gw);alb=mix(base,alb,m);}
+  vec3 col0=mix(base,alb*(uFl<2?mix(.62,1.,dryM):1.),m);
+  // lighting
+  vec3 V=normalize(camP-vPos);
+  vec3 Lv=lampP-vPos;float dl=length(Lv);vec3 L=Lv/dl;float att=2.2/(1.+dl*dl*.12);
+  vec3 lampC=vec3(1.,.88,.7);vec3 moonD=normalize(vec3(-3.,5.,4.));vec3 moonC=vec3(.11,.14,.19);vec3 amb=vec3(.14,.15,.17);
+  vec3 Fv=flashP-vPos;float fd=length(Fv);vec3 FL=Fv/fd;float cone=smoothstep(.86,.97,dot(-FL,flashD));float fatt=cone*1.1/(1.+fd*fd*.6);
+  vec3 dif=col0*(amb+lampC*att*max(dot(Nf,L),0.)+moonC*max(dot(Nf,moonD),0.)+vec3(.95,.97,1.)*fatt*max(dot(Nf,FL),0.));
+  float wv=max(wet,gw*.7);
+  float shin=mix(30.,320.,wv);
+  vec3 Hh=normalize(L+V);vec3 Hf=normalize(FL+V);
+  float sp=pow(max(dot(Nf,Hh),0.),shin)*shin*.011*att;float spf=pow(max(dot(Nf,Hf),0.),shin)*shin*.008*fatt;
+  vec3 R=reflect(-V,Nf);
+  vec3 env=mix(vec3(.03,.035,.04),vec3(.15,.17,.21),clamp(R.y*1.4,0.,1.));
+  env+=lampC*(pow(max(dot(R,L),0.),500.)*7.+pow(max(dot(R,L),0.),40.)*.6)*att;
+  float fr=F0+(1.-F0)*pow(1.-max(dot(Nf,V),0.),5.);
+  vec3 col=dif*(1.-fr*wv*.7)+(env*min(1.,fr*(uFl==4?1.6:3.4))+min(lampC*sp+vec3(.9,.95,1.)*spf,vec3(.85)))*wv;
+  if(uFl==3){float film=(1.-smoothstep(.04,.55,h))*m;vec3 ir=.5+.5*cos(6.283*(h*7.+n1*.5+uT*.03+vec3(0.,.33,.67)));col+=ir*film*(.10+.5*fr)*(.6+att*.4);}
+  if(uFl==4){vec2 wp=p;float film=m*(.4+.6*(1.-smoothstep(.02,.2,h)));vec3 ir=.5+.5*cos(6.283*(nz(wp*6.)*1.4+uT*.02+vec3(0.,.33,.67)));col+=ir*film*.05*(.3+fr*3.);}
+  if(dbg>.5){float k=clamp(h/3.,0.,1.);vec3 hc=mix(vec3(.05,.1,.5),vec3(1.,.9,.2),k);hc=mix(hc,vec3(1.,.2,.1),step(.66,k));col=mix(base*.25,mix(hc,vec3(.6),dryM*.7),step(.004,h));}
+  float cover=max(m,gw*.55);
+  gl_FragColor=vec4(pow(max(col,vec3(0.)),vec3(2.2)),clamp(cover,0.,1.));
+  #include <colorspace_fragment>
+}`;
+
+// src/film/material.ts
+var LOOK_INDEX = { blood: 0, bile: 2, oil: 3, fuel: 4 };
+var DEFAULT_SPAN = 4.95;
+var rgb = (THREE, target, hex) => {
+  target.set((hex >> 16 & 255) / 255, (hex >> 8 & 255) / 255, (hex & 255) / 255);
+};
+function createFilmMaterial(THREE, texture, width, height, span = DEFAULT_SPAN) {
+  const V3 = THREE.Vector3;
+  const uniforms = {
+    tF: { value: texture },
+    tx: { value: new THREE.Vector2(1 / width, 1 / height) },
+    uGrid: { value: new THREE.Vector2(width, height) },
+    uSpan: { value: span },
+    uT: { value: 0 },
+    uFl: { value: 0 },
+    cThin: { value: new V3() },
+    cThick: { value: new V3() },
+    cDry: { value: new V3() },
+    cDryThin: { value: new V3() },
+    uBase: { value: new V3(0.4, 0.4, 0.38) },
+    opK: { value: 3 },
+    F0: { value: 0.03 },
+    nrm: { value: 16 },
+    camP: { value: new V3() },
+    lampP: { value: new V3() },
+    flashP: { value: new V3() },
+    flashD: { value: new V3(0, 0, -1) },
+    dbg: { value: 0 }
+  };
+  const material = new THREE.ShaderMaterial({
+    uniforms,
+    vertexShader: FILM_VERTEX,
+    fragmentShader: FILM_FRAGMENT,
+    transparent: true,
+    depthWrite: false,
+    // the layout's axes may be either handed (the page's strips were all built facing out)
+    side: THREE.DoubleSide,
+    polygonOffset: true,
+    polygonOffsetFactor: -2,
+    polygonOffsetUnits: -2
+  });
+  return {
+    material,
+    setProfile(profile) {
+      uniforms.uFl.value = LOOK_INDEX[profile.look];
+      rgb(THREE, uniforms.cThin.value, profile.thin);
+      rgb(THREE, uniforms.cThick.value, profile.thick);
+      rgb(THREE, uniforms.cDry.value, profile.dry);
+      rgb(THREE, uniforms.cDryThin.value, profile.dryThin);
+      uniforms.opK.value = profile.opacityRate;
+      uniforms.F0.value = profile.reflectance;
+      uniforms.nrm.value = profile.normalScale;
+    },
+    dispose() {
+      material.dispose();
+    }
+  };
+}
+
+// src/film/strips.ts
+var SEGMENTS_ACROSS = 8;
+var SEGMENTS_ALONG = 8;
+function createStripGeometry(THREE, layout, region) {
+  const { width, height, cellSize } = layout;
+  const alongSegments = region.rowCount <= 2 ? 1 : SEGMENTS_ALONG;
+  const position = [];
+  const normal = [];
+  const uv = [];
+  const down = [];
+  const across = [];
+  const index = [];
+  for (let j = 0; j <= alongSegments; j++) {
+    const t = j / alongSegments;
+    for (let i = 0; i <= SEGMENTS_ACROSS; i++) {
+      const u = i / SEGMENTS_ACROSS;
+      for (let k = 0; k < 3; k++) position.push(region.origin[k] + region.columnAxis[k] * u * width * cellSize + region.rowAxis[k] * t * region.rowCount * cellSize);
+      normal.push(region.normal[0], region.normal[1], region.normal[2]);
+      down.push(region.rowAxis[0], region.rowAxis[1], region.rowAxis[2]);
+      across.push(region.columnAxis[0], region.columnAxis[1], region.columnAxis[2]);
+      uv.push(u, (region.firstRow + t * region.rowCount) / height);
+    }
+  }
+  for (let j = 0; j < alongSegments; j++) {
+    for (let i = 0; i < SEGMENTS_ACROSS; i++) {
+      const a = j * (SEGMENTS_ACROSS + 1) + i;
+      const b = a + 1;
+      const c = a + SEGMENTS_ACROSS + 1;
+      index.push(a, c, b, b, c, c + 1);
+    }
+  }
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute("position", new THREE.Float32BufferAttribute(position, 3));
+  geometry.setAttribute("normal", new THREE.Float32BufferAttribute(normal, 3));
+  geometry.setAttribute("uv", new THREE.Float32BufferAttribute(uv, 2));
+  geometry.setAttribute("aB", new THREE.Float32BufferAttribute(down, 3));
+  geometry.setAttribute("aT", new THREE.Float32BufferAttribute(across, 3));
+  geometry.setIndex(index);
+  return geometry;
+}
+
+// src/film/grid.ts
+var MAX_THICKNESS = 6;
+var CHANNEL = 255;
+var VISIBLE_THICKNESS = 0.035;
+var DEFAULT_BASE = 6710881;
+var MIN_CHANGE = 2;
+var CHANGE_FRACTION = 5e-3;
+var LAMP_OFFSET = [0.9, 2.9, 0.4];
+var FilmGrid = class {
+  constructor(THREE, options) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "film");
+    __publicField(this, "group");
+    __publicField(this, "texture");
+    __publicField(this, "center");
+    __publicField(this, "tint");
+    __publicField(this, "data");
+    /** Seconds the grid has been without anything landing, flowing or drying. */
+    __publicField(this, "idle", 0);
+    /** Set once the whole texture went to the GPU (the partial uploads need it there first). */
+    __publicField(this, "uploaded", false);
+    __publicField(this, "strips", []);
+    __publicField(this, "material");
+    __publicField(this, "dropsView");
+    __publicField(this, "previous", null);
+    __publicField(this, "pending", null);
+    __publicField(this, "launched", 0);
+    __publicField(this, "lastWet", 0);
+    const { layout, profile } = options;
+    this.center = options.center;
+    this.tint = options.tint;
+    this.film = createFilm({ layout, profile, random: options.random, ...options.stepRate ? { stepRate: options.stepRate } : {}, ...options.maxSteps ? { maxSteps: options.maxSteps } : {} });
+    this.data = new Uint8Array(new ArrayBuffer(layout.width * layout.height * 4));
+    this.texture = new THREE.DataTexture(this.data, layout.width, layout.height, THREE.RGBAFormat);
+    this.texture.magFilter = THREE.LinearFilter;
+    this.texture.minFilter = THREE.LinearFilter;
+    this.texture.needsUpdate = true;
+    this.texture.onUpdate = () => {
+      this.uploaded = true;
+    };
+    this.material = createFilmMaterial(THREE, this.texture, layout.width, layout.height, layout.height * layout.cellSize);
+    this.material.setProfile(profile);
+    this.group = new THREE.Group();
+    this.group.name = "film_grid";
+    for (const region of layout.regions) {
+      const mesh = new THREE.Mesh(createStripGeometry(THREE, layout, region), this.material.material);
+      mesh.frustumCulled = false;
+      mesh.renderOrder = 3;
+      mesh.name = `film_${region.id}`;
+      this.strips.push(mesh);
+      this.group.add(mesh);
+    }
+    this.dropsView = createFilmDrops(THREE, layout.rules.dropCapacity, profile);
+    this.group.add(this.dropsView.drops, this.dropsView.bead);
+    const uniforms = this.material.material.uniforms;
+    const base = options.base ?? DEFAULT_BASE;
+    uniforms.uBase.value.set((base >> 16 & 255) / 255, (base >> 8 & 255) / 255, (base & 255) / 255);
+    uniforms.lampP.value.set(this.center[0] + LAMP_OFFSET[0], this.center[1] + LAMP_OFFSET[1], this.center[2] + LAMP_OFFSET[2]);
+    this.launched = this.film.drops.launched;
+  }
+  get profile() {
+    return this.film.profile;
+  }
+  setProfile(profile) {
+    this.film.profile = profile;
+    this.material.setProfile(profile);
+    this.dropsView.setProfile(profile);
+  }
+  /** Where the film's light and eye are (the page's `camP`, `flashP` and `flashD`). */
+  setView(camera, forward, time) {
+    const uniforms = this.material.material.uniforms;
+    uniforms.camP.value.set(camera[0], camera[1], camera[2]);
+    uniforms.flashP.value.set(camera[0] + 0.12, camera[1] - 0.15, camera[2]);
+    uniforms.flashD.value.set(forward[0], forward[1], forward[2]);
+    uniforms.uT.value = time;
+  }
+  /** Steps the film one frame and refreshes the texture cells that may have changed. Returns the rectangle to upload, or null. */
+  update(dt, dryingSeconds) {
+    this.film.update({ dt, dryingSeconds });
+    const bounds = this.film.simulator.bounds;
+    const launched = this.film.drops.launched;
+    const busy = launched !== this.launched || this.film.drip !== void 0 || this.film.sources.length > 0 || this.film.drags.some((drag) => !drag.done) || this.dropsInFlight();
+    this.launched = launched;
+    const current = bounds.lastRow < 0 ? null : { firstRow: bounds.firstRow, lastRow: bounds.lastRow, firstColumn: bounds.firstColumn, lastColumn: bounds.lastColumn };
+    const rect = this.union(this.previous, current);
+    this.previous = current;
+    const wet = current ? this.film.wetCells() : 0;
+    const moved = Math.abs(wet - this.lastWet) > Math.max(MIN_CHANGE, wet * CHANGE_FRACTION);
+    this.idle = busy || moved ? 0 : this.idle + dt;
+    if (moved || busy) this.lastWet = wet;
+    if (!rect) return this.takePending();
+    this.encode(rect);
+    this.pending = this.union(this.pending, rect);
+    return this.takePending();
+  }
+  takePending() {
+    const rect = this.pending;
+    this.pending = null;
+    return rect;
+  }
+  /** The mean dryness of the cells that are wet (1 when nothing is). */
+  dryness() {
+    const { thickness, dryness } = this.film.field;
+    let wet = 0;
+    let dry = 0;
+    for (let i = 0; i < thickness.length; i++) {
+      if (thickness[i] > VISIBLE_THICKNESS) {
+        wet++;
+        dry += dryness[i];
+      }
+    }
+    return wet === 0 ? 1 : dry / wet;
+  }
+  /** Draws the drops and the bead; answers how many drops are in flight. */
+  syncDrops() {
+    return this.dropsView.sync(this.film);
+  }
+  dropsInFlight() {
+    const { active } = this.film.drops;
+    for (let i = 0; i < active.length; i++) if (active[i]) return true;
+    return false;
+  }
+  /** Writes the cells of the texture from the field, as the page's `upload` does (F360). */
+  encode(rect) {
+    const { thickness, dryness, dampness, width } = this.film.field;
+    const data = this.data;
+    for (let row = rect.firstRow; row <= rect.lastRow; row++) {
+      for (let column = rect.firstColumn; column <= rect.lastColumn; column++) {
+        const cell = row * width + column;
+        const j = cell * 4;
+        const h = thickness[cell];
+        data[j] = h > 0 ? Math.min(CHANNEL, Math.sqrt(Math.min(MAX_THICKNESS, h) / MAX_THICKNESS) * CHANNEL + 0.5) : 0;
+        data[j + 1] = dryness[cell] * CHANNEL;
+        data[j + 2] = dampness[cell] * CHANNEL;
+        data[j + 3] = CHANNEL;
+      }
+    }
+  }
+  /** Encodes the whole field (a grid made from a state, or after `clear`). */
+  encodeAll() {
+    this.encode({ firstRow: 0, lastRow: this.film.field.height - 1, firstColumn: 0, lastColumn: this.film.field.width - 1 });
+    this.texture.needsUpdate = true;
+    this.uploaded = false;
+  }
+  union(a, b) {
+    if (!a) return b ? { ...b } : null;
+    if (!b) return { ...a };
+    return { firstRow: Math.min(a.firstRow, b.firstRow), lastRow: Math.max(a.lastRow, b.lastRow), firstColumn: Math.min(a.firstColumn, b.firstColumn), lastColumn: Math.max(a.lastColumn, b.lastColumn) };
+  }
+  dispose() {
+    for (const mesh of this.strips) mesh.geometry.dispose();
+    this.material.dispose();
+    this.dropsView.dispose();
+    this.texture.dispose();
+  }
+};
+
+// src/film/manager.ts
+var DEFAULT_MAX_GRIDS = 6;
+var DEFAULT_RANGE = 30;
+var DEFAULT_BUDGET_MS = 1.2;
+var DEFAULT_SETTLE_SECONDS = 20;
+var DEFAULT_MAX_STAGING = 16;
+var DEFAULT_GRID_METRES = 2;
+var DEFAULT_CELL = 0.0125;
+var BAKE_RANGE_FACTOR = 1.25;
+var EDGE_MARGIN = 0.35;
+var FLOOR_REACH = 0.3;
+var DROP_HEIGHT = 2.5;
+var DEFAULT_DROP_RADIUS = 3;
+var FALL_SPEED = 2;
+var VISIBLE_THICKNESS2 = 0.035;
+var DEFAULT_HALF = 50;
+var FREE_AFTER_EMPTY = 2;
+var THICK_FACTOR = 0.55;
+var sameTint = (a, b) => a?.fresh === b?.fresh && a?.dry === b?.dry;
+var scaleColor = (hex, factor) => Math.round((hex >> 16 & 255) * factor) << 16 | Math.round((hex >> 8 & 255) * factor) << 8 | Math.round((hex & 255) * factor);
+function tinted(profile, tint) {
+  return { ...profile, thin: tint.fresh, thick: scaleColor(tint.fresh, THICK_FACTOR), dry: tint.dry, dryThin: tint.dry, dropColor: tint.fresh };
+}
+var distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+var FilmManager = class {
+  constructor(THREE, options) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "options", options);
+    __publicField(this, "group");
+    __publicField(this, "grids", []);
+    __publicField(this, "profiles");
+    __publicField(this, "staging", /* @__PURE__ */ new Map());
+    __publicField(this, "now");
+    __publicField(this, "rain", 0);
+    __publicField(this, "time", 0);
+    __publicField(this, "bakedCount", 0);
+    __publicField(this, "last", { grids: 0, drops: 0, wetCells: 0, simMs: 0, starved: 0, baked: 0, uploadedTexels: 0 });
+    __publicField(this, "empties", /* @__PURE__ */ new Map());
+    this.group = new THREE.Group();
+    this.group.name = "film_manager";
+    options.scene.add(this.group);
+    this.profiles = options.profiles ?? Object.fromEntries(FILM_PROFILES.map((profile) => [profile.id, profile]));
+    this.now = options.now ?? (() => typeof performance === "undefined" ? Date.now() : performance.now());
+  }
+  get gridCount() {
+    return this.grids.length;
+  }
+  /** The grids, for a host that wants to look at them (a bench, a test). */
+  list() {
+    return this.grids;
+  }
+  setWeather(weather) {
+    this.rain = Math.min(1, Math.max(0, weather.rain));
+    for (const grid of this.grids) grid.film.setWeather({ rain: this.rain });
+  }
+  /** Throws a drop of a liquid: it lands in the grid under it (made on the spot) and leaves the impact splash. Null when it is out of range or has no surface. */
+  launch(request) {
+    const grid = this.gridFor(request.fluid, request.point, request.surfaces, request.tint);
+    if (!grid) return null;
+    const velocity = request.velocity ?? [0, -FALL_SPEED, 0];
+    grid.film.launch(request.point, velocity, request.radius ?? DEFAULT_DROP_RADIUS);
+    return grid;
+  }
+  /** A drip: a bead swells at `point`, detaches and falls every `every` seconds on average. Replaces the grid's drip. */
+  drip(spec) {
+    const grid = this.gridFor(spec.fluid, spec.point, spec.surfaces, spec.tint);
+    if (!grid) return null;
+    grid.film.drip = { position: [spec.point[0], spec.point[1], spec.point[2]], every: spec.every, base: spec.every, elapsed: 0, radius: spec.radius ?? DEFAULT_DROP_RADIUS };
+    return grid;
+  }
+  /** The grid of a liquid that covers `point`, made when there is none. Null when `point` is out of range or has no surface under it. */
+  gridFor(fluid, point, surfaces, tint) {
+    const viewer = this.viewer();
+    if (viewer && distance(viewer.position, point) > (this.options.range ?? DEFAULT_RANGE)) return null;
+    const existing = this.grids.find((grid2) => grid2.profile.id === fluid && sameTint(grid2.tint, tint) && this.covers(grid2, point));
+    if (existing) return existing;
+    const base = this.profiles[fluid] ?? filmProfileOf(fluid);
+    if (!base) return null;
+    const profile = tint ? tinted(base, tint) : base;
+    const found = surfaces ?? this.surfacesAt(point);
+    if (!found) return null;
+    const layout = layoutFromSurfaces({ ...found, center: point, columns: this.columns(), rows: this.columns(), cellSize: this.options.cellSize ?? DEFAULT_CELL });
+    if (this.grids.length >= (this.options.maxGrids ?? DEFAULT_MAX_GRIDS)) this.evict(point);
+    const grid = new FilmGrid(this.THREE, { layout, profile, random: this.options.random, center: point, ...tint ? { tint } : {}, ...this.options.base === void 0 ? {} : { base: this.options.base } });
+    grid.film.setWeather({ rain: this.rain });
+    this.grids.push(grid);
+    this.group.add(grid.group);
+    return grid;
+  }
+  /** One frame: simulates the grids near the player inside the budget, uploads what changed, bakes the ones that are far or still. */
+  update(dt) {
+    this.time += dt;
+    const viewer = this.viewer();
+    const range = this.options.range ?? DEFAULT_RANGE;
+    const budget = this.options.budgetMs ?? DEFAULT_BUDGET_MS;
+    const drying = dt * (this.options.dryingSpeed ?? 1);
+    const order = [...this.grids].sort((a, b) => viewer ? distance(viewer.position, a.center) - distance(viewer.position, b.center) : 0);
+    const start = this.now();
+    let starved = 0;
+    let uploaded = 0;
+    for (const grid of order) {
+      if (viewer && distance(viewer.position, grid.center) > range * BAKE_RANGE_FACTOR) {
+        this.release(grid, "range");
+        continue;
+      }
+      if (this.now() - start > budget) {
+        starved++;
+        continue;
+      }
+      if (viewer) grid.setView(viewer.position, viewer.forward, this.time);
+      const rect = grid.update(dt, drying);
+      grid.syncDrops();
+      if (rect) uploaded += this.upload(grid, rect);
+      if (this.emptyFor(grid, dt) || grid.idle > (this.options.settleSeconds ?? DEFAULT_SETTLE_SECONDS)) this.release(grid, "settled");
+    }
+    let drops = 0;
+    let wet = 0;
+    for (const grid of this.grids) {
+      const { active } = grid.film.drops;
+      for (let i = 0; i < active.length; i++) drops += active[i];
+      wet += grid.film.wetCells();
+    }
+    this.last = { grids: this.grids.length, drops, wetCells: wet, simMs: this.now() - start, starved, baked: this.bakedCount, uploadedTexels: uploaded };
+    return this.last;
+  }
+  stats() {
+    return this.last;
+  }
+  /** Frees every grid. `bake` leaves each one's film as a stain first. */
+  clear(bake = false) {
+    for (const grid of [...this.grids]) {
+      if (bake) this.release(grid, "clear");
+      else this.free(grid);
+    }
+  }
+  dispose() {
+    this.clear();
+    for (const texture of this.staging.values()) texture.dispose();
+    this.staging.clear();
+    this.options.scene.remove(this.group);
+  }
+  // ---- internals ----
+  columns() {
+    return Math.round((this.options.gridMetres ?? DEFAULT_GRID_METRES) / (this.options.cellSize ?? DEFAULT_CELL));
+  }
+  viewer() {
+    if (this.options.viewer) return this.options.viewer();
+    const camera = this.options.camera;
+    if (!camera) return null;
+    const forward = new this.THREE.Vector3();
+    camera.getWorldDirection(forward);
+    return { position: [camera.position.x, camera.position.y, camera.position.z], forward: [forward.x, forward.y, forward.z] };
+  }
+  surfacesAt(point) {
+    if (this.options.surfaceAt) return this.options.surfaceAt(point);
+    const y = this.options.groundAt?.(point[0], point[2]) ?? 0;
+    return { floor: { id: "film_ground", point: [point[0], y, point[2]], normal: [0, 1, 0], halfSize: [DEFAULT_HALF, DEFAULT_HALF], porosity: 0 } };
+  }
+  /** Whether `point` is over the grid, away from its edge, so a splash there does not fall off the strip. */
+  covers(grid, point) {
+    const layout = grid.film.layout;
+    const wide = layout.width * layout.cellSize;
+    for (const region of layout.regions) {
+      const local = [point[0] - region.origin[0], point[1] - region.origin[1], point[2] - region.origin[2]];
+      const above = local[0] * region.normal[0] + local[1] * region.normal[1] + local[2] * region.normal[2];
+      if (above < -FLOOR_REACH || above > DROP_HEIGHT) continue;
+      const sideways = local[0] * region.columnAxis[0] + local[1] * region.columnAxis[1] + local[2] * region.columnAxis[2];
+      const down = local[0] * region.rowAxis[0] + local[1] * region.rowAxis[1] + local[2] * region.rowAxis[2];
+      const length = region.rowCount * layout.cellSize;
+      if (sideways > EDGE_MARGIN && sideways < wide - EDGE_MARGIN && down > EDGE_MARGIN && down < length - EDGE_MARGIN) return true;
+    }
+    return false;
+  }
+  /** The grid squeezed out for a new one at `point`: the one that has been still the longest, then the farthest from the player. */
+  evict(point) {
+    const viewer = this.viewer();
+    const score = (grid) => grid.idle * 10 + (viewer ? distance(viewer.position, grid.center) : distance(point, grid.center));
+    const victim = [...this.grids].sort((a, b) => score(b) - score(a))[0];
+    if (victim) this.release(victim, "budget");
+  }
+  /** A grid that has nothing wet for two seconds goes without a trace. */
+  emptyFor(grid, dt) {
+    if (grid.film.wetCells() > 0 || grid.dropsInFlight() || grid.film.drip || grid.film.sources.length > 0) {
+      this.empties.delete(grid);
+      return false;
+    }
+    const seconds = (this.empties.get(grid) ?? 0) + dt;
+    this.empties.set(grid, seconds);
+    return seconds > FREE_AFTER_EMPTY;
+  }
+  free(grid) {
+    const at = this.grids.indexOf(grid);
+    if (at < 0) return;
+    this.grids.splice(at, 1);
+    this.empties.delete(grid);
+    this.group.remove(grid.group);
+    grid.dispose();
+  }
+  /** Bakes the film of a grid into the host's stain decals and frees the grid. */
+  release(grid, reason) {
+    const bake = this.measure(grid, reason);
+    this.free(grid);
+    if (!bake) return;
+    this.bakedCount++;
+    this.options.fluids?.splash(bake.fluid, bake.point, bake.liters, void 0, { tint: bake.tint });
+    this.options.onBake?.(bake);
+  }
+  /** The film's centre of volume, its litres (millimetres of film times cell area) and the radius of the wet cells. */
+  measure(grid, reason) {
+    const { thickness } = grid.film.field;
+    const { width, cellSize } = grid.film.layout;
+    let volume = 0;
+    let x = 0;
+    let y = 0;
+    let z = 0;
+    const wet = [];
+    for (let i = 0; i < thickness.length; i++) {
+      const h = thickness[i];
+      if (h <= VISIBLE_THICKNESS2) continue;
+      const at = grid.film.layout.cellToWorld(Math.floor(i / width) + 0.5, i % width + 0.5);
+      volume += h;
+      x += at[0] * h;
+      y += at[1] * h;
+      z += at[2] * h;
+      wet.push(i);
+    }
+    if (volume === 0) return null;
+    const point = [x / volume, y / volume, z / volume];
+    let radius = 0;
+    for (const i of wet) radius = Math.max(radius, distance(grid.film.layout.cellToWorld(Math.floor(i / width) + 0.5, i % width + 0.5), point));
+    const profile = grid.profile;
+    return { fluid: profile.id, point, liters: volume * cellSize * cellSize, tint: grid.tint ?? { fresh: profile.thin, dry: profile.dry }, radius, reason };
+  }
+  /** Copies the dirty rectangle to the GPU texture; answers the texels written. */
+  upload(grid, rect) {
+    const gpu = this.options.gpu;
+    const width = rect.lastColumn - rect.firstColumn + 1;
+    const height = rect.lastRow - rect.firstRow + 1;
+    const whole = grid.film.layout.width * grid.film.layout.height;
+    if (!gpu || !grid.uploaded || width * height >= whole * 0.6) {
+      grid.texture.needsUpdate = true;
+      return whole;
+    }
+    const staging = this.stagingFor(width, height);
+    const target = staging.image.data;
+    const stride = grid.film.layout.width * 4;
+    for (let row = 0; row < height; row++) {
+      const from = (rect.firstRow + row) * stride + rect.firstColumn * 4;
+      target.set(grid.data.subarray(from, from + width * 4), row * width * 4);
+    }
+    staging.needsUpdate = true;
+    gpu.copyTextureToTexture(new this.THREE.Vector2(rect.firstColumn, rect.firstRow), staging, grid.texture);
+    return width * height;
+  }
+  stagingFor(width, height) {
+    const key = `${width}x${height}`;
+    let texture = this.staging.get(key);
+    if (!texture) {
+      if (this.staging.size >= DEFAULT_MAX_STAGING) {
+        const oldest = this.staging.keys().next().value;
+        this.staging.get(oldest)?.dispose();
+        this.staging.delete(oldest);
+      }
+      texture = new this.THREE.DataTexture(new Uint8Array(new ArrayBuffer(width * height * 4)), width, height, this.THREE.RGBAFormat);
+      texture.magFilter = this.THREE.LinearFilter;
+      texture.minFilter = this.THREE.LinearFilter;
+      this.staging.set(key, texture);
+    }
+    return texture;
+  }
+};
+function createFilmManager(THREE, options) {
+  return new FilmManager(THREE, options);
+}
+
+// src/film/bridge.ts
+import { FILM_PROFILES as FILM_PROFILES2 } from "@adatechnology/game-fluids";
+var DEFAULT_DROP_LITERS = 15e-5;
+var DEFAULT_DROP_RADIUS2 = 3.2;
+var MAX_DROPS_PER_FRAME = 6;
+var RADIUS_SPREAD = 0.3;
+var RADIUS_BASE = 0.85;
+var DEFAULT_SPLAT_SPEED = 2.5;
+var filmLiquids = () => Object.fromEntries(FILM_PROFILES2.map((profile) => [profile.id, profile.id]));
+function createFilmBridge(options) {
+  const { fluids, manager, random } = options;
+  const liquids = options.liquids ?? filmLiquids();
+  const dropLiters = options.dropLiters ?? DEFAULT_DROP_LITERS;
+  const leaks = /* @__PURE__ */ new Map();
+  const offLeak = fluids.on("leak", (event) => {
+    if (event.type !== "leak") return;
+    const fluid = liquids[event.liquid];
+    if (fluid) leaks.set(event.stream, { fluid, owed: 0 });
+  });
+  const offEnd = fluids.on("stream_end", (event) => {
+    if (event.type === "stream_end") leaks.delete(event.stream);
+  });
+  const surfaces = (point) => options.surfaceAt?.(point) ?? void 0;
+  return {
+    get leaks() {
+      return leaks.size;
+    },
+    splat(splat) {
+      const count = splat.count ?? 1;
+      const speed = splat.speed ?? DEFAULT_SPLAT_SPEED;
+      const direction = splat.direction ?? [0, -1, 0];
+      const length = Math.hypot(direction[0], direction[1], direction[2]) || 1;
+      const velocity = [direction[0] / length * speed, direction[1] / length * speed, direction[2] / length * speed];
+      let landed = 0;
+      for (let i = 0; i < count; i++) {
+        const grid = manager.launch({
+          fluid: splat.fluid,
+          point: splat.point,
+          velocity,
+          radius: (splat.radius ?? DEFAULT_DROP_RADIUS2) * (RADIUS_BASE + random() * RADIUS_SPREAD),
+          ...splat.surfaces ? { surfaces: splat.surfaces } : {},
+          ...splat.tint ? { tint: splat.tint } : {}
+        });
+        if (grid) landed++;
+      }
+      return landed;
+    },
+    setWeather: (weather) => manager.setWeather(weather),
+    update(dt) {
+      if (leaks.size === 0) return;
+      const streams = new Map(fluids.streams().map((stream) => [stream.id, stream]));
+      for (const [id, leak] of leaks) {
+        const stream = streams.get(id);
+        if (!stream) continue;
+        leak.owed += stream.rate * dt / dropLiters;
+        let thrown = 0;
+        while (leak.owed >= 1 && thrown < MAX_DROPS_PER_FRAME) {
+          leak.owed -= 1;
+          thrown++;
+          manager.launch({
+            fluid: leak.fluid,
+            point: stream.origin,
+            velocity: stream.velocity,
+            radius: DEFAULT_DROP_RADIUS2 * (RADIUS_BASE + random() * RADIUS_SPREAD),
+            ...surfaces(stream.origin) ? { surfaces: surfaces(stream.origin) } : {}
+          });
+        }
+        if (thrown === MAX_DROPS_PER_FRAME) leak.owed = 0;
+      }
+    },
+    dispose() {
+      offLeak();
+      offEnd();
+      leaks.clear();
+    }
+  };
+}
 export {
+  FILM_FRAGMENT,
+  FILM_VERTEX,
+  FilmGrid,
+  FilmManager,
+  LOOK_INDEX,
+  createFilmBridge,
+  createFilmDrops,
+  createFilmManager,
+  createFilmMaterial,
   createFluidRenderer,
-  smoothOutline
+  createStripGeometry,
+  smoothOutline,
+  tinted
 };
 //# sourceMappingURL=index.js.map