@oeave/bakery3 0.0.0-stage → 0.2.0

package/dist/shapes/index.js

@@ -0,0 +1,836 @@
+import { registerBuiltin } from '../chunk-S4AJTLLN.js';
+import * as THREE from 'three';
+import { SimplexNoise } from 'three/addons/math/SimplexNoise.js';
+import { mergeVertices } from 'three/addons/utils/BufferGeometryUtils.js';
+import { PMREMGenerator, MeshStandardNodeMaterial } from 'three/webgpu';
+import { positionWorld, positionLocal, float, sin, atan, mix, color, smoothstep, fract, oneMinus, min, normalize, asin, max, pow, vec3, mx_worley_noise_float, dot, saturate, mx_fractal_noise_float, abs, normalView, positionViewDirection, cos } from 'three/tsl';
+
+registerBuiltin(
+  { uuid: positionWorld.uuid },
+  { op: "position", params: () => ({ space: "world" }) }
+);
+var SHAPE_KINDS = [
+  "sphere",
+  "blob",
+  "pebble",
+  "torus",
+  "ring",
+  "knot",
+  "capsule",
+  "box"
+];
+var SHAPE_FINISHES = [
+  "glow",
+  "glass",
+  "matte",
+  "satin",
+  "metal",
+  "rim",
+  "nebula",
+  "beacon",
+  "iris",
+  "scan",
+  "magma",
+  "holo",
+  "aurora",
+  "topo",
+  "spiral"
+];
+var MOTION_KINDS = [
+  "spin",
+  "tumble",
+  "pulse",
+  "bob",
+  "orbit",
+  "drift",
+  "glow",
+  "tint",
+  "frost"
+];
+var DEFAULT_STRENGTH = {
+  glow: 5,
+  rim: 4,
+  nebula: 3,
+  beacon: 5,
+  scan: 6,
+  magma: 6,
+  holo: 6,
+  aurora: 2,
+  topo: 6,
+  glass: 0,
+  matte: 0,
+  satin: 0,
+  metal: 0,
+  iris: 0,
+  spiral: 0
+};
+var DEFAULT_NOISE = {
+  sphere: 0,
+  blob: 0.5,
+  pebble: 0.25,
+  torus: 0,
+  ring: 0,
+  knot: 0,
+  capsule: 0,
+  box: 0
+};
+var ROUGHNESS = {
+  glow: 0.55,
+  glass: 0.03,
+  matte: 0.85,
+  satin: 0.4,
+  metal: 0.22,
+  rim: 0.6,
+  nebula: 0.6,
+  beacon: 0.45,
+  iris: 0.16,
+  scan: 0.5,
+  magma: 0.8,
+  holo: 0.5,
+  aurora: 0.6,
+  topo: 0.5,
+  spiral: 0.35
+};
+var GRAPH_FINISHES = /* @__PURE__ */ new Set([
+  "rim",
+  "nebula",
+  "beacon",
+  "iris",
+  "scan",
+  "magma",
+  "holo",
+  "aurora",
+  "topo",
+  "spiral"
+]);
+var EMISSION_COVERAGE = {
+  scan: 0.22,
+  magma: 0.07,
+  holo: 0.2,
+  aurora: 0.5,
+  topo: 0.16
+};
+function motionSuits(kind, finish) {
+  if (kind === "glow") return finish === "glow";
+  if (kind === "frost")
+    return finish === "glass" || finish === "metal" || finish === "satin";
+  if (kind === "tint") return !GRAPH_FINISHES.has(finish);
+  return true;
+}
+var GLOW_LIGHT = Math.PI / 4;
+function mulberry32(seed) {
+  let a = Math.floor(seed) >>> 0 || 2654435769;
+  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 hashString(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function primitive(kind, noisy) {
+  switch (kind) {
+    case "sphere":
+      return mergeVertices(new THREE.IcosahedronGeometry(0.5, noisy ? 5 : 4));
+    case "blob":
+      return mergeVertices(new THREE.IcosahedronGeometry(0.5, 5));
+    case "pebble": {
+      const g = mergeVertices(new THREE.IcosahedronGeometry(0.5, 5));
+      g.scale(1, 0.62, 0.85);
+      return g;
+    }
+    case "torus":
+      return mergeVertices(new THREE.TorusGeometry(0.36, 0.14, 48, 112));
+    case "ring":
+      return mergeVertices(new THREE.TorusGeometry(0.45, 0.05, 24, 160));
+    case "knot":
+      return mergeVertices(new THREE.TorusKnotGeometry(0.3, 0.1, 256, 32));
+    case "capsule":
+      return mergeVertices(new THREE.CapsuleGeometry(0.22, 0.56, 16, 40));
+    case "box":
+      return noisy ? mergeVertices(new THREE.BoxGeometry(1, 1, 1, 18, 18, 18)) : new THREE.BoxGeometry(1, 1, 1, 18, 18, 18);
+  }
+}
+function displace(geometry, amount, size, seed) {
+  geometry.computeVertexNormals();
+  const random = mulberry32(seed);
+  const simplex = new SimplexNoise({ random });
+  const offset = new THREE.Vector3(
+    random() * 100,
+    random() * 100,
+    random() * 100
+  );
+  const frequency = 1.9 / size;
+  const amplitude = amount * 0.2 * size;
+  const positions = geometry.attributes.position;
+  const normals = geometry.attributes.normal;
+  const p = new THREE.Vector3();
+  const n = new THREE.Vector3();
+  const fbm = (x, y, z) => (simplex.noise3d(x, y, z) + 0.5 * simplex.noise3d(x * 2.1, y * 2.1, z * 2.1) + 0.25 * simplex.noise3d(x * 4.3, y * 4.3, z * 4.3)) / 1.75;
+  for (let i = 0; i < positions.count; i++) {
+    p.fromBufferAttribute(positions, i);
+    n.fromBufferAttribute(normals, i);
+    const v = fbm(
+      p.x * frequency + offset.x,
+      p.y * frequency + offset.y,
+      p.z * frequency + offset.z
+    );
+    p.addScaledVector(n, v * amplitude);
+    positions.setXYZ(i, p.x, p.y, p.z);
+  }
+  positions.needsUpdate = true;
+  geometry.computeVertexNormals();
+}
+function shapeGeometry(shape, compositionSeed) {
+  const noise = shape.noise ?? DEFAULT_NOISE[shape.kind];
+  const geometry = primitive(shape.kind, noise > 0);
+  geometry.computeBoundingBox();
+  const extent = geometry.boundingBox.getSize(new THREE.Vector3());
+  const longest = Math.max(extent.x, extent.y, extent.z) || 1;
+  geometry.scale(
+    shape.size / longest,
+    shape.size / longest,
+    shape.size / longest
+  );
+  if (noise > 0)
+    displace(
+      geometry,
+      noise,
+      shape.size,
+      (compositionSeed ^ hashString(shape.id)) >>> 0
+    );
+  geometry.computeBoundingSphere();
+  return geometry;
+}
+function rimMaterial(c, strength) {
+  const material = new MeshStandardNodeMaterial();
+  material.name = "bakery3-shape-rim";
+  material.roughness = ROUGHNESS.rim;
+  material.metalness = 0;
+  material.emissive.set(0);
+  material.emissiveIntensity = 1;
+  const facing = saturate(abs(dot(normalView, positionViewDirection)));
+  const rim = pow(oneMinus(facing), 2.5);
+  material.colorNode = color(c.clone().multiplyScalar(0.06));
+  material.emissiveNode = color(c).mul(rim).mul(float(strength));
+  return material;
+}
+function nebulaMaterial(c, strength, size, seed) {
+  const material = new MeshStandardNodeMaterial();
+  material.name = "bakery3-shape-nebula";
+  material.roughness = ROUGHNESS.nebula;
+  material.metalness = 0;
+  material.emissive.set(0);
+  material.emissiveIntensity = 1;
+  const random = mulberry32(seed);
+  const offset = vec3(random() * 40, random() * 40, random() * 40);
+  const n = mx_fractal_noise_float(
+    positionLocal.mul(float(3.2 / size)).add(offset),
+    3,
+    2,
+    0.5
+  );
+  const mask = smoothstep(-0.05, 0.55, n);
+  material.colorNode = color(c.clone().multiplyScalar(0.08));
+  material.emissiveNode = mix(
+    color(c.clone().multiplyScalar(0.12)),
+    color(c),
+    mask
+  ).mul(float(strength));
+  return material;
+}
+var BEACON = { points: 7, inner: 7, outer: 13 };
+var BEACON_COVERAGE = BEACON.points * (1 - Math.cos(THREE.MathUtils.degToRad((BEACON.inner + BEACON.outer) / 2))) / 2;
+function beaconPoints(seed) {
+  const random = mulberry32(seed);
+  const turn = new THREE.Euler(
+    random() * Math.PI * 2,
+    random() * Math.PI * 2,
+    random() * Math.PI * 2
+  );
+  const golden = Math.PI * (3 - Math.sqrt(5));
+  const v = new THREE.Vector3();
+  return Array.from({ length: BEACON.points }, (_, i) => {
+    const y = 1 - 2 * (i + 0.5) / BEACON.points;
+    const r = Math.sqrt(1 - y * y);
+    v.set(Math.cos(golden * i) * r, y, Math.sin(golden * i) * r).applyEuler(
+      turn
+    );
+    return [v.x, v.y, v.z];
+  });
+}
+function beaconMaterial(c, strength, seed) {
+  const material = new MeshStandardNodeMaterial();
+  material.name = "bakery3-shape-beacon";
+  material.roughness = ROUGHNESS.beacon;
+  material.metalness = 0;
+  material.emissive.set(0);
+  material.emissiveIntensity = 1;
+  const direction = normalize(positionLocal);
+  const dark = Math.cos(THREE.MathUtils.degToRad(BEACON.outer));
+  const lit = Math.cos(THREE.MathUtils.degToRad(BEACON.inner));
+  let mask = float(0);
+  for (const p of beaconPoints(seed))
+    mask = mask.add(
+      smoothstep(dark, lit, dot(direction, vec3(p[0], p[1], p[2])))
+    );
+  material.colorNode = color(c.clone().multiplyScalar(0.04));
+  material.emissiveNode = color(c).mul(saturate(mask)).mul(float(strength / BEACON_COVERAGE));
+  return material;
+}
+function graphMaterial(finish) {
+  const material = new MeshStandardNodeMaterial();
+  material.name = `bakery3-shape-${finish}`;
+  material.roughness = ROUGHNESS[finish];
+  material.metalness = 0;
+  material.emissive.set(0);
+  material.emissiveIntensity = 1;
+  return material;
+}
+var facingEye = () => saturate(abs(dot(normalView, positionViewDirection)));
+var COMPANION_HUE = 0.72;
+function companion(c) {
+  const hsl = c.getHSL({ h: 0, s: 0, l: 0 });
+  const away = (COMPANION_HUE - hsl.h + 1.5) % 1 - 0.5;
+  const turn = Math.abs(away) < 0.06 ? -0.17 : Math.sign(away) * Math.min(Math.abs(away), 0.2);
+  return c.clone().offsetHSL(turn, 0, 0);
+}
+var IRIS = { turns: 1.15, along: 0.35 };
+function irisMaterial(c, size, seed) {
+  const material = graphMaterial("iris");
+  material.metalness = 1;
+  const random = mulberry32(seed);
+  const phase = facingEye().mul(IRIS.turns).add(positionLocal.y.mul(IRIS.along / size)).add(random());
+  const channel = (offset) => cos(phase.add(offset).mul(TAU)).mul(0.5).add(0.5);
+  const film = vec3(channel(0), channel(1 / 3), channel(2 / 3));
+  material.colorNode = mix(color(c), film, 0.72);
+  material.emissiveNode = film.mul(pow(oneMinus(facingEye()), 2)).mul(0.3);
+  return material;
+}
+var SCAN = { lines: 5, width: 0.17 };
+function scanMaterial(c, strength, size) {
+  const material = graphMaterial("scan");
+  const f = fract(positionWorld.y.mul(SCAN.lines / size));
+  const w = SCAN.width;
+  const band = smoothstep(0.5 - w, 0.5 - w * 0.45, f).mul(
+    oneMinus(smoothstep(0.5 + w * 0.45, 0.5 + w, f))
+  );
+  material.colorNode = color(c.clone().multiplyScalar(0.05));
+  material.emissiveNode = color(c).mul(band).mul(float(strength));
+  return material;
+}
+var MAGMA = { cells: 5, from: 0.5, to: 0.7 };
+function magmaMaterial(c, strength, size, seed) {
+  const material = graphMaterial("magma");
+  const random = mulberry32(seed);
+  const offset = vec3(random() * 40, random() * 40, random() * 40);
+  const d = mx_worley_noise_float(
+    positionLocal.mul(float(MAGMA.cells / size)).add(offset),
+    float(1)
+  );
+  const seam = smoothstep(MAGMA.from, MAGMA.to, d);
+  material.colorNode = color(c.clone().multiplyScalar(0.03).addScalar(0.012));
+  material.emissiveNode = mix(color(c), color(16777215), pow(seam, 5).mul(0.25)).mul(seam).mul(float(strength));
+  return material;
+}
+var HOLO = { parallels: 9, meridians: 14, width: 0.07 };
+function holoMaterial(c, strength) {
+  const material = graphMaterial("holo");
+  const n = normalize(positionLocal);
+  const latitude = asin(n.y).mul(HOLO.parallels / Math.PI);
+  const longitude = atan(n.z, n.x).mul(HOLO.meridians / TAU);
+  const line = (cells) => {
+    const f = fract(cells);
+    return oneMinus(
+      smoothstep(HOLO.width * 0.45, HOLO.width, min(f, oneMinus(f)))
+    );
+  };
+  const grid = max(line(latitude), line(longitude));
+  const edge = pow(oneMinus(facingEye()), 3).mul(0.45);
+  material.colorNode = color(c.clone().multiplyScalar(0.03));
+  material.emissiveNode = color(c).mul(grid.add(edge)).mul(float(strength));
+  return material;
+}
+function auroraMaterial(c, strength, size, seed) {
+  const material = graphMaterial("aurora");
+  const random = mulberry32(seed);
+  const [a, b, d] = [random() * TAU, random() * TAU, random() * TAU];
+  const p = positionLocal.mul(float(1 / size));
+  const fold = sin(p.x.mul(7.3).add(a)).mul(sin(p.z.mul(6.1).add(b)));
+  const veil = smoothstep(
+    0.2,
+    0.9,
+    sin(p.y.mul(17).add(fold.mul(2.6)).add(d)).mul(0.5).add(0.5)
+  );
+  const trade = sin(p.y.mul(4.1).add(fold).add(a)).mul(0.5).add(0.5);
+  material.colorNode = color(c.clone().multiplyScalar(0.05));
+  material.emissiveNode = mix(color(companion(c)), color(c), trade).mul(mix(float(0.06), float(1), veil)).mul(float(strength));
+  return material;
+}
+var TOPO = { lines: 11, wobble: 0.05, width: 0.09 };
+function topoMaterial(c, strength, size, seed) {
+  const material = graphMaterial("topo");
+  const random = mulberry32(seed);
+  const [a, b] = [random() * TAU, random() * TAU];
+  const p = positionLocal.mul(float(1 / size));
+  const height = p.y.add(
+    sin(p.x.mul(6.3).add(a)).mul(sin(p.z.mul(5.7).add(b))).mul(TOPO.wobble)
+  );
+  const f = fract(height.mul(TOPO.lines));
+  const line = oneMinus(
+    smoothstep(TOPO.width * 0.45, TOPO.width, min(f, oneMinus(f)))
+  );
+  material.colorNode = color(c.clone().multiplyScalar(0.05));
+  material.emissiveNode = color(c).mul(line).mul(float(strength));
+  return material;
+}
+var SPIRAL = { arms: 4, twist: 7 };
+function spiralMaterial(c, size, seed) {
+  const material = graphMaterial("spiral");
+  const random = mulberry32(seed);
+  const p = positionLocal.mul(float(1 / size));
+  const wind = sin(
+    atan(p.z, p.x).mul(SPIRAL.arms).add(p.y.mul(SPIRAL.twist)).add(random() * TAU)
+  );
+  material.colorNode = mix(
+    color(c),
+    color(15921909),
+    smoothstep(-0.08, 0.08, wind)
+  );
+  return material;
+}
+function materialFor(shape, c, strength, seed) {
+  switch (shape.finish) {
+    case "glow":
+      return new THREE.MeshStandardMaterial({
+        color: c.clone().multiplyScalar(0.1),
+        emissive: c,
+        emissiveIntensity: strength,
+        roughness: ROUGHNESS.glow,
+        metalness: 0
+      });
+    case "glass":
+      return new THREE.MeshPhysicalMaterial({
+        color: c,
+        transmission: 1,
+        ior: 1.5,
+        thickness: shape.size * 0.5,
+        attenuationColor: c,
+        attenuationDistance: shape.size,
+        roughness: ROUGHNESS.glass,
+        metalness: 0,
+        specularIntensity: 1
+      });
+    case "matte":
+      return new THREE.MeshStandardMaterial({
+        color: c,
+        roughness: ROUGHNESS.matte,
+        metalness: 0
+      });
+    case "satin":
+      return new THREE.MeshStandardMaterial({
+        color: c,
+        roughness: ROUGHNESS.satin,
+        metalness: 0
+      });
+    case "metal":
+      return new THREE.MeshStandardMaterial({
+        color: c,
+        roughness: ROUGHNESS.metal,
+        metalness: 1
+      });
+    case "rim":
+      return rimMaterial(c, strength);
+    case "nebula":
+      return nebulaMaterial(c, strength, shape.size, seed);
+    case "beacon":
+      return beaconMaterial(c, strength, seed);
+    case "iris":
+      return irisMaterial(c, shape.size, seed);
+    case "scan":
+      return scanMaterial(c, strength, shape.size);
+    case "magma":
+      return magmaMaterial(c, strength, shape.size, seed);
+    case "holo":
+      return holoMaterial(c, strength);
+    case "aurora":
+      return auroraMaterial(c, strength, shape.size, seed);
+    case "topo":
+      return topoMaterial(c, strength, shape.size, seed);
+    case "spiral":
+      return spiralMaterial(c, shape.size, seed);
+  }
+}
+function createComposition(spec, at = [0, 0, 0]) {
+  const seed = spec.seed ?? 1;
+  const group = new THREE.Group();
+  group.name = "bakery3-composition";
+  group.position.set(at[0], at[1], at[2]);
+  const shapes = [];
+  for (const shape of spec.shapes) {
+    const c = new THREE.Color(shape.color);
+    const strength = shape.strength ?? DEFAULT_STRENGTH[shape.finish];
+    const shapeSeed = (seed ^ hashString(shape.id)) >>> 0;
+    const mesh = new THREE.Mesh(
+      shapeGeometry(shape, seed),
+      materialFor(shape, c, strength, shapeSeed)
+    );
+    mesh.name = `shape-${shape.id}`;
+    mesh.position.set(shape.position[0], shape.position[1], shape.position[2]);
+    const rotation = [
+      THREE.MathUtils.degToRad(shape.rotation?.[0] ?? 0),
+      THREE.MathUtils.degToRad(shape.rotation?.[1] ?? 0),
+      THREE.MathUtils.degToRad(shape.rotation?.[2] ?? 0)
+    ];
+    mesh.rotation.set(rotation[0], rotation[1], rotation[2]);
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    group.add(mesh);
+    const built = {
+      spec: shape,
+      mesh,
+      base: {
+        position: [...shape.position],
+        rotation,
+        strength,
+        roughness: ROUGHNESS[shape.finish],
+        color: c.clone()
+      }
+    };
+    const worth = glowWorth(shape.finish, strength);
+    if (worth > 0) {
+      const light = new THREE.PointLight(
+        c,
+        worth * shape.size * shape.size * GLOW_LIGHT,
+        0,
+        2
+      );
+      light.name = `glow-${shape.id}`;
+      light.castShadow = false;
+      light.userData.bakery3 = { exclude: true };
+      mesh.add(light);
+      built.light = light;
+    }
+    shapes.push(built);
+  }
+  return { group, shapes };
+}
+function glowWorth(finish, strength) {
+  if (finish === "glow" || finish === "beacon") return strength;
+  return strength * (EMISSION_COVERAGE[finish] ?? 0);
+}
+function followGlow(built) {
+  for (const shape of built.shapes) {
+    if (!shape.light) continue;
+    const material = shape.mesh.material;
+    const size2 = shape.spec.size * shape.spec.size;
+    if (GRAPH_FINISHES.has(shape.spec.finish)) {
+      const level = shape.mesh.scale.x;
+      shape.light.intensity = glowWorth(shape.spec.finish, shape.base.strength) * size2 * GLOW_LIGHT * level;
+      if (shape.halo) shape.halo.material.opacity = haloGain(shape) * level;
+      continue;
+    }
+    shape.light.intensity = material.emissiveIntensity * material.opacity * size2 * GLOW_LIGHT;
+    shape.light.color.copy(material.emissive);
+    if (shape.halo) {
+      shape.halo.material.opacity = haloGain(shape) * material.emissiveIntensity * material.opacity / Math.max(shape.base.strength, 1e-6);
+      shape.halo.material.color.copy(material.emissive);
+    }
+  }
+}
+function haloGain(shape) {
+  return shape.halo?.userData.gain ?? 0;
+}
+var REFLECTIVE = /* @__PURE__ */ new Set([
+  "glass",
+  "metal",
+  "satin",
+  "matte",
+  "iris",
+  "spiral"
+]);
+var EMITTERS = /* @__PURE__ */ new Set([
+  "glow",
+  "rim",
+  "nebula",
+  "beacon",
+  "scan",
+  "magma",
+  "holo",
+  "aurora",
+  "topo"
+]);
+function emitterPoses(built) {
+  const world = new THREE.Vector3();
+  return built.shapes.filter((s) => EMITTERS.has(s.spec.finish)).map((s) => {
+    s.mesh.getWorldPosition(world);
+    const material = s.mesh.material;
+    return {
+      id: s.spec.id,
+      position: [world.x, world.y, world.z],
+      strength: (material.emissiveIntensity ?? 1) * material.opacity * s.mesh.scale.x
+    };
+  });
+}
+function emittersMoved(before, after) {
+  if (before.length !== after.length) return true;
+  for (let i = 0; i < before.length; i++) {
+    const a = before[i];
+    const b = after[i];
+    if (a.id !== b.id) return true;
+    const d = Math.hypot(
+      a.position[0] - b.position[0],
+      a.position[1] - b.position[1],
+      a.position[2] - b.position[2]
+    );
+    if (d > 0.01) return true;
+    if (Math.abs(a.strength - b.strength) > 0.05 * Math.max(Math.abs(a.strength), 1e-6))
+      return true;
+  }
+  return false;
+}
+var FOLLOW_INTERVAL_MS = 100;
+async function snapshotReflections(renderer, scene, built, center) {
+  const none = {
+    shapes: 0,
+    refresh: async () => {
+    },
+    follow: () => {
+    },
+    busy: false,
+    settle: async () => {
+    },
+    dispose: () => {
+    }
+  };
+  if (scene.environment) return none;
+  const targets = built.shapes.filter((s) => REFLECTIVE.has(s.spec.finish));
+  if (!targets.length) return none;
+  const position = new THREE.Vector3(center[0], center[1], center[2]);
+  let current;
+  let retired;
+  let last = [];
+  let lastAt = 0;
+  let busy;
+  let disposed = false;
+  const generator = new PMREMGenerator(renderer);
+  const take = async () => {
+    const hidden = targets.map((s) => [s.mesh, s.mesh.visible]);
+    for (const [mesh] of hidden) mesh.visible = false;
+    try {
+      last = emitterPoses(built);
+      lastAt = performance.now();
+      const target = await generator.fromSceneAsync(scene, 0.03, 0.1, 100, {
+        position,
+        ...current ? { renderTarget: current } : {}
+      });
+      if (disposed) {
+        if (target !== current) target.dispose();
+        return;
+      }
+      if (target !== current) {
+        for (const shape of targets) {
+          const material = shape.mesh.material;
+          material.envMap = target.texture;
+          material.envMapIntensity = 1;
+          material.needsUpdate = true;
+        }
+        retired?.dispose();
+        retired = current;
+        current = target;
+      }
+    } finally {
+      for (const [mesh, visible] of hidden) mesh.visible = visible;
+    }
+  };
+  const refresh = () => {
+    if (!busy) busy = take().finally(() => busy = void 0);
+    return busy;
+  };
+  await refresh();
+  return {
+    shapes: targets.length,
+    refresh,
+    follow() {
+      if (disposed || busy || performance.now() - lastAt < FOLLOW_INTERVAL_MS)
+        return;
+      if (emittersMoved(last, emitterPoses(built))) void refresh();
+    },
+    get busy() {
+      return busy !== void 0;
+    },
+    async settle() {
+      if (busy) await busy;
+      if (!disposed && emittersMoved(last, emitterPoses(built)))
+        await refresh();
+    },
+    dispose() {
+      disposed = true;
+      for (const shape of targets) {
+        const material = shape.mesh.material;
+        material.envMap = null;
+        material.needsUpdate = true;
+      }
+      current?.dispose();
+      retired?.dispose();
+      current = void 0;
+      retired = void 0;
+      generator.dispose();
+    }
+  };
+}
+var TAU = Math.PI * 2;
+var easeInOut = (u) => u < 0.5 ? 2 * u * u : 1 - Math.pow(-2 * u + 2, 2) / 2;
+var smoothstep01 = (x) => x <= 0 ? 0 : x >= 1 ? 1 : x * x * (3 - 2 * x);
+var LOOP_FADE_SECONDS = 1.5;
+function motionLoops(m) {
+  switch (m.kind) {
+    case "spin":
+    case "tumble":
+    case "orbit":
+      return Number.isInteger(m.turns ?? 1);
+    case "pulse":
+    case "glow":
+      return Number.isInteger(m.cycles ?? 2);
+    case "bob":
+      return Number.isInteger(m.cycles ?? 1);
+    case "drift":
+    case "tint":
+    case "frost":
+      return false;
+  }
+}
+function compositionLoop(spec, clip) {
+  const camera = clip.camera ?? {};
+  const cameraLoops = (camera.orbitY ?? 0) % 360 === 0 && !camera.orbitX && !camera.dolly;
+  const motionsLoop = spec.shapes.every(
+    (s) => (s.motion ?? []).every(
+      (m) => !motionSuits(m.kind, s.finish) || motionLoops(m)
+    )
+  );
+  if (cameraLoops && motionsLoop) return { fade: 0, start: 0 };
+  const frames = Math.max(1, Math.round(clip.seconds * clip.fps));
+  const fade = Math.min(LOOP_FADE_SECONDS, clip.seconds / 4);
+  return { fade, start: Math.min(frames - 1, Math.ceil(fade * clip.fps)) };
+}
+function loopPresence(time, duration, fade) {
+  if (fade <= 0) return 1;
+  return Math.min(
+    smoothstep01(time / fade),
+    smoothstep01((duration - time) / fade)
+  );
+}
+var fadesByScale = (finish) => GRAPH_FINISHES.has(finish);
+function poseAt(shape, u) {
+  const b = shape.base;
+  const pose = {
+    position: [...b.position],
+    rotation: [...b.rotation],
+    scale: 1,
+    strength: b.strength,
+    roughness: b.roughness,
+    color: b.color.clone(),
+    opacity: 1
+  };
+  for (const m of shape.spec.motion ?? []) {
+    if (!motionSuits(m.kind, shape.spec.finish)) continue;
+    switch (m.kind) {
+      case "spin": {
+        const axis = m.axis === "x" ? 0 : m.axis === "z" ? 2 : 1;
+        pose.rotation[axis] += (m.turns ?? 1) * TAU * u;
+        break;
+      }
+      case "tumble":
+        pose.rotation[0] += (m.turns ?? 1) * TAU * u;
+        pose.rotation[2] += (m.turns ?? 1) * TAU * u;
+        break;
+      case "pulse":
+        pose.scale *= 1 + (m.amount ?? 0.12) * Math.sin(TAU * (m.cycles ?? 2) * u);
+        break;
+      case "bob":
+        pose.position[1] += (m.amount ?? 0.12) * Math.sin(TAU * (m.cycles ?? 1) * u);
+        break;
+      case "orbit": {
+        const radius = m.radius ?? Math.hypot(b.position[0], b.position[2]);
+        const start = Math.atan2(b.position[2], b.position[0]);
+        const angle = start + (m.turns ?? 1) * TAU * u;
+        pose.position[0] = Math.cos(angle) * radius;
+        pose.position[2] = Math.sin(angle) * radius;
+        break;
+      }
+      case "drift": {
+        const e = easeInOut(u);
+        for (let i = 0; i < 3; i++)
+          pose.position[i] = b.position[i] + (m.to[i] - b.position[i]) * e;
+        break;
+      }
+      case "glow":
+        pose.strength = b.strength * (1 + (m.amount ?? 0.6) * Math.sin(TAU * (m.cycles ?? 2) * u));
+        break;
+      case "tint":
+        pose.color = b.color.clone().lerp(new THREE.Color(m.to), easeInOut(u));
+        break;
+      case "frost":
+        pose.roughness = b.roughness + ((m.to ?? 0.6) - b.roughness) * easeInOut(u);
+        break;
+    }
+  }
+  return pose;
+}
+function touched(shape, fades) {
+  const out = /* @__PURE__ */ new Set();
+  if (fades) out.add(fadesByScale(shape.spec.finish) ? "scale" : "opacity");
+  for (const m of shape.spec.motion ?? []) {
+    if (!motionSuits(m.kind, shape.spec.finish)) continue;
+    if (m.kind === "spin" || m.kind === "tumble") out.add("rotation");
+    else if (m.kind === "pulse") out.add("scale");
+    else if (m.kind === "bob" || m.kind === "orbit" || m.kind === "drift")
+      out.add("position");
+    else if (m.kind === "glow") out.add("emissiveIntensity");
+    else if (m.kind === "tint")
+      out.add(shape.spec.finish === "glow" ? "emissive" : "color");
+    else if (m.kind === "frost") out.add("roughness");
+  }
+  return out;
+}
+function animateComposition(tl, built, duration, fps, loop = { fade: 0, start: 0 }) {
+  const frames = Math.max(1, Math.round(duration * fps));
+  const fades = loop.fade > 0;
+  let tracks = 0;
+  for (const shape of built.shapes) {
+    const props = touched(shape, fades);
+    if (!props.size) continue;
+    const lanes = [...props].map((property) => ({
+      property,
+      track: tl.track(shape.mesh, property)
+    }));
+    const byScale = fadesByScale(shape.spec.finish);
+    for (let f = 0; f < frames; f++) {
+      const time = f / fps;
+      const pose = poseAt(shape, duration > 0 ? time / duration : 0);
+      if (fades) {
+        const presence = loopPresence(time, duration, loop.fade);
+        if (byScale) pose.scale *= Math.max(presence, 1e-3);
+        else pose.opacity = presence;
+      }
+      for (const { property, track } of lanes) {
+        const value = property === "position" ? pose.position : property === "rotation" ? pose.rotation : property === "scale" ? [pose.scale, pose.scale, pose.scale] : property === "emissiveIntensity" ? [pose.strength] : property === "roughness" ? [pose.roughness] : property === "opacity" ? [pose.opacity] : [pose.color.r, pose.color.g, pose.color.b];
+        track.keyframes.push({ time, value: [...value] });
+      }
+    }
+    tracks += lanes.length;
+  }
+  return tracks;
+}
+
+export { MOTION_KINDS, SHAPE_FINISHES, SHAPE_KINDS, animateComposition, compositionLoop, createComposition, followGlow, snapshotReflections };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map