sparcoon 0.1.0 → 0.3.0

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

@@ -0,0 +1,141 @@
+import { MeshLambertMaterial, Color, DoubleSide } from 'three';
+import { PARTICLE_DEFINES } from '../../miscellaneous/miscellaneous.js';
+import { FXTextureNode } from '../../nodes/texture/FXTextureNode.js';
+
+function buildFXDiffuseMaterial(varyings, blending, useAlphaHashing, alphaTest, albedoNodes, normalNodes, emissionNodes) {
+    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 MeshLambertMaterial({
+        transparent: !useAlphaHashing,
+        depthWrite: useAlphaHashing,
+        depthTest: true,
+        alphaHash: useAlphaHashing,
+        blending,
+        side: DoubleSide,
+        forceSinglePass: true,
+        alphaTest,
+        emissive: emissionNodes.length > 0 ? new Color(1, 1, 1) : new Color(0, 0, 0),
+    });
+    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 <beginnormal_vertex>", "vec3 objectNormal = vec3(0.0, 0.0, 1.0);")
+                    .replace("#include <defaultnormal_vertex>", "vec3 transformedNormal = vec3(0.0, 0.0, 1.0);")
+                    .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>", `
+          // Scale and rotate the billboard offset in camera space
+          vec2 billboardOffset = position.xy;
+          billboardOffset.x *= PARTICLE_SCALE_X;
+          billboardOffset.y *= PARTICLE_SCALE_Y;
+
+          float cosRotation = cos(PARTICLE_ROTATION);
+          float sinRotation = sin(PARTICLE_ROTATION);
+          billboardOffset = vec2(
+            billboardOffset.x * cosRotation - billboardOffset.y * sinRotation,
+            billboardOffset.x * sinRotation + billboardOffset.y * cosRotation
+          );
+
+          // Move particle center to view space, then apply the billboard offset
+          vec3 particleCenter = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z);
+          vec4 mvPosition = modelViewMatrix * vec4(particleCenter, 1.0);
+          mvPosition.xy += billboardOffset;
+          gl_Position = projectionMatrix * mvPosition;
+          `)
+                    .replace("#include <worldpos_vertex>", `
+          #if defined(USE_SHADOWMAP) || defined(USE_ENVMAP) || defined(DISTANCE) || (NUM_SPOT_LIGHT_COORDS > 0)
+            // Reconstruct world-space position for shadow/environment maps.
+            // Camera right and up are the first two rows of the view matrix rotation (transposed).
+            vec3 cameraRight = vec3(viewMatrix[0][0], viewMatrix[1][0], viewMatrix[2][0]);
+            vec3 cameraUp    = vec3(viewMatrix[0][1], viewMatrix[1][1], viewMatrix[2][1]);
+            vec4 worldPosition = vec4(
+              (modelMatrix * vec4(particleCenter, 1.0)).xyz + cameraRight * billboardOffset.x + cameraUp * billboardOffset.y,
+              1.0
+            );
+          #endif
+          `);
+        const blendReorientedNormalsHelper = normalNodes.length > 1
+            ? `
+          vec3 blendReorientedNormals(vec3 base, vec3 detail) {
+            base += vec3(0.0, 0.0, 1.0);
+            detail *= vec3(-1.0, -1.0, 1.0);
+            return normalize(base * dot(base, detail) / base.z - detail);
+          }
+        `
+            : "";
+        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"),
+            normalNodes.flatMap((n) => n.uniformDeclarations).join("\n"),
+            normalNodes.map((n) => n.helperFunctions).join("\n"),
+            blendReorientedNormalsHelper,
+            emissionNodes.flatMap((n) => n.uniformDeclarations).join("\n"),
+            emissionNodes.map((n) => n.helperFunctions).join("\n"),
+        ].join("\n");
+        for (const node of albedoNodes) {
+            Object.assign(shader.uniforms, node.uniforms);
+        }
+        for (const node of normalNodes) {
+            Object.assign(shader.uniforms, node.uniforms);
+        }
+        for (const node of emissionNodes) {
+            Object.assign(shader.uniforms, node.uniforms);
+        }
+        let fragmentShader = shader.fragmentShader;
+        if (normalNodes.length > 0) {
+            const normalExpressions = normalNodes.map((node) => {
+                if (node instanceof FXTextureNode) {
+                    return `normalize(${node.colorExpression}.rgb * 2.0 - 1.0)`;
+                }
+                return node.normalExpression;
+            });
+            const blendLines = normalExpressions
+                .slice(1)
+                .map((expression) => `normal = blendReorientedNormals(normal, ${expression});`);
+            const normalCode = [
+                "float faceDirection = gl_FrontFacing ? 1.0 : -1.0;",
+                `vec3 normal = ${normalExpressions[0]};`,
+                ...blendLines,
+            ].join("\n");
+            fragmentShader = fragmentShader.replace("#include <normal_fragment_begin>", normalCode);
+        }
+        if (albedoNodes.length > 0) {
+            const combinedExpression = albedoNodes.map((n) => n.colorExpression).join(" * ");
+            const discardLine = useAlphaHashing ? "" : "if (diffuseColor.a < 0.0035) discard;";
+            fragmentShader = fragmentShader.replace("#include <map_fragment>", `diffuseColor = ${combinedExpression}; ${discardLine}`);
+        }
+        if (emissionNodes.length > 0) {
+            const combinedExpression = emissionNodes.map((n) => n.colorExpression).join(" * ");
+            fragmentShader = fragmentShader.replace("#include <emissivemap_fragment>", `totalEmissiveRadiance = (${combinedExpression}).rgb;`);
+        }
+        shader.fragmentShader = fragmentPreamble + "\n" + fragmentShader;
+    };
+    material.customProgramCacheKey = () => `fx-diffuse-${albedoNodes.map((n) => n.cacheKey).join("-") || "none"}-${normalNodes.map((n) => n.cacheKey).join("-") || "none"}-${emissionNodes.map((n) => n.cacheKey).join("-") || "none"}`;
+    return material;
+}
+
+export { buildFXDiffuseMaterial };

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

@@ -0,0 +1,15 @@
+import type { FXColorNode } from "../../nodes/color/FXColorNode";
+import type { FXNormalNode } from "../../nodes/normal/FXNormalNode";
+import type { FXTextureNode } from "../../nodes/texture/FXTextureNode";
+import type { FXMaterialOptions } from "../FXMaterial/FXMaterial";
+import { FXMaterial } from "../FXMaterial/FXMaterial";
+export interface FXDiffuseMaterialOptions extends FXMaterialOptions {
+    normalNodes?: (FXTextureNode | FXNormalNode)[];
+    emissionNodes?: (FXColorNode | FXTextureNode)[];
+}
+export declare class FXDiffuseMaterial extends FXMaterial {
+    private readonly normalNodes;
+    private readonly emissionNodes;
+    constructor(options?: FXDiffuseMaterialOptions);
+    destroy(): void;
+}

package/dist/materials/FXDiffuseMaterial/FXDiffuseMaterial.js

@@ -0,0 +1,26 @@
+import { FXSphericalNormalNode } from '../../nodes/normal/FXSphericalNormalNode.js';
+import { FXMaterial } from '../FXMaterial/FXMaterial.js';
+import { buildFXDiffuseMaterial } from './FXDiffuseMaterial.Internal.js';
+
+class FXDiffuseMaterial extends FXMaterial {
+    constructor(options = {}) {
+        super(options);
+        this._private_normalNodes = options.normalNodes ?? [new FXSphericalNormalNode()];
+        this._private_emissionNodes = options.emissionNodes ?? [];
+    }
+    destroy() {
+        super.destroy();
+        for (const node of this._private_normalNodes) {
+            node.destroy?.();
+        }
+        for (const node of this._private_emissionNodes) {
+            node.destroy?.();
+        }
+    }
+    /** @internal */
+    buildThreeMaterial(varyings) {
+        return buildFXDiffuseMaterial(varyings, this.blending, this.useAlphaHashing, this.alphaTest, this.albedoNodes, this._private_normalNodes, this._private_emissionNodes);
+    }
+}
+
+export { FXDiffuseMaterial };

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

@@ -0,0 +1,5 @@
+import { MeshDepthMaterial } from "three";
+import type { FXColorNode } from "../../nodes/color/FXColorNode";
+import type { FXTextureNode } from "../../nodes/texture/FXTextureNode";
+export declare const DEPTH_VERTEX_SHADER = "\n  #define PARTICLE_POSITION_X a_builtin[0][0]\n  #define PARTICLE_POSITION_Y a_builtin[0][1]\n  #define PARTICLE_POSITION_Z a_builtin[0][2]\n\n  #define PARTICLE_SCALE_X a_builtin[1][2]\n  #define PARTICLE_SCALE_Y a_builtin[1][3]\n\n  #define PARTICLE_ROTATION a_builtin[2][1]\n\n  attribute mat4 a_builtin;\n  varying mat4 p_builtin;\n  varying vec2 p_uv;\n  varying vec2 vHighPrecisionZW;\n  varying float v_viewZ;\n  #ifdef USE_ALPHAHASH\n    varying vec3 vPosition;\n  #endif\n\n  void main() {\n    p_builtin = a_builtin;\n    p_uv = uv;\n    #ifdef USE_ALPHAHASH\n      vPosition = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z) + vec3(position.xy, 0.0);\n    #endif\n\n    vec2 transformedPosition = position.xy;\n    transformedPosition.x *= PARTICLE_SCALE_X;\n    transformedPosition.y *= PARTICLE_SCALE_Y;\n\n    float cosR = cos(PARTICLE_ROTATION);\n    float sinR = sin(PARTICLE_ROTATION);\n    transformedPosition = vec2(\n      transformedPosition.x * cosR - transformedPosition.y * sinR,\n      transformedPosition.x * sinR + transformedPosition.y * cosR\n    );\n\n    vec3 center = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z);\n    vec4 modelViewCenter = modelViewMatrix * vec4(center, 1.0);\n    v_viewZ = modelViewCenter.z;\n    modelViewCenter.xy += transformedPosition;\n    gl_Position = projectionMatrix * modelViewCenter;\n    vHighPrecisionZW = gl_Position.zw;\n  }\n";
+export declare function buildDepthMaterial(albedoNodes: readonly (FXColorNode | FXTextureNode)[], depthAlphaTest: number, useDepthAlphaHash: boolean, useSphericalDepth: boolean): MeshDepthMaterial;

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

@@ -0,0 +1,106 @@
+import { MeshDepthMaterial, DoubleSide, RGBADepthPacking } from 'three';
+import { PARTICLE_DEFINES } from '../../miscellaneous/miscellaneous.js';
+
+const 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 mat4 p_builtin;
+  varying vec2 p_uv;
+  varying vec2 vHighPrecisionZW;
+  varying float v_viewZ;
+  #ifdef USE_ALPHAHASH
+    varying vec3 vPosition;
+  #endif
+
+  void main() {
+    p_builtin = a_builtin;
+    p_uv = uv;
+    #ifdef USE_ALPHAHASH
+      vPosition = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z) + vec3(position.xy, 0.0);
+    #endif
+
+    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);
+    v_viewZ = modelViewCenter.z;
+    modelViewCenter.xy += transformedPosition;
+    gl_Position = projectionMatrix * modelViewCenter;
+    vHighPrecisionZW = gl_Position.zw;
+  }
+`;
+const DEPTH_SPHERICAL_FRAG_COORD_Z = `
+  float _dx = (p_uv.x - 0.5) * PARTICLE_SCALE_X;
+  float _dy = (p_uv.y - 0.5) * PARTICLE_SCALE_Y;
+  float _r = min(PARTICLE_SCALE_X, PARTICLE_SCALE_Y) * 0.5;
+  float _d2 = _dx * _dx + _dy * _dy;
+  if (_d2 > _r * _r) discard;
+  float _sphereZ = v_viewZ + sqrt(_r * _r - _d2);
+  float _pz = projectionMatrix[2][2] * _sphereZ + projectionMatrix[3][2];
+  float _pw = projectionMatrix[2][3] * _sphereZ + projectionMatrix[3][3];
+  float _ndc_z = _pz / _pw;
+  #ifdef USE_REVERSEDEPTHBUF
+    float fragCoordZ = _ndc_z;
+  #else
+    float fragCoordZ = 0.5 * _ndc_z + 0.5;
+  #endif
+`;
+function buildDepthMaterial(albedoNodes, depthAlphaTest, useDepthAlphaHash, useSphericalDepth) {
+    const depthNodes = albedoNodes.filter((n) => n.affectsDepth);
+    const needsFragmentMod = depthNodes.length > 0 || useSphericalDepth;
+    const material = new MeshDepthMaterial({
+        depthPacking: RGBADepthPacking,
+        side: DoubleSide,
+        forceSinglePass: true,
+        alphaHash: useDepthAlphaHash,
+    });
+    material.onBeforeCompile = (shader) => {
+        shader.vertexShader = DEPTH_VERTEX_SHADER;
+        if (!needsFragmentMod) {
+            return;
+        }
+        const fragmentPreamble = [
+            PARTICLE_DEFINES,
+            "varying mat4 p_builtin;",
+            "varying vec2 p_uv;",
+            "varying float v_viewZ;",
+            useSphericalDepth ? "uniform mat4 projectionMatrix;" : "",
+            depthNodes.flatMap((n) => n.uniformDeclarations).join("\n"),
+            depthNodes.map((n) => n.helperFunctions).join("\n"),
+        ].join("\n");
+        for (const node of depthNodes) {
+            Object.assign(shader.uniforms, node.uniforms);
+        }
+        let fs = shader.fragmentShader;
+        if (depthNodes.length > 0) {
+            const combinedAlpha = depthNodes.map((n) => n.colorExpression).join(" * ");
+            fs = fs.replace("#include <map_fragment>", `diffuseColor.a = (${combinedAlpha}).a;
+         if (diffuseColor.a < ${depthAlphaTest.toFixed(4)}) discard;`);
+        }
+        if (useSphericalDepth) {
+            fs = fs.replace(/float fragCoordZ\b[^;]*;/, DEPTH_SPHERICAL_FRAG_COORD_Z);
+        }
+        shader.fragmentShader = fragmentPreamble + "\n" + fs;
+    };
+    material.customProgramCacheKey = () => `fx-depth-${useDepthAlphaHash ? "ah" : "at"}-${useSphericalDepth ? "sd" : "flat"}-${depthNodes.map((n) => n.cacheKey).join("-") || "none"}`;
+    return material;
+}
+
+export { DEPTH_VERTEX_SHADER, buildDepthMaterial };

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

