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

package/dist/particles/selfTest.d.ts

@@ -0,0 +1,53 @@
+import * as THREE from "three";
+/**
+ * A GPU self-test of the particles on this device's WebGL2:
+ *
+ * 1. **compile**: the particle and parity shaders link, with no shader or GL error.
+ * 2. **parity**: `PARTICLE_STATE_GLSL` matches `sampleParticle` (the CPU
+ *    reference) for particles from a moving, turning, scaled emitter, at
+ *    several times, under no forces, under drag, gravity and wind, and with
+ *    colour ramps (float targets; skipped where the GPU cannot render them).
+ * 3. **same frame**: particles emitted in the scene's before-render hook
+ *    draw in that very render, along the emitter's path, and nowhere else.
+ * 4. **streak**: a streak lies along its motion and never reaches behind
+ *    its emitter (its tail is at most its age).
+ * 5. **dead**: past their lifetime, particles draw nothing.
+ *
+ * The headless smoke run drives it (`example/smoke/particles.spec.ts`); open
+ * `/smoke/particles.html` on the dev server to run it on a device.
+ */
+export type ParticleSelfTestCheck = {
+    name: string;
+    ok: boolean;
+    detail: string;
+};
+export type ParticleSelfTestResult = {
+    ok: boolean;
+    error: string | null;
+    checks: ParticleSelfTestCheck[];
+};
+export declare const PARTICLE_SELF_TEST: Readonly<{
+    parityParticles: 256;
+    parityTimes: readonly number[];
+    /** Position and velocity: |GPU − CPU| ≤ abs + rel × |CPU|. */
+    motionTolerance: {
+        abs: number;
+        rel: number;
+    };
+    /** Size, opacity, colour and life. */
+    looksTolerance: 0.0002;
+    /** Birth and death within this of the time are not compared (float32 rounding). */
+    boundaryMargin: 0.001;
+    /** The draw checks' target (px, square) and view (world units across). */
+    drawSize: 128;
+    drawView: 32;
+    /** A pixel is lit above this (8-bit sum of RGB). */
+    litLevel: 24;
+}>;
+/**
+ * Runs every check on `options.renderer` (default: an offscreen renderer it
+ * disposes). Never rejects: failures and thrown errors are in the result.
+ */
+export declare const runParticleSelfTest: (options?: {
+    renderer?: THREE.WebGLRenderer;
+}) => Promise<ParticleSelfTestResult>;

