sparcoon 0.3.0 → 0.3.1

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

@@ -84,17 +84,28 @@ function buildFXDiffuseMaterial(varyings, blending, useAlphaHashing, alphaTest,
           }
         `
             : "";
+        const seenCacheKeys = new Set();
+        const uniqueHelpers = (nodes) => nodes
+            .filter((n) => {
+            if (seenCacheKeys.has(n.cacheKey)) {
+                return false;
+            }
+            seenCacheKeys.add(n.cacheKey);
+            return true;
+        })
+            .map((n) => n.helperFunctions)
+            .join("\n");
         const fragmentPreamble = [
             PARTICLE_DEFINES,
             "varying vec2 p_uv;",
             varyingDeclarations.join("\n"),
             albedoNodes.flatMap((n) => n.uniformDeclarations).join("\n"),
-            albedoNodes.map((n) => n.helperFunctions).join("\n"),
+            uniqueHelpers(albedoNodes),
             normalNodes.flatMap((n) => n.uniformDeclarations).join("\n"),
-            normalNodes.map((n) => n.helperFunctions).join("\n"),
+            uniqueHelpers(normalNodes),
             blendReorientedNormalsHelper,
             emissionNodes.flatMap((n) => n.uniformDeclarations).join("\n"),
-            emissionNodes.map((n) => n.helperFunctions).join("\n"),
+            uniqueHelpers(emissionNodes),
         ].join("\n");
         for (const node of albedoNodes) {
             Object.assign(shader.uniforms, node.uniforms);

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

@@ -59,12 +59,23 @@ function buildFXUnlitMaterial(varyings, blending, useAlphaHashing, alphaTest, al
           mvPosition.xy += billboardOffset;
           gl_Position = projectionMatrix * mvPosition;
           `);
+        const seenCacheKeys = new Set();
+        const uniqueHelpers = (nodes) => nodes
+            .filter((n) => {
+            if (seenCacheKeys.has(n.cacheKey)) {
+                return false;
+            }
+            seenCacheKeys.add(n.cacheKey);
+            return true;
+        })
+            .map((n) => n.helperFunctions)
+            .join("\n");
         const fragmentPreamble = [
             PARTICLE_DEFINES,
             "varying vec2 p_uv;",
             varyingDeclarations.join("\n"),
             albedoNodes.flatMap((n) => n.uniformDeclarations).join("\n"),
-            albedoNodes.map((n) => n.helperFunctions).join("\n"),
+            uniqueHelpers(albedoNodes),
         ].join("\n");
         for (const node of albedoNodes) {
             Object.assign(shader.uniforms, node.uniforms);

package/dist/nodes/color/FXColorOverLifeNode.js

@@ -2,19 +2,21 @@ import { buildGradientTexture } from '../../miscellaneous/miscellaneous.js';
 import { checkSRGBSupport } from '../../miscellaneous/webglCapabilities.js';
 import { FXColorNode } from './FXColorNode.js';
 
+const INSTANCES = [];
 class FXColorOverLifeNode extends FXColorNode {
     constructor(colors) {
         if (colors.length === 0) {
             throw new Error("FXColorOverLifeNode: colors array cannot be empty");
         }
         super();
+        INSTANCES.push(this);
+        const uniformName = `u_ColorOverLife_${INSTANCES.length - 1}`;
         this._private_gradientTexture = buildGradientTexture(colors);
         this.affectsDepth = true;
         this.cacheKey = "color-over-life";
-        this.uniformDeclarations = ["uniform sampler2D u_ColorOverLife;"];
+        this.uniformDeclarations = [`uniform sampler2D ${uniformName};`];
         this.uniforms = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            u_ColorOverLife: { value: this._private_gradientTexture },
+            [uniformName]: { value: this._private_gradientTexture },
         };
         this.helperFunctions = `
       vec4 sampleColorOverLife(sampler2D gradientTexture) {
@@ -28,10 +30,14 @@ class FXColorOverLifeNode extends FXColorNode {
         return color;
       }
     `;
-        this.colorExpression = "sampleColorOverLife(u_ColorOverLife)";
+        this.colorExpression = `sampleColorOverLife(${uniformName})`;
     }
     destroy() {
         this._private_gradientTexture.dispose();
+        const index = INSTANCES.indexOf(this);
+        if (index !== -1) {
+            INSTANCES.splice(index, 1);
+        }
     }
 }
 

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

