sparcoon 0.7.3 → 0.9.1

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

@@ -1,275 +0,0 @@
-import { MeshLambertMaterial, Color, DoubleSide, NormalBlending } from 'three';
-import { PARTICLE_DEFINES } from '../../miscellaneous/miscellaneous.js';
-import { FXNodeColor } from '../../nodes/color/FXNodeColor.js';
-import { CURRENT_EXPRESSION_VALUE_PLACEHOLDER } from '../../nodes/FXNode.js';
-import { FXNodeTexture } from '../../nodes/texture/FXNodeTexture.js';
-import { buildAlbedoAndBlendingCode } from '../FXMaterial/FXBlending.Internal.js';
-import { FXBlending } from '../FXMaterial/FXMaterial.js';
-
-/**
- * Wraps every `getShadow(...)` call in the shader source with
- * `mix(1.0, getShadow(...), <uniformName>)` so that a uniform
- * can scale shadow influence from 0 (no shadows) to 1 (full shadows).
- */
-function wrapShadowCalls(source, uniformName) {
-    const target = "getShadow(";
-    let result = "";
-    let position = 0;
-    while (position < source.length) {
-        const callStart = source.indexOf(target, position);
-        if (callStart === -1) {
-            result += source.slice(position);
-            break;
-        }
-        result += source.slice(position, callStart);
-        let depth = 0;
-        let cursor = callStart + target.length - 1;
-        for (; cursor < source.length; cursor++) {
-            if (source[cursor] === "(") {
-                depth++;
-            }
-            if (source[cursor] === ")") {
-                depth--;
-            }
-            if (depth === 0) {
-                break;
-            }
-        }
-        const originalCall = source.slice(callStart, cursor + 1);
-        result += `mix(1.0, ${originalCall}, ${uniformName})`;
-        position = cursor + 1;
-    }
-    return result;
-}
-function buildFXDiffuseMaterial(varyings, blending, useAlphaHashing, alphaTest, albedoNodes, normalNodes, emissionNodes, scatterUniforms, shadowSensitivity) {
-    const useScatter = scatterUniforms !== undefined;
-    const useShadowSensitivity = shadowSensitivity !== undefined;
-    const useNormals = normalNodes.length > 0;
-    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({
-        name: "FXDiffuseMaterial",
-        transparent: !useAlphaHashing,
-        depthWrite: useAlphaHashing,
-        depthTest: true,
-        alphaHash: useAlphaHashing,
-        blending: NormalBlending,
-        side: DoubleSide,
-        forceSinglePass: true,
-        alphaTest,
-        emissive: emissionNodes.length > 0 ? new Color(1, 1, 1) : new Color(0, 0, 0),
-        premultipliedAlpha: true,
-    });
-    material.onBeforeCompile = (shader) => {
-        const vertexPreamble = [
-            PARTICLE_DEFINES,
-            attributeDeclarations.join("\n"),
-            "varying vec2 p_uv;",
-            useNormals ? "varying vec2 p_billboardSinCos;" : "",
-            useScatter ? "varying vec3 v_viewPosition;" : "",
-            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 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",
-                    ");",
-                    "",
-                    // Pass the exact sin/cos that rotated the billboard to the fragment shader.
-                    useNormals ? "p_billboardSinCos = vec2(sinRotation, cosRotation);" : "",
-                    "",
-                    "vec3 particleCenter = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z);",
-                    "vec4 mvPosition = modelViewMatrix * vec4(particleCenter, 1.0);",
-                    "mvPosition.xy += billboardOffset;",
-                    useScatter ? "v_viewPosition = mvPosition.xyz;" : "",
-                    "gl_Position = projectionMatrix * mvPosition;",
-                ].join("\n"))
-                    .replace("#include <worldpos_vertex>", `
-          #if defined(USE_SHADOWMAP) || defined(USE_ENVMAP) || defined(DISTANCE) || (NUM_SPOT_LIGHT_COORDS > 0)
-            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 seenCacheKeys = new Set();
-        const uniqueHelpers = (nodes) => nodes
-            .filter((node) => {
-            if (seenCacheKeys.has(node.cacheKey)) {
-                return false;
-            }
-            seenCacheKeys.add(node.cacheKey);
-            return true;
-        })
-            .map((node) => node.helperFunctions)
-            .join("\n");
-        const scatterDeclarations = useScatter
-            ? [
-                "varying vec3 v_viewPosition;",
-                "uniform vec3 u_ScatterTint;",
-                "uniform float u_ScatterPower;",
-                "uniform float u_ForwardScatterStrength;",
-                "uniform float u_BackScatterStrength;",
-                `vec3 calculateScatter(vec3 viewDirection, vec3 lightDirection, vec3 lightColor, float alpha) {
-            float viewDotLight = dot(viewDirection, lightDirection);
-            float scatterForward  = pow(max(-viewDotLight, 0.0), u_ScatterPower) * u_ForwardScatterStrength;
-            float scatterBackward = pow(max( viewDotLight, 0.0), 2.0) * u_BackScatterStrength;
-            return lightColor * u_ScatterTint * (scatterForward + scatterBackward) * alpha;
-          }`,
-            ]
-            : [];
-        const shadowSensitivityDeclarations = useShadowSensitivity
-            ? ["uniform float u_shadowSensitivity;"]
-            : [];
-        const fragmentPreamble = [
-            PARTICLE_DEFINES,
-            "varying vec2 p_uv;",
-            useNormals ? "varying vec2 p_billboardSinCos;" : "",
-            varyingDeclarations.join("\n"),
-            albedoNodes.flatMap((node) => node.uniformDeclarations).join("\n"),
-            uniqueHelpers(albedoNodes),
-            normalNodes.flatMap((node) => node.uniformDeclarations).join("\n"),
-            uniqueHelpers(normalNodes),
-            emissionNodes.flatMap((node) => node.uniformDeclarations).join("\n"),
-            uniqueHelpers(emissionNodes),
-            ...scatterDeclarations,
-            ...shadowSensitivityDeclarations,
-        ].join("\n");
-        if (useScatter) {
-            shader.uniforms["u_ScatterTint"] = scatterUniforms.u_ScatterTint;
-            shader.uniforms["u_ScatterPower"] = scatterUniforms.u_ScatterPower;
-            shader.uniforms["u_ForwardScatterStrength"] = scatterUniforms.u_ForwardScatterStrength;
-            shader.uniforms["u_BackScatterStrength"] = scatterUniforms.u_BackScatterStrength;
-        }
-        if (useShadowSensitivity) {
-            shader.uniforms["u_shadowSensitivity"] = shadowSensitivity;
-        }
-        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 (useNormals) {
-            const normalLines = [
-                "float faceDirection = gl_FrontFacing ? 1.0 : -1.0;",
-                "vec3 fxNormal = vec3(0.0, 0.0, 1.0);",
-            ];
-            for (const node of normalNodes) {
-                if (node instanceof FXNodeTexture || node instanceof FXNodeColor) {
-                    normalLines.push(`fxNormal = normalize((${node.colorExpression.replace(CURRENT_EXPRESSION_VALUE_PLACEHOLDER, "vec4(fxNormal, 1.0)")}).rgb * 2.0 - 1.0);`);
-                }
-                else {
-                    normalLines.push(`fxNormal = ${node.normalExpression.replace(CURRENT_EXPRESSION_VALUE_PLACEHOLDER, "fxNormal")};`);
-                }
-            }
-            normalLines.push("", "float sinR = p_billboardSinCos.x;", "float cosR = p_billboardSinCos.y;", "vec3 normal = vec3(", "  fxNormal.x * cosR - fxNormal.y * sinR,", "  fxNormal.x * sinR + fxNormal.y * cosR,", "  fxNormal.z", ");", "", "normal *= faceDirection;");
-            fragmentShader = fragmentShader.replace("#include <normal_fragment_begin>", normalLines.join("\n"));
-        }
-        const albedoCode = buildAlbedoAndBlendingCode(albedoNodes, blending, useAlphaHashing);
-        if (albedoCode.mapFragment !== null) {
-            fragmentShader = fragmentShader.replace("#include <map_fragment>", albedoCode.mapFragment);
-        }
-        if (emissionNodes.length > 0) {
-            const emissiveLines = ["vec4 fxEmissive = vec4(1.0);"];
-            for (const node of emissionNodes) {
-                emissiveLines.push(`fxEmissive = ${node.colorExpression.replace(CURRENT_EXPRESSION_VALUE_PLACEHOLDER, "fxEmissive")};`);
-            }
-            emissiveLines.push("totalEmissiveRadiance = fxEmissive.rgb;");
-            fragmentShader = fragmentShader.replace("#include <emissivemap_fragment>", emissiveLines.join("\n"));
-        }
-        if (useScatter) {
-            fragmentShader = fragmentShader.replace("#include <opaque_fragment>", `
-        #ifdef OPAQUE
-          diffuseColor.a = 1.0;
-        #endif
-
-        vec3 viewDirection = normalize(-v_viewPosition);
-        vec3 totalScatter = vec3(0.0);
-
-        #if NUM_DIR_LIGHTS > 0
-          for (int i = 0; i < NUM_DIR_LIGHTS; i++) {
-            totalScatter += calculateScatter(viewDirection, directionalLights[i].direction, directionalLights[i].color, diffuseColor.a);
-          }
-        #endif
-
-        #if NUM_POINT_LIGHTS > 0
-          for (int i = 0; i < NUM_POINT_LIGHTS; i++) {
-            vec3 toLightDirection = normalize(pointLights[i].position - v_viewPosition);
-            float lightDistance = length(pointLights[i].position - v_viewPosition);
-            float attenuation = 1.0 / (1.0 + 0.09 * lightDistance + 0.032 * lightDistance * lightDistance);
-            totalScatter += calculateScatter(viewDirection, toLightDirection, pointLights[i].color, diffuseColor.a) * attenuation;
-          }
-        #endif
-
-        #if NUM_SPOT_LIGHTS > 0
-          for (int i = 0; i < NUM_SPOT_LIGHTS; i++) {
-            vec3 toLightDirection = normalize(spotLights[i].position - v_viewPosition);
-            float lightDistance = length(spotLights[i].position - v_viewPosition);
-            float attenuation = 1.0 / (1.0 + 0.09 * lightDistance + 0.032 * lightDistance * lightDistance);
-            float spotCosine = dot(normalize(spotLights[i].direction), -toLightDirection);
-            float spotFalloff = smoothstep(spotLights[i].coneCos, spotLights[i].penumbraCos, spotCosine);
-            totalScatter += calculateScatter(viewDirection, toLightDirection, spotLights[i].color, diffuseColor.a) * attenuation * spotFalloff;
-          }
-        #endif
-
-        vec3 albedo = diffuseColor.a > 0.001
-            ? diffuseColor.rgb / diffuseColor.a
-            : vec3(0.0);
-        gl_FragColor = vec4(outgoingLight + totalScatter * albedo, diffuseColor.a);
-        `);
-        }
-        if (useShadowSensitivity) {
-            fragmentShader = wrapShadowCalls(fragmentShader, "u_shadowSensitivity");
-        }
-        fragmentShader = fragmentShader.replace("#include <premultiplied_alpha_fragment>", albedoCode.premultChunk);
-        shader.fragmentShader = fragmentPreamble + "\n" + fragmentShader;
-    };
-    const scatterKey = useScatter ? `scatter(${scatterUniforms.u_ScatterPower.value})` : "no-scatter";
-    const shadowKey = useShadowSensitivity ? "shadow-sens" : "no-shadow-sens";
-    material.customProgramCacheKey = () => [
-        "fx",
-        albedoNodes.map((node) => node.cacheKey).join("-") || "none",
-        normalNodes.map((node) => node.cacheKey).join("-") || "none",
-        emissionNodes.map((node) => node.cacheKey).join("-") || "none",
-        FXBlending[blending],
-        scatterKey,
-        shadowKey,
-    ].join("_");
-    return material;
-}
-
-export { buildFXDiffuseMaterial };

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

@@ -1,75 +0,0 @@
-import type { ColorRepresentation } from "three";
-import type { FXNodeColor } from "../../nodes/color/FXNodeColor";
-import type { FXNodeNormal } from "../../nodes/normal/FXNodeNormal";
-import type { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
-import type { FXMaterialOptions } from "../FXMaterial/FXMaterial";
-import { FXMaterial } from "../FXMaterial/FXMaterial";
-/**
- * Configuration options for {@link FXDiffuseMaterial}
- */
-export interface FXDiffuseMaterialOptions extends FXMaterialOptions {
-    /**
-     * Normal nodes for lighting; multiple nodes are blended together
-     *
-     * @defaultValue `[new FXNodeSphericalNormal()]`
-     */
-    normalNodes: (FXNodeTexture | FXNodeNormal)[];
-    /**
-     * Emission color nodes composited for emissive output
-     *
-     * @defaultValue `[]`
-     */
-    emissionNodes: (FXNodeColor | FXNodeTexture)[];
-    /**
-     * Enable subsurface scattering approximation
-     *
-     * @defaultValue `false`
-     */
-    enableScatter: boolean;
-    /**
-     * Tint color applied to the scatter contribution
-     *
-     * @defaultValue `0xffd999`
-     */
-    scatterTint: ColorRepresentation;
-    /**
-     * Scatter lobe sharpness; higher values produce a tighter highlight
-     *
-     * @defaultValue `10`
-     */
-    scatterPower: number;
-    /**
-     * Forward scatter intensity (light-facing side)
-     *
-     * @defaultValue `1`
-     */
-    forwardScatterStrength: number;
-    /**
-     * Back scatter intensity (back-lit side)
-     *
-     * @defaultValue `1`
-     */
-    backScatterStrength: number;
-    /**
-     * Shadow influence (`0` = no shadows, `1` = full shadows)
-     *
-     * @defaultValue `1`
-     */
-    shadowSensitivity: number;
-}
-/**
- * Diffuse particle material with lighting, normals, emission, and optional subsurface scattering
- */
-export declare class FXDiffuseMaterial extends FXMaterial {
-    private readonly normalNodes;
-    private readonly emissionNodes;
-    private readonly scatterUniforms;
-    private readonly shadowSensitivity;
-    /**
-     * @param options - Material configuration
-     */
-    constructor(options?: Partial<FXDiffuseMaterialOptions>);
-    /** Releases resources held by all albedo, normal, and emission nodes */
-    destroy(): void;
-    prepare(): void;
-}

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;