sparcoon 0.0.5 → 0.0.7

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);
-        assertValidNumber(this._private_directionInternal.x, "UIBehaviorDirectionalGravity.constructor.direction.x");
-        assertValidNumber(this._private_directionInternal.y, "UIBehaviorDirectionalGravity.constructor.direction.y");
+        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);
-        assertValidNumber(this._private_directionInternal.x, "UIBehaviorDirectionalGravity.direction.x");
-        assertValidNumber(this._private_directionInternal.y, "UIBehaviorDirectionalGravity.direction.y");
+        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,18 +19,19 @@ class FXBehaviorPointGravity extends FXBehaviorModule {
         super();
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
-        this._private_centerInternal = resolveFXVector2Config(center);
-        assertValidNumber(this._private_centerInternal.x, "UIBehaviorPointGravity.constructor.center.x");
-        assertValidNumber(this._private_centerInternal.y, "UIBehaviorPointGravity.constructor.center.y");
+        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, "UIBehaviorPointGravity.constructor.strength.min");
-        assertValidNumber(this._private_strengthInternal.max, "UIBehaviorPointGravity.constructor.strength.max");
+        assertValidNumber(this._private_strengthInternal.min, "FXBehaviorPointGravity.constructor.strength.min");
+        assertValidNumber(this._private_strengthInternal.max, "FXBehaviorPointGravity.constructor.strength.max");
         this._private_exponentInternal = resolveFXRangeConfig(exponent);
-        assertValidNumber(this._private_exponentInternal.min, "UIBehaviorPointGravity.constructor.exponent.min");
-        assertValidNumber(this._private_exponentInternal.max, "UIBehaviorPointGravity.constructor.exponent.max");
+        assertValidNumber(this._private_exponentInternal.min, "FXBehaviorPointGravity.constructor.exponent.min");
+        assertValidNumber(this._private_exponentInternal.max, "FXBehaviorPointGravity.constructor.exponent.max");
         this._private_thresholdInternal = resolveFXRangeConfig(threshold);