@@ -0,0 +1,19 @@
+import type { Blending } from "three";
+import type { FXColorNode } from "../../nodes/color/FXColorNode";
+import type { FXTextureNode } from "../../nodes/texture/FXTextureNode";
+export interface FXMaterialOptions {
+    albedoNodes?: (FXColorNode | FXTextureNode)[];
+    blending?: Blending;
+    useAlphaHashing?: boolean;
+    alphaTest?: number;
+    depthAlphaTest?: number;
+    useDepthAlphaHash?: boolean;
+    useSphericalDepth?: boolean;
+}
+export declare abstract class FXMaterial {
+    private readonly depthAlphaTest;
+    private readonly useDepthAlphaHash;
+    private readonly useSphericalDepth;
+    constructor(options?: FXMaterialOptions);
+    destroy(): void;
+}

package/dist/materials/FXMaterial/FXMaterial.js

@@ -0,0 +1,25 @@
+import { NormalBlending } from 'three';
+import { buildDepthMaterial } from './FXMaterial.Internal.js';
+
+class FXMaterial {
+    constructor(options = {}) {
+        this.albedoNodes = options.albedoNodes ?? [];
+        this.blending = options.blending ?? NormalBlending;
+        this.useAlphaHashing = options.useAlphaHashing ?? false;
+        this.alphaTest = options.alphaTest ?? 1 / 255;
+        this._private_depthAlphaTest = options.depthAlphaTest ?? 0.5;
+        this._private_useDepthAlphaHash = options.useDepthAlphaHash ?? false;
+        this._private_useSphericalDepth = options.useSphericalDepth ?? true;
+    }
+    destroy() {
+        for (const node of this.albedoNodes) {
+            node.destroy?.();
+        }
+    }
+    /** @internal */
+    buildDepthMaterial() {
+        return buildDepthMaterial(this.albedoNodes, this._private_depthAlphaTest, this._private_useDepthAlphaHash, this._private_useSphericalDepth);
+    }
+}
+
+export { FXMaterial };

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

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

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