package/dist/particles/settings.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Particle emitter settings (pure): the fields, their defaults and ranges,
+ * and `resolveParticleSettings`, which turns any partial (from an app or an
+ * agent) into a complete, clamped set the emitter and the shader read.
+ *
+ * Lengths, speeds and forces are in the emitter's own units: its world
+ * scale when a particle is emitted converts them (inside a head frame they
+ * are centimetres). Gravity pulls along the world's −Y, wind pushes along
+ * the world's axes; the shape and the direction particles leave in are in
+ * the emitter's axes (+Z forward).
+ */
+/** Where particles start: one point, a sphere, a box, or the base of a cone. */
+export declare const PARTICLE_SHAPES: readonly ["point", "sphere", "box", "cone"];
+export type ParticleShape = (typeof PARTICLE_SHAPES)[number];
+/** The built-in particle shapes: a soft round glow, or a streak along the motion. */
+export declare const PARTICLE_SPRITES: readonly ["glow", "streak"];
+export type ParticleSprite = (typeof PARTICLE_SPRITES)[number];
+/** `additive` brightens what is behind (light, lasers); `normal` covers it. */
+export declare const PARTICLE_BLENDINGS: readonly ["additive", "normal"];
+export type ParticleBlending = (typeof PARTICLE_BLENDINGS)[number];
+/** A CSS colour (`"#ff3b30"`, `"red"`, `"rgb(255 0 0)"`) or a hex number (`0xff3b30`). */
+export type ParticleColor = string | number;
+/** One value for the whole life, or `[start, end]` (linear over life). */
+export type ParticleOverLife = number | readonly [number, number];
+/** The most colours over life. */
+export declare const PARTICLE_MAX_COLORS = 4;
+/** The most particles one emitter keeps alive. */
+export declare const PARTICLE_MAX_PARTICLES = 65536;
+export type ParticleSettings = {
+    /** Particles per second. */
+    rate: number;
+    /** Seconds each particle lives. */
+    lifetime: number;
+    /** 0..1: each particle lives `lifetime × (1 − lifetimeJitter × random)`. */
+    lifetimeJitter: number;
+    /** Where particles start (the emitter's axes and units). */
+    shape: ParticleShape;
+    /** `sphere`: its radius. `cone`: its base radius (0 = from one point). */
+    radius: number;
+    /** `box`: its full size along x, y, z. */
+    boxSize: readonly [number, number, number];
+    /**
+     * Degrees around the emitter's +Z: `point` and `box` send particles within
+     * this angle, `cone` is a cone of this half angle (180 = every direction).
+     * `sphere` sends them outward.
+     */
+    angle: number;
+    /** `sphere` and `box`: start on the surface only. */
+    surface: boolean;
+    /** Start speed, units per second. */
+    speed: number;
+    /** 0..1: each particle starts at `speed × (1 − speedJitter × random)`. */
+    speedJitter: number;
+    /** Pull along the world's −Y, units per second² (negative floats up). */
+    gravity: number;
+    /** Constant push along the world's x, y, z, units per second². */
+    wind: readonly [number, number, number];
+    /** How fast speed decays, per second (0: none). With gravity or wind it sets the top speed. */
+    drag: number;
+    /** Size over life, units (the glow's width, the streak's thickness). */
+    size: ParticleOverLife;
+    /** 0..1: each particle is `size × (1 − sizeJitter × random)`. */
+    sizeJitter: number;
+    /** Colour over life: one colour, or up to 4 spread evenly from birth to death. */
+    color: ParticleColor | readonly ParticleColor[];
+    /** Opacity over life, 0..1. */
+    opacity: ParticleOverLife;
+    /** The built-in shape drawn. */
+    sprite: ParticleSprite;
+    /** `streak`: its length, as the seconds of motion it covers. */
+    stretch: number;
+    blending: ParticleBlending;
+    /** The most particles alive at once; 0 (default) sizes it from `rate × lifetime`. */
+    maxParticles: number;
+    /** The random sequence's seed: the same seed and inputs give the same particles. */
+    seed: number;
+};
+/** A generic emitter: a soft white spray along +Z, sized for centimetres. */
+export declare const DEFAULT_PARTICLE_SETTINGS: ParticleSettings;
+/** Valid ranges of the numeric fields (each component of `boxSize`, `wind`, `size`, `opacity`). */
+export declare const PARTICLE_SETTINGS_RANGES: {
+    readonly rate: readonly [0, 10000];
+    readonly lifetime: readonly [0.02, 30];
+    readonly lifetimeJitter: readonly [0, 1];
+    readonly radius: readonly [0, 10000];
+    readonly boxSize: readonly [0, 10000];
+    readonly angle: readonly [0, 180];
+    readonly speed: readonly [0, 100000];
+    readonly speedJitter: readonly [0, 1];
+    readonly gravity: readonly [-100000, 100000];
+    readonly wind: readonly [-100000, 100000];
+    readonly drag: readonly [0, 100];
+    readonly size: readonly [0, 10000];
+    readonly sizeJitter: readonly [0, 1];
+    readonly opacity: readonly [0, 1];
+    readonly stretch: readonly [0, 1];
+    readonly maxParticles: readonly [0, 65536];
+    readonly seed: readonly [-1000000000, 1000000000];
+};
+/** Everything the emitter and the shader read, complete and clamped. */
+export type ResolvedParticleSettings = Omit<ParticleSettings, "boxSize" | "wind" | "size" | "color" | "opacity"> & {
+    boxSize: [number, number, number];
+    wind: [number, number, number];
+    /** Size at birth and at death. */
+    size: [number, number];
+    /** Opacity at birth and at death. */
+    opacity: [number, number];
+    /** The colours over life, linear RGB, `colorCount` of them (1..4), 3 floats each. */
+    colors: Float32Array;
+    colorCount: number;
+    /** Particles kept (the ring's size): `maxParticles`, or enough for `rate × lifetime`. */
+    capacity: number;
+};
+/** A colour as linear RGB, or null when it cannot be read. */
+export declare const parseParticleColor: (value: unknown) => [number, number, number] | null;
+/**
+ * Particles to keep for `rate × lifetime` alive at once, with room for a
+ * slow frame's spawns: 10% more plus a tenth of a second's worth.
+ */
+export declare const particleCapacity: (rate: number, lifetime: number, maxParticles?: number) => number;
+/**
+ * Any partial settings → complete, clamped settings. Missing, non-finite or
+ * unknown values fall back to `base` (default `DEFAULT_PARTICLE_SETTINGS`);
+ * numbers clamp to `PARTICLE_SETTINGS_RANGES`; colours that cannot be read
+ * fall back as a whole; more than 4 colours keep the first 4.
+ */
+export declare const resolveParticleSettings: (input?: Partial<ParticleSettings>, base?: ParticleSettings) => ResolvedParticleSettings;

package/dist/particles/shapes.d.ts

