@codexo/exojs-particles 0.15.3 → 0.16.0

package/dist/esm/modules/Turbulence.js

@@ -1,58 +1,73 @@
-import { UpdateModule } from './UpdateModule.js';
+import { UpdateModule } from "./UpdateModule.js";
 
+//#region src/modules/Turbulence.ts
 /**
- * Adds a smooth pseudo-random force field that animates over time.
- * Implemented as 2D value noise with cubic Hermite smoothing — sampled
- * twice per particle (offset to decorrelate x and y components) and scaled
- * by `strength`. The field evolves at `timeScale` units per second; lower
- * values produce slow-moving currents, higher values produce buzzy chaos.
- *
- * `frequency` controls the spatial granularity: small values (≈ 0.005)
- * yield broad swirls across the playfield, large values (≈ 0.1) produce
- * tight per-particle jitter.
- *
- * Use cases: smoke turbulence, organic swirls, wind eddies, dust haze.
- * Pair with {@link Drag} to keep particle velocities bounded.
- *
- * GPU-eligible. The noise function is identical on CPU and GPU so visual
- * results match across backends (modulo float precision).
- */
-class Turbulence extends UpdateModule {
-    strength;
-    frequency;
-    timeScale;
-    _time = 0;
-    constructor(strength, frequency = 0.01, timeScale = 1) {
-        super();
-        this.strength = strength;
-        this.frequency = frequency;
-        this.timeScale = timeScale;
-    }
-    apply(system, dt) {
-        this._time += dt * this.timeScale;
-        const t = this._time;
-        const f = this.frequency;
-        const s = this.strength * dt;
-        const { posX, posY, velX, velY, liveCount } = system;
-        for (let i = 0; i < liveCount; i++) {
-            const x = (posX[i] ?? 0) * f;
-            const y = (posY[i] ?? 0) * f;
-            const nx = valueNoise2(x + t, y);
-            const ny = valueNoise2(x, y + t + 17.31);
-            velX[i] = (velX[i] ?? 0) + (nx * 2 - 1) * s;
-            velY[i] = (velY[i] ?? 0) + (ny * 2 - 1) * s;
-        }
-    }
-    wgsl() {
-        return {
-            key: 'Turbulence',
-            uniforms: [
-                { name: 'strength', type: 'f32' },
-                { name: 'frequency', type: 'f32' },
-                { name: 'time', type: 'f32' },
-                { name: '_pad0', type: 'f32' },
-            ],
-            prelude: `
+* Adds a smooth pseudo-random force field that animates over time.
+* Implemented as 2D value noise with cubic Hermite smoothing - sampled
+* twice per particle (offset to decorrelate x and y components) and scaled
+* by `strength`. The field evolves at `timeScale` units per second; lower
+* values produce slow-moving currents, higher values produce buzzy chaos.
+*
+* `frequency` controls the spatial granularity: small values (≈ 0.005)
+* yield broad swirls across the playfield, large values (≈ 0.1) produce
+* tight per-particle jitter.
+*
+* Use cases: smoke turbulence, organic swirls, wind eddies, dust haze.
+* Pair with {@link Drag} to keep particle velocities bounded.
+*
+* GPU-eligible. The noise function is identical on CPU and GPU so visual
+* results match across backends (modulo float precision).
+*/
+var Turbulence = class extends UpdateModule {
+	strength;
+	frequency;
+	timeScale;
+	_time = 0;
+	constructor(strength, frequency = .01, timeScale = 1) {
+		super();
+		this.strength = strength;
+		this.frequency = frequency;
+		this.timeScale = timeScale;
+	}
+	apply(particles, dt) {
+		this._time += dt * this.timeScale;
+		const t = this._time;
+		const f = this.frequency;
+		const s = this.strength * dt;
+		const { x: posX, y: posY } = particles.position;
+		const { x: velX, y: velY } = particles.velocity;
+		const liveCount = particles.count;
+		for (let i = 0; i < liveCount; i++) {
+			const x = (posX[i] ?? 0) * f;
+			const y = (posY[i] ?? 0) * f;
+			const nx = valueNoise2(x + t, y);
+			const ny = valueNoise2(x, y + t + 17.31);
+			velX[i] = (velX[i] ?? 0) + (nx * 2 - 1) * s;
+			velY[i] = (velY[i] ?? 0) + (ny * 2 - 1) * s;
+		}
+	}
+	wgsl() {
+		return {
+			key: "Turbulence",
+			uniforms: [
+				{
+					name: "strength",
+					type: "f32"
+				},
+				{
+					name: "frequency",
+					type: "f32"
+				},
+				{
+					name: "time",
+					type: "f32"
+				},
+				{
+					name: "_pad0",
+					type: "f32"
+				}
+			],
+			prelude: `
 fn exojs_turbulence_hash21(p: vec2<f32>) -> f32 {
     let n = sin(dot(p, vec2<f32>(127.1, 311.7))) * 43758.5453;
     return fract(n);
@@ -74,7 +89,7 @@ fn exojs_turbulence_valueNoise2(x: f32, y: f32) -> f32 {
     return ab + (cd - ab) * v;
 }
             `,
-            body: `
+			body: `
                 let turbF = modules.u_Turbulence.frequency;
                 let turbT = modules.u_Turbulence.time;
                 let turbS = modules.u_Turbulence.strength * dt;
@@ -83,40 +98,37 @@ fn exojs_turbulence_valueNoise2(x: f32, y: f32) -> f32 {
                 let turbNx = exojs_turbulence_valueNoise2(turbX + turbT, turbY);
                 let turbNy = exojs_turbulence_valueNoise2(turbX, turbY + turbT + 17.31);
                 velocities[idx] = velocities[idx] + vec2<f32>(turbNx * 2.0 - 1.0, turbNy * 2.0 - 1.0) * turbS;
-            `,
-        };
-    }
-    writeUniforms(view, offset, dt) {
-        // GPU mode: apply() never runs, so advance _time here once per frame.
-        // CPU mode: apply() already advances _time before update finishes,
-        // and writeUniforms is not called → no double-advance.
-        this._time += dt * this.timeScale;
-        view.setFloat32(offset + 0, this.strength, true);
-        view.setFloat32(offset + 4, this.frequency, true);
-        view.setFloat32(offset + 8, this._time, true);
-        view.setFloat32(offset + 12, 0, true);
-    }
-}
-function hash21(x, y) {
-    let n = Math.sin(x * 127.1 + y * 311.7) * 43758.5453;
-    n = n - Math.floor(n);
-    return n;
-}
-function valueNoise2(x, y) {
-    const xi = Math.floor(x);
-    const yi = Math.floor(y);
-    const xf = x - xi;
-    const yf = y - yi;
-    const u = xf * xf * (3 - 2 * xf);
-    const v = yf * yf * (3 - 2 * yf);
-    const a = hash21(xi, yi);
-    const b = hash21(xi + 1, yi);
-    const c = hash21(xi, yi + 1);
-    const d = hash21(xi + 1, yi + 1);
-    const ab = a + (b - a) * u;
-    const cd = c + (d - c) * u;
-    return ab + (cd - ab) * v;
-}
+            `
+		};
+	}
+	writeUniforms(view, offset, dt) {
+		this._time += dt * this.timeScale;
+		view.setFloat32(offset + 0, this.strength, true);
+		view.setFloat32(offset + 4, this.frequency, true);
+		view.setFloat32(offset + 8, this._time, true);
+		view.setFloat32(offset + 12, 0, true);
+	}
+};
+const hash21 = (x, y) => {
+	let n = Math.sin(x * 127.1 + y * 311.7) * 43758.5453;
+	n = n - Math.floor(n);
+	return n;
+};
+const valueNoise2 = (x, y) => {
+	const xi = Math.floor(x);
+	const yi = Math.floor(y);
+	const xf = x - xi;
+	const yf = y - yi;
+	const u = xf * xf * (3 - 2 * xf);
+	const v = yf * yf * (3 - 2 * yf);
+	const a = hash21(xi, yi);
+	const b = hash21(xi + 1, yi);
+	const c = hash21(xi, yi + 1);
+	const d = hash21(xi + 1, yi + 1);
+	const ab = a + (b - a) * u;
+	return ab + (c + (d - c) * u - ab) * v;
+};
 
+//#endregion
 export { Turbulence };
-//# sourceMappingURL=Turbulence.js.map
+//# sourceMappingURL=Turbulence.js.map

package/dist/esm/modules/Turbulence.js.map

@@ -1 +1 @@
-{"version":3,"file":"Turbulence.js","sources":["../../../../src/modules/Turbulence.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}
+{"version":3,"file":"Turbulence.js","names":[],"sources":["../../../src/modules/Turbulence.ts"],"sourcesContent":["import type { ParticleBatch } from '#ParticleStorage';\n\nimport { UpdateModule } from './UpdateModule';\nimport type { WgslContribution } from './WgslContribution';\n\n/**\n * Adds a smooth pseudo-random force field that animates over time.\n * Implemented as 2D value noise with cubic Hermite smoothing - sampled\n * twice per particle (offset to decorrelate x and y components) and scaled\n * by `strength`. The field evolves at `timeScale` units per second; lower\n * values produce slow-moving currents, higher values produce buzzy chaos.\n *\n * `frequency` controls the spatial granularity: small values (≈ 0.005)\n * yield broad swirls across the playfield, large values (≈ 0.1) produce\n * tight per-particle jitter.\n *\n * Use cases: smoke turbulence, organic swirls, wind eddies, dust haze.\n * Pair with {@link Drag} to keep particle velocities bounded.\n *\n * GPU-eligible. The noise function is identical on CPU and GPU so visual\n * results match across backends (modulo float precision).\n */\nexport class Turbulence extends UpdateModule {\n  public strength: number;\n  public frequency: number;\n  public timeScale: number;\n  private _time = 0;\n\n  public constructor(strength: number, frequency = 0.01, timeScale = 1) {\n    super();\n    this.strength = strength;\n    this.frequency = frequency;\n    this.timeScale = timeScale;\n  }\n\n  public override apply(particles: ParticleBatch, dt: number): void {\n    this._time += dt * this.timeScale;\n    const t = this._time;\n    const f = this.frequency;\n    const s = this.strength * dt;\n\n    const { x: posX, y: posY } = particles.position;\n    const { x: velX, y: velY } = particles.velocity;\n    const liveCount = particles.count;\n\n    for (let i = 0; i < liveCount; i++) {\n      const x = (posX[i] ?? 0) * f;\n      const y = (posY[i] ?? 0) * f;\n      const nx = valueNoise2(x + t, y);\n      const ny = valueNoise2(x, y + t + 17.31);\n\n      velX[i] = (velX[i] ?? 0) + (nx * 2 - 1) * s;\n      velY[i] = (velY[i] ?? 0) + (ny * 2 - 1) * s;\n    }\n  }\n\n  public override wgsl(): WgslContribution {\n    return {\n      key: 'Turbulence',\n      uniforms: [\n        { name: 'strength', type: 'f32' },\n        { name: 'frequency', type: 'f32' },\n        { name: 'time', type: 'f32' },\n        { name: '_pad0', type: 'f32' },\n      ],\n      prelude: `\nfn exojs_turbulence_hash21(p: vec2<f32>) -> f32 {\n    let n = sin(dot(p, vec2<f32>(127.1, 311.7))) * 43758.5453;\n    return fract(n);\n}\n\nfn exojs_turbulence_valueNoise2(x: f32, y: f32) -> f32 {\n    let xi = floor(x);\n    let yi = floor(y);\n    let xf = x - xi;\n    let yf = y - yi;\n    let u = xf * xf * (3.0 - 2.0 * xf);\n    let v = yf * yf * (3.0 - 2.0 * yf);\n    let a = exojs_turbulence_hash21(vec2<f32>(xi, yi));\n    let b = exojs_turbulence_hash21(vec2<f32>(xi + 1.0, yi));\n    let c = exojs_turbulence_hash21(vec2<f32>(xi, yi + 1.0));\n    let d = exojs_turbulence_hash21(vec2<f32>(xi + 1.0, yi + 1.0));\n    let ab = a + (b - a) * u;\n    let cd = c + (d - c) * u;\n    return ab + (cd - ab) * v;\n}\n            `,\n      body: `\n                let turbF = modules.u_Turbulence.frequency;\n                let turbT = modules.u_Turbulence.time;\n                let turbS = modules.u_Turbulence.strength * dt;\n                let turbX = positions[idx].x * turbF;\n                let turbY = positions[idx].y * turbF;\n                let turbNx = exojs_turbulence_valueNoise2(turbX + turbT, turbY);\n                let turbNy = exojs_turbulence_valueNoise2(turbX, turbY + turbT + 17.31);\n                velocities[idx] = velocities[idx] + vec2<f32>(turbNx * 2.0 - 1.0, turbNy * 2.0 - 1.0) * turbS;\n            `,\n    };\n  }\n\n  public override writeUniforms(view: DataView, offset: number, dt: number): void {\n    // GPU mode: apply() never runs, so advance _time here once per frame.\n    // CPU mode: apply() already advances _time before update finishes,\n    // and writeUniforms is not called → no double-advance.\n    this._time += dt * this.timeScale;\n\n    view.setFloat32(offset + 0, this.strength, true);\n    view.setFloat32(offset + 4, this.frequency, true);\n    view.setFloat32(offset + 8, this._time, true);\n    view.setFloat32(offset + 12, 0, true);\n  }\n}\n\nconst hash21 = (x: number, y: number): number => {\n  let n = Math.sin(x * 127.1 + y * 311.7) * 43758.5453;\n  n = n - Math.floor(n);\n  return n;\n};\n\nconst valueNoise2 = (x: number, y: number): number => {\n  const xi = Math.floor(x);\n  const yi = Math.floor(y);\n  const xf = x - xi;\n  const yf = y - yi;\n\n  const u = xf * xf * (3 - 2 * xf);\n  const v = yf * yf * (3 - 2 * yf);\n\n  const a = hash21(xi, yi);\n  const b = hash21(xi + 1, yi);\n  const c = hash21(xi, yi + 1);\n  const d = hash21(xi + 1, yi + 1);\n\n  const ab = a + (b - a) * u;\n  const cd = c + (d - c) * u;\n  return ab + (cd - ab) * v;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsBA,IAAa,aAAb,cAAgC,aAAa;CAC3C,AAAO;CACP,AAAO;CACP,AAAO;CACP,AAAQ,QAAQ;CAEhB,AAAO,YAAY,UAAkB,YAAY,KAAM,YAAY,GAAG;EACpE,MAAM;EACN,KAAK,WAAW;EAChB,KAAK,YAAY;EACjB,KAAK,YAAY;CACnB;CAEA,AAAgB,MAAM,WAA0B,IAAkB;EAChE,KAAK,SAAS,KAAK,KAAK;EACxB,MAAM,IAAI,KAAK;EACf,MAAM,IAAI,KAAK;EACf,MAAM,IAAI,KAAK,WAAW;EAE1B,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,UAAU;EACvC,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,UAAU;EACvC,MAAM,YAAY,UAAU;EAE5B,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,KAAK;GAClC,MAAM,KAAK,KAAK,MAAM,KAAK;GAC3B,MAAM,KAAK,KAAK,MAAM,KAAK;GAC3B,MAAM,KAAK,YAAY,IAAI,GAAG,CAAC;GAC/B,MAAM,KAAK,YAAY,GAAG,IAAI,IAAI,KAAK;GAEvC,KAAK,MAAM,KAAK,MAAM,MAAM,KAAK,IAAI,KAAK;GAC1C,KAAK,MAAM,KAAK,MAAM,MAAM,KAAK,IAAI,KAAK;EAC5C;CACF;CAEA,AAAgB,OAAyB;EACvC,OAAO;GACL,KAAK;GACL,UAAU;IACR;KAAE,MAAM;KAAY,MAAM;IAAM;IAChC;KAAE,MAAM;KAAa,MAAM;IAAM;IACjC;KAAE,MAAM;KAAQ,MAAM;IAAM;IAC5B;KAAE,MAAM;KAAS,MAAM;IAAM;GAC/B;GACA,SAAS;;;;;;;;;;;;;;;;;;;;;;GAsBT,MAAM;;;;;;;;;;EAUR;CACF;CAEA,AAAgB,cAAc,MAAgB,QAAgB,IAAkB;EAI9E,KAAK,SAAS,KAAK,KAAK;EAExB,KAAK,WAAW,SAAS,GAAG,KAAK,UAAU,IAAI;EAC/C,KAAK,WAAW,SAAS,GAAG,KAAK,WAAW,IAAI;EAChD,KAAK,WAAW,SAAS,GAAG,KAAK,OAAO,IAAI;EAC5C,KAAK,WAAW,SAAS,IAAI,GAAG,IAAI;CACtC;AACF;AAEA,MAAM,UAAU,GAAW,MAAsB;CAC/C,IAAI,IAAI,KAAK,IAAI,IAAI,QAAQ,IAAI,KAAK,IAAI;CAC1C,IAAI,IAAI,KAAK,MAAM,CAAC;CACpB,OAAO;AACT;AAEA,MAAM,eAAe,GAAW,MAAsB;CACpD,MAAM,KAAK,KAAK,MAAM,CAAC;CACvB,MAAM,KAAK,KAAK,MAAM,CAAC;CACvB,MAAM,KAAK,IAAI;CACf,MAAM,KAAK,IAAI;CAEf,MAAM,IAAI,KAAK,MAAM,IAAI,IAAI;CAC7B,MAAM,IAAI,KAAK,MAAM,IAAI,IAAI;CAE7B,MAAM,IAAI,OAAO,IAAI,EAAE;CACvB,MAAM,IAAI,OAAO,KAAK,GAAG,EAAE;CAC3B,MAAM,IAAI,OAAO,IAAI,KAAK,CAAC;CAC3B,MAAM,IAAI,OAAO,KAAK,GAAG,KAAK,CAAC;CAE/B,MAAM,KAAK,KAAK,IAAI,KAAK;CAEzB,OAAO,MADI,KAAK,IAAI,KAAK,IACP,MAAM;AAC1B"}

package/dist/esm/modules/UpdateModule.d.ts

@@ -1,25 +1,25 @@
-import type { ParticleSystem } from "#ParticleSystem";
+import type { ParticleBatch } from '#ParticleStorage';
 import type { WgslContribution } from './WgslContribution';
 /**
- * Per-frame, per-batch mutator. Operates on the system's SoA storage
- * directly — typically a single tight loop over `[0, system.liveCount)`
- * that reads/writes the relevant `Float32Array`s.
+ * Per-frame, per-batch mutator. Operates on the live particles through their
+ * named channels - typically a single tight loop over `[0, particles.count)`
+ * that reads and writes the channel arrays it needs.
  *
  * Implementations must always provide a CPU `apply()`. To make a module
  * GPU-eligible (executed inside the system's composite compute shader on
  * WebGPU backends), additionally implement {@link wgsl} and
  * {@link writeUniforms}. Modules that declare a {@link WgslContribution}
  * may also opt to declare a 1D texture binding via the `textures` field
- * (used by `Curve` / `ColorGradient`-driven modules) — in which case
+ * (used by `Curve` / `ColorGradient`-driven modules) - in which case
  * {@link uploadTextures} runs once at compile time to upload the data.
  *
  * Implementation pattern (CPU-only module):
  *
  * ```ts
  * class MyModule extends UpdateModule {
- *     apply(system, dt) {
- *         const { velX, velY, liveCount } = system;
- *         for (let i = 0; i < liveCount; i++) { velX[i] *= 0.99; velY[i] *= 0.99; }
+ *     apply(particles, dt) {
+ *         const { x: velX, y: velY } = particles.velocity;
+ *         for (let i = 0; i < particles.count; i++) { velX[i] *= 0.99; velY[i] *= 0.99; }
  *     }
  * }
  * ```
@@ -30,9 +30,9 @@ import type { WgslContribution } from './WgslContribution';
  * class MyForce extends UpdateModule {
  *     constructor(public ax: number, public ay: number) { super(); }
  *
- *     apply(system, dt) {
- *         const { velX, velY, liveCount } = system;
- *         for (let i = 0; i < liveCount; i++) { velX[i] += this.ax * dt; velY[i] += this.ay * dt; }
+ *     apply(particles, dt) {
+ *         const { x: velX, y: velY } = particles.velocity;
+ *         for (let i = 0; i < particles.count; i++) { velX[i] += this.ax * dt; velY[i] += this.ay * dt; }
  *     }
  *
  *     wgsl(): WgslContribution {
@@ -51,7 +51,7 @@ import type { WgslContribution } from './WgslContribution';
  * ```
  *
  * If *any* registered update module on a system lacks `wgsl()`, the system
- * forces CPU mode regardless of backend — preserving the contract that
+ * forces CPU mode regardless of backend - preserving the contract that
  * `apply()` is always honoured. Built-in modules ship both
  * implementations; custom modules can opt into GPU acceleration at their
  * authors' discretion.
@@ -60,7 +60,14 @@ import type { WgslContribution } from './WgslContribution';
  * in registration order; later modules see the effects of earlier ones.
  */
 export declare abstract class UpdateModule {
-    abstract apply(system: ParticleSystem, dt: number): void;
+    /**
+     * Mutates the live particles for one frame.
+     *
+     * Runs only on the CPU path: a system whose modules are all GPU-eligible
+     * executes {@link wgsl} bodies inside its compute shader instead, and never
+     * calls this.
+     */
+    abstract apply(particles: ParticleBatch, dt: number): void;
     /**
      * Override to declare a GPU contribution. Returning a {@link WgslContribution}
      * makes this module GPU-eligible; omitting (or returning undefined)
@@ -93,3 +100,4 @@ export declare abstract class UpdateModule {
     /** Optional cleanup hook called from `ParticleSystem.destroy`. */
     destroy(): void;
 }
+//# sourceMappingURL=UpdateModule.d.ts.map

package/dist/esm/modules/UpdateModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UpdateModule.d.ts","sourceRoot":"","sources":["../../../src/modules/UpdateModule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,8BAAsB,YAAY;IAChC;;;;;;OAMG;aACa,KAAK,CAAC,SAAS,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAEjE;;;;OAIG;IACI,IAAI,CAAC,IAAI,gBAAgB;IAEhC;;;;;;;;;;;;OAYG;IACI,aAAa,CAAC,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAE3E;;;;;;;OAOG;IACI,cAAc,CAAC,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,IAAI;IAE1F,kEAAkE;IAC3D,OAAO,IAAI,IAAI;CACvB"}

package/dist/esm/modules/UpdateModule.js

@@ -1,66 +1,68 @@
+//#region src/modules/UpdateModule.ts
 /**
- * Per-frame, per-batch mutator. Operates on the system's SoA storage
- * directly — typically a single tight loop over `[0, system.liveCount)`
- * that reads/writes the relevant `Float32Array`s.
- *
- * Implementations must always provide a CPU `apply()`. To make a module
- * GPU-eligible (executed inside the system's composite compute shader on
- * WebGPU backends), additionally implement {@link wgsl} and
- * {@link writeUniforms}. Modules that declare a {@link WgslContribution}
- * may also opt to declare a 1D texture binding via the `textures` field
- * (used by `Curve` / `ColorGradient`-driven modules) — in which case
- * {@link uploadTextures} runs once at compile time to upload the data.
- *
- * Implementation pattern (CPU-only module):
- *
- * ```ts
- * class MyModule extends UpdateModule {
- *     apply(system, dt) {
- *         const { velX, velY, liveCount } = system;
- *         for (let i = 0; i < liveCount; i++) { velX[i] *= 0.99; velY[i] *= 0.99; }
- *     }
- * }
- * ```
- *
- * Implementation pattern (GPU-eligible module):
- *
- * ```ts
- * class MyForce extends UpdateModule {
- *     constructor(public ax: number, public ay: number) { super(); }
- *
- *     apply(system, dt) {
- *         const { velX, velY, liveCount } = system;
- *         for (let i = 0; i < liveCount; i++) { velX[i] += this.ax * dt; velY[i] += this.ay * dt; }
- *     }
- *
- *     wgsl(): WgslContribution {
- *         return {
- *             key: 'MyForce',
- *             uniforms: [{ name: 'ax', type: 'f32' }, { name: 'ay', type: 'f32' }],
- *             body: `velX[idx] += u_MyForce.ax * dt; velY[idx] += u_MyForce.ay * dt;`,
- *         };
- *     }
- *
- *     writeUniforms(view, offset) {
- *         view.setFloat32(offset + 0, this.ax, true);
- *         view.setFloat32(offset + 4, this.ay, true);
- *     }
- * }
- * ```
- *
- * If *any* registered update module on a system lacks `wgsl()`, the system
- * forces CPU mode regardless of backend — preserving the contract that
- * `apply()` is always honoured. Built-in modules ship both
- * implementations; custom modules can opt into GPU acceleration at their
- * authors' discretion.
- *
- * Update modules run after integration each frame. Multiple modules execute
- * in registration order; later modules see the effects of earlier ones.
- */
-class UpdateModule {
-    /** Optional cleanup hook called from `ParticleSystem.destroy`. */
-    destroy() { }
-}
+* Per-frame, per-batch mutator. Operates on the live particles through their
+* named channels - typically a single tight loop over `[0, particles.count)`
+* that reads and writes the channel arrays it needs.
+*
+* Implementations must always provide a CPU `apply()`. To make a module
+* GPU-eligible (executed inside the system's composite compute shader on
+* WebGPU backends), additionally implement {@link wgsl} and
+* {@link writeUniforms}. Modules that declare a {@link WgslContribution}
+* may also opt to declare a 1D texture binding via the `textures` field
+* (used by `Curve` / `ColorGradient`-driven modules) - in which case
+* {@link uploadTextures} runs once at compile time to upload the data.
+*
+* Implementation pattern (CPU-only module):
+*
+* ```ts
+* class MyModule extends UpdateModule {
+*     apply(particles, dt) {
+*         const { x: velX, y: velY } = particles.velocity;
+*         for (let i = 0; i < particles.count; i++) { velX[i] *= 0.99; velY[i] *= 0.99; }
+*     }
+* }
+* ```
+*
+* Implementation pattern (GPU-eligible module):
+*
+* ```ts
+* class MyForce extends UpdateModule {
+*     constructor(public ax: number, public ay: number) { super(); }
+*
+*     apply(particles, dt) {
+*         const { x: velX, y: velY } = particles.velocity;
+*         for (let i = 0; i < particles.count; i++) { velX[i] += this.ax * dt; velY[i] += this.ay * dt; }
+*     }
+*
+*     wgsl(): WgslContribution {
+*         return {
+*             key: 'MyForce',
+*             uniforms: [{ name: 'ax', type: 'f32' }, { name: 'ay', type: 'f32' }],
+*             body: `velX[idx] += u_MyForce.ax * dt; velY[idx] += u_MyForce.ay * dt;`,
+*         };
+*     }
+*
+*     writeUniforms(view, offset) {
+*         view.setFloat32(offset + 0, this.ax, true);
+*         view.setFloat32(offset + 4, this.ay, true);
+*     }
+* }
+* ```
+*
+* If *any* registered update module on a system lacks `wgsl()`, the system
+* forces CPU mode regardless of backend - preserving the contract that
+* `apply()` is always honoured. Built-in modules ship both
+* implementations; custom modules can opt into GPU acceleration at their
+* authors' discretion.
+*
+* Update modules run after integration each frame. Multiple modules execute
+* in registration order; later modules see the effects of earlier ones.
+*/
+var UpdateModule = class {
+	/** Optional cleanup hook called from `ParticleSystem.destroy`. */
+	destroy() {}
+};
 
+//#endregion
 export { UpdateModule };
-//# sourceMappingURL=UpdateModule.js.map
+//# sourceMappingURL=UpdateModule.js.map

package/dist/esm/modules/UpdateModule.js.map

@@ -1 +1 @@
-{"version":3,"file":"UpdateModule.js","sources":["../../../../src/modules/UpdateModule.ts"],"sourcesContent":[null],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DG;MACmB,YAAY,CAAA;;AAoCzB,IAAA,OAAO,KAAU;AACzB;;;;"}
+{"version":3,"file":"UpdateModule.js","names":[],"sources":["../../../src/modules/UpdateModule.ts"],"sourcesContent":["import type { ParticleBatch } from '#ParticleStorage';\n\nimport type { WgslContribution } from './WgslContribution';\n\n/**\n * Per-frame, per-batch mutator. Operates on the live particles through their\n * named channels - typically a single tight loop over `[0, particles.count)`\n * that reads and writes the channel arrays it needs.\n *\n * Implementations must always provide a CPU `apply()`. To make a module\n * GPU-eligible (executed inside the system's composite compute shader on\n * WebGPU backends), additionally implement {@link wgsl} and\n * {@link writeUniforms}. Modules that declare a {@link WgslContribution}\n * may also opt to declare a 1D texture binding via the `textures` field\n * (used by `Curve` / `ColorGradient`-driven modules) - in which case\n * {@link uploadTextures} runs once at compile time to upload the data.\n *\n * Implementation pattern (CPU-only module):\n *\n * ```ts\n * class MyModule extends UpdateModule {\n *     apply(particles, dt) {\n *         const { x: velX, y: velY } = particles.velocity;\n *         for (let i = 0; i < particles.count; i++) { velX[i] *= 0.99; velY[i] *= 0.99; }\n *     }\n * }\n * ```\n *\n * Implementation pattern (GPU-eligible module):\n *\n * ```ts\n * class MyForce extends UpdateModule {\n *     constructor(public ax: number, public ay: number) { super(); }\n *\n *     apply(particles, dt) {\n *         const { x: velX, y: velY } = particles.velocity;\n *         for (let i = 0; i < particles.count; i++) { velX[i] += this.ax * dt; velY[i] += this.ay * dt; }\n *     }\n *\n *     wgsl(): WgslContribution {\n *         return {\n *             key: 'MyForce',\n *             uniforms: [{ name: 'ax', type: 'f32' }, { name: 'ay', type: 'f32' }],\n *             body: `velX[idx] += u_MyForce.ax * dt; velY[idx] += u_MyForce.ay * dt;`,\n *         };\n *     }\n *\n *     writeUniforms(view, offset) {\n *         view.setFloat32(offset + 0, this.ax, true);\n *         view.setFloat32(offset + 4, this.ay, true);\n *     }\n * }\n * ```\n *\n * If *any* registered update module on a system lacks `wgsl()`, the system\n * forces CPU mode regardless of backend - preserving the contract that\n * `apply()` is always honoured. Built-in modules ship both\n * implementations; custom modules can opt into GPU acceleration at their\n * authors' discretion.\n *\n * Update modules run after integration each frame. Multiple modules execute\n * in registration order; later modules see the effects of earlier ones.\n */\nexport abstract class UpdateModule {\n  /**\n   * Mutates the live particles for one frame.\n   *\n   * Runs only on the CPU path: a system whose modules are all GPU-eligible\n   * executes {@link wgsl} bodies inside its compute shader instead, and never\n   * calls this.\n   */\n  public abstract apply(particles: ParticleBatch, dt: number): void;\n\n  /**\n   * Override to declare a GPU contribution. Returning a {@link WgslContribution}\n   * makes this module GPU-eligible; omitting (or returning undefined)\n   * forces CPU mode for any system that uses this module.\n   */\n  public wgsl?(): WgslContribution;\n\n  /**\n   * Write this module's current uniform values into the shared uniform\n   * buffer at `byteOffset`. Layout must match the field declarations\n   * returned by {@link wgsl} (in the same order).\n   *\n   * Receives the current frame `dt` (seconds). Modules tracking\n   * accumulated time (e.g. noise/turbulence) should advance their\n   * internal counter here to stay in sync when running in GPU mode\n   * (where {@link apply} is not called).\n   *\n   * Required when {@link wgsl} declares uniforms. Called every frame by\n   * the system before dispatching compute.\n   */\n  public writeUniforms?(view: DataView, byteOffset: number, dt: number): void;\n\n  /**\n   * Upload texture data (Curve/ColorGradient lookup tables) to the GPU at\n   * compile time. Receives the GPUDevice and a map of texture bindings\n   * keyed by the `name` in {@link WgslContribution.textures}. Called once\n   * after pipeline creation.\n   *\n   * Required when {@link wgsl} declares textures.\n   */\n  public uploadTextures?(device: GPUDevice, textures: ReadonlyMap<string, GPUTexture>): void;\n\n  /** Optional cleanup hook called from `ParticleSystem.destroy`. */\n  public destroy(): void {}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+DA,IAAsB,eAAtB,MAAmC;;CA2CjC,AAAO,UAAgB,CAAC;AAC1B"}

package/dist/esm/modules/VelocityOverLifetime.d.ts

@@ -1,16 +1,16 @@
-import type { Curve } from "#distributions/Curve";
-import type { ParticleSystem } from "#ParticleSystem";
+import type { Curve } from '#distributions/Curve';
+import type { ParticleBatch } from '#ParticleStorage';
 import { UpdateModule } from './UpdateModule';
 import type { WgslContribution } from './WgslContribution';
 /**
  * Multiplies every live particle's velocity by a curve sampled at the
  * particle's current `elapsed / lifetime` ratio. The same scalar is applied
- * to both axes — the direction is preserved, only the magnitude scales.
+ * to both axes - the direction is preserved, only the magnitude scales.
  *
  * Common patterns:
- * - **Snappy spawn, slow drift:** `[0,1]→[1,0.1]` — fast initial motion
+ * - **Snappy spawn, slow drift:** `[0,1]→[1,0.1]` - fast initial motion
  *   that decays over lifetime.
- * - **Late acceleration:** `[0,0.2]→[1,1]` — particles ease in.
+ * - **Late acceleration:** `[0,0.2]→[1,1]` - particles ease in.
  * - **Pulse:** sine-shaped curve for breathing-style motion.
  *
  * Note: the curve **replaces** velocity each frame relative to the previous
@@ -24,7 +24,8 @@ export declare class VelocityOverLifetime extends UpdateModule {
     curve: Curve;
     private _prevSample;
     constructor(curve: Curve);
-    apply(system: ParticleSystem, _dt: number): void;
+    apply(particles: ParticleBatch, _dt: number): void;
     wgsl(): WgslContribution;
     uploadTextures(device: GPUDevice, textures: ReadonlyMap<string, GPUTexture>): void;
 }
+//# sourceMappingURL=VelocityOverLifetime.d.ts.map

package/dist/esm/modules/VelocityOverLifetime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VelocityOverLifetime.d.ts","sourceRoot":"","sources":["../../../src/modules/VelocityOverLifetime.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAI3D;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;IAC7C,KAAK,EAAE,KAAK,CAAC;IAEpB,OAAO,CAAC,WAAW,CAAuB;gBAEvB,KAAK,EAAE,KAAK;IAKf,KAAK,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IA2BlD,IAAI,IAAI,gBAAgB;IAsBxB,cAAc,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,IAAI;CAoBnG"}