sparcoon 0.6.1 → 0.7.0

package/dist/emitter/FXEmitter.d.ts

@@ -32,6 +32,10 @@ export declare class FXEmitter extends Object3D {
      * @param options - Emitter configuration
      */
     constructor(spawnSequence: FXSpawn[], behaviorSequence: readonly FXBehavior[], material: FXMaterial, options?: Partial<FXEmitterOptions>);
+    /** Number of currently alive particles */
+    get particleCount(): number;
+    /** Maximum number of particles that fit in the currently allocated buffers */
+    get particleCapacity(): number;
     /**
      * Ticks all active emitters; call once per frame before rendering
      *

package/dist/emitter/FXEmitter.js

@@ -69,6 +69,14 @@ class FXEmitter extends Object3D {
         this.add(this._private_mesh);
         EMITTERS.push(this);
     }
+    /** Number of currently alive particles */
+    get particleCount() {
+        return this._private_mesh.instanceCount;
+    }
+    /** Maximum number of particles that fit in the currently allocated buffers */
+    get particleCapacity() {
+        return this._private_mesh.instanceCapacity;
+    }
     /** Unregisters the emitter, removes it from the scene, and disposes modules and material */
     destroy() {
         const index = EMITTERS.indexOf(this);

package/dist/emitter/behavior/FXBehaviorDirectionalForce.d.ts

@@ -18,8 +18,6 @@ export declare class FXBehaviorDirectionalForce extends FXBehavior<{
     get direction(): Vector3Like;
     /** Acceleration magnitude in units/second² */
     get magnitude(): number;
-    /** Direction vector (normalized) */
     set direction(value: FXVector3Config);
-    /** Acceleration magnitude in units/second² */
     set magnitude(value: number);
 }

package/dist/emitter/behavior/FXBehaviorDirectionalForce.js

@@ -36,7 +36,6 @@ class FXBehaviorDirectionalForce extends FXBehavior {
     get magnitude() {
         return this._private_magnitudeInternal;
     }
-    /** Direction vector (normalized) */
     set direction(value) {
         const resolved = resolveFXVector3Config(value);
         assertValidNumber(resolved.x, "FXBehaviorDirectionalForce.direction.x");
@@ -48,7 +47,6 @@ class FXBehaviorDirectionalForce extends FXBehavior {
         }
         this._private_directionInternal.normalize();
     }
-    /** Acceleration magnitude in units/second² */
     set magnitude(value) {
         assertValidNumber(value, "FXBehaviorDirectionalForce.magnitude");
         this._private_magnitudeInternal = value;

package/dist/emitter/behavior/FXBehaviorPointForce.d.ts

@@ -29,12 +29,8 @@ export declare class FXBehaviorPointForce extends FXBehavior<{
     get exponent(): number;
     /** Minimum distance */
     get threshold(): number;
-    /** Force center position */
     set center(value: FXVector3Config);
-    /** Force multiplier */
     set strength(value: number);
-    /** Distance power exponent */
     set exponent(value: number);
-    /** Minimum distance */
     set threshold(value: number);
 }

package/dist/emitter/behavior/FXBehaviorPointForce.js

@@ -46,24 +46,20 @@ class FXBehaviorPointForce extends FXBehavior {
     get threshold() {
         return this._private_thresholdInternal;
     }
-    /** Force center position */
     set center(value) {
         this._private_centerInternal = resolveFXVector3Config(value);
         assertValidNumber(this._private_centerInternal.x, "FXBehaviorPointForce.center.x");
         assertValidNumber(this._private_centerInternal.y, "FXBehaviorPointForce.center.y");
         assertValidNumber(this._private_centerInternal.z, "FXBehaviorPointForce.center.z");
     }
-    /** Force multiplier */
     set strength(value) {
         assertValidNumber(value, "FXBehaviorPointForce.strength");
         this._private_strengthInternal = value;
     }
-    /** Distance power exponent */
     set exponent(value) {
         assertValidNumber(value, "FXBehaviorPointForce.exponent");
         this._private_exponentInternal = value;
     }
-    /** Minimum distance */
     set threshold(value) {
         assertValidNumber(value, "FXBehaviorPointForce.threshold");
         this._private_thresholdInternal = value;

package/dist/emitter/behavior/FXBehaviorScaleOverLife.d.ts

@@ -8,16 +8,17 @@ import { FXBehavior } from "./FXBehavior";
 export declare class FXBehaviorScaleOverLife extends FXBehavior<{
     builtin: "Matrix4";
 }> {
-    /** Active scale curve */
-    curve: FXCurve1D<FXRange>;
+    private curveInternal;
     private aspectInternal;
     /**
      * @param curve - Scale curve; accepts a {@link FXCurve1D} instance or a `FXRange[]` shorthand
      * @param aspect - Width/height ratio; must be positive. Defaults to `1`
      */
     constructor(curve: FXCurve1DConfig<FXRange>, aspect?: FXAspectConfig);
+    /** Active scale curve */
+    get curve(): FXCurve1D<FXRange>;
     /** Width/height aspect ratio */
     get aspect(): number;
-    /** Width/height aspect ratio */
+    set curve(value: FXCurve1DConfig<FXRange>);
     set aspect(value: FXAspectConfig);
 }

package/dist/emitter/behavior/FXBehaviorScaleOverLife.js

@@ -16,15 +16,21 @@ class FXBehaviorScaleOverLife extends FXBehavior {
         super();
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
-        this.curve = new FXCurve1D(curve);
+        this._private_curveInternal = new FXCurve1D(curve);
         this._private_aspectInternal = resolveAspect(aspect);
         assertValidPositiveNumber(this._private_aspectInternal, "FXBehaviorScaleOverLife.constructor.aspect");
     }
+    /** Active scale curve */
+    get curve() {
+        return this._private_curveInternal;
+    }
     /** Width/height aspect ratio */
     get aspect() {
         return this._private_aspectInternal;
     }
-    /** Width/height aspect ratio */
+    set curve(value) {
+        this._private_curveInternal = new FXCurve1D(value);
+    }
     set aspect(value) {
         this._private_aspectInternal = resolveAspect(value);
         assertValidPositiveNumber(this._private_aspectInternal, "FXBehaviorScaleOverLife.aspect");
@@ -37,7 +43,7 @@ class FXBehaviorScaleOverLife extends FXBehavior {
             const itemOffset = i * itemSize;
             const lifeT = Math.min(array[itemOffset + BUILTIN_OFFSET_AGE] / array[itemOffset + BUILTIN_OFFSET_LIFETIME], 1);
             const scaleT = array[itemOffset + BUILTIN_OFFSET_RANDOM_A];
-            const { a, b, t: localT } = this.curve.sample(lifeT);
+            const { a, b, t: localT } = this._private_curveInternal.sample(lifeT);
             const scale = MathUtils.lerp(MathUtils.lerp(a.min, a.max, scaleT), MathUtils.lerp(b.min, b.max, scaleT), localT);
             array[itemOffset + BUILTIN_OFFSET_SCALE_X] = scale * this._private_aspectInternal;
             array[itemOffset + BUILTIN_OFFSET_SCALE_Y] = scale;

package/dist/emitter/behavior/FXBehaviorTorqueDamping.d.ts

@@ -16,6 +16,5 @@ export declare class FXBehaviorTorqueDamping extends FXBehavior<{
     constructor(damping: FXRangeConfig);
     /** Damping coefficient range (0-1) */
     get damping(): FXRange;
-    /** Damping coefficient range (0-1) */
     set damping(value: FXRangeConfig);
 }

package/dist/emitter/behavior/FXBehaviorTorqueDamping.js

@@ -25,7 +25,6 @@ class FXBehaviorTorqueDamping extends FXBehavior {
     get damping() {
         return this._private_dampingInternal;
     }
-    /** Damping coefficient range (0-1) */
     set damping(value) {
         this._private_dampingInternal = resolveFXRangeConfig(value);
         assertValidNonNegativeNumber(this._private_dampingInternal.min, `FXBehaviorTorqueDamping.damping.min`);

package/dist/emitter/behavior/FXBehaviorTorqueNoise.d.ts

@@ -20,8 +20,6 @@ export declare class FXBehaviorTorqueNoise extends FXBehavior<{
     get scale(): FXRange;
     /** Force multiplier range */
     get strength(): FXRange;
-    /** Noise frequency range */
     set scale(value: FXRangeConfig);
-    /** Force multiplier range */
     set strength(value: FXRangeConfig);
 }

package/dist/emitter/behavior/FXBehaviorTorqueNoise.js

@@ -35,13 +35,11 @@ class FXBehaviorTorqueNoise extends FXBehavior {
     get strength() {
         return this._private_strengthInternal;
     }
-    /** Noise frequency range */
     set scale(value) {
         this._private_scaleInternal = resolveFXRangeConfig(value);
         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, `FXBehaviorTorqueNoise.strength.min`);

package/dist/emitter/behavior/FXBehaviorTorqueOverLife.d.ts

@@ -8,10 +8,12 @@ import { FXBehavior } from "./FXBehavior";
 export declare class FXBehaviorTorqueOverLife extends FXBehavior<{
     builtin: "Matrix4";
 }> {
-    /** Active torque curve */
-    curve: FXCurve1D<FXRange>;
+    private curveInternal;
     /**
      * @param curve - Torque curve; accepts a {@link FXCurve1D} instance or a `FXRange[]` shorthand
      */
     constructor(curve: FXCurve1DConfig<FXRange>);
+    /** Active torque curve */
+    get curve(): FXCurve1D<FXRange>;
+    set curve(value: FXCurve1DConfig<FXRange>);
 }

package/dist/emitter/behavior/FXBehaviorTorqueOverLife.js

@@ -14,7 +14,14 @@ class FXBehaviorTorqueOverLife extends FXBehavior {
         super();
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
-        this.curve = new FXCurve1D(curve);
+        this._private_curveInternal = new FXCurve1D(curve);
+    }
+    /** Active torque curve */
+    get curve() {
+        return this._private_curveInternal;
+    }
+    set curve(value) {
+        this._private_curveInternal = new FXCurve1D(value);
     }
     /** @internal */
     update(properties, instanceCount) {
@@ -24,7 +31,7 @@ class FXBehaviorTorqueOverLife extends FXBehavior {
             const itemOffset = i * itemSize;
             const lifeT = Math.min(array[itemOffset + BUILTIN_OFFSET_AGE] / array[itemOffset + BUILTIN_OFFSET_LIFETIME], 1);
             const torqueT = array[itemOffset + BUILTIN_OFFSET_RANDOM_B];
-            const { a, b, t: localT } = this.curve.sample(lifeT);
+            const { a, b, t: localT } = this._private_curveInternal.sample(lifeT);
             array[itemOffset + BUILTIN_OFFSET_TORQUE] = MathUtils.lerp(MathUtils.lerp(a.min, a.max, torqueT), MathUtils.lerp(b.min, b.max, torqueT), localT);
         }
         builtin.needsUpdate = true;

package/dist/emitter/behavior/FXBehaviorVelocityDamping.d.ts

@@ -16,6 +16,5 @@ export declare class FXBehaviorVelocityDamping extends FXBehavior<{
     constructor(damping: FXRangeConfig);
     /** Damping coefficient range (0-1) */
     get damping(): FXRange;
-    /** Damping coefficient range (0-1) */
     set damping(value: FXRangeConfig);
 }

package/dist/emitter/behavior/FXBehaviorVelocityDamping.js

@@ -25,7 +25,6 @@ class FXBehaviorVelocityDamping extends FXBehavior {
     get damping() {
         return this._private_dampingInternal;
     }
-    /** Damping coefficient range (0-1) */
     set damping(value) {
         this._private_dampingInternal = resolveFXRangeConfig(value);
         assertValidNonNegativeNumber(this._private_dampingInternal.min, `FXBehaviorVelocityDamping.damping.min`);

package/dist/emitter/behavior/FXBehaviorVelocityNoise.d.ts

@@ -20,8 +20,6 @@ export declare class FXBehaviorVelocityNoise extends FXBehavior<{
     get scale(): FXRange;
     /** Force multiplier range */
     get strength(): FXRange;
-    /** Noise frequency range */
     set scale(value: FXRangeConfig);
-    /** Force multiplier range */
     set strength(value: FXRangeConfig);
 }

package/dist/emitter/behavior/FXBehaviorVelocityNoise.js

@@ -37,13 +37,11 @@ class FXBehaviorVelocityNoise extends FXBehavior {
     get strength() {
         return this._private_strengthInternal;
     }
-    /** Noise frequency range */
     set scale(value) {
         this._private_scaleInternal = resolveFXRangeConfig(value);
         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, `FXBehaviorVelocityNoise.strength.min`);

package/dist/emitter/behavior/FXBehaviorVelocityOverLife.d.ts

@@ -11,10 +11,12 @@ import { FXBehavior } from "./FXBehavior";
 export declare class FXBehaviorVelocityOverLife extends FXBehavior<{
     builtin: "Matrix4";
 }> {
-    /** Active speed curve */
-    curve: FXCurve1D<FXRange>;
+    private curveInternal;
     /**
      * @param curve - Speed curve; accepts a {@link FXCurve1D} instance or a `FXRange[]` shorthand
      */
     constructor(curve: FXCurve1DConfig<FXRange>);
+    /** Active speed curve */
+    get curve(): FXCurve1D<FXRange>;
+    set curve(value: FXCurve1DConfig<FXRange>);
 }

package/dist/emitter/behavior/FXBehaviorVelocityOverLife.js

@@ -17,7 +17,14 @@ class FXBehaviorVelocityOverLife extends FXBehavior {
         super();
         /** @internal */
         this.requiredProperties = { builtin: "Matrix4" };
-        this.curve = new FXCurve1D(curve);
+        this._private_curveInternal = new FXCurve1D(curve);
+    }
+    /** Active speed curve */
+    get curve() {
+        return this._private_curveInternal;
+    }
+    set curve(value) {
+        this._private_curveInternal = new FXCurve1D(value);
     }
     /** @internal */
     update(properties, instanceCount) {
@@ -34,7 +41,7 @@ class FXBehaviorVelocityOverLife extends FXBehavior {
                 continue;
             }
             const velocityT = array[itemOffset + BUILTIN_OFFSET_RANDOM_A];
-            const { a, b, t: localT } = this.curve.sample(lifeT);
+            const { a, b, t: localT } = this._private_curveInternal.sample(lifeT);
             const targetSpeed = MathUtils.lerp(MathUtils.lerp(a.min, a.max, velocityT), MathUtils.lerp(b.min, b.max, velocityT), localT);
             const scaleFactor = targetSpeed / currentSpeed;
             array[itemOffset + BUILTIN_OFFSET_VELOCITY_X] = velocityX * scaleFactor;

package/dist/emitter/spawn/FXSpawnBox.d.ts

@@ -14,6 +14,5 @@ export declare class FXSpawnBox extends FXSpawn<{
     constructor(size?: FXVector3Config);
     /** Size of the spawn box */
     get size(): Vector3Like;
-    /** Size of the spawn box */
     set size(value: FXVector3Config);
 }

package/dist/emitter/spawn/FXSpawnBox.js

@@ -23,7 +23,6 @@ class FXSpawnBox extends FXSpawn {
     get size() {
         return this._private_sizeInternal;
     }
-    /** Size of the spawn box */
     set size(value) {
         this._private_sizeInternal = resolveFXVector3Config(value);
         assertValidNumber(this._private_sizeInternal.x, "FXSpawnBox.size.x");

package/dist/emitter/spawn/FXSpawnLifetime.d.ts

@@ -13,6 +13,5 @@ export declare class FXSpawnLifetime extends FXSpawn<{
     constructor(lifetime?: FXRangeConfig);
     /** Lifetime range in seconds */
     get lifetime(): FXRange;
-    /** Lifetime range in seconds */
     set lifetime(value: FXRangeConfig);
 }

package/dist/emitter/spawn/FXSpawnLifetime.js

@@ -22,7 +22,6 @@ class FXSpawnLifetime extends FXSpawn {
     get lifetime() {
         return this._private_lifetimeInternal;
     }
-    /** Lifetime range in seconds */
     set lifetime(value) {
         this._private_lifetimeInternal = resolveFXRangeConfig(value);
         assertValidPositiveNumber(this._private_lifetimeInternal.min, "FXSpawnLifetime.lifetime.min");

package/dist/emitter/spawn/FXSpawnOffset.d.ts

@@ -17,6 +17,5 @@ export declare class FXSpawnOffset extends FXSpawn<{
     constructor(offset?: FXVector3Config);
     /** Particle position offset */
     get offset(): Vector3Like;
-    /** Particle position offset */
     set offset(value: FXVector3Config);
 }

package/dist/emitter/spawn/FXSpawnOffset.js

@@ -25,7 +25,6 @@ class FXSpawnOffset extends FXSpawn {
     get offset() {
         return this._private_offsetInternal;
     }
-    /** Particle position offset */
     set offset(value) {
         this._private_offsetInternal = resolveFXVector3Config(value);
         assertValidNumber(this._private_offsetInternal.x, "FXSpawnOffset.offset.x");

package/dist/emitter/spawn/FXSpawnPoint.d.ts

@@ -14,6 +14,5 @@ export declare class FXSpawnPoint extends FXSpawn<{
     constructor(position?: FXVector3Config);
     /** Spawn position */
     get position(): Vector3Like;
-    /** Spawn position */
     set position(value: FXVector3Config);
 }

package/dist/emitter/spawn/FXSpawnPoint.js

@@ -22,7 +22,6 @@ class FXSpawnPoint extends FXSpawn {
     get position() {
         return this._private_positionInternal;
     }
-    /** Spawn position */
     set position(value) {
         this._private_positionInternal = resolveFXVector3Config(value);
         assertValidNumber(this._private_positionInternal.x, "FXSpawnPoint.position.x");

package/dist/emitter/spawn/FXSpawnRotation.d.ts

@@ -13,6 +13,5 @@ export declare class FXSpawnRotation extends FXSpawn<{
     constructor(rotation?: FXRangeConfig);
     /** Rotation range in radians */
     get rotation(): FXRange;
-    /** Rotation range in radians */
     set rotation(value: FXRangeConfig);
 }

package/dist/emitter/spawn/FXSpawnRotation.js

@@ -22,7 +22,6 @@ class FXSpawnRotation extends FXSpawn {
     get rotation() {
         return this._private_rotationInternal;
     }
-    /** Rotation range in radians */
     set rotation(value) {
         this._private_rotationInternal = resolveFXRangeConfig(value);
         assertValidNumber(this._private_rotationInternal.min, "FXSpawnRotation.rotation.min");

package/dist/emitter/spawn/FXSpawnScale.d.ts

@@ -17,8 +17,6 @@ export declare class FXSpawnScale extends FXSpawn<{
     get scale(): FXRange;
     /** Width/height aspect ratio */
     get aspect(): number;
-    /** Base scale range */
     set scale(value: FXRangeConfig);
-    /** Width/height aspect ratio */
     set aspect(value: FXAspectConfig);
 }

package/dist/emitter/spawn/FXSpawnScale.js

@@ -29,13 +29,11 @@ class FXSpawnScale extends FXSpawn {
     get aspect() {
         return this._private_aspectInternal;
     }
-    /** Base scale range */
     set scale(value) {
         this._private_scaleInternal = resolveFXRangeConfig(value);
         assertValidPositiveNumber(this._private_scaleInternal.min, "FXSpawnScale.scale.min");
         assertValidPositiveNumber(this._private_scaleInternal.max, "FXSpawnScale.scale.max");
     }
-    /** Width/height aspect ratio */
     set aspect(value) {
         this._private_aspectInternal = resolveAspect(value);
         assertValidPositiveNumber(this._private_aspectInternal, "FXSpawnScale.aspect");

package/dist/emitter/spawn/FXSpawnSphere.d.ts

@@ -20,24 +20,17 @@ export declare class FXSpawnSphere extends FXSpawn<{
      * @param angle - Polar half-angle from equatorial plane in radians. Defaults to `Math.PI / 2`
      */
     constructor(innerRadius?: number, outerRadius?: number, angle?: number);
-    /**
-     * Polar half-angle from the equatorial plane.
-     * - `0` - flat disk
-     * - `Math.PI / 2` - full sphere
-     */
-    get angle(): number;
     /** Minimum spawn radius */
     get innerRadius(): number;
     /** Maximum spawn radius */
     get outerRadius(): number;
-    /** Minimum spawn radius */
-    set innerRadius(value: number);
-    /** Maximum spawn radius */
-    set outerRadius(value: number);
     /**
      * Polar half-angle from the equatorial plane.
      * - `0` - flat disk
      * - `Math.PI / 2` - full sphere
      */
+    get angle(): number;
+    set innerRadius(value: number);
+    set outerRadius(value: number);
     set angle(value: number);
 }

package/dist/emitter/spawn/FXSpawnSphere.js

@@ -29,14 +29,6 @@ class FXSpawnSphere extends FXSpawn {
         assertValidNonNegativeNumber(outerRadius, "FXSpawnSphere.constructor.outerRadius");
         assertValidNumber(angle, "FXSpawnSphere.constructor.angle");
     }
-    /**
-     * Polar half-angle from the equatorial plane.
-     * - `0` - flat disk
-     * - `Math.PI / 2` - full sphere
-     */
-    get angle() {
-        return this._private_angleInternal;
-    }
     /** Minimum spawn radius */
     get innerRadius() {
         return this._private_innerRadiusInternal;
@@ -45,21 +37,22 @@ class FXSpawnSphere extends FXSpawn {
     get outerRadius() {
         return this._private_outerRadiusInternal;
     }
-    /** Minimum spawn radius */
+    /**
+     * Polar half-angle from the equatorial plane.
+     * - `0` - flat disk
+     * - `Math.PI / 2` - full sphere
+     */
+    get angle() {
+        return this._private_angleInternal;
+    }
     set innerRadius(value) {
         assertValidNonNegativeNumber(value, "FXSpawnSphere.innerRadius");
         this._private_innerRadiusInternal = value;
     }
-    /** Maximum spawn radius */
     set outerRadius(value) {
         assertValidNonNegativeNumber(value, "FXSpawnSphere.outerRadius");
         this._private_outerRadiusInternal = value;
     }
-    /**
-     * Polar half-angle from the equatorial plane.
-     * - `0` - flat disk
-     * - `Math.PI / 2` - full sphere
-     */
     set angle(value) {
         assertValidNumber(value, "FXSpawnSphere.angle");
         this._private_angleInternal = value;

package/dist/emitter/spawn/FXSpawnTorque.d.ts

@@ -13,6 +13,5 @@ export declare class FXSpawnTorque extends FXSpawn<{
     constructor(torque?: FXRangeConfig);
     /** Angular velocity range in radians/second */
     get torque(): FXRange;
-    /** Angular velocity range in radians/second */
     set torque(value: FXRangeConfig);
 }

package/dist/emitter/spawn/FXSpawnTorque.js

@@ -22,7 +22,6 @@ class FXSpawnTorque extends FXSpawn {
     get torque() {
         return this._private_torqueInternal;
     }
-    /** Angular velocity range in radians/second */
     set torque(value) {
         this._private_torqueInternal = resolveFXRangeConfig(value);
         assertValidNumber(this._private_torqueInternal.min, "FXSpawnTorque.torque.min");

package/dist/emitter/spawn/FXSpawnVelocity.d.ts

@@ -17,16 +17,13 @@ export declare class FXSpawnVelocity extends FXSpawn<{
      * @param magnitude - Speed range in units/second. Defaults to `{ min: -1, max: 1 }`
      */
     constructor(direction?: Vector3, angle?: FXRangeConfig, magnitude?: FXRangeConfig);
+    /** Cone axis (always normalized) */
+    get direction(): Vector3;
     /** Cone half-angle range in radians */
     get angle(): FXRange;
     /** Speed range in units/second */
     get magnitude(): FXRange;
-    /** Cone axis (always normalized) */
-    get direction(): Vector3;
-    /** Cone half-angle range in radians */
+    set direction(value: Vector3);
     set angle(value: FXRangeConfig);
-    /** Speed range in units/second */
     set magnitude(value: FXRangeConfig);
-    /** Cone axis - normalized on assignment */
-    set direction(value: Vector3);
 }

package/dist/emitter/spawn/FXSpawnVelocity.js

@@ -28,6 +28,10 @@ class FXSpawnVelocity extends FXSpawn {
         assertValidNumber(this._private_magnitudeInternal.min, "FXSpawnVelocity.constructor.magnitude.min");
         assertValidNumber(this._private_magnitudeInternal.max, "FXSpawnVelocity.constructor.magnitude.max");
     }
+    /** Cone axis (always normalized) */
+    get direction() {
+        return this._private_directionInternal;
+    }
     /** Cone half-angle range in radians */
     get angle() {
         return this._private_angleInternal;
@@ -36,26 +40,19 @@ class FXSpawnVelocity extends FXSpawn {
     get magnitude() {
         return this._private_magnitudeInternal;
     }
-    /** Cone axis (always normalized) */
-    get direction() {
-        return this._private_directionInternal;
+    set direction(value) {
+        this._private_directionInternal.copy(value).normalize();
     }
-    /** Cone half-angle range in radians */
     set angle(value) {
         this._private_angleInternal = resolveFXRangeConfig(value);
         assertValidNumber(this._private_angleInternal.min, "FXSpawnVelocity.angle.min");
         assertValidNumber(this._private_angleInternal.max, "FXSpawnVelocity.angle.max");
     }
-    /** Speed range in units/second */
     set magnitude(value) {
         this._private_magnitudeInternal = resolveFXRangeConfig(value);
         assertValidNumber(this._private_magnitudeInternal.min, "FXSpawnVelocity.magnitude.min");
         assertValidNumber(this._private_magnitudeInternal.max, "FXSpawnVelocity.magnitude.max");
     }
-    /** Cone axis - normalized on assignment */
-    set direction(value) {
-        this._private_directionInternal.copy(value).normalize();
-    }
     /** @internal */
     spawn(properties, instanceBegin, instanceEnd) {
         const { builtin } = properties;

package/dist/index.d.ts

@@ -18,13 +18,15 @@ export { FXSpawnSphere } from "./emitter/spawn/FXSpawnSphere";
 export { FXSpawnTorque } from "./emitter/spawn/FXSpawnTorque";
 export { FXSpawnVelocity } from "./emitter/spawn/FXSpawnVelocity";
 export { FXDiffuseMaterial } from "./materials/FXDiffuseMaterial/FXDiffuseMaterial";
-export { FXMaterial } from "./materials/FXMaterial/FXMaterial";
+export { FXBlending, FXMaterial } from "./materials/FXMaterial/FXMaterial";
 export { FXUnlitMaterial } from "./materials/FXUnlitMaterial/FXUnlitMaterial";
 export { FXColor } from "./miscellaneous/color/FXColor";
 export { FXCurve1D } from "./miscellaneous/curve/FXCurve1D";
 export type { FXCurve1DAnchor, FXCurve1DConfig, FXCurve1DPoint, } from "./miscellaneous/curve/FXCurve1D";
 export { FXTextureView } from "./miscellaneous/texture/FXTextureView";
 export type { FXTextureAtlasConfig, FXTextureConfig, FXTextureRect, FXTextureSize, FXTextureTrim, } from "./miscellaneous/texture/FXTextureView.Internal";
+export { FXNodeBlending } from "./nodes/blending/FXNodeBlending";
+export { FXNodeLightnessBlendingMask } from "./nodes/blending/FXNodeLightnessBlendingMask";
 export { FXNodeColor } from "./nodes/color/FXNodeColor";
 export { FXNodeColorOverLife } from "./nodes/color/FXNodeColorOverLife";
 export { FXNodeSphericalClip } from "./nodes/color/FXNodeSphericalClip";

package/dist/index.js

@@ -18,11 +18,13 @@ export { FXSpawnSphere } from './emitter/spawn/FXSpawnSphere.js';
 export { FXSpawnTorque } from './emitter/spawn/FXSpawnTorque.js';
 export { FXSpawnVelocity } from './emitter/spawn/FXSpawnVelocity.js';
 export { FXDiffuseMaterial } from './materials/FXDiffuseMaterial/FXDiffuseMaterial.js';
-export { FXMaterial } from './materials/FXMaterial/FXMaterial.js';
+export { FXBlending, FXMaterial } from './materials/FXMaterial/FXMaterial.js';
 export { FXUnlitMaterial } from './materials/FXUnlitMaterial/FXUnlitMaterial.js';
 export { FXColor } from './miscellaneous/color/FXColor.js';
 export { FXCurve1D } from './miscellaneous/curve/FXCurve1D.js';
 export { FXTextureView } from './miscellaneous/texture/FXTextureView.js';
+export { FXNodeBlending } from './nodes/blending/FXNodeBlending.js';
+export { FXNodeLightnessBlendingMask } from './nodes/blending/FXNodeLightnessBlendingMask.js';
 export { FXNodeColor } from './nodes/color/FXNodeColor.js';
 export { FXNodeColorOverLife } from './nodes/color/FXNodeColorOverLife.js';
 export { FXNodeSphericalClip } from './nodes/color/FXNodeSphericalClip.js';

package/dist/instancedParticle/FXInstancedParticle.d.ts

@@ -12,6 +12,7 @@ export declare class FXInstancedParticle extends Mesh {
     private sortingTemporaryBuffer;
     constructor(varyings: Record<string, GLTypeInfo>, expectedCapacity: number, capacityStep: number, material: Material);
     get instanceCount(): number;
+    get instanceCapacity(): number;
     createInstances(count: number): void;
     removeDeadParticles(): void;
     sortByDistance(cameraWorldPosition: Vector3): void;