sparcoon 0.7.2 → 0.9.0

package/dist/emitter/spawn/FXSpawnTorque.js

@@ -1,42 +0,0 @@
-import { MathUtils } from 'three';
-import { assertValidNumber } from '../../miscellaneous/asserts.js';
-import { resolveFXRangeConfig, BUILTIN_OFFSET_TORQUE } from '../../miscellaneous/miscellaneous.js';
-import { FXSpawn } from './FXSpawn.js';
-
-/**
- * Assigns a random initial angular velocity to each spawned particle
- */
-class FXSpawnTorque extends FXSpawn {
-    /**
-     * @param torque - Angular velocity range in radians/second. Defaults to `{ min: -Math.PI, max: Math.PI }`
-     */
-    constructor(torque = { min: -Math.PI, max: Math.PI }) {
-        super();
-        /** @internal */
-        this.requiredProperties = { builtin: "Matrix4" };
-        this._private_torqueInternal = resolveFXRangeConfig(torque);
-        assertValidNumber(this._private_torqueInternal.min, "FXSpawnTorque.constructor.torque.min");
-        assertValidNumber(this._private_torqueInternal.max, "FXSpawnTorque.constructor.torque.max");
-    }
-    /** Angular velocity range in radians/second */
-    get torque() {
-        return this._private_torqueInternal;
-    }
-    set torque(value) {
-        this._private_torqueInternal = resolveFXRangeConfig(value);
-        assertValidNumber(this._private_torqueInternal.min, "FXSpawnTorque.torque.min");
-        assertValidNumber(this._private_torqueInternal.max, "FXSpawnTorque.torque.max");
-    }
-    /** @internal */
-    spawn(properties, instanceBegin, instanceEnd) {
-        const { builtin } = properties;
-        const { array, itemSize } = builtin;
-        const { min: torqueMin, max: torqueMax } = this._private_torqueInternal;
-        for (let i = instanceBegin; i < instanceEnd; i++) {
-            array[i * itemSize + BUILTIN_OFFSET_TORQUE] = MathUtils.randFloat(torqueMin, torqueMax);
-        }
-        builtin.needsUpdate = true;
-    }
-}
-
-export { FXSpawnTorque };

package/dist/emitter/spawn/FXSpawnVelocity.d.ts

@@ -1,29 +0,0 @@
-import { Vector3 } from "three";
-import type { FXRange, FXRangeConfig } from "../../miscellaneous/miscellaneous";
-import { FXSpawn } from "./FXSpawn";
-/**
- * Assigns a random initial velocity to each spawned particle within a cone around a direction axis
- */
-export declare class FXSpawnVelocity extends FXSpawn<{
-    builtin: "Matrix4";
-}> {
-    private angleInternal;
-    private magnitudeInternal;
-    private readonly directionInternal;
-    /**
-     * @param direction - Cone axis; normalized automatically. Defaults to `(0, 1, 0)`
-     * @param angle - Cone half-angle range in radians; `{ min: 0, max: 0 }` fires in a straight line.
-     * Defaults to `{ min: 0, max: Math.PI }`
-     * @param magnitude - Speed range in units/second. Defaults to `{ min: -1, max: 1 }`
-     */
-    constructor(direction?: Vector3, angle?: FXRangeConfig, magnitude?: FXRangeConfig);
-    /** Cone axis (always normalized) */
-    get direction(): Vector3;
-    /** Cone half-angle range in radians */
-    get angle(): FXRange;
-    /** Speed range in units/second */
-    get magnitude(): FXRange;
-    set direction(value: Vector3);
-    set angle(value: FXRangeConfig);
-    set magnitude(value: FXRangeConfig);
-}

package/dist/emitter/spawn/FXSpawnVelocity.js

