sparcoon 0.5.0 → 0.6.0

package/dist/materials/FXDiffuseMaterial/FXDiffuseMaterial.js

@@ -1,12 +1,18 @@
 import { FXColor } from '../../miscellaneous/color/FXColor.js';
-import { FXSphericalNormalNode } from '../../nodes/normal/FXSphericalNormalNode.js';
+import { FXNodeSphericalNormal } from '../../nodes/normal/FXNodeSphericalNormal.js';
 import { FXMaterial } from '../FXMaterial/FXMaterial.js';
 import { buildFXDiffuseMaterial } from './FXDiffuseMaterial.Internal.js';
 
+/**
+ * Diffuse particle material with lighting, normals, emission, and optional subsurface scattering
+ */
 class FXDiffuseMaterial extends FXMaterial {
+    /**
+     * @param options - Material configuration
+     */
     constructor(options = {}) {
         super(options);
-        this._private_normalNodes = options.normalNodes ?? [new FXSphericalNormalNode()];
+        this._private_normalNodes = options.normalNodes ?? [new FXNodeSphericalNormal()];
         this._private_emissionNodes = options.emissionNodes ?? [];
         this._private_scatterUniforms =
             options.enableScatter === true
@@ -23,6 +29,7 @@ class FXDiffuseMaterial extends FXMaterial {
                 : undefined;
         this._private_shadowSensitivity = { value: options.shadowSensitivity ?? 1 };
     }
+    /** Releases resources held by all albedo, normal, and emission nodes */
     destroy() {
         super.destroy();
         for (const node of this._private_normalNodes) {

package/dist/materials/FXMaterial/FXDepthMaterial.Internal.d.ts

@@ -1,4 +1,4 @@
 import { MeshDepthMaterial } from "three";
-import type { FXColorNode } from "../../nodes/color/FXColorNode";
-import type { FXTextureNode } from "../../nodes/texture/FXTextureNode";
-export declare function buildDepthMaterial(albedoNodes: readonly (FXColorNode | FXTextureNode)[], depthAlphaTest: number, useDepthAlphaHash: boolean, useSphericalDepth: boolean): MeshDepthMaterial;
+import type { FXNodeColor } from "../../nodes/color/FXNodeColor";
+import type { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
+export declare function buildDepthMaterial(albedoNodes: readonly (FXNodeColor | FXNodeTexture)[], depthAlphaTest: number, useDepthAlphaHash: boolean, useSphericalDepth: boolean): MeshDepthMaterial;

package/dist/materials/FXMaterial/FXDistanceMaterial.Internal.d.ts

@@ -1,4 +1,4 @@
 import { MeshDistanceMaterial } from "three";
-import type { FXColorNode } from "../../nodes/color/FXColorNode";
-import type { FXTextureNode } from "../../nodes/texture/FXTextureNode";
-export declare function buildDistanceMaterial(albedoNodes: readonly (FXColorNode | FXTextureNode)[], distanceAlphaTest: number, useDistanceAlphaHash: boolean, useSphericalDepth: boolean): MeshDistanceMaterial;
+import type { FXNodeColor } from "../../nodes/color/FXNodeColor";
+import type { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
+export declare function buildDistanceMaterial(albedoNodes: readonly (FXNodeColor | FXNodeTexture)[], distanceAlphaTest: number, useDistanceAlphaHash: boolean, useSphericalDepth: boolean): MeshDistanceMaterial;

package/dist/materials/FXMaterial/FXMaterial.d.ts

@@ -1,21 +1,67 @@
-import type { Blending, MeshDistanceMaterial } from "three";
-import type { FXColorNode } from "../../nodes/color/FXColorNode";
-import type { FXTextureNode } from "../../nodes/texture/FXTextureNode";
+import type { Blending } from "three";
+import type { FXNodeColor } from "../../nodes/color/FXNodeColor";
+import type { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
+/**
+ * Configuration options shared by all {@link FXMaterial} subclasses
+ */
 export interface FXMaterialOptions {
-    albedoNodes: (FXColorNode | FXTextureNode)[];
+    /**
+     * Color and texture nodes composited for particle color
+     *
+     * @defaultValue `[]`
+     */
+    albedoNodes: (FXNodeColor | FXNodeTexture)[];
+    /**
+     * Three.js blending mode
+     *
+     * @defaultValue `NormalBlending`
+     */
     blending: Blending;
+    /**
+     * Use alpha hashing instead of standard transparency
+     *
+     * @defaultValue `false`
+     */
     useAlphaHashing: boolean;
+    /**
+     * Alpha cutoff threshold for color passes
+     *
+     * @defaultValue `0.0075`
+     */
     alphaTest: number;
+    /**
+     * Alpha cutoff threshold for depth and shadow passes
+     *
+     * @defaultValue `0.5`
+     */
     depthAlphaTest: number;
+    /**
+     * Use alpha hashing in depth and shadow passes
+     *
+     * @defaultValue `false`
+     */
     useDepthAlphaHash: boolean;
+    /**
+     * Approximate spherical depth for shadow maps
+     *
+     * @defaultValue `true`
+     */
     useSphericalDepth: boolean;
+    /**
+     * Use premultiplied alpha blending
+     *
+     * @defaultValue `true`
+     */
     premultipliedAlpha: boolean;
 }
+/**
+ * Abstract base class for particle materials
+ */
 export declare abstract class FXMaterial {
     private readonly depthAlphaTest;
     private readonly useDepthAlphaHash;
     private readonly useSphericalDepth;
     constructor(options?: Partial<FXMaterialOptions>);
+    /** Releases resources held by all albedo nodes */
     destroy(): void;
-    buildDistanceMaterial(): MeshDistanceMaterial;
 }

package/dist/materials/FXMaterial/FXMaterial.js

@@ -2,6 +2,9 @@ import { NormalBlending } from 'three';
 import { buildDepthMaterial } from './FXDepthMaterial.Internal.js';
 import { buildDistanceMaterial } from './FXDistanceMaterial.Internal.js';
 
+/**
+ * Abstract base class for particle materials
+ */
 class FXMaterial {
     constructor(options = {}) {
         this.albedoNodes = options.albedoNodes ?? [];
@@ -14,6 +17,7 @@ class FXMaterial {
         this._private_useDepthAlphaHash = options.useDepthAlphaHash ?? false;
         this._private_useSphericalDepth = options.useSphericalDepth ?? true;
     }
+    /** Releases resources held by all albedo nodes */
     destroy() {
         for (const node of this.albedoNodes) {
             node.destroy?.();
@@ -23,6 +27,7 @@ class FXMaterial {
     buildDepthMaterial() {
         return buildDepthMaterial(this.albedoNodes, this._private_depthAlphaTest, this._private_useDepthAlphaHash, this._private_useSphericalDepth);
     }
+    /** @internal */
     buildDistanceMaterial() {
         return buildDistanceMaterial(this.albedoNodes, this._private_depthAlphaTest, this._private_useDepthAlphaHash, this._private_useSphericalDepth);
     }

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.Internal.d.ts

@@ -1,6 +1,6 @@
 import type { Blending } from "three";
 import { MeshBasicMaterial } from "three";
 import type { GLTypeInfo } from "../../instancedParticle/shared";
-import type { FXColorNode } from "../../nodes/color/FXColorNode";
-import type { FXTextureNode } from "../../nodes/texture/FXTextureNode";
-export declare function buildFXUnlitMaterial(varyings: Record<string, GLTypeInfo>, blending: Blending, useAlphaHashing: boolean, alphaTest: number, premultipliedAlpha: boolean, albedoNodes: readonly (FXColorNode | FXTextureNode)[]): MeshBasicMaterial;
+import type { FXNodeColor } from "../../nodes/color/FXNodeColor";
+import type { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
+export declare function buildFXUnlitMaterial(varyings: Record<string, GLTypeInfo>, blending: Blending, useAlphaHashing: boolean, alphaTest: number, premultipliedAlpha: boolean, albedoNodes: readonly (FXNodeColor | FXNodeTexture)[]): MeshBasicMaterial;

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.d.ts

@@ -1,6 +1,6 @@
-import type { FXMaterialOptions } from "../FXMaterial/FXMaterial";
 import { FXMaterial } from "../FXMaterial/FXMaterial";
-export type FXUnlitMaterialOptions = FXMaterialOptions;
+/**
+ * Unlit particle material - renders particles without lighting or shadows
+ */
 export declare class FXUnlitMaterial extends FXMaterial {
-    constructor(options?: Partial<FXUnlitMaterialOptions>);
 }

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.js

@@ -1,10 +1,10 @@
 import { FXMaterial } from '../FXMaterial/FXMaterial.js';
 import { buildFXUnlitMaterial } from './FXUnlitMaterial.Internal.js';
 
+/**
+ * Unlit particle material - renders particles without lighting or shadows
+ */
 class FXUnlitMaterial extends FXMaterial {
-    constructor(options = {}) {
-        super(options);
-    }
     /** @internal */
     buildThreeMaterial(varyings) {
         return buildFXUnlitMaterial(varyings, this.blending, this.useAlphaHashing, this.alphaTest, this.premultipliedAlpha, this.albedoNodes);

package/dist/miscellaneous/curve/FXCurve1D.Internal.d.ts

@@ -0,0 +1,20 @@
+import type { FXCurve1D } from "./FXCurve1D";
+/** Input point for {@link FXCurve1D}. */
+export interface FXCurve1DPoint<T> {
+    /** Output value at this position. */
+    value: T;
+    /** Normalized position in [0, 1]. */
+    position: number;
+}
+/**
+ * Accepts either:
+ * - Explicit anchor points ({@link FXCurve1DPoint}\<T>[])
+ * - A uniform shorthand (`T[]`) where anchors are distributed evenly across [0, 1]
+ * - Another {@link FXCurve1D}\<T> instance to copy anchors from
+ */
+export type FXCurve1DConfig<T> = FXCurve1DPoint<T>[] | T[] | FXCurve1D<T>;
+/** Resolved anchor stored internally by {@link FXCurve1D}. */
+export interface FXCurve1DAnchor<T> {
+    readonly value: T;
+    readonly position: number;
+}

package/dist/miscellaneous/curve/FXCurve1D.d.ts

@@ -0,0 +1,17 @@
+import type { FXCurve1DAnchor, FXCurve1DConfig, FXCurve1DPoint } from "./FXCurve1D.Internal";
+export type { FXCurve1DAnchor, FXCurve1DConfig, FXCurve1DPoint };
+/**
+ * 1D curve defined by anchor points at explicit normalized positions.
+ *
+ * Anchors must be strictly ascending by `value`, first must be `0`, last must be `1`.
+ * Output at each anchor is a value of type `T` - interpolation is left to the caller.
+ */
+export declare class FXCurve1D<T> {
+    private readonly anchorsInternal;
+    /**
+     * @param config - Explicit anchor points, a uniform shorthand array, or another {@link FXCurve1D} to copy
+     */
+    constructor(config: FXCurve1DConfig<T>);
+    /** Resolved anchor points ordered ascending by `value`. */
+    get anchors(): readonly FXCurve1DAnchor<T>[];
+}

package/dist/miscellaneous/curve/FXCurve1D.js

@@ -0,0 +1,94 @@
+import { assertValidNumber } from '../asserts.js';
+
+/**
+ * 1D curve defined by anchor points at explicit normalized positions.
+ *
+ * Anchors must be strictly ascending by `value`, first must be `0`, last must be `1`.
+ * Output at each anchor is a value of type `T` - interpolation is left to the caller.
+ */
+class FXCurve1D {
+    /**
+     * @param config - Explicit anchor points, a uniform shorthand array, or another {@link FXCurve1D} to copy
+     */
+    constructor(config) {
+        if (config instanceof FXCurve1D) {
+            this._private_anchorsInternal = config._private_anchorsInternal.map((anchor) => ({ ...anchor }));
+            return;
+        }
+        const isPointArray = config.length > 0 &&
+            typeof config[0] === "object" &&
+            !Array.isArray(config[0]) &&
+            "value" in config[0];
+        const points = isPointArray
+            ? config
+            : config.map((value, index) => ({
+                value,
+                position: index / (config.length - 1),
+            }));
+        if (points.length < 2) {
+            throw new Error("FXCurve1D: at least 2 anchor points are required");
+        }
+        if (points[0].position !== 0) {
+            throw new Error(`FXCurve1D: first anchor value must be 0, got ${points[0].position}`);
+        }
+        if (points[points.length - 1].position !== 1) {
+            throw new Error(`FXCurve1D: last anchor value must be 1, got ${points[points.length - 1].position}`);
+        }
+        this._private_anchorsInternal = [];
+        for (let index = 0; index < points.length; index++) {
+            const { value, position } = points[index];
+            if (position < 0 || position > 1) {
+                throw new Error(`FXCurve1D: anchor[${index}].value must be in [0, 1], got ${position}`);
+            }
+            if (index > 0 && position <= points[index - 1].position) {
+                throw new Error(`FXCurve1D: anchor[${index}].value (${position}) must be strictly greater than anchor[${index - 1}].value (${points[index - 1].position})`);
+            }
+            this._private_anchorsInternal.push({ value, position });
+        }
+    }
+    /** Resolved anchor points ordered ascending by `value`. */
+    get anchors() {
+        return this._private_anchorsInternal;
+    }
+    /**
+     * Samples the curve at normalized position `t`.
+     *
+     * Returns the two bracketing anchor values and the local interpolation factor `t` in [0, 1].
+     * The caller is responsible for interpolating between `a` and `b` using `t`.
+     *
+     * @param t - Normalized position in [0, 1]
+     * @internal
+     */
+    sample(t) {
+        assertValidNumber(t, "FXCurve1D.sample.t");
+        const anchors = this._private_anchorsInternal;
+        const anchorCount = anchors.length;
+        let segmentIndex;
+        if (anchorCount < 10) {
+            segmentIndex = 0;
+            while (segmentIndex < anchorCount - 2 && anchors[segmentIndex + 1].position <= t) {
+                segmentIndex++;
+            }
+        }
+        else {
+            let low = 0;
+            let high = anchorCount - 2;
+            while (low < high) {
+                const mid = (low + high + 1) >> 1;
+                if (anchors[mid].position <= t) {
+                    low = mid;
+                }
+                else {
+                    high = mid - 1;
+                }
+            }
+            segmentIndex = low;
+        }
+        const anchorA = anchors[segmentIndex];
+        const anchorB = anchors[segmentIndex + 1];
+        const localT = (t - anchorA.position) / (anchorB.position - anchorA.position);
+        return { a: anchorA.value, b: anchorB.value, t: localT };
+    }
+}
+
+export { FXCurve1D };

package/dist/miscellaneous/miscellaneous.d.ts

@@ -3,6 +3,8 @@ import { DataTexture } from "three";
 import type { Vector3Like } from "../miscellaneous/math";
 import type { FXTextureConfig } from "../miscellaneous/texture/FXTextureView.Internal";
 import type { FXColor } from "./color/FXColor";
+import type { FXCurve1D } from "./curve/FXCurve1D";
+export declare function getNextInstanceId(): number;
 export interface FXRange {
     min: number;
     max: number;
@@ -13,7 +15,7 @@ export type FXAspectConfig = number | FXTextureConfig;
 export declare function resolveFXRangeConfig(config: FXRangeConfig): FXRange;
 export declare function resolveFXVector3Config(config: FXVector3Config): Vector3Like;
 export declare function resolveAspect(config: number | FXTextureConfig): number;
-export declare function buildGradientTexture(colors: FXColor[]): DataTexture;
+export declare function buildGradientTexture(curve: FXCurve1D<FXColor>): DataTexture;
 export declare const BUILTIN_OFFSET_POSITION_X = 0;
 export declare const BUILTIN_OFFSET_POSITION_Y = 1;
 export declare const BUILTIN_OFFSET_POSITION_Z = 2;

package/dist/miscellaneous/miscellaneous.js

@@ -1,5 +1,9 @@
 import { Texture, DataTexture, RGBAFormat, UnsignedByteType, UVMapping, ClampToEdgeWrapping, LinearFilter, SRGBColorSpace } from 'three';
 
+let nextInstanceId = 0;
+function getNextInstanceId() {
+    return nextInstanceId++;
+}
 function resolveFXRangeConfig(config) {
     if (typeof config === "number") {
         return { min: config, max: config };
@@ -27,12 +31,12 @@ function resolveAspect(config) {
     }
     return config.sourceSize.w / config.sourceSize.h;
 }
-function buildGradientTexture(colors) {
-    const width = colors.length;
+function buildGradientTexture(curve) {
+    const width = curve.anchors.length;
     const height = 1;
     const data = new Uint8Array(width * height * 4);
     for (let i = 0; i < width; i++) {
-        const color = colors[i];
+        const color = curve.anchors[i].value;
         const index = i * 4;
         data[index] = Math.round(color.r * 255);
         data[index + 1] = Math.round(color.g * 255);
@@ -82,4 +86,4 @@ const PARTICLE_DEFINES = `
   #define PARTICLE_RANDOM_C p_builtin[3][3]
 `;
 
-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, PARTICLE_DEFINES, buildGradientTexture, resolveAspect, resolveFXRangeConfig, resolveFXVector3Config };
+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, PARTICLE_DEFINES, buildGradientTexture, getNextInstanceId, resolveAspect, resolveFXRangeConfig, resolveFXVector3Config };

package/dist/miscellaneous/texture/FXTextureView.Internal.js

@@ -0,0 +1,6 @@
+import { Texture } from 'three';
+
+const TEXTURE_DEFAULT_TEXTURE = new Texture();
+const TEXTURE_DEFAULT_SIZE = 2;
+
+export { TEXTURE_DEFAULT_SIZE, TEXTURE_DEFAULT_TEXTURE };

package/dist/miscellaneous/texture/FXTextureView.js

@@ -0,0 +1,234 @@
+import { Ferrsign3 } from 'ferrsign';
+import { Matrix3, Vector2, Texture } from 'three';
+import { assertValidPositiveNumber, assertValidNonNegativeNumber } from '../asserts.js';
+import { TEXTURE_DEFAULT_TEXTURE, TEXTURE_DEFAULT_SIZE } from './FXTextureView.Internal.js';
+
+/** Wrapper for Three.js texture with atlas and trim support. Does not own the underlying texture; user must dispose it. */
+class FXTextureView {
+    /** @param config Texture or atlas configuration */
+    constructor(config) {
+        this._private_textureInternal = TEXTURE_DEFAULT_TEXTURE;
+        this._private_sourceWidth = TEXTURE_DEFAULT_SIZE;
+        this._private_sourceHeight = TEXTURE_DEFAULT_SIZE;
+        this._private_frameX = 0;
+        this._private_frameY = 0;
+        this._private_frameWidth = TEXTURE_DEFAULT_SIZE;
+        this._private_frameHeight = TEXTURE_DEFAULT_SIZE;
+        this._private_rotatedInternal = false;
+        this._private_scaleInternal = 1;
+        this._private_trimLeft = 0;
+        this._private_trimRight = 0;
+        this._private_trimTop = 0;
+        this._private_trimBottom = 0;
+        this._private_textureDirtyInternal = false;
+        this._private_uvTransformDirtyInternal = false;
+        this._private_trimDirtyInternal = false;
+        this._private_signalDiminsionsChangedInternal = new Ferrsign3();
+        if (config !== undefined) {
+            this.set(config);
+        }
+    }
+    /** Original width before trimming in world units */
+    get width() {
+        return this._private_sourceWidth / this._private_scaleInternal;
+    }
+    /** Original height before trimming in world units */
+    get height() {
+        return this._private_sourceHeight / this._private_scaleInternal;
+    }
+    /** Visible width after trimming in world units */
+    get trimmedWidth() {
+        const frameSize = this._private_rotatedInternal ? this._private_frameHeight : this._private_frameWidth;
+        return frameSize / this._private_scaleInternal;
+    }
+    /** Visible height after trimming in world units */
+    get trimmedHeight() {
+        const frameSize = this._private_rotatedInternal ? this._private_frameWidth : this._private_frameHeight;
+        return frameSize / this._private_scaleInternal;
+    }
+    /** Underlying Three.js texture */
+    get texture() {
+        return this._private_textureInternal;
+    }
+    /** Whether sprite is rotated in atlas */
+    get rotated() {
+        return this._private_rotatedInternal;
+    }
+    /** Scale factor for resolution independence */
+    get scale() {
+        return this._private_scaleInternal;
+    }
+    /** Transparent padding around visible content */
+    get trim() {
+        const scale = this._private_scaleInternal;
+        return {
+            left: this._private_trimLeft / scale,
+            right: this._private_trimRight / scale,
+            top: this._private_trimTop / scale,
+            bottom: this._private_trimBottom / scale,
+        };
+    }
+    get textureDirty() {
+        return this._private_textureDirtyInternal;
+    }
+    /** Whether UV transform inputs changed since last check */
+    get uvTransformDirty() {
+        return this._private_uvTransformDirtyInternal;
+    }
+    /** Whether trim values changed since last check */
+    get trimDirty() {
+        return this._private_trimDirtyInternal;
+    }
+    get signalDiminsionsChanged() {
+        return this._private_signalDiminsionsChangedInternal;
+    }
+    setTextureDirtyFalse() {
+        this._private_textureDirtyInternal = false;
+    }
+    /** Marks UV transform as clean. @internal */
+    setUVTransformDirtyFalse() {
+        this._private_uvTransformDirtyInternal = false;
+    }
+    /** Marks trim as clean. @internal */
+    setTrimDirtyFalse() {
+        this._private_trimDirtyInternal = false;
+    }
+    /**
+     * Calculates UV transform matrix for shader sampling.
+     * @param result Matrix to store result in
+     * @returns UV transform matrix
+     */
+    calculateUVTransform(result = new Matrix3()) {
+        const atlasWidth = this._private_textureInternal.image?.naturalWidth ?? TEXTURE_DEFAULT_SIZE;
+        const atlasHeight = this._private_textureInternal.image?.naturalHeight ?? TEXTURE_DEFAULT_SIZE;
+        if (this._private_rotatedInternal) {
+            const physicalWidth = this._private_frameHeight;
+            const physicalHeight = this._private_frameWidth;
+            const u0 = this._private_frameX / atlasWidth;
+            const v0 = (atlasHeight - this._private_frameY - physicalHeight) / atlasHeight;
+            const uSize = physicalWidth / atlasWidth;
+            const vSize = physicalHeight / atlasHeight;
+            result.set(0, uSize, u0, -vSize, 0, v0 + vSize, 0, 0, 1);
+        }
+        else {
+            const u0 = this._private_frameX / atlasWidth;
+            const v0 = (atlasHeight - this._private_frameY - this._private_frameHeight) / atlasHeight;
+            const uSize = this._private_frameWidth / atlasWidth;
+            const vSize = this._private_frameHeight / atlasHeight;
+            result.set(uSize, 0, u0, 0, vSize, v0, 0, 0, 1);
+        }
+        return result;
+    }
+    /**
+     * Gets original dimensions before trimming.
+     * @param result Vector to store result in
+     * @returns Width and height in world units
+     */
+    getResolution(result = new Vector2()) {
+        return result.set(this.width, this.height);
+    }
+    /**
+     * Replaces texture with new configuration.
+     * @param config Texture or atlas configuration
+     */
+    set(config) {
+        const lastWidth = this.width;
+        const lastHeight = this.height;
+        if (config instanceof Texture) {
+            this._private_setFromTexture(config);
+        }
+        else {
+            this._private_setFromAtlasConfig(config);
+        }
+        if (this.width !== lastWidth || this.height !== lastHeight) {
+            this._private_signalDiminsionsChangedInternal.emit(this.width, this.height, this);
+        }
+    }
+    _private_setFromTexture(texture) {
+        const width = texture.image?.naturalWidth ?? TEXTURE_DEFAULT_SIZE;
+        const height = texture.image?.naturalHeight ?? TEXTURE_DEFAULT_SIZE;
+        this._private_sourceWidth = width;
+        this._private_sourceHeight = height;
+        if (this.texture !== texture) {
+            this._private_textureInternal = texture;
+            this._private_textureDirtyInternal = true;
+        }
+        if (this._private_frameX !== 0 ||
+            this._private_frameY !== 0 ||
+            this._private_frameWidth !== width ||
+            this._private_frameHeight !== height ||
+            this._private_scaleInternal !== 1 || this._private_rotatedInternal) {
+            this._private_frameX = 0;
+            this._private_frameY = 0;
+            this._private_frameWidth = width;
+            this._private_frameHeight = height;
+            this._private_rotatedInternal = false;
+            this._private_scaleInternal = 1;
+            this._private_uvTransformDirtyInternal = true;
+        }
+        if (this._private_trimLeft !== 0 ||
+            this._private_trimRight !== 0 ||
+            this._private_trimTop !== 0 ||
+            this._private_trimBottom !== 0) {
+            this._private_trimLeft = 0;
+            this._private_trimRight = 0;
+            this._private_trimTop = 0;
+            this._private_trimBottom = 0;
+            this._private_trimDirtyInternal = true;
+        }
+    }
+    _private_setFromAtlasConfig(config) {
+        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, "FXTextureView.setFromAtlasConfig.config.scale");
+        }
+        this._private_sourceWidth = config.sourceSize.w;
+        this._private_sourceHeight = config.sourceSize.h;
+        if (this.texture !== config.texture) {
+            this._private_textureInternal = config.texture;
+            this._private_textureDirtyInternal = true;
+        }
+        const scale = config.scale ?? 1;
+        const rotated = config.rotated ?? false;
+        if (this._private_frameX !== 0 ||
+            this._private_frameY !== 0 ||
+            this._private_frameWidth !== config.frame.w ||
+            this._private_frameHeight !== config.frame.h ||
+            this._private_scaleInternal !== scale ||
+            this._private_rotatedInternal !== rotated) {
+            this._private_frameX = config.frame.x;
+            this._private_frameY = config.frame.y;
+            this._private_frameWidth = config.frame.w;
+            this._private_frameHeight = config.frame.h;
+            this._private_scaleInternal = scale;
+            this._private_rotatedInternal = rotated;
+            this._private_uvTransformDirtyInternal = true;
+        }
+        const spriteSource = config.spriteSourceSize;
+        const trimLeft = spriteSource.x;
+        const trimTop = spriteSource.y;
+        const trimRight = this._private_sourceWidth - spriteSource.x - spriteSource.w;
+        const trimBottom = this._private_sourceHeight - spriteSource.y - spriteSource.h;
+        if (this._private_trimLeft !== trimLeft ||
+            this._private_trimRight !== trimRight ||
+            this._private_trimTop !== trimTop ||
+            this._private_trimBottom !== trimBottom) {
+            this._private_trimLeft = trimLeft;
+            this._private_trimRight = trimRight;
+            this._private_trimTop = trimTop;
+            this._private_trimBottom = trimBottom;
+            this._private_trimDirtyInternal = true;
+        }
+    }
+}
+
+export { FXTextureView };

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

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

package/dist/nodes/color/FXNodeColor.js

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

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

@@ -0,0 +1,25 @@
+import type { FXColor } from "../../miscellaneous/color/FXColor";
+import type { FXCurve1DConfig } from "../../miscellaneous/curve/FXCurve1D";
+import { FXCurve1D } from "../../miscellaneous/curve/FXCurve1D";
+import { FXNodeColor } from "./FXNodeColor";
+/**
+ * Color node that animates particle color along a gradient curve over its lifetime
+ */
+export declare class FXNodeColorOverLife extends FXNodeColor {
+    private readonly uniformName;
+    private curveInternal;
+    /**
+     * @param curve - Color gradient defining the animation over the particle lifetime
+     */
+    constructor(curve: FXCurve1DConfig<FXColor>);
+    /** Current color gradient curve */
+    get curve(): FXCurve1D<FXColor>;
+    /**
+     * Replaces the color gradient curve and rebuilds the backing texture
+     *
+     * @param value - New color gradient configuration
+     */
+    set curve(value: FXCurve1DConfig<FXColor>);
+    /** Releases the backing gradient texture */
+    destroy(): void;
+}