@adatechnology/game-fluids-three 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1081 @@
+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/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]];
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+var norm = (a) => {
+  const l = Math.hypot(a[0], a[1], a[2]) || 1;
+  return [a[0] / l, a[1] / l, a[2] / l];
+};
+var orient = (p, n, outward) => {
+  if (dot(cross(sub(p[1], p[0]), sub(p[2], p[0])), outward) < 0) return { p: [...p].reverse(), n: [...n].reverse() };
+  return { p, n };
+};
+var finish = (faces) => {
+  let maxVertices = 0;
+  for (const f of faces) maxVertices += (f.p.length * 2 + 2) * 3;
+  maxVertices += faces.length * 3 * 2 + 64;
+  return { faces, maxVertices };
+};
+var cylinderSolid = (radius, height, segments) => {
+  const faces = [];
+  const ring = (y, i) => {
+    const a = i / segments * Math.PI * 2;
+    return [Math.cos(a) * radius, y, Math.sin(a) * radius];
+  };
+  const radial = (i) => {
+    const a = i / segments * Math.PI * 2;
+    return [Math.cos(a), 0, Math.sin(a)];
+  };
+  for (let i = 0; i < segments; i++) {
+    const j = (i + 1) % segments;
+    const mid = norm([radial(i)[0] + radial(j)[0], 0, radial(i)[2] + radial(j)[2]]);
+    faces.push(orient([ring(0, i), ring(0, j), ring(height, j), ring(height, i)], [radial(i), radial(j), radial(j), radial(i)], mid));
+  }
+  const bottom = [];
+  const top = [];
+  for (let i = 0; i < segments; i++) {
+    bottom.push(ring(0, i));
+    top.push(ring(height, i));
+  }
+  faces.push(orient(bottom, bottom.map(() => [0, -1, 0]), [0, -1, 0]));
+  faces.push(orient(top, top.map(() => [0, 1, 0]), [0, 1, 0]));
+  return finish(faces);
+};
+var boxSolid = (size) => {
+  const hx = size[0] / 2;
+  const hz = size[2] / 2;
+  const hy = size[1];
+  const c = (x, y, z) => [x * hx, y * hy, z * hz];
+  const quad = (a, b, cc, d, n) => orient([a, b, cc, d], [n, n, n, n], n);
+  return finish([
+    quad(c(1, 0, -1), c(1, 1, -1), c(1, 1, 1), c(1, 0, 1), [1, 0, 0]),
+    quad(c(-1, 0, -1), c(-1, 1, -1), c(-1, 1, 1), c(-1, 0, 1), [-1, 0, 0]),
+    quad(c(-1, 1, -1), c(1, 1, -1), c(1, 1, 1), c(-1, 1, 1), [0, 1, 0]),
+    quad(c(-1, 0, -1), c(1, 0, -1), c(1, 0, 1), c(-1, 0, 1), [0, -1, 0]),
+    quad(c(-1, 0, 1), c(1, 0, 1), c(1, 1, 1), c(-1, 1, 1), [0, 0, 1]),
+    quad(c(-1, 0, -1), c(1, 0, -1), c(1, 1, -1), c(-1, 1, -1), [0, 0, -1])
+  ]);
+};
+var polyP = [];
+var polyN = [];
+var cut = [];
+var clipSolid = (solid, u, d, pos, nor) => {
+  let count = 0;
+  const capacity = Math.floor(pos.length / 3);
+  cut.length = 0;
+  const put = (px, py, pz, nx, ny, nz) => {
+    if (count >= capacity) return;
+    pos[count * 3] = px;
+    pos[count * 3 + 1] = py;
+    pos[count * 3 + 2] = pz;
+    nor[count * 3] = nx;
+    nor[count * 3 + 1] = ny;
+    nor[count * 3 + 2] = nz;
+    count++;
+  };
+  for (const face of solid.faces) {
+    const m = face.p.length;
+    polyP.length = 0;
+    polyN.length = 0;
+    for (let i = 0; i < m; i++) {
+      const a = face.p[i];
+      const b = face.p[(i + 1) % m];
+      const na = face.n[i];
+      const nb = face.n[(i + 1) % m];
+      const da = u[0] * a[0] + u[1] * a[1] + u[2] * a[2] - d;
+      const db = u[0] * b[0] + u[1] * b[1] + u[2] * b[2] - d;
+      const ina = da <= 0;
+      const inb = db <= 0;
+      if (ina) {
+        polyP.push(a[0], a[1], a[2]);
+        polyN.push(na[0], na[1], na[2]);
+        if (da > -1e-7) cut.push(a[0], a[1], a[2]);
+      }
+      if (ina !== inb) {
+        const t = da / (da - db);
+        const x = a[0] + (b[0] - a[0]) * t;
+        const y = a[1] + (b[1] - a[1]) * t;
+        const z = a[2] + (b[2] - a[2]) * t;
+        polyP.push(x, y, z);
+        polyN.push(na[0] + (nb[0] - na[0]) * t, na[1] + (nb[1] - na[1]) * t, na[2] + (nb[2] - na[2]) * t);
+        cut.push(x, y, z);
+      }
+    }
+    const n = polyP.length / 3;
+    for (let i = 1; i < n - 1; i++) {
+      for (const k of [0, i, i + 1]) put(polyP[k * 3], polyP[k * 3 + 1], polyP[k * 3 + 2], polyN[k * 3], polyN[k * 3 + 1], polyN[k * 3 + 2]);
+    }
+  }
+  const pts = [];
+  for (let i = 0; i < cut.length; i += 3) {
+    let dup = false;
+    for (const q of pts) {
+      if (Math.abs(q[0] - cut[i]) + Math.abs(q[1] - cut[i + 1]) + Math.abs(q[2] - cut[i + 2]) < 1e-6) {
+        dup = true;
+        break;
+      }
+    }
+    if (!dup) pts.push([cut[i], cut[i + 1], cut[i + 2]]);
+  }
+  if (pts.length >= 3) {
+    const c = [0, 0, 0];
+    for (const q of pts) {
+      c[0] += q[0] / pts.length;
+      c[1] += q[1] / pts.length;
+      c[2] += q[2] / pts.length;
+    }
+    const e1 = norm(cross(u, Math.abs(u[0]) < 0.9 ? [1, 0, 0] : [0, 1, 0]));
+    const e2 = cross(u, e1);
+    const keyed = pts.map((q) => ({ q, a: Math.atan2(dot(sub(q, c), e2), dot(sub(q, c), e1)) })).sort((p, r) => p.a - r.a);
+    for (let i = 0; i < keyed.length; i++) {
+      for (const q of [c, keyed[i].q, keyed[(i + 1) % keyed.length].q]) put(q[0], q[1], q[2], u[0], u[1], u[2]);
+    }
+  }
+  return count;
+};
+
+// src/liquid-body.ts
+var INSET = 0.985;
+var LiquidBody = class {
+  constructor(THREE, containerId, object, offset) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "containerId", containerId);
+    __publicField(this, "object", object);
+    __publicField(this, "group");
+    __publicField(this, "mesh", null);
+    __publicField(this, "geometry", null);
+    __publicField(this, "pos", new Float32Array(0));
+    __publicField(this, "nor", new Float32Array(0));
+    __publicField(this, "solid", null);
+    __publicField(this, "shapeKey", "");
+    __publicField(this, "steamAcc", 0);
+    __publicField(this, "inverse");
+    __publicField(this, "tmpN");
+    __publicField(this, "tmpP");
+    __publicField(this, "vertices", 0);
+    this.group = new THREE.Group();
+    this.group.name = "fluid_liquid_body";
+    this.group.position.set(offset[0], offset[1], offset[2]);
+    this.inverse = new THREE.Matrix4();
+    this.tmpN = new THREE.Vector3();
+    this.tmpP = new THREE.Vector3();
+    object.add(this.group);
+  }
+  get visible() {
+    return !!this.mesh && this.mesh.visible;
+  }
+  build(state, quality) {
+    const shape = state.shape;
+    if (!shape) return;
+    const key = JSON.stringify(shape) + quality.bodySegments;
+    if (key === this.shapeKey) return;
+    this.shapeKey = key;
+    this.solid = shape.kind === "cylinder" ? cylinderSolid(shape.radius * INSET, shape.height * INSET, quality.bodySegments) : boxSolid([shape.size[0] * INSET, shape.size[1] * INSET, shape.size[2] * INSET]);
+    const T = this.THREE;
+    this.geometry?.dispose();
+    this.pos = new Float32Array(this.solid.maxVertices * 3);
+    this.nor = new Float32Array(this.solid.maxVertices * 3);
+    this.geometry = new T.BufferGeometry();
+    const p = new T.BufferAttribute(this.pos, 3);
+    const n = new T.BufferAttribute(this.nor, 3);
+    p.setUsage(T.DynamicDrawUsage);
+    n.setUsage(T.DynamicDrawUsage);
+    this.geometry.setAttribute("position", p);
+    this.geometry.setAttribute("normal", n);
+    if (!this.mesh) {
+      this.mesh = new T.Mesh(this.geometry);
+      this.mesh.name = "fluid_liquid";
+      this.mesh.frustumCulled = false;
+      this.mesh.renderOrder = 3;
+      this.group.add(this.mesh);
+    } else this.mesh.geometry = this.geometry;
+  }
+  update(dt, world, materials, quality, particles) {
+    const state = world.container(this.containerId);
+    const def = state?.liquid ? world.liquids.get(state.liquid) : void 0;
+    if (!state || !state.shape || !def || state.liters <= 1e-6) {
+      if (this.mesh) this.mesh.visible = false;
+      this.vertices = 0;
+      return;
+    }
+    this.build(state, quality);
+    if (!this.mesh || !this.solid) return;
+    this.mesh.material = materials.liquidBody(def);
+    this.object.updateWorldMatrix(true, false);
+    this.group.updateWorldMatrix(true, false);
+    this.inverse.copy(this.group.matrixWorld).invert();
+    this.tmpN.set(state.surfaceNormal[0], state.surfaceNormal[1], state.surfaceNormal[2]).transformDirection(this.inverse);
+    this.tmpP.set(state.surfacePoint[0], state.surfacePoint[1], state.surfacePoint[2]).applyMatrix4(this.inverse);
+    const u = [this.tmpN.x, this.tmpN.y, this.tmpN.z];
+    const d = u[0] * this.tmpP.x + u[1] * this.tmpP.y + u[2] * this.tmpP.z;
+    this.vertices = clipSolid(this.solid, u, d, this.pos, this.nor);
+    const geometry = this.geometry;
+    geometry.setDrawRange(0, this.vertices);
+    geometry.getAttribute("position").needsUpdate = true;
+    geometry.getAttribute("normal").needsUpdate = true;
+    this.mesh.visible = this.vertices > 0;
+    if (state.steaming && this.vertices > 0) {
+      this.steamAcc += dt * quality.steamRate;
+      while (this.steamAcc >= 1) {
+        this.steamAcc -= 1;
+        const o = this.tmpP.set(state.surfacePoint[0], state.surfacePoint[1], state.surfacePoint[2]);
+        particles.steam([o.x, o.y + 0.01, o.z]);
+      }
+    } else this.steamAcc = 0;
+  }
+  get triangles() {
+    return this.visible ? Math.floor(this.vertices / 3) : 0;
+  }
+  dispose() {
+    this.object.remove(this.group);
+    this.geometry?.dispose();
+    this.geometry = null;
+    this.mesh = null;
+  }
+};
+
+// src/util.ts
+var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+var Rng = class {
+  constructor(seed) {
+    __publicField(this, "state");
+    this.state = seed >>> 0 || 1;
+  }
+  next() {
+    this.state = this.state + 1831565813 >>> 0;
+    let t = this.state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+};
+var hashPoint = (x, y, z) => {
+  let h = 2166136261;
+  for (const v of [x, y, z]) h = Math.imul(h ^ Math.round(v * 1e3), 16777619);
+  return h >>> 0;
+};
+
+// src/materials.ts
+var stainColorOf = (def) => {
+  if (def.stainColor !== void 0) return def.stainColor;
+  const r = (def.color >> 16 & 255) * 0.65;
+  const g = (def.color >> 8 & 255) * 0.65;
+  const b = (def.color & 255) * 0.65;
+  return Math.round(r) << 16 | Math.round(g) << 8 | Math.round(b);
+};
+var MaterialCache = class {
+  constructor(THREE, envMap) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "envMap", envMap);
+    __publicField(this, "body", /* @__PURE__ */ new Map());
+    __publicField(this, "stream", /* @__PURE__ */ new Map());
+    __publicField(this, "film", /* @__PURE__ */ new Map());
+    __publicField(this, "wet", /* @__PURE__ */ new Map());
+  }
+  make(params) {
+    const m = new this.THREE.MeshStandardMaterial({ metalness: 0, ...params });
+    if (this.envMap) m.envMap = this.envMap;
+    return m;
+  }
+  /** The volume of liquid inside a container. */
+  liquidBody(def) {
+    let m = this.body.get(def.id);
+    if (!m) {
+      m = this.make({
+        color: def.color,
+        opacity: def.opacity,
+        transparent: def.opacity < 0.999,
+        roughness: clamp(1 - def.gloss * 0.9, 0.04, 1),
+        envMapIntensity: 0.5 + def.gloss * 0.9,
+        depthWrite: def.opacity >= 0.999
+      });
+      this.body.set(def.id, m);
+    }
+    return m;
+  }
+  /** A jet or a drop in the air. */
+  liquidStream(def) {
+    let m = this.stream.get(def.id);
+    if (!m) {
+      m = this.make({
+        color: def.color,
+        opacity: clamp(def.opacity + 0.1, 0.35, 1),
+        transparent: true,
+        roughness: clamp(1 - def.gloss * 0.95, 0.03, 1),
+        envMapIntensity: 0.8 + def.gloss,
+        side: this.THREE.DoubleSide,
+        depthWrite: false
+      });
+      this.stream.set(def.id, m);
+    }
+    return m;
+  }
+  /** The thin outer film of a stain (and the permanent mark): tinted by vertex colour, soft rim by vertex alpha, mostly matte. */
+  stainFilm(def) {
+    let m = this.film.get(def.id);
+    if (!m) {
+      m = this.make({
+        color: 16777215,
+        vertexColors: true,
+        transparent: true,
+        roughness: clamp(0.95 - def.gloss * 0.45, 0.3, 1),
+        envMapIntensity: 0.4 + def.gloss * 0.4,
+        depthWrite: false,
+        polygonOffset: true,
+        polygonOffsetFactor: -2,
+        polygonOffsetUnits: -2
+      });
+      this.film.set(def.id, m);
+    }
+    return m;
+  }
+  /** The glossy wet part of a stain, which shrinks while it dries. */
+  stainWet(def) {
+    let m = this.wet.get(def.id);
+    if (!m) {
+      m = this.make({
+        color: 16777215,
+        vertexColors: true,
+        transparent: true,
+        roughness: clamp(1 - def.gloss, 0.02, 0.7),
+        envMapIntensity: 0.9 + def.gloss * 1.4,
+        depthWrite: false,
+        polygonOffset: true,
+        polygonOffsetFactor: -3,
+        polygonOffsetUnits: -3
+      });
+      this.wet.set(def.id, m);
+    }
+    return m;
+  }
+  dispose() {
+    for (const map of [this.body, this.stream, this.film, this.wet]) {
+      for (const m of map.values()) m.dispose();
+      map.clear();
+    }
+  }
+};
+
+// 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");
+    __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;
+  }
+  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. */
+  splash(point, intensity, hex, opacity, count) {
+    const rng = new Rng(hashPoint(point[0], point[1], point[2]) ^ this.next);
+    const n = Math.max(2, Math.round(count * (0.35 + 0.65 * clamp(intensity, 0, 1))));
+    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);
+    }
+  }
+  /** 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);
+  }
+  dispose() {
+    this.geometry.dispose();
+    this.material.dispose();
+  }
+};
+
+// 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/stains.ts
+import { STAIN_SAMPLES } from "@adatechnology/game-fluids";
+var smoothOutline = (front, subdiv, out) => {
+  const n = front.length;
+  const res = out ?? [];
+  res.length = n * subdiv;
+  for (let i = 0; i < n; i++) {
+    const p0 = front[(i + n - 1) % n];
+    const p1 = front[i];
+    const p2 = front[(i + 1) % n];
+    const p3 = front[(i + 2) % n];
+    for (let j = 0; j < subdiv; j++) {
+      const t = j / subdiv;
+      const r = 0.5 * (2 * p1 + (-p0 + p2) * t + (2 * p0 - 5 * p1 + 4 * p2 - p3) * t * t + (-p0 + 3 * p1 - 3 * p2 + p3) * t * t * t);
+      res[i * subdiv + j] = Math.max(4e-3, r);
+    }
+  }
+  return res;
+};
+var StainVisual = class {
+  constructor(THREE, profile, slot) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "slot", slot);
+    __publicField(this, "group");
+    __publicField(this, "outer");
+    __publicField(this, "inner");
+    __publicField(this, "ring");
+    __publicField(this, "radii", []);
+    __publicField(this, "tint");
+    __publicField(this, "stainId", "");
+    __publicField(this, "signature", Number.NaN);
+    __publicField(this, "triangles", 0);
+    this.ring = STAIN_SAMPLES * profile.stainSubdiv;
+    this.group = new THREE.Group();
+    this.group.name = "fluid_stain";
+    this.tint = new THREE.Color();
+    this.outer = this.makeFan("fluid_stain_film", 1);
+    this.inner = this.makeFan("fluid_stain_wet", 2);
+    this.group.add(this.outer.mesh, this.inner.mesh);
+    this.group.visible = false;
+  }
+  makeFan(name, order) {
+    const T = this.THREE;
+    const count = 1 + this.ring;
+    const position = new Float32Array(count * 3);
+    const color = new Float32Array(count * 4);
+    const normal = new Float32Array(count * 3);
+    const geometry = new T.BufferGeometry();
+    const p = new T.BufferAttribute(position, 3);
+    const c = new T.BufferAttribute(color, 4);
+    p.setUsage(T.DynamicDrawUsage);
+    c.setUsage(T.DynamicDrawUsage);
+    geometry.setAttribute("position", p);
+    geometry.setAttribute("normal", new T.BufferAttribute(normal, 3));
+    geometry.setAttribute("color", c);
+    const index = [];
+    for (let i = 0; i < this.ring; i++) index.push(0, 1 + i, 1 + (i + 1) % this.ring);
+    geometry.setIndex(index);
+    const mesh = new T.Mesh(geometry);
+    mesh.name = name;
+    mesh.frustumCulled = false;
+    mesh.renderOrder = order;
+    return { mesh, position, color };
+  }
+  assign(def, materials) {
+    this.outer.mesh.material = materials.stainFilm(def);
+    this.inner.mesh.material = materials.stainWet(def);
+  }
+  hide() {
+    this.group.visible = false;
+    this.stainId = "";
+    this.signature = Number.NaN;
+    this.triangles = 0;
+  }
+  /** Rebuild the vertices from the stain state (skipped when nothing changed). */
+  update(stain, def, profile) {
+    const sig = stain.center[0] * 3 + stain.center[1] * 5 + stain.center[2] * 7 + stain.front.reduce((s, v, i) => s + v * (i + 1), 0) * 11 + stain.wetness * 13 + stain.wetRadius * 17 + stain.soaked / (stain.soaked + stain.liters + 1e-6) * 19;
+    if (sig === this.signature && this.group.visible) return;
+    this.signature = sig;
+    const n = stain.normal ?? [0, 1, 0];
+    const t1 = stain.tangent ?? [1, 0, 0];
+    const t2 = [n[1] * t1[2] - n[2] * t1[1], n[2] * t1[0] - n[0] * t1[2], n[0] * t1[1] - n[1] * t1[0]];
+    smoothOutline(stain.front, profile.stainSubdiv, this.radii);
+    const ring = this.ring;
+    const lift = 15e-4 + 4e-4 * (this.slot % 6);
+    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));
+    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));
+    this.writeFan(this.outer, stain.center, n, t1, t2, lift, 1, this.tint.r * dark, this.tint.g * dark, this.tint.b * dark, aMid, aMid * 0.45);
+    this.outer.mesh.visible = true;
+    const wr = clamp(stain.wetRadius, 0, 1);
+    const showInner = wr > 0.05 && wet > 0.03;
+    this.inner.mesh.visible = showInner;
+    if (showInner) {
+      this.tint.setHex(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;
+      this.writeFan(this.inner, centre, n, t1, t2, lift + 7e-4, 0.9 * wr, this.tint.r, this.tint.g, this.tint.b, a, a * 0.5);
+    }
+    this.triangles = ring * (showInner ? 2 : 1);
+    this.group.visible = true;
+  }
+  writeFan(fan, center, n, t1, t2, lift, scale, r, g, b, aCentre, aRim) {
+    const ring = this.ring;
+    const px = center[0] + n[0] * lift;
+    const py = center[1] + n[1] * lift;
+    const pz = center[2] + n[2] * lift;
+    fan.position[0] = px;
+    fan.position[1] = py;
+    fan.position[2] = pz;
+    fan.color[0] = r * 0.85;
+    fan.color[1] = g * 0.85;
+    fan.color[2] = b * 0.85;
+    fan.color[3] = aCentre;
+    const normalAttr = fan.mesh.geometry.getAttribute("normal");
+    for (let i = 0; i <= ring; i++) {
+      normalAttr.setXYZ(i, n[0], n[1], n[2]);
+    }
+    normalAttr.needsUpdate = true;
+    for (let i = 0; i < ring; i++) {
+      const a = i / ring * Math.PI * 2;
+      const c = Math.cos(a) * this.radii[i] * scale;
+      const s = Math.sin(a) * this.radii[i] * scale;
+      const o = (1 + i) * 3;
+      fan.position[o] = px + t1[0] * c + t2[0] * s;
+      fan.position[o + 1] = py + t1[1] * c + t2[1] * s;
+      fan.position[o + 2] = pz + t1[2] * c + t2[2] * s;
+      const k = (1 + i) * 4;
+      fan.color[k] = r;
+      fan.color[k + 1] = g;
+      fan.color[k + 2] = b;
+      fan.color[k + 3] = aRim;
+    }
+    const geometry = fan.mesh.geometry;
+    geometry.getAttribute("position").needsUpdate = true;
+    geometry.getAttribute("color").needsUpdate = true;
+  }
+  dispose() {
+    for (const fan of [this.outer, this.inner]) fan.mesh.geometry.dispose();
+  }
+};
+
+// src/streams.ts
+import { sampleStream } from "@adatechnology/game-fluids";
+var GHOST_TIME = 0.4;
+var StreamVisual = class {
+  constructor(THREE, profile, dropGeometry) {
+    __publicField(this, "THREE", THREE);
+    __publicField(this, "tube");
+    __publicField(this, "drops");
+    __publicField(this, "positions");
+    __publicField(this, "normals");
+    __publicField(this, "samples");
+    __publicField(this, "sides");
+    __publicField(this, "matrix");
+    __publicField(this, "maxDrops");
+    __publicField(this, "id", "");
+    __publicField(this, "age", 0);
+    __publicField(this, "ghostAge", -1);
+    /** Last known state, kept while the stream breaks into drops. */
+    __publicField(this, "state", null);
+    __publicField(this, "triangles", 0);
+    const T = THREE;
+    this.samples = profile.streamSamples;
+    this.sides = profile.streamSides;
+    this.maxDrops = Math.max(profile.thinDrops, 2) + 2;
+    this.positions = new Float32Array(this.samples * this.sides * 3);
+    this.normals = new Float32Array(this.samples * this.sides * 3);
+    const geometry = new T.BufferGeometry();
+    const p = new T.BufferAttribute(this.positions, 3);
+    const n = new T.BufferAttribute(this.normals, 3);
+    p.setUsage(T.DynamicDrawUsage);
+    n.setUsage(T.DynamicDrawUsage);
+    geometry.setAttribute("position", p);
+    geometry.setAttribute("normal", n);
+    const index = [];
+    for (let i = 0; i < this.samples - 1; i++) {
+      for (let j = 0; j < this.sides; j++) {
+        const a = i * this.sides + j;
+        const b = i * this.sides + (j + 1) % this.sides;
+        const c = (i + 1) * this.sides + j;
+        const d = (i + 1) * this.sides + (j + 1) % this.sides;
+        index.push(a, c, b, b, c, d);
+      }
+    }
+    geometry.setIndex(index);
+    this.tube = new T.Mesh(geometry);
+    this.tube.name = "fluid_stream";
+    this.tube.frustumCulled = false;
+    this.tube.renderOrder = 2;
+    this.drops = new T.InstancedMesh(dropGeometry, void 0, this.maxDrops);
+    this.drops.name = "fluid_stream_drops";
+    this.drops.frustumCulled = false;
+    this.drops.renderOrder = 2;
+    this.drops.instanceMatrix.setUsage(T.DynamicDrawUsage);
+    this.drops.count = 0;
+    this.matrix = new T.Matrix4();
+  }
+  setMaterial(material) {
+    this.tube.material = material;
+    this.drops.material = material;
+  }
+  hide() {
+    this.tube.visible = false;
+    this.drops.visible = false;
+    this.drops.count = 0;
+    this.triangles = 0;
+  }
+  dropAt(slot, x, y, z, radius) {
+    this.matrix.makeScale(radius, radius, radius).setPosition(x, y, z);
+    this.drops.setMatrixAt(slot, this.matrix);
+  }
+  /**
+   * Draw the stream. `state` is the world's stream while it lives, or the last known one while ghost (`ghostAge >= 0`).
+   */
+  update(state, gravity, dt, profile, time) {
+    this.state = state;
+    this.age += dt;
+    if (this.ghostAge >= 0) this.ghostAge += dt;
+    const flight = Math.max(0.02, state.flightTime ?? 1);
+    const [vx, vy, vz] = state.velocity;
+    const speed0 = Math.max(0.3, Math.hypot(vx, vy, vz));
+    const q = Math.max(state.rate, 0) / 1e3;
+    const r0 = clamp(Math.sqrt(q / (Math.PI * speed0)), 15e-4, 0.03);
+    const tB = Math.min(flight, this.age);
+    const tA = this.ghostAge >= 0 ? Math.min(flight, this.ghostAge) : 0;
+    let drops = 0;
+    const thin = state.thin && this.ghostAge < 0;
+    if (thin) {
+      this.tube.visible = false;
+      this.triangles = 0;
+      const n = profile.thinDrops;
+      const phase = time * 1.3;
+      for (let k = 0; k < n && drops < this.maxDrops; k++) {
+        const tau = (phase + k / n) % 1 * flight;
+        if (tau > tB) continue;
+        const p = sampleStream(state, gravity, tau);
+        const grow = Math.min(1, tau / (0.12 * flight + 0.02));
+        this.dropAt(drops++, p[0], p[1], p[2], Math.max(2e-3, r0 * 1.8) * (0.4 + 0.6 * grow));
+      }
+    } else if (tB - tA > 0.015) {
+      this.writeTube(state, gravity, tA, tB, r0, speed0);
+      this.tube.visible = true;
+      this.triangles = (this.samples - 1) * this.sides * 2;
+      if (tB < flight) {
+        const p = sampleStream(state, gravity, tB);
+        const w = this.radiusAt(state, gravity, tB, r0, speed0);
+        this.dropAt(drops++, p[0], p[1], p[2], w * 1.35);
+      }
+      if (this.ghostAge >= 0) {
+        const p = sampleStream(state, gravity, tA);
+        const w = this.radiusAt(state, gravity, tA, r0, speed0);
+        this.dropAt(drops++, p[0], p[1], p[2], w * 1.4 * (1 - this.ghostAge / GHOST_TIME * 0.4));
+      }
+    } else {
+      this.tube.visible = false;
+      this.triangles = 0;
+      if (tA < flight) {
+        const p = sampleStream(state, gravity, this.ghostAge >= 0 ? tA : tB);
+        this.dropAt(drops++, p[0], p[1], p[2], Math.max(3e-3, r0 * 1.3));
+      }
+    }
+    this.drops.count = drops;
+    this.drops.visible = drops > 0;
+    this.drops.instanceMatrix.needsUpdate = true;
+    this.triangles += drops * 24;
+  }
+  /** The ghost is over once its tail reached the landing. */
+  get finished() {
+    return this.ghostAge >= 0 && (this.ghostAge >= GHOST_TIME || this.ghostAge >= (this.state?.flightTime ?? 0));
+  }
+  radiusAt(state, gravity, t, r0, speed0) {
+    const vy = state.velocity[1] - gravity * t;
+    const speed = Math.max(0.3, Math.hypot(state.velocity[0], vy, state.velocity[2]));
+    const fade = this.ghostAge >= 0 ? clamp(1 - this.ghostAge / GHOST_TIME, 0.15, 1) : 1;
+    return r0 * Math.sqrt(speed0 / speed) * fade;
+  }
+  writeTube(state, gravity, tA, tB, r0, speed0) {
+    const n = this.samples;
+    const sides = this.sides;
+    for (let i = 0; i < n; i++) {
+      const k = i / (n - 1);
+      const t = tA + (tB - tA) * k;
+      const p = sampleStream(state, gravity, t);
+      const vx = state.velocity[0];
+      const vy = state.velocity[1] - gravity * t;
+      const vz = state.velocity[2];
+      const l = Math.hypot(vx, vy, vz) || 1;
+      const tx = vx / l;
+      const ty = vy / l;
+      const tz = vz / l;
+      const ax = Math.abs(tz) < 0.9 ? 0 : 1;
+      const az = Math.abs(tz) < 0.9 ? 1 : 0;
+      let b1x = ty * az - tz * 0;
+      let b1y = tz * ax - tx * az;
+      let b1z = tx * 0 - ty * ax;
+      const bl = Math.hypot(b1x, b1y, b1z) || 1;
+      b1x /= bl;
+      b1y /= bl;
+      b1z /= bl;
+      const b2x = ty * b1z - tz * b1y;
+      const b2y = tz * b1x - tx * b1z;
+      const b2z = tx * b1y - ty * b1x;
+      const end = Math.min(1, 0.35 + Math.min(k, 1 - k) * 8);
+      const r = this.radiusAt(state, gravity, t, r0, speed0) * end;
+      for (let j = 0; j < sides; j++) {
+        const a = j / sides * Math.PI * 2;
+        const c = Math.cos(a);
+        const s = Math.sin(a);
+        const nx = b1x * c + b2x * s;
+        const ny = b1y * c + b2y * s;
+        const nz = b1z * c + b2z * s;
+        const o = (i * sides + j) * 3;
+        this.positions[o] = p[0] + nx * r;
+        this.positions[o + 1] = p[1] + ny * r;
+        this.positions[o + 2] = p[2] + nz * r;
+        this.normals[o] = nx;
+        this.normals[o + 1] = ny;
+        this.normals[o + 2] = nz;
+      }
+    }
+    const g = this.tube.geometry;
+    g.getAttribute("position").needsUpdate = true;
+    g.getAttribute("normal").needsUpdate = true;
+  }
+  start(id) {
+    this.id = id;
+    this.age = 0;
+    this.ghostAge = -1;
+    this.state = null;
+  }
+  dispose() {
+    this.tube.geometry.dispose();
+    this.drops.dispose();
+  }
+};
+
+// src/renderer.ts
+function createFluidRenderer(THREE, options) {
+  const { scene, fluids } = options;
+  const quality = options.quality ?? "medium";
+  const profile = profileOf(quality);
+  const materials = new MaterialCache(THREE, options.envMap ?? null);
+  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 dropGeometry = new THREE.SphereGeometry(1, 8, 6);
+  const bodies = /* @__PURE__ */ new Map();
+  const streamsActive = /* @__PURE__ */ new Map();
+  const streamsFree = [];
+  let streamsCreated = 0;
+  const stainsActive = /* @__PURE__ */ new Map();
+  const stainsFree = [];
+  let stainsCreated = 0;
+  let time = 0;
+  let disposed = false;
+  const offSplash = fluids.on("splash", (e) => {
+    if (e.type !== "splash" || disposed) return;
+    const def = fluids.liquids.get(e.liquid);
+    if (!def) return;
+    particles.splash(e.point, e.intensity, def.color, def.opacity, profile.splashDroplets);
+  });
+  const acquireStream = (id) => {
+    let v = streamsFree.pop() ?? null;
+    if (!v) {
+      if (streamsCreated >= profile.maxStreams) return null;
+      streamsCreated++;
+      v = new StreamVisual(THREE, profile, dropGeometry);
+      root.add(v.tube, v.drops);
+    }
+    v.start(id);
+    return v;
+  };
+  const releaseStream = (v) => {
+    v.hide();
+    streamsActive.delete(v.id);
+    streamsFree.push(v);
+  };
+  const syncStreams = (dt) => {
+    const live = fluids.streams();
+    const seen = /* @__PURE__ */ new Set();
+    live.sort((a, b) => b.rate - a.rate);
+    for (const s of live) {
+      seen.add(s.id);
+      let v = streamsActive.get(s.id);
+      if (!v) {
+        const fresh = acquireStream(s.id);
+        if (!fresh) continue;
+        v = fresh;
+        streamsActive.set(s.id, v);
+      }
+      const def = fluids.liquids.get(s.liquid);
+      if (!def) continue;
+      v.ghostAge = -1;
+      v.setMaterial(materials.liquidStream(def));
+      v.update(s, fluids.gravity, dt, profile, time);
+    }
+    for (const v of [...streamsActive.values()]) {
+      if (seen.has(v.id)) continue;
+      if (v.ghostAge < 0) v.ghostAge = 0;
+      if (!v.state || v.finished) {
+        releaseStream(v);
+        continue;
+      }
+      v.update(v.state, fluids.gravity, dt, profile, time);
+      if (v.finished) releaseStream(v);
+    }
+  };
+  const syncStains = () => {
+    const all = fluids.stains();
+    const wanted = all.length > profile.maxStains ? [...all].sort((a, b) => (a.age ?? 0) - (b.age ?? 0)).slice(0, profile.maxStains) : all;
+    const ids = new Set(wanted.map((s) => s.id));
+    for (const [id, v] of [...stainsActive]) {
+      if (ids.has(id)) continue;
+      v.hide();
+      stainsActive.delete(id);
+      stainsFree.push(v);
+    }
+    for (const s of wanted) {
+      const def = fluids.liquids.get(s.liquid);
+      if (!def) continue;
+      let v = stainsActive.get(s.id);
+      if (!v) {
+        v = stainsFree.pop();
+        if (!v) {
+          if (stainsCreated >= profile.maxStains) continue;
+          v = new StainVisual(THREE, profile, stainsCreated++);
+          root.add(v.group);
+        }
+        v.stainId = s.id;
+        v.signature = Number.NaN;
+        v.assign(def, materials);
+        stainsActive.set(s.id, v);
+      }
+      v.update(s, def, profile);
+    }
+  };
+  const renderer = {
+    bindContainer(containerId, object, opts = {}) {
+      renderer.unbindContainer(containerId);
+      bodies.set(containerId, new LiquidBody(THREE, containerId, object, opts.innerOffset ?? [0, 0, 0]));
+    },
+    unbindContainer(containerId) {
+      const body = bodies.get(containerId);
+      if (!body) return;
+      body.dispose();
+      bodies.delete(containerId);
+    },
+    update(dt) {
+      if (disposed) return;
+      time += dt;
+      for (const body of bodies.values()) body.update(dt, fluids, materials, profile, particles);
+      syncStreams(dt);
+      syncStains();
+      particles.update(dt, fluids.gravity);
+    },
+    clear() {
+      for (const v of [...streamsActive.values()]) releaseStream(v);
+      for (const [id, v] of [...stainsActive]) {
+        v.hide();
+        stainsActive.delete(id);
+        stainsFree.push(v);
+      }
+      particles.clear();
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      offSplash();
+      for (const body of bodies.values()) body.dispose();
+      bodies.clear();
+      for (const v of [...streamsActive.values(), ...streamsFree]) v.dispose();
+      for (const v of [...stainsActive.values(), ...stainsFree]) v.dispose();
+      streamsActive.clear();
+      stainsActive.clear();
+      streamsFree.length = 0;
+      stainsFree.length = 0;
+      particles.dispose();
+      dropGeometry.dispose();
+      materials.dispose();
+      scene.remove(root);
+      root.clear();
+    },
+    stats() {
+      let triangles = 0;
+      let containers = 0;
+      for (const body of bodies.values()) {
+        triangles += body.triangles;
+        if (body.visible) containers++;
+      }
+      for (const v of streamsActive.values()) triangles += v.triangles;
+      for (const v of stainsActive.values()) triangles += v.triangles;
+      return {
+        quality,
+        containers,
+        streams: streamsActive.size,
+        stains: stainsActive.size,
+        particles: particles.count,
+        triangles,
+        budget: { stains: profile.maxStains, streams: profile.maxStreams, particles: profile.maxParticles }
+      };
+    }
+  };
+  return renderer;
+}
+export {
+  createFluidRenderer,
+  smoothOutline
+};
+//# sourceMappingURL=index.js.map