sparcoon 0.5.0 → 0.6.0

package/dist/nodes/color/FXNodeColorOverLife.js

@@ -0,0 +1,60 @@
+import { FXCurve1D } from '../../miscellaneous/curve/FXCurve1D.js';
+import { buildGradientTexture, getNextInstanceId } from '../../miscellaneous/miscellaneous.js';
+import { checkSRGBSupport } from '../../miscellaneous/webglCapabilities.js';
+import { FXNodeColor } from './FXNodeColor.js';
+
+/**
+ * Color node that animates particle color along a gradient curve over its lifetime
+ */
+class FXNodeColorOverLife extends FXNodeColor {
+    /**
+     * @param curve - Color gradient defining the animation over the particle lifetime
+     */
+    constructor(curve) {
+        super();
+        const id = getNextInstanceId();
+        this._private_uniformName = `u_ColorOverLife_${id}`;
+        this._private_curveInternal = new FXCurve1D(curve);
+        this._private_gradientTexture = buildGradientTexture(this._private_curveInternal);
+        this.affectsDepth = true;
+        this.cacheKey = "color-over-life";
+        this.uniformDeclarations = [`uniform sampler2D ${this._private_uniformName};`];
+        this.uniforms = {
+            [this._private_uniformName]: { value: this._private_gradientTexture },
+        };
+        this.helperFunctions = `
+      vec4 fxSampleColorOverLife(sampler2D gradientTexture) {
+        // Normalized particle age [0, 1] maps to the gradient texture's x-axis
+        float lifetimeRatio = clamp(PARTICLE_AGE / PARTICLE_LIFETIME, 0.0, 1.0);
+        vec4 color = texture2D(gradientTexture, vec2(lifetimeRatio, 0.5));
+
+        // Apply gamma correction when sRGB textures are not natively supported
+        ${checkSRGBSupport() ? "" : "color = vec4(pow(color.rgb, vec3(2.2)), color.a);"}
+
+        return color;
+      }
+    `;
+        this.colorExpression = `fxSampleColorOverLife(${this._private_uniformName})`;
+    }
+    /** Current color gradient curve */
+    get curve() {
+        return this._private_curveInternal;
+    }
+    /**
+     * Replaces the color gradient curve and rebuilds the backing texture
+     *
+     * @param value - New color gradient configuration
+     */
+    set curve(value) {
+        this._private_curveInternal = new FXCurve1D(value);
+        this._private_gradientTexture.dispose();
+        this._private_gradientTexture = buildGradientTexture(this._private_curveInternal);
+        this.uniforms[this._private_uniformName].value = this._private_gradientTexture;
+    }
+    /** Releases the backing gradient texture */
+    destroy() {
+        this._private_gradientTexture.dispose();
+    }
+}
+
+export { FXNodeColorOverLife };

package/dist/nodes/color/FXNodeSphericalClip.d.ts

@@ -0,0 +1,18 @@
+import { FXNodeColor } from "./FXNodeColor";
+/**
+ * Color node that clips a particle to a circle with a configurable soft edge
+ *
+ * @remarks
+ * Fades alpha from fully opaque at `innerRadius` to fully transparent at the billboard edge
+ * (UV radius `0.5`). An `innerRadius` of `0.5` produces a hard circular clip with no gradient.
+ */
+export declare class FXNodeSphericalClip extends FXNodeColor {
+    private readonly uniformInnerRadius;
+    /**
+     * @param innerRadius - UV radius where the fade begins; must be non-negative. Defaults to `0.5`
+     */
+    constructor(innerRadius?: number);
+    /** UV radius of the fully opaque inner area */
+    get innerRadius(): number;
+    set innerRadius(value: number);
+}

package/dist/nodes/color/FXNodeSphericalClip.js