@@ -0,0 +1,84 @@
+import { MeshBasicMaterial, DoubleSide } from 'three';
+import { PARTICLE_DEFINES } from '../../miscellaneous/miscellaneous.js';
+
+function buildFXUnlitMaterial(varyings, blending, useAlphaHashing, alphaTest, albedoNodes) {
+    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,
+    });
+    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>", `
+          // Scale and rotate the billboard offset in camera space
+          vec2 billboardOffset = position.xy;
+          billboardOffset.x *= PARTICLE_SCALE_X;
+          billboardOffset.y *= PARTICLE_SCALE_Y;
+
+          float cosRotation = cos(PARTICLE_ROTATION);
+          float sinRotation = sin(PARTICLE_ROTATION);
+          billboardOffset = vec2(
+            billboardOffset.x * cosRotation - billboardOffset.y * sinRotation,
+            billboardOffset.x * sinRotation + billboardOffset.y * cosRotation
+          );
+
+          // Move particle center to view space, then apply the billboard offset
+          vec3 particleCenter = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z);
+          vec4 mvPosition = modelViewMatrix * vec4(particleCenter, 1.0);
+          mvPosition.xy += billboardOffset;
+          gl_Position = projectionMatrix * mvPosition;
+          `);
+        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"),
+        ].join("\n");
+        for (const node of albedoNodes) {
+            Object.assign(shader.uniforms, node.uniforms);
+        }
+        let fragmentShader = shader.fragmentShader;
+        if (albedoNodes.length > 0) {
+            const combinedExpression = albedoNodes.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-${albedoNodes.map((n) => n.cacheKey).join("-") || "none"}`;
+    return material;
+}
+
+export { buildFXUnlitMaterial };

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

