sparcoon 0.1.0 → 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.1.0",
+  "version": "0.2.0",
   "description": "",
   "keywords": [
     "particles",

package/dist/elements/FXEmitter.Internal.js

@@ -1,12 +0,0 @@
-import { FXParticleNormalsMode } from '../instancedParticle/FXParticleNormalsMode.js';
-import { FXParticleRenderingMode } from '../instancedParticle/FXParticleRenderingMode.js';
-
-const EMITTER_DEFAULT_EXPECTED_CAPACITY = 32;
-const EMITTER_DEFAULT_CAPACITY_STEP = 32;
-const EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES = true;
-const EMITTER_DEFAULT_CAST_SHADOW = false;
-const EMITTER_DEFAULT_RECEIVE_SHADOW = false;
-const EMITTER_DEFAULT_RENDERING_MODE = FXParticleRenderingMode.Unlit;
-const EMITTER_DEFAULT_NORMALS_MODE = FXParticleNormalsMode.Flat;
-
-export { EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES, EMITTER_DEFAULT_CAPACITY_STEP, EMITTER_DEFAULT_CAST_SHADOW, EMITTER_DEFAULT_EXPECTED_CAPACITY, EMITTER_DEFAULT_NORMALS_MODE, EMITTER_DEFAULT_RECEIVE_SHADOW, EMITTER_DEFAULT_RENDERING_MODE };

package/dist/instancedParticle/FXParticleDepthMaterial.d.ts

@@ -1,2 +0,0 @@
-import { MeshDepthMaterial } from "three";
-export declare function buildParticleDepthMaterial(): MeshDepthMaterial;

package/dist/instancedParticle/FXParticleDepthMaterial.js

@@ -1,52 +0,0 @@
-import { MeshDepthMaterial, RGBADepthPacking } from 'three';
-
-const PARTICLE_DEPTH_VERTEX_SHADER = `
-  #define PARTICLE_POSITION_X a_builtin[0][0]
-  #define PARTICLE_POSITION_Y a_builtin[0][1]
-  #define PARTICLE_POSITION_Z a_builtin[0][2]
-
-  #define PARTICLE_SCALE_X a_builtin[1][2]
-  #define PARTICLE_SCALE_Y a_builtin[1][3]
-
-  #define PARTICLE_ROTATION a_builtin[2][1]
-
-  attribute mat4 a_builtin;
-
-  varying vec2 vHighPrecisionZW;
-
-  void main() {
-    vec2 transformedPosition = position.xy;
-
-    transformedPosition.x *= PARTICLE_SCALE_X;
-    transformedPosition.y *= PARTICLE_SCALE_Y;
-
-    float cosR = cos(PARTICLE_ROTATION);
-    float sinR = sin(PARTICLE_ROTATION);
-
-    transformedPosition = vec2(
-      transformedPosition.x * cosR - transformedPosition.y * sinR,
-      transformedPosition.x * sinR + transformedPosition.y * cosR
-    );
-
-    vec3 center = vec3(
-      PARTICLE_POSITION_X,
-      PARTICLE_POSITION_Y,
-      PARTICLE_POSITION_Z
-    );
-
-    vec4 modelViewCenter = modelViewMatrix * vec4(center, 1.0);
-    modelViewCenter.xy += transformedPosition;
-    gl_Position = projectionMatrix * modelViewCenter;
-    vHighPrecisionZW = gl_Position.zw;
-  }
-`;
-function buildParticleDepthMaterial() {
-    const material = new MeshDepthMaterial({ depthPacking: RGBADepthPacking });
-    material.onBeforeCompile = (shader) => {
-        shader.vertexShader = PARTICLE_DEPTH_VERTEX_SHADER;
-    };
-    material.customProgramCacheKey = () => "fx-particle-depth";
-    return material;
-}
-
-export { buildParticleDepthMaterial };

package/dist/instancedParticle/FXParticleLambertMaterial.d.ts

@@ -1,4 +0,0 @@
-import { MeshLambertMaterial, type Blending } from "three";
-import { FXParticleNormalsMode } from "./FXParticleNormalsMode";
-import type { GLProperty, GLTypeInfo } from "./shared";
-export declare function buildParticleLambertMaterial(sources: string[], uniformProperties: Record<string, GLProperty>, varyingProperties: Record<string, GLTypeInfo>, blending: Blending, useAlphaHashing: boolean, normalsMode: FXParticleNormalsMode): MeshLambertMaterial;

package/dist/instancedParticle/FXParticleLambertMaterial.js

@@ -1,152 +0,0 @@
-import { MeshLambertMaterial } from 'three';
-import { FXColor } from '../color/FXColor.js';
-import { checkSRGBSupport } from '../miscellaneous/webglCapabilities.js';
-import { FXParticleNormalsMode } from './FXParticleNormalsMode.js';
-
-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]
-`;
-function buildParticleLambertMaterial(sources, uniformProperties, varyingProperties, blending, useAlphaHashing, normalsMode) {
-    const uniformValues = {};
-    const uniformDeclarations = [];
-    const attributeDeclarations = [];
-    const varyingDeclarations = [];
-    const vertexAssignments = [];
-    for (const name in uniformProperties) {
-        const { value, glslTypeInfo } = uniformProperties[name];
-        uniformValues[`p_${name}`] = { value: value instanceof FXColor ? value.toGLSLColor() : value };
-        uniformDeclarations.push(`uniform ${glslTypeInfo.glslTypeName} p_${name};`);
-    }
-    for (const name in varyingProperties) {
-        const { glslTypeName } = varyingProperties[name];
-        attributeDeclarations.push(`attribute ${glslTypeName} a_${name};`);
-        varyingDeclarations.push(`varying ${glslTypeName} p_${name};`);
-        vertexAssignments.push(`p_${name} = a_${name};`);
-    }
-    const renamedSources = sources.map((source, index) => source.replace(/vec4\s+draw\s*\(\s*\)/g, `vec4 draw${index}()`));
-    let drawCalls = "";
-    for (let i = 0; i < sources.length; i++) {
-        drawCalls += i !== 0 ? " * " : "";
-        drawCalls += `draw${i}()`;
-    }
-    const srgbSupported = checkSRGBSupport() ? "1" : "0";
-    const srgbHelper = `
-    vec4 srgbTexture2D(sampler2D textureSampler, vec2 uv) {
-      #if SRGB_SUPPORTED
-        return texture2D(textureSampler, uv);
-      #else
-        vec4 textureValue = texture2D(textureSampler, uv);
-        return vec4(pow(textureValue.rgb, vec3(2.2)), textureValue.a);
-      #endif
-    }
-  `;
-    const material = new MeshLambertMaterial({
-        transparent: true,
-        depthWrite: false,
-        depthTest: true,
-        alphaHash: useAlphaHashing,
-        blending,
-    });
-    material.onBeforeCompile = (shader) => {
-        Object.assign(shader.uniforms, uniformValues);
-        // --- Vertex shader ---
-        const vertexPreamble = [
-            PARTICLE_DEFINES,
-            attributeDeclarations.join("\n"),
-            "varying vec2 p_uv;",
-            varyingDeclarations.join("\n"),
-        ].join("\n");
-        shader.vertexShader =
-            vertexPreamble +
-                "\n" +
-                shader.vertexShader
-                    // Hardcode objectNormal — no normal attribute on billboard geometry
-                    .replace("#include <beginnormal_vertex>", "vec3 objectNormal = vec3(0.0, 0.0, 1.0);")
-                    // Hardcode transformedNormal as view-space camera-facing (0,0,1)
-                    .replace("#include <defaultnormal_vertex>", "vec3 transformedNormal = vec3(0.0, 0.0, 1.0);")
-                    // Set p_uv, user varyings, placeholder transformed for downstream chunks
-                    .replace("#include <begin_vertex>", ["p_uv = uv;", vertexAssignments.join("\n"), "vec3 transformed = position;"].join("\n"))
-                    // Billboard projection: computes p_bp (screen offset) and p_c (center), sets mvPosition
-                    .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;
-          `)
-                    // Billboard world position — p_c and p_bp in scope from project_vertex above
-                    .replace("#include <worldpos_vertex>", `
-          #if defined(USE_SHADOWMAP) || defined(USE_ENVMAP) || defined(DISTANCE) || (NUM_SPOT_LIGHT_COORDS > 0)
-            vec3 p_cr = vec3(viewMatrix[0][0], viewMatrix[1][0], viewMatrix[2][0]);
-            vec3 p_cu = vec3(viewMatrix[0][1], viewMatrix[1][1], viewMatrix[2][1]);
-            vec4 worldPosition = vec4(
-              (modelMatrix * vec4(p_c, 1.0)).xyz + p_cr * p_bp.x + p_cu * p_bp.y,
-              1.0
-            );
-          #endif
-          `);
-        // --- Fragment shader ---
-        const fragmentPreamble = [
-            PARTICLE_DEFINES,
-            `#define SRGB_SUPPORTED ${srgbSupported}`,
-            uniformDeclarations.join("\n"),
-            "varying vec2 p_uv;",
-            varyingDeclarations.join("\n"),
-            srgbHelper,
-            renamedSources.join("\n"),
-        ].join("\n");
-        let fragmentShader = shader.fragmentShader;
-        if (normalsMode === FXParticleNormalsMode.Spherical) {
-            fragmentShader = fragmentShader.replace("#include <normal_fragment_begin>", `
-        float faceDirection = gl_FrontFacing ? 1.0 : -1.0;
-        vec2 p_sn = p_uv * 2.0 - 1.0;
-        vec3 normal = normalize(vec3(p_sn, sqrt(max(0.0, 1.0 - dot(p_sn, p_sn)))));
-        `);
-        }
-        else if (normalsMode === FXParticleNormalsMode.TowardsLight) {
-            fragmentShader = fragmentShader.replace("float dotNL = saturate( dot( geometryNormal, directLight.direction ) );", "float dotNL = 1.0;");
-        }
-        shader.fragmentShader =
-            fragmentPreamble +
-                "\n" +
-                fragmentShader
-                    // Inject custom diffuse color from draw() pipeline
-                    .replace("#include <map_fragment>", `
-          vec4 p_color = ${drawCalls};
-          if (p_color.a < 0.0035) discard;
-          diffuseColor = p_color;
-          `);
-    };
-    material.customProgramCacheKey = () => `fx-particle-lambert-${normalsMode}-${sources.join("|")}`;
-    return material;
-}
-
-export { buildParticleLambertMaterial };