@@ -0,0 +1,29 @@
+import { ResolvedParticleSettings } from './settings';
+/**
+ * Where a particle starts and which way it leaves (pure), in the emitter's
+ * own axes and units: +Z is forward. The emitter's world transform is
+ * applied when the particle is emitted (`spawnParticles`).
+ */
+/** A seeded random sequence in [0, 1) (mulberry32): the same seed gives the same numbers. */
+export type ParticleRandom = () => number;
+export declare const createParticleRandom: (seed: number) => ParticleRandom;
+/** A start point and a unit direction, written in place. */
+export type ParticleStart = {
+    position: [number, number, number];
+    direction: [number, number, number];
+};
+export declare const createParticleStart: () => ParticleStart;
+/** A direction within `angle` degrees of +Z, uniform over that cap of the sphere. */
+export declare const sampleParticleCone: (angle: number, random: ParticleRandom, out: [number, number, number]) => [number, number, number];
+/**
+ * One particle's start (the emitter's axes and units):
+ * - `point`: at the origin, leaving within `angle` of +Z;
+ * - `sphere`: inside the sphere of `radius` (on it with `surface`), leaving
+ *   outward from the centre;
+ * - `box`: inside the box of `boxSize` centred on the origin (on its faces
+ *   with `surface`), leaving within `angle` of +Z;
+ * - `cone`: on the disc of `radius` at the origin, facing +Z, leaving along
+ *   the cone of half angle `angle` (tilted outward by `angle × distance /
+ *   radius`; with radius 0, anywhere within `angle`).
+ */
+export declare const sampleParticleStart: (settings: Pick<ResolvedParticleSettings, "shape" | "radius" | "boxSize" | "angle" | "surface">, random: ParticleRandom, out?: ParticleStart) => ParticleStart;

package/dist/particles/spawner.d.ts

@@ -0,0 +1,60 @@
+import { ParticleRing } from './ring';
+import { ResolvedParticleSettings } from './settings';
+import { ParticleRandom } from './shapes';
+import * as THREE from "three";
+/**
+ * Emitting particles into the ring (pure, no GPU): each frame, the
+ * particles due are placed along the emitter's path from its last world
+ * transform to this one, at their own moments in the frame, and written as
+ * spawn records in world space. They keep their own path from then on.
+ */
+/** The emitter's mean world scale (world units per emitter unit). */
+export declare const particleUnitOf: (matrix: THREE.Matrix4) => number;
+/** One frame of the emitter's motion: its world transform and the clock (s) at the last frame and now. */
+export type ParticleSpawnFrame = {
+    from: THREE.Matrix4;
+    to: THREE.Matrix4;
+    timeFrom: number;
+    timeTo: number;
+};
+/**
+ * Writes one particle per birth moment (`births`, 0..1 through the frame)
+ * into `ring`. Settings are in the emitter's units: its world scale at the
+ * birth converts speed and size and is kept for gravity and wind. The random
+ * sequence advances by the same count per particle whatever the settings.
+ */
+export declare const spawnParticles: (ring: ParticleRing, settings: ResolvedParticleSettings, frame: ParticleSpawnFrame, births: readonly number[], random: ParticleRandom) => void;
+/**
+ * One emitter's particles on the CPU side: its settings, its ring of spawn
+ * records, its rate and random sequence, and its last pose. `update` once a
+ * frame with the emitter's world matrix and the clock; upload the ring's
+ * dirty slots after it.
+ */
+export declare class ParticleSpawner {
+    private ringValue;
+    private settingsValue;
+    private random;
+    private readonly emission;
+    private readonly births;
+    private readonly last;
+    private lastTime;
+    private readonly frame;
+    constructor(settings: ResolvedParticleSettings);
+    get ring(): ParticleRing;
+    get settings(): ResolvedParticleSettings;
+    /**
+     * 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(settings: ResolvedParticleSettings): void;
+    /**
+     * 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(matrix: THREE.Matrix4, time: number, emitting?: boolean): number;
+    /** Removes every particle and forgets the last pose (the next update starts again). */
+    reset(): void;
+}

package/dist/particles/system.d.ts

@@ -0,0 +1,64 @@
+import { ParticleRing } from './ring';
+import { ParticleSettings, ResolvedParticleSettings } from './settings';
+import * as THREE from "three";
+/**
+ * One emitter's particles on the GPU (no React): `mesh` draws every slot of
+ * the spawner's ring as an instanced quad, and `update` emits, uploads only
+ * the new slots and moves the clock. The mesh is in world space wherever it
+ * sits in the scene (its own transform is ignored).
+ */
+export type ParticleUniforms = {
+    uTime: THREE.IUniform<number>;
+    uDrag: THREE.IUniform<number>;
+    uAcceleration: THREE.IUniform<THREE.Vector3>;
+    uSize: THREE.IUniform<THREE.Vector2>;
+    uOpacity: THREE.IUniform<THREE.Vector2>;
+    uColors: THREE.IUniform<THREE.Vector3[]>;
+    uColorCount: THREE.IUniform<number>;
+    uSprite: THREE.IUniform<number>;
+    uStretch: THREE.IUniform<number>;
+};
+export declare const createParticleUniforms: () => ParticleUniforms;
+/** Writes resolved settings into the uniforms (everything but the clock). */
+export declare const applyParticleUniforms: (uniforms: ParticleUniforms, settings: ResolvedParticleSettings) => void;
+export declare class ParticleSystem {
+    /** Add it anywhere in the scene (its own transform is ignored); render order is yours to set. */
+    readonly mesh: THREE.Mesh<THREE.InstancedBufferGeometry, THREE.ShaderMaterial>;
+    readonly uniforms: ParticleUniforms;
+    private readonly spawner;
+    private buffer;
+    private bufferRing;
+    private epoch;
+    private readonly ranges;
+    private disposed;
+    constructor(settings?: Partial<ParticleSettings>, base?: ParticleSettings);
+    /** The settings in use (resolved). */
+    get settings(): ResolvedParticleSettings;
+    /** The spawn records (slots in use show their lifetime above 0). */
+    get ring(): ParticleRing;
+    /** The clock the shader draws at (s since the first update). */
+    get time(): number;
+    /**
+     * 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(settings: Partial<ParticleSettings>, base?: ParticleSettings): void;
+    /**
+     * 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(matrix: THREE.Matrix4, time: number, emitting?: boolean): number;
+    /** Particles alive now (counts the ring on the CPU: for a readout, not every frame). */
+    aliveCount(): number;
+    /** Removes every particle; the next update starts emitting again. */
+    reset(): void;
+    dispose(): void;
+    private apply;
+    /** A new ring (a capacity change) needs a new geometry around it. */
+    private syncRing;
+}