@@ -0,0 +1,6 @@
+import type { FXMaterialOptions } from "../FXMaterial/FXMaterial";
+import { FXMaterial } from "../FXMaterial/FXMaterial";
+export type FXUnlitMaterialOptions = FXMaterialOptions;
+export declare class FXUnlitMaterial extends FXMaterial {
+    constructor(options?: FXUnlitMaterialOptions);
+}

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.js

@@ -0,0 +1,14 @@
+import { FXMaterial } from '../FXMaterial/FXMaterial.js';
+import { buildFXUnlitMaterial } from './FXUnlitMaterial.Internal.js';
+
+class FXUnlitMaterial extends FXMaterial {
+    constructor(options = {}) {
+        super(options);
+    }
+    /** @internal */
+    buildThreeMaterial(varyings) {
+        return buildFXUnlitMaterial(varyings, this.blending, this.useAlphaHashing, this.alphaTest, this.albedoNodes);
+    }
+}
+
+export { FXUnlitMaterial };

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;
@@ -30,3 +30,4 @@ export declare const BUILTIN_OFFSET_AGE = 12;
 export declare const BUILTIN_OFFSET_RANDOM_A = 13;
 export declare const BUILTIN_OFFSET_RANDOM_B = 14;
 export declare const BUILTIN_OFFSET_RANDOM_C = 15;
