@nayan-ui/engine 0.0.0-stage → 1.0.0-beta.3

package/lib/module/world/desc.js

@@ -0,0 +1,186 @@
+"use strict";
+
+// Encodes entity options into the flat layout the Rust core decodes (native/core/include/engine_core.h,
+// native/core/src/world/desc.rs). One reusable Float64Array per world: spawning or changing an entity is
+// a single native call, and doubles keep entity ids and layer bits exact.
+
+export const DESC_LEN = 64;
+const FLAG = {
+  MESH: 1 << 0,
+  POSITION: 1 << 1,
+  ROTATION: 1 << 2,
+  SCALE: 1 << 3,
+  COLOR: 1 << 4,
+  VELOCITY: 1 << 5,
+  GROUND_VELOCITY: 1 << 6,
+  SPIN: 1 << 7,
+  BOB: 1 << 8,
+  FOLLOW: 1 << 9,
+  LIFETIME: 1 << 10,
+  PARENT: 1 << 11,
+  PHYSICS: 1 << 12,
+  IMPACT: 1 << 13,
+  ACCELERATION: 1 << 14,
+  PICKABLE: 1 << 15,
+  REGION: 1 << 16
+};
+const SLOT = {
+  FLAGS: 0,
+  MESH: 1,
+  POSITION: 2,
+  ROTATION: 5,
+  SCALE: 9,
+  COLOR: 12,
+  VELOCITY: 16,
+  GROUND_VELOCITY: 19,
+  SPIN: 21,
+  BOB: 24,
+  FOLLOW: 29,
+  LIFETIME: 31,
+  PARENT: 32,
+  PHYSICS: 33,
+  IMPACT: 50,
+  ACCELERATION: 56,
+  PICKABLE: 59,
+  REGION: 60
+};
+const BODY_KIND = {
+  dynamic: 1,
+  kinematic: 2,
+  fixed: 3
+};
+const SHAPE = {
+  ball: 0,
+  box: 1,
+  fromMesh: 2,
+  cylinder: 3,
+  capsule: 4,
+  cone: 5
+};
+function encodePhysics(d, physics) {
+  const p = SLOT.PHYSICS;
+  const shape = physics.shape !== undefined ? SHAPE[physics.shape] : physics.size !== undefined ? SHAPE.box : physics.radius !== undefined ? SHAPE.ball : SHAPE.fromMesh;
+  // Sizes <= 0 tell the core to size the collider from the entity's mesh and scale.
+  const [sx, sy, sz] = shape === SHAPE.box ? physics.size ? [physics.size[0] / 2, physics.size[1] / 2, physics.size[2] / 2] : [0, 0, 0] : [physics.radius ?? 0, (physics.height ?? 0) / 2, 0];
+  d[p] = BODY_KIND[physics.type];
+  d[p + 1] = shape;
+  d[p + 2] = sx;
+  d[p + 3] = sy;
+  d[p + 4] = sz;
+  d[p + 5] = physics.layer ?? 1;
+  d[p + 6] = physics.mask ?? -1; // all layers
+  d[p + 7] = physics.sensor ? 1 : 0;
+  d[p + 8] = physics.friction ?? 0.5;
+  d[p + 9] = physics.bounce ?? 0;
+  d[p + 10] = physics.density ?? 1;
+  d[p + 11] = physics.drag ?? 0;
+  d[p + 12] = physics.angularDrag ?? 0.05;
+  d[p + 13] = physics.gravityScale ?? 1;
+  d[p + 14] = physics.upright ? 1 : 0;
+  d[p + 15] = physics.ccd ? 1 : 0;
+  d[p + 16] = physics.planar ? 1 : 0;
+}
+
+/** Writes `options` into `d`, with the mesh id already resolved. Only the fields present are flagged. */
+export function encode(d, o, mesh) {
+  let flags = 0;
+  if (mesh !== undefined) {
+    flags |= FLAG.MESH;
+    d[SLOT.MESH] = mesh;
+  }
+  if (o.position) {
+    flags |= FLAG.POSITION;
+    d.set(o.position, SLOT.POSITION);
+  }
+  if (o.rotation) {
+    flags |= FLAG.ROTATION;
+    d.set(o.rotation, SLOT.ROTATION);
+  }
+  if (o.scale !== undefined) {
+    flags |= FLAG.SCALE;
+    if (typeof o.scale === 'number') d.fill(o.scale, SLOT.SCALE, SLOT.SCALE + 3);else d.set(o.scale, SLOT.SCALE);
+  }
+  if (o.color) {
+    flags |= FLAG.COLOR;
+    d[SLOT.COLOR] = o.color[0];
+    d[SLOT.COLOR + 1] = o.color[1];
+    d[SLOT.COLOR + 2] = o.color[2];
+    d[SLOT.COLOR + 3] = o.color[3] ?? 1;
+  }
+  if (o.velocity) {
+    flags |= FLAG.VELOCITY;
+    d.set(o.velocity, SLOT.VELOCITY);
+  }
+  if (o.groundVelocity) {
+    flags |= FLAG.GROUND_VELOCITY;
+    d.set(o.groundVelocity, SLOT.GROUND_VELOCITY);
+  }
+  if (o.spin) {
+    flags |= FLAG.SPIN;
+    d.set(o.spin, SLOT.SPIN);
+  }
+  if (o.bob !== undefined) {
+    flags |= FLAG.BOB;
+    d.set(o.bob?.amplitude ?? [0, 0, 0], SLOT.BOB);
+    d[SLOT.BOB + 3] = o.bob?.speed ?? 0;
+    d[SLOT.BOB + 4] = o.bob?.phase ?? 0;
+  }
+  if (o.follow !== undefined) {
+    flags |= FLAG.FOLLOW;
+    d[SLOT.FOLLOW] = o.follow?.target ?? -1;
+    d[SLOT.FOLLOW + 1] = o.follow?.speed ?? 0;
+  }
+  if (o.lifetime !== undefined) {
+    flags |= FLAG.LIFETIME;
+    d[SLOT.LIFETIME] = o.lifetime ?? 0;
+  }
+  if (o.parent !== undefined) {
+    flags |= FLAG.PARENT;
+    d[SLOT.PARENT] = o.parent ?? -1;
+  }
+  if (o.physics !== undefined) {
+    flags |= FLAG.PHYSICS;
+    if (o.physics === null) d[SLOT.PHYSICS] = 0;else encodePhysics(d, typeof o.physics === 'string' ? {
+      type: o.physics
+    } : o.physics);
+  }
+  if (o.impact !== undefined) {
+    flags |= FLAG.IMPACT;
+    const i = SLOT.IMPACT;
+    d[i] = o.impact ? 1 : 0;
+    d[i + 1] = o.impact?.sound ?? -1;
+    d[i + 2] = o.impact?.minSpeed ?? 1;
+    d[i + 3] = o.impact?.maxSpeed ?? 10;
+    d[i + 4] = o.impact?.volume ?? 1;
+    d[i + 5] = o.impact?.haptic ?? 0;
+  }
+  if (o.acceleration) {
+    flags |= FLAG.ACCELERATION;
+    d.set(o.acceleration, SLOT.ACCELERATION);
+  }
+  if (o.pickable !== undefined) {
+    flags |= FLAG.PICKABLE;
+    d[SLOT.PICKABLE] = o.pickable ? 1 : 0;
+  }
+  if (o.textureRegion) {
+    flags |= FLAG.REGION;
+    d.set(o.textureRegion, SLOT.REGION);
+  }
+  d[SLOT.FLAGS] = flags;
+}
+
+// ── Animations and bursts (layouts in native/core/include/engine_core.h) ─────────
+
+export const ANIM_HEADER = 12;
+export const ANIM_KEY_LEN = 23;
+export const BURST_LEN = 36;
+export const EASING = {
+  linear: 0,
+  easeIn: 1,
+  easeOut: 2,
+  easeInOut: 3,
+  back: 4,
+  bounce: 5,
+  elastic: 6
+};
+//# sourceMappingURL=desc.js.map