package/dist/particles.cjs

@@ -0,0 +1,122 @@
+"use strict";var je=Object.defineProperty;var Ge=(t,e,i)=>e in t?je(t,e,{enumerable:!0,configurable:!0,writable:!0,value:i}):t[e]=i;var p=(t,e,i)=>Ge(t,typeof e!="symbol"?e+"":e,i);Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const T=require("react/jsx-runtime"),W=require("@react-three/fiber"),R=require("react"),Ve=require("./selectors-C4X71aoD.cjs"),K=require("./index-DE17y0ZI.cjs"),Je=require("./index-CfSF8LXa.cjs"),re=require("./CanonicalHeadFrame-D-_T1OMU.cjs"),Be=require("three"),Ue=require("./useLandmarkPoseFit-Bg-h9BPb.cjs");function He(t){const e=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(t){for(const i in t)if(i!=="default"){const r=Object.getOwnPropertyDescriptor(t,i);Object.defineProperty(e,i,r.get?r:{enumerable:!0,get:()=>t[i]})}}return e.default=t,Object.freeze(e)}const f=He(Be),qe=["leftEye","rightEye","eyes"],Xe=[263,249,390,373,374,380,381,382,362,398,384,385,386,387,388,466],Ye=[33,7,163,144,145,153,154,155,133,173,157,158,159,160,161,246],Q=t=>{const e=[0,0,0];return t.forEach(i=>{for(let r=0;r<3;r+=1)e[r]+=re.CANONICAL_FACE_POSITIONS[i*3+r]/t.length}),e},se=.4,ae=(()=>{const t=Q(Xe),e=Q(Ye);return Object.freeze([(t[0]-e[0])/2,(t[1]+e[1])/2,(t[2]+e[2])/2+se])})(),oe=(t,e)=>{const[i,r,s]=ae;return[Je.personLeftSign(e)*(t==="left"?1:-1)*i,r,s]},ne=t=>t==="eyes"?["left","right"]:[t==="leftEye"?"left":"right"],ce=["point","sphere","box","cone"],le=["glow","streak"],fe=["additive","normal"],D=4,z=65536,L=Object.freeze({rate:60,lifetime:1.5,lifetimeJitter:.2,shape:"cone",radius:0,boxSize:Object.freeze([10,10,10]),angle:15,surface:!1,speed:30,speedJitter:.2,gravity:0,wind:Object.freeze([0,0,0]),drag:0,size:Object.freeze([1,.2]),sizeJitter:.3,color:"#ffffff",opacity:Object.freeze([1,0]),sprite:"glow",stretch:.05,blending:"additive",maxParticles:0,seed:1}),he={rate:[0,1e4],lifetime:[.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,z],seed:[-1e9,1e9]},I=(t,e,i,r)=>typeof t=="number"&&Number.isFinite(t)?Math.min(i,Math.max(e,t)):r,k=(t,e,i)=>typeof e=="string"&&t.includes(e)?e:i,Z=(t,[e,i],r)=>{const s=Array.isArray(t)?t:[];return[0,1,2].map(a=>I(s[a],e,i,r[a]))},ee=(t,[e,i],r)=>{const s=typeof r=="number"?[r,r]:r;if(typeof t=="number"){const o=I(t,e,i,s[0]);return[o,o]}const a=Array.isArray(t)?t:[];return[I(a[0],e,i,s[0]),I(a[1],e,i,s[1])]},v=new f.Color,pe=t=>typeof t=="number"&&Number.isFinite(t)?(v.setHex(Math.max(0,Math.min(16777215,Math.round(t)))),[v.r,v.g,v.b]):typeof t!="string"||t.trim()===""?null:(v.setRGB(-1,-1,-1),v.setStyle(t),v.r<0?null:[v.r,v.g,v.b]),$e=(t,e)=>{const i=s=>{const o=(Array.isArray(s)?s:[s]).slice(0,D).map(pe);return o.length>0&&o.every(Boolean)?o:null},r=i(t)??i(e)??[[1,1,1]];return{colors:Float32Array.from(r.flat()),colorCount:r.length}},ue=(t,e,i=0)=>{if(i>0)return Math.min(z,Math.ceil(i));const r=Math.max(0,t)*Math.max(0,e);return Math.min(z,Math.max(1,Math.ceil(r*1.1+Math.max(0,t)*.1)+8))},F=(t={},e=L)=>{const i=he,r=n=>I(t[n],i[n][0],i[n][1],e[n]),s=r("rate"),a=r("lifetime"),o=Math.round(r("maxParticles"));return{rate:s,lifetime:a,lifetimeJitter:r("lifetimeJitter"),shape:k(ce,t.shape,e.shape),radius:r("radius"),boxSize:Z(t.boxSize,i.boxSize,e.boxSize),angle:r("angle"),surface:typeof t.surface=="boolean"?t.surface:e.surface,speed:r("speed"),speedJitter:r("speedJitter"),gravity:r("gravity"),wind:Z(t.wind,i.wind,e.wind),drag:r("drag"),size:ee(t.size,i.size,e.size),sizeJitter:r("sizeJitter"),...$e(t.color,e.color),opacity:ee(t.opacity,i.opacity,e.opacity),sprite:k(le,t.sprite,e.sprite),stretch:r("stretch"),blending:k(fe,t.blending,e.blending),maxParticles:o,seed:r("seed"),capacity:ue(s,a,o)}},me=["laser"],de=Object.freeze({laser:Object.freeze({rate:900,lifetime:.3,lifetimeJitter:.15,shape:"cone",radius:.08,angle:.6,speed:260,speedJitter:.05,gravity:0,wind:[0,0,0],drag:0,size:[.5,.2],sizeJitter:.2,color:["#ffffff","#ff3b30","#7a0000"],opacity:[1,0],sprite:"streak",stretch:.08,blending:"additive"})}),ye=t=>typeof t=="string"&&me.includes(t),Ee=t=>ye(t)?{...L,...de[t]}:L,A=12,b=Object.freeze({position:0,birth:3,velocity:4,lifetime:7,sizeScale:8,unit:9,seed:10}),Se=()=>({position:[0,0,0],velocity:[0,0,0],birth:0,lifetime:0,sizeScale:1,unit:1,seed:0});class j{constructor(e){p(this,"capacity");p(this,"data");p(this,"head",0);p(this,"dirtyFirst",0);p(this,"dirtyCount",0);this.capacity=Math.max(1,Math.floor(e)),this.data=new Float32Array(this.capacity*A)}get next(){return this.head}push(e){const i=this.head,r=i*A,s=this.data,a=b;return s[r+a.position]=e.position[0],s[r+a.position+1]=e.position[1],s[r+a.position+2]=e.position[2],s[r+a.birth]=e.birth,s[r+a.velocity]=e.velocity[0],s[r+a.velocity+1]=e.velocity[1],s[r+a.velocity+2]=e.velocity[2],s[r+a.lifetime]=e.lifetime,s[r+a.sizeScale]=e.sizeScale,s[r+a.unit]=e.unit,s[r+a.seed]=e.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}takeDirty(e=[]){e.length=0;const i=this.dirtyCount;if(i===0)return e;if(i>=this.capacity)e.push([0,this.capacity]);else{const r=this.dirtyFirst,s=r+i;s<=this.capacity?e.push([r,i]):e.push([r,this.capacity-r],[0,s-this.capacity])}return this.dirtyCount=0,e}clear(){this.data.fill(0),this.head=0,this.dirtyFirst=0,this.dirtyCount=this.capacity}aliveAt(e){const i=this.data;let r=0;for(let s=0;s<i.length;s+=A){const a=e-i[s+b.birth];a>=0&&a<i[s+b.lifetime]&&(r+=1)}return r}}const O=.01,ge=(t,e)=>{const i=t*e;return i<O?e*(1-i/2+i*i/6-i*i*i/24):(1-Math.exp(-i))/t},ve=(t,e)=>{const i=t*e;return i<O?e*e*(.5-i/6+i*i/24-i*i*i/120):(e-(1-Math.exp(-i))/t)/t},B=(t,e=[0,0,0])=>(e[0]=t.wind[0],e[1]=t.wind[1]-t.gravity,e[2]=t.wind[2],e),G=(t,e)=>t[0]+(t[1]-t[0])*e,Re=(t,e,i=[0,0,0])=>{const{colors:r,colorCount:s}=t,a=Math.min(1,Math.max(0,e))*(s-1),o=Math.min(s-1,Math.floor(a)),n=Math.min(s-1,o+1),c=a-o;for(let l=0;l<3;l+=1)i[l]=r[o*3+l]+(r[n*3+l]-r[o*3+l])*c;return i},Ae=()=>({alive:!1,age:0,life:0,position:[0,0,0],velocity:[0,0,0],size:0,opacity:0,color:[0,0,0]}),te=[0,0,0],We=(t,e,i,r,s=Ae())=>{const a=e*A,o=b,n=t[a+o.lifetime],c=i-t[a+o.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 h=r.drag,u=ge(h,l),g=ve(h,l),P=Math.exp(-h*l),m=t[a+o.unit];B(r,te);for(let d=0;d<3;d+=1){const M=te[d]*m,y=t[a+o.velocity+d];s.position[d]=t[a+o.position+d]+y*u+M*g,s.velocity[d]=y*P+M*u}return s.size=G(r.size,s.life)*t[a+o.sizeScale],s.opacity=G(r.opacity,s.life),Re(r,s.life,s.color),s},Ke=t=>Number.isInteger(t)?`${t}.0`:`${t}`,Pe=`
+uniform float uTime;
+uniform float uDrag;
+uniform vec3 uAcceleration;
+uniform vec2 uSize;
+uniform vec2 uOpacity;
+uniform vec3 uColors[${D}];
+uniform float uColorCount;
+
+const float PARTICLE_DRAG_SERIES_LIMIT = ${Ke(O)};
+
+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;
+}
+`,Te=`
+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);
+}
+`,Ce=`
+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>
+}
+`,xe=.25,Me=()=>({carry:0}),_e=(t,e,i,r=[],s=1/0)=>{if(r.length=0,!(e>0)||!(i>0))return r;const a=Math.min(xe,i),o=t.carry+e*a,n=Math.floor(o),c=Math.max(0,n-Math.max(0,Math.floor(s)));for(let l=c;l<n;l+=1){const h=(l+1-t.carry)/e;r.push(Math.min(1,(i-a+h)/i))}return t.carry=o-n,r},V=t=>{let e=Math.floor(t)>>>0;return()=>{e=e+1831565813>>>0;let i=e;return i=Math.imul(i^i>>>15,i|1),i^=i+Math.imul(i^i>>>7,i|61),((i^i>>>14)>>>0)/4294967296}},U=()=>({position:[0,0,0],direction:[0,0,1]}),Ie=Math.PI/180,w=(t,e,i)=>{const r=Math.cos(Math.min(180,Math.max(0,t))*Ie),s=1-e()*(1-r),a=Math.sqrt(Math.max(0,1-s*s)),o=e()*2*Math.PI;return i[0]=a*Math.cos(o),i[1]=a*Math.sin(o),i[2]=s,i},Qe=(t,e)=>w(180,t,e),be=(t,e,i=U())=>{const r=i.position,s=i.direction;switch(r[0]=0,r[1]=0,r[2]=0,t.shape){case"sphere":{Qe(e,s);const a=t.radius*(t.surface?1:Math.cbrt(e()));r[0]=s[0]*a,r[1]=s[1]*a,r[2]=s[2]*a;break}case"box":{const[a,o,n]=t.boxSize;if(r[0]=(e()-.5)*a,r[1]=(e()-.5)*o,r[2]=(e()-.5)*n,t.surface){const c=[o*n,a*n,a*o],l=c[0]+c[1]+c[2];let h=e()*(l>0?l:3),u=0;if(l>0)for(;u<2&&h>=c[u];)h-=c[u],u+=1;else u=Math.min(2,Math.floor(h));r[u]=(e()<.5?-.5:.5)*t.boxSize[u]}w(t.angle,e,s);break}case"cone":{const a=t.radius;if(a>0){const o=Math.sqrt(e()),n=e()*2*Math.PI,c=Math.cos(n),l=Math.sin(n);r[0]=a*o*c,r[1]=a*o*l;const h=Math.min(180,t.angle)*Ie*o;s[0]=Math.sin(h)*c,s[1]=Math.sin(h)*l,s[2]=Math.cos(h)}else w(t.angle,e,s);break}default:w(t.angle,e,s)}return i},J=t=>{const e=t.elements,i=Math.hypot(e[0],e[1],e[2]),r=Math.hypot(e[4],e[5],e[6]),s=Math.hypot(e[8],e[9],e[10]);return(i+r+s)/3},N=U(),S=Se(),x=new f.Vector3,E=new f.Vector3,_=new f.Vector3,we=(t,e,i,r,s)=>{const a=J(i.from),o=J(i.to);for(let n=0;n<r.length;n+=1){const c=r[n];be(e,s,N);const l=s(),h=s(),u=s(),g=s();x.fromArray(N.position),E.copy(x).applyMatrix4(i.from),_.copy(x).applyMatrix4(i.to),E.lerp(_,c),S.position[0]=E.x,S.position[1]=E.y,S.position[2]=E.z,x.fromArray(N.direction),E.copy(x).transformDirection(i.from),_.copy(x).transformDirection(i.to),E.lerp(_,c),E.lengthSq()>1e-12?E.normalize():E.copy(_);const P=a+(o-a)*c,m=e.speed*(1-e.speedJitter*l)*P;S.velocity[0]=E.x*m,S.velocity[1]=E.y*m,S.velocity[2]=E.z*m,S.birth=i.timeFrom+(i.timeTo-i.timeFrom)*c,S.lifetime=e.lifetime*(1-e.lifetimeJitter*h),S.sizeScale=(1-e.sizeJitter*u)*P,S.unit=P,S.seed=g,t.push(S)}};class Le{constructor(e){p(this,"ringValue");p(this,"settingsValue");p(this,"random");p(this,"emission",Me());p(this,"births",[]);p(this,"last",new f.Matrix4);p(this,"lastTime",null);p(this,"frame",{from:new f.Matrix4,to:new f.Matrix4,timeFrom:0,timeTo:0});this.settingsValue=e,this.ringValue=new j(e.capacity),this.random=V(e.seed)}get ring(){return this.ringValue}get settings(){return this.settingsValue}setSettings(e){const i=this.settingsValue;this.settingsValue=e,e.capacity!==i.capacity&&(this.ringValue=new j(e.capacity),this.ringValue.clear()),e.seed!==i.seed&&(this.random=V(e.seed))}update(e,i,r=!0){const s=this.lastTime;if(this.lastTime=i,s===null||!r||!(i>s))return this.last.copy(e),r||(this.emission.carry=0),0;const a=this.settingsValue;_e(this.emission,a.rate,i-s,this.births,this.ringValue.capacity);const o=this.frame;return o.from.copy(this.last),o.to.copy(e),o.timeFrom=s,o.timeTo=i,we(this.ringValue,a,o,this.births,this.random),this.last.copy(e),this.births.length}reset(){this.ringValue.clear(),this.emission.carry=0,this.lastTime=null}}const ze=()=>({uTime:{value:0},uDrag:{value:0},uAcceleration:{value:new f.Vector3},uSize:{value:new f.Vector2(1,1)},uOpacity:{value:new f.Vector2(1,1)},uColors:{value:Array.from({length:D},()=>new f.Vector3(1,1,1))},uColorCount:{value:1},uSprite:{value:0},uStretch:{value:0}}),De=(t,e)=>{t.uDrag.value=e.drag,t.uAcceleration.value.fromArray(B(e)),t.uSize.value.set(e.size[0],e.size[1]),t.uOpacity.value.set(e.opacity[0],e.opacity[1]),t.uColors.value.forEach((i,r)=>{const s=Math.min(r,e.colorCount-1)*3;i.set(e.colors[s],e.colors[s+1],e.colors[s+2])}),t.uColorCount.value=e.colorCount,t.uSprite.value=e.sprite==="streak"?1:0,t.uStretch.value=e.stretch},Ze=[-1,-1,0,1,-1,0,1,1,0,-1,1,0],et=[0,1,2,0,2,3],ie=t=>{const e=new f.InstancedBufferGeometry;e.setAttribute("position",new f.Float32BufferAttribute(Ze,3)),e.setIndex(et);const i=new f.InstancedInterleavedBuffer(t.data,A,1);return i.setUsage(f.DynamicDrawUsage),e.setAttribute("aStart",new f.InterleavedBufferAttribute(i,4,0)),e.setAttribute("aMotion",new f.InterleavedBufferAttribute(i,4,4)),e.setAttribute("aExtra",new f.InterleavedBufferAttribute(i,4,8)),e.instanceCount=t.capacity,e.boundingSphere=new f.Sphere(new f.Vector3,1/0),{geometry:e,buffer:i}};class Oe{constructor(e={},i){p(this,"mesh");p(this,"uniforms",ze());p(this,"spawner");p(this,"buffer");p(this,"bufferRing");p(this,"epoch",null);p(this,"ranges",[]);p(this,"disposed",!1);const r=F(e,i);this.spawner=new Le(r),this.bufferRing=this.spawner.ring;const{geometry:s,buffer:a}=ie(this.bufferRing);this.buffer=a;const o=new f.ShaderMaterial({name:"Particles",uniforms:this.uniforms,vertexShader:Te,fragmentShader:Ce,transparent:!0,depthTest:!0,depthWrite:!1,side:f.DoubleSide,toneMapped:!1});this.mesh=new f.Mesh(s,o),this.mesh.name="Particles",this.mesh.frustumCulled=!1,this.mesh.matrixAutoUpdate=!1,this.mesh.raycast=()=>{},this.apply(r)}get settings(){return this.spawner.settings}get ring(){return this.spawner.ring}get time(){return this.uniforms.uTime.value}setSettings(e,i=L){const r=F(e,i);this.spawner.setSettings(r),this.apply(r)}update(e,i,r=!0){if(this.disposed)return 0;this.epoch===null&&(this.epoch=i);const s=i-this.epoch,a=this.spawner.update(e,s,r);return this.syncRing(),this.spawner.ring.takeDirty(this.ranges),this.ranges.length>0&&(this.ranges.forEach(([o,n])=>this.buffer.addUpdateRange(o*A,n*A)),this.buffer.needsUpdate=!0),this.uniforms.uTime.value=s,a}aliveCount(){return this.spawner.ring.aliveAt(Math.fround(this.uniforms.uTime.value))}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(e){De(this.uniforms,e),this.mesh.material.blending=e.blending==="additive"?f.AdditiveBlending:f.NormalBlending,this.syncRing()}syncRing(){const e=this.spawner.ring;if(e===this.bufferRing||!this.mesh)return;this.mesh.geometry.dispose();const{geometry:i,buffer:r}=ie(e);this.mesh.geometry=i,this.buffer=r,this.bufferRing=e}}const tt=t=>{for(let e=t;e;e=e.parent)if(!e.visible)return!1;return!0},H=R.forwardRef(({base:t,emitting:e=!0,renderOrder:i=0,position:r,rotation:s,scale:a,onSystem:o,children:n,...c},l)=>{const h=W.useThree(y=>y.scene),u=W.useThree(y=>y.get),g=R.useRef(null);R.useImperativeHandle(l,()=>g.current,[]);const P=JSON.stringify(c),m=R.useRef({settings:c,base:t,emitting:e,onSystem:o});m.current={settings:c,base:t,emitting:e,onSystem:o};const[d,M]=R.useState(null);return R.useEffect(()=>{var q,X;const y=new Oe(m.current.settings,m.current.base);h.add(y.mesh);const Fe=Ue.addSceneBeforeRender(h,()=>{const C=g.current;C&&y.update(C.matrixWorld,u().clock.elapsedTime,m.current.emitting&&tt(C))});return M(y),(X=(q=m.current).onSystem)==null||X.call(q,y),()=>{var C,Y;Fe(),h.remove(y.mesh),y.dispose(),(Y=(C=m.current).onSystem)==null||Y.call(C,null),M($=>$===y?null:$)}},[h,u]),R.useEffect(()=>{d==null||d.setSettings(m.current.settings,m.current.base)},[d,P,t]),d&&(d.mesh.renderOrder=i),T.jsx("group",{ref:g,position:r,rotation:s,scale:a,children:n})});H.displayName="Emitter";const ke=R.forwardRef(({target:t,faceIndex:e,numFaces:i,base:r,seed:s,...a},o)=>{const n=K.useTrackerContext(),c=Ve.useXRMirrored(),l=s??r.seed,h=T.jsx(re.CanonicalHeadFrame,{faceIndex:e,children:ne(t).map((u,g)=>T.jsx("group",{position:oe(u,c),children:T.jsx(H,{ref:g===0?o:void 0,base:r,seed:l+g,...a})},u))});return(n==null?void 0:n.type)==="face"?h:T.jsx(K.FaceTracker,{faceIndex:e??0,numFaces:i,children:h})});ke.displayName="EyeEmitters";const Ne=R.forwardRef(({preset:t,target:e,faceIndex:i,numFaces:r,...s},a)=>{const o=R.useMemo(()=>Ee(t),[t]);return e?T.jsx(ke,{ref:a,target:e,faceIndex:i,numFaces:r,base:o,...s}):T.jsx(H,{ref:a,base:o,...s})});Ne.displayName="ParticleEmitter";exports.DEFAULT_PARTICLE_SETTINGS=L;exports.PARTICLE_BLENDINGS=fe;exports.PARTICLE_DRAG_SERIES_LIMIT=O;exports.PARTICLE_EMITTER_TARGETS=qe;exports.PARTICLE_EYE_CENTRE=ae;exports.PARTICLE_EYE_FORWARD=se;exports.PARTICLE_FRAGMENT_SHADER=Ce;exports.PARTICLE_MAX_COLORS=D;exports.PARTICLE_MAX_PARTICLES=z;exports.PARTICLE_MAX_STEP=xe;exports.PARTICLE_PRESETS=de;exports.PARTICLE_PRESET_KEYS=me;exports.PARTICLE_RECORD=b;exports.PARTICLE_RECORD_FLOATS=A;exports.PARTICLE_SETTINGS_RANGES=he;exports.PARTICLE_SHAPES=ce;exports.PARTICLE_SPRITES=le;exports.PARTICLE_STATE_GLSL=Pe;exports.PARTICLE_VERTEX_SHADER=Te;exports.ParticleEmitter=Ne;exports.ParticleRing=j;exports.ParticleSpawner=Le;exports.ParticleSystem=Oe;exports.applyParticleUniforms=De;exports.createParticleEmission=Me;exports.createParticleRandom=V;exports.createParticleRecord=Se;exports.createParticleSample=Ae;exports.createParticleStart=U;exports.createParticleUniforms=ze;exports.isParticlePreset=ye;exports.parseParticleColor=pe;exports.particleAcceleration=B;exports.particleCapacity=ue;exports.particleColorAt=Re;exports.particleDragAcceleration=ve;exports.particleDragDistance=ge;exports.particleEyePosition=oe;exports.particleOverLife=G;exports.particlePresetBase=Ee;exports.particleTargetSides=ne;exports.particleUnitOf=J;exports.resolveParticleSettings=F;exports.sampleParticle=We;exports.sampleParticleCone=w;exports.sampleParticleStart=be;exports.spawnParticles=we;exports.stepParticleEmission=_e;