sparcoon 0.7.1 → 0.7.3

package/dist/emitter/FXEmitter.js

@@ -53,6 +53,7 @@ class FXEmitter extends Object3D {
         };
         collectProperties(collectedProperties, _private_spawnSequence, "FXEmitter.constructor.spawnSequence");
         collectProperties(collectedProperties, _private_behaviorSequence, "FXEmitter.constructor.behaviorSequence");
+        material.prepare();
         const threeMaterial = material.buildThreeMaterial(collectedProperties);
         this._private_mesh = new FXInstancedParticle(collectedProperties, options.expectedCapacity ?? EMITTER_DEFAULT_EXPECTED_CAPACITY, options.capacityStep ?? EMITTER_DEFAULT_CAPACITY_STEP, threeMaterial);
         if (options.castShadow ?? EMITTER_DEFAULT_CAST_SHADOW) {

package/dist/instancedParticle/FXInstancedParticle.js

@@ -1,10 +1,15 @@
-import { Mesh, InstancedBufferAttribute, StreamDrawUsage } from 'three';
+import { Mesh, InstancedBufferGeometry, BufferAttribute, Float32BufferAttribute, InstancedBufferAttribute, StreamDrawUsage } from 'three';
 import { BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_LIFETIME, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z } from '../miscellaneous/miscellaneous.js';
-import { INSTANCED_PARTICLE_GEOMETRY } from './FXInstancedParticle.Internal.js';
 
 class FXInstancedParticle extends Mesh {
     constructor(varyings, expectedCapacity, _private_capacityStep, material) {
-        const instancedGeometry = INSTANCED_PARTICLE_GEOMETRY.clone();
+        const instancedGeometry = new InstancedBufferGeometry();
+        const indices = new Uint16Array([0, 2, 1, 2, 3, 1]);
+        instancedGeometry.setIndex(new BufferAttribute(indices, 1));
+        const positions = new Float32Array([-0.5, 0.5, 0, 0.5, 0.5, 0, -0.5, -0.5, 0, 0.5, -0.5, 0]);
+        instancedGeometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
+        const uvs = new Float32Array([0, 1, 1, 1, 0, 0, 1, 0]);
+        instancedGeometry.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
         super(instancedGeometry, material);
         this._private_capacityStep = _private_capacityStep;
         this.propertyBuffers = {};

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

@@ -4,7 +4,7 @@ import type { FXNodeBlending } from "../../nodes/blending/FXNodeBlending";
 import { FXNodeColor } from "../../nodes/color/FXNodeColor";
 import type { FXNodeNormal } from "../../nodes/normal/FXNodeNormal";
 import { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
-import type { FXBlending } from "../FXMaterial/FXMaterial";
+import { FXBlending } from "../FXMaterial/FXMaterial";
 export interface FXScatterUniforms {
     u_ScatterTint: {
         value: Color;

package/dist/materials/FXDiffuseMaterial/FXDiffuseMaterial.Internal.js

@@ -4,6 +4,7 @@ import { FXNodeColor } from '../../nodes/color/FXNodeColor.js';
 import { CURRENT_EXPRESSION_VALUE_PLACEHOLDER } from '../../nodes/FXNode.js';
 import { FXNodeTexture } from '../../nodes/texture/FXNodeTexture.js';
 import { buildAlbedoAndBlendingCode } from '../FXMaterial/FXBlending.Internal.js';
+import { FXBlending } from '../FXMaterial/FXMaterial.js';
 
 /**
  * Wraps every `getShadow(...)` call in the shader source with
@@ -257,18 +258,17 @@ function buildFXDiffuseMaterial(varyings, blending, useAlphaHashing, alphaTest,
         fragmentShader = fragmentShader.replace("#include <premultiplied_alpha_fragment>", albedoCode.premultChunk);
         shader.fragmentShader = fragmentPreamble + "\n" + fragmentShader;
     };
-    // const scatterKey = useScatter ? `scatter(${scatterUniforms.u_ScatterPower.value})` : "no-scatter";
-    // const shadowKey = useShadowSensitivity ? "shadow-sens" : "no-shadow-sens";
-    // material.customProgramCacheKey = (): string =>
-    //   [
-    //     "fx",
-    //     albedoNodes.map((node) => node.cacheKey).join("-") || "none",
-    //     normalNodes.map((node) => node.cacheKey).join("-") || "none",
-    //     emissionNodes.map((node) => node.cacheKey).join("-") || "none",
-    //     FXBlending[blending],
-    //     scatterKey,
-    //     shadowKey,
-    //   ].join("_");
+    const scatterKey = useScatter ? `scatter(${scatterUniforms.u_ScatterPower.value})` : "no-scatter";
+    const shadowKey = useShadowSensitivity ? "shadow-sens" : "no-shadow-sens";
+    material.customProgramCacheKey = () => [
+        "fx",
+        albedoNodes.map((node) => node.cacheKey).join("-") || "none",
+        normalNodes.map((node) => node.cacheKey).join("-") || "none",
+        emissionNodes.map((node) => node.cacheKey).join("-") || "none",
+        FXBlending[blending],
+        scatterKey,
+        shadowKey,
+    ].join("_");
     return material;
 }
 

package/dist/materials/FXDiffuseMaterial/FXDiffuseMaterial.d.ts

@@ -71,4 +71,5 @@ export declare class FXDiffuseMaterial extends FXMaterial {
     constructor(options?: Partial<FXDiffuseMaterialOptions>);
     /** Releases resources held by all albedo, normal, and emission nodes */
     destroy(): void;
+    prepare(): void;
 }

package/dist/materials/FXDiffuseMaterial/FXDiffuseMaterial.js

@@ -43,6 +43,21 @@ class FXDiffuseMaterial extends FXMaterial {
     buildThreeMaterial(varyings) {
         return buildFXDiffuseMaterial(varyings, this.blending, this.useAlphaHashing, this.alphaTest, this.albedoNodes, this._private_normalNodes, this._private_emissionNodes, this._private_scatterUniforms, this._private_shadowSensitivity);
     }
+    prepare() {
+        let i = 0;
+        for (const node of this.albedoNodes) {
+            node.prepare?.(i);
+            i += 1;
+        }
+        for (const node of this._private_normalNodes) {
+            node.prepare?.(i);
+            i += 1;
+        }
+        for (const node of this._private_emissionNodes) {
+            node.prepare?.(i);
+            i += 1;
+        }
+    }
 }
 
 export { FXDiffuseMaterial };

package/dist/materials/FXMaterial/FXDepthMaterial.Internal.js

@@ -137,8 +137,7 @@ function buildDepthMaterial(albedoNodes, depthAlphaTest, useDepthAlphaHash, useS
         }
         shader.fragmentShader = fragmentPreamble + "\n" + fragmentShader;
     };
-    // material.customProgramCacheKey = (): string =>
-    //   `fx-depth-${useDepthAlphaHash ? "alphaHash" : "alphaTest"}-${useSphericalDepth ? "spherical" : "flat"}-${depthNodes.map((node) => node.cacheKey).join("-") || "none"}`;
+    material.customProgramCacheKey = () => `fx-depth-${useDepthAlphaHash ? "alphaHash" : "alphaTest"}-${useSphericalDepth ? "spherical" : "flat"}-${depthNodes.map((node) => node.cacheKey).join("-") || "none"}`;
     return material;
 }
 

package/dist/materials/FXMaterial/FXDistanceMaterial.Internal.js

@@ -168,8 +168,7 @@ function buildDistanceMaterial(albedoNodes, distanceAlphaTest, useDistanceAlphaH
         }
         shader.fragmentShader = fragmentPreamble + "\n" + fragmentShader;
     };
-    // material.customProgramCacheKey = (): string =>
-    //   `fx-distance-${useDistanceAlphaHash ? "alphaHash" : "alphaTest"}-${useSphericalDepth ? "spherical" : "flat"}-${distanceNodes.map((node) => node.cacheKey).join("-") || "none"}`;
+    material.customProgramCacheKey = () => `fx-distance-${useDistanceAlphaHash ? "alphaHash" : "alphaTest"}-${useSphericalDepth ? "spherical" : "flat"}-${distanceNodes.map((node) => node.cacheKey).join("-") || "none"}`;
     return material;
 }
 

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

@@ -3,5 +3,5 @@ import type { GLTypeInfo } from "../../instancedParticle/shared";
 import type { FXNodeBlending } from "../../nodes/blending/FXNodeBlending";
 import type { FXNodeColor } from "../../nodes/color/FXNodeColor";
 import type { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
-import type { FXBlending } from "../FXMaterial/FXMaterial";
+import { FXBlending } from "../FXMaterial/FXMaterial";
 export declare function buildFXUnlitMaterial(varyings: Record<string, GLTypeInfo>, blending: FXBlending, useAlphaHashing: boolean, alphaTest: number, albedoNodes: readonly (FXNodeColor | FXNodeTexture | FXNodeBlending)[]): MeshBasicMaterial;

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

@@ -1,6 +1,7 @@
 import { MeshBasicMaterial, DoubleSide, NormalBlending } from 'three';
 import { PARTICLE_DEFINES } from '../../miscellaneous/miscellaneous.js';
 import { buildAlbedoAndBlendingCode } from '../FXMaterial/FXBlending.Internal.js';
+import { FXBlending } from '../FXMaterial/FXMaterial.js';
 
 function buildFXUnlitMaterial(varyings, blending, useAlphaHashing, alphaTest, albedoNodes) {
     const attributeDeclarations = [];
@@ -91,10 +92,11 @@ function buildFXUnlitMaterial(varyings, blending, useAlphaHashing, alphaTest, al
         fragmentShader = fragmentShader.replace("#include <premultiplied_alpha_fragment>", albedoCode.premultChunk);
         shader.fragmentShader = fragmentPreamble + "\n" + fragmentShader;
     };
-    // material.customProgramCacheKey = (): string =>
-    //   ["fx-unlit", albedoNodes.map((node) => node.cacheKey).join("-") || "none", FXBlending[blending]].join(
-    //     "_",
-    //   );
+    material.customProgramCacheKey = () => [
+        "fx-unlit",
+        albedoNodes.map((node) => node.cacheKey).join("-") || "none",
+        FXBlending[blending],
+    ].join("_");
     return material;
 }
 

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

@@ -3,4 +3,5 @@ import { FXMaterial } from "../FXMaterial/FXMaterial";
  * Unlit particle material - renders particles without lighting or shadows
  */
 export declare class FXUnlitMaterial extends FXMaterial {
+    prepare(): void;
 }

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.js

@@ -9,6 +9,13 @@ class FXUnlitMaterial extends FXMaterial {
     buildThreeMaterial(varyings) {
         return buildFXUnlitMaterial(varyings, this.blending, this.useAlphaHashing, this.alphaTest, this.albedoNodes);
     }
+    prepare() {
+        let i = 0;
+        for (const node of this.albedoNodes) {
+            node.prepare?.(i);
+            i += 1;
+        }
+    }
 }
 
 export { FXUnlitMaterial };

package/dist/miscellaneous/miscellaneous.d.ts

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

package/dist/miscellaneous/miscellaneous.js

@@ -1,9 +1,5 @@
 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 };
@@ -86,4 +82,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, getNextInstanceId, 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, resolveAspect, resolveFXRangeConfig, resolveFXVector3Config };