@@ -0,0 +1,45 @@
+import { assertValidNonNegativeNumber } from '../../miscellaneous/asserts.js';
+import { getNextInstanceId } from '../../miscellaneous/miscellaneous.js';
+import { FXNodeColor } from './FXNodeColor.js';
+
+/**
+ * Color node that clips a particle to a circle with a configurable soft edge
+ *
+ * @remarks
+ * Fades alpha from fully opaque at `innerRadius` to fully transparent at the billboard edge
+ * (UV radius `0.5`). An `innerRadius` of `0.5` produces a hard circular clip with no gradient.
+ */
+class FXNodeSphericalClip extends FXNodeColor {
+    /**
+     * @param innerRadius - UV radius where the fade begins; must be non-negative. Defaults to `0.5`
+     */
+    constructor(innerRadius = 0.5) {
+        super();
+        assertValidNonNegativeNumber(innerRadius, "FXNodeSphericalClip.constructor.innerRadius");
+        const id = getNextInstanceId();
+        this._private_uniformInnerRadius = `u_SphericalClipInnerRadius_${id}`;
+        this.affectsDepth = true;
+        this.cacheKey = "spherical-clip";
+        this.uniformDeclarations = [`uniform float ${this._private_uniformInnerRadius};`];
+        this.uniforms = {
+            [this._private_uniformInnerRadius]: { value: innerRadius },
+        };
+        this.helperFunctions = `
+      vec4 fxApplySphericalClip(float innerRadius) {
+        float distanceToCenter = distance(p_uv, vec2(0.5, 0.5));
+        return vec4(1.0, 1.0, 1.0, 1.0 - smoothstep(innerRadius, 0.5, distanceToCenter));
+      }
+    `;
+        this.colorExpression = `fxApplySphericalClip(${this._private_uniformInnerRadius})`;
+    }
+    /** UV radius of the fully opaque inner area */
+    get innerRadius() {
+        return this.uniforms[this._private_uniformInnerRadius].value;
+    }
+    set innerRadius(value) {
+        assertValidNonNegativeNumber(value, "FXNodeSphericalClip.innerRadius");
+        this.uniforms[this._private_uniformInnerRadius].value = value;
+    }
+}
+
+export { FXNodeSphericalClip };

package/dist/nodes/normal/FXNodeFlatNormal.d.ts

@@ -0,0 +1,7 @@
+import { FXNodeNormal } from "./FXNodeNormal";
+/**
+ * Normal node that outputs a constant face-aligned normal pointing toward the camera
+ */
+export declare class FXNodeFlatNormal extends FXNodeNormal {
+    constructor();
+}

package/dist/nodes/normal/FXNodeFlatNormal.js

@@ -0,0 +1,17 @@
+import { FXNodeNormal } from './FXNodeNormal.js';
+
+/**
+ * Normal node that outputs a constant face-aligned normal pointing toward the camera
+ */
+class FXNodeFlatNormal extends FXNodeNormal {
+    constructor() {
+        super();
+        this.cacheKey = "flat-normal";
+        this.uniformDeclarations = [];
+        this.uniforms = {};
+        this.helperFunctions = "";
+        this.normalExpression = "vec3(0.0, 0.0, 1.0)";
+    }
+}
+
+export { FXNodeFlatNormal };

package/dist/nodes/normal/FXNodeNormal.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Abstract base class for particle normal nodes
+ */
+export declare abstract class FXNodeNormal {
+    /** Releases any GPU resources held by this node */
+    destroy?(): void;
+}

package/dist/nodes/normal/FXNodeNormal.js

@@ -0,0 +1,7 @@
+/**
+ * Abstract base class for particle normal nodes
+ */
+class FXNodeNormal {
+}
+
+export { FXNodeNormal };

package/dist/nodes/normal/FXNodeSphericalNormal.d.ts

@@ -0,0 +1,7 @@
+import { FXNodeNormal } from "./FXNodeNormal";
+/**
+ * Normal node that makes flat billboard particles appear as spheres under directional lighting
+ */
+export declare class FXNodeSphericalNormal extends FXNodeNormal {
+    constructor();
+}

package/dist/nodes/normal/{FXSphericalNormalNode.js → FXNodeSphericalNormal.js}

@@ -1,9 +1,12 @@
-import { FXNormalNode } from './FXNormalNode.js';
+import { FXNodeNormal } from './FXNodeNormal.js';
 
