sparcoon 0.0.6 → 0.0.8

package/dist/_virtual/2d.js

@@ -0,0 +1,3 @@
+var _2d = {};
+
+export { _2d as __exports };

package/dist/_virtual/3d.js

@@ -0,0 +1,3 @@
+var _3d = {};
+
+export { _3d as __exports };

package/dist/_virtual/4d.js

@@ -0,0 +1,3 @@
+var _4d = {};
+
+export { _4d as __exports };

package/dist/_virtual/mod.js

@@ -0,0 +1,5 @@
+import { __require as requireMod } from '../node_modules/fast-simplex-noise/lib/mod.js';
+
+var modExports = requireMod();
+
+export { modExports as m };

package/dist/_virtual/mod2.js

@@ -0,0 +1,3 @@
+var mod = {};
+
+export { mod as __exports };

package/dist/behaviorModules/FXBehaviorDirectionalGravity.js

@@ -1,5 +1,5 @@
 import { assertValidNumber } from '../miscellaneous/asserts.js';
-import { resolveFXVector2Config, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y } from '../miscellaneous/miscellaneous.js';
+import { resolveFXVector3Config, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z } from '../miscellaneous/miscellaneous.js';
 import { FXBehaviorModule } from './FXBehaviorModule.js';
 
 /**
@@ -15,9 +15,10 @@ class FXBehaviorDirectionalGravity extends FXBehaviorModule {
         super();
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
-        this._private_directionInternal = resolveFXVector2Config(direction);
+        this._private_directionInternal = resolveFXVector3Config(direction);
         assertValidNumber(this._private_directionInternal.x, "FXBehaviorDirectionalGravity.constructor.direction.x");
         assertValidNumber(this._private_directionInternal.y, "FXBehaviorDirectionalGravity.constructor.direction.y");
+        assertValidNumber(this._private_directionInternal.z, "FXBehaviorDirectionalGravity.constructor.direction.z");
     }
     /** Acceleration vector in units/second² */
     get direction() {
@@ -25,9 +26,10 @@ class FXBehaviorDirectionalGravity extends FXBehaviorModule {
     }
     /** Acceleration vector in units/second² */
     set direction(value) {
-        this._private_directionInternal = resolveFXVector2Config(value);
+        this._private_directionInternal = resolveFXVector3Config(value);
         assertValidNumber(this._private_directionInternal.x, "FXBehaviorDirectionalGravity.direction.x");
         assertValidNumber(this._private_directionInternal.y, "FXBehaviorDirectionalGravity.direction.y");
+        assertValidNumber(this._private_directionInternal.z, "FXBehaviorDirectionalGravity.direction.z");
     }
     /** @internal */
     update(properties, instanceCount, deltaTime) {
@@ -35,10 +37,12 @@ class FXBehaviorDirectionalGravity extends FXBehaviorModule {
         const { array, itemSize } = builtin;
         const offsetX = this._private_directionInternal.x * deltaTime;
         const offsetY = this._private_directionInternal.y * deltaTime;
+        const offsetZ = this._private_directionInternal.z * deltaTime;
         for (let i = 0; i < instanceCount; i++) {
             const itemOffset = i * itemSize;
             array[itemOffset + BUILTIN_OFFSET_VELOCITY_X] += offsetX;
             array[itemOffset + BUILTIN_OFFSET_VELOCITY_Y] += offsetY;
+            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Z] += offsetZ;
         }
         builtin.needsUpdate = true;
     }

package/dist/behaviorModules/FXBehaviorPointGravity.js

@@ -1,6 +1,6 @@
 import { MathUtils } from 'three';
 import { assertValidNumber } from '../miscellaneous/asserts.js';
-import { resolveFXVector2Config, resolveFXRangeConfig, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y } from '../miscellaneous/miscellaneous.js';
+import { resolveFXVector3Config, resolveFXRangeConfig, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z } from '../miscellaneous/miscellaneous.js';
 import { FXBehaviorModule } from './FXBehaviorModule.js';
 
 /**
@@ -19,9 +19,10 @@ class FXBehaviorPointGravity extends FXBehaviorModule {
         super();
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
-        this._private_centerInternal = resolveFXVector2Config(center);
+        this._private_centerInternal = resolveFXVector3Config(center);
         assertValidNumber(this._private_centerInternal.x, "FXBehaviorPointGravity.constructor.center.x");
         assertValidNumber(this._private_centerInternal.y, "FXBehaviorPointGravity.constructor.center.y");
+        assertValidNumber(this._private_centerInternal.z, "FXBehaviorPointGravity.constructor.center.z");
         this._private_strengthInternal = resolveFXRangeConfig(strength);
         assertValidNumber(this._private_strengthInternal.min, "FXBehaviorPointGravity.constructor.strength.min");
         assertValidNumber(this._private_strengthInternal.max, "FXBehaviorPointGravity.constructor.strength.max");
@@ -50,9 +51,10 @@ class FXBehaviorPointGravity extends FXBehaviorModule {
     }
     /** Gravity center position */
     set center(value) {
-        this._private_centerInternal = resolveFXVector2Config(value);
+        this._private_centerInternal = resolveFXVector3Config(value);
         assertValidNumber(this._private_centerInternal.x, "FXBehaviorPointGravity.center.x");
         assertValidNumber(this._private_centerInternal.y, "FXBehaviorPointGravity.center.y");
+        assertValidNumber(this._private_centerInternal.z, "FXBehaviorPointGravity.center.z");
     }
     /** Force multiplier range */
     set strength(value) {
@@ -80,11 +82,12 @@ class FXBehaviorPointGravity extends FXBehaviorModule {
             const itemOffset = i * itemSize;
             const dx = this._private_centerInternal.x - array[itemOffset + BUILTIN_OFFSET_POSITION_X];
             const dy = this._private_centerInternal.y - array[itemOffset + BUILTIN_OFFSET_POSITION_Y];
+            const dz = this._private_centerInternal.z - array[itemOffset + BUILTIN_OFFSET_POSITION_Z];
             // Constant over the life of a particle but different for each particle
             const thresholdT = array[itemOffset + BUILTIN_OFFSET_RANDOM_A];
             const threshold = MathUtils.lerp(this.threshold.min, this.threshold.max, thresholdT);
             const thresholdSquared = threshold * threshold;
-            const distanceSquared = dx * dx + dy * dy;
+            const distanceSquared = dx * dx + dy * dy + dz * dz;
             if (distanceSquared < thresholdSquared) {
                 continue;
             }
@@ -98,10 +101,13 @@ class FXBehaviorPointGravity extends FXBehaviorModule {
             const forceMagnitude = strength / Math.pow(distance, exponent);
             const directionX = dx / distance;
             const directionY = dy / distance;
+            const directionZ = dz / distance;
             const accelerationX = directionX * forceMagnitude;
             const accelerationY = directionY * forceMagnitude;
+            const accelerationZ = directionZ * forceMagnitude;
             array[itemOffset + BUILTIN_OFFSET_VELOCITY_X] += accelerationX * deltaTime;
             array[itemOffset + BUILTIN_OFFSET_VELOCITY_Y] += accelerationY * deltaTime;
+            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Z] += accelerationZ * deltaTime;
         }
         builtin.needsUpdate = true;
     }

package/dist/behaviorModules/FXBehaviorTorqueNoise.d.ts

@@ -1,4 +1,4 @@
-import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import type { FXRange, FXRangeConfig } from "../miscellaneous/miscellaneous";
 import { FXBehaviorModule } from "./FXBehaviorModule";
 /**
  * Applies noise-based angular acceleration to particles.

package/dist/behaviorModules/FXBehaviorTorqueNoise.js

@@ -1,8 +1,10 @@
+import { m as modExports } from '../_virtual/mod.js';
 import { MathUtils } from 'three';
 import { assertValidPositiveNumber, assertValidNonNegativeNumber } from '../miscellaneous/asserts.js';
-import { resolveFXRangeConfig, BUILTIN_OFFSET_RANDOM_C, generateNoise3D, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_TORQUE } from '../miscellaneous/miscellaneous.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_TORQUE } from '../miscellaneous/miscellaneous.js';
 import { FXBehaviorModule } from './FXBehaviorModule.js';
 
+const generateNoise3D = modExports.makeNoise3D();
 /**
  * Applies noise-based angular acceleration to particles.
  *

package/dist/behaviorModules/FXBehaviorVelocityDamping.js

@@ -1,6 +1,6 @@
 import { MathUtils } from 'three';
 import { assertValidNonNegativeNumber } from '../miscellaneous/asserts.js';
-import { resolveFXRangeConfig, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y } from '../miscellaneous/miscellaneous.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z } from '../miscellaneous/miscellaneous.js';
 import { FXBehaviorModule } from './FXBehaviorModule.js';
 
 /**
@@ -41,6 +41,7 @@ class FXBehaviorVelocityDamping extends FXBehaviorModule {
             const dampingFactor = Math.pow(1 - MathUtils.lerp(this._private_dampingInternal.min, this._private_dampingInternal.max, dampingT), deltaTime);
             array[itemOffset + BUILTIN_OFFSET_VELOCITY_X] *= dampingFactor;
             array[itemOffset + BUILTIN_OFFSET_VELOCITY_Y] *= dampingFactor;
+            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Z] *= dampingFactor;
         }
         builtin.needsUpdate = true;
     }

package/dist/behaviorModules/FXBehaviorVelocityNoise.d.ts

@@ -1,4 +1,4 @@
-import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import type { FXRange, FXRangeConfig } from "../miscellaneous/miscellaneous";
 import { FXBehaviorModule } from "./FXBehaviorModule";
 /**
  * Applies noise-based acceleration to particles.

package/dist/behaviorModules/FXBehaviorVelocityNoise.js

@@ -1,8 +1,12 @@
+import { m as modExports } from '../_virtual/mod.js';
 import { MathUtils } from 'three';
 import { assertValidPositiveNumber, assertValidNonNegativeNumber } from '../miscellaneous/asserts.js';
-import { resolveFXRangeConfig, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z, generateNoise3D } from '../miscellaneous/miscellaneous.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z } from '../miscellaneous/miscellaneous.js';
 import { FXBehaviorModule } from './FXBehaviorModule.js';
 
+const generateNoise3D0 = modExports.makeNoise3D();
+const generateNoise3D1 = modExports.makeNoise3D();
+const generateNoise3D2 = modExports.makeNoise3D();
 /**
  * Applies noise-based acceleration to particles.
  *
@@ -56,9 +60,9 @@ class FXBehaviorVelocityNoise extends FXBehaviorModule {
             // Constant over the life of a particle but different for each particle
             const scaleT = array[itemOffset + BUILTIN_OFFSET_RANDOM_C];
             const scale = MathUtils.lerp(this._private_scaleInternal.min, this._private_scaleInternal.max, scaleT);
-            const noiseX = generateNoise3D(x * scale, y * scale, z * scale);
-            const noiseY = generateNoise3D((x + 100) * scale, (y + 100) * scale, (z + 100) * scale);
-            const noiseZ = generateNoise3D((x - 200) * scale, (y - 200) * scale, (z - 200) * scale);
+            const noiseX = generateNoise3D0(x * scale, y * scale, z * scale);
+            const noiseY = generateNoise3D1(x * scale, y * scale, z * scale);
+            const noiseZ = generateNoise3D2(x * scale, y * scale, z * scale);
             // Constant over the life of a particle but different for each particle
             const strengthT = array[itemOffset + BUILTIN_OFFSET_RANDOM_A];
             const strength = MathUtils.lerp(this._private_strengthInternal.min, this._private_strengthInternal.max, strengthT);

package/dist/elements/FXEmitter.js

@@ -2,7 +2,7 @@ import { Object3D, NormalBlending } from 'three';
 import { FXInstancedParticle } from '../instancedParticle/FXInstancedParticle.js';
 import { collectProperties, collectUniforms } from '../instancedParticle/FXInstancedParticle.Internal.js';
 import { resolveGLSLTypeInfo } from '../instancedParticle/shared.js';
-import { BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_ROTATION, BUILTIN_OFFSET_TORQUE, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_RANDOM_C } from '../miscellaneous/miscellaneous.js';
+import { BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_VELOCITY_Z, BUILTIN_OFFSET_ROTATION, BUILTIN_OFFSET_TORQUE, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_RANDOM_C } from '../miscellaneous/miscellaneous.js';
 import { EMITTER_DEFAULT_EXPECTED_CAPACITY, EMITTER_DEFAULT_CAPACITY_STEP, EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES } from './FXEmitter.Internal.js';
 
 const INSTANCES = new Array();
@@ -58,6 +58,8 @@ class FXEmitter extends Object3D {
                         array[itemOffset + BUILTIN_OFFSET_VELOCITY_X] * deltaTime;
                     array[itemOffset + BUILTIN_OFFSET_POSITION_Y] +=
                         array[itemOffset + BUILTIN_OFFSET_VELOCITY_Y] * deltaTime;
+                    array[itemOffset + BUILTIN_OFFSET_POSITION_Z] +=
+                        array[itemOffset + BUILTIN_OFFSET_VELOCITY_Z] * deltaTime;
                 }
                 builtin.needsUpdate = true;
             }
@@ -73,11 +75,11 @@ class FXEmitter extends Object3D {
         const collectedProperties = {
             builtin: resolveGLSLTypeInfo("Matrix4"),
         };
-        collectProperties(collectedProperties, _private_spawnSequence, "UIEmitter.constructor.spawnSequence:");
-        collectProperties(collectedProperties, _private_behaviorSequence, "UIEmitter.constructor.behaviorSequence");
-        collectProperties(collectedProperties, _private_renderingSequence, "UIEmitter.constructor.renderingSequence");
+        collectProperties(collectedProperties, _private_spawnSequence, "FXEmitter.constructor.spawnSequence:");
+        collectProperties(collectedProperties, _private_behaviorSequence, "FXEmitter.constructor.behaviorSequence");
+        collectProperties(collectedProperties, _private_renderingSequence, "FXEmitter.constructor.renderingSequence");
         const collectedUniforms = {};
-        collectUniforms(collectedUniforms, _private_renderingSequence, "UIEmitter.constructor.renderingSequence");
+        collectUniforms(collectedUniforms, _private_renderingSequence, "FXEmitter.constructor.renderingSequence");
         this._private_mesh = new FXInstancedParticle(this._private_renderingSequence.map((module) => module.source), collectedUniforms, collectedProperties, options.expectedCapacity ?? EMITTER_DEFAULT_EXPECTED_CAPACITY, options.capacityStep ?? EMITTER_DEFAULT_CAPACITY_STEP, options.blending ?? NormalBlending, options.useAlphaHashing ?? false);
         this.automaticallyDestroyModules =
             options.automaticallyDestroyModules ?? EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES;

package/dist/instancedParticle/shared.d.ts

@@ -2,7 +2,7 @@ import type { IUniform, ShaderMaterial } from "three";
 import { Matrix3, Matrix4, Texture, Vector2, Vector3, Vector4 } from "three";
 import { FXColor } from "../color/FXColor";
 export type FXProperty = Texture | FXColor | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | number;
-export type FXPropertyName = "Texture" | "UIColor" | "Vector2" | "Vector3" | "Vector4" | "Matrix3" | "Matrix4" | "number";
+export type FXPropertyName = "Texture" | "FXColor" | "Vector2" | "Vector3" | "Vector4" | "Matrix3" | "Matrix4" | "number";
 export type FXPropertyConstructor = typeof Texture | typeof FXColor | typeof Vector2 | typeof Vector3 | typeof Vector4 | typeof Matrix3 | typeof Matrix4 | NumberConstructor;
 export type FXPropertyCopyTo = FXColor | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4;
 export type FXPropertyCopyFrom = FXColor & Vector2 & Vector3 & Vector4 & Matrix3 & Matrix4;
@@ -15,11 +15,5 @@ export interface GLProperty {
     value: FXProperty;
     glslTypeInfo: GLTypeInfo;
 }
-export interface PlaneData {
-    source: string;
-    properties: Record<string, GLProperty>;
-    transform: Matrix4;
-    visibility: boolean;
-}
 export declare function resolveGLSLTypeInfo(value: FXProperty | FXPropertyName | FXPropertyConstructor): GLTypeInfo;
 export declare function resolvePropertyUniform(name: string, material: ShaderMaterial): IUniform<FXProperty>;

package/dist/instancedParticle/shared.js

@@ -43,7 +43,7 @@ function resolveGLSLTypeInfo(value) {
                 return GLSL_TYPE_INFO_FLOAT;
             case "Texture":
                 return GLSL_TYPE_INFO_SAMPLER2D;
-            case "UIColor":
+            case "FXColor":
                 return GLSL_TYPE_INFO_VEC4;
             case "Vector2":
                 return GLSL_TYPE_INFO_VEC2;

package/dist/miscellaneous/miscellaneous.d.ts

@@ -11,9 +11,8 @@ export type FXRangeConfig = FXRange | [number, number, number] | number;
 export type FXVector3Config = Vector3Like | Vector3Tuple | number;
 export type FXAspectConfig = number | FXTextureConfig;
 export declare function resolveFXRangeConfig(config: FXRangeConfig): FXRange;
-export declare function resolveFXVector2Config(config: FXVector3Config): Vector3Like;
+export declare function resolveFXVector3Config(config: FXVector3Config): Vector3Like;
 export declare function resolveAspect(config: number | FXTextureConfig): number;
-export declare function generateNoise3D(x: number, y: number, z: number): number;
 export declare function buildGradientTexture(colors: FXColor[]): DataTexture;
 export declare const BUILTIN_OFFSET_POSITION_X = 0;
 export declare const BUILTIN_OFFSET_POSITION_Y = 1;

package/dist/miscellaneous/miscellaneous.js

@@ -9,7 +9,7 @@ function resolveFXRangeConfig(config) {
     }
     return config;
 }
-function resolveFXVector2Config(config) {
+function resolveFXVector3Config(config) {
     if (typeof config === "number") {
         return { x: config, y: config, z: config };
     }
@@ -27,10 +27,6 @@ function resolveAspect(config) {
     }
     return config.sourceSize.w / config.sourceSize.h;
 }
-function generateNoise3D(x, y, z) {
-    const noise = Math.sin(x * 12.9898 + y * 78.233 + z * 37.719) * 43758.5453123;
-    return (noise - Math.floor(noise)) * 2 - 1;
-}
 function buildGradientTexture(colors) {
     const width = colors.length;
     const height = 1;
@@ -63,4 +59,4 @@ const BUILTIN_OFFSET_RANDOM_A = 13;
 const BUILTIN_OFFSET_RANDOM_B = 14;
 const BUILTIN_OFFSET_RANDOM_C = 15;
 
-export { BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_LIFETIME, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_ROTATION, BUILTIN_OFFSET_SCALE_X, BUILTIN_OFFSET_SCALE_Y, BUILTIN_OFFSET_TORQUE, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z, buildGradientTexture, generateNoise3D, resolveAspect, resolveFXRangeConfig, resolveFXVector2Config };
+export { BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_LIFETIME, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_ROTATION, BUILTIN_OFFSET_SCALE_X, BUILTIN_OFFSET_SCALE_Y, BUILTIN_OFFSET_TORQUE, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z, buildGradientTexture, resolveAspect, resolveFXRangeConfig, resolveFXVector3Config };

package/dist/node_modules/fast-simplex-noise/lib/2d.js

@@ -0,0 +1,93 @@
+import { __exports as _2d } from '../../../_virtual/2d.js';
+
+var hasRequired_2d;
+
+function require_2d () {
+	if (hasRequired_2d) return _2d;
+	hasRequired_2d = 1;
+	/*
+	 * Based on example code by Stefan Gustavson (stegu@itn.liu.se).
+	 * Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
+	 * Better rank ordering method by Stefan Gustavson in 2012.
+	 *
+	 * This code was placed in the public domain by its original author,
+	 * Stefan Gustavson. You may use it as you see fit, but
+	 * attribution is appreciated.
+	 */
+	Object.defineProperty(_2d, "__esModule", { value: true });
+	_2d.makeNoise2D = void 0;
+	var G2 = (3.0 - Math.sqrt(3.0)) / 6.0;
+	var Grad = [
+	    [1, 1],
+	    [-1, 1],
+	    [1, -1],
+	    [-1, -1],
+	    [1, 0],
+	    [-1, 0],
+	    [1, 0],
+	    [-1, 0],
+	    [0, 1],
+	    [0, -1],
+	    [0, 1],
+	    [0, -1],
+	];
+	function makeNoise2D(random) {
+	    if (random === void 0) { random = Math.random; }
+	    var p = new Uint8Array(256);
+	    for (var i = 0; i < 256; i++)
+	        p[i] = i;
+	    var n;
+	    var q;
+	    for (var i = 255; i > 0; i--) {
+	        n = Math.floor((i + 1) * random());
+	        q = p[i];
+	        p[i] = p[n];
+	        p[n] = q;
+	    }
+	    var perm = new Uint8Array(512);
+	    var permMod12 = new Uint8Array(512);
+	    for (var i = 0; i < 512; i++) {
+	        perm[i] = p[i & 255];
+	        permMod12[i] = perm[i] % 12;
+	    }
+	    return function (x, y) {
+	        // Skew the input space to determine which simplex cell we're in
+	        var s = (x + y) * 0.5 * (Math.sqrt(3.0) - 1.0); // Hairy factor for 2D
+	        var i = Math.floor(x + s);
+	        var j = Math.floor(y + s);
+	        var t = (i + j) * G2;
+	        var X0 = i - t; // Unskew the cell origin back to (x,y) space
+	        var Y0 = j - t;
+	        var x0 = x - X0; // The x,y distances from the cell origin
+	        var y0 = y - Y0;
+	        // Determine which simplex we are in.
+	        var i1 = x0 > y0 ? 1 : 0;
+	        var j1 = x0 > y0 ? 0 : 1;
+	        // Offsets for corners
+	        var x1 = x0 - i1 + G2;
+	        var y1 = y0 - j1 + G2;
+	        var x2 = x0 - 1.0 + 2.0 * G2;
+	        var y2 = y0 - 1.0 + 2.0 * G2;
+	        // Work out the hashed gradient indices of the three simplex corners
+	        var ii = i & 255;
+	        var jj = j & 255;
+	        var g0 = Grad[permMod12[ii + perm[jj]]];
+	        var g1 = Grad[permMod12[ii + i1 + perm[jj + j1]]];
+	        var g2 = Grad[permMod12[ii + 1 + perm[jj + 1]]];
+	        // Calculate the contribution from the three corners
+	        var t0 = 0.5 - x0 * x0 - y0 * y0;
+	        var n0 = t0 < 0 ? 0.0 : Math.pow(t0, 4) * (g0[0] * x0 + g0[1] * y0);
+	        var t1 = 0.5 - x1 * x1 - y1 * y1;
+	        var n1 = t1 < 0 ? 0.0 : Math.pow(t1, 4) * (g1[0] * x1 + g1[1] * y1);
+	        var t2 = 0.5 - x2 * x2 - y2 * y2;
+	        var n2 = t2 < 0 ? 0.0 : Math.pow(t2, 4) * (g2[0] * x2 + g2[1] * y2);
+	        // Add contributions from each corner to get the final noise value.
+	        // The result is scaled to return values in the interval [-1, 1]
+	        return 70.14805770653952 * (n0 + n1 + n2);
+	    };
+	}
+	_2d.makeNoise2D = makeNoise2D;
+	return _2d;
+}
+
+export { require_2d as __require };

