@vincentt-xr/sdk 2.0.0-alpha.8 → 2.0.0-alpha.9

package/dist/particles.js

@@ -0,0 +1,774 @@
+var nt = Object.defineProperty;
+var ct = (e, t, i) => t in e ? nt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[t] = i;
+var p = (e, t, i) => ct(e, typeof t != "symbol" ? t + "" : t, i);
+import { jsx as M } from "react/jsx-runtime";
+import { useThree as B } from "@react-three/fiber";
+import { forwardRef as k, useMemo as lt, useRef as U, useImperativeHandle as ht, useState as ft, useEffect as H } from "react";
+import { e as pt } from "./selectors-DmNaKIwE.js";
+import { u as ut, F as mt } from "./index-BavF06C6.js";
+import { p as dt } from "./index-CIe7eCMH.js";
+import { C as yt, a as vt } from "./CanonicalHeadFrame-BHcWyaiK.js";
+import * as h from "three";
+import { a as gt } from "./useLandmarkPoseFit-Bmb3h6Mw.js";
+const me = ["leftEye", "rightEye", "eyes"], St = [
+  263,
+  249,
+  390,
+  373,
+  374,
+  380,
+  381,
+  382,
+  362,
+  398,
+  384,
+  385,
+  386,
+  387,
+  388,
+  466
+], Et = [
+  33,
+  7,
+  163,
+  144,
+  145,
+  153,
+  154,
+  155,
+  133,
+  173,
+  157,
+  158,
+  159,
+  160,
+  161,
+  246
+], X = (e) => {
+  const t = [0, 0, 0];
+  return e.forEach((i) => {
+    for (let r = 0; r < 3; r += 1) t[r] += yt[i * 3 + r] / e.length;
+  }), t;
+}, xt = 0.4, Mt = (() => {
+  const e = X(St), t = X(Et);
+  return Object.freeze([
+    (e[0] - t[0]) / 2,
+    (e[1] + t[1]) / 2,
+    (e[2] + t[2]) / 2 + xt
+  ]);
+})(), Ct = (e, t) => {
+  const [i, r, s] = Mt;
+  return [dt(t) * (e === "left" ? 1 : -1) * i, r, s];
+}, At = (e) => e === "eyes" ? ["left", "right"] : [e === "leftEye" ? "left" : "right"], Rt = ["point", "sphere", "box", "cone"], bt = ["glow", "streak"], Tt = ["additive", "normal"], O = 4, L = 65536, I = 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
+}), wt = {
+  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, L],
+  seed: [-1e9, 1e9]
+}, w = (e, t, i, r) => typeof e == "number" && Number.isFinite(e) ? Math.min(i, Math.max(t, e)) : r, _ = (e, t, i) => typeof t == "string" && e.includes(t) ? t : i, Y = (e, [t, i], r) => {
+  const s = Array.isArray(e) ? e : [];
+  return [0, 1, 2].map((o) => w(s[o], t, i, r[o]));
+}, $ = (e, [t, i], r) => {
+  const s = typeof r == "number" ? [r, r] : r;
+  if (typeof e == "number") {
+    const a = w(e, t, i, s[0]);
+    return [a, a];
+  }
+  const o = Array.isArray(e) ? e : [];
+  return [w(o[0], t, i, s[0]), w(o[1], t, i, s[1])];
+}, E = new h.Color(), zt = (e) => typeof e == "number" && Number.isFinite(e) ? (E.setHex(Math.max(0, Math.min(16777215, Math.round(e)))), [E.r, E.g, E.b]) : typeof e != "string" || e.trim() === "" ? null : (E.setRGB(-1, -1, -1), E.setStyle(e), E.r < 0 ? null : [E.r, E.g, E.b]), Pt = (e, t) => {
+  const i = (s) => {
+    const a = (Array.isArray(s) ? s : [s]).slice(0, O).map(zt);
+    return a.length > 0 && a.every(Boolean) ? a : null;
+  }, r = i(e) ?? i(t) ?? [[1, 1, 1]];
+  return { colors: Float32Array.from(r.flat()), colorCount: r.length };
+}, It = (e, t, i = 0) => {
+  if (i > 0) return Math.min(L, Math.ceil(i));
+  const r = Math.max(0, e) * Math.max(0, t);
+  return Math.min(
+    L,
+    Math.max(1, Math.ceil(r * 1.1 + Math.max(0, e) * 0.1) + 8)
+  );
+}, q = (e = {}, t = I) => {
+  const i = wt, r = (n) => w(e[n], i[n][0], i[n][1], t[n]), s = r("rate"), o = r("lifetime"), a = Math.round(r("maxParticles"));
+  return {
+    rate: s,
+    lifetime: o,
+    lifetimeJitter: r("lifetimeJitter"),
+    shape: _(Rt, e.shape, t.shape),
+    radius: r("radius"),
+    boxSize: Y(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: Y(e.wind, i.wind, t.wind),
+    drag: r("drag"),
+    size: $(e.size, i.size, t.size),
+    sizeJitter: r("sizeJitter"),
+    ...Pt(e.color, t.color),
+    opacity: $(e.opacity, i.opacity, t.opacity),
+    sprite: _(bt, e.sprite, t.sprite),
+    stretch: r("stretch"),
+    blending: _(Tt, e.blending, t.blending),
+    maxParticles: a,
+    seed: r("seed"),
+    capacity: It(s, o, a)
+  };
+}, _t = ["laser"], Dt = 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"
+  })
+}), Lt = (e) => typeof e == "string" && _t.includes(e), kt = (e) => Lt(e) ? { ...I, ...Dt[e] } : I, C = 12, z = Object.freeze({
+  position: 0,
+  birth: 3,
+  velocity: 4,
+  lifetime: 7,
+  sizeScale: 8,
+  unit: 9,
+  seed: 10
+}), Ot = () => ({
+  position: [0, 0, 0],
+  velocity: [0, 0, 0],
+  birth: 0,
+  lifetime: 0,
+  sizeScale: 1,
+  unit: 1,
+  seed: 0
+});
+class W {
+  constructor(t) {
+    p(this, "capacity");
+    /** `capacity × PARTICLE_RECORD_FLOATS` floats; a lifetime of 0 is an empty slot. */
+    p(this, "data");
+    p(this, "head", 0);
+    p(this, "dirtyFirst", 0);
+    p(this, "dirtyCount", 0);
+    this.capacity = Math.max(1, Math.floor(t)), this.data = new Float32Array(this.capacity * C);
+  }
+  /** 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 * C, s = this.data, o = z;
+    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 += C) {
+      const o = t - i[s + z.birth];
+      o >= 0 && o < i[s + z.lifetime] && (r += 1);
+    }
+    return r;
+  }
+}
+const F = 0.01, Ft = (e, t) => {
+  const i = e * t;
+  return i < F ? t * (1 - i / 2 + i * i / 6 - i * i * i / 24) : (1 - Math.exp(-i)) / e;
+}, Nt = (e, t) => {
+  const i = e * t;
+  return i < F ? t * t * (0.5 - i / 6 + i * i / 24 - i * i * i / 120) : (t - (1 - Math.exp(-i)) / e) / e;
+}, it = (e, t = [0, 0, 0]) => (t[0] = e.wind[0], t[1] = e.wind[1] - e.gravity, t[2] = e.wind[2], t), K = (e, t) => e[0] + (e[1] - e[0]) * t, Vt = (e, t, i = [0, 0, 0]) => {
+  const { colors: r, colorCount: s } = e, o = Math.min(1, Math.max(0, t)) * (s - 1), a = Math.min(s - 1, Math.floor(o)), n = Math.min(s - 1, a + 1), c = o - a;
+  for (let l = 0; l < 3; l += 1)
+    i[l] = r[a * 3 + l] + (r[n * 3 + l] - r[a * 3 + l]) * c;
+  return i;
+}, Jt = () => ({
+  alive: !1,
+  age: 0,
+  life: 0,
+  position: [0, 0, 0],
+  velocity: [0, 0, 0],
+  size: 0,
+  opacity: 0,
+  color: [0, 0, 0]
+}), Q = [0, 0, 0], de = (e, t, i, r, s = Jt()) => {
+  const o = t * C, a = z, n = e[o + a.lifetime], c = i - e[o + a.birth];
+  s.age = c, s.alive = n > 0 && c >= 0 && c < n;
+  const l = Math.min(Math.max(c, 0), Math.max(n, 0));
+  s.life = n > 0 ? l / n : 0;
+  const f = r.drag, u = Ft(f, l), S = Nt(f, l), x = Math.exp(-f * l), m = e[o + a.unit];
+  it(r, Q);
+  for (let d = 0; d < 3; d += 1) {
+    const b = Q[d] * m, y = e[o + a.velocity + d];
+    s.position[d] = e[o + a.position + d] + y * u + b * S, s.velocity[d] = y * x + b * u;
+  }
+  return s.size = K(r.size, s.life) * e[o + a.sizeScale], s.opacity = K(r.opacity, s.life), Vt(r, s.life, s.color), s;
+}, Gt = (e) => Number.isInteger(e) ? `${e}.0` : `${e}`, jt = (
+  /* glsl */
+  `
+uniform float uTime;
+uniform float uDrag;
+uniform vec3 uAcceleration;
+uniform vec2 uSize;
+uniform vec2 uOpacity;
+uniform vec3 uColors[${O}];
+uniform float uColorCount;
+
+const float PARTICLE_DRAG_SERIES_LIMIT = ${Gt(F)};
+
+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;
+}
+`
+), Bt = (
+  /* 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;
+${jt}
+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);
+}
+`
+), Ut = (
+  /* 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>
+}
+`
+), Ht = 0.25, Xt = () => ({ carry: 0 }), Yt = (e, t, i, r = [], s = 1 / 0) => {
+  if (r.length = 0, !(t > 0) || !(i > 0)) return r;
+  const o = Math.min(Ht, i), a = e.carry + t * o, n = Math.floor(a), c = Math.max(0, n - Math.max(0, Math.floor(s)));
+  for (let l = c; l < n; l += 1) {
+    const f = (l + 1 - e.carry) / t;
+    r.push(Math.min(1, (i - o + f) / i));
+  }
+  return e.carry = a - n, r;
+}, Z = (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;
+  };
+}, rt = () => ({
+  position: [0, 0, 0],
+  direction: [0, 0, 1]
+}), st = Math.PI / 180, P = (e, t, i) => {
+  const r = Math.cos(Math.min(180, Math.max(0, e)) * st), s = 1 - t() * (1 - r), o = Math.sqrt(Math.max(0, 1 - s * s)), a = t() * 2 * Math.PI;
+  return i[0] = o * Math.cos(a), i[1] = o * Math.sin(a), i[2] = s, i;
+}, $t = (e, t) => P(180, e, t), qt = (e, t, i = rt()) => {
+  const r = i.position, s = i.direction;
+  switch (r[0] = 0, r[1] = 0, r[2] = 0, e.shape) {
+    case "sphere": {
+      $t(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, a, n] = e.boxSize;
+      if (r[0] = (t() - 0.5) * o, r[1] = (t() - 0.5) * a, r[2] = (t() - 0.5) * n, e.surface) {
+        const c = [a * n, o * n, o * a], l = c[0] + c[1] + c[2];
+        let f = t() * (l > 0 ? l : 3), u = 0;
+        if (l > 0)
+          for (; u < 2 && f >= c[u]; )
+            f -= c[u], u += 1;
+        else
+          u = Math.min(2, Math.floor(f));
+        r[u] = (t() < 0.5 ? -0.5 : 0.5) * e.boxSize[u];
+      }
+      P(e.angle, t, s);
+      break;
+    }
+    case "cone": {
+      const o = e.radius;
+      if (o > 0) {
+        const a = Math.sqrt(t()), n = t() * 2 * Math.PI, c = Math.cos(n), l = Math.sin(n);
+        r[0] = o * a * c, r[1] = o * a * l;
+        const f = Math.min(180, e.angle) * st * a;
+        s[0] = Math.sin(f) * c, s[1] = Math.sin(f) * l, s[2] = Math.cos(f);
+      } else
+        P(e.angle, t, s);
+      break;
+    }
+    default:
+      P(e.angle, t, s);
+  }
+  return i;
+}, tt = (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;
+}, D = rt(), g = Ot(), R = new h.Vector3(), v = new h.Vector3(), T = new h.Vector3(), Wt = (e, t, i, r, s) => {
+  const o = tt(i.from), a = tt(i.to);
+  for (let n = 0; n < r.length; n += 1) {
+    const c = r[n];
+    qt(t, s, D);
+    const l = s(), f = s(), u = s(), S = s();
+    R.fromArray(D.position), v.copy(R).applyMatrix4(i.from), T.copy(R).applyMatrix4(i.to), v.lerp(T, c), g.position[0] = v.x, g.position[1] = v.y, g.position[2] = v.z, R.fromArray(D.direction), v.copy(R).transformDirection(i.from), T.copy(R).transformDirection(i.to), v.lerp(T, c), v.lengthSq() > 1e-12 ? v.normalize() : v.copy(T);
+    const x = o + (a - o) * c, m = t.speed * (1 - t.speedJitter * l) * x;
+    g.velocity[0] = v.x * m, g.velocity[1] = v.y * m, g.velocity[2] = v.z * m, g.birth = i.timeFrom + (i.timeTo - i.timeFrom) * c, g.lifetime = t.lifetime * (1 - t.lifetimeJitter * f), g.sizeScale = (1 - t.sizeJitter * u) * x, g.unit = x, g.seed = S, e.push(g);
+  }
+};
+class Kt {
+  constructor(t) {
+    p(this, "ringValue");
+    p(this, "settingsValue");
+    p(this, "random");
+    p(this, "emission", Xt());
+    p(this, "births", []);
+    p(this, "last", new h.Matrix4());
+    p(this, "lastTime", null);
+    p(this, "frame", {
+      from: new h.Matrix4(),
+      to: new h.Matrix4(),
+      timeFrom: 0,
+      timeTo: 0
+    });
+    this.settingsValue = t, this.ringValue = new W(t.capacity), this.random = Z(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 W(t.capacity), this.ringValue.clear()), t.seed !== i.seed && (this.random = Z(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;
+    Yt(
+      this.emission,
+      o.rate,
+      i - s,
+      this.births,
+      this.ringValue.capacity
+    );
+    const a = this.frame;
+    return a.from.copy(this.last), a.to.copy(t), a.timeFrom = s, a.timeTo = i, Wt(this.ringValue, o, a, this.births, this.random), this.last.copy(t), this.births.length;
+  }
+  /** Removes every particle and forgets the last pose (the next update starts again). */
+  reset() {
+    this.ringValue.clear(), this.emission.carry = 0, this.lastTime = null;
+  }
+}
+const Qt = () => ({
+  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: O }, () => new h.Vector3(1, 1, 1)) },
+  uColorCount: { value: 1 },
+  uSprite: { value: 0 },
+  uStretch: { value: 0 }
+}), Zt = (e, t) => {
+  e.uDrag.value = t.drag, e.uAcceleration.value.fromArray(it(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;
+}, te = [-1, -1, 0, 1, -1, 0, 1, 1, 0, -1, 1, 0], ee = [0, 1, 2, 0, 2, 3], et = (e) => {
+  const t = new h.InstancedBufferGeometry();
+  t.setAttribute("position", new h.Float32BufferAttribute(te, 3)), t.setIndex(ee);
+  const i = new h.InstancedInterleavedBuffer(e.data, C, 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 ie {
+  constructor(t = {}, i) {
+    /** Add it anywhere in the scene (its own transform is ignored); render order is yours to set. */
+    p(this, "mesh");
+    p(this, "uniforms", Qt());
+    p(this, "spawner");
+    p(this, "buffer");
+    p(this, "bufferRing");
+    p(this, "epoch", null);
+    p(this, "ranges", []);
+    p(this, "disposed", !1);
+    const r = q(t, i);
+    this.spawner = new Kt(r), this.bufferRing = this.spawner.ring;
+    const { geometry: s, buffer: o } = et(this.bufferRing);
+    this.buffer = o;
+    const a = new h.ShaderMaterial({
+      name: "Particles",
+      uniforms: this.uniforms,
+      vertexShader: Bt,
+      fragmentShader: Ut,
+      transparent: !0,
+      depthTest: !0,
+      depthWrite: !1,
+      side: h.DoubleSide,
+      toneMapped: !1
+    });
+    this.mesh = new h.Mesh(s, a), 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 = I) {
+    const r = q(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(
+      ([a, n]) => this.buffer.addUpdateRange(a * C, n * C)
+    ), 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) {
+    Zt(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 } = et(t);
+    this.mesh.geometry = i, this.buffer = r, this.bufferRing = t;
+  }
+}
+const re = (e) => {
+  for (let t = e; t; t = t.parent) if (!t.visible) return !1;
+  return !0;
+}, N = k(
+  ({
+    base: e,
+    emitting: t = !0,
+    renderOrder: i = 0,
+    position: r,
+    rotation: s,
+    scale: o,
+    onSystem: a,
+    children: n,
+    ...c
+  }, l) => {
+    const f = B((y) => y.scene), u = B((y) => y.get), S = U(null);
+    ht(l, () => S.current, []);
+    const x = JSON.stringify(c), m = U({ settings: c, base: e, emitting: t, onSystem: a });
+    m.current = { settings: c, base: e, emitting: t, onSystem: a };
+    const [d, b] = ft(null);
+    return H(() => {
+      var V, J;
+      const y = new ie(m.current.settings, m.current.base);
+      f.add(y.mesh);
+      const at = gt(f, () => {
+        const A = S.current;
+        A && y.update(
+          A.matrixWorld,
+          u().clock.elapsedTime,
+          m.current.emitting && re(A)
+        );
+      });
+      return b(y), (J = (V = m.current).onSystem) == null || J.call(V, y), () => {
+        var A, G;
+        at(), f.remove(y.mesh), y.dispose(), (G = (A = m.current).onSystem) == null || G.call(A, null), b((j) => j === y ? null : j);
+      };
+    }, [f, u]), H(() => {
+      d == null || d.setSettings(m.current.settings, m.current.base);
+    }, [d, x, e]), d && (d.mesh.renderOrder = i), /* @__PURE__ */ M("group", { ref: S, position: r, rotation: s, scale: o, children: n });
+  }
+);
+N.displayName = "Emitter";
+const ot = k(
+  ({ target: e, faceIndex: t, numFaces: i, base: r, seed: s, ...o }, a) => {
+    const n = ut(), c = pt(), l = s ?? r.seed, f = /* @__PURE__ */ M(vt, { faceIndex: t, children: At(e).map((u, S) => /* @__PURE__ */ M("group", { position: Ct(u, c), children: /* @__PURE__ */ M(
+      N,
+      {
+        ref: S === 0 ? a : void 0,
+        base: r,
+        seed: l + S,
+        ...o
+      }
+    ) }, u)) });
+    return (n == null ? void 0 : n.type) === "face" ? f : /* @__PURE__ */ M(mt, { faceIndex: t ?? 0, numFaces: i, children: f });
+  }
+);
+ot.displayName = "EyeEmitters";
+const se = k(
+  ({ preset: e, target: t, faceIndex: i, numFaces: r, ...s }, o) => {
+    const a = lt(() => kt(e), [e]);
+    return t ? /* @__PURE__ */ M(
+      ot,
+      {
+        ref: o,
+        target: t,
+        faceIndex: i,
+        numFaces: r,
+        base: a,
+        ...s
+      }
+    ) : /* @__PURE__ */ M(N, { ref: o, base: a, ...s });
+  }
+);
+se.displayName = "ParticleEmitter";
+export {
+  I as DEFAULT_PARTICLE_SETTINGS,
+  Tt as PARTICLE_BLENDINGS,
+  F as PARTICLE_DRAG_SERIES_LIMIT,
+  me as PARTICLE_EMITTER_TARGETS,
+  Mt as PARTICLE_EYE_CENTRE,
+  xt as PARTICLE_EYE_FORWARD,
+  Ut as PARTICLE_FRAGMENT_SHADER,
+  O as PARTICLE_MAX_COLORS,
+  L as PARTICLE_MAX_PARTICLES,
+  Ht as PARTICLE_MAX_STEP,
+  Dt as PARTICLE_PRESETS,
+  _t as PARTICLE_PRESET_KEYS,
+  z as PARTICLE_RECORD,
+  C as PARTICLE_RECORD_FLOATS,
+  wt as PARTICLE_SETTINGS_RANGES,
+  Rt as PARTICLE_SHAPES,
+  bt as PARTICLE_SPRITES,
+  jt as PARTICLE_STATE_GLSL,
+  Bt as PARTICLE_VERTEX_SHADER,
+  se as ParticleEmitter,
+  W as ParticleRing,
+  Kt as ParticleSpawner,
+  ie as ParticleSystem,
+  Zt as applyParticleUniforms,
+  Xt as createParticleEmission,
+  Z as createParticleRandom,
+  Ot as createParticleRecord,
+  Jt as createParticleSample,
+  rt as createParticleStart,
+  Qt as createParticleUniforms,
+  Lt as isParticlePreset,
+  zt as parseParticleColor,
+  it as particleAcceleration,
+  It as particleCapacity,
+  Vt as particleColorAt,
+  Nt as particleDragAcceleration,
+  Ft as particleDragDistance,
+  Ct as particleEyePosition,
+  K as particleOverLife,
+  kt as particlePresetBase,
+  At as particleTargetSides,
+  tt as particleUnitOf,
+  q as resolveParticleSettings,
+  de as sampleParticle,
+  P as sampleParticleCone,
+  qt as sampleParticleStart,
+  Wt as spawnParticles,
+  Yt as stepParticleEmission
+};