package/dist/nodes/blending/FXNodeLightnessBlendingMask.d.ts

@@ -1,7 +1,10 @@
 import { FXNodeBlending } from "./FXNodeBlending";
 export declare class FXNodeLightnessBlendingMask extends FXNodeBlending {
-    private readonly uniformEdge0;
-    private readonly uniformEdge1;
+    private uniformNameEdge0;
+    private uniformNameEdge1;
+    private edge0Internal;
+    private edge1Internal;
+    private isPrepared;
     /**
      * @param edge0 - brightness threshold where mask starts (below this: NormalBlending). Defaults to `0.3`
      * @param edge1 - brightness threshold where mask is fully active (above this: full FXBlending effect). Defaults to `0.7`

package/dist/nodes/blending/FXNodeLightnessBlendingMask.js

@@ -1,4 +1,4 @@
-import { getNextInstanceId } from '../../miscellaneous/miscellaneous.js';
+import { assertValidNonNegativeNumber } from '../../miscellaneous/asserts.js';
 import { CURRENT_EXPRESSION_VALUE_PLACEHOLDER, BLENDING_EXPRESSION_CURRENT_COLOR_PLACEHOLDER } from '../FXNode.js';
 import { FXNodeBlending } from './FXNodeBlending.js';
 
@@ -11,38 +11,54 @@ class FXNodeLightnessBlendingMask extends FXNodeBlending {
         super();
         /** @internal */
         this.cacheKey = "lightness-blending-mask";
-        const id = getNextInstanceId();
-        this._private_uniformEdge0 = `u_LightnessBlendingMaskEdge0_${id}`;
-        this._private_uniformEdge1 = `u_LightnessBlendingMaskEdge1_${id}`;
-        this.uniformDeclarations = [
-            `uniform float ${this._private_uniformEdge0};`,
-            `uniform float ${this._private_uniformEdge1};`,
-        ];
-        this.uniforms = {
-            [this._private_uniformEdge0]: { value: edge0 },
-            [this._private_uniformEdge1]: { value: edge1 },
-        };
-        this.helperFunctions = `
-      float fxLightnessBlendingMask(vec4 color, float edge0, float edge1) {
-        float brightness = dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));
-        return smoothstep(edge0, edge1, brightness);
-      }
-    `;
-        this.blendingExpression = `${CURRENT_EXPRESSION_VALUE_PLACEHOLDER} * fxLightnessBlendingMask(${BLENDING_EXPRESSION_CURRENT_COLOR_PLACEHOLDER}, ${this._private_uniformEdge0}, ${this._private_uniformEdge1})`;
+        this._private_isPrepared = false;
+        assertValidNonNegativeNumber(edge0, "FXNodeLightnessBlendingMask.constructor.edge0");
+        assertValidNonNegativeNumber(edge1, "FXNodeLightnessBlendingMask.constructor.edge1");
+        this._private_edge0Internal = edge0;
+        this._private_edge1Internal = edge1;
     }
     /** Brightness threshold where mask starts (below this: NormalBlending) */
     get edge0() {
-        return this.uniforms[this._private_uniformEdge0].value;
+        return this._private_edge0Internal;
     }
     /** Brightness threshold where mask is fully active (above this: full FXBlending effect) */
     get edge1() {
-        return this.uniforms[this._private_uniformEdge1].value;
+        return this._private_edge1Internal;
     }
     set edge0(value) {
-        this.uniforms[this._private_uniformEdge0].value = value;
+        assertValidNonNegativeNumber(value, "FXNodeLightnessBlendingMask.edge0");
+        this._private_edge0Internal = value;
+        if (this._private_isPrepared) {
+            this.uniforms[this._private_uniformNameEdge0].value = value;
+        }
     }
     set edge1(value) {
-        this.uniforms[this._private_uniformEdge1].value = value;
+        assertValidNonNegativeNumber(value, "FXNodeLightnessBlendingMask.edge1");
+        this._private_edge1Internal = value;
+        if (this._private_isPrepared) {
+            this.uniforms[this._private_uniformNameEdge1].value = value;
+        }
+    }
+    /** @internal */
+    prepare(index) {
+        this._private_uniformNameEdge0 = `u_LightnessBlendingMaskEdge0_${index}`;
+        this._private_uniformNameEdge1 = `u_LightnessBlendingMaskEdge1_${index}`;
+        this.uniformDeclarations = [
+            `uniform float ${this._private_uniformNameEdge0};`,
+            `uniform float ${this._private_uniformNameEdge1};`,
+        ];
+        this.uniforms = {
+            [this._private_uniformNameEdge0]: { value: this._private_edge0Internal },
+            [this._private_uniformNameEdge1]: { value: this._private_edge1Internal },
+        };
+        this.helperFunctions = `
+      float fxLightnessBlendingMask(vec4 color, float edge0, float edge1) {
+        float brightness = dot(color.rgb, vec3(0.2126, 0.7152, 0.0722));
+        return smoothstep(edge0, edge1, brightness);
+      }
+    `;
+        this.blendingExpression = `${CURRENT_EXPRESSION_VALUE_PLACEHOLDER} * fxLightnessBlendingMask(${BLENDING_EXPRESSION_CURRENT_COLOR_PLACEHOLDER}, ${this._private_uniformNameEdge0}, ${this._private_uniformNameEdge1})`;
+        this._private_isPrepared = true;
     }
 }
 

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

