sparcoon 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,22 +1,25 @@
-export { FXBehaviorDirectionalGravity } from './behaviorModules/FXBehaviorDirectionalGravity.js';
-export { FXBehaviorPointGravity } from './behaviorModules/FXBehaviorPointGravity.js';
-export { FXBehaviorScaleOverLife } from './behaviorModules/FXBehaviorScaleOverLife.js';
-export { FXBehaviorTorqueDamping } from './behaviorModules/FXBehaviorTorqueDamping.js';
-export { FXBehaviorTorqueNoise } from './behaviorModules/FXBehaviorTorqueNoise.js';
-export { FXBehaviorVelocityDamping } from './behaviorModules/FXBehaviorVelocityDamping.js';
-export { FXBehaviorVelocityNoise } from './behaviorModules/FXBehaviorVelocityNoise.js';
-export { FXColor } from './color/FXColor.js';
-export { FXEmitter } from './elements/FXEmitter.js';
-export { FXRenderingAnimatedTexture } from './renderingModules/FXRenderingAnimatedTexture.js';
-export { FXRenderingColorOverLife } from './renderingModules/FXRenderingColorOverLife.js';
-export { FXRenderingColorOverVelocity } from './renderingModules/FXRenderingColorOverVelocity.js';
-export { FXRenderingTexture } from './renderingModules/FXRenderingTexture.js';
-export { FXSpawnBox } from './spawnModules/FXSpawnBox.js';
-export { FXSpawnOffset } from './spawnModules/FXSpawnOffset.js';
-export { FXSpawnRandomLifetime } from './spawnModules/FXSpawnRandomLifetime.js';
-export { FXSpawnRandomRotation } from './spawnModules/FXSpawnRandomRotation.js';
-export { FXSpawnRandomScale } from './spawnModules/FXSpawnRandomScale.js';
-export { FXSpawnRandomTorque } from './spawnModules/FXSpawnRandomTorque.js';
-export { FXSpawnRandomVelocity } from './spawnModules/FXSpawnRandomVelocity.js';
-export { FXParticleNormalsMode } from './instancedParticle/FXParticleNormalsMode.js';
-export { FXParticleRenderingMode } from './instancedParticle/FXParticleRenderingMode.js';
+export { FXBehaviorDirectionalGravity } from './emitter/behavior/FXBehaviorDirectionalGravity.js';
+export { FXBehaviorPointGravity } from './emitter/behavior/FXBehaviorPointGravity.js';
+export { FXBehaviorScaleOverLife } from './emitter/behavior/FXBehaviorScaleOverLife.js';
+export { FXBehaviorTorqueDamping } from './emitter/behavior/FXBehaviorTorqueDamping.js';
+export { FXBehaviorTorqueNoise } from './emitter/behavior/FXBehaviorTorqueNoise.js';
+export { FXBehaviorVelocityDamping } from './emitter/behavior/FXBehaviorVelocityDamping.js';
+export { FXBehaviorVelocityNoise } from './emitter/behavior/FXBehaviorVelocityNoise.js';
+export { FXEmitter } from './emitter/FXEmitter.js';
+export { FXSpawnBox } from './emitter/spawn/FXSpawnBox.js';
+export { FXSpawnOffset } from './emitter/spawn/FXSpawnOffset.js';
+export { FXSpawnRandomLifetime } from './emitter/spawn/FXSpawnRandomLifetime.js';
+export { FXSpawnRandomRotation } from './emitter/spawn/FXSpawnRandomRotation.js';
+export { FXSpawnRandomScale } from './emitter/spawn/FXSpawnRandomScale.js';
+export { FXSpawnRandomTorque } from './emitter/spawn/FXSpawnRandomTorque.js';
+export { FXSpawnRandomVelocity } from './emitter/spawn/FXSpawnRandomVelocity.js';
+export { FXSpawnSphere } from './emitter/spawn/FXSpawnSphere.js';
+export { FXAnimatedTextureNode } from './materials/color-nodes/FXAnimatedTextureNode.js';
+export { FXColorNode } from './materials/color-nodes/FXColorNode.js';
+export { FXColorOverLifeNode } from './materials/color-nodes/FXColorOverLifeNode.js';
+export { FXStaticTextureNode } from './materials/color-nodes/FXStaticTextureNode.js';
+export { FXDiffuseMaterial } from './materials/FXDiffuseMaterial/FXDiffuseMaterial.js';
+export { FXMaterial } from './materials/FXMaterial.js';
+export { FXUnlitMaterial } from './materials/FXUnlitMaterial/FXUnlitMaterial.js';
+export { FXColor } from './miscellaneous/color/FXColor.js';
+export { FXParticleNormalsMode } from './materials/FXDiffuseMaterial/FXDiffuseMaterial.Internal.js';