@@ -8,4 +8,5 @@ export interface FXAnimatedTextureNodeOptions {
 }
 export declare class FXAnimatedTextureNode extends FXTextureNode {
     constructor({ texture, columns, rows, interpolate }: FXAnimatedTextureNodeOptions);
+    destroy(): void;
 }

package/dist/nodes/texture/FXAnimatedTextureNode.js

@@ -1,26 +1,29 @@
 import { checkSRGBSupport } from '../../miscellaneous/webglCapabilities.js';
 import { FXTextureNode } from './FXTextureNode.js';
 
+const INSTANCES = [];
 class FXAnimatedTextureNode extends FXTextureNode {
     constructor({ texture, columns, rows, interpolate = false }) {
         super();
+        INSTANCES.push(this);
+        const idx = INSTANCES.length - 1;
+        const uniformTexture = `u_AnimatedTexture_${idx}`;
+        const uniformColumns = `u_AnimatedTextureColumns_${idx}`;
+        const uniformRows = `u_AnimatedTextureRows_${idx}`;
         const gammaCorrection = checkSRGBSupport()
             ? ""
             : "color = vec4(pow(color.rgb, vec3(2.2)), color.a);";
         this.affectsDepth = true;
         this.cacheKey = interpolate ? "animated-interpolated" : "animated";
         this.uniformDeclarations = [
-            "uniform sampler2D u_AnimatedTexture;",
-            "uniform float u_AnimatedTextureColumns;",
-            "uniform float u_AnimatedTextureRows;",
+            `uniform sampler2D ${uniformTexture};`,
+            `uniform float ${uniformColumns};`,
+            `uniform float ${uniformRows};`,
         ];
         this.uniforms = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            u_AnimatedTexture: { value: texture },
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            u_AnimatedTextureColumns: { value: columns },
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            u_AnimatedTextureRows: { value: rows },
+            [uniformTexture]: { value: texture },
+            [uniformColumns]: { value: columns },
+            [uniformRows]: { value: rows },
         };
         this.helperFunctions = interpolate
             ? `
@@ -72,8 +75,13 @@ class FXAnimatedTextureNode extends FXTextureNode {
           return color;
         }
       `;
-        this.colorExpression =
-            "sampleAnimatedTexture(u_AnimatedTexture, p_uv, u_AnimatedTextureColumns, u_AnimatedTextureRows)";
+        this.colorExpression = `sampleAnimatedTexture(${uniformTexture}, p_uv, ${uniformColumns}, ${uniformRows})`;
+    }
+    destroy() {
+        const index = INSTANCES.indexOf(this);
+        if (index !== -1) {
+            INSTANCES.splice(index, 1);
+        }
     }
 }
 

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

@@ -2,4 +2,5 @@ import type { Texture } from "three";
 import { FXTextureNode } from "./FXTextureNode";
 export declare class FXStaticTextureNode extends FXTextureNode {
     constructor(texture: Texture);
+    destroy(): void;
 }

package/dist/nodes/texture/FXStaticTextureNode.js

@@ -1,15 +1,17 @@
 import { checkSRGBSupport } from '../../miscellaneous/webglCapabilities.js';
 import { FXTextureNode } from './FXTextureNode.js';
 
+const INSTANCES = [];
 class FXStaticTextureNode extends FXTextureNode {
     constructor(texture) {
         super();
+        INSTANCES.push(this);
+        const uniformName = `u_StaticTexture_${INSTANCES.length - 1}`;
         this.affectsDepth = true;
         this.cacheKey = "static";
-        this.uniformDeclarations = ["uniform sampler2D u_StaticTexture;"];
+        this.uniformDeclarations = [`uniform sampler2D ${uniformName};`];
         this.uniforms = {
-            // eslint-disable-next-line @typescript-eslint/naming-convention
-            u_StaticTexture: { value: texture },
+            [uniformName]: { value: texture },
         };
         this.helperFunctions = `
       vec4 sampleStaticTexture(sampler2D colorTexture, vec2 uv) {
@@ -19,7 +21,13 @@ class FXStaticTextureNode extends FXTextureNode {
         return color;
       }
     `;
-        this.colorExpression = "sampleStaticTexture(u_StaticTexture, p_uv)";
+        this.colorExpression = `sampleStaticTexture(${uniformName}, p_uv)`;
+    }
+    destroy() {
+        const index = INSTANCES.indexOf(this);
+        if (index !== -1) {
+            INSTANCES.splice(index, 1);
+        }
     }
 }
 

package/package.json

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