sparcoon 0.7.2 → 0.9.0

package/dist/materials/FXDiffuseMaterial/FXDiffuseMaterial.js

@@ -1,63 +0,0 @@
-import { FXColor } from '../../miscellaneous/color/FXColor.js';
-import { FXNodeSphericalNormal } from '../../nodes/normal/FXNodeSphericalNormal.js';
-import { FXMaterial } from '../FXMaterial/FXMaterial.js';
-import { buildFXDiffuseMaterial } from './FXDiffuseMaterial.Internal.js';
-
-/**
- * Diffuse particle material with lighting, normals, emission, and optional subsurface scattering
- */
-class FXDiffuseMaterial extends FXMaterial {
-    /**
-     * @param options - Material configuration
-     */
-    constructor(options = {}) {
-        super(options);
-        this._private_normalNodes = options.normalNodes ?? [new FXNodeSphericalNormal()];
-        this._private_emissionNodes = options.emissionNodes ?? [];
-        this._private_scatterUniforms =
-            options.enableScatter === true
-                ? {
-                    // eslint-disable-next-line @typescript-eslint/naming-convention
-                    u_ScatterTint: { value: new FXColor(options.scatterTint ?? 0xffd999).toThreeColor() },
-                    // eslint-disable-next-line @typescript-eslint/naming-convention
-                    u_ScatterPower: { value: options.scatterPower ?? 10 },
-                    // eslint-disable-next-line @typescript-eslint/naming-convention
-                    u_ForwardScatterStrength: { value: options.forwardScatterStrength ?? 1 },
-                    // eslint-disable-next-line @typescript-eslint/naming-convention
-                    u_BackScatterStrength: { value: options.backScatterStrength ?? 1 },
-                }
-                : undefined;
-        this._private_shadowSensitivity = { value: options.shadowSensitivity ?? 1 };
-    }
-    /** Releases resources held by all albedo, normal, and emission nodes */
-    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, this._private_scatterUniforms, this._private_shadowSensitivity);
-    }
-    prepare() {
-        let i = 0;
-        for (const node of this.albedoNodes) {
-            node.prepare?.(i);
-            i += 1;
-        }
-        for (const node of this._private_normalNodes) {
-            node.prepare?.(i);
-            i += 1;
-        }
-        for (const node of this._private_emissionNodes) {
-            node.prepare?.(i);
-            i += 1;
-        }
-    }
-}
-
-export { FXDiffuseMaterial };

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