+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/miscellaneous/miscellaneous.js

@@ -58,5 +58,28 @@ const BUILTIN_OFFSET_AGE = 12;
 const BUILTIN_OFFSET_RANDOM_A = 13;
 const BUILTIN_OFFSET_RANDOM_B = 14;
 const BUILTIN_OFFSET_RANDOM_C = 15;
+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]
 
-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, buildGradientTexture, resolveAspect, resolveFXRangeConfig, resolveFXVector3Config };
+  #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 { 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/color/FXColorNode.d.ts

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

package/dist/nodes/color/FXColorNode.js

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

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

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

package/dist/nodes/color/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();
+        this._private_gradientTexture = buildGradientTexture(colors);
+        this.affectsDepth = true;
+        this.cacheKey = "color-over-life";
+        this.uniformDeclarations = ["uniform sampler2D u_ColorOverLife;"];
+        this.uniforms = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            u_ColorOverLife: { value: this._private_gradientTexture },
+        };
+        this.helperFunctions = `
+      vec4 sampleColorOverLife(sampler2D gradientTexture) {
+        // Normalized particle age [0, 1] maps to the gradient texture's x-axis
+        float lifetimeRatio = clamp(PARTICLE_AGE / PARTICLE_LIFETIME, 0.0, 1.0);
+        vec4 color = texture2D(gradientTexture, vec2(lifetimeRatio, 0.5));
+
+        // Apply gamma correction when sRGB textures are not natively supported
+        ${checkSRGBSupport() ? "" : "color = vec4(pow(color.rgb, vec3(2.2)), color.a);"}
+
+        return color;
+      }
+    `;
+        this.colorExpression = "sampleColorOverLife(u_ColorOverLife)";
+    }
+    destroy() {
+        this._private_gradientTexture.dispose();
+    }
+}
+
+export { FXColorOverLifeNode };

