sparcoon 0.0.8 → 0.2.0

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.Internal.js

@@ -0,0 +1,80 @@
+import { MeshBasicMaterial, DoubleSide } from 'three';
+import { PARTICLE_DEFINES } from '../miscellaneous.js';
+
+function buildFXUnlitMaterial(varyings, blending, useAlphaHashing, colorNodes) {
+    const attributeDeclarations = [];
+    const varyingDeclarations = [];
+    const vertexAssignments = [];
+    for (const name in varyings) {
+        const { glslTypeName } = varyings[name];
+        attributeDeclarations.push(`attribute ${glslTypeName} a_${name};`);
+        varyingDeclarations.push(`varying ${glslTypeName} p_${name};`);
+        vertexAssignments.push(`p_${name} = a_${name};`);
+    }
+    const material = new MeshBasicMaterial({
+        transparent: !useAlphaHashing,
+        depthWrite: useAlphaHashing,
+        depthTest: true,
+        alphaHash: useAlphaHashing,
+        blending,
+        side: DoubleSide,
+        forceSinglePass: true,
+        alphaTest: 1 / 255,
+    });
+    material.onBeforeCompile = (shader) => {
+        const vertexPreamble = [
+            PARTICLE_DEFINES,
+            attributeDeclarations.join("\n"),
+            "varying vec2 p_uv;",
+            varyingDeclarations.join("\n"),
+        ].join("\n");
+        shader.vertexShader =
+            vertexPreamble +
+                "\n" +
+                shader.vertexShader
+                    .replace("#include <begin_vertex>", [
+                    "p_uv = uv;",
+                    vertexAssignments.join("\n"),
+                    "vec3 transformed = position;",
+                    "#ifdef USE_ALPHAHASH",
+                    "  vPosition = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z) + vec3(position.xy, 0.0);",
+                    "#endif",
+                ].join("\n"))
+                    .replace("#include <project_vertex>", `
+          vec2 p_bp = position.xy;
+          p_bp.x *= PARTICLE_SCALE_X;
+          p_bp.y *= PARTICLE_SCALE_Y;
+          float p_cosR = cos(PARTICLE_ROTATION);
+          float p_sinR = sin(PARTICLE_ROTATION);
+          p_bp = vec2(
+            p_bp.x * p_cosR - p_bp.y * p_sinR,
+            p_bp.x * p_sinR + p_bp.y * p_cosR
+          );
+          vec3 p_c = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z);
+          vec4 mvPosition = modelViewMatrix * vec4(p_c, 1.0);
+          mvPosition.xy += p_bp;
+          gl_Position = projectionMatrix * mvPosition;
+          `);
+        const fragmentPreamble = [
+            PARTICLE_DEFINES,
+            "varying vec2 p_uv;",
+            varyingDeclarations.join("\n"),
+            colorNodes.flatMap((n) => n.uniformDeclarations).join("\n"),
+            colorNodes.map((n) => n.helperFunctions).join("\n"),
+        ].join("\n");
+        for (const node of colorNodes) {
+            Object.assign(shader.uniforms, node.uniforms);
+        }
+        let fragmentShader = shader.fragmentShader;
+        if (colorNodes.length > 0) {
+            const combinedExpression = colorNodes.map((n) => n.colorExpression).join(" * ");
+            const discardLine = useAlphaHashing ? "" : "if (diffuseColor.a < 0.0035) discard;";
+            fragmentShader = fragmentShader.replace("#include <map_fragment>", `diffuseColor = ${combinedExpression}; ${discardLine}`);
+        }
+        shader.fragmentShader = fragmentPreamble + "\n" + fragmentShader;
+    };
+    material.customProgramCacheKey = () => `fx-unlit-${colorNodes.map((n) => n.cacheKey).join("-") || "none"}`;
+    return material;
+}
+
+export { buildFXUnlitMaterial };

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

@@ -0,0 +1,11 @@
+import { type Blending } from "three";
+import { FXMaterial, type FXMaterialOptions } from "../FXMaterial";
+export interface FXUnlitMaterialOptions extends FXMaterialOptions {
+    blending: Blending;
+    useAlphaHashing: boolean;
+}
+export declare class FXUnlitMaterial extends FXMaterial {
+    private readonly blending;
+    private readonly useAlphaHashing;
+    constructor(options?: Partial<FXUnlitMaterialOptions>);
+}

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.js