package/dist/node_modules/fast-simplex-noise/lib/3d.js

@@ -0,0 +1,142 @@
+import { __exports as _3d } from '../../../_virtual/3d.js';
+
+var hasRequired_3d;
+
+function require_3d () {
+	if (hasRequired_3d) return _3d;
+	hasRequired_3d = 1;
+	/*
+	 * Based on example code by Stefan Gustavson (stegu@itn.liu.se).
+	 * Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
+	 * Better rank ordering method by Stefan Gustavson in 2012.
+	 *
+	 * This code was placed in the public domain by its original author,
+	 * Stefan Gustavson. You may use it as you see fit, but
+	 * attribution is appreciated.
+	 */
+	Object.defineProperty(_3d, "__esModule", { value: true });
+	_3d.makeNoise3D = void 0;
+	var G3 = 1.0 / 6.0;
+	var Grad = [
+	    [1, 1, 0],
+	    [-1, 1, 0],
+	    [1, -1, 0],
+	    [-1, -1, 0],
+	    [1, 0, 1],
+	    [-1, 0, 1],
+	    [1, 0, -1],
+	    [-1, 0, -1],
+	    [0, 1, 1],
+	    [0, -1, -1],
+	    [0, 1, -1],
+	    [0, -1, -1],
+	];
+	function makeNoise3D(random) {
+	    if (random === void 0) { random = Math.random; }
+	    var p = new Uint8Array(256);
+	    for (var i = 0; i < 256; i++)
+	        p[i] = i;
+	    var n;
+	    var q;
+	    for (var i = 255; i > 0; i--) {
+	        n = Math.floor((i + 1) * random());
+	        q = p[i];
+	        p[i] = p[n];
+	        p[n] = q;
+	    }
+	    var perm = new Uint8Array(512);
+	    var permMod12 = new Uint8Array(512);
+	    for (var i = 0; i < 512; i++) {
+	        perm[i] = p[i & 255];
+	        permMod12[i] = perm[i] % 12;
+	    }
+	    return function (x, y, z) {
+	        // Skew the input space to determine which simplex cell we're in
+	        var s = (x + y + z) / 3.0; // Very nice and simple skew factor for 3D
+	        var i = Math.floor(x + s);
+	        var j = Math.floor(y + s);
+	        var k = Math.floor(z + s);
+	        var t = (i + j + k) * G3;
+	        var X0 = i - t; // Unskew the cell origin back to (x,y,z) space
+	        var Y0 = j - t;
+	        var Z0 = k - t;
+	        var x0 = x - X0; // The x,y,z distances from the cell origin
+	        var y0 = y - Y0;
+	        var z0 = z - Z0;
+	        // Deterine which simplex we are in
+	        var i1, j1, k1 // Offsets for second corner of simplex in (i,j,k) coords
+	        ;
+	        var i2, j2, k2 // Offsets for third corner of simplex in (i,j,k) coords
+	        ;
+	        if (x0 >= y0) {
+	            if (y0 >= z0) {
+	                i1 = i2 = j2 = 1;
+	                j1 = k1 = k2 = 0;
+	            }
+	            else if (x0 >= z0) {
+	                i1 = i2 = k2 = 1;
+	                j1 = k1 = j2 = 0;
+	            }
+	            else {
+	                k1 = i2 = k2 = 1;
+	                i1 = j1 = j2 = 0;
+	            }
+	        }
+	        else {
+	            if (y0 < z0) {
+	                k1 = j2 = k2 = 1;
+	                i1 = j1 = i2 = 0;
+	            }
+	            else if (x0 < z0) {
+	                j1 = j2 = k2 = 1;
+	                i1 = k1 = i2 = 0;
+	            }
+	            else {
+	                j1 = i2 = j2 = 1;
+	                i1 = k1 = k2 = 0;
+	            }
+	        }
+	        var x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
+	        var y1 = y0 - j1 + G3;
+	        var z1 = z0 - k1 + G3;
+	        var x2 = x0 - i2 + 2.0 * G3; // Offsets for third corner in (x,y,z) coords
+	        var y2 = y0 - j2 + 2.0 * G3;
+	        var z2 = z0 - k2 + 2.0 * G3;
+	        var x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords
+	        var y3 = y0 - 1.0 + 3.0 * G3;
+	        var z3 = z0 - 1.0 + 3.0 * G3;
+	        // Work out the hashed gradient indices of the four simplex corners
+	        var ii = i & 255;
+	        var jj = j & 255;
+	        var kk = k & 255;
+	        var g0 = Grad[permMod12[ii + perm[jj + perm[kk]]]];
+	        var g1 = Grad[permMod12[ii + i1 + perm[jj + j1 + perm[kk + k1]]]];
+	        var g2 = Grad[permMod12[ii + i2 + perm[jj + j2 + perm[kk + k2]]]];
+	        var g3 = Grad[permMod12[ii + 1 + perm[jj + 1 + perm[kk + 1]]]];
+	        // Calculate the contribution from the four corners
+	        var t0 = 0.5 - x0 * x0 - y0 * y0 - z0 * z0;
+	        var n0 = t0 < 0
+	            ? 0.0
+	            : Math.pow(t0, 4) * (g0[0] * x0 + g0[1] * y0 + g0[2] * z0);
+	        var t1 = 0.5 - x1 * x1 - y1 * y1 - z1 * z1;
+	        var n1 = t1 < 0
+	            ? 0.0
+	            : Math.pow(t1, 4) * (g1[0] * x1 + g1[1] * y1 + g1[2] * z1);
+	        var t2 = 0.5 - x2 * x2 - y2 * y2 - z2 * z2;
+	        var n2 = t2 < 0
+	            ? 0.0
+	            : Math.pow(t2, 4) * (g2[0] * x2 + g2[1] * y2 + g2[2] * z2);
+	        var t3 = 0.5 - x3 * x3 - y3 * y3 - z3 * z3;
+	        var n3 = t3 < 0
+	            ? 0.0
+	            : Math.pow(t3, 4) * (g3[0] * x3 + g3[1] * y3 + g3[2] * z3);
+	        // Add contributions from each corner to get the final noise value.
+	        // The result is scaled to stay just inside [-1,1]
+	        return 94.68493150681972 * (n0 + n1 + n2 + n3);
+	    };
+	}
+	_3d.makeNoise3D = makeNoise3D;
+	return _3d;
+}
+
+export { require_3d as __require };