@@ -6,8 +6,10 @@ 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 uniformName;
+    private gradientTexture;
     private curveInternal;
+    private isPrepared;
     /**
      * @param curve - Color gradient defining the animation over the particle lifetime
      */

package/dist/nodes/color/FXNodeColorOverLife.js

@@ -1,5 +1,5 @@
 import { FXCurve1D } from '../../miscellaneous/curve/FXCurve1D.js';
-import { buildGradientTexture, getNextInstanceId } from '../../miscellaneous/miscellaneous.js';
+import { buildGradientTexture } from '../../miscellaneous/miscellaneous.js';
 import { checkSRGBSupport } from '../../miscellaneous/webglCapabilities.js';
 import { CURRENT_EXPRESSION_VALUE_PLACEHOLDER } from '../FXNode.js';
 import { FXNodeColor } from './FXNodeColor.js';
@@ -17,10 +17,29 @@ class FXNodeColorOverLife extends FXNodeColor {
         this.affectsDepth = true;
         /** @internal */
         this.cacheKey = "color-over-life";
-        const id = getNextInstanceId();
-        this._private_uniformName = `u_ColorOverLife_${id}`;
+        this._private_isPrepared = false;
         this._private_curveInternal = new FXCurve1D(curve);
         this._private_gradientTexture = buildGradientTexture(this._private_curveInternal);
+    }
+    /** Current color gradient curve */
+    get curve() {
+        return this._private_curveInternal;
+    }
+    set curve(value) {
+        this._private_curveInternal = new FXCurve1D(value);
+        this._private_gradientTexture.dispose();
+        this._private_gradientTexture = buildGradientTexture(this._private_curveInternal);
+        if (this._private_isPrepared) {
+            this.uniforms[this._private_uniformName].value = this._private_gradientTexture;
+        }
+    }
+    /** Releases the backing gradient texture */
+    destroy() {
+        this._private_gradientTexture.dispose();
+    }
+    /** @internal */
+    prepare(index) {
+        this._private_uniformName = `u_ColorOverLife_${index}`;
         this.uniformDeclarations = [`uniform sampler2D ${this._private_uniformName};`];
         this.uniforms = {
             [this._private_uniformName]: { value: this._private_gradientTexture },
@@ -38,20 +57,7 @@ class FXNodeColorOverLife extends FXNodeColor {
       }
     `;
         this.colorExpression = `${CURRENT_EXPRESSION_VALUE_PLACEHOLDER} * fxSampleColorOverLife(${this._private_uniformName})`;
-    }
-    /** Current color gradient curve */
-    get curve() {
-        return this._private_curveInternal;
-    }
-    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();
+        this._private_isPrepared = true;
     }
 }
 

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

@@ -7,7 +7,9 @@ import { FXNodeColor } from "./FXNodeColor";
  * (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;
+    private uniformName;
+    private innerRadiusInternal;
+    private isPrepared;
     /**
      * @param innerRadius - UV radius where the fade begins; must be non-negative. Defaults to `0.5`
      */
@@ -15,4 +17,5 @@ export declare class FXNodeSphericalClip extends FXNodeColor {
     /** UV radius of the fully opaque inner area */
     get innerRadius(): number;
     set innerRadius(value: number);
+    prepare(index: number): void;
 }

package/dist/nodes/color/FXNodeSphericalClip.js

@@ -1,5 +1,4 @@
 import { assertValidNonNegativeNumber } from '../../miscellaneous/asserts.js';
-import { getNextInstanceId } from '../../miscellaneous/miscellaneous.js';
 import { CURRENT_EXPRESSION_VALUE_PLACEHOLDER } from '../FXNode.js';
 import { FXNodeColor } from './FXNodeColor.js';
 
@@ -20,12 +19,26 @@ class FXNodeSphericalClip extends FXNodeColor {
         this.affectsDepth = true;
         /** @internal */
         this.cacheKey = "spherical-clip";
+        this._private_isPrepared = false;
         assertValidNonNegativeNumber(innerRadius, "FXNodeSphericalClip.constructor.innerRadius");
-        const id = getNextInstanceId();
-        this._private_uniformInnerRadius = `u_SphericalClipInnerRadius_${id}`;
-        this.uniformDeclarations = [`uniform float ${this._private_uniformInnerRadius};`];
+        this._private_innerRadiusInternal = innerRadius;
+    }
+    /** UV radius of the fully opaque inner area */
+    get innerRadius() {
+        return this._private_innerRadiusInternal;
+    }
+    set innerRadius(value) {
+        assertValidNonNegativeNumber(value, "FXNodeSphericalClip.innerRadius");
+        this._private_innerRadiusInternal = value;
+        if (this._private_isPrepared) {
+            this.uniforms[this._private_uniformName].value = value;
+        }
+    }
+    prepare(index) {
+        this._private_uniformName = `u_SphericalClipInnerRadius_${index}`;
+        this.uniformDeclarations = [`uniform float ${this._private_uniformName};`];
         this.uniforms = {
-            [this._private_uniformInnerRadius]: { value: innerRadius },
+            [this._private_uniformName]: { value: this._private_innerRadiusInternal },
         };
         this.helperFunctions = `
       vec4 fxApplySphericalClip(float innerRadius) {
@@ -33,15 +46,8 @@ class FXNodeSphericalClip extends FXNodeColor {
         return vec4(1.0, 1.0, 1.0, 1.0 - smoothstep(innerRadius, 0.5, distanceToCenter));
       }
     `;
-        this.colorExpression = `${CURRENT_EXPRESSION_VALUE_PLACEHOLDER} * 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;
+        this.colorExpression = `${CURRENT_EXPRESSION_VALUE_PLACEHOLDER} * fxApplySphericalClip(${this._private_uniformName})`;
+        this._private_isPrepared = true;
     }
 }
 

package/dist/nodes/normal/FXNodeFlatNormal.js

@@ -1,4 +1,3 @@
-import { CURRENT_EXPRESSION_VALUE_PLACEHOLDER } from '../FXNode.js';
 import { FXNodeNormal } from './FXNodeNormal.js';
 
 /**
@@ -10,7 +9,7 @@ class FXNodeFlatNormal extends FXNodeNormal {
         /** @internal */
         this.cacheKey = "flat-normal";
         /** @internal */
-        this.normalExpression = `${CURRENT_EXPRESSION_VALUE_PLACEHOLDER} * vec3(0.0, 0.0, 1.0)`;
+        this.normalExpression = `vec3(0.0, 0.0, 1.0)`;
     }
 }
 