package/lib/module/world/effects.js

@@ -0,0 +1,451 @@
+"use strict";
+
+// Ready-made particle effects and the cleared-piece pop, built from `world.burst` and `world.animate`.
+//
+// A single burst gives every particle 50..100% of one top speed, so on its own it flies out as a
+// hollow shell of same-sized bits that pop out of existence. These effects mix a few bursts instead:
+// slow big pieces that fill the middle and fast small ones at the edge, an additive glow that flashes
+// at the source (visible on dark scenes, harmless on light ones), and soft puffs that linger and fade.
+// Every particle takes a world slot, out of the capacity shared with the game's own entities, so the
+// counts stay close to what was passed in. Effects run entirely in the Rust core after one call each.
+
+/** Shared options of the layered effects (confetti, sparkle, shatter, splash, sparks, explosion). */
+
+/** A soft cloud of puffs that swell and fade: landing dust, kicked-up sand, sawdust, steam, muzzle smoke. */
+
+/** One glow that swells and fades at a point: a hit, a strike, a muzzle flash. */
+
+/** The cleared-piece pop: swell, flash white, settle, shrink away. */
+
+const rgba = c => [c[0], c[1], c[2], c[3] ?? 1];
+const list = colors => typeof colors[0] === 'number' ? [rgba(colors)] : colors.map(rgba);
+const part = (count, share) => Math.max(1, Math.round(count * share));
+const fade = c => [c[0], c[1], c[2], 0];
+
+/** The colors' average. */
+function mean(colors) {
+  const sum = [0, 0, 0, 0];
+  for (const c of colors) for (let i = 0; i < 4; i++) sum[i] += c[i];
+  return sum.map(v => v / colors.length);
+}
+
+/** The same hue, self-lit: its brightest channel lifted to `peak` (above 1 glows, through light, shadow and fog). */
+function hot(c, peak = 2.2, alpha = c[3] ?? 1) {
+  const k = peak / Math.max(c[0], c[1], c[2], 0.25);
+  return [c[0] * k, c[1] * k, c[2] * k, alpha];
+}
+
+/** Part way (`t`, 0..1) to white, with `alpha`. */
+function pale(c, t, alpha = c[3] ?? 1) {
+  return [c[0] + (1 - c[0]) * t, c[1] + (1 - c[1]) * t, c[2] + (1 - c[2]) * t, alpha];
+}
+function aim(e) {
+  return {
+    position: e.position,
+    direction: e.direction ?? [0, 1, 0],
+    spread: e.spread ?? Math.PI
+  };
+}
+function flash(world, o) {
+  return world.burst({
+    position: o.position,
+    count: o.count ?? 1,
+    mesh: o.mesh ?? 'flame',
+    size: o.size,
+    speed: o.speed ?? 0,
+    lifetime: o.lifetime ?? 0.22,
+    gravity: 0,
+    color: o.color,
+    endSize: o.endSize ?? 2.2,
+    endColor: o.endColor ?? fade(o.color)
+  });
+}
+
+/** A glow that swells and fades at the source, in the effect's own hue. */
+function glowFlash(world, e, colors, size) {
+  flash(world, {
+    position: e.position,
+    color: hot(mean(colors), 2, 0.85),
+    size
+  });
+}
+function dust(world, o) {
+  const single = typeof o.color[0] === 'number';
+  return world.burst({
+    position: o.position,
+    count: o.count,
+    mesh: o.mesh ?? 'puff',
+    size: o.size,
+    speed: o.speed,
+    lifetime: o.lifetime,
+    gravity: o.gravity ?? 0,
+    direction: o.direction,
+    spread: o.spread,
+    color: o.color,
+    endSize: o.endSize ?? 2,
+    endColor: o.endColor ?? (single ? fade(o.color) : undefined)
+  });
+}
+
+/** Celebration confetti: tumbling paper in two layers, a few glinting sparkles, and a pop of light. */
+function confetti(world, e) {
+  const colors = list(e.colors);
+  const g = (e.gravity ?? 0) * 0.65; // paper drifts down rather than dropping
+  const base = {
+    ...aim(e),
+    mesh: 'cube',
+    gravity: g,
+    color: colors,
+    endSize: 0.3
+  };
+  world.burst({
+    ...base,
+    count: part(e.count, 0.55),
+    size: e.size,
+    speed: e.speed,
+    lifetime: e.lifetime * 1.15
+  });
+  world.burst({
+    ...base,
+    count: part(e.count, 0.3),
+    size: e.size * 0.7,
+    speed: e.speed * 0.5,
+    lifetime: e.lifetime
+  });
+  const glint = colors.slice(0, 4).map(c => hot(pale(c, 0.5, 1), 2.4));
+  world.burst({
+    ...aim(e),
+    count: part(e.count, 0.15),
+    mesh: 'flame',
+    size: e.size * 1.1,
+    speed: e.speed * 0.8,
+    lifetime: e.lifetime * 0.8,
+    gravity: g * 0.5,
+    color: glint,
+    endSize: 0
+  });
+  if (e.flash !== false) glowFlash(world, e, [[1, 0.95, 0.8, 1]], e.size * 7);
+}
+
+/** Glitter for a reward: solid bright beads (seen on any background) with additive glints around them. */
+function sparkle(world, e) {
+  const colors = list(e.colors);
+  const bright = colors.map(c => hot(c, 1.4));
+  const base = {
+    ...aim(e),
+    gravity: e.gravity ?? 0,
+    endSize: 0
+  };
+  world.burst({
+    ...base,
+    count: part(e.count, 0.35),
+    mesh: 'sphere',
+    size: e.size,
+    speed: e.speed,
+    lifetime: e.lifetime,
+    color: bright
+  });
+  world.burst({
+    ...base,
+    count: part(e.count, 0.25),
+    mesh: 'sphere',
+    size: e.size * 1.3,
+    speed: e.speed * 0.45,
+    lifetime: e.lifetime * 0.85,
+    color: bright
+  });
+  world.burst({
+    ...base,
+    count: part(e.count, 0.4),
+    mesh: 'flame',
+    size: e.size * 1.6,
+    speed: e.speed * 0.8,
+    lifetime: e.lifetime * 0.9,
+    color: colors.map(c => hot(pale(c, 0.35, 1), 2.4))
+  });
+  if (e.flash !== false) glowFlash(world, e, colors, e.size * 6);
+}
+
+/**
+ * Something breaking apart: big slow chunks, small fast crumbs, a glow at the break and a puff of
+ * its dust. `mesh` is the chunks' shape.
+ */
+function shatter(world, e) {
+  const colors = list(e.colors);
+  const mesh = e.mesh ?? 'cube';
+  const base = {
+    ...aim(e),
+    gravity: e.gravity ?? 0,
+    color: colors
+  };
+  world.burst({
+    ...base,
+    count: part(e.count, 0.55),
+    mesh,
+    size: e.size * 1.1,
+    speed: e.speed * 0.65,
+    lifetime: e.lifetime,
+    endSize: 0.2
+  });
+  world.burst({
+    ...base,
+    count: part(e.count, 0.6),
+    mesh,
+    size: e.size * 0.5,
+    speed: e.speed * 1.1,
+    lifetime: e.lifetime * 0.85,
+    endSize: 0
+  });
+  if (e.flash !== false) glowFlash(world, e, colors, e.size * 3);
+  if (e.dust !== false) {
+    const c = pale(mean(colors), 0.45, 0.5);
+    world.burst({
+      ...aim(e),
+      count: 2,
+      mesh: 'puff',
+      size: e.size * 2,
+      speed: e.speed * 0.2,
+      lifetime: e.lifetime * 0.9,
+      gravity: 0,
+      color: c,
+      endSize: 2.4,
+      endColor: fade(c)
+    });
+  }
+}
+
+/** Liquid: droplets in two sizes thrown out of a fine mist of the same color. */
+function splash(world, e) {
+  const colors = list(e.colors);
+  const base = {
+    ...aim(e),
+    mesh: 'sphere',
+    gravity: e.gravity ?? 0,
+    color: colors
+  };
+  world.burst({
+    ...base,
+    count: part(e.count, 0.6),
+    size: e.size,
+    speed: e.speed,
+    lifetime: e.lifetime,
+    endSize: 0.3
+  });
+  world.burst({
+    ...base,
+    count: part(e.count, 0.4),
+    size: e.size * 1.5,
+    speed: e.speed * 0.45,
+    lifetime: e.lifetime * 0.8,
+    endSize: 0.2
+  });
+  const mist = pale(mean(colors), 0.2, 0.55);
+  world.burst({
+    ...aim(e),
+    count: 3,
+    mesh: 'puff',
+    size: e.size * 3,
+    speed: e.speed * 0.25,
+    lifetime: e.lifetime * 0.7,
+    gravity: 0,
+    color: mist,
+    endSize: 2.2,
+    endColor: fade(mist)
+  });
+  if (e.flash !== false) glowFlash(world, e, colors, e.size * 4);
+}
+
+/** Hot metal sparks: additive streaks that burn out, with a few solid beads and a flash where they strike. */
+function sparks(world, e) {
+  const colors = list(e.colors).map(c => hot(c, 2.6));
+  const base = {
+    ...aim(e),
+    gravity: e.gravity ?? 0,
+    color: colors,
+    endSize: 0
+  };
+  world.burst({
+    ...base,
+    count: part(e.count, 0.7),
+    mesh: 'flame',
+    size: e.size * 1.6,
+    speed: e.speed,
+    lifetime: e.lifetime
+  });
+  world.burst({
+    ...base,
+    count: part(e.count, 0.3),
+    mesh: 'sphere',
+    size: e.size * 0.6,
+    speed: e.speed * 1.1,
+    lifetime: e.lifetime * 0.8
+  });
+  if (e.flash !== false) glowFlash(world, e, colors, e.size * 5);
+}
+const FIRE = [[2.6, 2.4, 1.8, 1], [2.4, 1.5, 0.45, 0.95], [2.2, 0.8, 0.2, 0.85]];
+const EMBERS = [[2.8, 2.2, 1, 1], [2.6, 1.3, 0.3, 1]];
+
+/**
+ * A fiery blast: a white-hot flash, a fireball that cools into smoke, embers thrown out and, given
+ * `debris` colors, chunks of whatever blew up. `size` is the fireball's puff size; `colors` its fire.
+ * The fire and smoke swell every way; `direction`, `spread` and `gravity` aim the embers and debris.
+ */
+function explosion(world, e) {
+  const fire = list(e.colors ?? FIRE);
+  const smoke = rgba(e.smoke ?? [0.28, 0.25, 0.24, 0.6]);
+  const g = e.gravity ?? 0;
+  const around = {
+    position: e.position,
+    spread: Math.PI,
+    gravity: 0
+  };
+  if (e.flash !== false) {
+    flash(world, {
+      position: e.position,
+      color: [3, 2.7, 2.1, 1],
+      size: e.size * 1.6,
+      lifetime: 0.2,
+      endSize: 2,
+      endColor: [2.4, 0.9, 0.2, 0]
+    });
+  }
+  world.burst({
+    ...around,
+    count: part(e.count, 0.5),
+    mesh: 'puff',
+    size: e.size,
+    speed: e.speed,
+    lifetime: e.lifetime,
+    color: fire,
+    endSize: 2.2,
+    endColor: [smoke[0], smoke[1], smoke[2], 0]
+  });
+  world.burst({
+    ...around,
+    count: part(e.count, 0.2),
+    mesh: 'flame',
+    size: e.size * 0.8,
+    speed: e.speed * 0.5,
+    lifetime: e.lifetime * 0.6,
+    color: fire,
+    endSize: 1.8,
+    endColor: [2, 0.5, 0.1, 0]
+  });
+  world.burst({
+    ...around,
+    count: part(e.count, 0.25),
+    mesh: 'puff',
+    size: e.size * 0.9,
+    speed: e.speed * 0.6,
+    lifetime: e.lifetime * 1.7,
+    color: smoke,
+    endSize: 2.8,
+    endColor: fade(smoke)
+  });
+  world.burst({
+    ...aim(e),
+    count: part(e.count, 0.4),
+    mesh: 'flame',
+    size: e.size * 0.12,
+    speed: e.speed * 2.4,
+    lifetime: e.lifetime * 0.9,
+    gravity: g,
+    color: EMBERS,
+    endSize: 0
+  });
+  if (e.debris) {
+    world.burst({
+      ...aim(e),
+      count: part(e.count, 0.5),
+      mesh: 'cube',
+      size: e.size * 0.16,
+      speed: e.speed * 1.8,
+      lifetime: e.lifetime * 1.2,
+      gravity: g,
+      color: e.debris,
+      endSize: 0.3
+    });
+  }
+}
+const WHITE_HOT = [2, 2, 2, 1]; // above 1 glows
+const WHITE = [1, 1, 1, 1];
+const POP_TIME = 0.5;
+const times = (scale, k) => typeof scale === 'number' ? scale * k : [scale[0] * k, scale[1] * k, scale[2] * k];
+
+/** The piece swells, flashes white, settles and shrinks away. Resolves when it's gone (despawning it is the caller's). */
+function pop(world, entity, o) {
+  const delay = o.delay ?? 0;
+  const duration = o.duration ?? POP_TIME;
+  const flashFor = {
+    duration: duration * 0.3,
+    delay
+  };
+  world.stopAnimation(entity); // whatever it was doing (landing, falling, wobbling) gives way
+  if (o.color) world.animate(entity, [{
+    color: WHITE_HOT,
+    at: 0.33
+  }, {
+    color: o.color
+  }], flashFor);
+  if (o.flash?.length) world.animate(o.flash, [{
+    color: WHITE_HOT,
+    at: 0.33
+  }, {
+    color: WHITE
+  }], flashFor);
+  const s = o.scale;
+  return world.animate(entity, [{
+    scale: times(s, 1.35),
+    at: 0.15
+  }, {
+    scale: times(s, 0.9),
+    at: 0.25
+  }, {
+    scale: times(s, 1),
+    at: 0.35
+  }, {
+    scale: times(s, 0)
+  }], {
+    duration,
+    delay
+  });
+}
+
+/**
+ * Ready-made effects. Each is one call; particles then live, fall, shrink and recolor in Rust.
+ *
+ * ```ts
+ * effects.confetti(world, { position, colors: [RED, GOLD], size: 0.12, speed: 6, count: 40, lifetime: 1.2, gravity: -6 });
+ * effects.dust(world, { position: feet, color: [0.8, 0.75, 0.65, 0.6], size: 0.3, speed: 1.5, count: 6, lifetime: 0.5 });
+ * effects.flash(world, { position: hit, color: effects.hot(ORANGE), size: 0.8 });
+ * await effects.pop(world, candy, { scale: 1, color: RED });
+ * world.despawn(candy);
+ * ```
+ */
+export const effects = {
+  /** Celebration: tumbling paper, glints and a pop of light (wins, level-ups). */
+  confetti,
+  /** Reward glitter: bright beads and glints (pickups, perfect moves). */
+  sparkle,
+  /** Breaking apart: chunks, crumbs, a glow and dust (bricks, crates, glass). `mesh` shapes the chunks. */
+  shatter,
+  /** Liquid: droplets and mist (water, juice, paint). */
+  splash,
+  /** Hot metal: additive streaks and beads (scrapes, strikes, electricity). */
+  sparks,
+  /** Fiery blast: flash, fireball cooling to smoke, embers and optional debris. */
+  explosion,
+  /** Soft swelling puffs: dust, sand, sawdust, steam, smoke. */
+  dust,
+  /** One swelling glow: hits, strikes, muzzle flashes. */
+  flash,
+  /** The cleared-piece animation: swell, flash white, settle, shrink to nothing. */
+  pop,
+  /** Default `pop` duration in seconds. */
+  POP_TIME,
+  /** The same hue made self-lit (brightest channel lifted to `peak`), for glows. */
+  hot,
+  /** Part way (`t`, 0..1) to white. */
+  pale
+};
+//# sourceMappingURL=effects.js.map