package/dist/node_modules/fast-simplex-noise/lib/4d.js

@@ -0,0 +1,196 @@
+import { __exports as _4d } from '../../../_virtual/4d.js';
+
+var hasRequired_4d;
+
+function require_4d () {
+	if (hasRequired_4d) return _4d;
+	hasRequired_4d = 1;
+	/*
+	 * Based on example code by Stefan Gustavson (stegu@itn.liu.se).
+	 * Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
+	 * Better rank ordering method by Stefan Gustavson in 2012.
+	 *
+	 * This code was placed in the public domain by its original author,
+	 * Stefan Gustavson. You may use it as you see fit, but
+	 * attribution is appreciated.
+	 */
+	Object.defineProperty(_4d, "__esModule", { value: true });
+	_4d.makeNoise4D = void 0;
+	var G4 = (5.0 - Math.sqrt(5.0)) / 20.0;
+	var Grad = [
+	    [0, 1, 1, 1],
+	    [0, 1, 1, -1],
+	    [0, 1, -1, 1],
+	    [0, 1, -1, -1],
+	    [0, -1, 1, 1],
+	    [0, -1, 1, -1],
+	    [0, -1, -1, 1],
+	    [0, -1, -1, -1],
+	    [1, 0, 1, 1],
+	    [1, 0, 1, -1],
+	    [1, 0, -1, 1],
+	    [1, 0, -1, -1],
+	    [-1, 0, 1, 1],
+	    [-1, 0, 1, -1],
+	    [-1, 0, -1, 1],
+	    [-1, 0, -1, -1],
+	    [1, 1, 0, 1],
+	    [1, 1, 0, -1],
+	    [1, -1, 0, 1],
+	    [1, -1, 0, -1],
+	    [-1, 1, 0, 1],
+	    [-1, 1, 0, -1],
+	    [-1, -1, 0, 1],
+	    [-1, -1, 0, -1],
+	    [1, 1, 1, 0],
+	    [1, 1, -1, 0],
+	    [1, -1, 1, 0],
+	    [1, -1, -1, 0],
+	    [-1, 1, 1, 0],
+	    [-1, 1, -1, 0],
+	    [-1, -1, 1, 0],
+	    [-1, -1, -1, 0],
+	];
+	function makeNoise4D(random) {
+	    if (random === void 0) { random = Math.random; }
+	    var p = new Uint8Array(256);
+	    for (var i = 0; i < 256; i++)
+	        p[i] = i;
+	    var n;
+	    var q;
+	    for (var i = 255; i > 0; i--) {
+	        n = Math.floor((i + 1) * random());
+	        q = p[i];
+	        p[i] = p[n];
+	        p[n] = q;
+	    }
+	    var perm = new Uint8Array(512);
+	    var permMod12 = new Uint8Array(512);
+	    for (var i = 0; i < 512; i++) {
+	        perm[i] = p[i & 255];
+	        permMod12[i] = perm[i] % 12;
+	    }
+	    return function (x, y, z, w) {
+	        // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
+	        var s = (x + y + z + w) * (Math.sqrt(5.0) - 1.0) / 4.0; // Factor for 4D skewing
+	        var i = Math.floor(x + s);
+	        var j = Math.floor(y + s);
+	        var k = Math.floor(z + s);
+	        var l = Math.floor(w + s);
+	        var t = (i + j + k + l) * G4; // Factor for 4D unskewing
+	        var X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
+	        var Y0 = j - t;
+	        var Z0 = k - t;
+	        var W0 = l - t;
+	        var x0 = x - X0; // The x,y,z,w distances from the cell origin
+	        var y0 = y - Y0;
+	        var z0 = z - Z0;
+	        var w0 = w - W0;
+	        // To find out which of the 24 possible simplices we're in, we need to determine the
+	        // magnitude ordering of x0, y0, z0 and w0. Six pair-wise comparisons are performed between
+	        // each possible pair of the four coordinates, and the results are used to rank the numbers.
+	        var rankx = 0;
+	        var ranky = 0;
+	        var rankz = 0;
+	        var rankw = 0;
+	        if (x0 > y0)
+	            rankx++;
+	        else
+	            ranky++;
+	        if (x0 > z0)
+	            rankx++;
+	        else
+	            rankz++;
+	        if (x0 > w0)
+	            rankx++;
+	        else
+	            rankw++;
+	        if (y0 > z0)
+	            ranky++;
+	        else
+	            rankz++;
+	        if (y0 > w0)
+	            ranky++;
+	        else
+	            rankw++;
+	        if (z0 > w0)
+	            rankz++;
+	        else
+	            rankw++;
+	        // simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
+	        // Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
+	        // impossible. Only the 24 indices which have non-zero entries make any sense.
+	        // We use a thresholding to set the coordinates in turn from the largest magnitude.
+	        // Rank 3 denotes the largest coordinate.
+	        var i1 = rankx >= 3 ? 1 : 0;
+	        var j1 = ranky >= 3 ? 1 : 0;
+	        var k1 = rankz >= 3 ? 1 : 0;
+	        var l1 = rankw >= 3 ? 1 : 0;
+	        // Rank 2 denotes the second largest coordinate.
+	        var i2 = rankx >= 2 ? 1 : 0;
+	        var j2 = ranky >= 2 ? 1 : 0;
+	        var k2 = rankz >= 2 ? 1 : 0;
+	        var l2 = rankw >= 2 ? 1 : 0;
+	        // Rank 1 denotes the second smallest coordinate.
+	        var i3 = rankx >= 1 ? 1 : 0;
+	        var j3 = ranky >= 1 ? 1 : 0;
+	        var k3 = rankz >= 1 ? 1 : 0;
+	        var l3 = rankw >= 1 ? 1 : 0;
+	        // The fifth corner has all coordinate offsets = 1, so no need to compute that.
+	        var x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
+	        var y1 = y0 - j1 + G4;
+	        var z1 = z0 - k1 + G4;
+	        var w1 = w0 - l1 + G4;
+	        var x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords
+	        var y2 = y0 - j2 + 2.0 * G4;
+	        var z2 = z0 - k2 + 2.0 * G4;
+	        var w2 = w0 - l2 + 2.0 * G4;
+	        var x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords
+	        var y3 = y0 - j3 + 3.0 * G4;
+	        var z3 = z0 - k3 + 3.0 * G4;
+	        var w3 = w0 - l3 + 3.0 * G4;
+	        var x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords
+	        var y4 = y0 - 1.0 + 4.0 * G4;
+	        var z4 = z0 - 1.0 + 4.0 * G4;
+	        var w4 = w0 - 1.0 + 4.0 * G4;
+	        // Work out the hashed gradient indices of the five simplex corners
+	        var ii = i & 255;
+	        var jj = j & 255;
+	        var kk = k & 255;
+	        var ll = l & 255;
+	        var g0 = Grad[perm[ii + perm[jj + perm[kk + perm[ll]]]] %
+	            32];
+	        var g1 = Grad[perm[ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]]] % 32];
+	        var g2 = Grad[perm[ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]]] % 32];
+	        var g3 = Grad[perm[ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]]] % 32];
+	        var g4 = Grad[perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32];
+	        // Calculate the contribution from the five corners
+	        var t0 = 0.5 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
+	        var n0 = t0 < 0
+	            ? 0.0
+	            : Math.pow(t0, 4) * (g0[0] * x0 + g0[1] * y0 + g0[2] * z0 + g0[3] * w0);
+	        var t1 = 0.5 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
+	        var n1 = t1 < 0
+	            ? 0.0
+	            : Math.pow(t1, 4) * (g1[0] * x1 + g1[1] * y1 + g1[2] * z1 + g1[3] * w1);
+	        var t2 = 0.5 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
+	        var n2 = t2 < 0
+	            ? 0.0
+	            : Math.pow(t2, 4) * (g2[0] * x2 + g2[1] * y2 + g2[2] * z2 + g2[3] * w2);
+	        var t3 = 0.5 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
+	        var n3 = t3 < 0
+	            ? 0.0
+	            : Math.pow(t3, 4) * (g3[0] * x3 + g3[1] * y3 + g3[2] * z3 + g3[3] * w3);
+	        var t4 = 0.5 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
+	        var n4 = t4 < 0
+	            ? 0.0
+	            : Math.pow(t4, 4) * (g4[0] * x4 + g4[1] * y4 + g4[2] * z4 + g4[3] * w4);
+	        // Sum up and scale the result to cover the range [-1,1]
+	        return 72.37855765153665 * (n0 + n1 + n2 + n3 + n4);
+	    };
+	}
+	_4d.makeNoise4D = makeNoise4D;
+	return _4d;
+}
+
+export { require_4d as __require };

