@vincentt-xr/sdk 2.0.0-alpha.0 → 2.0.0-alpha.10

package/dist/particles.js

@@ -0,0 +1,999 @@
+var _t = Object.defineProperty;
+var Dt = (e, t, i) => t in e ? _t(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[t] = i;
+var u = (e, t, i) => Dt(e, typeof t != "symbol" ? t + "" : t, i);
+import { useThree as V } from "@react-three/fiber";
+import { forwardRef as Z, useMemo as Mt, useRef as W, useImperativeHandle as kt, useState as Lt, useEffect as q } from "react";
+import * as h from "three";
+import { p as Ot, e as _, j as Ft, t as J } from "./index-CKRN-xJp.js";
+import { u as Jt } from "./landmarks-DtCAFV_m.js";
+import { a as At } from "./useLandmarkPoseFit-Bmb3h6Mw.js";
+import { jsx as D } from "react/jsx-runtime";
+import { f as Nt } from "./selectors-BvJepq6H.js";
+import { u as Vt, F as jt } from "./index-vr2ichWQ.js";
+import { C as Bt, a as Gt } from "./CanonicalHeadFrame-DdUqF6Fv.js";
+const Ge = ["leftEye", "rightEye", "eyes"], Ut = [
+  263,
+  249,
+  390,
+  373,
+  374,
+  380,
+  381,
+  382,
+  362,
+  398,
+  384,
+  385,
+  386,
+  387,
+  388,
+  466
+], Ht = [
+  33,
+  7,
+  163,
+  144,
+  145,
+  153,
+  154,
+  155,
+  133,
+  173,
+  157,
+  158,
+  159,
+  160,
+  161,
+  246
+], at = (e) => {
+  const t = [0, 0, 0];
+  return e.forEach((i) => {
+    for (let r = 0; r < 3; r += 1) t[r] += Bt[i * 3 + r] / e.length;
+  }), t;
+}, Xt = 0.4, Yt = (() => {
+  const e = at(Ut), t = at(Ht);
+  return Object.freeze([
+    (e[0] - t[0]) / 2,
+    (e[1] + t[1]) / 2,
+    (e[2] + t[2]) / 2 + Xt
+  ]);
+})(), $t = (e, t) => {
+  const [i, r, s] = Yt;
+  return [Ot(t) * (e === "left" ? 1 : -1) * i, r, s];
+}, Kt = (e) => e === "eyes" ? ["left", "right"] : [e === "leftEye" ? "left" : "right"], Wt = ["point", "sphere", "box", "cone"], qt = ["glow", "streak"], Qt = ["additive", "normal"], tt = 4, Q = 65536, U = Object.freeze({
+  rate: 60,
+  lifetime: 1.5,
+  lifetimeJitter: 0.2,
+  shape: "cone",
+  radius: 0,
+  boxSize: Object.freeze([10, 10, 10]),
+  angle: 15,
+  surface: !1,
+  speed: 30,
+  speedJitter: 0.2,
+  gravity: 0,
+  wind: Object.freeze([0, 0, 0]),
+  drag: 0,
+  size: Object.freeze([1, 0.2]),
+  sizeJitter: 0.3,
+  color: "#ffffff",
+  opacity: Object.freeze([1, 0]),
+  sprite: "glow",
+  stretch: 0.05,
+  blending: "additive",
+  maxParticles: 0,
+  seed: 1
+}), Zt = {
+  rate: [0, 1e4],
+  lifetime: [0.02, 30],
+  lifetimeJitter: [0, 1],
+  radius: [0, 1e4],
+  boxSize: [0, 1e4],
+  angle: [0, 180],
+  speed: [0, 1e5],
+  speedJitter: [0, 1],
+  gravity: [-1e5, 1e5],
+  wind: [-1e5, 1e5],
+  drag: [0, 100],
+  size: [0, 1e4],
+  sizeJitter: [0, 1],
+  opacity: [0, 1],
+  stretch: [0, 1],
+  maxParticles: [0, Q],
+  seed: [-1e9, 1e9]
+}, j = (e, t, i, r) => typeof e == "number" && Number.isFinite(e) ? Math.min(i, Math.max(t, e)) : r, Y = (e, t, i) => typeof t == "string" && e.includes(t) ? t : i, ct = (e, [t, i], r) => {
+  const s = Array.isArray(e) ? e : [];
+  return [0, 1, 2].map((o) => j(s[o], t, i, r[o]));
+}, lt = (e, [t, i], r) => {
+  const s = typeof r == "number" ? [r, r] : r;
+  if (typeof e == "number") {
+    const n = j(e, t, i, s[0]);
+    return [n, n];
+  }
+  const o = Array.isArray(e) ? e : [];
+  return [j(o[0], t, i, s[0]), j(o[1], t, i, s[1])];
+}, R = new h.Color(), te = (e) => typeof e == "number" && Number.isFinite(e) ? (R.setHex(Math.max(0, Math.min(16777215, Math.round(e)))), [R.r, R.g, R.b]) : typeof e != "string" || e.trim() === "" ? null : (R.setRGB(-1, -1, -1), R.setStyle(e), R.r < 0 ? null : [R.r, R.g, R.b]), ee = (e, t) => {
+  const i = (s) => {
+    const n = (Array.isArray(s) ? s : [s]).slice(0, tt).map(te);
+    return n.length > 0 && n.every(Boolean) ? n : null;
+  }, r = i(e) ?? i(t) ?? [[1, 1, 1]];
+  return { colors: Float32Array.from(r.flat()), colorCount: r.length };
+}, ie = (e, t, i = 0) => {
+  if (i > 0) return Math.min(Q, Math.ceil(i));
+  const r = Math.max(0, e) * Math.max(0, t);
+  return Math.min(
+    Q,
+    Math.max(1, Math.ceil(r * 1.1 + Math.max(0, e) * 0.1) + 8)
+  );
+}, ht = (e = {}, t = U) => {
+  const i = Zt, r = (c) => j(e[c], i[c][0], i[c][1], t[c]), s = r("rate"), o = r("lifetime"), n = Math.round(r("maxParticles"));
+  return {
+    rate: s,
+    lifetime: o,
+    lifetimeJitter: r("lifetimeJitter"),
+    shape: Y(Wt, e.shape, t.shape),
+    radius: r("radius"),
+    boxSize: ct(e.boxSize, i.boxSize, t.boxSize),
+    angle: r("angle"),
+    surface: typeof e.surface == "boolean" ? e.surface : t.surface,
+    speed: r("speed"),
+    speedJitter: r("speedJitter"),
+    gravity: r("gravity"),
+    wind: ct(e.wind, i.wind, t.wind),
+    drag: r("drag"),
+    size: lt(e.size, i.size, t.size),
+    sizeJitter: r("sizeJitter"),
+    ...ee(e.color, t.color),
+    opacity: lt(e.opacity, i.opacity, t.opacity),
+    sprite: Y(qt, e.sprite, t.sprite),
+    stretch: r("stretch"),
+    blending: Y(Qt, e.blending, t.blending),
+    maxParticles: n,
+    seed: r("seed"),
+    capacity: ie(s, o, n)
+  };
+}, re = ["laser", "trail", "sparkles", "fire"], se = Object.freeze({
+  /**
+   * Laser beams: fast streaks in a narrow cone, a white-hot core cooling to
+   * red, additive. Made for the eyes (`target="eyes"`): beams straight out
+   * of the face.
+   */
+  laser: Object.freeze({
+    rate: 900,
+    lifetime: 0.3,
+    lifetimeJitter: 0.15,
+    shape: "cone",
+    radius: 0.08,
+    angle: 0.6,
+    speed: 260,
+    speedJitter: 0.05,
+    gravity: 0,
+    wind: [0, 0, 0],
+    drag: 0,
+    size: [0.5, 0.2],
+    sizeJitter: 0.2,
+    color: ["#ffffff", "#ff3b30", "#7a0000"],
+    opacity: [1, 0],
+    sprite: "streak",
+    stretch: 0.08,
+    blending: "additive"
+  }),
+  /**
+   * Trail: a soft ribbon that lingers where the emitter moved — slow glows
+   * born at the point, almost no spread, long life, fading out. Made for a
+   * moving hand or fingertip (`HandEffect look="trail"`).
+   */
+  trail: Object.freeze({
+    rate: 240,
+    lifetime: 0.9,
+    lifetimeJitter: 0.3,
+    shape: "sphere",
+    radius: 0.4,
+    speed: 2,
+    speedJitter: 0.5,
+    gravity: 0,
+    wind: [0, 0, 0],
+    drag: 2,
+    size: [1.6, 0.3],
+    sizeJitter: 0.3,
+    color: ["#ffffff", "#7dd3fc", "#1d4ed8"],
+    opacity: [0.9, 0],
+    sprite: "glow",
+    stretch: 0,
+    blending: "additive"
+  }),
+  /**
+   * Sparkles: small bright glints thrown out in every direction, a quick
+   * flash that drifts down. Made for fingertips.
+   */
+  sparkles: Object.freeze({
+    rate: 160,
+    lifetime: 0.7,
+    lifetimeJitter: 0.5,
+    shape: "sphere",
+    radius: 0.3,
+    speed: 18,
+    speedJitter: 0.6,
+    gravity: 25,
+    wind: [0, 0, 0],
+    drag: 1.5,
+    size: [0.7, 0.1],
+    sizeJitter: 0.6,
+    color: ["#ffffff", "#fde68a", "#f59e0b"],
+    opacity: [1, 0],
+    sprite: "glow",
+    stretch: 0,
+    blending: "additive"
+  }),
+  /**
+   * Fire: flames that rise from the point, white-yellow at the base through
+   * orange to a dark red tip, growing then shrinking. Rises along the
+   * emitter's +Z (`HandEffect` aims it at the world's up).
+   */
+  fire: Object.freeze({
+    rate: 220,
+    lifetime: 0.8,
+    lifetimeJitter: 0.35,
+    shape: "cone",
+    radius: 0.6,
+    angle: 14,
+    speed: 28,
+    speedJitter: 0.4,
+    gravity: -20,
+    wind: [0, 0, 0],
+    drag: 0.5,
+    size: [1.4, 2.6],
+    sizeJitter: 0.4,
+    color: ["#fff7ae", "#fb923c", "#dc2626", "#3b0a0a"],
+    opacity: [0.95, 0],
+    sprite: "glow",
+    stretch: 0,
+    blending: "additive"
+  })
+}), oe = (e) => typeof e == "string" && re.includes(e), xt = (e) => oe(e) ? { ...U, ...se[e] } : U, I = 12, B = Object.freeze({
+  position: 0,
+  birth: 3,
+  velocity: 4,
+  lifetime: 7,
+  sizeScale: 8,
+  unit: 9,
+  seed: 10
+}), ne = () => ({
+  position: [0, 0, 0],
+  velocity: [0, 0, 0],
+  birth: 0,
+  lifetime: 0,
+  sizeScale: 1,
+  unit: 1,
+  seed: 0
+});
+class ft {
+  constructor(t) {
+    u(this, "capacity");
+    /** `capacity × PARTICLE_RECORD_FLOATS` floats; a lifetime of 0 is an empty slot. */
+    u(this, "data");
+    u(this, "head", 0);
+    u(this, "dirtyFirst", 0);
+    u(this, "dirtyCount", 0);
+    this.capacity = Math.max(1, Math.floor(t)), this.data = new Float32Array(this.capacity * I);
+  }
+  /** The slot the next particle goes in (the oldest). */
+  get next() {
+    return this.head;
+  }
+  /** Writes a particle over the oldest slot; returns the slot. */
+  push(t) {
+    const i = this.head, r = i * I, s = this.data, o = B;
+    return s[r + o.position] = t.position[0], s[r + o.position + 1] = t.position[1], s[r + o.position + 2] = t.position[2], s[r + o.birth] = t.birth, s[r + o.velocity] = t.velocity[0], s[r + o.velocity + 1] = t.velocity[1], s[r + o.velocity + 2] = t.velocity[2], s[r + o.lifetime] = t.lifetime, s[r + o.sizeScale] = t.sizeScale, s[r + o.unit] = t.unit, s[r + o.seed] = t.seed, s[r + 11] = 0, this.dirtyCount === 0 && (this.dirtyFirst = i), this.dirtyCount = Math.min(this.capacity, this.dirtyCount + 1), this.head = (i + 1) % this.capacity, i;
+  }
+  /**
+   * The slots written since the last call, as at most two ranges (one when
+   * they do not wrap, the whole ring after a full lap), then forgets them.
+   */
+  takeDirty(t = []) {
+    t.length = 0;
+    const i = this.dirtyCount;
+    if (i === 0) return t;
+    if (i >= this.capacity)
+      t.push([0, this.capacity]);
+    else {
+      const r = this.dirtyFirst, s = r + i;
+      s <= this.capacity ? t.push([r, i]) : t.push([r, this.capacity - r], [0, s - this.capacity]);
+    }
+    return this.dirtyCount = 0, t;
+  }
+  /** Empties every slot (and marks them all for upload). */
+  clear() {
+    this.data.fill(0), this.head = 0, this.dirtyFirst = 0, this.dirtyCount = this.capacity;
+  }
+  /** Particles alive at `time` (s): born and not yet past their lifetime. */
+  aliveAt(t) {
+    const i = this.data;
+    let r = 0;
+    for (let s = 0; s < i.length; s += I) {
+      const o = t - i[s + B.birth];
+      o >= 0 && o < i[s + B.lifetime] && (r += 1);
+    }
+    return r;
+  }
+}
+const et = 0.01, ae = (e, t) => {
+  const i = e * t;
+  return i < et ? t * (1 - i / 2 + i * i / 6 - i * i * i / 24) : (1 - Math.exp(-i)) / e;
+}, ce = (e, t) => {
+  const i = e * t;
+  return i < et ? t * t * (0.5 - i / 6 + i * i / 24 - i * i * i / 120) : (t - (1 - Math.exp(-i)) / e) / e;
+}, Tt = (e, t = [0, 0, 0]) => (t[0] = e.wind[0], t[1] = e.wind[1] - e.gravity, t[2] = e.wind[2], t), pt = (e, t) => e[0] + (e[1] - e[0]) * t, le = (e, t, i = [0, 0, 0]) => {
+  const { colors: r, colorCount: s } = e, o = Math.min(1, Math.max(0, t)) * (s - 1), n = Math.min(s - 1, Math.floor(o)), c = Math.min(s - 1, n + 1), l = o - n;
+  for (let a = 0; a < 3; a += 1)
+    i[a] = r[n * 3 + a] + (r[c * 3 + a] - r[n * 3 + a]) * l;
+  return i;
+}, he = () => ({
+  alive: !1,
+  age: 0,
+  life: 0,
+  position: [0, 0, 0],
+  velocity: [0, 0, 0],
+  size: 0,
+  opacity: 0,
+  color: [0, 0, 0]
+}), ut = [0, 0, 0], Ue = (e, t, i, r, s = he()) => {
+  const o = t * I, n = B, c = e[o + n.lifetime], l = i - e[o + n.birth];
+  s.age = l, s.alive = c > 0 && l >= 0 && l < c;
+  const a = Math.min(Math.max(l, 0), Math.max(c, 0));
+  s.life = c > 0 ? a / c : 0;
+  const f = r.drag, m = ae(f, a), v = ce(f, a), d = Math.exp(-f * a), g = e[o + n.unit];
+  Tt(r, ut);
+  for (let S = 0; S < 3; S += 1) {
+    const E = ut[S] * g, M = e[o + n.velocity + S];
+    s.position[S] = e[o + n.position + S] + M * m + E * v, s.velocity[S] = M * d + E * m;
+  }
+  return s.size = pt(r.size, s.life) * e[o + n.sizeScale], s.opacity = pt(r.opacity, s.life), le(r, s.life, s.color), s;
+}, fe = (e) => Number.isInteger(e) ? `${e}.0` : `${e}`, pe = (
+  /* glsl */
+  `
+uniform float uTime;
+uniform float uDrag;
+uniform vec3 uAcceleration;
+uniform vec2 uSize;
+uniform vec2 uOpacity;
+uniform vec3 uColors[${tt}];
+uniform float uColorCount;
+
+const float PARTICLE_DRAG_SERIES_LIMIT = ${fe(et)};
+
+float particleDragDistance(float k, float t) {
+  float kt = k * t;
+  if (kt < PARTICLE_DRAG_SERIES_LIMIT) {
+    return t * (1.0 - kt / 2.0 + kt * kt / 6.0 - kt * kt * kt / 24.0);
+  }
+  return (1.0 - exp(-kt)) / k;
+}
+
+float particleDragAcceleration(float k, float t) {
+  float kt = k * t;
+  if (kt < PARTICLE_DRAG_SERIES_LIMIT) {
+    return t * t * (0.5 - kt / 6.0 + kt * kt / 24.0 - kt * kt * kt / 120.0);
+  }
+  return (t - (1.0 - exp(-kt)) / k) / k;
+}
+
+vec3 particleColorAt(float life) {
+  float last = max(uColorCount, 1.0) - 1.0;
+  float x = clamp(life, 0.0, 1.0) * last;
+  float i = min(floor(x), last);
+  float j = min(i + 1.0, last);
+  return mix(uColors[int(i)], uColors[int(j)], x - i);
+}
+
+struct ParticleState {
+  float alive;
+  float life;
+  vec3 position;
+  vec3 velocity;
+  float size;
+  float opacity;
+  vec3 color;
+};
+
+// start: position (world) and birth; motion: velocity (world) and lifetime;
+// extra: size scale, unit (world units per emitter unit), seed.
+ParticleState particleState(vec4 start, vec4 motion, vec4 extra, float time) {
+  ParticleState s;
+  float lifetime = motion.w;
+  float age = time - start.w;
+  s.alive = (lifetime > 0.0 && age >= 0.0 && age < lifetime) ? 1.0 : 0.0;
+  float t = clamp(age, 0.0, max(lifetime, 0.0));
+  s.life = lifetime > 0.0 ? t / lifetime : 0.0;
+  float D = particleDragDistance(uDrag, t);
+  float A = particleDragAcceleration(uDrag, t);
+  vec3 a = uAcceleration * extra.y;
+  s.position = start.xyz + motion.xyz * D + a * A;
+  s.velocity = motion.xyz * exp(-uDrag * t) + a * D;
+  s.size = mix(uSize.x, uSize.y, s.life) * extra.x;
+  s.opacity = mix(uOpacity.x, uOpacity.y, s.life);
+  s.color = particleColorAt(s.life);
+  return s;
+}
+`
+), ue = (
+  /* glsl */
+  `
+attribute vec4 aStart;
+attribute vec4 aMotion;
+attribute vec4 aExtra;
+uniform float uSprite;
+uniform float uStretch;
+varying vec2 vCorner;
+varying vec4 vColor;
+varying float vStreak;
+${pe}
+void main() {
+  ParticleState p = particleState(aStart, aMotion, aExtra, uTime);
+  vCorner = position.xy;
+  vColor = vec4(p.color, p.opacity);
+  vStreak = 0.0;
+  if (p.alive < 0.5 || p.size <= 0.0 || p.opacity <= 0.0) {
+    gl_Position = vec4(0.0, 0.0, 2.0, 1.0);
+    return;
+  }
+  float halfSize = 0.5 * p.size;
+  vec3 head = (viewMatrix * vec4(p.position, 1.0)).xyz;
+  vec3 point = head + vec3(position.xy * halfSize, 0.0);
+  if (uSprite > 0.5) {
+    // Never longer than the particle's own path: a newborn streak starts at the emitter.
+    float tailSeconds = min(uStretch, max(uTime - aStart.w, 0.0));
+    vec3 tail = (viewMatrix * vec4(p.position - p.velocity * tailSeconds, 1.0)).xyz;
+    vec3 axis = head - tail;
+    vec3 toPoint = isOrthographic ? vec3(0.0, 0.0, -1.0) : normalize(head);
+    vec3 side = cross(axis, toPoint);
+    float sideLength = length(side);
+    // Seen end-on (or not moving), a streak is a glow.
+    if (sideLength > 0.05 * p.size) {
+      point = mix(tail, head, position.y * 0.5 + 0.5) + side / sideLength * position.x * halfSize;
+      vStreak = 1.0;
+    }
+  }
+  gl_Position = projectionMatrix * vec4(point, 1.0);
+}
+`
+), me = (
+  /* glsl */
+  `
+varying vec2 vCorner;
+varying vec4 vColor;
+varying float vStreak;
+void main() {
+  float shape;
+  if (vStreak > 0.5) {
+    float across = exp(-5.0 * vCorner.x * vCorner.x);
+    float along = clamp(vCorner.y * 0.5 + 0.5, 0.0, 1.0);
+    shape = across * along * along * (1.0 - smoothstep(0.9, 1.0, along));
+  } else {
+    float r2 = dot(vCorner, vCorner);
+    shape = r2 < 1.0 ? (1.0 - r2) * (1.0 - r2) : 0.0;
+  }
+  float alpha = shape * vColor.a;
+  if (alpha < 0.002) discard;
+  gl_FragColor = vec4(vColor.rgb, alpha);
+  #include <colorspace_fragment>
+}
+`
+), de = 0.25, ye = () => ({ carry: 0 }), mt = (e, t, i, r = [], s = 1 / 0) => {
+  if (r.length = 0, !(t > 0) || !(i > 0)) return r;
+  const o = Math.min(de, i), n = e.carry + t * o, c = Math.floor(n), l = Math.max(0, c - Math.max(0, Math.floor(s)));
+  for (let a = l; a < c; a += 1) {
+    const f = (a + 1 - e.carry) / t;
+    r.push(Math.min(1, (i - o + f) / i));
+  }
+  return e.carry = n - c, r;
+}, dt = (e) => {
+  let t = Math.floor(e) >>> 0;
+  return () => {
+    t = t + 1831565813 >>> 0;
+    let i = t;
+    return i = Math.imul(i ^ i >>> 15, i | 1), i ^= i + Math.imul(i ^ i >>> 7, i | 61), ((i ^ i >>> 14) >>> 0) / 4294967296;
+  };
+}, bt = () => ({
+  position: [0, 0, 0],
+  direction: [0, 0, 1]
+}), Ct = Math.PI / 180, G = (e, t, i) => {
+  const r = Math.cos(Math.min(180, Math.max(0, e)) * Ct), s = 1 - t() * (1 - r), o = Math.sqrt(Math.max(0, 1 - s * s)), n = t() * 2 * Math.PI;
+  return i[0] = o * Math.cos(n), i[1] = o * Math.sin(n), i[2] = s, i;
+}, ge = (e, t) => G(180, e, t), ve = (e, t, i = bt()) => {
+  const r = i.position, s = i.direction;
+  switch (r[0] = 0, r[1] = 0, r[2] = 0, e.shape) {
+    case "sphere": {
+      ge(t, s);
+      const o = e.radius * (e.surface ? 1 : Math.cbrt(t()));
+      r[0] = s[0] * o, r[1] = s[1] * o, r[2] = s[2] * o;
+      break;
+    }
+    case "box": {
+      const [o, n, c] = e.boxSize;
+      if (r[0] = (t() - 0.5) * o, r[1] = (t() - 0.5) * n, r[2] = (t() - 0.5) * c, e.surface) {
+        const l = [n * c, o * c, o * n], a = l[0] + l[1] + l[2];
+        let f = t() * (a > 0 ? a : 3), m = 0;
+        if (a > 0)
+          for (; m < 2 && f >= l[m]; )
+            f -= l[m], m += 1;
+        else
+          m = Math.min(2, Math.floor(f));
+        r[m] = (t() < 0.5 ? -0.5 : 0.5) * e.boxSize[m];
+      }
+      G(e.angle, t, s);
+      break;
+    }
+    case "cone": {
+      const o = e.radius;
+      if (o > 0) {
+        const n = Math.sqrt(t()), c = t() * 2 * Math.PI, l = Math.cos(c), a = Math.sin(c);
+        r[0] = o * n * l, r[1] = o * n * a;
+        const f = Math.min(180, e.angle) * Ct * n;
+        s[0] = Math.sin(f) * l, s[1] = Math.sin(f) * a, s[2] = Math.cos(f);
+      } else
+        G(e.angle, t, s);
+      break;
+    }
+    default:
+      G(e.angle, t, s);
+  }
+  return i;
+}, yt = (e) => {
+  const t = e.elements, i = Math.hypot(t[0], t[1], t[2]), r = Math.hypot(t[4], t[5], t[6]), s = Math.hypot(t[8], t[9], t[10]);
+  return (i + r + s) / 3;
+}, $ = bt(), C = ne(), L = new h.Vector3(), x = new h.Vector3(), N = new h.Vector3(), gt = (e, t, i, r, s) => {
+  const o = yt(i.from), n = yt(i.to);
+  for (let c = 0; c < r.length; c += 1) {
+    const l = r[c];
+    ve(t, s, $);
+    const a = s(), f = s(), m = s(), v = s();
+    L.fromArray($.position), x.copy(L).applyMatrix4(i.from), N.copy(L).applyMatrix4(i.to), x.lerp(N, l), C.position[0] = x.x, C.position[1] = x.y, C.position[2] = x.z, L.fromArray($.direction), x.copy(L).transformDirection(i.from), N.copy(L).transformDirection(i.to), x.lerp(N, l), x.lengthSq() > 1e-12 ? x.normalize() : x.copy(N);
+    const d = o + (n - o) * l, g = t.speed * (1 - t.speedJitter * a) * d;
+    C.velocity[0] = x.x * g, C.velocity[1] = x.y * g, C.velocity[2] = x.z * g, C.birth = i.timeFrom + (i.timeTo - i.timeFrom) * l, C.lifetime = t.lifetime * (1 - t.lifetimeJitter * f), C.sizeScale = (1 - t.sizeJitter * m) * d, C.unit = d, C.seed = v, e.push(C);
+  }
+};
+class Se {
+  constructor(t) {
+    u(this, "ringValue");
+    u(this, "settingsValue");
+    u(this, "random");
+    u(this, "emission", ye());
+    u(this, "births", []);
+    u(this, "last", new h.Matrix4());
+    /** Per-slot last poses for `updateAt`. */
+    u(this, "lasts", []);
+    u(this, "slotBirths", []);
+    u(this, "lastTime", null);
+    u(this, "frame", {
+      from: new h.Matrix4(),
+      to: new h.Matrix4(),
+      timeFrom: 0,
+      timeTo: 0
+    });
+    this.settingsValue = t, this.ringValue = new ft(t.capacity), this.random = dt(t.seed);
+  }
+  get ring() {
+    return this.ringValue;
+  }
+  get settings() {
+    return this.settingsValue;
+  }
+  /**
+   * New settings. A new capacity starts a new (empty) ring and a new seed a
+   * new random sequence; anything else applies to the particles already out
+   * (the shader reads it every frame) and to the next ones.
+   */
+  setSettings(t) {
+    const i = this.settingsValue;
+    this.settingsValue = t, t.capacity !== i.capacity && (this.ringValue = new ft(t.capacity), this.ringValue.clear()), t.seed !== i.seed && (this.random = dt(t.seed));
+  }
+  /**
+   * One frame at `time` (s) with the emitter at `matrix` (world): emits the
+   * particles due since the last update along the emitter's path, unless
+   * `emitting` is false. The first update only records the pose. Returns how
+   * many were emitted.
+   */
+  update(t, i, r = !0) {
+    const s = this.lastTime;
+    if (this.lastTime = i, s === null || !r || !(i > s))
+      return this.last.copy(t), r || (this.emission.carry = 0), 0;
+    const o = this.settingsValue;
+    mt(
+      this.emission,
+      o.rate,
+      i - s,
+      this.births,
+      this.ringValue.capacity
+    );
+    const n = this.frame;
+    return n.from.copy(this.last), n.to.copy(t), n.timeFrom = s, n.timeTo = i, gt(this.ringValue, o, n, this.births, this.random), this.last.copy(t), this.births.length;
+  }
+  /**
+   * One frame with the emitter at SEVERAL places at once — five fingertips
+   * sharing one system. The rate is the emitter's total: the particles due
+   * this frame are dealt out round-robin over `matrices`, each born along
+   * its own slot's path since the last frame. A change in the number of
+   * slots restarts their paths (no particle is born between two slots).
+   */
+  updateAt(t, i, r = !0) {
+    const s = this.lastTime;
+    this.lastTime = i;
+    const o = t.length;
+    if (this.lasts.length !== o) {
+      this.lasts.length = 0;
+      for (let a = 0; a < o; a += 1) this.lasts.push(new h.Matrix4().copy(t[a]));
+      return this.emission.carry = 0, 0;
+    }
+    if (s === null || !r || !(i > s) || o === 0) {
+      for (let a = 0; a < o; a += 1) this.lasts[a].copy(t[a]);
+      return r || (this.emission.carry = 0), 0;
+    }
+    const n = this.settingsValue;
+    mt(
+      this.emission,
+      n.rate,
+      i - s,
+      this.births,
+      this.ringValue.capacity
+    );
+    const c = this.frame;
+    c.timeFrom = s, c.timeTo = i;
+    let l = 0;
+    for (let a = 0; a < o; a += 1) {
+      this.slotBirths.length = 0;
+      for (let f = a; f < this.births.length; f += o) this.slotBirths.push(this.births[f]);
+      this.slotBirths.length > 0 && (c.from.copy(this.lasts[a]), c.to.copy(t[a]), gt(this.ringValue, n, c, this.slotBirths, this.random), l += this.slotBirths.length), this.lasts[a].copy(t[a]);
+    }
+    return l;
+  }
+  /** Removes every particle and forgets the last pose (the next update starts again). */
+  reset() {
+    this.ringValue.clear(), this.emission.carry = 0, this.lastTime = null, this.lasts.length = 0;
+  }
+}
+const Ee = () => ({
+  uTime: { value: 0 },
+  uDrag: { value: 0 },
+  uAcceleration: { value: new h.Vector3() },
+  uSize: { value: new h.Vector2(1, 1) },
+  uOpacity: { value: new h.Vector2(1, 1) },
+  uColors: { value: Array.from({ length: tt }, () => new h.Vector3(1, 1, 1)) },
+  uColorCount: { value: 1 },
+  uSprite: { value: 0 },
+  uStretch: { value: 0 }
+}), Me = (e, t) => {
+  e.uDrag.value = t.drag, e.uAcceleration.value.fromArray(Tt(t)), e.uSize.value.set(t.size[0], t.size[1]), e.uOpacity.value.set(t.opacity[0], t.opacity[1]), e.uColors.value.forEach((i, r) => {
+    const s = Math.min(r, t.colorCount - 1) * 3;
+    i.set(t.colors[s], t.colors[s + 1], t.colors[s + 2]);
+  }), e.uColorCount.value = t.colorCount, e.uSprite.value = t.sprite === "streak" ? 1 : 0, e.uStretch.value = t.stretch;
+}, Ae = [-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0], xe = [0, 1, 2, 0, 2, 3], vt = (e) => {
+  const t = new h.InstancedBufferGeometry();
+  t.setAttribute("position", new h.Float32BufferAttribute(Ae, 3)), t.setIndex(xe);
+  const i = new h.InstancedInterleavedBuffer(e.data, I, 1);
+  return i.setUsage(h.DynamicDrawUsage), t.setAttribute("aStart", new h.InterleavedBufferAttribute(i, 4, 0)), t.setAttribute("aMotion", new h.InterleavedBufferAttribute(i, 4, 4)), t.setAttribute("aExtra", new h.InterleavedBufferAttribute(i, 4, 8)), t.instanceCount = e.capacity, t.boundingSphere = new h.Sphere(new h.Vector3(), 1 / 0), { geometry: t, buffer: i };
+};
+class wt {
+  constructor(t = {}, i) {
+    /** Add it anywhere in the scene (its own transform is ignored); render order is yours to set. */
+    u(this, "mesh");
+    u(this, "uniforms", Ee());
+    u(this, "spawner");
+    u(this, "buffer");
+    u(this, "bufferRing");
+    u(this, "epoch", null);
+    u(this, "ranges", []);
+    u(this, "disposed", !1);
+    const r = ht(t, i);
+    this.spawner = new Se(r), this.bufferRing = this.spawner.ring;
+    const { geometry: s, buffer: o } = vt(this.bufferRing);
+    this.buffer = o;
+    const n = new h.ShaderMaterial({
+      name: "Particles",
+      uniforms: this.uniforms,
+      vertexShader: ue,
+      fragmentShader: me,
+      transparent: !0,
+      depthTest: !0,
+      depthWrite: !1,
+      side: h.DoubleSide,
+      toneMapped: !1
+    });
+    this.mesh = new h.Mesh(s, n), this.mesh.name = "Particles", this.mesh.frustumCulled = !1, this.mesh.matrixAutoUpdate = !1, this.mesh.raycast = () => {
+    }, this.apply(r);
+  }
+  /** The settings in use (resolved). */
+  get settings() {
+    return this.spawner.settings;
+  }
+  /** The spawn records (slots in use show their lifetime above 0). */
+  get ring() {
+    return this.spawner.ring;
+  }
+  /** The clock the shader draws at (s since the first update). */
+  get time() {
+    return this.uniforms.uTime.value;
+  }
+  /**
+   * New settings (any subset, over `base`, default `DEFAULT_PARTICLE_SETTINGS`).
+   * A new capacity empties the particles; anything else applies to the
+   * particles already out too.
+   */
+  setSettings(t, i = U) {
+    const r = ht(t, i);
+    this.spawner.setSettings(r), this.apply(r);
+  }
+  /**
+   * One frame: the emitter at `matrix` (world) at `time` (s, any clock that
+   * moves forward). Emits the particles due (unless `emitting` is false),
+   * uploads the new slots and sets the clock. Call it after the world
+   * matrices are up to date and before the render (the scene's
+   * `onBeforeRender`) so new particles draw this frame. A second call at the
+   * same time does nothing more. Returns how many were emitted.
+   */
+  update(t, i, r = !0) {
+    if (this.disposed) return 0;
+    this.epoch === null && (this.epoch = i);
+    const s = i - this.epoch, o = this.spawner.update(t, s, r);
+    return this.syncRing(), this.spawner.ring.takeDirty(this.ranges), this.ranges.length > 0 && (this.ranges.forEach(
+      ([n, c]) => this.buffer.addUpdateRange(n * I, c * I)
+    ), this.buffer.needsUpdate = !0), this.uniforms.uTime.value = s, o;
+  }
+  /** `update` from several places at once (one system for five fingertips): see `ParticleSpawner.updateAt`. */
+  updateAt(t, i, r = !0) {
+    if (this.disposed) return 0;
+    this.epoch === null && (this.epoch = i);
+    const s = i - this.epoch, o = this.spawner.updateAt(t, s, r);
+    return this.syncRing(), this.spawner.ring.takeDirty(this.ranges), this.ranges.length > 0 && (this.ranges.forEach(
+      ([n, c]) => this.buffer.addUpdateRange(n * I, c * I)
+    ), this.buffer.needsUpdate = !0), this.uniforms.uTime.value = s, o;
+  }
+  /** Particles alive now (counts the ring on the CPU: for a readout, not every frame). */
+  aliveCount() {
+    return this.spawner.ring.aliveAt(Math.fround(this.uniforms.uTime.value));
+  }
+  /** Removes every particle; the next update starts emitting again. */
+  reset() {
+    this.spawner.reset(), this.epoch = null, this.uniforms.uTime.value = 0;
+  }
+  dispose() {
+    this.disposed || (this.disposed = !0, this.mesh.geometry.dispose(), this.mesh.material.dispose());
+  }
+  apply(t) {
+    Me(this.uniforms, t), this.mesh.material.blending = t.blending === "additive" ? h.AdditiveBlending : h.NormalBlending, this.syncRing();
+  }
+  /** A new ring (a capacity change) needs a new geometry around it. */
+  syncRing() {
+    const t = this.spawner.ring;
+    if (t === this.bufferRing || !this.mesh) return;
+    this.mesh.geometry.dispose();
+    const { geometry: i, buffer: r } = vt(t);
+    this.mesh.geometry = i, this.buffer = r, this.bufferRing = t;
+  }
+}
+const Te = (e) => {
+  for (let t = e; t; t = t.parent) if (!t.visible) return !1;
+  return !0;
+}, it = Z(
+  ({
+    base: e,
+    emitting: t = !0,
+    renderOrder: i = 0,
+    position: r,
+    rotation: s,
+    scale: o,
+    onSystem: n,
+    children: c,
+    ...l
+  }, a) => {
+    const f = V((M) => M.scene), m = V((M) => M.get), v = W(null);
+    kt(a, () => v.current, []);
+    const d = JSON.stringify(l), g = W({ settings: l, base: e, emitting: t, onSystem: n });
+    g.current = { settings: l, base: e, emitting: t, onSystem: n };
+    const [S, E] = Lt(null);
+    return q(() => {
+      var T, b;
+      const M = new wt(g.current.settings, g.current.base);
+      f.add(M.mesh);
+      const A = At(f, () => {
+        const y = v.current;
+        y && M.update(
+          y.matrixWorld,
+          m().clock.elapsedTime,
+          g.current.emitting && Te(y)
+        );
+      });
+      return E(M), (b = (T = g.current).onSystem) == null || b.call(T, M), () => {
+        var y, w;
+        A(), f.remove(M.mesh), M.dispose(), (w = (y = g.current).onSystem) == null || w.call(y, null), E((F) => F === M ? null : F);
+      };
+    }, [f, m]), q(() => {
+      S == null || S.setSettings(g.current.settings, g.current.base);
+    }, [S, d, e]), S && (S.mesh.renderOrder = i), /* @__PURE__ */ D("group", { ref: v, position: r, rotation: s, scale: o, children: c });
+  }
+);
+it.displayName = "Emitter";
+const Rt = Z(
+  ({ target: e, faceIndex: t, numFaces: i, base: r, seed: s, ...o }, n) => {
+    const c = Vt(), l = Nt(), a = s ?? r.seed, f = /* @__PURE__ */ D(Gt, { faceIndex: t, children: Kt(e).map((m, v) => /* @__PURE__ */ D("group", { position: $t(m, l), children: /* @__PURE__ */ D(
+      it,
+      {
+        ref: v === 0 ? n : void 0,
+        base: r,
+        seed: a + v,
+        ...o
+      }
+    ) }, m)) });
+    return (c == null ? void 0 : c.type) === "face" ? f : /* @__PURE__ */ D(jt, { faceIndex: t ?? 0, numFaces: i, children: f });
+  }
+);
+Rt.displayName = "EyeEmitters";
+const be = Z(
+  ({ preset: e, target: t, faceIndex: i, numFaces: r, ...s }, o) => {
+    const n = Mt(() => xt(e), [e]);
+    return t ? /* @__PURE__ */ D(
+      Rt,
+      {
+        ref: o,
+        target: t,
+        faceIndex: i,
+        numFaces: r,
+        base: n,
+        ...s
+      }
+    ) : /* @__PURE__ */ D(it, { ref: o, base: n, ...s });
+  }
+);
+be.displayName = "ParticleEmitter";
+const He = ["fingertips", "index", "palm"], Ce = ["thumbTip", "indexTip", "middleTip", "ringTip", "pinkyTip"], we = ["indexMcp", "middleMcp", "ringMcp", "pinkyMcp"], Re = (e) => e === "index" ? [_.indexTip] : e === "palm" ? we.map((t) => _[t]) : Ce.map((t) => _[t]), ze = (e) => e === "palm", zt = Object.freeze({
+  still: 0.15,
+  full: 60
+}), Pe = (e, t, i = zt) => {
+  if (!(e > 0)) return 0;
+  const r = Math.min(1, Math.max(0, i.still));
+  if (r >= 1 || !(i.full > 0)) return e;
+  const s = Number.isFinite(t) ? Math.max(0, t) : 0, o = Math.min(1, s / i.full);
+  return e * (r + (1 - r) * o);
+}, Ie = (e, t) => {
+  const i = e.world[_.wrist], r = e.world[_.middleMcp];
+  if (!i || !r || !(t > 0)) return 0;
+  const s = Math.hypot(r.x - i.x, r.y - i.y, r.z - i.z);
+  return s > 1e-6 ? t / s : 0;
+}, St = [
+  _.wrist,
+  _.middleMcp
+], _e = ["left", "right"], Et = new h.Quaternion().setFromAxisAngle(new h.Vector3(1, 0, 0), -Math.PI / 2), P = new h.Vector3(), O = new h.Vector3(), K = new h.Vector3(), Xe = ({
+  look: e = "sparkles",
+  from: t = "fingertips",
+  hand: i = "both",
+  motion: r,
+  emitting: s = !0,
+  renderOrder: o = 0,
+  onSystem: n,
+  ...c
+}) => {
+  const { node: l } = Jt(Ft.HAND_TRACKER), a = V((E) => E.scene), f = V((E) => E.get), m = V((E) => E.camera), v = Mt(() => xt(e), [e]), d = W({
+    settings: c,
+    base: v,
+    emitting: s,
+    motion: r,
+    node: l,
+    camera: m,
+    from: t,
+    onSystem: n,
+    renderOrder: o
+  });
+  d.current = { settings: c, base: v, emitting: s, motion: r, node: l, camera: m, from: t, onSystem: n, renderOrder: o };
+  const g = i === "both" ? _e : [i], S = g.join(",");
+  return q(() => {
+    const E = /* @__PURE__ */ new Map();
+    g.forEach((A, T) => {
+      var y, w;
+      const b = new wt(
+        { ...d.current.settings, seed: (d.current.settings.seed ?? v.seed) + T },
+        v
+      );
+      a.add(b.mesh), E.set(A, { system: b, matrices: [], last: null, lastTime: 0, speedCmPerS: 0 }), (w = (y = d.current).onSystem) == null || w.call(y, b, A);
+    });
+    const M = At(a, () => {
+      const { node: A, camera: T, from: b } = d.current, y = f().clock.elapsedTime, w = Re(b), F = ze(b), Pt = { ...zt, ...d.current.motion };
+      E.forEach((p, rt) => {
+        var ot, nt;
+        const z = ((ot = A == null ? void 0 : A.getHandPose) == null ? void 0 : ot.call(A, rt)) ?? ((nt = A == null ? void 0 : A.poses) == null ? void 0 : nt[rt]) ?? null;
+        if (!z || z.image.length < 21) {
+          p.matrices.length = 0, p.system.updateAt(p.matrices, y, !1), p.last = null;
+          return;
+        }
+        J(z.image[St[0]], T, P, 0), J(z.image[St[1]], T, O, 0);
+        const H = Ie(z, P.distanceTo(O));
+        if (!(H > 0)) {
+          p.system.updateAt(p.matrices, y, !1);
+          return;
+        }
+        if (J(z.image[_.middleMcp], T, P, 0), p.last && y > p.lastTime) {
+          const k = y - p.lastTime, X = p.last.distanceTo(P) / k / H;
+          p.speedCmPerS += (X - p.speedCmPerS) * Math.min(1, k * 8);
+        } else
+          p.last = new h.Vector3(), p.speedCmPerS = 0;
+        p.last.copy(P), p.lastTime = y;
+        const st = F ? 1 : w.length;
+        for (; p.matrices.length < st; ) p.matrices.push(new h.Matrix4());
+        p.matrices.length = st, K.setScalar(H), F ? (P.set(0, 0, 0), w.forEach((k) => {
+          J(z.image[k], T, O, 0), P.add(O);
+        }), P.divideScalar(w.length), p.matrices[0].compose(P, Et, K)) : w.forEach((k, X) => {
+          J(z.image[k], T, O, 0), p.matrices[X].compose(O, Et, K);
+        });
+        const It = Pe(
+          d.current.settings.rate ?? d.current.base.rate,
+          p.speedCmPerS,
+          Pt
+        );
+        p.system.setSettings({ ...d.current.settings, rate: It }, d.current.base), p.system.mesh.renderOrder = d.current.renderOrder, p.system.updateAt(p.matrices, y, d.current.emitting && !z.held);
+      });
+    });
+    return () => {
+      M(), E.forEach((A, T) => {
+        var b, y;
+        a.remove(A.system.mesh), A.system.dispose(), (y = (b = d.current).onSystem) == null || y.call(b, null, T);
+      }), E.clear();
+    };
+  }, [a, f, v, S]), null;
+};
+export {
+  zt as DEFAULT_HAND_EFFECT_MOTION,
+  U as DEFAULT_PARTICLE_SETTINGS,
+  He as HAND_EFFECT_SOURCES,
+  St as HAND_UNIT_JOINTS,
+  Xe as HandEffect,
+  Qt as PARTICLE_BLENDINGS,
+  et as PARTICLE_DRAG_SERIES_LIMIT,
+  Ge as PARTICLE_EMITTER_TARGETS,
+  Yt as PARTICLE_EYE_CENTRE,
+  Xt as PARTICLE_EYE_FORWARD,
+  me as PARTICLE_FRAGMENT_SHADER,
+  tt as PARTICLE_MAX_COLORS,
+  Q as PARTICLE_MAX_PARTICLES,
+  de as PARTICLE_MAX_STEP,
+  se as PARTICLE_PRESETS,
+  re as PARTICLE_PRESET_KEYS,
+  B as PARTICLE_RECORD,
+  I as PARTICLE_RECORD_FLOATS,
+  Zt as PARTICLE_SETTINGS_RANGES,
+  Wt as PARTICLE_SHAPES,
+  qt as PARTICLE_SPRITES,
+  pe as PARTICLE_STATE_GLSL,
+  ue as PARTICLE_VERTEX_SHADER,
+  be as ParticleEmitter,
+  ft as ParticleRing,
+  Se as ParticleSpawner,
+  wt as ParticleSystem,
+  Me as applyParticleUniforms,
+  ye as createParticleEmission,
+  dt as createParticleRandom,
+  ne as createParticleRecord,
+  he as createParticleSample,
+  bt as createParticleStart,
+  Ee as createParticleUniforms,
+  ze as handEffectIsCentred,
+  Re as handEffectJoints,
+  Pe as handEffectRate,
+  Ie as handUnitPerCm,
+  oe as isParticlePreset,
+  te as parseParticleColor,
+  Tt as particleAcceleration,
+  ie as particleCapacity,
+  le as particleColorAt,
+  ce as particleDragAcceleration,
+  ae as particleDragDistance,
+  $t as particleEyePosition,
+  pt as particleOverLife,
+  xt as particlePresetBase,
+  Kt as particleTargetSides,
+  yt as particleUnitOf,
+  ht as resolveParticleSettings,
+  Ue as sampleParticle,
+  G as sampleParticleCone,
+  ve as sampleParticleStart,
+  gt as spawnParticles,
+  mt as stepParticleEmission
+};