package/dist/instancedParticle/FXParticleNormalsMode.d.ts

@@ -1,5 +0,0 @@
-export declare enum FXParticleNormalsMode {
-    Flat = "flat",
-    Spherical = "spherical",
-    TowardsLight = "towards-light"
-}

package/dist/instancedParticle/FXParticleNormalsMode.js

@@ -1,8 +0,0 @@
-var FXParticleNormalsMode;
-(function (FXParticleNormalsMode) {
-    FXParticleNormalsMode["Flat"] = "flat";
-    FXParticleNormalsMode["Spherical"] = "spherical";
-    FXParticleNormalsMode["TowardsLight"] = "towards-light";
-})(FXParticleNormalsMode || (FXParticleNormalsMode = {}));
-
-export { FXParticleNormalsMode };

package/dist/instancedParticle/FXParticleRenderingMode.d.ts

@@ -1,4 +0,0 @@
-export declare enum FXParticleRenderingMode {
-    Unlit = "unlit",
-    Lambert = "lambert"
-}

package/dist/instancedParticle/FXParticleRenderingMode.js

@@ -1,7 +0,0 @@
-var FXParticleRenderingMode;
-(function (FXParticleRenderingMode) {
-    FXParticleRenderingMode["Unlit"] = "unlit";
-    FXParticleRenderingMode["Lambert"] = "lambert";
-})(FXParticleRenderingMode || (FXParticleRenderingMode = {}));
-
-export { FXParticleRenderingMode };

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 };