@@ -1,91 +0,0 @@
-import { Vector3, MathUtils } from 'three';
-import { assertValidNumber } from '../../miscellaneous/asserts.js';
-import { resolveFXRangeConfig, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z } from '../../miscellaneous/miscellaneous.js';
-import { FXSpawn } from './FXSpawn.js';
-
-const TEMP_TANGENT = new Vector3();
-const TEMP_BITANGENT = new Vector3();
-const TEMP_VELOCITY = new Vector3();
-/**
- * Assigns a random initial velocity to each spawned particle within a cone around a direction axis
- */
-class FXSpawnVelocity extends FXSpawn {
-    /**
-     * @param direction - Cone axis; normalized automatically. Defaults to `(0, 1, 0)`
-     * @param angle - Cone half-angle range in radians; `{ min: 0, max: 0 }` fires in a straight line.
-     * Defaults to `{ min: 0, max: Math.PI }`
-     * @param magnitude - Speed range in units/second. Defaults to `{ min: -1, max: 1 }`
-     */
-    constructor(direction = new Vector3(0, 1, 0), angle = { min: 0, max: Math.PI }, magnitude = { min: -1, max: 1 }) {
-        super();
-        /** @internal */
-        this.requiredProperties = { builtin: "Matrix4" };
-        this._private_directionInternal = direction.clone().normalize();
-        this._private_angleInternal = resolveFXRangeConfig(angle);
-        this._private_magnitudeInternal = resolveFXRangeConfig(magnitude);
-        assertValidNumber(this._private_angleInternal.min, "FXSpawnVelocity.constructor.angle.min");
-        assertValidNumber(this._private_angleInternal.max, "FXSpawnVelocity.constructor.angle.max");
-        assertValidNumber(this._private_magnitudeInternal.min, "FXSpawnVelocity.constructor.magnitude.min");
-        assertValidNumber(this._private_magnitudeInternal.max, "FXSpawnVelocity.constructor.magnitude.max");
-    }
-    /** Cone axis (always normalized) */
-    get direction() {
-        return this._private_directionInternal;
-    }
-    /** Cone half-angle range in radians */
-    get angle() {
-        return this._private_angleInternal;
-    }
-    /** Speed range in units/second */
-    get magnitude() {
-        return this._private_magnitudeInternal;
-    }
-    set direction(value) {
-        this._private_directionInternal.copy(value).normalize();
-    }
-    set angle(value) {
-        this._private_angleInternal = resolveFXRangeConfig(value);
-        assertValidNumber(this._private_angleInternal.min, "FXSpawnVelocity.angle.min");
-        assertValidNumber(this._private_angleInternal.max, "FXSpawnVelocity.angle.max");
-    }
-    set magnitude(value) {
-        this._private_magnitudeInternal = resolveFXRangeConfig(value);
-        assertValidNumber(this._private_magnitudeInternal.min, "FXSpawnVelocity.magnitude.min");
-        assertValidNumber(this._private_magnitudeInternal.max, "FXSpawnVelocity.magnitude.max");
-    }
-    /** @internal */
-    spawn(properties, instanceBegin, instanceEnd) {
-        const { builtin } = properties;
-        const { array, itemSize } = builtin;
-        const { min: angleMin, max: angleMax } = this._private_angleInternal;
-        const { min: magnitudeMin, max: magnitudeMax } = this._private_magnitudeInternal;
-        const dir = this._private_directionInternal;
-        if (Math.abs(dir.y) < 0.999) {
-            TEMP_TANGENT.set(0, 1, 0).cross(dir).normalize();
-        }
-        else {
-            TEMP_TANGENT.set(1, 0, 0).cross(dir).normalize();
-        }
-        TEMP_BITANGENT.crossVectors(dir, TEMP_TANGENT);
-        const cosMin = Math.cos(angleMax);
-        const cosMax = Math.cos(angleMin);
-        for (let i = instanceBegin; i < instanceEnd; i++) {
-            const itemOffset = i * itemSize;
-            const cosTheta = MathUtils.lerp(cosMin, cosMax, Math.random());
-            const sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
-            const phi = Math.random() * Math.PI * 2;
-            const magnitude = MathUtils.randFloat(magnitudeMin, magnitudeMax);
-            TEMP_VELOCITY.copy(dir)
-                .multiplyScalar(cosTheta)
-                .addScaledVector(TEMP_TANGENT, Math.cos(phi) * sinTheta)
-                .addScaledVector(TEMP_BITANGENT, Math.sin(phi) * sinTheta)
-                .multiplyScalar(magnitude);
-            array[itemOffset + BUILTIN_OFFSET_VELOCITY_X] = TEMP_VELOCITY.x;
-            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Y] = TEMP_VELOCITY.y;
-            array[itemOffset + BUILTIN_OFFSET_VELOCITY_Z] = TEMP_VELOCITY.z;
-        }
-        builtin.needsUpdate = true;
-    }
-}
-
-export { FXSpawnVelocity };

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