@@ -0,0 +1,17 @@
+import { NormalBlending } from 'three';
+import { FXMaterial } from '../FXMaterial.js';
+import { buildFXUnlitMaterial } from './FXUnlitMaterial.Internal.js';
+
+class FXUnlitMaterial extends FXMaterial {
+    constructor(options = {}) {
+        super(options);
+        this._private_blending = options.blending ?? NormalBlending;
+        this._private_useAlphaHashing = options.useAlphaHashing ?? false;
+    }
+    /** @internal */
+    buildThreeMaterial(varyings) {
+        return buildFXUnlitMaterial(varyings, this._private_blending, this._private_useAlphaHashing, this.colorNodes);
+    }
+}
+
+export { FXUnlitMaterial };

package/dist/materials/color-nodes/FXAnimatedTextureNode.d.ts

@@ -0,0 +1,10 @@
+import type { Texture } from "three";
+import { FXColorNode } from "./FXColorNode";
+export interface FXAnimatedTextureNodeOptions {
+    texture: Texture;
+    cols: number;
+    rows: number;
+}
+export declare class FXAnimatedTextureNode extends FXColorNode {
+    constructor({ texture, cols, rows }: FXAnimatedTextureNodeOptions);
+}

package/dist/materials/color-nodes/FXAnimatedTextureNode.js

@@ -0,0 +1,41 @@
+import { FXColorNode } from './FXColorNode.js';
+
+class FXAnimatedTextureNode extends FXColorNode {
+    constructor({ texture, cols, rows }) {
+        super();
+        /** @internal */
+        this.cacheKey = "animated";
+        /** @internal */
+        this.uniformDeclarations = [
+            "uniform sampler2D u_AnimatedTexture;",
+            "uniform float u_AnimatedTextureCols;",
+            "uniform float u_AnimatedTextureRows;",
+        ];
+        /** @internal */
+        this.helperFunctions = `
+    vec4 _fx_sampleAnimated(sampler2D tex, vec2 uv, float cols, float rows) {
+      float totalFrames = cols * rows;
+      float frame = floor(PARTICLE_AGE / PARTICLE_LIFETIME * totalFrames);
+      frame = clamp(frame, 0.0, totalFrames - 1.0);
+      float col = mod(frame, cols);
+      float row = floor(frame / cols);
+      vec2 frameUV = vec2((col + uv.x) / cols, 1.0 - (row + 1.0 - uv.y) / rows);
+      return texture2D(tex, frameUV);
+    }
+  `;
+        /** @internal */
+        this.colorExpression = "_fx_sampleAnimated(u_AnimatedTexture, p_uv, u_AnimatedTextureCols, u_AnimatedTextureRows)";
+        /** @internal */
+        this.affectsDepth = true;
+        this.uniforms = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            u_AnimatedTexture: { value: texture },
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            u_AnimatedTextureCols: { value: cols },
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            u_AnimatedTextureRows: { value: rows },
+        };
+    }
+}
+
+export { FXAnimatedTextureNode };

package/dist/materials/color-nodes/FXColorNode.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class FXColorNode {
+    destroy?(): void;
+}

package/dist/materials/color-nodes/FXColorNode.js

@@ -0,0 +1,8 @@
+class FXColorNode {
+    constructor() {
+        /** @internal */
+        this.affectsDepth = false;
+    }
+}
+
+export { FXColorNode };

package/dist/materials/color-nodes/FXColorOverLifeNode.d.ts

@@ -0,0 +1,7 @@
+import type { FXColor } from "../../miscellaneous/color/FXColor";
+import { FXColorNode } from "./FXColorNode";
+export declare class FXColorOverLifeNode extends FXColorNode {
+    private readonly gradientTexture;
+    constructor(colors: FXColor[]);
+    destroy(): void;
+}

package/dist/materials/color-nodes/FXColorOverLifeNode.js

@@ -0,0 +1,38 @@
+import { buildGradientTexture } from '../../miscellaneous/miscellaneous.js';
+import { checkSRGBSupport } from '../../miscellaneous/webglCapabilities.js';
+import { FXColorNode } from './FXColorNode.js';
+
+class FXColorOverLifeNode extends FXColorNode {
+    constructor(colors) {
+        if (colors.length === 0) {
+            throw new Error("FXColorOverLifeNode: colors array cannot be empty");
+        }
+        super();
+        /** @internal */
+        this.affectsDepth = true;
+        /** @internal */
+        this.cacheKey = "color-over-life";
+        /** @internal */
+        this.uniformDeclarations = ["uniform sampler2D u_ColorOverLife;"];
+        /** @internal */
+        this.colorExpression = "_fx_sampleColorOverLife(u_ColorOverLife)";
+        this._private_gradientTexture = buildGradientTexture(colors);
+        this.uniforms = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            u_ColorOverLife: { value: this._private_gradientTexture },
+        };
+        this.helperFunctions = `
+      vec4 _fx_sampleColorOverLife(sampler2D tex) {
+        float t = clamp(PARTICLE_AGE / PARTICLE_LIFETIME, 0.0, 1.0);
+        vec4 c = texture2D(tex, vec2(t, 0.5));
+        ${checkSRGBSupport() ? "" : "c = vec4(pow(c.rgb, vec3(2.2)), c.a);"}
+        return c;
+      }
+    `;
+    }
+    destroy() {
+        this._private_gradientTexture.dispose();
+    }
+}
+
+export { FXColorOverLifeNode };