package/lib/module/world/quat.js

@@ -0,0 +1,86 @@
+"use strict";
+
+/** A writable quaternion; pass one as `out` to reuse it instead of allocating. */
+
+const result = (out, x, y, z, w) => {
+  if (!out) return [x, y, z, w];
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  out[3] = w;
+  return out;
+};
+
+/**
+ * Quaternion helpers for `rotation` options, keyframes and geometry parts ([x, y, z, w]). Every
+ * function takes an optional `out` so per-frame code can reuse one array instead of allocating.
+ *
+ * ```ts
+ * world.set(car, { rotation: quat.y(heading) });
+ * const spin = quat.multiply(quat.y(yaw), quat.x(pitch), scratch); // pitch first, then yaw
+ * ```
+ */
+export const quat = {
+  /** No rotation. */
+  identity: Object.freeze([0, 0, 0, 1]),
+  /** Rotation by `angle` radians around the unit axis (x, y, z). */
+  axisAngle(x, y, z, angle, out) {
+    const s = Math.sin(angle / 2);
+    return result(out, x * s, y * s, z * s, Math.cos(angle / 2));
+  },
+  /** Rotation around the x axis (pitch). */
+  x(angle, out) {
+    return result(out, Math.sin(angle / 2), 0, 0, Math.cos(angle / 2));
+  },
+  /** Rotation around the y axis (yaw, heading). */
+  y(angle, out) {
+    return result(out, 0, Math.sin(angle / 2), 0, Math.cos(angle / 2));
+  },
+  /** Rotation around the z axis (roll; spin for 2D games looking down -z). */
+  z(angle, out) {
+    return result(out, 0, 0, Math.sin(angle / 2), Math.cos(angle / 2));
+  },
+  /** `a` after `b`: `b` turns first. `out` may be `a` or `b`. */
+  multiply(a, b, out) {
+    const [ax, ay, az, aw] = a;
+    const [bx, by, bz, bw] = b;
+    return result(out, aw * bx + ax * bw + ay * bz - az * by, aw * by - ax * bz + ay * bw + az * bx, aw * bz + ax * by - ay * bx + az * bw, aw * bw - ax * bx - ay * by - az * bz);
+  },
+  /** Turns around x, then y, then z (radians): the same as `multiply(z(z), multiply(y(y), x(x)))`. */
+  fromEuler(x, y, z, out) {
+    const sx = Math.sin(x / 2);
+    const cx = Math.cos(x / 2);
+    const sy = Math.sin(y / 2);
+    const cy = Math.cos(y / 2);
+    const sz = Math.sin(z / 2);
+    const cz = Math.cos(z / 2);
+    return result(out, sx * cy * cz - cx * sy * sz, cx * sy * cz + sx * cy * sz, cx * cy * sz - sx * sy * cz, cx * cy * cz + sx * sy * sz);
+  },
+  /** Shortest-path interpolation from `a` (t = 0) to `b` (t = 1). */
+  slerp(a, b, t, out) {
+    let [bx, by, bz, bw] = b;
+    let cos = a[0] * bx + a[1] * by + a[2] * bz + a[3] * bw;
+    if (cos < 0) {
+      cos = -cos;
+      bx = -bx;
+      by = -by;
+      bz = -bz;
+      bw = -bw;
+    }
+    let k0 = 1 - t;
+    let k1 = t;
+    if (cos < 0.9995) {
+      const angle = Math.acos(cos);
+      const sin = Math.sin(angle);
+      k0 = Math.sin(k0 * angle) / sin;
+      k1 = Math.sin(k1 * angle) / sin;
+    }
+    const x = k0 * a[0] + k1 * bx;
+    const y = k0 * a[1] + k1 * by;
+    const z = k0 * a[2] + k1 * bz;
+    const w = k0 * a[3] + k1 * bw;
+    const length = Math.hypot(x, y, z, w) || 1;
+    return result(out, x / length, y / length, z / length, w / length);
+  }
+};
+//# sourceMappingURL=quat.js.map