@@ -1,2 +0,0 @@
-import { InstancedBufferGeometry } from "three";
-export declare const INSTANCED_PARTICLE_GEOMETRY: InstancedBufferGeometry;

package/dist/instancedParticle/shared.d.ts

@@ -1,19 +0,0 @@
-import type { IUniform, ShaderMaterial } from "three";
-import { Matrix3, Matrix4, Texture, Vector2, Vector3, Vector4 } from "three";
-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;
-export type FXPropertyCopyTo = FXColor | Vector2 | Vector3 | Vector4 | Matrix3 | Matrix4;
-export type FXPropertyCopyFrom = FXColor & Vector2 & Vector3 & Vector4 & Matrix3 & Matrix4;
-export interface GLTypeInfo {
-    glslTypeName: string;
-    bufferSize: number;
-    instantiable: boolean;
-}
-export interface GLProperty {
-    value: FXProperty;
-    glslTypeInfo: GLTypeInfo;
-}
-export declare function resolveGLSLTypeInfo(value: FXProperty | FXPropertyName | FXPropertyConstructor): GLTypeInfo;
-export declare function resolvePropertyUniform(name: string, material: ShaderMaterial): IUniform<FXProperty>;

package/dist/instancedParticle/shared.js

@@ -1,116 +0,0 @@
-import { Texture, Vector2, Vector3, Vector4, Matrix3, Matrix4 } from 'three';
-import { FXColor } from '../miscellaneous/color/FXColor.js';
-
-const GLSL_TYPE_INFO_FLOAT = Object.freeze({
-    glslTypeName: "float",
-    bufferSize: 1,
-    instantiable: true,
-});
-const GLSL_TYPE_INFO_SAMPLER2D = Object.freeze({
-    glslTypeName: "sampler2D",
-    bufferSize: -1,
-    instantiable: false,
-});
-const GLSL_TYPE_INFO_VEC2 = Object.freeze({
-    glslTypeName: "vec2",
-    bufferSize: 2,
-    instantiable: true,
-});
-const GLSL_TYPE_INFO_VEC3 = Object.freeze({
-    glslTypeName: "vec3",
-    bufferSize: 3,
-    instantiable: true,
-});
-const GLSL_TYPE_INFO_VEC4 = Object.freeze({
-    glslTypeName: "vec4",
-    bufferSize: 4,
-    instantiable: true,
-});
-const GLSL_TYPE_INFO_MAT3 = Object.freeze({
-    glslTypeName: "mat3",
-    bufferSize: 9,
-    instantiable: true,
-});
-const GLSL_TYPE_INFO_MAT4 = Object.freeze({
-    glslTypeName: "mat4",
-    bufferSize: 16,
-    instantiable: true,
-});
-function resolveGLSLTypeInfo(value) {
-    if (typeof value === "string") {
-        switch (value) {
-            case "number":
-                return GLSL_TYPE_INFO_FLOAT;
-            case "Texture":
-                return GLSL_TYPE_INFO_SAMPLER2D;
-            case "FXColor":
-                return GLSL_TYPE_INFO_VEC4;
-            case "Vector2":
-                return GLSL_TYPE_INFO_VEC2;
-            case "Vector3":
-                return GLSL_TYPE_INFO_VEC3;
-            case "Vector4":
-                return GLSL_TYPE_INFO_VEC4;
-            case "Matrix3":
-                return GLSL_TYPE_INFO_MAT3;
-            case "Matrix4":
-                return GLSL_TYPE_INFO_MAT4;
-            default:
-                throw new Error(`resolveGLSLTypeInfo.value: unsupported property type name`);
-        }
-    }
-    if (typeof value === "function") {
-        if (value === Number) {
-            return GLSL_TYPE_INFO_FLOAT;
-        }
-        if (value === Texture) {
-            return GLSL_TYPE_INFO_SAMPLER2D;
-        }
-        if (value === FXColor) {
-            return GLSL_TYPE_INFO_VEC4;
-        }
-        if (value === Vector2) {
-            return GLSL_TYPE_INFO_VEC2;
-        }
-        if (value === Vector3) {
-            return GLSL_TYPE_INFO_VEC3;
-        }
-        if (value === Vector4) {
-            return GLSL_TYPE_INFO_VEC4;
-        }
-        if (value === Matrix3) {
-            return GLSL_TYPE_INFO_MAT3;
-        }
-        if (value === Matrix4) {
-            return GLSL_TYPE_INFO_MAT4;
-        }
-        throw new Error(`resolveGLSLTypeInfo.value: unsupported property type constructor`);
-    }
-    if (typeof value === "number") {
-        return GLSL_TYPE_INFO_FLOAT;
-    }
-    if (value instanceof Texture) {
-        return GLSL_TYPE_INFO_SAMPLER2D;
-    }
-    if (value instanceof FXColor) {
-        return GLSL_TYPE_INFO_VEC4;
-    }
-    if (value instanceof Vector2) {
-        return GLSL_TYPE_INFO_VEC2;
-    }
-    if (value instanceof Vector3) {
-        return GLSL_TYPE_INFO_VEC3;
-    }
-    if (value instanceof Vector4) {
-        return GLSL_TYPE_INFO_VEC4;
-    }
-    if (value instanceof Matrix3) {
-        return GLSL_TYPE_INFO_MAT3;
-    }
-    if (value instanceof Matrix4) {
-        return GLSL_TYPE_INFO_MAT4;
-    }
-    throw new Error(`resolveGLSLTypeInfo.value: unsupported property type`);
-}
-
-export { resolveGLSLTypeInfo };

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

