@codexo/exojs-particles 0.15.3 → 0.16.0

package/dist/esm/modules/RotateOverLifetime.js

@@ -1,41 +1,45 @@
-import { UpdateModule } from './UpdateModule.js';
+import { UpdateModule } from "./UpdateModule.js";
 
+//#region src/modules/RotateOverLifetime.ts
 /**
- * Adds a constant angular acceleration to every live particle each frame
- * (analogous to the legacy `TorqueAffector`). The system's integrate pass
- * advances `rotation` from `rotationSpeed`; this module increments
- * `rotationSpeed` itself.
- *
- * Units: degrees per second². Negative values decelerate spin.
- *
- * GPU-eligible.
- */
-class RotateOverLifetime extends UpdateModule {
-    angularAcceleration;
-    constructor(angularAcceleration) {
-        super();
-        this.angularAcceleration = angularAcceleration;
-    }
-    apply(system, dt) {
-        const { rotationSpeeds, liveCount } = system;
-        const delta = this.angularAcceleration * dt;
-        for (let i = 0; i < liveCount; i++) {
-            rotationSpeeds[i] = (rotationSpeeds[i] ?? 0) + delta;
-        }
-    }
-    wgsl() {
-        return {
-            key: 'RotateOverLifetime',
-            uniforms: [{ name: 'angularAcceleration', type: 'f32' }],
-            body: `
+* Adds a constant angular acceleration to every live particle each frame
+* (analogous to the legacy `TorqueAffector`). The system's integrate pass
+* advances `rotation` from `rotationSpeed`; this module increments
+* `rotationSpeed` itself.
+*
+* Units: degrees per second². Negative values decelerate spin.
+*
+* GPU-eligible.
+*/
+var RotateOverLifetime = class extends UpdateModule {
+	angularAcceleration;
+	constructor(angularAcceleration) {
+		super();
+		this.angularAcceleration = angularAcceleration;
+	}
+	apply(particles, dt) {
+		const { speed: rotationSpeeds } = particles.rotation;
+		const liveCount = particles.count;
+		const delta = this.angularAcceleration * dt;
+		for (let i = 0; i < liveCount; i++) rotationSpeeds[i] = (rotationSpeeds[i] ?? 0) + delta;
+	}
+	wgsl() {
+		return {
+			key: "RotateOverLifetime",
+			uniforms: [{
+				name: "angularAcceleration",
+				type: "f32"
+			}],
+			body: `
                 rotInfo[idx].y = rotInfo[idx].y + modules.u_RotateOverLifetime.angularAcceleration * dt;
-            `,
-        };
-    }
-    writeUniforms(view, offset) {
-        view.setFloat32(offset + 0, this.angularAcceleration, true);
-    }
-}
+            `
+		};
+	}
+	writeUniforms(view, offset) {
+		view.setFloat32(offset + 0, this.angularAcceleration, true);
+	}
+};
 
+//#endregion
 export { RotateOverLifetime };
