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

package/dist/index.global.js

@@ -0,0 +1,1713 @@
+"use strict";
+var GameInteractablesThree = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    MATERIAL_KEYS: () => MATERIAL_KEYS,
+    applyPose: () => applyPose,
+    attachSway: () => attachSway,
+    catenary: () => catenary,
+    createCord: () => createCord,
+    createDefaultMaterials: () => createDefaultMaterials,
+    createEffects: () => createEffects,
+    createMeshApi: () => createMeshApi,
+    createMirrors: () => createMirrors,
+    createScreen: () => createScreen,
+    createThreeAdapter: () => createThreeAdapter,
+    mergeParts: () => mergeParts,
+    patchSwayShader: () => patchSwayShader,
+    poseOf: () => poseOf2,
+    rememberRest: () => rememberRest,
+    swayMaterial: () => swayMaterial,
+    syncObject: () => syncObject
+  });
+
+  // src/effects.ts
+  var POOLS = ["smoke", "steam", "fire", "water", "spark"];
+  var WEIGHT = { smoke: 0.27, steam: 0.15, fire: 0.2, water: 0.28, spark: 0.1 };
+  var VERT = (
+    /* glsl */
+    `
+attribute float aSize;
+attribute float aAlpha;
+attribute vec3 aColor;
+uniform float uScale;
+varying float vAlpha;
+varying vec3 vColor;
+void main() {
+  vAlpha = aAlpha;
+  vColor = aColor;
+  vec4 mv = modelViewMatrix * vec4(position, 1.0);
+  gl_PointSize = max(aSize * uScale / max(-mv.z, 0.05), 1.0);
+  gl_Position = projectionMatrix * mv;
+}
+`
+  );
+  var FRAG = (
+    /* glsl */
+    `
+uniform sampler2D uMap;
+varying float vAlpha;
+varying vec3 vColor;
+void main() {
+  vec4 t = texture2D(uMap, gl_PointCoord);
+  gl_FragColor = vec4(vColor, vAlpha * t.a);
+}
+`
+  );
+  function mulberry(seed) {
+    let a = seed >>> 0;
+    return () => {
+      a = a + 1831565813 >>> 0;
+      let t = a;
+      t = Math.imul(t ^ t >>> 15, t | 1);
+      t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+      return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+  }
+  function makeSprite(THREE, doc) {
+    const N = 64;
+    try {
+      const canvas = doc?.createElement("canvas");
+      const ctx = canvas?.getContext?.("2d");
+      if (canvas && ctx && ctx.createRadialGradient) {
+        canvas.width = N;
+        canvas.height = N;
+        const g = ctx.createRadialGradient(N / 2, N / 2, 0, N / 2, N / 2, N / 2);
+        g.addColorStop(0, "rgba(255,255,255,1)");
+        g.addColorStop(0.4, "rgba(255,255,255,0.55)");
+        g.addColorStop(1, "rgba(255,255,255,0)");
+        ctx.fillStyle = g;
+        ctx.fillRect(0, 0, N, N);
+        const tex2 = new THREE.CanvasTexture(canvas);
+        return tex2;
+      }
+    } catch {
+    }
+    const data = new Uint8Array(N * N * 4);
+    for (let y = 0; y < N; y++) {
+      for (let x = 0; x < N; x++) {
+        const d = Math.hypot(x + 0.5 - N / 2, y + 0.5 - N / 2) / (N / 2);
+        const a = d >= 1 ? 0 : Math.pow(1 - d, 1.6);
+        const i = (y * N + x) * 4;
+        data[i] = data[i + 1] = data[i + 2] = 255;
+        data[i + 3] = Math.round(a * 255);
+      }
+    }
+    const tex = new THREE.DataTexture(data, N, N, THREE.RGBAFormat);
+    tex.needsUpdate = true;
+    return tex;
+  }
+  function makeStreaks(THREE) {
+    const W = 16;
+    const H = 64;
+    const data = new Uint8Array(W * H * 4);
+    const hash = (x, y) => {
+      let h = Math.imul(x + 1, 374761393) ^ Math.imul(y + 7, 668265263);
+      h = Math.imul(h ^ h >>> 13, 1274126177);
+      return ((h ^ h >>> 16) >>> 0) / 4294967296;
+    };
+    for (let y = 0; y < H; y++) {
+      for (let x = 0; x < W; x++) {
+        const col = 0.35 + 0.65 * hash(x, 0);
+        const row = 0.55 + 0.45 * Math.sin((y / H * 3 + hash(x, 1) * 6) * Math.PI * 2);
+        const i = (y * W + x) * 4;
+        data[i] = data[i + 1] = data[i + 2] = 255;
+        data[i + 3] = Math.round(255 * Math.min(1, col * row * 1.3));
+      }
+    }
+    const tex = new THREE.DataTexture(data, W, H, THREE.RGBAFormat);
+    tex.wrapS = THREE.RepeatWrapping;
+    tex.wrapT = THREE.RepeatWrapping;
+    tex.needsUpdate = true;
+    return tex;
+  }
+  function createEffects(THREE, a, b = {}) {
+    const legacy = !!a.isObject3D;
+    const options = legacy ? { ...b, scene: a } : a;
+    const scene = options.scene;
+    if (!scene) throw new Error("createEffects: options.scene is required");
+    if (!legacy && options.camera === void 0) throw new Error("createEffects: options.camera is required (pass null for a 90 degree lens)");
+    const total = Math.max(POOLS.length, Math.floor(options.maxParticles ?? 800));
+    const rand = mulberry(options.seed ?? 1);
+    const wind = [options.wind?.[0] ?? 0, options.wind?.[1] ?? 0];
+    const sprite = makeSprite(THREE, options.document);
+    let viewHeight = options.viewHeight ?? 720;
+    let cameraSource = options.camera ?? null;
+    let camera = typeof cameraSource === "function" ? cameraSource() : cameraSource;
+    const scale = { value: 0 };
+    const refreshScale = (cam) => {
+      const fov = cam ? 2 * Math.atan(Math.tan(Math.min(Math.max(cam.fov, 1), 175) * Math.PI / 360) / Math.max(cam.zoom ?? 1, 0.01)) : Math.PI / 2;
+      scale.value = viewHeight / (2 * Math.tan(fov / 2));
+    };
+    refreshScale(camera);
+    const pools = {};
+    const objects = {};
+    let used = 0;
+    POOLS.forEach((kind, i) => {
+      const cap = i === POOLS.length - 1 ? Math.max(1, total - used) : Math.max(1, Math.floor(total * WEIGHT[kind]));
+      used += cap;
+      const geo = new THREE.BufferGeometry();
+      const aPos = new THREE.BufferAttribute(new Float32Array(cap * 3), 3);
+      const aSize = new THREE.BufferAttribute(new Float32Array(cap), 1);
+      const aAlpha = new THREE.BufferAttribute(new Float32Array(cap), 1);
+      const aColor = new THREE.BufferAttribute(new Float32Array(cap * 3), 3);
+      for (const a2 of [aPos, aSize, aAlpha, aColor]) a2.setUsage(THREE.DynamicDrawUsage);
+      geo.setAttribute("position", aPos);
+      geo.setAttribute("aSize", aSize);
+      geo.setAttribute("aAlpha", aAlpha);
+      geo.setAttribute("aColor", aColor);
+      geo.setDrawRange(0, 0);
+      const additive = kind === "fire" || kind === "spark";
+      const mat = new THREE.ShaderMaterial({
+        uniforms: { uMap: { value: sprite }, uScale: scale },
+        vertexShader: VERT,
+        fragmentShader: FRAG,
+        transparent: true,
+        depthWrite: false,
+        blending: additive ? THREE.AdditiveBlending : THREE.NormalBlending
+      });
+      const points = new THREE.Points(geo, mat);
+      points.frustumCulled = false;
+      points.name = `effects:${kind}`;
+      scene.add(points);
+      objects[kind] = points;
+      pools[kind] = {
+        kind,
+        cap,
+        count: 0,
+        pos: new Float32Array(cap * 3),
+        vel: new Float32Array(cap * 3),
+        age: new Float32Array(cap),
+        life: new Float32Array(cap),
+        size0: new Float32Array(cap),
+        size1: new Float32Array(cap),
+        tint: new Float32Array(cap),
+        flags: new Uint8Array(cap),
+        ground: new Float32Array(cap).fill(-1e9),
+        aSize,
+        aAlpha,
+        aColor,
+        aPos,
+        points
+      };
+    });
+    const debt = /* @__PURE__ */ new Map();
+    let stamp = 0;
+    let clock = 0;
+    const spawn = (p, x, y, z, vx, vy, vz, life, s0, s1, tint, flag = 0, ground = -1e9) => {
+      if (p.count >= p.cap) return;
+      const i = p.count++;
+      p.pos[i * 3] = x;
+      p.pos[i * 3 + 1] = y;
+      p.pos[i * 3 + 2] = z;
+      p.vel[i * 3] = vx;
+      p.vel[i * 3 + 1] = vy;
+      p.vel[i * 3 + 2] = vz;
+      p.age[i] = 0;
+      p.life[i] = life;
+      p.size0[i] = s0;
+      p.size1[i] = s1;
+      p.tint[i] = tint;
+      p.flags[i] = flag;
+      p.ground[i] = ground;
+    };
+    const emitFrom = (e, n) => {
+      const k = Math.min(1, Math.max(0, e.intensity));
+      const size = e.size > 0 ? e.size : 0.2;
+      const [px, py, pz] = e.pos;
+      for (let j = 0; j < n; j++) {
+        switch (e.kind) {
+          case "smoke":
+            spawn(pools.smoke, px + (rand() - 0.5) * size * 0.6, py, pz + (rand() - 0.5) * size * 0.6, (rand() - 0.5) * 0.2, 0.45 + rand() * 0.45, (rand() - 0.5) * 0.2, 2.8 + rand() * 1.8, size * 0.6, size * 2.6, 0.3 + rand() * 0.25, 0);
+            break;
+          case "steam":
+            spawn(pools.steam, px + (rand() - 0.5) * size * 0.5, py, pz + (rand() - 0.5) * size * 0.5, (rand() - 0.5) * 0.12, 0.3 + rand() * 0.3, (rand() - 0.5) * 0.12, 1.3 + rand() * 1.1, size * 0.3, size * 1.3, 0.92, 0);
+            break;
+          case "fire":
+            spawn(pools.fire, px + (rand() - 0.5) * size * 0.7, py, pz + (rand() - 0.5) * size * 0.7, (rand() - 0.5) * 0.25, 0.8 + rand() * 0.9 * k, (rand() - 0.5) * 0.25, 0.35 + rand() * 0.4, size * 0.75, size * 0.15, rand(), 0);
+            break;
+          case "flame": {
+            const a2 = rand() * Math.PI * 2;
+            const r = size * 0.8;
+            spawn(pools.fire, px + Math.cos(a2) * r, py + 0.01, pz + Math.sin(a2) * r, 0, 0.06 + rand() * 0.1, 0, 0.14 + rand() * 0.12, size * 0.55, size * 0.15, rand(), 1);
+            break;
+          }
+          case "spark": {
+            const a2 = rand() * Math.PI * 2;
+            const up = 0.4 + rand() * 0.6;
+            const sp = 1.2 + rand() * 2;
+            spawn(pools.spark, px, py, pz, Math.cos(a2) * sp * (1 - up * 0.5), up * sp * 1.4, Math.sin(a2) * sp * (1 - up * 0.5), 0.35 + rand() * 0.5, size * 0.18, size * 0.05, rand(), 0);
+            break;
+          }
+          case "water":
+            break;
+        }
+      }
+    };
+    const arc = { x: 0, y: 0, z: 0, vx: 0, vy: 0, vz: 0, t: 0, stopY: 0, r0: 0, r1: 0 };
+    const floorY = options.floorY ?? 0;
+    const arcOf = (e, k) => {
+      let [dx, dy, dz] = e.dir;
+      const len = Math.hypot(dx, dy, dz);
+      if (len < 1e-6) {
+        dx = 0;
+        dy = -1;
+        dz = 0;
+      } else {
+        dx /= len;
+        dy /= len;
+        dz /= len;
+      }
+      const speed = 0.7 + 1.8 * k;
+      const stopY = e.reach !== void 0 ? Math.max(e.pos[1] - e.reach, floorY) : floorY;
+      const drop = e.pos[1] - stopY;
+      if (drop < 0.02) return false;
+      const vy = dy * speed;
+      arc.x = e.pos[0];
+      arc.y = e.pos[1];
+      arc.z = e.pos[2];
+      arc.vx = dx * speed;
+      arc.vy = vy;
+      arc.vz = dz * speed;
+      arc.t = Math.min(2.5, (vy + Math.sqrt(vy * vy + 19.6 * drop)) / 9.8);
+      arc.stopY = stopY;
+      const size = e.size > 0 ? e.size : 0.05;
+      if (size < 0.1) {
+        arc.r0 = Math.max(4e-3, size * 0.5);
+        arc.r1 = arc.r0 * 0.55;
+      } else {
+        arc.r0 = size * 0.45;
+        arc.r1 = arc.r0 * 1.2;
+      }
+      return true;
+    };
+    const emitWater = (e, k, nSpray, nSplash, nMist) => {
+      const size = e.size > 0 ? e.size : 0.05;
+      const wide = size >= 0.1;
+      for (let j = 0; j < nSpray; j++) {
+        const s = rand();
+        const t = s * arc.t;
+        const r = (arc.r0 + (arc.r1 - arc.r0) * s) * (0.7 + rand() * 0.5);
+        const a2 = rand() * Math.PI * 2;
+        const ox = Math.cos(a2) * r;
+        const oz = Math.sin(a2) * r;
+        spawn(
+          pools.water,
+          arc.x + arc.vx * t + ox,
+          arc.y + arc.vy * t - 4.9 * t * t,
+          arc.z + arc.vz * t + oz,
+          arc.vx + (wide ? ox * 1.2 : 0) + (rand() - 0.5) * 0.25,
+          arc.vy - 9.8 * t,
+          arc.vz + (wide ? oz * 1.2 : 0) + (rand() - 0.5) * 0.25,
+          0.22 + rand() * 0.25,
+          0.011 + rand() * 0.012,
+          9e-3 + rand() * 8e-3,
+          rand(),
+          2,
+          arc.stopY
+        );
+      }
+      const ex = arc.x + arc.vx * arc.t;
+      const ez = arc.z + arc.vz * arc.t;
+      for (let j = 0; j < nSplash; j++) {
+        const a2 = rand() * Math.PI * 2;
+        const r = arc.r1 * Math.sqrt(rand());
+        const sp = (wide ? 0.5 : 0.25) + rand() * 0.7;
+        spawn(pools.water, ex + Math.cos(a2) * r, arc.stopY + 5e-3, ez + Math.sin(a2) * r, Math.cos(a2) * sp, 0.9 + rand() * 1.3, Math.sin(a2) * sp, 0.3 + rand() * 0.25, 0.014 + rand() * 0.018, 0.01, rand(), 3, arc.stopY);
+      }
+      for (let j = 0; j < nMist; j++) {
+        const a2 = rand() * Math.PI * 2;
+        const r = arc.r1 * 1.4 * Math.sqrt(rand());
+        spawn(pools.water, ex + Math.cos(a2) * r, arc.stopY + 0.02, ez + Math.sin(a2) * r, Math.cos(a2) * 0.15, 0.18 + rand() * 0.15, Math.sin(a2) * 0.15, 0.7 + rand() * 0.5, 0.06 + size * 0.2, 0.2 + size * 0.5, rand(), 4, arc.stopY);
+      }
+      void k;
+    };
+    const emitDrip = (e, n) => {
+      const size = e.size > 0 ? e.size : 0.05;
+      const stopY = e.reach !== void 0 ? Math.max(e.pos[1] - e.reach, floorY) : floorY;
+      for (let j = 0; j < n; j++) {
+        const sx = (rand() - 0.5) * 0.01;
+        const sz = (rand() - 0.5) * 0.01;
+        spawn(pools.water, e.pos[0] + sx, e.pos[1], e.pos[2] + sz, e.dir[0] * 0.08, e.dir[1] * 0.08, e.dir[2] * 0.08, 1.4, size * 0.22, size * 0.2, rand(), 1, stopY);
+      }
+    };
+    const RATE = { smoke: 42, steam: 48, fire: 150, flame: 55, spark: 40, water: 0 };
+    const SEG = 12;
+    const SIDES = 8;
+    const maxStreams = Math.max(0, Math.floor(options.maxStreams ?? 6));
+    const streaksTex = makeStreaks(THREE);
+    const streamMat = new THREE.MeshBasicMaterial({ color: 10276095, map: streaksTex, vertexColors: true, transparent: true, opacity: 0.8, depthWrite: false, side: THREE.DoubleSide });
+    const streamIndex = [];
+    for (let i = 0; i < SEG; i++) {
+      for (let m = 0; m < SIDES; m++) {
+        const a2 = i * (SIDES + 1) + m;
+        const b2 = a2 + SIDES + 1;
+        streamIndex.push(a2, b2, a2 + 1, a2 + 1, b2, b2 + 1);
+      }
+    }
+    const group = new THREE.Group();
+    group.name = "effects:meshes";
+    scene.add(group);
+    const streams = [];
+    for (let i = 0; i < maxStreams; i++) {
+      const geo = new THREE.BufferGeometry();
+      const n = (SEG + 1) * (SIDES + 1);
+      geo.setAttribute("position", new THREE.BufferAttribute(new Float32Array(n * 3), 3).setUsage(THREE.DynamicDrawUsage));
+      geo.setAttribute("color", new THREE.BufferAttribute(new Float32Array(n * 4), 4).setUsage(THREE.DynamicDrawUsage));
+      const uv = new Float32Array(n * 2);
+      geo.setAttribute("uv", new THREE.BufferAttribute(uv, 2).setUsage(THREE.DynamicDrawUsage));
+      geo.setIndex(streamIndex);
+      const mesh = new THREE.Mesh(geo, streamMat);
+      mesh.frustumCulled = false;
+      mesh.visible = false;
+      mesh.name = `effects:stream${i}`;
+      group.add(mesh);
+      streams.push(mesh);
+    }
+    const writeStream = (mesh, k) => {
+      const geo = mesh.geometry;
+      const pos = geo.getAttribute("position").array;
+      const col = geo.getAttribute("color").array;
+      const uv = geo.getAttribute("uv").array;
+      for (let i = 0; i <= SEG; i++) {
+        const s = i / SEG;
+        const t = s * arc.t;
+        const cx = arc.x + arc.vx * t;
+        const cy = arc.y + arc.vy * t - 4.9 * t * t;
+        const cz = arc.z + arc.vz * t;
+        let tx = arc.vx;
+        let ty = arc.vy - 9.8 * t;
+        let tz = arc.vz;
+        const tl = Math.hypot(tx, ty, tz) || 1;
+        tx /= tl;
+        ty /= tl;
+        tz /= tl;
+        let bx = tz;
+        const by = 0;
+        let bz = -tx;
+        const bl = Math.hypot(bx, bz);
+        if (bl < 1e-4) {
+          bx = 1;
+          bz = 0;
+        } else {
+          bx /= bl;
+          bz /= bl;
+        }
+        const nx = ty * bz - tz * by;
+        const ny = tz * bx - tx * bz;
+        const nz = tx * by - ty * bx;
+        const r = arc.r0 + (arc.r1 - arc.r0) * s;
+        const alpha = Math.min(1, s * 7) * (0.95 - 0.3 * s) * Math.min(1, 0.55 + k);
+        for (let m = 0; m <= SIDES; m++) {
+          const a2 = m / SIDES * Math.PI * 2;
+          const ca = Math.cos(a2) * r;
+          const sa = Math.sin(a2) * r;
+          const v = i * (SIDES + 1) + m;
+          pos[v * 3] = cx + bx * ca + nx * sa;
+          pos[v * 3 + 1] = cy + by * ca + ny * sa;
+          pos[v * 3 + 2] = cz + bz * ca + nz * sa;
+          col[v * 4] = col[v * 4 + 1] = col[v * 4 + 2] = 1;
+          col[v * 4 + 3] = alpha;
+          uv[v * 2] = m / SIDES * 3;
+          uv[v * 2 + 1] = s * arc.t * 2.2;
+        }
+      }
+      ;
+      geo.getAttribute("position").needsUpdate = true;
+      geo.getAttribute("color").needsUpdate = true;
+      geo.getAttribute("uv").needsUpdate = true;
+      mesh.visible = true;
+    };
+    const CONES = 16;
+    const maxFlames = Math.max(0, Math.floor(options.maxFlames ?? 16));
+    const flameGeo = new THREE.BufferGeometry();
+    const flamePos = new THREE.BufferAttribute(new Float32Array(maxFlames * CONES * 4 * 3), 3).setUsage(THREE.DynamicDrawUsage);
+    const flameCol = new THREE.BufferAttribute(new Float32Array(maxFlames * CONES * 4 * 3), 3).setUsage(THREE.DynamicDrawUsage);
+    flameGeo.setAttribute("position", flamePos);
+    flameGeo.setAttribute("color", flameCol);
+    const flameIdx = [];
+    for (let i = 0; i < maxFlames * CONES; i++) {
+      const v = i * 4;
+      flameIdx.push(v, v + 1, v + 3, v + 1, v + 2, v + 3, v + 2, v, v + 3);
+    }
+    flameGeo.setIndex(flameIdx);
+    flameGeo.setDrawRange(0, 0);
+    const flames = new THREE.Mesh(
+      flameGeo,
+      new THREE.MeshBasicMaterial({ vertexColors: true, transparent: true, blending: THREE.AdditiveBlending, depthWrite: false, side: THREE.DoubleSide })
+    );
+    flames.frustumCulled = false;
+    flames.visible = false;
+    flames.name = "effects:flames";
+    group.add(flames);
+    const hashOf = (id) => {
+      let h = 2166136261;
+      for (let i = 0; i < id.length; i++) h = Math.imul(h ^ id.charCodeAt(i), 16777619);
+      return (h >>> 0) % 1e3 / 1e3;
+    };
+    const writeFlame = (slot, e, time) => {
+      const pa = flamePos.array;
+      const ca = flameCol.array;
+      const k = Math.min(1, Math.max(0, e.intensity));
+      const size = e.size > 0 ? e.size : 0.05;
+      const R = size * 0.8;
+      const bw = Math.max(4e-3, size * 0.13);
+      const phase = hashOf(e.id) * 40;
+      for (let c = 0; c < CONES; c++) {
+        const a2 = c / CONES * Math.PI * 2;
+        const ux = Math.cos(a2);
+        const uz = Math.sin(a2);
+        const bx = e.pos[0] + ux * R;
+        const bz = e.pos[2] + uz * R;
+        const by = e.pos[1];
+        const h = (0.025 + size * 0.45) * k * (0.55 + 0.45 * Math.abs(Math.sin(time * 19 + c * 2.3 + phase)));
+        const v = (slot * CONES + c) * 4;
+        const tx = -uz * bw;
+        const tz = ux * bw;
+        pa.set([bx + tx, by, bz + tz, bx - tx, by, bz - tz, bx + ux * bw * 0.9, by, bz + uz * bw * 0.9, bx - ux * h * 0.12, by + h, bz - uz * h * 0.12], v * 3);
+        const lo = 0.3 * k;
+        ca.set([0.2 * k, 0.45 * k, 1 * k, 0.2 * k, 0.45 * k, 1 * k, 0.2 * k, 0.45 * k, 1 * k, 0.02 * lo, 0.1 * lo, 0.5 * lo], v * 3);
+      }
+    };
+    const advance = (p, dt) => {
+      let i = 0;
+      const swayX = wind[0];
+      const swayZ = wind[1];
+      while (i < p.count) {
+        p.age[i] += dt;
+        const age = p.age[i];
+        const life = p.life[i];
+        if (age >= life || p.kind === "water" && p.pos[i * 3 + 1] < p.ground[i]) {
+          const last = --p.count;
+          if (i !== last) {
+            p.pos.copyWithin(i * 3, last * 3, last * 3 + 3);
+            p.vel.copyWithin(i * 3, last * 3, last * 3 + 3);
+            p.age[i] = p.age[last];
+            p.life[i] = p.life[last];
+            p.size0[i] = p.size0[last];
+            p.size1[i] = p.size1[last];
+            p.tint[i] = p.tint[last];
+            p.flags[i] = p.flags[last];
+            p.ground[i] = p.ground[last];
+          }
+          continue;
+        }
+        const j = i * 3;
+        switch (p.kind) {
+          case "smoke":
+          case "steam":
+            p.vel[j] += (swayX - p.vel[j]) * Math.min(1, dt * 0.8);
+            p.vel[j + 2] += (swayZ - p.vel[j + 2]) * Math.min(1, dt * 0.8);
+            break;
+          case "water":
+            if (p.flags[i] !== 4) p.vel[j + 1] -= 9.8 * dt;
+            break;
+          case "spark":
+            p.vel[j + 1] -= 7 * dt;
+            break;
+          case "fire":
+            p.vel[j] += (swayX * 0.1 - p.vel[j]) * Math.min(1, dt * 2);
+            break;
+        }
+        p.pos[j] += p.vel[j] * dt;
+        p.pos[j + 1] += p.vel[j + 1] * dt;
+        p.pos[j + 2] += p.vel[j + 2] * dt;
+        if (p.kind === "water" && p.pos[j + 1] < p.ground[i]) {
+          p.pos[j + 1] = p.ground[i];
+          p.age[i] = p.life[i];
+        }
+        i++;
+      }
+    };
+    const write = (p) => {
+      const n = p.count;
+      const pa = p.aPos.array;
+      const sa = p.aSize.array;
+      const aa = p.aAlpha.array;
+      const ca = p.aColor.array;
+      for (let i = 0; i < n; i++) {
+        const u = p.age[i] / p.life[i];
+        const j = i * 3;
+        pa[j] = p.pos[j];
+        pa[j + 1] = p.pos[j + 1];
+        pa[j + 2] = p.pos[j + 2];
+        sa[i] = p.size0[i] + (p.size1[i] - p.size0[i]) * u;
+        let alpha;
+        switch (p.kind) {
+          case "smoke":
+            alpha = 0.55 * Math.min(1, u * 8) * (1 - u);
+            ca[j] = ca[j + 1] = ca[j + 2] = p.tint[i];
+            break;
+          case "steam":
+            alpha = 0.4 * Math.min(1, u * 6) * (1 - u);
+            ca[j] = ca[j + 1] = ca[j + 2] = p.tint[i];
+            break;
+          case "fire":
+            alpha = (p.flags[i] ? 0.95 : 0.8) * (1 - u * u);
+            if (p.flags[i]) {
+              ca[j] = 0.25 + 0.15 * p.tint[i];
+              ca[j + 1] = 0.5 + 0.2 * p.tint[i];
+              ca[j + 2] = 1;
+            } else {
+              ca[j] = 1;
+              ca[j + 1] = Math.max(0.15, 0.85 - u * 0.7 - p.tint[i] * 0.1);
+              ca[j + 2] = Math.max(0, 0.25 - u * 0.25);
+            }
+            break;
+          case "spark":
+            alpha = 1 - u;
+            ca[j] = 1;
+            ca[j + 1] = 0.75 - u * 0.4;
+            ca[j + 2] = 0.3;
+            break;
+          default: {
+            const f = p.flags[i];
+            alpha = f === 4 ? 0.16 * (1 - u) : f === 3 ? 0.8 * (1 - u * 0.5) : f === 2 ? 0.65 * (1 - u * 0.6) : 0.8;
+            ca[j] = f === 4 ? 0.85 : 0.5;
+            ca[j + 1] = f === 4 ? 0.92 : 0.74;
+            ca[j + 2] = 1;
+          }
+        }
+        aa[i] = alpha;
+      }
+      p.aPos.needsUpdate = true;
+      p.aSize.needsUpdate = true;
+      p.aAlpha.needsUpdate = true;
+      p.aColor.needsUpdate = true;
+      p.points.geometry.setDrawRange(0, n);
+    };
+    return {
+      objects,
+      meshes: { group, streams, flames },
+      update(dt, emitters, cam) {
+        camera = cam ?? (typeof cameraSource === "function" ? cameraSource() : cameraSource);
+        refreshScale(camera);
+        const step = Math.min(Math.max(dt, 0), 0.1);
+        stamp++;
+        clock += step;
+        streaksTex.offset.y = -(clock * 2.4) % 1;
+        let nStreams = 0;
+        let nFlames = 0;
+        const due = (key, rate) => {
+          let d = debt.get(key);
+          if (!d) {
+            d = { carry: 0, stamp };
+            debt.set(key, d);
+          }
+          d.stamp = stamp;
+          d.carry += rate * step;
+          const n = Math.floor(d.carry);
+          d.carry -= n;
+          return n;
+        };
+        for (let i = 0; i < emitters.length; i++) {
+          const e = emitters[i];
+          if (!(e.intensity > 0)) continue;
+          const k = Math.min(1, e.intensity);
+          const size = e.size > 0 ? e.size : 0.05;
+          if (e.kind === "water") {
+            if (k < 0.25) {
+              const n2 = due(e.id, 3 + k * 10);
+              if (n2 > 0) emitDrip(e, n2);
+            } else if (arcOf(e, k)) {
+              const nSpray = due(e.id, (60 + 260 * Math.min(size, 0.4)) * k);
+              const nSplash = due(`${e.id}#s`, (45 + 90 * Math.min(size, 0.4)) * k);
+              const nMist = due(`${e.id}#m`, 6 * k * (1 + size * 4));
+              emitWater(e, k, nSpray, nSplash, nMist);
+              if (nStreams < streams.length) writeStream(streams[nStreams++], k);
+            }
+            continue;
+          }
+          if (e.kind === "flame" && nFlames < maxFlames) writeFlame(nFlames++, e, clock);
+          const n = due(e.id, RATE[e.kind] * k);
+          if (n > 0) emitFrom(e, n);
+        }
+        for (let i = nStreams; i < streams.length; i++) streams[i].visible = false;
+        flames.visible = nFlames > 0;
+        flameGeo.setDrawRange(0, nFlames * CONES * 9);
+        flamePos.needsUpdate = true;
+        flameCol.needsUpdate = true;
+        if (debt.size > emitters.length * 3 + 8) {
+          for (const [id, d] of debt) if (d.stamp !== stamp) debt.delete(id);
+        }
+        for (const kind of POOLS) {
+          advance(pools[kind], step);
+          write(pools[kind]);
+        }
+      },
+      setWind(x, z) {
+        wind[0] = x;
+        wind[1] = z;
+      },
+      setCamera(cam) {
+        cameraSource = cam;
+        camera = typeof cam === "function" ? cam() : cam;
+        refreshScale(camera);
+      },
+      setViewHeight(px) {
+        viewHeight = px;
+        refreshScale(camera);
+      },
+      stats() {
+        const byKind = {};
+        let alive = 0;
+        let capacity = 0;
+        for (const kind of POOLS) {
+          byKind[kind] = pools[kind].count;
+          alive += pools[kind].count;
+          capacity += pools[kind].cap;
+        }
+        return { alive, capacity, byKind };
+      },
+      clear() {
+        for (const kind of POOLS) {
+          pools[kind].count = 0;
+          write(pools[kind]);
+        }
+        debt.clear();
+        for (const m of streams) m.visible = false;
+        flames.visible = false;
+      },
+      dispose() {
+        for (const kind of POOLS) {
+          scene.remove(objects[kind]);
+          objects[kind].geometry.dispose();
+          objects[kind].material.dispose();
+        }
+        scene.remove(group);
+        for (const m of streams) m.geometry.dispose();
+        flameGeo.dispose();
+        flames.material.dispose();
+        streamMat.dispose();
+        streaksTex.dispose();
+        sprite.dispose();
+      }
+    };
+  }
+
+  // src/cord.ts
+  function catenary(a, b, sag, n = 12) {
+    const count = Math.max(2, Math.floor(n));
+    const span = Math.hypot(b[0] - a[0], b[2] - a[2]) || Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+    const depth = Math.max(0, sag);
+    const out = [];
+    let shape = () => 0;
+    if (depth > 1e-6 && span > 1e-6) {
+      let lo = 1e-4;
+      let hi = span * 1e3;
+      for (let i = 0; i < 80; i++) {
+        const c2 = (lo + hi) / 2;
+        const d = c2 * (Math.cosh(span / (2 * c2)) - 1);
+        if (d > depth) lo = c2;
+        else hi = c2;
+      }
+      const c = (lo + hi) / 2;
+      shape = (s) => c * (Math.cosh((s - 0.5) * span / c) - Math.cosh(span / (2 * c)));
+    }
+    for (let i = 0; i < count; i++) {
+      const s = i / (count - 1);
+      out.push([a[0] + (b[0] - a[0]) * s, a[1] + (b[1] - a[1]) * s + shape(s), a[2] + (b[2] - a[2]) * s]);
+    }
+    return out;
+  }
+  function createCord(THREE, points, radius, material, radialSegments = 5) {
+    if (points.length < 2) throw new Error("createCord needs at least two points");
+    const curve = new THREE.CatmullRomCurve3(points.map((p) => new THREE.Vector3(p[0], p[1], p[2])), false, "centripetal");
+    const segments = Math.max(4, (points.length - 1) * 4);
+    const mesh = new THREE.Mesh(new THREE.TubeGeometry(curve, segments, radius, radialSegments, false), material);
+    mesh.name = "cord";
+    mesh.castShadow = true;
+    return mesh;
+  }
+
+  // src/types.ts
+  var MATERIAL_KEYS = ["plain", "metal", "wood", "glass", "fabric", "plant", "water", "emissive", "atlas_picture", "atlas_floor"];
+
+  // ../game-interactables/dist/index.js
+  var DEFAULT_AXIS = [0, 1, 0];
+  function poseOf(motion, t) {
+    const tt = Math.max(0, Math.min(1, t));
+    const axis = motion.axis ?? DEFAULT_AXIS;
+    const pose = { position: [0, 0, 0], rotation: { axis: [axis[0], axis[1], axis[2]], angle: 0 }, scale: [1, 1, 1] };
+    switch (motion.kind) {
+      case "hinge":
+      case "rocker":
+      case "knob":
+        pose.rotation.angle = (motion.angle ?? Math.PI / 2) * tt;
+        break;
+      case "slide": {
+        const d = (motion.distance ?? 0.4) * tt;
+        pose.position = [axis[0] * d, axis[1] * d, axis[2] * d];
+        break;
+      }
+      case "scale": {
+        const k = 1 + ((motion.scale ?? 0.2) - 1) * tt;
+        pose.scale = [axis[0] !== 0 ? k : 1, axis[1] !== 0 ? k : 1, axis[2] !== 0 ? k : 1];
+        break;
+      }
+    }
+    return pose;
+  }
+
+  // src/pose.ts
+  function poseOf2(motion, t) {
+    const k = Math.min(1, Math.max(0, Number.isFinite(t) ? t : 0));
+    const pose = poseOf(motion, k);
+    const [x, y, z] = pose.rotation.axis;
+    const l = Math.hypot(x, y, z) || 1;
+    const s = Math.sin(pose.rotation.angle / 2);
+    return {
+      position: [pose.position[0], pose.position[1], pose.position[2]],
+      quaternion: [x / l * s, y / l * s, z / l * s, Math.cos(pose.rotation.angle / 2)],
+      scale: [pose.scale[0], pose.scale[1], pose.scale[2]]
+    };
+  }
+  function rememberRest(group) {
+    let rest = group.userData.rest;
+    if (!rest) {
+      const p = group.position;
+      const q = group.quaternion;
+      const s = group.scale;
+      rest = { position: [p.x, p.y, p.z], quaternion: [q.x, q.y, q.z, q.w], scale: [s.x, s.y, s.z] };
+      group.userData.rest = rest;
+    }
+    return rest;
+  }
+  function applyPose(THREE, group, motion, t) {
+    const rest = rememberRest(group);
+    const pose = poseOf2(motion, t);
+    const restQ = new THREE.Quaternion(rest.quaternion[0], rest.quaternion[1], rest.quaternion[2], rest.quaternion[3]);
+    const delta = new THREE.Quaternion(pose.quaternion[0], pose.quaternion[1], pose.quaternion[2], pose.quaternion[3]);
+    group.quaternion.copy(restQ).multiply(delta);
+    const offset = new THREE.Vector3(pose.position[0], pose.position[1], pose.position[2]).applyQuaternion(restQ);
+    group.position.set(rest.position[0] + offset.x, rest.position[1] + offset.y, rest.position[2] + offset.z);
+    group.scale.set(rest.scale[0] * pose.scale[0], rest.scale[1] * pose.scale[1], rest.scale[2] * pose.scale[2]);
+    group.updateMatrix();
+    return group;
+  }
+  function syncObject(THREE, world, objectId, parts, options = {}) {
+    const obj = world.get(objectId);
+    if (!obj) return;
+    const motionOf = /* @__PURE__ */ new Map();
+    for (const p of obj.spec.parts ?? []) {
+      motionOf.set(p.id, p.motion);
+      const g = parts[p.id];
+      if (!g) continue;
+      const merged = g.userData.merged;
+      if (merged) {
+        merged.apply?.(p.motion, world.partT(objectId, p.id));
+        continue;
+      }
+      applyPose(THREE, g, p.motion, world.partT(objectId, p.id));
+    }
+    for (const soft of obj.spec.soft ?? []) {
+      const key = soft.part ?? soft.id;
+      const g = parts[key] ?? parts[soft.id];
+      if (!g) continue;
+      const { ax, az } = world.sway(objectId, soft.id);
+      const batch = g.userData.merged;
+      if (batch?.kind === "sway") {
+        const i = batch.index?.[soft.id];
+        if (i !== void 0) batch.setAt?.(i, ax, az);
+        if (options.time !== void 0) batch.setTime?.(options.time);
+        continue;
+      }
+      let shaded = false;
+      g.traverse((o) => {
+        const sway = o.userData.sway;
+        if (sway) {
+          sway.set(ax, az, options.time);
+          shaded = true;
+        }
+      });
+      if (shaded) continue;
+      rememberRest(g);
+      if (!motionOf.has(key)) applyPose(THREE, g, { kind: "hinge", angle: 0 }, 0);
+      const rot = new THREE.Quaternion().setFromEuler(new THREE.Euler(ax, 0, az, "XYZ"));
+      const anchor = new THREE.Vector3(soft.anchor[0], soft.anchor[1], soft.anchor[2]);
+      g.position.sub(anchor).applyQuaternion(rot).add(anchor);
+      g.quaternion.premultiply(rot);
+      g.updateMatrix();
+    }
+  }
+
+  // src/merge.ts
+  var QROT = (
+    /* glsl */
+    `
+vec3 batchRotate(vec4 q, vec3 v) { return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + q.w * v); }
+`
+  );
+  function patchProgram(material, key, patchShader, inherit) {
+    const previous = material.onBeforeCompile;
+    material.onBeforeCompile = (shader, renderer) => {
+      previous?.call(material, shader, renderer);
+      patchShader(shader);
+    };
+    const inherited = inherit?.customProgramCacheKey;
+    material.customProgramCacheKey = inherited && inherit ? () => `${inherited.call(inherit)}|${key}` : () => key;
+    return material;
+  }
+  function cloneKeepingHooks(base) {
+    const clone = base.clone();
+    if (base.defines) clone.defines = { ...clone.defines ?? {}, ...base.defines };
+    if (base.onBeforeCompile !== Object.getPrototypeOf(base).onBeforeCompile) clone.onBeforeCompile = base.onBeforeCompile;
+    clone.userData = { ...base.userData, mergedFrom: base.uuid };
+    return clone;
+  }
+  function patchedSet(THREE, base, key, patchShader) {
+    return {
+      material: patchProgram(cloneKeepingHooks(base), key, patchShader, base),
+      depth: patchProgram(new THREE.MeshDepthMaterial({ depthPacking: THREE.RGBADepthPacking }), key, patchShader),
+      distance: patchProgram(new THREE.MeshDistanceMaterial(), key, patchShader)
+    };
+  }
+  function concat(THREE, pieces, extraSizes) {
+    let verts = 0;
+    let idx = 0;
+    for (const p of pieces) {
+      verts += p.geometry.getAttribute("position").count;
+      idx += p.geometry.index.count;
+    }
+    const pos = new Float32Array(verts * 3);
+    const nor = new Float32Array(verts * 3);
+    const col = new Float32Array(verts * 3);
+    const uv = new Float32Array(verts * 2);
+    const index = new Uint32Array(idx);
+    const extra = {};
+    for (const [k, n] of Object.entries(extraSizes)) extra[k] = new Float32Array(verts * n);
+    const v = new THREE.Vector3();
+    const n3 = new THREE.Matrix3();
+    let vo = 0;
+    let io = 0;
+    for (const p of pieces) {
+      const g = p.geometry;
+      const count = g.getAttribute("position").count;
+      n3.getNormalMatrix(p.matrix);
+      const gp = g.getAttribute("position");
+      const gn = g.getAttribute("normal");
+      const gc = g.getAttribute("color");
+      const gu = g.getAttribute("uv");
+      for (let i = 0; i < count; i++) {
+        v.fromBufferAttribute(gp, i).applyMatrix4(p.matrix);
+        pos.set([v.x, v.y, v.z], (vo + i) * 3);
+        v.fromBufferAttribute(gn, i).applyMatrix3(n3).normalize();
+        nor.set([v.x, v.y, v.z], (vo + i) * 3);
+        col.set([gc.getX(i), gc.getY(i), gc.getZ(i)], (vo + i) * 3);
+        uv.set([gu.getX(i), gu.getY(i)], (vo + i) * 2);
+      }
+      for (const [k, values] of Object.entries(p.extra)) extra[k].set(values, vo * extraSizes[k]);
+      const gi = g.index;
+      for (let i = 0; i < gi.count; i++) index[io + i] = gi.getX(i) + vo;
+      vo += count;
+      io += gi.count;
+    }
+    const out = new THREE.BufferGeometry();
+    out.setAttribute("position", new THREE.BufferAttribute(pos, 3));
+    out.setAttribute("normal", new THREE.BufferAttribute(nor, 3));
+    out.setAttribute("color", new THREE.BufferAttribute(col, 3));
+    out.setAttribute("uv", new THREE.BufferAttribute(uv, 2));
+    for (const [k, n] of Object.entries(extraSizes)) out.setAttribute(k, new THREE.BufferAttribute(extra[k], n));
+    out.setIndex(new THREE.BufferAttribute(verts > 65535 ? index : new Uint16Array(index), 1));
+    out.computeBoundingSphere();
+    out.computeBoundingBox();
+    return out;
+  }
+  function meshesOf(group) {
+    return group.children.filter((c) => c.isMesh);
+  }
+  function mergeParts(THREE, root, parts, spec, options = {}) {
+    const amplitude = options.swayAmplitude ?? 0.04;
+    const skip = /* @__PURE__ */ new Set();
+    for (const m of spec.mirrors ?? []) if (m.part) skip.add(m.part);
+    for (const [id, g] of Object.entries(parts)) if (Math.abs(g.rotation.y) > 1e-9 || g.userData.merged) skip.add(id);
+    const take = (ids) => ids.map((id) => parts[id]);
+    const retire = (ids, merged) => {
+      for (const id of ids) {
+        const g = parts[id];
+        g.removeFromParent();
+        for (const m of meshesOf(g)) m.geometry.dispose();
+        parts[id] = merged;
+      }
+      root.add(merged);
+    };
+    const byMaterial = (groups, extra) => {
+      const map = /* @__PURE__ */ new Map();
+      for (const g of groups) {
+        g.updateMatrix();
+        for (const mesh of meshesOf(g)) {
+          const key = `${String(mesh.userData.material)}|${mesh.material.uuid}`;
+          let e = map.get(key);
+          if (!e) {
+            e = { base: mesh.material, pieces: [], mesh };
+            map.set(key, e);
+          }
+          e.pieces.push({ geometry: mesh.geometry, matrix: g.matrix, extra: extra(g, mesh.geometry.getAttribute("position").count) });
+        }
+      }
+      return map;
+    };
+    const finishMesh = (name, key, geometry, template, set, group) => {
+      const mesh = new THREE.Mesh(geometry, set.material);
+      mesh.name = `${name}:${key}`;
+      mesh.userData.material = key;
+      mesh.castShadow = template.castShadow;
+      mesh.receiveShadow = template.receiveShadow;
+      mesh.customDepthMaterial = set.depth;
+      mesh.customDistanceMaterial = set.distance;
+      group.add(mesh);
+    };
+    const cloths = (spec.soft ?? []).filter((s) => s.kind === "cloth" && parts[s.part ?? s.id] && !skip.has(s.part ?? s.id));
+    const clothPart = (s) => s.part ?? s.id;
+    const toggled = /* @__PURE__ */ new Set();
+    for (const i of spec.interactions ?? []) {
+      const a = i.action;
+      if (a.do === "toggle_part" && a.part) toggled.add(a.part);
+    }
+    const swing = cloths.filter((s) => !toggled.has(clothPart(s)));
+    if (swing.length >= 2) {
+      const ids = swing.map(clothPart);
+      const index = {};
+      swing.forEach((s, i) => index[s.id] = i);
+      const indexOfPart = new Map(swing.map((s, i) => [clothPart(s), i]));
+      const anchorOfPart = new Map(swing.map((s) => [clothPart(s), s.anchor[1]]));
+      const n = swing.length;
+      const uniforms = { time: { value: 0 }, axz: { value: Array.from({ length: n }, () => new THREE.Vector2()) } };
+      const groups = take(ids);
+      const partIdOf = new Map(groups.map((g, i) => [g, ids[i]]));
+      const plan = byMaterial(groups, (g, count) => {
+        const id = partIdOf.get(g);
+        return { swayId: new Array(count).fill(indexOf(indexOfPart, id)), swayAnchor: new Array(count).fill(anchorOfPart.get(id) ?? 0) };
+      });
+      const merged = new THREE.Group();
+      merged.name = "merge:cloth";
+      const patch2 = (shader) => {
+        shader.uniforms.swayTime = uniforms.time;
+        shader.uniforms.swayAxz = uniforms.axz;
+        shader.vertexShader = `attribute float swayId;
+attribute float swayAnchor;
+uniform float swayTime;
+uniform vec2 swayAxz[${n}];
+` + shader.vertexShader.replace(
+          "#include <begin_vertex>",
+          `#include <begin_vertex>
+{
+  vec2 swayA = swayAxz[int(swayId + 0.5)];
+  float swayHang = max(swayAnchor - position.y, 0.0);
+  float swayFlutter = ${amplitude.toFixed(4)} * sin(swayTime * 1.9 + swayId * 1.7 + position.x * 4.0 + position.z * 3.0 + swayHang * 3.0);
+  transformed.x += swayHang * (sin(swayA.y) + swayFlutter);
+  transformed.z += swayHang * (-sin(swayA.x) + swayFlutter * 0.6);
+  transformed.y += swayHang * (1.0 - cos(swayA.y) * cos(swayA.x));
+}`
+        );
+      };
+      for (const e of plan.values()) {
+        const key = String(e.mesh.userData.material);
+        const set = patchedSet(THREE, e.base, `swayBatch:${n}:${amplitude}`, patch2);
+        finishMesh("merge:cloth", key, concat(THREE, e.pieces, { swayId: 1, swayAnchor: 1 }), e.mesh, set, merged);
+      }
+      const batch = {
+        kind: "sway",
+        index,
+        setAt(i, ax, az) {
+          uniforms.axz.value[i].set(ax, az);
+        },
+        setTime(t) {
+          uniforms.time.value = t;
+        }
+      };
+      merged.userData.merged = batch;
+      retire(ids, merged);
+      for (const id of ids) skip.add(id);
+    }
+    const bySignature = /* @__PURE__ */ new Map();
+    for (const p of spec.parts ?? []) {
+      if (!p.group || !parts[p.id] || skip.has(p.id)) continue;
+      const sig = `${p.group}|${JSON.stringify(p.motion)}`;
+      const list = bySignature.get(sig);
+      if (list) list.push(p.id);
+      else bySignature.set(sig, [p.id]);
+    }
+    for (const [sig, ids] of bySignature) {
+      if (ids.length < 2) continue;
+      const motion = (spec.parts ?? []).find((p) => p.id === ids[0]).motion;
+      const uniforms = { q: { value: new THREE.Vector4(0, 0, 0, 1) }, pos: { value: new THREE.Vector3() }, scale: { value: new THREE.Vector3(1, 1, 1) } };
+      const groups = take(ids);
+      const plan = byMaterial(groups, (g, count) => {
+        const pv = new Array(count * 3);
+        for (let i = 0; i < count; i++) {
+          pv[i * 3] = g.position.x;
+          pv[i * 3 + 1] = g.position.y;
+          pv[i * 3 + 2] = g.position.z;
+        }
+        return { batchPivot: pv };
+      });
+      const merged = new THREE.Group();
+      merged.name = `merge:${sig.split("|")[0]}`;
+      const patch2 = (shader) => {
+        shader.uniforms.batchQ = uniforms.q;
+        shader.uniforms.batchPos = uniforms.pos;
+        shader.uniforms.batchScale = uniforms.scale;
+        let src = `attribute vec3 batchPivot;
+uniform vec4 batchQ;
+uniform vec3 batchPos;
+uniform vec3 batchScale;
+${QROT}${shader.vertexShader}`;
+        src = src.replace("#include <begin_vertex>", "#include <begin_vertex>\ntransformed = batchPivot + batchRotate(batchQ, (position - batchPivot) * batchScale) + batchPos;");
+        src = src.replace("#include <beginnormal_vertex>", "#include <beginnormal_vertex>\nobjectNormal = batchRotate(batchQ, objectNormal);");
+        shader.vertexShader = src;
+      };
+      for (const e of plan.values()) {
+        const key = String(e.mesh.userData.material);
+        const set = patchedSet(THREE, e.base, "poseBatch", patch2);
+        finishMesh(merged.name, key, concat(THREE, e.pieces, { batchPivot: 3 }), e.mesh, set, merged);
+      }
+      const batch = {
+        kind: "pose",
+        ids,
+        apply(m, t) {
+          const pose = poseOf2(m, t);
+          uniforms.q.value.set(pose.quaternion[0], pose.quaternion[1], pose.quaternion[2], pose.quaternion[3]);
+          uniforms.pos.value.set(pose.position[0], pose.position[1], pose.position[2]);
+          uniforms.scale.value.set(pose.scale[0], pose.scale[1], pose.scale[2]);
+        }
+      };
+      batch.apply(motion, 0);
+      merged.userData.merged = batch;
+      retire(ids, merged);
+    }
+  }
+  function indexOf(map, id) {
+    return map.get(id) ?? 0;
+  }
+
+  // src/mesh.ts
+  function createDefaultMaterials(THREE, quality = "high") {
+    const defined = (o) => {
+      const out = {};
+      for (const k of Object.keys(o)) if (o[k] !== void 0) out[k] = o[k];
+      return out;
+    };
+    const std = (p) => quality === "game" ? new THREE.MeshLambertMaterial(defined({ vertexColors: true, transparent: p.transparent, opacity: p.opacity, depthWrite: p.depthWrite, side: p.side })) : new THREE.MeshStandardMaterial(defined({ vertexColors: true, roughness: 0.85, metalness: 0, ...p }));
+    const solid = quality === "game" ? std({}) : null;
+    return {
+      plain: solid ?? std({}),
+      metal: solid ?? std({ roughness: 0.35, metalness: 0.7 }),
+      wood: solid ?? std({ roughness: 0.8 }),
+      glass: std({ roughness: 0.05, transparent: true, opacity: 0.35, depthWrite: false }),
+      fabric: solid ?? std({ roughness: 1 }),
+      plant: std({ roughness: 0.9, side: THREE.DoubleSide }),
+      water: std({ roughness: 0.1, transparent: true, opacity: 0.7, depthWrite: false }),
+      emissive: new THREE.MeshBasicMaterial({ vertexColors: true }),
+      atlas_picture: std({ roughness: 0.9 }),
+      atlas_floor: std({ roughness: 1 })
+    };
+  }
+  var IDENT_UV = { u0: 0, v0: 0, u1: 1, v1: 1 };
+  function createMeshApi(THREE, options = {}) {
+    const quality = options.quality ?? "high";
+    const shadows = options.shadows !== false;
+    const materials = { ...createDefaultMaterials(THREE, quality), ...stripUndefined(options.materials) };
+    if (options.doubleSidedPlanes) for (const k of MATERIAL_KEYS) materials[k].side = THREE.DoubleSide;
+    const root = { id: null, pivot: [0, 0, 0], ry: 0, acc: /* @__PURE__ */ new Map(), lights: [] };
+    const partTargets = /* @__PURE__ */ new Map();
+    const stack = [];
+    let current = root;
+    let finished = false;
+    const templates = /* @__PURE__ */ new Map();
+    const template = (key, make) => {
+      let t = templates.get(key);
+      if (!t) {
+        const g = make();
+        t = {
+          pos: g.getAttribute("position").array,
+          nor: g.getAttribute("normal").array,
+          uv: g.getAttribute("uv").array,
+          idx: g.index ? g.index.array : Array.from({ length: g.getAttribute("position").count }, (_, i) => i)
+        };
+        templates.set(key, t);
+      }
+      return t;
+    };
+    const segs = quality === "high" ? { cyl: 12, sphereW: 12, sphereH: 8 } : { cyl: 8, sphereW: 8, sphereH: 6 };
+    const tBox = () => template("box", () => new THREE.BoxGeometry(1, 1, 1));
+    const tCyl = (shape) => {
+      switch (shape) {
+        case "cyl6":
+          return template("cyl6", () => new THREE.CylinderGeometry(1, 1, 1, 6));
+        case "cone":
+          return template("cone", () => new THREE.CylinderGeometry(0, 1, 1, segs.cyl));
+        case "sphere":
+          return template("sphere", () => new THREE.SphereGeometry(1, segs.sphereW, segs.sphereH));
+        default:
+          return template("cyl", () => new THREE.CylinderGeometry(1, 1, 1, segs.cyl));
+      }
+    };
+    const tPlane = () => template("plane", () => new THREE.PlaneGeometry(1, 1));
+    const tLeaf = () => {
+      let t = templates.get("leaf");
+      if (!t) {
+        const f = [0, 0, 0, -0.5, 0.4, 0, 0.5, 0.4, 0, 0, 1, 0];
+        const pos = [];
+        const nor = [];
+        const uv = [];
+        const idx = [];
+        for (const side of [1, -1]) {
+          const base = pos.length / 3;
+          for (let i = 0; i < 4; i++) {
+            pos.push(f[i * 3], f[i * 3 + 1], f[i * 3 + 2]);
+            nor.push(0, 0, side);
+            uv.push(f[i * 3] + 0.5, f[i * 3 + 1]);
+          }
+          if (side === 1) idx.push(base, base + 2, base + 1, base + 1, base + 2, base + 3);
+          else idx.push(base, base + 1, base + 2, base + 1, base + 3, base + 2);
+        }
+        t = { pos: new Float32Array(pos), nor: new Float32Array(nor), uv: new Float32Array(uv), idx };
+        templates.set("leaf", t);
+      }
+      return t;
+    };
+    const m4 = new THREE.Matrix4();
+    const mItem = new THREE.Matrix4();
+    const mTotal = new THREE.Matrix4();
+    const n3 = new THREE.Matrix3();
+    const v = new THREE.Vector3();
+    const quat = new THREE.Quaternion();
+    const euler = new THREE.Euler();
+    const scl = new THREE.Vector3();
+    const color = new THREE.Color();
+    const canonical = /* @__PURE__ */ new Map();
+    for (const k of MATERIAL_KEYS) {
+      const first = MATERIAL_KEYS.find((o) => materials[o] === materials[k]) ?? k;
+      canonical.set(k, first);
+    }
+    const accOf = (requested) => {
+      const key = canonical.get(requested) ?? requested;
+      let a = current.acc.get(key);
+      if (!a) {
+        a = { pos: [], nor: [], col: [], uv: [], idx: [] };
+        current.acc.set(key, a);
+      }
+      return a;
+    };
+    const frame = (M) => {
+      mItem.makeRotationY(M?.ry ?? 0);
+      mItem.setPosition(M?.x ?? 0, 0, M?.z ?? 0);
+      return mItem;
+    };
+    const emit = (requested, M, local, t, hexColor, uv) => {
+      const key = requested in materials ? requested : "plain";
+      const a = accOf(key);
+      const total = mTotal.copy(frame(M)).multiply(local);
+      n3.getNormalMatrix(total);
+      const base = a.pos.length / 3;
+      color.setHex(hexColor);
+      const count = t.pos.length / 3;
+      const e = total.elements;
+      const nm = n3.elements;
+      const u = uv ?? IDENT_UV;
+      for (let i = 0; i < count; i++) {
+        const x = t.pos[i * 3];
+        const y = t.pos[i * 3 + 1];
+        const z = t.pos[i * 3 + 2];
+        a.pos.push(e[0] * x + e[4] * y + e[8] * z + e[12], e[1] * x + e[5] * y + e[9] * z + e[13], e[2] * x + e[6] * y + e[10] * z + e[14]);
+        const nx = t.nor[i * 3];
+        const ny = t.nor[i * 3 + 1];
+        const nz = t.nor[i * 3 + 2];
+        v.set(nm[0] * nx + nm[3] * ny + nm[6] * nz, nm[1] * nx + nm[4] * ny + nm[7] * nz, nm[2] * nx + nm[5] * ny + nm[8] * nz).normalize();
+        a.nor.push(v.x, v.y, v.z);
+        a.col.push(color.r, color.g, color.b);
+        a.uv.push(u.u0 + t.uv[i * 2] * (u.u1 - u.u0), u.v0 + t.uv[i * 2 + 1] * (u.v1 - u.v0));
+      }
+      for (let i = 0; i < t.idx.length; i++) a.idx.push(base + t.idx[i]);
+    };
+    const compose = (x, y, z, rx, ry, rz, sx, sy, sz) => {
+      euler.set(rx, ry, rz, "YXZ");
+      quat.setFromEuler(euler);
+      return m4.compose(v.set(x, y, z), quat, scl.set(sx, sy, sz));
+    };
+    const api = {
+      box(M, material, x, y, z, w, h, d, col, ry, rx, rz) {
+        emit(material, M, compose(x, y + h / 2, z, rx, ry, rz, w, h, d), tBox(), col);
+      },
+      cylinder(M, material, x, y, z, r, h, col, rx, rz, shape) {
+        const tilted = rx !== 0 || rz !== 0;
+        const cy = shape === "sphere" ? y + h / 2 : tilted ? y : y + h / 2;
+        const sy = shape === "sphere" ? h / 2 : h;
+        emit(material, M, compose(x, cy, z, rx, 0, rz, r, sy, r), tCyl(shape), col);
+      },
+      leaf(M, x, y, z, w, h, col, ry, rx) {
+        emit("plant", M, compose(x, y, z, rx, ry, 0, w, h, 1), tLeaf(), col);
+      },
+      plane(M, material, x, y, z, w, h, col, ry, rx, rz, uv) {
+        emit(material, M, compose(x, y, z, rx, ry, rz, w, h, 1), tPlane(), col, uv);
+      },
+      light(M, x, y, z, col, range) {
+        const fr = frame(M);
+        v.set(x, y, z).applyMatrix4(fr);
+        current.lights.push({ x: v.x, y: v.y, z: v.z, color: col, range });
+      },
+      part(id, pivot, ry, draw) {
+        let target = partTargets.get(id);
+        if (!target) {
+          target = { id, pivot: [pivot[0], pivot[1], pivot[2]], ry, acc: /* @__PURE__ */ new Map(), lights: [] };
+          partTargets.set(id, target);
+        }
+        stack.push(current);
+        current = target;
+        try {
+          draw();
+        } finally {
+          current = stack.pop() ?? root;
+        }
+      }
+    };
+    const build = (target, into, materialFor) => {
+      for (const [key, a] of target.acc) {
+        if (!a.idx.length) continue;
+        const g = new THREE.BufferGeometry();
+        g.setAttribute("position", new THREE.Float32BufferAttribute(a.pos, 3));
+        g.setAttribute("normal", new THREE.Float32BufferAttribute(a.nor, 3));
+        g.setAttribute("color", new THREE.Float32BufferAttribute(a.col, 3));
+        g.setAttribute("uv", new THREE.Float32BufferAttribute(a.uv, 2));
+        g.setIndex(a.pos.length / 3 > 65535 ? new THREE.Uint32BufferAttribute(a.idx, 1) : new THREE.Uint16BufferAttribute(a.idx, 1));
+        g.computeBoundingSphere();
+        g.computeBoundingBox();
+        const mesh = new THREE.Mesh(g, materialFor?.(key, target.id) ?? materials[key]);
+        mesh.name = target.id === null ? `static:${key}` : `part:${target.id}`;
+        if (target.id !== null) mesh.userData.part = target.id;
+        mesh.userData.material = key;
+        mesh.castShadow = shadows;
+        mesh.receiveShadow = shadows;
+        into.add(mesh);
+      }
+      for (const l of target.lights) {
+        const light = new THREE.PointLight(l.color, 1, l.range);
+        light.position.set(l.x, l.y, l.z);
+        into.add(light);
+        lightsOut.push(light);
+      }
+    };
+    const lightsOut = [];
+    return {
+      api,
+      materials,
+      finish(spec, finishOptions) {
+        const materialFor = finishOptions?.materialFor ?? options.materialFor;
+        if (finished) throw new Error("createMeshApi: finish() was already called");
+        finished = true;
+        const group = new THREE.Group();
+        group.name = "interactable";
+        const parts = {};
+        build(root, group, materialFor);
+        for (const [id, target] of partTargets) {
+          const g = new THREE.Group();
+          g.name = `part:${id}`;
+          g.userData.part = id;
+          g.position.set(target.pivot[0], target.pivot[1], target.pivot[2]);
+          g.rotation.y = target.ry;
+          g.updateMatrix();
+          build(target, g, materialFor);
+          rememberRest(g);
+          group.add(g);
+          parts[id] = g;
+        }
+        if (spec && (options.mergeParts ?? quality === "game")) mergeParts(THREE, group, parts, spec, { swayAmplitude: options.swayAmplitude });
+        if (spec) tagDestruction(group, parts, spec);
+        return { group, parts, lights: lightsOut };
+      }
+    };
+  }
+  function tagDestruction(group, parts, spec) {
+    const body = spec.destruction;
+    const partGroups = new Set(Object.values(parts));
+    if (body) {
+      for (const child of group.children) {
+        if (!partGroups.has(child) && child.isMesh) child.userData.destructionMaterial = body.material;
+      }
+    }
+    const done = /* @__PURE__ */ new Set();
+    for (const ps of spec.parts ?? []) {
+      const g = parts[ps.id];
+      const d = ps.destruction;
+      if (!g || !d || done.has(g)) continue;
+      done.add(g);
+      for (const o of [g, ...g.children]) {
+        if (o !== g && !o.isMesh) continue;
+        o.userData.destructionMaterial = d.material;
+        o.userData.destructionPart = ps.id;
+        if (d.piece) o.userData.destructionPiece = d.piece;
+        if (d.joint) o.userData.destructionJoint = d.joint;
+      }
+    }
+  }
+  function stripUndefined(o) {
+    const out = {};
+    if (o) {
+      for (const k of Object.keys(o)) if (o[k] !== void 0) out[k] = o[k];
+    }
+    return out;
+  }
+
+  // src/mirrors.ts
+  function createMirrors(THREE, options = {}) {
+    const max = Math.max(0, Math.floor(options.max ?? 1));
+    const resolution = options.resolution ?? 512;
+    const offset = options.offset ?? 1e-3;
+    const envMaterial = new THREE.MeshStandardMaterial({ color: 14673642, metalness: 1, roughness: 0.04, envMap: options.envMap ?? null });
+    const entries = /* @__PURE__ */ new Map();
+    const slots = [];
+    const geometry = new THREE.PlaneGeometry(1, 1);
+    const worldNormal = (e, out) => {
+      if (e.normal) return out.set(e.normal[0], e.normal[1], e.normal[2]).normalize();
+      e.mesh.updateWorldMatrix(true, false);
+      return out.set(0, 0, 1).transformDirection(e.mesh.matrixWorld);
+    };
+    const slotFor = (id) => {
+      if (!options.Reflector) return null;
+      const existing = slots.find((s2) => s2.id === id);
+      if (existing) return existing;
+      const free = slots.find((s2) => s2.id === null);
+      if (free) return free;
+      if (slots.length >= max) return null;
+      const reflector = new options.Reflector(geometry, { textureWidth: resolution, textureHeight: resolution, clipBias: 3e-3 });
+      reflector.name = "mirror:reflector";
+      if (options.keepInfo !== false) {
+        const original = reflector.onBeforeRender;
+        reflector.onBeforeRender = function(renderer, scene, camera, geo, mat, grp) {
+          const info = renderer.info;
+          if (!info.autoReset) return original.call(this, renderer, scene, camera, geo, mat, grp);
+          const before = { calls: info.render.calls, triangles: info.render.triangles, points: info.render.points, lines: info.render.lines };
+          original.call(this, renderer, scene, camera, geo, mat, grp);
+          info.render.calls += before.calls;
+          info.render.triangles += before.triangles;
+          info.render.points += before.points;
+          info.render.lines += before.lines;
+        };
+      }
+      reflector.visible = false;
+      const s = { reflector, id: null };
+      slots.push(s);
+      return s;
+    };
+    const release = (s) => {
+      s.id = null;
+      s.reflector.visible = false;
+    };
+    const pos = new THREE.Vector3();
+    const quat = new THREE.Quaternion();
+    const scl = new THREE.Vector3();
+    const n = new THREE.Vector3();
+    const toEye = new THREE.Vector3();
+    const box = new THREE.Box3();
+    const size = new THREE.Vector3();
+    const facing = new THREE.Vector3();
+    const flip = new THREE.Quaternion(0, 1, 0, 0);
+    return {
+      envMaterial,
+      register(id, mesh, normal) {
+        const previous = entries.get(id);
+        entries.set(id, { mesh, normal: normal ?? null, original: previous ? previous.original : mesh.material });
+        mesh.material = envMaterial;
+      },
+      unregister(id) {
+        const e = entries.get(id);
+        const s = slots.find((x) => x.id === id);
+        if (s) release(s);
+        if (e) e.mesh.material = e.original;
+        entries.delete(id);
+      },
+      update(camera, candidates) {
+        const eye = camera.getWorldPosition(toEye);
+        const wanted = [];
+        for (const c of candidates) {
+          const e = entries.get(c.id);
+          if (!e) continue;
+          n.set(c.normal[0], c.normal[1], c.normal[2]);
+          const dx = eye.x - c.center[0];
+          const dy = eye.y - c.center[1];
+          const dz = eye.z - c.center[2];
+          if (n.x * dx + n.y * dy + n.z * dz <= 0) continue;
+          wanted.push({ id: c.id, d: dx * dx + dy * dy + dz * dz });
+        }
+        wanted.sort((a, b) => a.d - b.d);
+        const chosen = /* @__PURE__ */ new Set();
+        for (let i = 0; i < wanted.length && chosen.size < max; i++) chosen.add(wanted[i].id);
+        for (const s of slots) if (s.id !== null && !chosen.has(s.id)) release(s);
+        for (const id of chosen) {
+          const s = slotFor(id);
+          if (!s) continue;
+          const e = entries.get(id);
+          e.mesh.updateWorldMatrix(true, false);
+          e.mesh.matrixWorld.decompose(pos, quat, scl);
+          if (!e.mesh.geometry.boundingBox) e.mesh.geometry.computeBoundingBox();
+          box.copy(e.mesh.geometry.boundingBox);
+          box.getSize(size);
+          worldNormal(e, n);
+          s.reflector.position.copy(pos).addScaledVector(n, offset);
+          s.reflector.quaternion.copy(quat);
+          if (facing.set(0, 0, 1).applyQuaternion(quat).dot(n) < 0) s.reflector.quaternion.multiply(flip);
+          s.reflector.scale.set(Math.max(size.x * scl.x, 1e-3), Math.max(size.y * scl.y, 1e-3), 1);
+          s.id = id;
+          s.reflector.visible = true;
+          if (!s.reflector.parent) {
+            let top = e.mesh;
+            while (top.parent) top = top.parent;
+            (options.scene ?? top).add(s.reflector);
+          }
+        }
+        return slots.filter((s) => s.id !== null).map((s) => s.id);
+      },
+      active() {
+        return slots.filter((s) => s.id !== null).map((s) => s.id);
+      },
+      dispose() {
+        for (const s of slots) s.reflector.removeFromParent();
+        slots.length = 0;
+        for (const e of entries.values()) e.mesh.material = e.original;
+        entries.clear();
+        envMaterial.dispose();
+        geometry.dispose();
+      }
+    };
+  }
+
+  // src/screen.ts
+  var BARS = ["#c0c0c0", "#c0c000", "#00c0c0", "#00c000", "#c000c0", "#c00000", "#0000c0"];
+  function mulberry2(seed) {
+    let a = seed >>> 0;
+    return () => {
+      a = a + 1831565813 >>> 0;
+      let t = a;
+      t = Math.imul(t ^ t >>> 15, t | 1);
+      t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+      return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+  }
+  function createScreen(THREE, options) {
+    const w = options.w ?? 128;
+    const h = options.h ?? 72;
+    const canvas = options.document.createElement("canvas");
+    canvas.width = w;
+    canvas.height = h;
+    const ctx = canvas.getContext("2d", { willReadFrequently: true });
+    const rand = mulberry2(options.seed ?? 1);
+    const period = 1 / Math.max(1, options.fps ?? 15);
+    const intensity = options.intensity ?? 1;
+    const texture = new THREE.CanvasTexture(canvas);
+    texture.colorSpace = THREE.SRGBColorSpace;
+    const material = new THREE.MeshStandardMaterial({
+      color: 328965,
+      roughness: 0.25,
+      metalness: 0,
+      map: texture,
+      emissive: 16777215,
+      emissiveMap: texture,
+      emissiveIntensity: 0
+    });
+    let on = false;
+    let channel = 0;
+    let clock = 0;
+    let acc = 0;
+    const fill = (style, x, y, rw, rh) => {
+      if (!ctx) return;
+      ctx.fillStyle = style;
+      ctx.fillRect(x, y, rw, rh);
+    };
+    const drawBars = () => {
+      const n = BARS.length;
+      for (let i = 0; i < n; i++) fill(BARS[(i + channel) % n], Math.floor(i * w / n), 0, Math.ceil(w / n), Math.floor(h * 0.75));
+      fill("#101010", 0, Math.floor(h * 0.75), w, h - Math.floor(h * 0.75));
+      const x = clock * 20 % (w + 12) - 12;
+      fill("#ffffff", x, Math.floor(h * 0.8), 12, Math.floor(h * 0.1));
+    };
+    const drawNoise = () => {
+      const cell = Math.max(2, Math.floor(w / 48));
+      for (let y = 0; y < h; y += cell) {
+        for (let x = 0; x < w; x += cell) {
+          const g = Math.floor(rand() * 220 + 20);
+          fill(`rgb(${g},${g},${g})`, x, y, cell, cell);
+        }
+      }
+    };
+    const drawScene = () => {
+      const hue = channel * 40 % 360;
+      fill(`hsl(${(200 + hue) % 360},60%,${55 + 10 * Math.sin(clock * 0.3)}%)`, 0, 0, w, Math.floor(h * 0.65));
+      fill(`hsl(${(110 + hue) % 360},40%,32%)`, 0, Math.floor(h * 0.65), w, h - Math.floor(h * 0.65));
+      const sx = (0.5 + 0.4 * Math.sin(clock * 0.5)) * w;
+      const sy = (0.3 - 0.15 * Math.cos(clock * 0.5)) * h;
+      fill("#ffe680", sx - 5, sy - 5, 10, 10);
+      const bx = clock * 25 % (w + 16) - 16;
+      fill("#e03030", bx, Math.floor(h * 0.7), 16, 10);
+    };
+    const draw = () => {
+      if (!on) {
+        fill("#000000", 0, 0, w, h);
+      } else if (channel % 3 === 0) {
+        drawBars();
+      } else if (channel % 3 === 1) {
+        drawNoise();
+      } else {
+        drawScene();
+      }
+      texture.needsUpdate = true;
+    };
+    const apply = () => {
+      material.emissiveIntensity = on ? intensity : 0;
+      material.color.setHex(on ? 1118481 : 0);
+      draw();
+    };
+    apply();
+    return {
+      material,
+      texture,
+      canvas,
+      get on() {
+        return on;
+      },
+      get channel() {
+        return channel;
+      },
+      setOn(value) {
+        on = !!value;
+        acc = 0;
+        apply();
+      },
+      setChannel(n) {
+        channel = Math.max(0, Math.floor(n));
+        if (on) draw();
+      },
+      update(dt) {
+        if (!on) return;
+        clock += dt;
+        acc += dt;
+        if (acc >= period) {
+          acc %= period;
+          draw();
+        }
+      },
+      dispose() {
+        texture.dispose();
+        material.dispose();
+      }
+    };
+  }
+
+  // src/sway.ts
+  var VERTEX_PATCH = (
+    /* glsl */
+    `
+#include <begin_vertex>
+{
+  float swayHang = max(swayAnchorY - position.y, 0.0);
+  float swayFlutter = swayAmplitude * sin(swayTime * 1.9 + position.x * 4.0 + position.z * 3.0 + swayHang * 3.0);
+  transformed.x += swayHang * (sin(swayAz) + swayFlutter);
+  transformed.z += swayHang * (-sin(swayAx) + swayFlutter * 0.6);
+  transformed.y += swayHang * (1.0 - cos(swayAz) * cos(swayAx));
+}
+`
+  );
+  var VERTEX_UNIFORMS = (
+    /* glsl */
+    `
+uniform float swayTime;
+uniform float swayAx;
+uniform float swayAz;
+uniform float swayAnchorY;
+uniform float swayAmplitude;
+`
+  );
+  function patchSwayShader(shader, uniforms, amplitude) {
+    shader.uniforms.swayTime = uniforms.time;
+    shader.uniforms.swayAx = uniforms.ax;
+    shader.uniforms.swayAz = uniforms.az;
+    shader.uniforms.swayAnchorY = uniforms.anchorY;
+    shader.uniforms.swayAmplitude = { value: amplitude };
+    shader.vertexShader = VERTEX_UNIFORMS + shader.vertexShader.replace("#include <begin_vertex>", VERTEX_PATCH);
+  }
+  function patch(material, uniforms, amplitude) {
+    const previous = material.onBeforeCompile;
+    material.onBeforeCompile = (shader, renderer) => {
+      previous?.call(material, shader, renderer);
+      patchSwayShader(shader, uniforms, amplitude);
+    };
+    material.customProgramCacheKey = () => `sway:${amplitude}`;
+    return material;
+  }
+  function swayMaterial(THREE, base, options = {}) {
+    const amplitude = options.amplitude ?? 0.04;
+    const uniforms = { time: { value: 0 }, ax: { value: 0 }, az: { value: 0 }, anchorY: { value: options.anchorY ?? 0 } };
+    const handle = {
+      uniforms,
+      set(ax, az, time) {
+        uniforms.ax.value = ax;
+        uniforms.az.value = az;
+        if (time !== void 0) uniforms.time.value = time;
+      }
+    };
+    const material = patch(base.clone(), uniforms, amplitude);
+    const depth = patch(new THREE.MeshDepthMaterial({ depthPacking: THREE.RGBADepthPacking }), uniforms, amplitude);
+    const distance = patch(new THREE.MeshDistanceMaterial(), uniforms, amplitude);
+    material.userData.sway = handle;
+    material.userData.depthMaterial = depth;
+    material.userData.distanceMaterial = distance;
+    return material;
+  }
+  function attachSway(THREE, mesh, options = {}) {
+    let anchorY = options.anchorY;
+    if (anchorY === void 0) {
+      if (!mesh.geometry.boundingBox) mesh.geometry.computeBoundingBox();
+      anchorY = mesh.geometry.boundingBox ? mesh.geometry.boundingBox.max.y : 0;
+    }
+    const base = Array.isArray(mesh.material) ? mesh.material[0] : mesh.material;
+    const m = swayMaterial(THREE, base, { ...options, anchorY });
+    m.userData.sway.uniforms.anchorY.value = anchorY;
+    mesh.material = m;
+    mesh.customDepthMaterial = m.userData.depthMaterial;
+    mesh.customDistanceMaterial = m.userData.distanceMaterial;
+    mesh.userData.sway = m.userData.sway;
+    return m.userData.sway;
+  }
+
+  // src/adapter.ts
+  function createThreeAdapter(THREE, options = {}) {
+    return {
+      THREE,
+      createMeshApi: (o = {}) => createMeshApi(THREE, { quality: options.quality, materials: options.materials, ...o }),
+      applyPose: (group, motion, t) => applyPose(THREE, group, motion, t),
+      syncObject: (world, objectId, parts, o) => syncObject(THREE, world, objectId, parts, o),
+      swayMaterial: (base, o) => swayMaterial(THREE, base, o),
+      attachSway: (mesh, o) => attachSway(THREE, mesh, o),
+      createEffects: ((a, o = {}) => a.isObject3D ? createEffects(THREE, a, { document: options.document, ...o }) : createEffects(THREE, { document: options.document, ...a })),
+      createScreen: (o = {}) => {
+        const document = o.document ?? options.document;
+        if (!document) throw new Error("createScreen needs a document (option of createThreeAdapter or of the call)");
+        return createScreen(THREE, { ...o, document });
+      },
+      createMirrors: (o = {}) => createMirrors(THREE, { Reflector: options.Reflector, envMap: options.envMap, ...o }),
+      createCord: (points, radius, material) => createCord(THREE, points, radius, material),
+      catenary
+    };
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map