-        assertValidNumber(this._private_thresholdInternal.min, "UIBehaviorPointGravity.constructor.threshold.min");
-        assertValidNumber(this._private_thresholdInternal.max, "UIBehaviorPointGravity.constructor.threshold.max");
+        assertValidNumber(this._private_thresholdInternal.min, "FXBehaviorPointGravity.constructor.threshold.min");
+        assertValidNumber(this._private_thresholdInternal.max, "FXBehaviorPointGravity.constructor.threshold.max");
     }
     /** Gravity center position */
     get center() {
@@ -50,27 +51,28 @@ class FXBehaviorPointGravity extends FXBehaviorModule {
     }
     /** Gravity center position */
     set center(value) {
-        this._private_centerInternal = resolveFXVector2Config(value);
-        assertValidNumber(this._private_centerInternal.x, "UIBehaviorPointGravity.center.x");
-        assertValidNumber(this._private_centerInternal.y, "UIBehaviorPointGravity.center.y");
+        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) {
         this._private_strengthInternal = resolveFXRangeConfig(value);
-        assertValidNumber(this._private_strengthInternal.min, "UIBehaviorPointGravity.strength.min");
-        assertValidNumber(this._private_strengthInternal.max, "UIBehaviorPointGravity.strength.max");
+        assertValidNumber(this._private_strengthInternal.min, "FXBehaviorPointGravity.strength.min");
+        assertValidNumber(this._private_strengthInternal.max, "FXBehaviorPointGravity.strength.max");
     }
     /** Distance power exponent range */
     set exponent(value) {
         this._private_exponentInternal = resolveFXRangeConfig(value);
-        assertValidNumber(this._private_exponentInternal.min, "UIBehaviorPointGravity.exponent.min");
-        assertValidNumber(this._private_exponentInternal.max, "UIBehaviorPointGravity.exponent.max");
+        assertValidNumber(this._private_exponentInternal.min, "FXBehaviorPointGravity.exponent.min");
+        assertValidNumber(this._private_exponentInternal.max, "FXBehaviorPointGravity.exponent.max");
     }
     /** Minimum distance range */
     set threshold(value) {
         this._private_thresholdInternal = resolveFXRangeConfig(value);
-        assertValidNumber(this._private_thresholdInternal.min, "UIBehaviorPointGravity.threshold.min");
-        assertValidNumber(this._private_thresholdInternal.max, "UIBehaviorPointGravity.threshold.max");
+        assertValidNumber(this._private_thresholdInternal.min, "FXBehaviorPointGravity.threshold.min");
+        assertValidNumber(this._private_thresholdInternal.max, "FXBehaviorPointGravity.threshold.max");
     }
     /** @internal */
     update(properties, instanceCount, deltaTime) {
@@ -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/FXBehaviorScaleOverLife.js

@@ -19,16 +19,16 @@ class FXBehaviorScaleOverLife extends FXBehaviorModule {
         this.requiredProperties = { builtin: "Matrix4" };
         this._private_scales = [];
         if (scales.length < 2) {
-            throw new Error("UIBehaviorScaleOverLife.scales: the number of scale anchors must be more than two");
+            throw new Error("FXBehaviorScaleOverLife.scales: the number of scale anchors must be more than two");
         }
         for (let i = 0; i < scales.length; i++) {
             const scale = resolveFXRangeConfig(scales[i]);
-            assertValidNonNegativeNumber(scale.min, `UIBehaviorScaleOverLife.constructor.scales[${i}].min`);
-            assertValidNonNegativeNumber(scale.max, `UIBehaviorScaleOverLife.constructor.scales[${i}].max`);
+            assertValidNonNegativeNumber(scale.min, `FXBehaviorScaleOverLife.constructor.scales[${i}].min`);
+            assertValidNonNegativeNumber(scale.max, `FXBehaviorScaleOverLife.constructor.scales[${i}].max`);
             this._private_scales.push(scale);
         }
         this._private_aspectInternal = resolveAspect(aspect);
-        assertValidPositiveNumber(this._private_aspectInternal, "UIBehaviorScaleOverLife.constructor.aspect");
+        assertValidPositiveNumber(this._private_aspectInternal, "FXBehaviorScaleOverLife.constructor.aspect");
     }
     /** Width/height aspect ratio */
     get aspect() {
@@ -37,7 +37,7 @@ class FXBehaviorScaleOverLife extends FXBehaviorModule {
     /** Width/height aspect ratio */
     set aspect(value) {
         this._private_aspectInternal = resolveAspect(value);
-        assertValidPositiveNumber(this._private_aspectInternal, "UIBehaviorScaleOverLife.aspect");
+        assertValidPositiveNumber(this._private_aspectInternal, "FXBehaviorScaleOverLife.aspect");
     }
     /** @internal */
     update(properties, instanceCount) {

package/dist/behaviorModules/FXBehaviorTorqueDamping.js

@@ -17,8 +17,8 @@ class FXBehaviorTorqueDamping extends FXBehaviorModule {
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
         this._private_dampingInternal = resolveFXRangeConfig(damping);
-        assertValidNonNegativeNumber(this._private_dampingInternal.min, `UIBehaviorTorqueDamping.constructor.damping.min`);
-        assertValidNonNegativeNumber(this._private_dampingInternal.max, `UIBehaviorTorqueDamping.constructor.damping.max`);
+        assertValidNonNegativeNumber(this._private_dampingInternal.min, `FXBehaviorTorqueDamping.constructor.damping.min`);
+        assertValidNonNegativeNumber(this._private_dampingInternal.max, `FXBehaviorTorqueDamping.constructor.damping.max`);
     }
     /** Damping coefficient range (0-1) */
     get damping() {
@@ -27,8 +27,8 @@ class FXBehaviorTorqueDamping extends FXBehaviorModule {
     /** Damping coefficient range (0-1) */
     set damping(value) {
         this._private_dampingInternal = resolveFXRangeConfig(value);
-        assertValidNonNegativeNumber(this._private_dampingInternal.min, `UIBehaviorTorqueDamping.damping.min`);
-        assertValidNonNegativeNumber(this._private_dampingInternal.max, `UIBehaviorTorqueDamping.damping.max`);
+        assertValidNonNegativeNumber(this._private_dampingInternal.min, `FXBehaviorTorqueDamping.damping.min`);
+        assertValidNonNegativeNumber(this._private_dampingInternal.max, `FXBehaviorTorqueDamping.damping.max`);
     }
     /** @internal */
     update(properties, instanceCount, deltaTime) {

package/dist/behaviorModules/FXBehaviorTorqueNoise.js

@@ -18,11 +18,11 @@ class FXBehaviorTorqueNoise extends FXBehaviorModule {
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
         this._private_scaleInternal = resolveFXRangeConfig(scale);
-        assertValidPositiveNumber(this._private_scaleInternal.min, `UIBehaviorTorqueNoise.constructor.scale.min`);
-        assertValidPositiveNumber(this._private_scaleInternal.max, `UIBehaviorTorqueNoise.constructor.scale.max`);
+        assertValidPositiveNumber(this._private_scaleInternal.min, `FXBehaviorTorqueNoise.constructor.scale.min`);
+        assertValidPositiveNumber(this._private_scaleInternal.max, `FXBehaviorTorqueNoise.constructor.scale.max`);
         this._private_strengthInternal = resolveFXRangeConfig(strength);
-        assertValidNonNegativeNumber(this._private_strengthInternal.min, `UIBehaviorTorqueNoise.constructor.strength.min`);
-        assertValidNonNegativeNumber(this._private_strengthInternal.max, `UIBehaviorTorqueNoise.constructor.strength.max`);
+        assertValidNonNegativeNumber(this._private_strengthInternal.min, `FXBehaviorTorqueNoise.constructor.strength.min`);
+        assertValidNonNegativeNumber(this._private_strengthInternal.max, `FXBehaviorTorqueNoise.constructor.strength.max`);
     }
     /** Noise frequency range */
     get scale() {
@@ -35,14 +35,14 @@ class FXBehaviorTorqueNoise extends FXBehaviorModule {
     /** Noise frequency range */
     set scale(value) {
         this._private_scaleInternal = resolveFXRangeConfig(value);
-        assertValidPositiveNumber(this._private_scaleInternal.min, `UIBehaviorTorqueNoise.scale.min`);
-        assertValidPositiveNumber(this._private_scaleInternal.max, `UIBehaviorTorqueNoise.scale.max`);
+        assertValidPositiveNumber(this._private_scaleInternal.min, `FXBehaviorTorqueNoise.scale.min`);
+        assertValidPositiveNumber(this._private_scaleInternal.max, `FXBehaviorTorqueNoise.scale.max`);
     }
     /** Force multiplier range */
     set strength(value) {
         this._private_strengthInternal = resolveFXRangeConfig(value);
-        assertValidNonNegativeNumber(this._private_strengthInternal.min, `UIBehaviorTorqueNoise.strength.min`);
-        assertValidNonNegativeNumber(this._private_strengthInternal.max, `UIBehaviorTorqueNoise.strength.max`);
+        assertValidNonNegativeNumber(this._private_strengthInternal.min, `FXBehaviorTorqueNoise.strength.min`);
+        assertValidNonNegativeNumber(this._private_strengthInternal.max, `FXBehaviorTorqueNoise.strength.max`);
     }
     /** @internal */
     update(properties, instanceCount, deltaTime) {

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';
 
 /**
@@ -17,8 +17,8 @@ class FXBehaviorVelocityDamping extends FXBehaviorModule {
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
         this._private_dampingInternal = resolveFXRangeConfig(damping);
-        assertValidNonNegativeNumber(this._private_dampingInternal.min, `UIBehaviorVelocityDamping.constructor.damping.min`);
-        assertValidNonNegativeNumber(this._private_dampingInternal.max, `UIBehaviorVelocityDamping.constructor.damping.max`);
+        assertValidNonNegativeNumber(this._private_dampingInternal.min, `FXBehaviorVelocityDamping.constructor.damping.min`);
+        assertValidNonNegativeNumber(this._private_dampingInternal.max, `FXBehaviorVelocityDamping.constructor.damping.max`);
     }
     /** Damping coefficient range (0-1) */
     get damping() {
@@ -27,8 +27,8 @@ class FXBehaviorVelocityDamping extends FXBehaviorModule {
     /** Damping coefficient range (0-1) */
     set damping(value) {
         this._private_dampingInternal = resolveFXRangeConfig(value);
-        assertValidNonNegativeNumber(this._private_dampingInternal.min, `UIBehaviorVelocityDamping.damping.min`);
-        assertValidNonNegativeNumber(this._private_dampingInternal.max, `UIBehaviorVelocityDamping.damping.max`);
+        assertValidNonNegativeNumber(this._private_dampingInternal.min, `FXBehaviorVelocityDamping.damping.min`);
+        assertValidNonNegativeNumber(this._private_dampingInternal.max, `FXBehaviorVelocityDamping.damping.max`);
     }
     /** @internal */
     update(properties, instanceCount, deltaTime) {
@@ -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.js

@@ -18,11 +18,11 @@ class FXBehaviorVelocityNoise extends FXBehaviorModule {
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
         this._private_scaleInternal = resolveFXRangeConfig(scale);
-        assertValidPositiveNumber(this._private_scaleInternal.min, `UIBehaviorVelocityNoise.constructor.scale.min`);
-        assertValidPositiveNumber(this._private_scaleInternal.max, `UIBehaviorVelocityNoise.constructor.scale.max`);
+        assertValidPositiveNumber(this._private_scaleInternal.min, `FXBehaviorVelocityNoise.constructor.scale.min`);
+        assertValidPositiveNumber(this._private_scaleInternal.max, `FXBehaviorVelocityNoise.constructor.scale.max`);
         this._private_strengthInternal = resolveFXRangeConfig(strength);
-        assertValidNonNegativeNumber(this._private_strengthInternal.min, `UIBehaviorVelocityNoise.constructor.strength.min`);
-        assertValidNonNegativeNumber(this._private_strengthInternal.max, `UIBehaviorVelocityNoise.constructor.strength.max`);
+        assertValidNonNegativeNumber(this._private_strengthInternal.min, `FXBehaviorVelocityNoise.constructor.strength.min`);
+        assertValidNonNegativeNumber(this._private_strengthInternal.max, `FXBehaviorVelocityNoise.constructor.strength.max`);
     }
     /** Noise frequency range */
     get scale() {
@@ -35,14 +35,14 @@ class FXBehaviorVelocityNoise extends FXBehaviorModule {
     /** Noise frequency range */
     set scale(value) {
         this._private_scaleInternal = resolveFXRangeConfig(value);
-        assertValidPositiveNumber(this._private_scaleInternal.min, `UIBehaviorVelocityNoise.scale.min`);
-        assertValidPositiveNumber(this._private_scaleInternal.max, `UIBehaviorVelocityNoise.scale.max`);
+        assertValidPositiveNumber(this._private_scaleInternal.min, `FXBehaviorVelocityNoise.scale.min`);
+        assertValidPositiveNumber(this._private_scaleInternal.max, `FXBehaviorVelocityNoise.scale.max`);
     }
     /** Force multiplier range */
     set strength(value) {
         this._private_strengthInternal = resolveFXRangeConfig(value);
-        assertValidNonNegativeNumber(this._private_strengthInternal.min, `UIBehaviorVelocityNoise.strength.min`);
-        assertValidNonNegativeNumber(this._private_strengthInternal.max, `UIBehaviorVelocityNoise.strength.max`);
+        assertValidNonNegativeNumber(this._private_strengthInternal.min, `FXBehaviorVelocityNoise.strength.min`);
+        assertValidNonNegativeNumber(this._private_strengthInternal.max, `FXBehaviorVelocityNoise.strength.max`);
     }
     /** @internal */
     update(properties, instanceCount, deltaTime) {

package/dist/color/FXColor.js

@@ -212,7 +212,7 @@ class FXColor {
     }
     /** Red component (0 to 1) */
     set r(value) {
-        assertValidNumber(value, "UIColor.r");
+        assertValidNumber(value, "FXColor.r");
         value = MathUtils.clamp(value, 0, 1);
         this._private_ensureRGBUpdatedFromHSL();
         if (value !== this._private_rInternal) {
@@ -223,7 +223,7 @@ class FXColor {
     }
     /** Green component (0 to 1) */
     set g(value) {
-        assertValidNumber(value, "UIColor.g");
+        assertValidNumber(value, "FXColor.g");
         value = MathUtils.clamp(value, 0, 1);
         this._private_ensureRGBUpdatedFromHSL();
         if (value !== this._private_gInternal) {
@@ -234,7 +234,7 @@ class FXColor {
     }
     /** Blue component (0 to 1) */
     set b(value) {
-        assertValidNumber(value, "UIColor.b");
+        assertValidNumber(value, "FXColor.b");
         value = MathUtils.clamp(value, 0, 1);
         this._private_ensureRGBUpdatedFromHSL();
         if (value !== this._private_bInternal) {
@@ -245,7 +245,7 @@ class FXColor {
     }
     /** Alpha component (0 to 1) */
     set a(value) {
-        assertValidNumber(value, "UIColor.a");
+        assertValidNumber(value, "FXColor.a");
         value = MathUtils.clamp(value, 0, 1);
         if (value !== this._private_aInternal) {
             this._private_aInternal = value;
@@ -254,7 +254,7 @@ class FXColor {
     }
     /** Hue component (0 to 360) */
     set hue(value) {
-        assertValidNumber(value, "UIColor.hue");
+        assertValidNumber(value, "FXColor.hue");
         value = MathUtils.clamp(value, 0, 360);
         this._private_ensureHSLUpdatedFromRGB();
         if (value !== this._private_hInternal) {
@@ -265,7 +265,7 @@ class FXColor {
     }
     /** Saturation component (0 to 1) */
     set saturation(value) {
-        assertValidNumber(value, "UIColor.saturation");
+        assertValidNumber(value, "FXColor.saturation");
         value = MathUtils.clamp(value, 0, 1);
         this._private_ensureHSLUpdatedFromRGB();
         if (value !== this._private_sInternal) {
@@ -276,7 +276,7 @@ class FXColor {
     }
     /** Lightness component (0 to 1) */
     set lightness(value) {
-        assertValidNumber(value, "UIColor.lightness");
+        assertValidNumber(value, "FXColor.lightness");
         value = MathUtils.clamp(value, 0, 1);
         this._private_ensureHSLUpdatedFromRGB();
         if (value !== this._private_lInternal) {
@@ -312,14 +312,14 @@ class FXColor {
         if (typeof firstArgument === "number") {
             return this.setHexRGB(firstArgument, a);
         }
-        throw new Error("UIColor.set: cannot create color from provided arguments");
+        throw new Error("FXColor.set: cannot create color from provided arguments");
     }
     /** Sets RGBA components directly */
     setRGBA(r, g, b, a = this._private_aInternal) {
-        assertValidNumber(r, "UIColor.setRGBA.r");
-        assertValidNumber(g, "UIColor.setRGBA.g");
-        assertValidNumber(b, "UIColor.setRGBA.b");
-        assertValidNumber(a, "UIColor.setRGBA.a");
+        assertValidNumber(r, "FXColor.setRGBA.r");
+        assertValidNumber(g, "FXColor.setRGBA.g");
+        assertValidNumber(b, "FXColor.setRGBA.b");
+        assertValidNumber(a, "FXColor.setRGBA.a");
         r = MathUtils.clamp(r, 0, 1);
         g = MathUtils.clamp(g, 0, 1);
         b = MathUtils.clamp(b, 0, 1);
@@ -365,7 +365,7 @@ class FXColor {
     }
     /** Sets from 32-bit hex RGBA (RRGGBBAA) */
     setHexRGBA(hex) {
-        assertValidNumber(hex, "UIColor.setHexRGBA.hex");
+        assertValidNumber(hex, "FXColor.setHexRGBA.hex");
         this._private_ensureRGBUpdatedFromHSL();
         const r = ((hex >> 16) & 0xff) / 255;
         const g = ((hex >> 8) & 0xff) / 255;
@@ -386,8 +386,8 @@ class FXColor {
     }
     /** Sets from 24-bit hex RGB (RRGGBB) */
     setHexRGB(hex, a = this._private_aInternal) {
-        assertValidNumber(hex, "UIColor.setHexRGB.hex");
-        assertValidNumber(a, "UIColor.setHexRGB.a");
+        assertValidNumber(hex, "FXColor.setHexRGB.hex");
+        assertValidNumber(a, "FXColor.setHexRGB.a");
         a = MathUtils.clamp(a, 0, 1);
         this._private_ensureRGBUpdatedFromHSL();
         const r = ((hex >> 16) & 0xff) / 255;
@@ -414,33 +414,33 @@ class FXColor {
      */
     setHexString(hexString) {
         if (!hexString.startsWith("#")) {
-            throw new Error(`UIColor.setHexString.hexString: invalid hex string format. expected format: "#ffffff" or "#ffffffff"`);
+            throw new Error(`FXColor.setHexString.hexString: invalid hex string format. expected format: "#ffffff" or "#ffffffff"`);
         }
         const hex = hexString.slice(1);
         if (hex.length === 6) {
             const hexNumber = parseInt(hex, 16);
             if (isNaN(hexNumber)) {
-                throw new Error(`UIColor.setHexString.hexString: invalid hex string format. expected format: "#ffffff" or "#ffffffff"`);
+                throw new Error(`FXColor.setHexString.hexString: invalid hex string format. expected format: "#ffffff" or "#ffffffff"`);
             }
             return this.setHexRGB(hexNumber);
         }
         else if (hex.length === 8) {
             const hexNumber = parseInt(hex, 16);
             if (isNaN(hexNumber)) {
-                throw new Error(`UIColor.setHexString.hexString: invalid hex string format. expected format: "#ffffff" or "#ffffffff"`);
+                throw new Error(`FXColor.setHexString.hexString: invalid hex string format. expected format: "#ffffff" or "#ffffffff"`);
             }
             return this.setHexRGBA(hexNumber);
         }
         else {
-            throw new Error(`UIColor.setHexString.hexString: invalid hex string format. expected format: "#ffffff" or "#ffffffff"`);
+            throw new Error(`FXColor.setHexString.hexString: invalid hex string format. expected format: "#ffffff" or "#ffffffff"`);
         }
     }
     /** Sets from HSL values */
     setHSL(h, s, l, a = this._private_aInternal) {
-        assertValidNumber(h, "UIColor.setHSL.h");
-        assertValidNumber(s, "UIColor.setHSL.s");
-        assertValidNumber(l, "UIColor.setHSL.l");
-        assertValidNumber(a, "UIColor.setHSL.a");
+        assertValidNumber(h, "FXColor.setHSL.h");
+        assertValidNumber(s, "FXColor.setHSL.s");
+        assertValidNumber(l, "FXColor.setHSL.l");
+        assertValidNumber(a, "FXColor.setHSL.a");
         h = MathUtils.clamp(h, 0, 360);
         s = MathUtils.clamp(s, 0, 1);
         l = MathUtils.clamp(l, 0, 1);
@@ -465,21 +465,21 @@ class FXColor {
      * @throws If color name unknown
      */
     setColorName(colorName, a = this._private_aInternal) {
-        assertValidNumber(a, "UIColor.setColorName.a");
+        assertValidNumber(a, "FXColor.setColorName.a");
         a = MathUtils.clamp(a, 0, 1);
         const normalizedName = colorName.toLowerCase().trim();
         const hex = COLORS[normalizedName];
         if (hex === undefined) {
-            throw new Error(`UIColor.setColorName.colorName: unknown color name`);
+            throw new Error(`FXColor.setColorName.colorName: unknown color name`);
         }
         return this.setHexRGB(hex, a);
     }
     /** Sets from linear (GLSL) color space */
     setGLSLColor(r, g, b, a = this._private_aInternal) {
-        assertValidNumber(r, "UIColor.setGLSLColor.r");
-        assertValidNumber(g, "UIColor.setGLSLColor.g");
-        assertValidNumber(b, "UIColor.setGLSLColor.b");
-        assertValidNumber(a, "UIColor.setGLSLColor.a");
+        assertValidNumber(r, "FXColor.setGLSLColor.r");
+        assertValidNumber(g, "FXColor.setGLSLColor.g");
+        assertValidNumber(b, "FXColor.setGLSLColor.b");
+        assertValidNumber(a, "FXColor.setGLSLColor.a");
         a = MathUtils.clamp(a, 0, 1);
         this._private_ensureRGBUpdatedFromHSL();
         const sRGBR = linearToSRGB(r);
@@ -500,7 +500,7 @@ class FXColor {
     }
     /** Sets from Three.js Color */
     setThreeColor(threeColor, a = this._private_aInternal) {
-        assertValidNumber(a, "UIColor.setThreeColor.a");
+        assertValidNumber(a, "FXColor.setThreeColor.a");
         a = MathUtils.clamp(a, 0, 1);
         this._private_ensureRGBUpdatedFromHSL();
         if (threeColor.r !== this._private_rInternal ||

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/FXInstancedParticle.Internal.js

@@ -177,7 +177,7 @@ function buildParticleFragmentShader(uniformDeclarations, varyingDeclarations, s
         discard;
       }
       #ifdef USE_ALPHAHASH
-        if (diffuseColor.a < getAlphaHashThreshold(vec2(p_builtin[0][0], p_builtin[0][1]))) {
+        if (diffuseColor.a < getAlphaHashThreshold(vec3(p_builtin[0][0], p_builtin[0][1], p_builtin[0][2]))) {
           discard;
         }
       #endif

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,7 +11,7 @@ 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;

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 };
     }
@@ -63,4 +63,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, generateNoise3D, resolveAspect, resolveFXRangeConfig, resolveFXVector3Config };

package/dist/miscellaneous/texture/FXTextureView.js

@@ -178,18 +178,18 @@ class FXTextureView {
         }
     }
     _private_setFromAtlasConfig(config) {
-        assertValidPositiveNumber(config.sourceSize.w, "UITextureView.setFromAtlasConfig.config.sourceSize.w");
-        assertValidPositiveNumber(config.sourceSize.h, "UITextureView.setFromAtlasConfig.config.sourceSize.h");
-        assertValidNonNegativeNumber(config.frame.x, "UITextureView.setFromAtlasConfig.config.frame.x");
-        assertValidNonNegativeNumber(config.frame.y, "UITextureView.setFromAtlasConfig.config.frame.y");
-        assertValidPositiveNumber(config.frame.w, "UITextureView.setFromAtlasConfig.config.frame.w");
-        assertValidPositiveNumber(config.frame.h, "UITextureView.setFromAtlasConfig.config.frame.h");
-        assertValidNonNegativeNumber(config.spriteSourceSize.x, "UITextureView.setFromAtlasConfig.config.spriteSourceSize.x");
-        assertValidNonNegativeNumber(config.spriteSourceSize.y, "UITextureView.setFromAtlasConfig.config.spriteSourceSize.y");
-        assertValidPositiveNumber(config.spriteSourceSize.w, "UITextureView.setFromAtlasConfig.config.spriteSourceSize.w");
-        assertValidPositiveNumber(config.spriteSourceSize.h, "UITextureView.setFromAtlasConfig.config.spriteSourceSize.h");
+        assertValidPositiveNumber(config.sourceSize.w, "FXTextureView.setFromAtlasConfig.config.sourceSize.w");
+        assertValidPositiveNumber(config.sourceSize.h, "FXTextureView.setFromAtlasConfig.config.sourceSize.h");
+        assertValidNonNegativeNumber(config.frame.x, "FXTextureView.setFromAtlasConfig.config.frame.x");
+        assertValidNonNegativeNumber(config.frame.y, "FXTextureView.setFromAtlasConfig.config.frame.y");
+        assertValidPositiveNumber(config.frame.w, "FXTextureView.setFromAtlasConfig.config.frame.w");
+        assertValidPositiveNumber(config.frame.h, "FXTextureView.setFromAtlasConfig.config.frame.h");
+        assertValidNonNegativeNumber(config.spriteSourceSize.x, "FXTextureView.setFromAtlasConfig.config.spriteSourceSize.x");
+        assertValidNonNegativeNumber(config.spriteSourceSize.y, "FXTextureView.setFromAtlasConfig.config.spriteSourceSize.y");
+        assertValidPositiveNumber(config.spriteSourceSize.w, "FXTextureView.setFromAtlasConfig.config.spriteSourceSize.w");
+        assertValidPositiveNumber(config.spriteSourceSize.h, "FXTextureView.setFromAtlasConfig.config.spriteSourceSize.h");
         if (config.scale !== undefined) {
-            assertValidPositiveNumber(config.scale, "UITextureView.setFromAtlasConfig.config.scale");
+            assertValidPositiveNumber(config.scale, "FXTextureView.setFromAtlasConfig.config.scale");
         }
         this._private_sourceWidth = config.sourceSize.w;
         this._private_sourceHeight = config.sourceSize.h;

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, "UISpawnRectangle.constructor.min.x");
-        assertValidNumber(this._private_minInternal.y, "UISpawnRectangle.constructor.min.y");
-        assertValidNumber(this._private_minInternal.z, "UISpawnRectangle.constructor.min.z");
-        assertValidNumber(this._private_maxInternal.x, "UISpawnRectangle.constructor.max.x");
-        assertValidNumber(this._private_maxInternal.y, "UISpawnRectangle.constructor.max.y");
-        assertValidNumber(this._private_maxInternal.z, "UISpawnRectangle.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, "UISpawnRectangle.min.x");
-        assertValidNumber(this._private_minInternal.y, "UISpawnRectangle.min.y");
-        assertValidNumber(this._private_minInternal.z, "UISpawnRectangle.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, "UISpawnRectangle.max.x");
-        assertValidNumber(this._private_maxInternal.y, "UISpawnRectangle.max.y");
-        assertValidNumber(this._private_maxInternal.z, "UISpawnRectangle.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,10 +15,10 @@ class FXSpawnOffset extends FXSpawnModule {
         super();
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
-        this._private_offsetInternal = resolveFXVector2Config(offset);
-        assertValidNumber(this._private_offsetInternal.x, "UISpawnOffset.constructor.offset.x");
-        assertValidNumber(this._private_offsetInternal.y, "UISpawnOffset.constructor.offset.y");
-        assertValidNumber(this._private_offsetInternal.z, "UISpawnOffset.constructor.offset.z");
+        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");
     }
     /** Particle position offset */
     get offset() {
@@ -26,10 +26,10 @@ class FXSpawnOffset extends FXSpawnModule {
     }
     /** Particle position offset */
     set offset(value) {
-        this._private_offsetInternal = resolveFXVector2Config(value);
-        assertValidNumber(this._private_offsetInternal.x, "UISpawnOffset.offset.x");
-        assertValidNumber(this._private_offsetInternal.y, "UISpawnOffset.offset.y");
-        assertValidNumber(this._private_offsetInternal.z, "UISpawnOffset.offset.z");
+        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");
     }
     /** @internal */
     spawn(properties, instanceBegin, instanceEnd) {

package/dist/spawnModules/FXSpawnRandomLifetime.js

@@ -17,8 +17,8 @@ class FXSpawnRandomLifetime extends FXSpawnModule {
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
         this._private_lifetimeInternal = resolveFXRangeConfig(lifetime);
-        assertValidPositiveNumber(this._private_lifetimeInternal.min, "UISpawnRandomLifetime.constructor.lifetime.min");
-        assertValidPositiveNumber(this._private_lifetimeInternal.max, "UISpawnRandomLifetime.constructor.lifetime.max");
+        assertValidPositiveNumber(this._private_lifetimeInternal.min, "FXSpawnRandomLifetime.constructor.lifetime.min");
+        assertValidPositiveNumber(this._private_lifetimeInternal.max, "FXSpawnRandomLifetime.constructor.lifetime.max");
     }
     /** Lifetime range in seconds */
     get lifetime() {
@@ -27,8 +27,8 @@ class FXSpawnRandomLifetime extends FXSpawnModule {
     /** Lifetime range in seconds */
     set lifetime(value) {
         this._private_lifetimeInternal = resolveFXRangeConfig(value);
-        assertValidPositiveNumber(this._private_lifetimeInternal.min, "UISpawnRandomLifetime.lifetime.min");
-        assertValidPositiveNumber(this._private_lifetimeInternal.max, "UISpawnRandomLifetime.lifetime.max");
+        assertValidPositiveNumber(this._private_lifetimeInternal.min, "FXSpawnRandomLifetime.lifetime.min");
+        assertValidPositiveNumber(this._private_lifetimeInternal.max, "FXSpawnRandomLifetime.lifetime.max");
     }
     /** @internal */
     spawn(properties, instanceBegin, instanceEnd) {

package/dist/spawnModules/FXSpawnRandomRotation.js

@@ -17,8 +17,8 @@ class FXSpawnRandomRotation extends FXSpawnModule {
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
         this._private_rotationInternal = resolveFXRangeConfig(rotation);
-        assertValidNumber(this._private_rotationInternal.min, "UISpawnRandomRotation.constructor.rotation.min");
-        assertValidNumber(this._private_rotationInternal.max, "UISpawnRandomRotation.constructor.rotation.max");
+        assertValidNumber(this._private_rotationInternal.min, "FXSpawnRandomRotation.constructor.rotation.min");
+        assertValidNumber(this._private_rotationInternal.max, "FXSpawnRandomRotation.constructor.rotation.max");
     }
     /** Rotation range in radians */
     get rotation() {
@@ -27,8 +27,8 @@ class FXSpawnRandomRotation extends FXSpawnModule {
     /** Rotation range in radians */
     set rotation(value) {
         this._private_rotationInternal = resolveFXRangeConfig(value);
-        assertValidNumber(this._private_rotationInternal.min, "UISpawnRandomRotation.rotation.min");
-        assertValidNumber(this._private_rotationInternal.max, "UISpawnRandomRotation.rotation.max");
+        assertValidNumber(this._private_rotationInternal.min, "FXSpawnRandomRotation.rotation.min");
+        assertValidNumber(this._private_rotationInternal.max, "FXSpawnRandomRotation.rotation.max");
     }
     /** @internal */
     spawn(properties, instanceBegin, instanceEnd) {

package/dist/spawnModules/FXSpawnRandomScale.js

@@ -19,9 +19,9 @@ class FXSpawnRandomScale extends FXSpawnModule {
         this.requiredProperties = { builtin: "Matrix4" };
         this._private_scaleInternal = resolveFXRangeConfig(scale);
         this._private_aspectInternal = resolveAspect(aspect);
-        assertValidPositiveNumber(this._private_scaleInternal.min, "UISpawnRandomScale.constructor.scale.min");
-        assertValidPositiveNumber(this._private_scaleInternal.max, "UISpawnRandomScale.constructor.scale.max");
-        assertValidPositiveNumber(this._private_aspectInternal, "UISpawnRandomScale.constructor.aspect");
+        assertValidPositiveNumber(this._private_scaleInternal.min, "FXSpawnRandomScale.constructor.scale.min");
+        assertValidPositiveNumber(this._private_scaleInternal.max, "FXSpawnRandomScale.constructor.scale.max");
+        assertValidPositiveNumber(this._private_aspectInternal, "FXSpawnRandomScale.constructor.aspect");
     }
     /** Base scale range */
     get scale() {
@@ -34,13 +34,13 @@ class FXSpawnRandomScale extends FXSpawnModule {
     /** Base scale range */
     set scale(value) {
         this._private_scaleInternal = resolveFXRangeConfig(value);
-        assertValidPositiveNumber(this._private_scaleInternal.min, "UISpawnRandomScale.scale.min");
-        assertValidPositiveNumber(this._private_scaleInternal.max, "UISpawnRandomScale.scale.max");
+        assertValidPositiveNumber(this._private_scaleInternal.min, "FXSpawnRandomScale.scale.min");
+        assertValidPositiveNumber(this._private_scaleInternal.max, "FXSpawnRandomScale.scale.max");
     }
     /** Width/height aspect ratio */
     set aspect(value) {
         this._private_aspectInternal = resolveAspect(value);
-        assertValidPositiveNumber(this._private_aspectInternal, "UISpawnRandomScale.aspect");
+        assertValidPositiveNumber(this._private_aspectInternal, "FXSpawnRandomScale.aspect");
     }
     /** @internal */
     spawn(properties, instanceBegin, instanceEnd) {

package/dist/spawnModules/FXSpawnRandomTorque.js

@@ -17,8 +17,8 @@ class FXSpawnRandomTorque extends FXSpawnModule {
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
         this._private_torqueInternal = resolveFXRangeConfig(torque);
-        assertValidNumber(this._private_torqueInternal.min, "UISpawnRandomTorque.constructor.torque.min");
-        assertValidNumber(this._private_torqueInternal.max, "UISpawnRandomTorque.constructor.torque.max");
+        assertValidNumber(this._private_torqueInternal.min, "FXSpawnRandomTorque.constructor.torque.min");
+        assertValidNumber(this._private_torqueInternal.max, "FXSpawnRandomTorque.constructor.torque.max");
     }
     /** Angular velocity range in radians/second */
     get torque() {
@@ -27,8 +27,8 @@ class FXSpawnRandomTorque extends FXSpawnModule {
     /** Angular velocity range in radians/second */
     set torque(value) {
         this._private_torqueInternal = resolveFXRangeConfig(value);
-        assertValidNumber(this._private_torqueInternal.min, "UISpawnRandomTorque.torque.min");
-        assertValidNumber(this._private_torqueInternal.max, "UISpawnRandomTorque.torque.max");
+        assertValidNumber(this._private_torqueInternal.min, "FXSpawnRandomTorque.torque.min");
+        assertValidNumber(this._private_torqueInternal.max, "FXSpawnRandomTorque.torque.max");
     }
     /** @internal */
     spawn(properties, instanceBegin, instanceEnd) {

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "sparcoon",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "",
   "keywords": [
     "particles",
+    "particle-system",
     "three.js",
-    "mobile",
-    "ads",
+    "3d",
+    "webgl",
+    "instanced",
+    "billboard",
     "typescript"
   ],
   "author": "jango",