package/dist/nodes/normal/FXNodeSphericalNormal.js

@@ -1,4 +1,3 @@
-import { CURRENT_EXPRESSION_VALUE_PLACEHOLDER } from '../FXNode.js';
 import { FXNodeNormal } from './FXNodeNormal.js';
 
 /**
@@ -17,7 +16,7 @@ class FXNodeSphericalNormal extends FXNodeNormal {
     }
   `;
         /** @internal */
-        this.normalExpression = `${CURRENT_EXPRESSION_VALUE_PLACEHOLDER} * fxComputeSphericalNormal(p_uv)`;
+        this.normalExpression = `fxComputeSphericalNormal(p_uv)`;
     }
 }
 

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

@@ -26,11 +26,15 @@ export interface FXNodeAnimatedTextureOptions {
  * 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 uniformTexture;
+    private uniformUVTransform;
+    private uniformColumns;
+    private uniformRows;
     private readonly textureInternal;
+    private readonly isInterpolate;
+    private columnsInternal;
+    private rowsInternal;
+    private isPrepared;
     /**
      * @param options - Sprite sheet configuration
      */
@@ -44,4 +48,5 @@ export declare class FXNodeAnimatedTexture extends FXNodeTexture {
     set texture(config: FXTextureConfig);
     set columns(value: number);
     set rows(value: number);
+    prepare(index: number): void;
 }

package/dist/nodes/texture/FXNodeAnimatedTexture.js

@@ -1,5 +1,4 @@
 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 { CURRENT_EXPRESSION_VALUE_PLACEHOLDER } from '../FXNode.js';
@@ -20,21 +19,65 @@ class FXNodeAnimatedTexture extends FXNodeTexture {
         super();
         /** @internal */
         this.affectsDepth = true;
+        this._private_isPrepared = false;
         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_columnsInternal = columns;
+        this._private_rowsInternal = rows;
         this._private_textureInternal = new FXTextureView(texture);
+        this._private_isInterpolate = interpolate;
+    }
+    /** View describing the texture and its atlas region */
+    get texture() {
+        return this._private_textureInternal;
+    }
+    /** Number of frame columns in the sprite sheet */
+    get columns() {
+        return this._private_columnsInternal;
+    }
+    /** Number of frame rows in the sprite sheet */
+    get rows() {
+        return this._private_rowsInternal;
+    }
+    set texture(config) {
+        this._private_textureInternal.set(config);
+        if (this._private_isPrepared) {
+            if (this._private_textureInternal.textureDirty) {
+                this.uniforms[this._private_uniformTexture].value = this._private_textureInternal.texture;
+                this._private_textureInternal.setTextureDirtyFalse();
+            }
+            if (this._private_textureInternal.uvTransformDirty) {
+                this._private_textureInternal.calculateUVTransform(this.uniforms[this._private_uniformUVTransform].value);
+                this._private_textureInternal.setUVTransformDirtyFalse();
+            }
+        }
+    }
+    set columns(value) {
+        assertValidPositiveNumber(value, "FXNodeAnimatedTexture.columns");
+        this._private_columnsInternal = value;
+        if (this._private_isPrepared) {
+            this.uniforms[this._private_uniformColumns].value = value;
+        }
+    }
+    set rows(value) {
+        assertValidPositiveNumber(value, "FXNodeAnimatedTexture.rows");
+        this._private_rowsInternal = value;
+        if (this._private_isPrepared) {
+            this.uniforms[this._private_uniformRows].value = value;
+        }
+    }
+    prepare(index) {
+        this._private_uniformTexture = `u_AnimatedTexture_${index}`;
+        this._private_uniformUVTransform = `u_AnimatedTextureUVTransform_${index}`;
+        this._private_uniformColumns = `u_AnimatedTextureColumns_${index}`;
+        this._private_uniformRows = `u_AnimatedTextureRows_${index}`;
         const uvTransform = this._private_textureInternal.calculateUVTransform();
         this._private_textureInternal.setTextureDirtyFalse();
         this._private_textureInternal.setUVTransformDirtyFalse();
         const gammaCorrection = checkSRGBSupport()
             ? ""
             : "color = vec4(pow(color.rgb, vec3(2.2)), color.a);";
-        this.cacheKey = interpolate ? "animated-texture-interpolated" : "animated-texture";
+        this.cacheKey = this._private_isInterpolate ? "animated-texture-interpolated" : "animated-texture";
         this.uniformDeclarations = [
             `uniform sampler2D ${this._private_uniformTexture};`,
             `uniform mat3 ${this._private_uniformUVTransform};`,
@@ -44,11 +87,10 @@ class FXNodeAnimatedTexture extends FXNodeTexture {
         this.uniforms = {
             [this._private_uniformTexture]: { value: this._private_textureInternal.texture },
             [this._private_uniformUVTransform]: { value: uvTransform },
-            [this._private_uniformColumns]: { value: columns },
-            [this._private_uniformRows]: { value: rows },
+            [this._private_uniformColumns]: { value: this._private_columnsInternal },
+            [this._private_uniformRows]: { value: this._private_rowsInternal },
         };
-        this.helperFunctions = interpolate
-            ? `
+        this.helperFunctions = this._private_isInterpolate ? `
         vec2 fxFrameToUV(vec2 uv, float frame, float columns, float rows) {
           float column = mod(frame, columns);
           float row = floor(frame / columns);
@@ -102,37 +144,7 @@ class FXNodeAnimatedTexture extends FXNodeTexture {
         }
       `;
         this.colorExpression = `${CURRENT_EXPRESSION_VALUE_PLACEHOLDER} * fxSampleAnimatedTexture(${this._private_uniformTexture}, ${this._private_uniformUVTransform}, p_uv, ${this._private_uniformColumns}, ${this._private_uniformRows})`;
-    }
-    /** View describing the texture and its atlas region */
-    get texture() {
-        return this._private_textureInternal;
-    }
-    /** 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 texture(config) {
-        this._private_textureInternal.set(config);
-        if (this._private_textureInternal.textureDirty) {
-            this.uniforms[this._private_uniformTexture].value = this._private_textureInternal.texture;
-            this._private_textureInternal.setTextureDirtyFalse();
-        }
-        if (this._private_textureInternal.uvTransformDirty) {
-            this._private_textureInternal.calculateUVTransform(this.uniforms[this._private_uniformUVTransform].value);
-            this._private_textureInternal.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;
+        this._private_isPrepared = true;
     }
 }
 

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

@@ -5,9 +5,10 @@ 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 uniformTexture;
+    private uniformUVTransform;
     private readonly textureInternal;
+    private isPrepared;
     /**
      * @param config - Texture or atlas configuration applied to every particle
      */
@@ -15,4 +16,5 @@ export declare class FXNodeStaticTexture extends FXNodeTexture {
     /** View describing the texture and its atlas region */
     get texture(): FXTextureView;
     set texture(config: FXTextureConfig);
+    prepare(index: number): void;
 }

package/dist/nodes/texture/FXNodeStaticTexture.js

@@ -1,4 +1,3 @@
-import { getNextInstanceId } from '../../miscellaneous/miscellaneous.js';
 import { FXTextureView } from '../../miscellaneous/texture/FXTextureView.js';
 import { checkSRGBSupport } from '../../miscellaneous/webglCapabilities.js';
 import { CURRENT_EXPRESSION_VALUE_PLACEHOLDER } from '../FXNode.js';
@@ -17,10 +16,29 @@ class FXNodeStaticTexture extends FXNodeTexture {
         this.affectsDepth = true;
         /** @internal */
         this.cacheKey = "static-texture";
-        const id = getNextInstanceId();
-        this._private_uniformTexture = `u_StaticTexture_${id}`;
-        this._private_uniformUVTransform = `u_StaticTextureUVTransform_${id}`;
+        this._private_isPrepared = false;
         this._private_textureInternal = new FXTextureView(config);
+    }
+    /** View describing the texture and its atlas region */
+    get texture() {
+        return this._private_textureInternal;
+    }
+    set texture(config) {
+        this._private_textureInternal.set(config);
+        if (this._private_isPrepared) {
+            if (this._private_textureInternal.textureDirty) {
+                this.uniforms[this._private_uniformTexture].value = this._private_textureInternal.texture;
+                this._private_textureInternal.setTextureDirtyFalse();
+            }
+            if (this._private_textureInternal.uvTransformDirty) {
+                this._private_textureInternal.calculateUVTransform(this.uniforms[this._private_uniformUVTransform].value);
+                this._private_textureInternal.setUVTransformDirtyFalse();
+            }
+        }
+    }
+    prepare(index) {
+        this._private_uniformTexture = `u_StaticTexture_${index}`;
+        this._private_uniformUVTransform = `u_StaticTextureUVTransform_${index}`;
         const uvTransform = this._private_textureInternal.calculateUVTransform();
         this._private_textureInternal.setTextureDirtyFalse();
         this._private_textureInternal.setUVTransformDirtyFalse();
@@ -42,21 +60,7 @@ class FXNodeStaticTexture extends FXNodeTexture {
       }
     `;
         this.colorExpression = `${CURRENT_EXPRESSION_VALUE_PLACEHOLDER} * fxSampleStaticTexture(${this._private_uniformTexture}, ${this._private_uniformUVTransform}, p_uv)`;
-    }
-    /** View describing the texture and its atlas region */
-    get texture() {
-        return this._private_textureInternal;
-    }
-    set texture(config) {
-        this._private_textureInternal.set(config);
-        if (this._private_textureInternal.textureDirty) {
-            this.uniforms[this._private_uniformTexture].value = this._private_textureInternal.texture;
-            this._private_textureInternal.setTextureDirtyFalse();
-        }
-        if (this._private_textureInternal.uvTransformDirty) {
-            this._private_textureInternal.calculateUVTransform(this.uniforms[this._private_uniformUVTransform].value);
-            this._private_textureInternal.setUVTransformDirtyFalse();
-        }
+        this._private_isPrepared = true;
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sparcoon",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "Instanced-mesh particle system for Three.js.",
   "keywords": [
     "particles",

package/dist/instancedParticle/FXInstancedParticle.Internal.js

@@ -1,14 +0,0 @@
-import { InstancedBufferGeometry, BufferAttribute, Float32BufferAttribute } from 'three';
-
-const INSTANCED_PARTICLE_GEOMETRY = (() => {
-    const geometry = new InstancedBufferGeometry();
-    const indices = new Uint16Array([0, 2, 1, 2, 3, 1]);
-    geometry.setIndex(new BufferAttribute(indices, 1));
-    const positions = new Float32Array([-0.5, 0.5, 0, 0.5, 0.5, 0, -0.5, -0.5, 0, 0.5, -0.5, 0]);
-    geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
-    const uvs = new Float32Array([0, 1, 1, 1, 0, 0, 1, 0]);
-    geometry.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
-    return geometry;
-})();
-
-export { INSTANCED_PARTICLE_GEOMETRY };