@@ -1,24 +0,0 @@
-import { Color, MeshLambertMaterial } from "three";
-import type { GLTypeInfo } from "../../instancedParticle/shared";
-import type { FXNodeBlending } from "../../nodes/blending/FXNodeBlending";
-import { FXNodeColor } from "../../nodes/color/FXNodeColor";
-import type { FXNodeNormal } from "../../nodes/normal/FXNodeNormal";
-import { FXNodeTexture } from "../../nodes/texture/FXNodeTexture";
-import { FXBlending } from "../FXMaterial/FXMaterial";
-export interface FXScatterUniforms {
-    u_ScatterTint: {
-        value: Color;
-    };
-    u_ScatterPower: {
-        value: number;
-    };
-    u_ForwardScatterStrength: {
-        value: number;
-    };
-    u_BackScatterStrength: {
-        value: number;
-    };
-}
-export declare function buildFXDiffuseMaterial(varyings: Record<string, GLTypeInfo>, blending: FXBlending, useAlphaHashing: boolean, alphaTest: number, albedoNodes: readonly (FXNodeColor | FXNodeTexture | FXNodeBlending)[], normalNodes: readonly (FXNodeTexture | FXNodeNormal)[], emissionNodes: readonly (FXNodeColor | FXNodeTexture)[], scatterUniforms?: FXScatterUniforms, shadowSensitivity?: {
-    value: number;
-}): MeshLambertMaterial;

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