package/dist/node_modules/fast-simplex-noise/lib/mod.js

@@ -0,0 +1,24 @@
+import { __exports as mod } from '../../../_virtual/mod2.js';
+import { __require as require_2d } from './2d.js';
+import { __require as require_3d } from './3d.js';
+import { __require as require_4d } from './4d.js';
+
+var hasRequiredMod;
+
+function requireMod () {
+	if (hasRequiredMod) return mod;
+	hasRequiredMod = 1;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.makeNoise4D = exports$1.makeNoise3D = exports$1.makeNoise2D = void 0;
+		var _2d_1 = require_2d();
+		Object.defineProperty(exports$1, "makeNoise2D", { enumerable: true, get: function () { return _2d_1.makeNoise2D; } });
+		var _3d_1 = require_3d();
+		Object.defineProperty(exports$1, "makeNoise3D", { enumerable: true, get: function () { return _3d_1.makeNoise3D; } });
+		var _4d_1 = require_4d();
+		Object.defineProperty(exports$1, "makeNoise4D", { enumerable: true, get: function () { return _4d_1.makeNoise4D; } }); 
+	} (mod));
+	return mod;
+}
+
+export { requireMod as __require };

package/dist/renderingModules/FXRenderingColorOverLife.js

@@ -20,7 +20,7 @@ class FXRenderingColorOverLife extends FXRenderingModule {
         /** @internal */
         this.source = source;
         if (colors.length === 0) {
-            throw new Error("UIRenderingColorOverLife: colors array cannot be empty");
+            throw new Error("FXRenderingColorOverLife: colors array cannot be empty");
         }
         this.requiredUniforms = { colorOverLifeTexture: buildGradientTexture(colors) };
     }