-//# sourceMappingURL=RotateOverLifetime.js.map
+//# sourceMappingURL=RotateOverLifetime.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"RotateOverLifetime.js","sources":["../../../../src/modules/RotateOverLifetime.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;;;;;;;AASG;AACG,MAAO,kBAAmB,SAAQ,YAAY,CAAA;AAC3C,IAAA,mBAAmB;AAE1B,IAAA,WAAA,CAAmB,mBAA2B,EAAA;AAC5C,QAAA,KAAK,EAAE;AACP,QAAA,IAAI,CAAC,mBAAmB,GAAG,mBAAmB;IAChD;IAEgB,KAAK,CAAC,MAAsB,EAAE,EAAU,EAAA;AACtD,QAAA,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,GAAG,MAAM;AAC5C,QAAA,MAAM,KAAK,GAAG,IAAI,CAAC,mBAAmB,GAAG,EAAE;AAE3C,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE;AAClC,YAAA,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK;QACtD;IACF;IAEgB,IAAI,GAAA;QAClB,OAAO;AACL,YAAA,GAAG,EAAE,oBAAoB;YACzB,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,qBAAqB,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;AACxD,YAAA,IAAI,EAAE;;AAEC,YAAA,CAAA;SACR;IACH;IAEgB,aAAa,CAAC,IAAc,EAAE,MAAc,EAAA;AAC1D,QAAA,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,IAAI,CAAC,mBAAmB,EAAE,IAAI,CAAC;IAC7D;AACD;;;;"}
+{"version":3,"file":"RotateOverLifetime.js","names":[],"sources":["../../../src/modules/RotateOverLifetime.ts"],"sourcesContent":["import type { ParticleBatch } from '#ParticleStorage';\n\nimport { UpdateModule } from './UpdateModule';\nimport type { WgslContribution } from './WgslContribution';\n\n/**\n * Adds a constant angular acceleration to every live particle each frame\n * (analogous to the legacy `TorqueAffector`). The system's integrate pass\n * advances `rotation` from `rotationSpeed`; this module increments\n * `rotationSpeed` itself.\n *\n * Units: degrees per second². Negative values decelerate spin.\n *\n * GPU-eligible.\n */\nexport class RotateOverLifetime extends UpdateModule {\n  public angularAcceleration: number;\n\n  public constructor(angularAcceleration: number) {\n    super();\n    this.angularAcceleration = angularAcceleration;\n  }\n\n  public override apply(particles: ParticleBatch, dt: number): void {\n    const { speed: rotationSpeeds } = particles.rotation;\n    const liveCount = particles.count;\n    const delta = this.angularAcceleration * dt;\n\n    for (let i = 0; i < liveCount; i++) {\n      rotationSpeeds[i] = (rotationSpeeds[i] ?? 0) + delta;\n    }\n  }\n\n  public override wgsl(): WgslContribution {\n    return {\n      key: 'RotateOverLifetime',\n      uniforms: [{ name: 'angularAcceleration', type: 'f32' }],\n      body: `\n                rotInfo[idx].y = rotInfo[idx].y + modules.u_RotateOverLifetime.angularAcceleration * dt;\n            `,\n    };\n  }\n\n  public override writeUniforms(view: DataView, offset: number): void {\n    view.setFloat32(offset + 0, this.angularAcceleration, true);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAeA,IAAa,qBAAb,cAAwC,aAAa;CACnD,AAAO;CAEP,AAAO,YAAY,qBAA6B;EAC9C,MAAM;EACN,KAAK,sBAAsB;CAC7B;CAEA,AAAgB,MAAM,WAA0B,IAAkB;EAChE,MAAM,EAAE,OAAO,mBAAmB,UAAU;EAC5C,MAAM,YAAY,UAAU;EAC5B,MAAM,QAAQ,KAAK,sBAAsB;EAEzC,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,KAC7B,eAAe,MAAM,eAAe,MAAM,KAAK;CAEnD;CAEA,AAAgB,OAAyB;EACvC,OAAO;GACL,KAAK;GACL,UAAU,CAAC;IAAE,MAAM;IAAuB,MAAM;GAAM,CAAC;GACvD,MAAM;;;EAGR;CACF;CAEA,AAAgB,cAAc,MAAgB,QAAsB;EAClE,KAAK,WAAW,SAAS,GAAG,KAAK,qBAAqB,IAAI;CAC5D;AACF"}

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

@@ -1,5 +1,5 @@
-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';
 /**
@@ -11,15 +11,16 @@ import type { WgslContribution } from './WgslContribution';
  * curve up to peak then down), slow-grow (linear ramp).
  *
  * GPU-eligible: the curve is uploaded once as a 256-tap 1D R32F texture and
- * sampled with linear filtering on the GPU — no curve evaluation cost in
+ * sampled with linear filtering on the GPU - no curve evaluation cost in
  * the inner loop.
  */
 export declare class ScaleOverLifetime extends UpdateModule {
     curve: Curve;
     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;
 }
 /** Texture width for the curve lookup table. Exposed for ParticleGpuState. */
 export declare const scaleLookupSize = 256;
+//# sourceMappingURL=ScaleOverLifetime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScaleOverLifetime.d.ts","sourceRoot":"","sources":["../../../src/modules/ScaleOverLifetime.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;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;IAC1C,KAAK,EAAE,KAAK,CAAC;gBAED,KAAK,EAAE,KAAK;IAKf,KAAK,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAelD,IAAI,IAAI,gBAAgB;IAYxB,cAAc,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,GAAG,IAAI;CAoBnG;AAED,8EAA8E;AAC9E,eAAO,MAAM,eAAe,MAAa,CAAC"}

package/dist/esm/modules/ScaleOverLifetime.js

@@ -1,58 +1,68 @@
-import { UpdateModule } from './UpdateModule.js';
+import { UpdateModule } from "./UpdateModule.js";
 
-/// <reference types="@webgpu/types" />
+//#region src/modules/ScaleOverLifetime.ts
 const lookupSize = 256;
 /**
- * Sets every live particle's scale to a curve sampled at the particle's
- * current lifetime ratio. Both axes share one curve; non-uniform per-axis
- * scaling isn't supported by this module.
- *
- * Common patterns: shrink-to-zero (start at 1, end at 0), pulse (sine-like
- * curve up to peak then down), slow-grow (linear ramp).
- *
- * GPU-eligible: the curve is uploaded once as a 256-tap 1D R32F texture and
- * sampled with linear filtering on the GPU — no curve evaluation cost in
- * the inner loop.
- */
-class ScaleOverLifetime extends UpdateModule {
-    curve;
-    constructor(curve) {
-        super();
-        this.curve = curve;
-    }
-    apply(system, _dt) {
-        const { scaleX, scaleY, elapsed, lifetime, liveCount } = system;
-        const curve = this.curve;
-        for (let i = 0; i < liveCount; i++) {
-            const t = (elapsed[i] ?? 0) / (lifetime[i] ?? 1);
-            const s = curve.evaluate(t);
-            scaleX[i] = s;
-            scaleY[i] = s;
-        }
-    }
-    wgsl() {
-        return {
-            key: 'ScaleOverLifetime',
-            textures: [{ name: 'curve', format: 'r32float' }],
-            body: `
+* Sets every live particle's scale to a curve sampled at the particle's
+* current lifetime ratio. Both axes share one curve; non-uniform per-axis
+* scaling isn't supported by this module.
+*
+* Common patterns: shrink-to-zero (start at 1, end at 0), pulse (sine-like
+* curve up to peak then down), slow-grow (linear ramp).
+*
+* GPU-eligible: the curve is uploaded once as a 256-tap 1D R32F texture and
+* sampled with linear filtering on the GPU - no curve evaluation cost in
+* the inner loop.
+*/
+var ScaleOverLifetime = class extends UpdateModule {
+	curve;
+	constructor(curve) {
+		super();
+		this.curve = curve;
+	}
+	apply(particles, _dt) {
+		const { x: scaleX, y: scaleY } = particles.scale;
+		const { elapsed, lifetime } = particles.timing;
+		const liveCount = particles.count;
+		const curve = this.curve;
+		for (let i = 0; i < liveCount; i++) {
+			const t = (elapsed[i] ?? 0) / (lifetime[i] ?? 1);
+			const s = curve.evaluate(t);
+			scaleX[i] = s;
+			scaleY[i] = s;
+		}
+	}
+	wgsl() {
+		return {
+			key: "ScaleOverLifetime",
+			textures: [{
+				name: "curve",
+				format: "r32float"
+			}],
+			body: `
                 let scaleT = clamp(timing[idx].x / max(timing[idx].y, 0.000001), 0.0, 1.0);
                 let scaleSample = textureSampleLevel(u_ScaleOverLifetime_curve, u_ScaleOverLifetime_curve_sampler, scaleT, 0.0).r;
                 scales[idx] = vec2<f32>(scaleSample, scaleSample);
-            `,
-        };
-    }
-    uploadTextures(device, textures) {
-        const texture = textures.get('curve');
-        if (texture === undefined) {
-            return;
-        }
-        const data = new Float32Array(lookupSize);
-        for (let i = 0; i < lookupSize; i++) {
-            data[i] = this.curve.evaluate(i / (lookupSize - 1));
-        }
-        device.queue.writeTexture({ texture }, data.buffer, { offset: 0, bytesPerRow: lookupSize * 4, rowsPerImage: 1 }, { width: lookupSize, height: 1, depthOrArrayLayers: 1 });
-    }
-}
+            `
+		};
+	}
+	uploadTextures(device, textures) {
+		const texture = textures.get("curve");
+		if (texture === void 0) return;
+		const data = new Float32Array(lookupSize);
+		for (let i = 0; i < lookupSize; i++) data[i] = this.curve.evaluate(i / 255);
+		device.queue.writeTexture({ texture }, data.buffer, {
+			offset: 0,
+			bytesPerRow: lookupSize * 4,
+			rowsPerImage: 1
+		}, {
+			width: lookupSize,
+			height: 1,
+			depthOrArrayLayers: 1
+		});
+	}
+};
 
+//#endregion
 export { ScaleOverLifetime };
-//# sourceMappingURL=ScaleOverLifetime.js.map
+//# sourceMappingURL=ScaleOverLifetime.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"ScaleOverLifetime.js","sources":["../../../../src/modules/ScaleOverLifetime.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAAA;AAQA,MAAM,UAAU,GAAG,GAAG;AAEtB;;;;;;;;;;;AAWG;AACG,MAAO,iBAAkB,SAAQ,YAAY,CAAA;AAC1C,IAAA,KAAK;AAEZ,IAAA,WAAA,CAAmB,KAAY,EAAA;AAC7B,QAAA,KAAK,EAAE;AACP,QAAA,IAAI,CAAC,KAAK,GAAG,KAAK;IACpB;IAEgB,KAAK,CAAC,MAAsB,EAAE,GAAW,EAAA;AACvD,QAAA,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,GAAG,MAAM;AAC/D,QAAA,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK;AAExB,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE;AAClC,YAAA,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YAChD,MAAM,CAAC,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;AAE3B,YAAA,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC;AACb,YAAA,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC;QACf;IACF;IAEgB,IAAI,GAAA;QAClB,OAAO;AACL,YAAA,GAAG,EAAE,mBAAmB;YACxB,QAAQ,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC;AACjD,YAAA,IAAI,EAAE;;;;AAIC,YAAA,CAAA;SACR;IACH;IAEgB,cAAc,CAAC,MAAiB,EAAE,QAAyC,EAAA;QACzF,MAAM,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC;AAErC,QAAA,IAAI,OAAO,KAAK,SAAS,EAAE;YACzB;QACF;AAEA,QAAA,MAAM,IAAI,GAAG,IAAI,YAAY,CAAC,UAAU,CAAC;AAEzC,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,EAAE;AACnC,YAAA,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI,UAAU,GAAG,CAAC,CAAC,CAAC;QACrD;AAEA,QAAA,MAAM,CAAC,KAAK,CAAC,YAAY,CACvB,EAAE,OAAO,EAAE,EACX,IAAI,CAAC,MAAM,EACX,EAAE,MAAM,EAAE,CAAC,EAAE,WAAW,EAAE,UAAU,GAAG,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,EAC3D,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC,EAAE,kBAAkB,EAAE,CAAC,EAAE,CACxD;IACH;AACD;;;;"}
+{"version":3,"file":"ScaleOverLifetime.js","names":[],"sources":["../../../src/modules/ScaleOverLifetime.ts"],"sourcesContent":["/// <reference types=\"@webgpu/types\" />\n\nimport type { Curve } from '#distributions/Curve';\nimport type { ParticleBatch } from '#ParticleStorage';\n\nimport { UpdateModule } from './UpdateModule';\nimport type { WgslContribution } from './WgslContribution';\n\nconst lookupSize = 256;\n\n/**\n * Sets every live particle's scale to a curve sampled at the particle's\n * current lifetime ratio. Both axes share one curve; non-uniform per-axis\n * scaling isn't supported by this module.\n *\n * Common patterns: shrink-to-zero (start at 1, end at 0), pulse (sine-like\n * curve up to peak then down), slow-grow (linear ramp).\n *\n * GPU-eligible: the curve is uploaded once as a 256-tap 1D R32F texture and\n * sampled with linear filtering on the GPU - no curve evaluation cost in\n * the inner loop.\n */\nexport class ScaleOverLifetime extends UpdateModule {\n  public curve: Curve;\n\n  public constructor(curve: Curve) {\n    super();\n    this.curve = curve;\n  }\n\n  public override apply(particles: ParticleBatch, _dt: number): void {\n    const { x: scaleX, y: scaleY } = particles.scale;\n    const { elapsed, lifetime } = particles.timing;\n    const liveCount = particles.count;\n    const curve = this.curve;\n\n    for (let i = 0; i < liveCount; i++) {\n      const t = (elapsed[i] ?? 0) / (lifetime[i] ?? 1);\n      const s = curve.evaluate(t);\n\n      scaleX[i] = s;\n      scaleY[i] = s;\n    }\n  }\n\n  public override wgsl(): WgslContribution {\n    return {\n      key: 'ScaleOverLifetime',\n      textures: [{ name: 'curve', format: 'r32float' }],\n      body: `\n                let scaleT = clamp(timing[idx].x / max(timing[idx].y, 0.000001), 0.0, 1.0);\n                let scaleSample = textureSampleLevel(u_ScaleOverLifetime_curve, u_ScaleOverLifetime_curve_sampler, scaleT, 0.0).r;\n                scales[idx] = vec2<f32>(scaleSample, scaleSample);\n            `,\n    };\n  }\n\n  public override uploadTextures(device: GPUDevice, textures: ReadonlyMap<string, GPUTexture>): void {\n    const texture = textures.get('curve');\n\n    if (texture === undefined) {\n      return;\n    }\n\n    const data = new Float32Array(lookupSize);\n\n    for (let i = 0; i < lookupSize; i++) {\n      data[i] = this.curve.evaluate(i / (lookupSize - 1));\n    }\n\n    device.queue.writeTexture(\n      { texture },\n      data.buffer,\n      { offset: 0, bytesPerRow: lookupSize * 4, rowsPerImage: 1 },\n      { width: lookupSize, height: 1, depthOrArrayLayers: 1 },\n    );\n  }\n}\n\n/** Texture width for the curve lookup table. Exposed for ParticleGpuState. */\nexport const scaleLookupSize = lookupSize;\n"],"mappings":";;;AAQA,MAAM,aAAa;;;;;;;;;;;;;AAcnB,IAAa,oBAAb,cAAuC,aAAa;CAClD,AAAO;CAEP,AAAO,YAAY,OAAc;EAC/B,MAAM;EACN,KAAK,QAAQ;CACf;CAEA,AAAgB,MAAM,WAA0B,KAAmB;EACjE,MAAM,EAAE,GAAG,QAAQ,GAAG,WAAW,UAAU;EAC3C,MAAM,EAAE,SAAS,aAAa,UAAU;EACxC,MAAM,YAAY,UAAU;EAC5B,MAAM,QAAQ,KAAK;EAEnB,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,KAAK;GAClC,MAAM,KAAK,QAAQ,MAAM,MAAM,SAAS,MAAM;GAC9C,MAAM,IAAI,MAAM,SAAS,CAAC;GAE1B,OAAO,KAAK;GACZ,OAAO,KAAK;EACd;CACF;CAEA,AAAgB,OAAyB;EACvC,OAAO;GACL,KAAK;GACL,UAAU,CAAC;IAAE,MAAM;IAAS,QAAQ;GAAW,CAAC;GAChD,MAAM;;;;;EAKR;CACF;CAEA,AAAgB,eAAe,QAAmB,UAAiD;EACjG,MAAM,UAAU,SAAS,IAAI,OAAO;EAEpC,IAAI,YAAY,QACd;EAGF,MAAM,OAAO,IAAI,aAAa,UAAU;EAExC,KAAK,IAAI,IAAI,GAAG,IAAI,YAAY,KAC9B,KAAK,KAAK,KAAK,MAAM,SAAS,IAAK,GAAe;EAGpD,OAAO,MAAM,aACX,EAAE,QAAQ,GACV,KAAK,QACL;GAAE,QAAQ;GAAG,aAAa,aAAa;GAAG,cAAc;EAAE,GAC1D;GAAE,OAAO;GAAY,QAAQ;GAAG,oBAAoB;EAAE,CACxD;CACF;AACF"}

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

@@ -1,30 +1,33 @@
-import type { ParticleSystem } from "#ParticleSystem";
+import type { ParticleEmitter } from '#ParticleStorage';
 /**
- * Per-frame particle spawner. Subclasses decide how many particles to emit
- * each tick (rate-based, burst, on-demand) and write their initial values
- * directly into the system's typed-array slots.
+ * Per-frame particle spawner. Subclasses decide how many particles to emit each
+ * tick (rate-based, burst, on-demand) and fill each emitted particle's initial
+ * values.
  *
  * Implementation pattern:
  *
  * ```ts
- * apply(system, dt) {
+ * apply(emitter, dt) {
  *     const count = this.computeSpawnCount(dt);
  *     for (let i = 0; i < count; i++) {
- *         const slot = system.spawn();
- *         if (slot < 0) break;          // capacity exhausted
- *         system.posX[slot] = ...;
- *         system.velX[slot] = ...;
- *         system.lifetime[slot] = ...;
- *         // ...etc
+ *         const particle = emitter.emit();
+ *         if (!particle) break;         // capacity exhausted
+ *         particle.position.set(x, y);
+ *         particle.velocity.set(vx, vy);
+ *         particle.lifetime = 2;
  *     }
  * }
  * ```
  *
+ * A writer belongs to the emission that produced it: the next `emit()` rebinds
+ * it, so fill it before emitting again.
+ *
  * Spawn modules run before integration each frame. Multiple modules can be
  * registered on one system and execute in registration order.
  */
 export declare abstract class SpawnModule {
-    abstract apply(system: ParticleSystem, dt: number): void;
+    abstract apply(emitter: ParticleEmitter, dt: number): void;
     /** Optional cleanup hook called from `ParticleSystem.destroy`. */
     destroy(): void;
 }
+//# sourceMappingURL=SpawnModule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SpawnModule.d.ts","sourceRoot":"","sources":["../../../src/modules/SpawnModule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,8BAAsB,WAAW;aACf,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IACjE,kEAAkE;IAC3D,OAAO,IAAI,IAAI;CACvB"}

package/dist/esm/modules/SpawnModule.js

@@ -1,31 +1,35 @@
+//#region src/modules/SpawnModule.ts
 /**
- * Per-frame particle spawner. Subclasses decide how many particles to emit
- * each tick (rate-based, burst, on-demand) and write their initial values
- * directly into the system's typed-array slots.
- *
- * Implementation pattern:
- *
- * ```ts
- * apply(system, dt) {
- *     const count = this.computeSpawnCount(dt);
- *     for (let i = 0; i < count; i++) {
- *         const slot = system.spawn();
- *         if (slot < 0) break;          // capacity exhausted
- *         system.posX[slot] = ...;
- *         system.velX[slot] = ...;
- *         system.lifetime[slot] = ...;
- *         // ...etc
- *     }
- * }
- * ```
- *
- * Spawn modules run before integration each frame. Multiple modules can be
- * registered on one system and execute in registration order.
- */
-class SpawnModule {
-    /** Optional cleanup hook called from `ParticleSystem.destroy`. */
-    destroy() { }
-}
+* Per-frame particle spawner. Subclasses decide how many particles to emit each
+* tick (rate-based, burst, on-demand) and fill each emitted particle's initial
+* values.
+*
+* Implementation pattern:
+*
+* ```ts
+* apply(emitter, dt) {
+*     const count = this.computeSpawnCount(dt);
+*     for (let i = 0; i < count; i++) {
+*         const particle = emitter.emit();
+*         if (!particle) break;         // capacity exhausted
+*         particle.position.set(x, y);
+*         particle.velocity.set(vx, vy);
+*         particle.lifetime = 2;
+*     }
+* }
+* ```
+*
+* A writer belongs to the emission that produced it: the next `emit()` rebinds
+* it, so fill it before emitting again.
+*
+* Spawn modules run before integration each frame. Multiple modules can be
+* registered on one system and execute in registration order.
+*/
+var SpawnModule = class {
+	/** Optional cleanup hook called from `ParticleSystem.destroy`. */
+	destroy() {}
+};
 
+//#endregion
 export { SpawnModule };
-//# sourceMappingURL=SpawnModule.js.map
+//# sourceMappingURL=SpawnModule.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"SpawnModule.js","sources":["../../../../src/modules/SpawnModule.ts"],"sourcesContent":[null],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;MACmB,WAAW,CAAA;;AAGxB,IAAA,OAAO,KAAU;AACzB;;;;"}
+{"version":3,"file":"SpawnModule.js","names":[],"sources":["../../../src/modules/SpawnModule.ts"],"sourcesContent":["import type { ParticleEmitter } from '#ParticleStorage';\n\n/**\n * Per-frame particle spawner. Subclasses decide how many particles to emit each\n * tick (rate-based, burst, on-demand) and fill each emitted particle's initial\n * values.\n *\n * Implementation pattern:\n *\n * ```ts\n * apply(emitter, dt) {\n *     const count = this.computeSpawnCount(dt);\n *     for (let i = 0; i < count; i++) {\n *         const particle = emitter.emit();\n *         if (!particle) break;         // capacity exhausted\n *         particle.position.set(x, y);\n *         particle.velocity.set(vx, vy);\n *         particle.lifetime = 2;\n *     }\n * }\n * ```\n *\n * A writer belongs to the emission that produced it: the next `emit()` rebinds\n * it, so fill it before emitting again.\n *\n * Spawn modules run before integration each frame. Multiple modules can be\n * registered on one system and execute in registration order.\n */\nexport abstract class SpawnModule {\n  public abstract apply(emitter: ParticleEmitter, dt: number): void;\n  /** Optional cleanup hook called from `ParticleSystem.destroy`. */\n  public destroy(): void {}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAsB,cAAtB,MAAkC;;CAGhC,AAAO,UAAgB,CAAC;AAC1B"}

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

@@ -1,18 +1,21 @@
-import type { ParticleSystem } from "#ParticleSystem";
+import type { ParticleDeathContext } from '#ParticleStorage';
+import type { ParticleSystem } from '#ParticleSystem';
 import { DeathModule } from './DeathModule';
 import type { SpawnModule } from './SpawnModule';
 /**
- * Sub-emitter: triggers a child {@link SpawnModule} on a target system at
- * the dying particle's position. Use for explosion-on-impact, sparks at
- * end-of-life, multi-stage VFX.
+ * Sub-emitter: triggers a child {@link SpawnModule} on a target system at the
+ * dying particle's position. Use for explosion-on-impact, sparks at end of
+ * life, multi-stage VFX.
  *
- * The child module receives a synthesized `dt` of 0 — it must spawn
+ * The child module receives a synthesized `dt` of 0 - it must spawn
  * immediately rather than rely on rate accumulation. {@link BurstSpawn}
  * works naturally; {@link RateSpawn} is the wrong fit here.
  *
- * Position is the only field forwarded — child distributions decide
- * everything else. To keep child particles riding the parent's velocity,
- * configure the child's velocity distribution to match.
+ * Position is the only field taken from the dying particle - child
+ * distributions decide everything else, and their sampled positions are treated
+ * as offsets from the death position. To keep child particles riding the
+ * parent's velocity, configure the child's velocity distribution to match, or
+ * read {@link ParticleDeathContext.velocityX} in a custom death module.
  */
 export declare class SpawnOnDeath extends DeathModule {
     targetSystem: ParticleSystem;
@@ -20,5 +23,6 @@ export declare class SpawnOnDeath extends DeathModule {
     /** Number of times to invoke the spawner per dying particle. Default 1. */
     count: number;
     constructor(targetSystem: ParticleSystem, spawner: SpawnModule, count?: number);
-    onDeath(parent: ParticleSystem, slot: number): void;
+    onDeath(_system: ParticleSystem, death: ParticleDeathContext): void;
 }
+//# sourceMappingURL=SpawnOnDeath.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SpawnOnDeath.d.ts","sourceRoot":"","sources":["../../../src/modules/SpawnOnDeath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,YAAa,SAAQ,WAAW;IACpC,YAAY,EAAE,cAAc,CAAC;IAC7B,OAAO,EAAE,WAAW,CAAC;IAE5B,2EAA2E;IACpE,KAAK,EAAE,MAAM,CAAC;gBAEF,YAAY,EAAE,cAAc,EAAE,OAAO,EAAE,WAAW,EAAE,KAAK,SAAI;IAOhE,OAAO,CAAC,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,oBAAoB,GAAG,IAAI;CAoBpF"}

package/dist/esm/modules/SpawnOnDeath.js

@@ -1,47 +1,45 @@
-import { DeathModule } from './DeathModule.js';
+import { DeathModule } from "./DeathModule.js";
 
+//#region src/modules/SpawnOnDeath.ts
 /**
- * Sub-emitter: triggers a child {@link SpawnModule} on a target system at
- * the dying particle's position. Use for explosion-on-impact, sparks at
- * end-of-life, multi-stage VFX.
- *
- * The child module receives a synthesized `dt` of 0 — it must spawn
- * immediately rather than rely on rate accumulation. {@link BurstSpawn}
- * works naturally; {@link RateSpawn} is the wrong fit here.
- *
- * Position is the only field forwarded — child distributions decide
- * everything else. To keep child particles riding the parent's velocity,
- * configure the child's velocity distribution to match.
- */
-class SpawnOnDeath extends DeathModule {
-    targetSystem;
-    spawner;
-    /** Number of times to invoke the spawner per dying particle. Default 1. */
-    count;
-    constructor(targetSystem, spawner, count = 1) {
-        super();
-        this.targetSystem = targetSystem;
-        this.spawner = spawner;
-        this.count = count;
-    }
-    onDeath(parent, slot) {
-        const target = this.targetSystem;
-        const x = parent.posX[slot] ?? 0;
-        const y = parent.posY[slot] ?? 0;
-        // Snapshot the target's pre-spawn count so we can apply the
-        // position to whichever slots the spawner adds.
-        const before = target.liveCount;
-        for (let n = 0; n < this.count; n++) {
-            this.spawner.apply(target, 0);
-        }
-        const added = target.liveCount - before;
-        for (let i = 0; i < added; i++) {
-            const dst = before + i;
-            target.posX[dst] = (target.posX[dst] ?? 0) + x;
-            target.posY[dst] = (target.posY[dst] ?? 0) + y;
-        }
-    }
-}
+* Sub-emitter: triggers a child {@link SpawnModule} on a target system at the
+* dying particle's position. Use for explosion-on-impact, sparks at end of
+* life, multi-stage VFX.
+*
+* The child module receives a synthesized `dt` of 0 - it must spawn
+* immediately rather than rely on rate accumulation. {@link BurstSpawn}
+* works naturally; {@link RateSpawn} is the wrong fit here.
+*
+* Position is the only field taken from the dying particle - child
+* distributions decide everything else, and their sampled positions are treated
+* as offsets from the death position. To keep child particles riding the
+* parent's velocity, configure the child's velocity distribution to match, or
+* read {@link ParticleDeathContext.velocityX} in a custom death module.
+*/
+var SpawnOnDeath = class extends DeathModule {
+	targetSystem;
+	spawner;
+	/** Number of times to invoke the spawner per dying particle. Default 1. */
+	count;
+	constructor(targetSystem, spawner, count = 1) {
+		super();
+		this.targetSystem = targetSystem;
+		this.spawner = spawner;
+		this.count = count;
+	}
+	onDeath(_system, death) {
+		const target = this.targetSystem;
+		const previous = target._beginSpawnRecording();
+		let spawned;
+		try {
+			for (let n = 0; n < this.count; n++) this.spawner.apply(target, 0);
+		} finally {
+			spawned = target._endSpawnRecording(previous);
+		}
+		target._offsetSpawned(spawned, death.x, death.y);
+	}
+};
 
+//#endregion
 export { SpawnOnDeath };
-//# sourceMappingURL=SpawnOnDeath.js.map
+//# sourceMappingURL=SpawnOnDeath.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"SpawnOnDeath.js","sources":["../../../../src/modules/SpawnOnDeath.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAKA;;;;;;;;;;;;AAYG;AACG,MAAO,YAAa,SAAQ,WAAW,CAAA;AACpC,IAAA,YAAY;AACZ,IAAA,OAAO;;AAGP,IAAA,KAAK;AAEZ,IAAA,WAAA,CAAmB,YAA4B,EAAE,OAAoB,EAAE,KAAK,GAAG,CAAC,EAAA;AAC9E,QAAA,KAAK,EAAE;AACP,QAAA,IAAI,CAAC,YAAY,GAAG,YAAY;AAChC,QAAA,IAAI,CAAC,OAAO,GAAG,OAAO;AACtB,QAAA,IAAI,CAAC,KAAK,GAAG,KAAK;IACpB;IAEgB,OAAO,CAAC,MAAsB,EAAE,IAAY,EAAA;AAC1D,QAAA,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY;QAChC,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;QAChC,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;;;AAIhC,QAAA,MAAM,MAAM,GAAG,MAAM,CAAC,SAAS;AAE/B,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE;YACnC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;QAC/B;AAEA,QAAA,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,GAAG,MAAM;AAEvC,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE;AAC9B,YAAA,MAAM,GAAG,GAAG,MAAM,GAAG,CAAC;AAEtB,YAAA,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;AAC9C,YAAA,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;QAChD;IACF;AACD;;;;"}
+{"version":3,"file":"SpawnOnDeath.js","names":[],"sources":["../../../src/modules/SpawnOnDeath.ts"],"sourcesContent":["import type { ParticleDeathContext } from '#ParticleStorage';\nimport type { ParticleSystem } from '#ParticleSystem';\n\nimport { DeathModule } from './DeathModule';\nimport type { SpawnModule } from './SpawnModule';\n\n/**\n * Sub-emitter: triggers a child {@link SpawnModule} on a target system at the\n * dying particle's position. Use for explosion-on-impact, sparks at end of\n * life, multi-stage VFX.\n *\n * The child module receives a synthesized `dt` of 0 - it must spawn\n * immediately rather than rely on rate accumulation. {@link BurstSpawn}\n * works naturally; {@link RateSpawn} is the wrong fit here.\n *\n * Position is the only field taken from the dying particle - child\n * distributions decide everything else, and their sampled positions are treated\n * as offsets from the death position. To keep child particles riding the\n * parent's velocity, configure the child's velocity distribution to match, or\n * read {@link ParticleDeathContext.velocityX} in a custom death module.\n */\nexport class SpawnOnDeath extends DeathModule {\n  public targetSystem: ParticleSystem;\n  public spawner: SpawnModule;\n\n  /** Number of times to invoke the spawner per dying particle. Default 1. */\n  public count: number;\n\n  public constructor(targetSystem: ParticleSystem, spawner: SpawnModule, count = 1) {\n    super();\n    this.targetSystem = targetSystem;\n    this.spawner = spawner;\n    this.count = count;\n  }\n\n  public override onDeath(_system: ParticleSystem, death: ParticleDeathContext): void {\n    const target = this.targetSystem;\n\n    // Which particles the spawner produced cannot be derived from the target's\n    // live count: on the GPU path an emission recycles a dead slot below the\n    // high-water mark, so the count can stay put while particles are added, and\n    // the reused slots are scattered rather than contiguous.\n    const previous = target._beginSpawnRecording();\n    let spawned: readonly number[];\n\n    try {\n      for (let n = 0; n < this.count; n++) {\n        this.spawner.apply(target, 0);\n      }\n    } finally {\n      spawned = target._endSpawnRecording(previous);\n    }\n\n    target._offsetSpawned(spawned, death.x, death.y);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAqBA,IAAa,eAAb,cAAkC,YAAY;CAC5C,AAAO;CACP,AAAO;;CAGP,AAAO;CAEP,AAAO,YAAY,cAA8B,SAAsB,QAAQ,GAAG;EAChF,MAAM;EACN,KAAK,eAAe;EACpB,KAAK,UAAU;EACf,KAAK,QAAQ;CACf;CAEA,AAAgB,QAAQ,SAAyB,OAAmC;EAClF,MAAM,SAAS,KAAK;EAMpB,MAAM,WAAW,OAAO,qBAAqB;EAC7C,IAAI;EAEJ,IAAI;GACF,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,OAAO,KAC9B,KAAK,QAAQ,MAAM,QAAQ,CAAC;EAEhC,UAAU;GACR,UAAU,OAAO,mBAAmB,QAAQ;EAC9C;EAEA,OAAO,eAAe,SAAS,MAAM,GAAG,MAAM,CAAC;CACjD;AACF"}

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

@@ -1,9 +1,9 @@
-import type { ParticleSystem } from "#ParticleSystem";
+import type { ParticleBatch } from '#ParticleStorage';
 import { UpdateModule } from './UpdateModule';
 import type { WgslContribution } from './WgslContribution';
 /**
  * Adds a smooth pseudo-random force field that animates over time.
- * Implemented as 2D value noise with cubic Hermite smoothing — sampled
+ * 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.
@@ -24,7 +24,8 @@ export declare class Turbulence extends UpdateModule {
     timeScale: number;
     private _time;
     constructor(strength: number, frequency?: number, timeScale?: number);
-    apply(system: ParticleSystem, dt: number): void;
+    apply(particles: ParticleBatch, dt: number): void;
     wgsl(): WgslContribution;
     writeUniforms(view: DataView, offset: number, dt: number): void;
 }
+//# sourceMappingURL=Turbulence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Turbulence.d.ts","sourceRoot":"","sources":["../../../src/modules/Turbulence.ts"],"names":[],"mappings":"AAAA,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;AAE3D;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,UAAW,SAAQ,YAAY;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,KAAK,CAAK;gBAEC,QAAQ,EAAE,MAAM,EAAE,SAAS,SAAO,EAAE,SAAS,SAAI;IAOpD,KAAK,CAAC,SAAS,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAqBjD,IAAI,IAAI,gBAAgB;IA4CxB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;CAWhF"}