package/dist/instancedParticle/FXInstancedParticle.Internal.d.ts

@@ -1,13 +1,6 @@
-import { InstancedBufferGeometry, ShaderMaterial, type Blending } from "three";
-import type { GLProperty, GLTypeInfo } from "./shared";
-import { type FXProperty, type FXPropertyName } from "./shared";
+import { InstancedBufferGeometry } from "three";
+import type { FXPropertyName, GLTypeInfo } from "./shared";
 export declare const INSTANCED_PARTICLE_GEOMETRY: InstancedBufferGeometry;
 export declare function collectProperties(keeper: Record<string, GLTypeInfo>, modules: readonly {
     requiredProperties?: Record<string, FXPropertyName>;
 }[], debugContext: string): void;
-export declare function collectUniforms(keeper: Record<string, GLProperty>, modules: readonly {
-    requiredUniforms: Record<string, FXProperty>;
-}[], debugContext: string): void;
-export declare function buildParticleVertexShader(uniformDeclarations: string[], attributeDeclarations: string[], varyingDeclarations: string[], vertexAssignments: string[]): string;
-export declare function buildParticleFragmentShader(uniformDeclarations: string[], varyingDeclarations: string[], sources: string[]): string;
-export declare function buildParticleMaterial(sources: string[], uniformProperties: Record<string, GLProperty>, varyingProperties: Record<string, GLTypeInfo>, blending: Blending, useAlphaHashing: boolean): ShaderMaterial;

package/dist/instancedParticle/FXInstancedParticle.Internal.js

@@ -1,6 +1,4 @@
-import { InstancedBufferGeometry, BufferAttribute, Float32BufferAttribute, ShaderMaterial } from 'three';
-import { FXColor } from '../color/FXColor.js';
-import { checkSRGBSupport } from '../miscellaneous/webglCapabilities.js';
+import { InstancedBufferGeometry, BufferAttribute, Float32BufferAttribute } from 'three';
 import { resolveGLSLTypeInfo } from './shared.js';
 
 const INSTANCED_PARTICLE_GEOMETRY = (() => {
@@ -30,189 +28,5 @@ function collectProperties(keeper, modules, debugContext) {
         }
     }
 }
