incanto 0.1.0

package/dist/noise-CGUMx44x.js

@@ -0,0 +1,82 @@
+import { t as Rng } from "./rng-DP-SR7eg.js";
+//#region src/core/noise.ts
+/** Skewing factors for 2D simplex: F2 = (√3−1)/2, G2 = (3−√3)/6. */
+const F2 = .5 * (Math.sqrt(3) - 1);
+const G2 = (3 - Math.sqrt(3)) / 6;
+/** The 8 unit-ish gradient directions of classic 2D simplex noise. */
+const GRAD = new Float64Array([
+	1,
+	1,
+	-1,
+	1,
+	1,
+	-1,
+	-1,
+	-1,
+	1,
+	0,
+	-1,
+	0,
+	0,
+	1,
+	0,
+	-1
+]);
+/**
+* Seeded 2D simplex noise (Ken Perlin's simplex, Gustavson's reference
+* implementation) returning values in [-1, 1]. The permutation table is a
+* Fisher–Yates shuffle drawn from our deterministic {@link Rng}, so an
+* integer seed reproduces the identical field on every machine — the same
+* contract as every other seeded generator in the engine. Pure math, no deps.
+*/
+function createNoise2D(seed) {
+	const rng = new Rng(seed);
+	const perm = new Uint8Array(512);
+	const table = new Uint8Array(256);
+	for (let i = 0; i < 256; i++) table[i] = i;
+	for (let i = 255; i > 0; i--) {
+		const j = rng.int(0, i);
+		const t = table[i];
+		table[i] = table[j];
+		table[j] = t;
+	}
+	for (let i = 0; i < 512; i++) perm[i] = table[i & 255];
+	return (x, y) => {
+		const s = (x + y) * F2;
+		const i = Math.floor(x + s);
+		const j = Math.floor(y + s);
+		const t = (i + j) * G2;
+		const x0 = x - (i - t);
+		const y0 = y - (j - t);
+		const i1 = x0 > y0 ? 1 : 0;
+		const j1 = x0 > y0 ? 0 : 1;
+		const x1 = x0 - i1 + G2;
+		const y1 = y0 - j1 + G2;
+		const x2 = x0 - 1 + 2 * G2;
+		const y2 = y0 - 1 + 2 * G2;
+		const ii = i & 255;
+		const jj = j & 255;
+		let n = 0;
+		let t0 = .5 - x0 * x0 - y0 * y0;
+		if (t0 > 0) {
+			t0 *= t0;
+			const g = perm[ii + perm[jj]] % 8 * 2;
+			n += t0 * t0 * (GRAD[g] * x0 + GRAD[g + 1] * y0);
+		}
+		let t1 = .5 - x1 * x1 - y1 * y1;
+		if (t1 > 0) {
+			t1 *= t1;
+			const g = perm[ii + i1 + perm[jj + j1]] % 8 * 2;
+			n += t1 * t1 * (GRAD[g] * x1 + GRAD[g + 1] * y1);
+		}
+		let t2 = .5 - x2 * x2 - y2 * y2;
+		if (t2 > 0) {
+			t2 *= t2;
+			const g = perm[ii + 1 + perm[jj + 1]] % 8 * 2;
+			n += t2 * t2 * (GRAD[g] * x2 + GRAD[g + 1] * y2);
+		}
+		return 70 * n;
+	};
+}
+//#endregion
+export { createNoise2D as t };

package/dist/particle-sim-CbN4YUuH.d.ts

@@ -0,0 +1,63 @@
+import { a as Rng } from "./schema-CcoWb32N.js";
+
+//#region src/core/particle-sim.d.ts
+/**
+* Deterministic particle pool — pure math, renderer-agnostic, headless-
+* testable. 2D uses the xy plane (y-down, directionDeg 0 = +x, -90 = up);
+* 3D feeds the same sim with a z spread.
+*/
+interface ParticleSimConfig {
+  /** Particles per second (0 = burst-only). */
+  rate: number;
+  /** Seconds, [min, max]. */
+  lifetime: [number, number];
+  /** Initial speed, [min, max] (units/sec — px in 2D, meters in 3D). */
+  speed: [number, number];
+  /** Emission direction center, degrees (0 = +x, -90 = up in y-down 2D). */
+  directionDeg: number;
+  /** Cone width, degrees (360 = all directions). */
+  spreadDeg: number;
+  /** Constant acceleration (y-down in 2D). */
+  gravity: [number, number, number];
+  /** Exponential velocity damping per second (0 = none). */
+  drag: number;
+  maxParticles: number;
+  /** Spread emission into the z axis too (3D). */
+  spreadZ?: boolean;
+}
+interface ParticleView {
+  x: number;
+  y: number;
+  z: number;
+  vx: number;
+  vy: number;
+  vz: number;
+  /** Seconds alive. */
+  age: number;
+  /** Total lifetime in seconds. */
+  life: number;
+  /** age/life in [0, 1] — drives size/color/alpha ramps. */
+  t: number;
+  /** Per-particle random in [0, 1) — stable for the particle's lifetime. */
+  seed: number;
+}
+declare class ParticleSim {
+  private readonly config;
+  private readonly rng;
+  private readonly data;
+  private alive;
+  private spawnAccumulator;
+  private everSpawned;
+  constructor(config: ParticleSimConfig, rng: Rng);
+  get count(): number;
+  /** True when nothing is alive and at least one particle has ever spawned. */
+  get done(): boolean;
+  /** Spawn n particles immediately (fireworks, explosions, flashes). */
+  burst(n: number): void;
+  update(dt: number): void;
+  forEach(fn: (p: ParticleView) => void): void;
+  private spawn;
+  private kill;
+}
+//#endregion
+export { ParticleSimConfig as n, ParticleView as r, ParticleSim as t };