-class FXSphericalNormalNode extends FXNormalNode {
+/**
+ * Normal node that makes flat billboard particles appear as spheres under directional lighting
+ */
+class FXNodeSphericalNormal extends FXNodeNormal {
     constructor() {
         super();
-        this.cacheKey = "spherical";
+        this.cacheKey = "spherical-normal";
         this.uniformDeclarations = [];
         this.uniforms = {};
         this.helperFunctions = `
@@ -16,4 +19,4 @@ class FXSphericalNormalNode extends FXNormalNode {
     }
 }
 
-export { FXSphericalNormalNode };
+export { FXNodeSphericalNormal };

package/dist/nodes/texture/FXNodeAnimatedTexture.d.ts

@@ -0,0 +1,47 @@
+import { FXTextureView } from "../../miscellaneous/texture/FXTextureView";
+import type { FXTextureConfig } from "../../miscellaneous/texture/FXTextureView.Internal";
+import { FXNodeTexture } from "./FXNodeTexture";
+/**
+ * Options for {@link FXNodeAnimatedTexture}
+ */
+export interface FXNodeAnimatedTextureOptions {
+    /** Texture or atlas configuration containing all animation frames */
+    texture: FXTextureConfig;
+    /** Number of frame columns in the sprite sheet */
+    columns: number;
+    /** Number of frame rows in the sprite sheet */
+    rows: number;
+    /**
+     * If true, blends between adjacent frames for smoother animation
+     *
+     * @defaultValue `false`
+     */
+    interpolate?: boolean;
+}
+/**
+ * Texture node that animates through sprite sheet frames over a particle's lifetime
+ *
+ * @remarks
+ * Frames advance from the first to the last as the particle ages. The total frame count
+ * is `columns * rows`. Both `columns` and `rows` must be positive integers.
+ */
+export declare class FXNodeAnimatedTexture extends FXNodeTexture {
+    private readonly uniformTexture;
+    private readonly uniformUVTransform;
+    private readonly uniformColumns;
+    private readonly uniformRows;
+    private readonly textureViewInternal;
+    /**
+     * @param options - Sprite sheet configuration
+     */
+    constructor({ texture, columns, rows, interpolate }: FXNodeAnimatedTextureOptions);
+    /** View describing the texture and its atlas region */
+    get textureView(): FXTextureView;
+    /** Number of frame columns in the sprite sheet */
+    get columns(): number;
+    /** Number of frame rows in the sprite sheet */
+    get rows(): number;
+    set textureView(config: FXTextureConfig);
+    set columns(value: number);
+    set rows(value: number);
+}

package/dist/nodes/texture/FXNodeAnimatedTexture.js

@@ -0,0 +1,137 @@
+import { assertValidPositiveNumber } from '../../miscellaneous/asserts.js';
+import { getNextInstanceId } from '../../miscellaneous/miscellaneous.js';
+import { FXTextureView } from '../../miscellaneous/texture/FXTextureView.js';
+import { checkSRGBSupport } from '../../miscellaneous/webglCapabilities.js';
+import { FXNodeTexture } from './FXNodeTexture.js';
+
+/**
+ * Texture node that animates through sprite sheet frames over a particle's lifetime
+ *
+ * @remarks
+ * Frames advance from the first to the last as the particle ages. The total frame count
+ * is `columns * rows`. Both `columns` and `rows` must be positive integers.
+ */
+class FXNodeAnimatedTexture extends FXNodeTexture {
+    /**
+     * @param options - Sprite sheet configuration
+     */
+    constructor({ texture, columns, rows, interpolate = false }) {
+        super();
+        assertValidPositiveNumber(columns, "FXNodeAnimatedTexture.constructor.columns");
+        assertValidPositiveNumber(rows, "FXNodeAnimatedTexture.constructor.rows");
+        const idx = getNextInstanceId();
+        this._private_uniformTexture = `u_AnimatedTexture_${idx}`;
+        this._private_uniformUVTransform = `u_AnimatedTextureUVTransform_${idx}`;
+        this._private_uniformColumns = `u_AnimatedTextureColumns_${idx}`;
+        this._private_uniformRows = `u_AnimatedTextureRows_${idx}`;
+        this._private_textureViewInternal = new FXTextureView(texture);
+        const uvTransform = this._private_textureViewInternal.calculateUVTransform();
+        this._private_textureViewInternal.setTextureDirtyFalse();
+        this._private_textureViewInternal.setUVTransformDirtyFalse();
+        const gammaCorrection = checkSRGBSupport()
+            ? ""
+            : "color = vec4(pow(color.rgb, vec3(2.2)), color.a);";
+        this.affectsDepth = true;
+        this.cacheKey = interpolate ? "animated-texture-interpolated" : "animated-texture";
+        this.uniformDeclarations = [
+            `uniform sampler2D ${this._private_uniformTexture};`,
+            `uniform mat3 ${this._private_uniformUVTransform};`,
+            `uniform float ${this._private_uniformColumns};`,
+            `uniform float ${this._private_uniformRows};`,
+        ];
+        this.uniforms = {
+            [this._private_uniformTexture]: { value: this._private_textureViewInternal.texture },
+            [this._private_uniformUVTransform]: { value: uvTransform },
+            [this._private_uniformColumns]: { value: columns },
+            [this._private_uniformRows]: { value: rows },
+        };
+        this.helperFunctions = interpolate
+            ? `
+        vec2 fxFrameToUV(vec2 uv, float frame, float columns, float rows) {
+          float column = mod(frame, columns);
+          float row = floor(frame / columns);
+          return vec2((column + uv.x) / columns, 1.0 - (row + 1.0 - uv.y) / rows);
+        }
+
+        vec4 fxSampleAnimatedTexture(sampler2D spriteSheet, mat3 uvTransform, vec2 uv, float columns, float rows) {
+          float totalFrames = columns * rows;
+
+          // Fractional frame position drives both frame selection and blend weight
+          float exactFrame = PARTICLE_AGE / PARTICLE_LIFETIME * totalFrames;
+          float currentFrame = clamp(floor(exactFrame), 0.0, totalFrames - 1.0);
+          float nextFrame    = clamp(currentFrame + 1.0, 0.0, totalFrames - 1.0);
+          float blendWeight  = fract(exactFrame);
+
+          vec2 currentUV = (uvTransform * vec3(fxFrameToUV(uv, currentFrame, columns, rows), 1.0)).xy;
+          vec2 nextUV    = (uvTransform * vec3(fxFrameToUV(uv, nextFrame,    columns, rows), 1.0)).xy;
+
+          vec4 color = mix(
+            texture2D(spriteSheet, currentUV),
+            texture2D(spriteSheet, nextUV),
+            blendWeight
+          );
+
+          // Apply gamma correction when sRGB textures are not natively supported
+          ${gammaCorrection}
+
+          return color;
+        }
+      `
+            : `
+        vec4 fxSampleAnimatedTexture(sampler2D spriteSheet, mat3 uvTransform, vec2 uv, float columns, float rows) {
+          // Determine which frame to display based on normalized particle age
+          float totalFrames = columns * rows;
+          float frame = floor(PARTICLE_AGE / PARTICLE_LIFETIME * totalFrames);
+          frame = clamp(frame, 0.0, totalFrames - 1.0);
+
+          // Locate the frame's column and row in the sprite sheet grid
+          float column = mod(frame, columns);
+          float row = floor(frame / columns);
+
+          // Remap UV to the frame's tile region, then apply atlas transform
+          vec2 frameUV = vec2((column + uv.x) / columns, 1.0 - (row + 1.0 - uv.y) / rows);
+          vec2 atlasUV = (uvTransform * vec3(frameUV, 1.0)).xy;
+          vec4 color = texture2D(spriteSheet, atlasUV);
+
+          // Apply gamma correction when sRGB textures are not natively supported
+          ${gammaCorrection}
+
+          return color;
+        }
+      `;
+        this.colorExpression = `fxSampleAnimatedTexture(${this._private_uniformTexture}, ${this._private_uniformUVTransform}, p_uv, ${this._private_uniformColumns}, ${this._private_uniformRows})`;
+    }
+    /** View describing the texture and its atlas region */
+    get textureView() {
+        return this._private_textureViewInternal;
+    }
+    /** Number of frame columns in the sprite sheet */
+    get columns() {
+        return this.uniforms[this._private_uniformColumns].value;
+    }
+    /** Number of frame rows in the sprite sheet */
+    get rows() {
+        return this.uniforms[this._private_uniformRows].value;
+    }
+    set textureView(config) {
+        this._private_textureViewInternal.set(config);
+        if (this._private_textureViewInternal.textureDirty) {
+            this.uniforms[this._private_uniformTexture].value = this._private_textureViewInternal.texture;
+            this._private_textureViewInternal.setTextureDirtyFalse();
+        }
+        if (this._private_textureViewInternal.uvTransformDirty) {
+            this._private_textureViewInternal.calculateUVTransform(this.uniforms[this._private_uniformUVTransform].value);
+            this._private_textureViewInternal.setUVTransformDirtyFalse();
+        }
+    }
+    set columns(value) {
+        assertValidPositiveNumber(value, "FXNodeAnimatedTexture.columns");
+        this.uniforms[this._private_uniformColumns].value = value;
+    }
+    set rows(value) {
+        assertValidPositiveNumber(value, "FXNodeAnimatedTexture.rows");
+        this.uniforms[this._private_uniformRows].value = value;
+    }
+}
+
+export { FXNodeAnimatedTexture };

package/dist/nodes/texture/FXNodeStaticTexture.d.ts

@@ -0,0 +1,18 @@
+import { FXTextureView } from "../../miscellaneous/texture/FXTextureView";
+import type { FXTextureConfig } from "../../miscellaneous/texture/FXTextureView.Internal";
+import { FXNodeTexture } from "./FXNodeTexture";
+/**
+ * Texture node that applies a single static texture to every particle
+ */
+export declare class FXNodeStaticTexture extends FXNodeTexture {
+    private readonly uniformTexture;
+    private readonly uniformUVTransform;
+    private readonly textureViewInternal;
+    /**
+     * @param config - Texture or atlas configuration applied to every particle
+     */
+    constructor(config: FXTextureConfig);
+    /** View describing the texture and its atlas region */
+    get textureView(): FXTextureView;
+    set textureView(config: FXTextureConfig);
+}

package/dist/nodes/texture/FXNodeStaticTexture.js

@@ -0,0 +1,60 @@
+import { getNextInstanceId } from '../../miscellaneous/miscellaneous.js';
+import { FXTextureView } from '../../miscellaneous/texture/FXTextureView.js';
+import { checkSRGBSupport } from '../../miscellaneous/webglCapabilities.js';
+import { FXNodeTexture } from './FXNodeTexture.js';
+
+/**
+ * Texture node that applies a single static texture to every particle
+ */
+class FXNodeStaticTexture extends FXNodeTexture {
+    /**
+     * @param config - Texture or atlas configuration applied to every particle
+     */
+    constructor(config) {
+        super();
+        const id = getNextInstanceId();
+        this._private_uniformTexture = `u_StaticTexture_${id}`;
+        this._private_uniformUVTransform = `u_StaticTextureUVTransform_${id}`;
+        this._private_textureViewInternal = new FXTextureView(config);
+        const uvTransform = this._private_textureViewInternal.calculateUVTransform();
+        this._private_textureViewInternal.setTextureDirtyFalse();
+        this._private_textureViewInternal.setUVTransformDirtyFalse();
+        this.affectsDepth = true;
+        this.cacheKey = "static-texture";
+        this.uniformDeclarations = [
+            `uniform sampler2D ${this._private_uniformTexture};`,
+            `uniform mat3 ${this._private_uniformUVTransform};`,
+        ];
+        this.uniforms = {
+            [this._private_uniformTexture]: { value: this._private_textureViewInternal.texture },
+            [this._private_uniformUVTransform]: { value: uvTransform },
+        };
+        this.helperFunctions = `
+      vec4 fxSampleStaticTexture(sampler2D colorTexture, mat3 uvTransform, vec2 uv) {
+        vec2 transformedUV = (uvTransform * vec3(uv, 1.0)).xy;
+        vec4 color = texture2D(colorTexture, transformedUV);
+        // Apply gamma correction when sRGB textures are not natively supported
+        ${checkSRGBSupport() ? "" : "color = vec4(pow(color.rgb, vec3(2.2)), color.a);"}
+        return color;
+      }
+    `;
+        this.colorExpression = `fxSampleStaticTexture(${this._private_uniformTexture}, ${this._private_uniformUVTransform}, p_uv)`;
+    }
+    /** View describing the texture and its atlas region */
+    get textureView() {
+        return this._private_textureViewInternal;
+    }
+    set textureView(config) {
+        this._private_textureViewInternal.set(config);
+        if (this._private_textureViewInternal.textureDirty) {
+            this.uniforms[this._private_uniformTexture].value = this._private_textureViewInternal.texture;
+            this._private_textureViewInternal.setTextureDirtyFalse();
+        }
+        if (this._private_textureViewInternal.uvTransformDirty) {
+            this._private_textureViewInternal.calculateUVTransform(this.uniforms[this._private_uniformUVTransform].value);
+            this._private_textureViewInternal.setUVTransformDirtyFalse();
+        }
+    }
+}
+
+export { FXNodeStaticTexture };

package/dist/nodes/texture/FXNodeTexture.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Abstract base class for particle texture nodes
+ */
+export declare abstract class FXNodeTexture {
+    /** Releases any GPU resources held by this node */
+    destroy?(): void;
+}

package/dist/nodes/texture/FXNodeTexture.js

@@ -0,0 +1,11 @@
+/**
+ * Abstract base class for particle texture nodes
+ */
+class FXNodeTexture {
+    constructor() {
+        /** @internal */
+        this.affectsDepth = false;
+    }
+}
+
+export { FXNodeTexture };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sparcoon",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Instanced-mesh particle system for Three.js.",
   "keywords": [
     "particles",
@@ -45,6 +45,7 @@
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-commonjs": "^29.0.2",
     "@types/node": "^25.0.2",
     "@types/three": "^0.157.0",
     "@typescript-eslint/eslint-plugin": "^8.32.0",
@@ -55,8 +56,5 @@
     "rollup-plugin-typescript2": "^0.36.0",
     "ts-transformer-minify-privates": "^1.0.0",
     "typescript": "^5.8.3"
-  },
-  "dependencies": {
-    "@rollup/plugin-commonjs": "^29.0.2"
   }
 }

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

@@ -1,21 +0,0 @@
-import type { Vector3Like } from "../../miscellaneous/math";
-import type { FXVector3Config } from "../../miscellaneous/miscellaneous";
-import { FXBehavior } from "./FXBehavior";
-/**
- * Applies constant acceleration to all particles.
- *
- * Adds the direction vector to particle velocity each frame.
- */
-export declare class FXBehaviorDirectionalGravity extends FXBehavior<{
-    builtin: "Matrix4";
-}> {
-    private directionInternal;
-    /**
-     * @param direction - Acceleration vector in units/second²
-     */
-    constructor(direction: Vector3Like);
-    /** Acceleration vector in units/second² */
-    get direction(): Vector3Like;
-    /** Acceleration vector in units/second² */
-    set direction(value: FXVector3Config);
-}

package/dist/emitter/behavior/FXBehaviorDirectionalGravity.js

@@ -1,51 +0,0 @@
-import { assertValidNumber } from '../../miscellaneous/asserts.js';
-import { resolveFXVector3Config, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z } from '../../miscellaneous/miscellaneous.js';
-import { FXBehavior } from './FXBehavior.js';
-
-/**
- * Applies constant acceleration to all particles.
- *
- * Adds the direction vector to particle velocity each frame.
- */
-class FXBehaviorDirectionalGravity extends FXBehavior {
-    /**
-     * @param direction - Acceleration vector in units/second²
-     */
-    constructor(direction) {
-        super();
-        /** @internal */
-        this.requiredProperties = { builtin: "Matrix4" };
-        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() {
-        return this._private_directionInternal;
-    }
-    /** Acceleration vector in units/second² */
-    set direction(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) {
-        const { builtin } = properties;
-        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;
-    }
-}
-
-export { FXBehaviorDirectionalGravity };

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

@@ -1,39 +0,0 @@
-import type { Vector3Like } from "../../miscellaneous/math";
-import { type FXRange, type FXRangeConfig, type FXVector3Config } from "../../miscellaneous/miscellaneous";
-import { FXBehavior } from "./FXBehavior";
-/**
- * Applies gravity attraction toward a point.
- *
- * Force follows inverse power law: strength / distance^exponent. Particles closer than threshold are unaffected.
- */
-export declare class FXBehaviorPointGravity extends FXBehavior<{
-    builtin: "Matrix4";
-}> {
-    private centerInternal;
-    private strengthInternal;
-    private exponentInternal;
-    private thresholdInternal;
-    /**
-     * @param center - Gravity center position
-     * @param strength - Force multiplier range. Accepts number, tuple, or range object
-     * @param exponent - Distance power exponent range. Accepts number, tuple, or range object
-     * @param threshold - Minimum distance range. Accepts number, tuple, or range object
-     */
-    constructor(center: Vector3Like, strength: FXRangeConfig, exponent?: FXRangeConfig, threshold?: FXRangeConfig);
-    /** Gravity center position */
-    get center(): Vector3Like;
-    /** Force multiplier range */
-    get strength(): FXRange;
-    /** Distance power exponent range */
-    get exponent(): FXRange;
-    /** Minimum distance range */
-    get threshold(): FXRange;
-    /** Gravity center position */
-    set center(value: FXVector3Config);
-    /** Force multiplier range */
-    set strength(value: FXRangeConfig);
-    /** Distance power exponent range */
-    set exponent(value: FXRangeConfig);
-    /** Minimum distance range */
-    set threshold(value: FXRangeConfig);
-}