package/dist/renderingModules/FXRenderingColorOverVelocity.js

@@ -21,10 +21,10 @@ class FXRenderingColorOverVelocity extends FXRenderingModule {
         /** @internal */
         this.source = source;
         if (colors.length === 0) {
-            throw new Error("UIRenderingColorOverVelocity: colors array cannot be empty");
+            throw new Error("FXRenderingColorOverVelocity: colors array cannot be empty");
         }
         if (maxVelocity <= 0) {
-            throw new Error("UIRenderingColorOverVelocity: maxVelocity must be greater than 0");
+            throw new Error("FXRenderingColorOverVelocity: maxVelocity must be greater than 0");
         }
         this.source = source.replace("COLOR_OVER_VELOCITY_MAX", `COLOR_OVER_VELOCITY_MAX ${maxVelocity.toFixed(2)}`);
         this.requiredUniforms = { colorOverVelocityTexture: buildGradientTexture(colors) };

package/dist/shaders/FXRenderingColorOverVelocity.glsl.js

@@ -1,3 +1,3 @@
-var source = "#define COLOR_OVER_VELOCITY_MAX vec4 draw(){float t=clamp(length(vec2(PARTICLE_VELOCITY_X,PARTICLE_VELOCITY_Y))/COLOR_OVER_VELOCITY_MAX,0.0,1.0);return srgbTexture2D(p_colorOverVelocityTexture,vec2(t,0.5));}";
+var source = "#define COLOR_OVER_VELOCITY_MAX vec4 draw(){float t=clamp(length(vec3(PARTICLE_VELOCITY_X,PARTICLE_VELOCITY_Y,PARTICLE_VELOCITY_Z))/COLOR_OVER_VELOCITY_MAX,0.0,1.0);return srgbTexture2D(p_colorOverVelocityTexture,vec2(t,0.5));}";
 
 export { source as default };

package/dist/spawnModules/FXSpawnBox.d.ts

@@ -2,7 +2,7 @@ import type { Vector3Like } from "../miscellaneous/math";
 import { type FXVector3Config } from "../miscellaneous/miscellaneous";
 import { FXSpawnModule } from "./FXSpawnModule";
 /**
- * Spawns particles at random positions within a rectangle.
+ * Spawns particles at random positions within an axis-aligned bounding box.
  *
  * Position is chosen uniformly within the bounds defined by min and max.
  */
@@ -12,16 +12,16 @@ export declare class FXSpawnBox extends FXSpawnModule<{
     private minInternal;
     private maxInternal;
     /**
-     * @param min - Bottom-left corner of spawn area
-     * @param max - Top-right corner of spawn area
+     * @param min - Minimum corner of the spawn box
+     * @param max - Maximum corner of the spawn box
      */
     constructor(min?: FXVector3Config, max?: FXVector3Config);
-    /** Bottom-left corner of spawn area */
+    /** Minimum corner of the spawn box */
     get min(): Vector3Like;
-    /** Top-right corner of spawn area */
+    /** Maximum corner of the spawn box */
     get max(): Vector3Like;
-    /** Bottom-left corner of spawn area */
+    /** Minimum corner of the spawn box */
     set min(value: FXVector3Config);
-    /** Top-right corner of spawn area */
+    /** Maximum corner of the spawn box */
     set max(value: FXVector3Config);
 }

package/dist/spawnModules/FXSpawnBox.js

@@ -1,52 +1,52 @@
 import { MathUtils } from 'three';
 import { assertValidNumber } from '../miscellaneous/asserts.js';
-import { resolveFXVector2Config, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z } from '../miscellaneous/miscellaneous.js';
+import { resolveFXVector3Config, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z } from '../miscellaneous/miscellaneous.js';
 import { FXSpawnModule } from './FXSpawnModule.js';
 
 /**
- * Spawns particles at random positions within a rectangle.
+ * Spawns particles at random positions within an axis-aligned bounding box.
  *
  * Position is chosen uniformly within the bounds defined by min and max.
  */
 class FXSpawnBox extends FXSpawnModule {
     /**
-     * @param min - Bottom-left corner of spawn area
-     * @param max - Top-right corner of spawn area
+     * @param min - Minimum corner of the spawn box
+     * @param max - Maximum corner of the spawn box
      */
     constructor(min = { x: -1, y: -1, z: -1 }, max = { x: 1, y: 1, z: 1 }) {
         super();
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
-        this._private_minInternal = resolveFXVector2Config(min);
-        this._private_maxInternal = resolveFXVector2Config(max);
-        assertValidNumber(this._private_minInternal.x, "FXSpawnRectangle.constructor.min.x");
-        assertValidNumber(this._private_minInternal.y, "FXSpawnRectangle.constructor.min.y");
-        assertValidNumber(this._private_minInternal.z, "FXSpawnRectangle.constructor.min.z");
-        assertValidNumber(this._private_maxInternal.x, "FXSpawnRectangle.constructor.max.x");
-        assertValidNumber(this._private_maxInternal.y, "FXSpawnRectangle.constructor.max.y");
-        assertValidNumber(this._private_maxInternal.z, "FXSpawnRectangle.constructor.max.z");
+        this._private_minInternal = resolveFXVector3Config(min);
+        this._private_maxInternal = resolveFXVector3Config(max);
+        assertValidNumber(this._private_minInternal.x, "FXSpawnBox.constructor.min.x");
+        assertValidNumber(this._private_minInternal.y, "FXSpawnBox.constructor.min.y");
+        assertValidNumber(this._private_minInternal.z, "FXSpawnBox.constructor.min.z");
+        assertValidNumber(this._private_maxInternal.x, "FXSpawnBox.constructor.max.x");
+        assertValidNumber(this._private_maxInternal.y, "FXSpawnBox.constructor.max.y");
+        assertValidNumber(this._private_maxInternal.z, "FXSpawnBox.constructor.max.z");
     }
-    /** Bottom-left corner of spawn area */
+    /** Minimum corner of the spawn box */
     get min() {
         return this._private_minInternal;
     }
-    /** Top-right corner of spawn area */
+    /** Maximum corner of the spawn box */
     get max() {
         return this._private_maxInternal;
     }
-    /** Bottom-left corner of spawn area */
+    /** Minimum corner of the spawn box */
     set min(value) {
-        this._private_minInternal = resolveFXVector2Config(value);
-        assertValidNumber(this._private_minInternal.x, "FXSpawnRectangle.min.x");
-        assertValidNumber(this._private_minInternal.y, "FXSpawnRectangle.min.y");
-        assertValidNumber(this._private_minInternal.z, "FXSpawnRectangle.min.z");
+        this._private_minInternal = resolveFXVector3Config(value);
+        assertValidNumber(this._private_minInternal.x, "FXSpawnBox.min.x");
+        assertValidNumber(this._private_minInternal.y, "FXSpawnBox.min.y");
+        assertValidNumber(this._private_minInternal.z, "FXSpawnBox.min.z");
     }
-    /** Top-right corner of spawn area */
+    /** Maximum corner of the spawn box */
     set max(value) {
-        this._private_maxInternal = resolveFXVector2Config(value);
-        assertValidNumber(this._private_maxInternal.x, "FXSpawnRectangle.max.x");
-        assertValidNumber(this._private_maxInternal.y, "FXSpawnRectangle.max.y");
-        assertValidNumber(this._private_maxInternal.z, "FXSpawnRectangle.max.z");
+        this._private_maxInternal = resolveFXVector3Config(value);
+        assertValidNumber(this._private_maxInternal.x, "FXSpawnBox.max.x");
+        assertValidNumber(this._private_maxInternal.y, "FXSpawnBox.max.y");
+        assertValidNumber(this._private_maxInternal.z, "FXSpawnBox.max.z");
     }
     /** @internal */
     spawn(properties, instanceBegin, instanceEnd) {

package/dist/spawnModules/FXSpawnOffset.js

@@ -1,5 +1,5 @@
 import { assertValidNumber } from '../miscellaneous/asserts.js';
-import { resolveFXVector2Config, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z } from '../miscellaneous/miscellaneous.js';
+import { resolveFXVector3Config, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z } from '../miscellaneous/miscellaneous.js';
 import { FXSpawnModule } from './FXSpawnModule.js';
 
 /**
@@ -15,7 +15,7 @@ class FXSpawnOffset extends FXSpawnModule {
         super();
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
-        this._private_offsetInternal = resolveFXVector2Config(offset);
+        this._private_offsetInternal = resolveFXVector3Config(offset);
         assertValidNumber(this._private_offsetInternal.x, "FXSpawnOffset.constructor.offset.x");
         assertValidNumber(this._private_offsetInternal.y, "FXSpawnOffset.constructor.offset.y");
         assertValidNumber(this._private_offsetInternal.z, "FXSpawnOffset.constructor.offset.z");
@@ -26,7 +26,7 @@ class FXSpawnOffset extends FXSpawnModule {
     }
     /** Particle position offset */
     set offset(value) {
-        this._private_offsetInternal = resolveFXVector2Config(value);
+        this._private_offsetInternal = resolveFXVector3Config(value);
         assertValidNumber(this._private_offsetInternal.x, "FXSpawnOffset.offset.x");
         assertValidNumber(this._private_offsetInternal.y, "FXSpawnOffset.offset.y");
         assertValidNumber(this._private_offsetInternal.z, "FXSpawnOffset.offset.z");

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "sparcoon",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "",
   "keywords": [
     "particles",
+    "particle-system",
     "three.js",
-    "mobile",
-    "ads",
+    "3d",
+    "webgl",
+    "instanced",
+    "billboard",
     "typescript"
   ],
   "author": "jango",
@@ -36,8 +39,9 @@
     }
   },
   "peerDependencies": {
-    "three": ">=0.157.0 <0.180.0",
-    "ferrsign": "^0.0.4"
+    "fast-simplex-noise": "^4.0.0",
+    "ferrsign": "^0.0.4",
+    "three": ">=0.157.0 <0.180.0"
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^16.0.1",
@@ -51,5 +55,8 @@
     "rollup-plugin-typescript2": "^0.36.0",
     "ts-transformer-minify-privates": "^1.0.0",
     "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@rollup/plugin-commonjs": "^29.0.2"
   }
 }