package/dist/materials/color-nodes/FXStaticTextureNode.d.ts

@@ -0,0 +1,5 @@
+import type { Texture } from "three";
+import { FXColorNode } from "./FXColorNode";
+export declare class FXStaticTextureNode extends FXColorNode {
+    constructor(texture: Texture);
+}

package/dist/materials/color-nodes/FXStaticTextureNode.js

@@ -0,0 +1,23 @@
+import { FXColorNode } from './FXColorNode.js';
+
+class FXStaticTextureNode extends FXColorNode {
+    constructor(texture) {
+        super();
+        /** @internal */
+        this.cacheKey = "static";
+        /** @internal */
+        this.uniformDeclarations = ["uniform sampler2D u_StaticTexture;"];
+        /** @internal */
+        this.helperFunctions = "";
+        /** @internal */
+        this.colorExpression = "texture2D(u_StaticTexture, p_uv)";
+        /** @internal */
+        this.affectsDepth = true;
+        this.uniforms = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            u_StaticTexture: { value: texture },
+        };
+    }
+}
+
+export { FXStaticTextureNode };

package/dist/materials/miscellaneous.d.ts

@@ -0,0 +1 @@
+export declare const PARTICLE_DEFINES = "\n  #define PARTICLE_POSITION_X p_builtin[0][0]\n  #define PARTICLE_POSITION_Y p_builtin[0][1]\n  #define PARTICLE_POSITION_Z p_builtin[0][2]\n\n  #define PARTICLE_VELOCITY_X p_builtin[0][3]\n  #define PARTICLE_VELOCITY_Y p_builtin[1][0]\n  #define PARTICLE_VELOCITY_Z p_builtin[1][1]\n\n  #define PARTICLE_SCALE_X p_builtin[1][2]\n  #define PARTICLE_SCALE_Y p_builtin[1][3]\n  #define PARTICLE_SCALE_Z p_builtin[2][0]\n\n  #define PARTICLE_ROTATION p_builtin[2][1]\n  #define PARTICLE_TORQUE p_builtin[2][2]\n\n  #define PARTICLE_LIFETIME p_builtin[2][3]\n  #define PARTICLE_AGE p_builtin[3][0]\n\n  #define PARTICLE_RANDOM_A p_builtin[3][1]\n  #define PARTICLE_RANDOM_B p_builtin[3][2]\n  #define PARTICLE_RANDOM_C p_builtin[3][3]\n";

package/dist/materials/miscellaneous.js

@@ -0,0 +1,25 @@
+const PARTICLE_DEFINES = `
+  #define PARTICLE_POSITION_X p_builtin[0][0]
+  #define PARTICLE_POSITION_Y p_builtin[0][1]
+  #define PARTICLE_POSITION_Z p_builtin[0][2]
+
+  #define PARTICLE_VELOCITY_X p_builtin[0][3]
+  #define PARTICLE_VELOCITY_Y p_builtin[1][0]
+  #define PARTICLE_VELOCITY_Z p_builtin[1][1]
+
+  #define PARTICLE_SCALE_X p_builtin[1][2]
+  #define PARTICLE_SCALE_Y p_builtin[1][3]
+  #define PARTICLE_SCALE_Z p_builtin[2][0]
+
+  #define PARTICLE_ROTATION p_builtin[2][1]
+  #define PARTICLE_TORQUE p_builtin[2][2]
+
+  #define PARTICLE_LIFETIME p_builtin[2][3]
+  #define PARTICLE_AGE p_builtin[3][0]
+
+  #define PARTICLE_RANDOM_A p_builtin[3][1]
+  #define PARTICLE_RANDOM_B p_builtin[3][2]
+  #define PARTICLE_RANDOM_C p_builtin[3][3]
+`;
+
+export { PARTICLE_DEFINES };

package/dist/{color → miscellaneous/color}/FXColor.js

@@ -1,6 +1,6 @@
 import { MathUtils, Color, Vector4 } from 'three';