@@ -1,24 +0,0 @@
-import { FXNodeBlending } from "../../nodes/blending/FXNodeBlending";
-import type { FXNodeColor } from "../../nodes/color/FXNodeColor";
-import type { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
-import { FXBlending } from "./FXMaterial";
-export interface AlbedoBlendingCode {
-    /** Replacement for #include <map_fragment>. null means: leave the include as-is */
-    mapFragment: string | null;
-    /** Replacement for #include <premultiplied_alpha_fragment> */
-    premultChunk: string;
-}
-/**
- * Processes albedoNodes in order to produce shader code for both the color assignment
- * and the per-pixel blending mode.
- *
- * Nodes are composed sequentially: each node receives the current accumulated value via
- * EXPRESSION_CURRENT_VALUE_PLACEHOLDER and returns a new value. Nodes that do not use
- * the placeholder act as sources and replace the current value entirely.
- *
- * When a FXNodeBlending appears, it receives both the current mask (via
- * EXPRESSION_CURRENT_VALUE_PLACEHOLDER) and the current color (via
- * EXPRESSION_CURRENT_COLOR_PLACEHOLDER), and returns the new mask value. Color nodes
- * that follow a blending node do not affect the mask.
- */
-export declare function buildAlbedoAndBlendingCode(albedoNodes: readonly (FXNodeColor | FXNodeTexture | FXNodeBlending)[], blending: FXBlending, useAlphaHashing: boolean): AlbedoBlendingCode;

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

@@ -1,64 +0,0 @@
-import { CURRENT_EXPRESSION_VALUE_PLACEHOLDER, BLENDING_EXPRESSION_CURRENT_COLOR_PLACEHOLDER } from '../../nodes/FXNode.js';
-import { FXNodeBlending } from '../../nodes/blending/FXNodeBlending.js';
-import { FXBlending } from './FXMaterial.js';
-
-/**
- * Processes albedoNodes in order to produce shader code for both the color assignment
- * and the per-pixel blending mode.
- *
- * Nodes are composed sequentially: each node receives the current accumulated value via
- * EXPRESSION_CURRENT_VALUE_PLACEHOLDER and returns a new value. Nodes that do not use
- * the placeholder act as sources and replace the current value entirely.
- *
- * When a FXNodeBlending appears, it receives both the current mask (via
- * EXPRESSION_CURRENT_VALUE_PLACEHOLDER) and the current color (via
- * EXPRESSION_CURRENT_COLOR_PLACEHOLDER), and returns the new mask value. Color nodes
- * that follow a blending node do not affect the mask.
- */
-function buildAlbedoAndBlendingCode(albedoNodes, blending, useAlphaHashing) {
-    if (albedoNodes.length === 0) {
-        return { mapFragment: null, premultChunk: buildPremultChunk(blending, false) };
-    }
-    const hasBlendingNodes = albedoNodes.some((node) => node instanceof FXNodeBlending);
-    const lines = [];
-    lines.push("vec4 fxAlbedo = vec4(1.0);");
-    if (hasBlendingNodes) {
-        lines.push("float fxBlendMask = 1.0;");
-    }
-    for (const node of albedoNodes) {
-        if (node instanceof FXNodeBlending) {
-            lines.push(`fxBlendMask = ${node.blendingExpression
-                .replace(CURRENT_EXPRESSION_VALUE_PLACEHOLDER, "fxBlendMask")
-                .replace(BLENDING_EXPRESSION_CURRENT_COLOR_PLACEHOLDER, "fxAlbedo")};`);
-        }
-        else {
-            lines.push(`fxAlbedo = ${node.colorExpression.replace(CURRENT_EXPRESSION_VALUE_PLACEHOLDER, "fxAlbedo")};`);
-        }
-    }
-    const discardLine = useAlphaHashing ? "" : "if (diffuseColor.a < 0.0035) discard;";
-    lines.push(`diffuseColor = fxAlbedo; ${discardLine}`);
-    return {
-        mapFragment: lines.join("\n"),
-        premultChunk: buildPremultChunk(blending, hasBlendingNodes),
-    };
-}
-function buildPremultChunk(blending, hasBlendingNodes) {
-    if (!hasBlendingNodes) {
-        return `gl_FragColor.rgb *= gl_FragColor.a;`;
-    }
-    if (blending === FXBlending.MASKED_ADDITIVE) {
-        return `
-      gl_FragColor.rgb *= gl_FragColor.a;
-      gl_FragColor.a *= (1.0 - clamp(fxBlendMask, 0.0, 1.0));
-    `;
-    }
-    // MASKED_MULTIPLY: dark areas darken destination, bright areas normal-blend
-    return `
-    gl_FragColor.rgb *= gl_FragColor.a;
-    float fxLumPremult = dot(gl_FragColor.rgb, vec3(0.2126, 0.7152, 0.0722));
-    vec4 fxMultiply = vec4(0.0, 0.0, 0.0, gl_FragColor.a - fxLumPremult);
-    gl_FragColor = mix(gl_FragColor, fxMultiply, clamp(fxBlendMask, 0.0, 1.0));
-  `;
-}
-
-export { buildAlbedoAndBlendingCode };

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

@@ -1,4 +0,0 @@
-import { MeshDepthMaterial } from "three";
-import type { FXNodeColor } from "../../nodes/color/FXNodeColor";
-import type { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
-export declare function buildDepthMaterial(albedoNodes: readonly (FXNodeColor | FXNodeTexture)[], depthAlphaTest: number, useDepthAlphaHash: boolean, useSphericalDepth: boolean): MeshDepthMaterial;

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

@@ -1,144 +0,0 @@
-import { MeshDepthMaterial, DoubleSide, RGBADepthPacking } from 'three';
-import { PARTICLE_DEFINES } from '../../miscellaneous/miscellaneous.js';
-import { CURRENT_EXPRESSION_VALUE_PLACEHOLDER } from '../../nodes/FXNode.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 vCenterViewZ;
-
-  #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 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
-    );
-
-    vec3 particleCenter = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z);
-    vec4 modelViewPosition = modelViewMatrix * vec4(particleCenter, 1.0);
-    vCenterViewZ = modelViewPosition.z;
-    modelViewPosition.xy += billboardOffset;
-    gl_Position = projectionMatrix * modelViewPosition;
-    vHighPrecisionZW = gl_Position.zw;
-  }
-`;
-/**
- * GLSL snippet that replaces the flat `fragCoordZ` with a spherical depth
- * approximation. Treats each billboard as the front hemisphere of a sphere
- * whose radius equals half the smaller particle scale dimension. Fragments
- * outside that radius are discarded, producing a circular silhouette.
- *
- * Expects `vCenterViewZ` (view-space Z of the particle center), `p_uv`,
- * `PARTICLE_SCALE_X / Y`, and `projectionMatrix` to be available.
- */
-const SPHERICAL_DEPTH_FRAG_COORD_Z = `
-  float sphereOffsetX = (p_uv.x - 0.5) * PARTICLE_SCALE_X;
-  float sphereOffsetY = (p_uv.y - 0.5) * PARTICLE_SCALE_Y;
-  float sphereRadius = min(PARTICLE_SCALE_X, PARTICLE_SCALE_Y) * 0.5;
-  float squaredDistanceFromCenter = sphereOffsetX * sphereOffsetX + sphereOffsetY * sphereOffsetY;
-  if (squaredDistanceFromCenter > sphereRadius * sphereRadius) discard;
-
-  float sphereViewZ = vCenterViewZ + sqrt(sphereRadius * sphereRadius - squaredDistanceFromCenter);
-  float projectedZ = projectionMatrix[2][2] * sphereViewZ + projectionMatrix[3][2];
-  float projectedW = projectionMatrix[2][3] * sphereViewZ + projectionMatrix[3][3];
-  float normalizedDeviceZ = projectedZ / projectedW;
-
-  #ifdef USE_REVERSEDEPTHBUF
-    float fragCoordZ = normalizedDeviceZ;
-  #else
-    float fragCoordZ = 0.5 * normalizedDeviceZ + 0.5;
-  #endif
-`;
-const FRAG_COORD_Z_PATTERN = /float fragCoordZ\b[^;]*;/;
-function buildDepthMaterial(albedoNodes, depthAlphaTest, useDepthAlphaHash, useSphericalDepth) {
-    const depthNodes = albedoNodes.filter((node) => node.affectsDepth);
-    const needsFragmentPatch = depthNodes.length > 0 || useSphericalDepth;
-    const material = new MeshDepthMaterial({
-        name: "FXDepthMaterial",
-        depthPacking: RGBADepthPacking,
-        side: DoubleSide,
-        forceSinglePass: true,
-        alphaHash: useDepthAlphaHash,
-    });
-    material.onBeforeCompile = (shader) => {
-        shader.vertexShader = DEPTH_VERTEX_SHADER;
-        if (!needsFragmentPatch) {
-            return;
-        }
-        const seenCacheKeys = new Set();
-        const uniqueHelpers = depthNodes
-            .filter((node) => {
-            if (seenCacheKeys.has(node.cacheKey)) {
-                return false;
-            }
-            seenCacheKeys.add(node.cacheKey);
-            return true;
-        })
-            .map((node) => node.helperFunctions)
-            .join("\n");
-        const fragmentPreamble = [
-            PARTICLE_DEFINES,
-            "varying mat4 p_builtin;",
-            "varying vec2 p_uv;",
-            "varying float vCenterViewZ;",
-            useSphericalDepth ? "uniform mat4 projectionMatrix;" : "",
-            depthNodes.flatMap((node) => node.uniformDeclarations).join("\n"),
-            uniqueHelpers,
-        ].join("\n");
-        for (const node of depthNodes) {
-            Object.assign(shader.uniforms, node.uniforms);
-        }
-        let fragmentShader = shader.fragmentShader;
-        if (depthNodes.length > 0) {
-            const albedoLines = ["vec4 fxDepthAlbedo = vec4(1.0);"];
-            for (const node of depthNodes) {
-                albedoLines.push(`fxDepthAlbedo = ${node.colorExpression.replace(CURRENT_EXPRESSION_VALUE_PLACEHOLDER, "fxDepthAlbedo")};`);
-            }
-            albedoLines.push(`diffuseColor.a = fxDepthAlbedo.a;`);
-            albedoLines.push(`if (diffuseColor.a < ${depthAlphaTest.toFixed(4)}) discard;`);
-            fragmentShader = fragmentShader.replace("#include <map_fragment>", albedoLines.join("\n"));
-        }
-        if (useSphericalDepth) {
-            if (!FRAG_COORD_Z_PATTERN.test(fragmentShader)) {
-                console.warn("FXDepthMaterial: could not find 'float fragCoordZ' in the depth fragment shader. " +
-                    "Spherical depth will not be applied. " +
-                    "This may indicate a Three.js version mismatch.");
-            }
-            else {
-                fragmentShader = fragmentShader.replace(FRAG_COORD_Z_PATTERN, SPHERICAL_DEPTH_FRAG_COORD_Z);
-            }
-        }
-        shader.fragmentShader = fragmentPreamble + "\n" + fragmentShader;
-    };
-    material.customProgramCacheKey = () => `fx-depth-${useDepthAlphaHash ? "alphaHash" : "alphaTest"}-${useSphericalDepth ? "spherical" : "flat"}-${depthNodes.map((node) => node.cacheKey).join("-") || "none"}`;
-    return material;
-}
-
-export { buildDepthMaterial };

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

@@ -1,4 +0,0 @@
-import { MeshDistanceMaterial } from "three";
-import type { FXNodeColor } from "../../nodes/color/FXNodeColor";
-import type { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
-export declare function buildDistanceMaterial(albedoNodes: readonly (FXNodeColor | FXNodeTexture)[], distanceAlphaTest: number, useDistanceAlphaHash: boolean, useSphericalDepth: boolean): MeshDistanceMaterial;

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

@@ -1,175 +0,0 @@
-import { MeshDistanceMaterial, DoubleSide } from 'three';
-import { PARTICLE_DEFINES } from '../../miscellaneous/miscellaneous.js';
-import { CURRENT_EXPRESSION_VALUE_PLACEHOLDER } from '../../nodes/FXNode.js';
-
-/**
- * Custom vertex shader for point/spot light shadow maps.
- *
- * Unlike the depth material (which writes clip-space Z for directional light
- * shadows), the distance material writes the world-space distance from each
- * fragment to the light position. This means we need to reconstruct world
- * position for each billboarded vertex.
- *
- * `vWorldPosition` is a Three.js convention consumed by the distance fragment
- * shader. `viewMatrix` here is the shadow camera's view matrix, so the
- * billboard faces the light - which is correct for shadow shape.
- */
-const DISTANCE_VERTEX_SHADER = `
-  #define DISTANCE
-
-  #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 vec3 vWorldPosition;
-
-  #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 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
-    );
-
-    vec3 particleCenter = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z);
-
-    // Reconstruct world-space position for the billboarded vertex.
-    // Camera axes are extracted from the shadow camera's view matrix (transposed
-    // rotation part), then scaled by the billboard offset.
-    vec3 cameraRight = vec3(viewMatrix[0][0], viewMatrix[1][0], viewMatrix[2][0]);
-    vec3 cameraUp    = vec3(viewMatrix[0][1], viewMatrix[1][1], viewMatrix[2][1]);
-    vec3 worldCenter = (modelMatrix * vec4(particleCenter, 1.0)).xyz;
-    vWorldPosition = worldCenter + cameraRight * billboardOffset.x + cameraUp * billboardOffset.y;
-
-    // Standard clip-space projection via the shadow camera.
-    vec4 modelViewPosition = modelViewMatrix * vec4(particleCenter, 1.0);
-    modelViewPosition.xy += billboardOffset;
-    gl_Position = projectionMatrix * modelViewPosition;
-  }
-`;
-/**
- * GLSL snippet for spherical distance adjustment.
- *
- * Instead of measuring distance from the flat billboard surface, this
- * approximates the front hemisphere of a sphere. The sphere radius is half
- * the smaller scale dimension. Fragments outside the sphere are discarded.
- *
- * The depth offset is subtracted from the flat distance, bringing the
- * perceived surface closer to the light. This is an approximation - the
- * true offset direction depends on the light-to-fragment vector, not the
- * camera-to-fragment vector - but for smoke particles the error is
- * negligible.
- */
-const SPHERICAL_DISTANCE_SNIPPET = `
-  {
-    float sphereOffsetX = (p_uv.x - 0.5) * PARTICLE_SCALE_X;
-    float sphereOffsetY = (p_uv.y - 0.5) * PARTICLE_SCALE_Y;
-    float sphereRadius = min(PARTICLE_SCALE_X, PARTICLE_SCALE_Y) * 0.5;
-    float squaredDistanceFromCenter = sphereOffsetX * sphereOffsetX + sphereOffsetY * sphereOffsetY;
-    if (squaredDistanceFromCenter > sphereRadius * sphereRadius) discard;
-    float sphereDepthOffset = sqrt(sphereRadius * sphereRadius - squaredDistanceFromCenter);
-    dist = max(0.0, dist - sphereDepthOffset);
-  }
-`;
-const DISTANCE_CALCULATION_PATTERN = /float\s+dist\s*=\s*length\s*\(\s*vWorldPosition\s*-\s*referencePosition\s*\)\s*;/;
-function buildDistanceMaterial(albedoNodes, distanceAlphaTest, useDistanceAlphaHash, useSphericalDepth) {
-    const distanceNodes = albedoNodes.filter((node) => node.affectsDepth);
-    const needsFragmentPatch = distanceNodes.length > 0 || useSphericalDepth;
-    const material = new MeshDistanceMaterial({
-        name: "FXDistanceMaterial",
-        side: DoubleSide,
-        forceSinglePass: true,
-        alphaHash: useDistanceAlphaHash,
-    });
-    material.onBeforeCompile = (shader) => {
-        shader.vertexShader = DISTANCE_VERTEX_SHADER;
-        if (!needsFragmentPatch) {
-            return;
-        }
-        const seenCacheKeys = new Set();
-        const uniqueHelpers = distanceNodes
-            .filter((node) => {
-            if (seenCacheKeys.has(node.cacheKey)) {
-                return false;
-            }
-            seenCacheKeys.add(node.cacheKey);
-            return true;
-        })
-            .map((node) => node.helperFunctions)
-            .join("\n");
-        const fragmentPreamble = [
-            PARTICLE_DEFINES,
-            "varying mat4 p_builtin;",
-            "varying vec2 p_uv;",
-            distanceNodes.flatMap((node) => node.uniformDeclarations).join("\n"),
-            uniqueHelpers,
-        ].join("\n");
-        for (const node of distanceNodes) {
-            Object.assign(shader.uniforms, node.uniforms);
-        }
-        let fragmentShader = shader.fragmentShader;
-        // Alpha from nodes - MeshDistanceMaterial may or may not include
-        // <map_fragment> depending on the Three.js version. If the chunk is
-        // absent, insert the alpha discard before the distance calculation.
-        if (distanceNodes.length > 0) {
-            const albedoLines = ["vec4 fxDistAlbedo = vec4(1.0);"];
-            for (const node of distanceNodes) {
-                albedoLines.push(`fxDistAlbedo = ${node.colorExpression.replace(CURRENT_EXPRESSION_VALUE_PLACEHOLDER, "fxDistAlbedo")};`);
-            }
-            albedoLines.push(`float nodeAlpha = fxDistAlbedo.a;`);
-            const alphaDiscardCode = albedoLines.join("\n") + `\nif (nodeAlpha < ${distanceAlphaTest.toFixed(4)}) discard;`;
-            if (fragmentShader.includes("#include <map_fragment>")) {
-                fragmentShader = fragmentShader.replace("#include <map_fragment>", alphaDiscardCode);
-            }
-            else if (DISTANCE_CALCULATION_PATTERN.test(fragmentShader)) {
-                // Fallback: inject alpha discard just before the distance calculation.
-                fragmentShader = fragmentShader.replace(DISTANCE_CALCULATION_PATTERN, (match) => alphaDiscardCode + "\n" + match);
-            }
-            else {
-                console.warn("FXDistanceMaterial: could not find a suitable injection point for alpha discard. " +
-                    "This may indicate a Three.js version mismatch.");
-            }
-        }
-        // Spherical distance adjustment - offset the flat-billboard distance by
-        // the sphere's front surface depth.
-        if (useSphericalDepth) {
-            if (!DISTANCE_CALCULATION_PATTERN.test(fragmentShader)) {
-                console.warn("FXDistanceMaterial: could not find the distance calculation line. " +
-                    "Spherical depth will not be applied. " +
-                    "This may indicate a Three.js version mismatch.");
-            }
-            else {
-                // Inject the spherical adjustment right after the distance calculation.
-                fragmentShader = fragmentShader.replace(DISTANCE_CALCULATION_PATTERN, (match) => match + "\n" + SPHERICAL_DISTANCE_SNIPPET);
-            }
-        }
-        shader.fragmentShader = fragmentPreamble + "\n" + fragmentShader;
-    };
-    material.customProgramCacheKey = () => `fx-distance-${useDistanceAlphaHash ? "alphaHash" : "alphaTest"}-${useSphericalDepth ? "spherical" : "flat"}-${distanceNodes.map((node) => node.cacheKey).join("-") || "none"}`;
-    return material;
-}
-
-export { buildDistanceMaterial };

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

@@ -1,70 +0,0 @@
-import { FXNodeColor } from "../../nodes/color/FXNodeColor";
-import { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
-/**
- * Per-particle blend mode used when compositing particles into the scene
- */
-export declare enum FXBlending {
-    /**
-     * Premultiplied additive blend - particle color is pre-multiplied by alpha and added to the
-     * destination with zero alpha contribution
-     */
-    MASKED_ADDITIVE = 0,
-    /**
-     * Luminance-aware multiply blend - dark areas darken the destination while bright areas
-     * normal-blend through a mask
-     */
-    MASKED_MULTIPLY = 1
-}
-/**
- * Configuration options shared by all {@link FXMaterial} subclasses
- */
-export interface FXMaterialOptions {
-    /**
-     * Color and texture nodes composited for particle color
-     *
-     * @defaultValue `[]`
-     */
-    albedoNodes: (FXNodeColor | FXNodeTexture)[];
-    blending: FXBlending;
-    /**
-     * Use alpha hashing instead of standard transparency
-     *
-     * @defaultValue `false`
-     */
-    useAlphaHashing: boolean;
-    /**
-     * Alpha cutoff threshold for color passes
-     *
-     * @defaultValue `0.0075`
-     */
-    alphaTest: number;
-    /**
-     * Alpha cutoff threshold for depth and shadow passes
-     *
-     * @defaultValue `0.5`
-     */
-    depthAlphaTest: number;
-    /**
-     * Use alpha hashing in depth and shadow passes
-     *
-     * @defaultValue `false`
-     */
-    useDepthAlphaHash: boolean;
-    /**
-     * Approximate spherical depth for shadow maps
-     *
-     * @defaultValue `true`
-     */
-    useSphericalDepth: boolean;
-}
-/**
- * Abstract base class for particle materials
- */
-export declare abstract class FXMaterial {
-    private readonly depthAlphaTest;
-    private readonly useDepthAlphaHash;
-    private readonly useSphericalDepth;
-    constructor(options?: Partial<FXMaterialOptions>);
-    /** Releases resources held by all albedo nodes */
-    destroy(): void;
-}

package/dist/materials/FXMaterial/FXMaterial.js

@@ -1,51 +0,0 @@
-import { FXNodeColor } from '../../nodes/color/FXNodeColor.js';
-import { FXNodeTexture } from '../../nodes/texture/FXNodeTexture.js';
-import { buildDepthMaterial } from './FXDepthMaterial.Internal.js';
-import { buildDistanceMaterial } from './FXDistanceMaterial.Internal.js';
-
-/**
- * Per-particle blend mode used when compositing particles into the scene
- */
-var FXBlending;
-(function (FXBlending) {
-    /**
-     * Premultiplied additive blend - particle color is pre-multiplied by alpha and added to the
-     * destination with zero alpha contribution
-     */
-    FXBlending[FXBlending["MASKED_ADDITIVE"] = 0] = "MASKED_ADDITIVE";
-    /**
-     * Luminance-aware multiply blend - dark areas darken the destination while bright areas
-     * normal-blend through a mask
-     */
-    FXBlending[FXBlending["MASKED_MULTIPLY"] = 1] = "MASKED_MULTIPLY";
-})(FXBlending || (FXBlending = {}));
-/**
- * Abstract base class for particle materials
- */
-class FXMaterial {
-    constructor(options = {}) {
-        this.albedoNodes = options.albedoNodes ?? [];
-        this.blending = options.blending ?? FXBlending.MASKED_ADDITIVE;
-        this.useAlphaHashing = options.useAlphaHashing ?? false;
-        this.alphaTest = options.alphaTest ?? 0.0075;
-        this._private_depthAlphaTest = options.depthAlphaTest ?? 0.5;
-        this._private_useDepthAlphaHash = options.useDepthAlphaHash ?? false;
-        this._private_useSphericalDepth = options.useSphericalDepth ?? true;
-    }
-    /** Releases resources held by all albedo nodes */
-    destroy() {
-        for (const node of this.albedoNodes) {
-            node.destroy?.();
-        }
-    }
-    /** @internal */
-    buildDepthMaterial() {
-        return buildDepthMaterial(this.albedoNodes.filter((node) => node instanceof FXNodeColor || node instanceof FXNodeTexture), this._private_depthAlphaTest, this._private_useDepthAlphaHash, this._private_useSphericalDepth);
-    }
-    /** @internal */
-    buildDistanceMaterial() {
-        return buildDistanceMaterial(this.albedoNodes.filter((node) => node instanceof FXNodeColor || node instanceof FXNodeTexture), this._private_depthAlphaTest, this._private_useDepthAlphaHash, this._private_useSphericalDepth);
-    }
-}
-
-export { FXBlending, FXMaterial };

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

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