package/dist/nodes/normal/FXFlatNormalNode.d.ts

@@ -0,0 +1,4 @@
+import { FXNormalNode } from "./FXNormalNode";
+export declare class FXFlatNormalNode extends FXNormalNode {
+    constructor();
+}

package/dist/nodes/normal/FXFlatNormalNode.js

@@ -0,0 +1,14 @@
+import { FXNormalNode } from './FXNormalNode.js';
+
+class FXFlatNormalNode extends FXNormalNode {
+    constructor() {
+        super();
+        this.cacheKey = "flat";
+        this.uniformDeclarations = [];
+        this.uniforms = {};
+        this.helperFunctions = "";
+        this.normalExpression = "vec3(0.0, 0.0, 1.0)";
+    }
+}
+
+export { FXFlatNormalNode };

package/dist/nodes/normal/FXNormalNode.d.ts

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

package/dist/nodes/normal/FXNormalNode.js

@@ -0,0 +1,4 @@
+class FXNormalNode {
+}
+
+export { FXNormalNode };

package/dist/nodes/normal/FXSphericalNormalNode.d.ts

@@ -0,0 +1,4 @@
+import { FXNormalNode } from "./FXNormalNode";
+export declare class FXSphericalNormalNode extends FXNormalNode {
+    constructor();
+}

package/dist/nodes/normal/FXSphericalNormalNode.js

@@ -0,0 +1,19 @@
+import { FXNormalNode } from './FXNormalNode.js';
+
+class FXSphericalNormalNode extends FXNormalNode {
+    constructor() {
+        super();
+        this.cacheKey = "spherical";
+        this.uniformDeclarations = [];
+        this.uniforms = {};
+        this.helperFunctions = `
+      vec3 fxComputeSphericalNormal(vec2 uv) {
+        vec2 centeredUV = uv * 2.0 - 1.0;
+        return normalize(vec3(centeredUV, sqrt(max(0.0, 1.0 - dot(centeredUV, centeredUV)))));
+      }
+    `;
+        this.normalExpression = "fxComputeSphericalNormal(p_uv)";
+    }
+}
+
+export { FXSphericalNormalNode };

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

@@ -0,0 +1,11 @@
+import type { Texture } from "three";
+import { FXTextureNode } from "./FXTextureNode";
+export interface FXAnimatedTextureNodeOptions {
+    texture: Texture;
+    columns: number;
+    rows: number;
+    interpolate?: boolean;
+}
+export declare class FXAnimatedTextureNode extends FXTextureNode {
+    constructor({ texture, columns, rows, interpolate }: FXAnimatedTextureNodeOptions);
+}