-function collectUniforms(keeper, modules, debugContext) {
-    for (const module of modules) {
-        for (const key in module.requiredUniforms) {
-            const value = module.requiredUniforms[key];
-            const existingGLProperty = keeper[key];
-            const newPropertyTypeInfo = resolveGLSLTypeInfo(value);
-            if (existingGLProperty === undefined) {
-                keeper[key] = { value, glslTypeInfo: newPropertyTypeInfo };
-            }
-            else if (existingGLProperty.glslTypeInfo.glslTypeName !== newPropertyTypeInfo.glslTypeName) {
-                throw new Error(`${debugContext}: property conflict for "${key}"`);
-            }
-        }
-    }
-}
-function buildParticleVertexShader(uniformDeclarations, attributeDeclarations, varyingDeclarations, vertexAssignments) {
-    return `
-    #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]
-
-    // User attributes
-    ${attributeDeclarations.join("\n")}
-
-    // Uniforms
-    ${uniformDeclarations.join("\n")}
-
-    // Builtin varyings
-    varying vec2 p_uv;
-
-    // User varyings
-    ${varyingDeclarations.join("\n")}
-
-    void main() {
-      ${vertexAssignments.join("\n")}
-
-      p_uv = uv;
-
-      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;
-    }
-  `;
-}
-function buildParticleFragmentShader(uniformDeclarations, varyingDeclarations, sources) {
-    const renamedSources = sources.map((source, index) => {
-        return 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}()`;
-    }
-    return `
-    #include <common>
-
-    // Defines
-    #define SRGB_SUPPORTED ${checkSRGBSupport() ? "1" : "0"}
-
-    #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]
-
-    // Uniforms
-    ${uniformDeclarations.join("\n")}
-
-    // Builtin varyings
-    varying vec2 p_uv;
-
-    // User varyings
-    ${varyingDeclarations.join("\n")}
-
-    #include <alphahash_pars_fragment>
-
-    // sRGB decode helper
-    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
-    }
-
-    // Source must define vec4 draw() function
-    ${renamedSources.join("\n")}
-
-    void main() {
-      vec4 diffuseColor = ${drawCalls};
-      if (diffuseColor.a < 0.0035) {
-        discard;
-      }
-      #ifdef USE_ALPHAHASH
-        if (diffuseColor.a < getAlphaHashThreshold(vec3(p_builtin[0][0], p_builtin[0][1], p_builtin[0][2]))) {
-          discard;
-        }
-      #endif
-      gl_FragColor = linearToOutputTexel(diffuseColor);
-    }
-  `;
-}
-function buildParticleMaterial(sources, uniformProperties, varyingProperties, blending, useAlphaHashing) {
-    const uniforms = {};
-    const uniformDeclarations = [];
-    const attributeDeclarations = [];
-    const varyingDeclarations = [];
-    const vertexAssignments = [];
-    for (const name in uniformProperties) {
-        const { value, glslTypeInfo } = uniformProperties[name];
-        uniforms[`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};`);
-    }
-    return new ShaderMaterial({
-        uniforms,
-        vertexShader: buildParticleVertexShader(uniformDeclarations, attributeDeclarations, varyingDeclarations, vertexAssignments),
-        fragmentShader: buildParticleFragmentShader(uniformDeclarations, varyingDeclarations, sources),
-        transparent: true,
-        depthWrite: false,
-        depthTest: true,
-        alphaHash: useAlphaHashing,
-        blending,
-    });
-}
 
-export { INSTANCED_PARTICLE_GEOMETRY, buildParticleFragmentShader, buildParticleMaterial, buildParticleVertexShader, collectProperties, collectUniforms };
+export { INSTANCED_PARTICLE_GEOMETRY, collectProperties };

package/dist/instancedParticle/FXInstancedParticle.d.ts

@@ -1,15 +1,13 @@
-import type { Blending } from "three";
+import type { Material } from "three";
 import { InstancedBufferAttribute, Mesh } from "three";
-import { FXParticleNormalsMode } from "./FXParticleNormalsMode";
-import { FXParticleRenderingMode } from "./FXParticleRenderingMode";
-import type { GLProperty, GLTypeInfo } from "./shared";
+import type { GLTypeInfo } from "./shared";
 export declare class FXInstancedParticle extends Mesh {
     private readonly capacityStep;
     readonly propertyBuffers: Record<string, InstancedBufferAttribute>;
     private readonly instancedGeometry;
     private readonly particleMaterial;
     private capacity;
-    constructor(sources: string[], uniforms: Record<string, GLProperty>, varyings: Record<string, GLTypeInfo>, expectedCapacity: number, capacityStep: number, blending: Blending, useAlphaHashing: boolean, renderingMode: FXParticleRenderingMode, normalsMode: FXParticleNormalsMode);
+    constructor(varyings: Record<string, GLTypeInfo>, expectedCapacity: number, capacityStep: number, material: Material);
     get instanceCount(): number;
     createInstances(count: number): void;
     removeDeadParticles(): void;

package/dist/instancedParticle/FXInstancedParticle.js

@@ -1,23 +1,17 @@
 import { Mesh, InstancedBufferAttribute, StreamDrawUsage } from 'three';
 import { BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_LIFETIME } from '../miscellaneous/miscellaneous.js';
-import { INSTANCED_PARTICLE_GEOMETRY, buildParticleMaterial } from './FXInstancedParticle.Internal.js';
-import { buildParticleLambertMaterial } from './FXParticleLambertMaterial.js';
-import './FXParticleNormalsMode.js';
-import { FXParticleRenderingMode } from './FXParticleRenderingMode.js';
+import { INSTANCED_PARTICLE_GEOMETRY } from './FXInstancedParticle.Internal.js';
 
 class FXInstancedParticle extends Mesh {
-    constructor(sources, uniforms, varyings, expectedCapacity, _private_capacityStep, blending, useAlphaHashing, renderingMode, normalsMode) {
+    constructor(varyings, expectedCapacity, _private_capacityStep, material) {
         const instancedGeometry = INSTANCED_PARTICLE_GEOMETRY.clone();
-        const particleMaterial = renderingMode === FXParticleRenderingMode.Lambert
-            ? buildParticleLambertMaterial(sources, uniforms, varyings, blending, useAlphaHashing, normalsMode)
-            : buildParticleMaterial(sources, uniforms, varyings, blending, useAlphaHashing);
-        super(instancedGeometry, particleMaterial);
+        super(instancedGeometry, material);
         this._private_capacityStep = _private_capacityStep;
         this.propertyBuffers = {};
         this.frustumCulled = false;
         this._private_instancedGeometry = instancedGeometry;
         this._private_instancedGeometry.instanceCount = 0;
-        this._private_particleMaterial = particleMaterial;
+        this._private_particleMaterial = material;
         this._private_capacity = Math.max(Math.ceil(expectedCapacity / this._private_capacityStep) * this._private_capacityStep, this._private_capacityStep);
         for (const name in varyings) {
             const { bufferSize } = varyings[name];

package/dist/instancedParticle/shared.d.ts

@@ -1,6 +1,6 @@
 import type { IUniform, ShaderMaterial } from "three";
 import { Matrix3, Matrix4, Texture, Vector2, Vector3, Vector4 } from "three";
-import { FXColor } from "../color/FXColor";
+import { FXColor } from "../miscellaneous/color/FXColor";
 export type FXProperty = Texture | FXColor | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4 | number;
 export type FXPropertyName = "Texture" | "FXColor" | "Vector2" | "Vector3" | "Vector4" | "Matrix3" | "Matrix4" | "number";
 export type FXPropertyConstructor = typeof Texture | typeof FXColor | typeof Vector2 | typeof Vector3 | typeof Vector4 | typeof Matrix3 | typeof Matrix4 | NumberConstructor;

package/dist/instancedParticle/shared.js

@@ -1,5 +1,5 @@
 import { Texture, Vector2, Vector3, Vector4, Matrix3, Matrix4 } from 'three';
-import { FXColor } from '../color/FXColor.js';
+import { FXColor } from '../miscellaneous/color/FXColor.js';
 
 const GLSL_TYPE_INFO_FLOAT = Object.freeze({
     glslTypeName: "float",

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

@@ -0,0 +1,9 @@
+import { MeshLambertMaterial, type Blending } from "three";
+import type { GLTypeInfo } from "../../instancedParticle/shared";
+import type { FXColorNode } from "../color-nodes/FXColorNode";
+export declare enum FXParticleNormalsMode {
+    FLAT = 0,
+    SPHERICAL = 1,
+    TOWARDS_LIGHT = 2
+}
+export declare function buildFXDiffuseMaterial(varyings: Record<string, GLTypeInfo>, blending: Blending, useAlphaHashing: boolean, normalsMode: FXParticleNormalsMode, colorNodes: readonly FXColorNode[]): MeshLambertMaterial;

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

@@ -0,0 +1,108 @@
+import { MeshLambertMaterial, DoubleSide } from 'three';
+import { PARTICLE_DEFINES } from '../miscellaneous.js';
+
+var FXParticleNormalsMode;
+(function (FXParticleNormalsMode) {
+    FXParticleNormalsMode[FXParticleNormalsMode["FLAT"] = 0] = "FLAT";
+    FXParticleNormalsMode[FXParticleNormalsMode["SPHERICAL"] = 1] = "SPHERICAL";
+    FXParticleNormalsMode[FXParticleNormalsMode["TOWARDS_LIGHT"] = 2] = "TOWARDS_LIGHT";
+})(FXParticleNormalsMode || (FXParticleNormalsMode = {}));
+function buildFXDiffuseMaterial(varyings, blending, useAlphaHashing, normalsMode, 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 MeshLambertMaterial({
+        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 <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>", `
+          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;
+          `)
+                    .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
+          `);
+        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 (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.TOWARDS_LIGHT) {
+            fragmentShader = fragmentShader.replace("float dotNL = saturate( dot( geometryNormal, directLight.direction ) );", "float dotNL = 1.0;");
+        }
+        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-diffuse-${normalsMode}-${colorNodes.map((n) => n.cacheKey).join("-") || "none"}`;
+    return material;
+}
+
+export { FXParticleNormalsMode, buildFXDiffuseMaterial };

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

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

package/dist/materials/FXDiffuseMaterial/FXDiffuseMaterial.js

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

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

@@ -0,0 +1,4 @@
+import { MeshDepthMaterial } from "three";
+import type { FXColorNode } from "./color-nodes/FXColorNode";
+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(colorNodes: readonly FXColorNode[], depthAlphaTest: number, useDepthAlphaHash: boolean, useSphericalDepth: boolean): MeshDepthMaterial;

package/dist/materials/FXMaterial.Internal.js

@@ -0,0 +1,106 @@
+import { MeshDepthMaterial, DoubleSide, RGBADepthPacking } from 'three';
+import { PARTICLE_DEFINES } from './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(colorNodes, depthAlphaTest, useDepthAlphaHash, useSphericalDepth) {
+    const depthNodes = colorNodes.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.d.ts

@@ -0,0 +1,14 @@
+import type { FXColorNode } from "./color-nodes/FXColorNode";
+export interface FXMaterialOptions {
+    colorNodes?: FXColorNode[];
+    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.js

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

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

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