-import { assertValidNumber } from '../miscellaneous/asserts.js';
-import { srgbToLinear, linearToSRGB } from '../miscellaneous/math.js';
+import { assertValidNumber } from '../asserts.js';
+import { srgbToLinear, linearToSRGB } from '../math.js';
 import { COLORS } from './FXColor.Internal.js';
 
 /** RGBA color with RGB, HSL, hex, and named color support */

package/dist/miscellaneous/miscellaneous.d.ts

@@ -1,8 +1,8 @@
 import type { Vector3Tuple } from "three";
 import { DataTexture } from "three";
-import type { FXColor } from "../color/FXColor";
 import type { Vector3Like } from "../miscellaneous/math";
 import type { FXTextureConfig } from "../miscellaneous/texture/FXTextureView.Internal";
+import type { FXColor } from "./color/FXColor";
 export interface FXRange {
     min: number;
     max: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sparcoon",
-  "version": "0.0.8",
+  "version": "0.2.0",
   "description": "",
   "keywords": [
     "particles",

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

@@ -1,6 +0,0 @@
-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

@@ -1,234 +0,0 @@
-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/renderingModules/FXRenderingAnimatedTexture.d.ts

@@ -1,5 +0,0 @@
-import { type Texture } from "three";
-import { FXRenderingModule } from "./FXRenderingModule";
-export declare class FXRenderingAnimatedTexture extends FXRenderingModule {
-    constructor(texture: Texture, horizontalCount: number, verticalCount: number);
-}

package/dist/renderingModules/FXRenderingAnimatedTexture.js

@@ -1,14 +0,0 @@
-import { Vector2 } from 'three';
-import source from '../shaders/FXRenderingAnimatedTexture.glsl.js';
-import { FXRenderingModule } from './FXRenderingModule.js';
-
-class FXRenderingAnimatedTexture extends FXRenderingModule {
-    constructor(texture, horizontalCount, verticalCount) {
-        super();
-        /** @internal */
-        this.source = source;
-        this.requiredUniforms = { texture, count: new Vector2(horizontalCount, verticalCount) };
-    }
-}
-
-export { FXRenderingAnimatedTexture };

package/dist/renderingModules/FXRenderingColorOverLife.d.ts

@@ -1,14 +0,0 @@
-import type { FXColor } from "../color/FXColor";
-import { FXRenderingModule } from "./FXRenderingModule";
-/**
- * Colors particles based on lifetime progression.
- *
- * Interpolates through color gradient as particles age from birth to death.
- */
-export declare class FXRenderingColorOverLife extends FXRenderingModule {
-    /**
-     * @param colors - Color gradient stops from birth to death
-     */
-    constructor(colors: FXColor[]);
-    destroy(): void;
-}

package/dist/renderingModules/FXRenderingColorOverLife.js

@@ -1,32 +0,0 @@
-import { buildGradientTexture } from '../miscellaneous/miscellaneous.js';
-import source from '../shaders/FXRenderingColorOverLife.glsl.js';
-import { FXRenderingModule } from './FXRenderingModule.js';
-
-/**
- * Colors particles based on lifetime progression.
- *
- * Interpolates through color gradient as particles age from birth to death.
- */
-class FXRenderingColorOverLife extends FXRenderingModule {
-    /**
-     * @param colors - Color gradient stops from birth to death
-     */
-    constructor(colors) {
-        super();
-        /** @internal */
-        this.requiredProperties = {
-            builtin: "Matrix4",
-        };
-        /** @internal */
-        this.source = source;
-        if (colors.length === 0) {
-            throw new Error("FXRenderingColorOverLife: colors array cannot be empty");
-        }
-        this.requiredUniforms = { colorOverLifeTexture: buildGradientTexture(colors) };
-    }
-    destroy() {
-        this.requiredUniforms.colorOverLifeTexture.dispose();
-    }
-}
-
-export { FXRenderingColorOverLife };

package/dist/renderingModules/FXRenderingColorOverVelocity.d.ts

@@ -1,15 +0,0 @@
-import type { FXColor } from "../color/FXColor";
-import { FXRenderingModule } from "./FXRenderingModule";
-/**
- * Colors particles based on velocity magnitude.
- *
- * Maps velocity from 0 to maxVelocity across the color gradient.
- */
-export declare class FXRenderingColorOverVelocity extends FXRenderingModule {
-    /**
-     * @param colors - Color gradient from slow to fast
-     * @param maxVelocity - Velocity mapped to final color
-     */
-    constructor(colors: FXColor[], maxVelocity: number);
-    destroy(): void;
-}