sparcoon 0.1.0 → 0.3.0

package/dist/{spawnModules → emitter/spawn}/FXSpawnRandomScale.d.ts

@@ -1,11 +1,11 @@
-import { type FXAspectConfig, type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
-import { FXSpawnModule } from "./FXSpawnModule";
+import type { FXAspectConfig, FXRange, FXRangeConfig } from "../../miscellaneous/miscellaneous";
+import { FXSpawn } from "./FXSpawn";
 /**
  * Assigns random scale to particles.
  *
  * Base scale is chosen uniformly from the range. Aspect ratio is applied to X scale.
  */
-export declare class FXSpawnRandomScale extends FXSpawnModule<{
+export declare class FXSpawnRandomScale extends FXSpawn<{
     builtin: "Matrix4";
 }> {
     private scaleInternal;

package/dist/{spawnModules → emitter/spawn}/FXSpawnRandomScale.js

@@ -1,14 +1,14 @@
 import { MathUtils } from 'three';
-import { assertValidPositiveNumber } from '../miscellaneous/asserts.js';
-import { resolveFXRangeConfig, resolveAspect, BUILTIN_OFFSET_SCALE_X, BUILTIN_OFFSET_SCALE_Y } from '../miscellaneous/miscellaneous.js';
-import { FXSpawnModule } from './FXSpawnModule.js';
+import { assertValidPositiveNumber } from '../../miscellaneous/asserts.js';
+import { resolveFXRangeConfig, resolveAspect, BUILTIN_OFFSET_SCALE_X, BUILTIN_OFFSET_SCALE_Y } from '../../miscellaneous/miscellaneous.js';
+import { FXSpawn } from './FXSpawn.js';
 
 /**
  * Assigns random scale to particles.
  *
  * Base scale is chosen uniformly from the range. Aspect ratio is applied to X scale.
  */
-class FXSpawnRandomScale extends FXSpawnModule {
+class FXSpawnRandomScale extends FXSpawn {
     /**
      * @param scale - Base scale range. Accepts number, tuple, or range object
      * @param aspect - Width/height ratio. Accepts number or texture

package/dist/{spawnModules → emitter/spawn}/FXSpawnRandomTorque.d.ts

@@ -1,11 +1,11 @@
-import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
-import { FXSpawnModule } from "./FXSpawnModule";
+import type { FXRange, FXRangeConfig } from "../../miscellaneous/miscellaneous";
+import { FXSpawn } from "./FXSpawn";
 /**
  * Assigns random angular velocity to particles.
  *
  * Torque (rotation speed) is chosen uniformly from the specified range.
  */
-export declare class FXSpawnRandomTorque extends FXSpawnModule<{
+export declare class FXSpawnRandomTorque extends FXSpawn<{
     builtin: "Matrix4";
 }> {
     private torqueInternal;

package/dist/{spawnModules → emitter/spawn}/FXSpawnRandomTorque.js

@@ -1,14 +1,14 @@
 import { MathUtils } from 'three';
-import { assertValidNumber } from '../miscellaneous/asserts.js';
-import { resolveFXRangeConfig, BUILTIN_OFFSET_TORQUE } from '../miscellaneous/miscellaneous.js';
-import { FXSpawnModule } from './FXSpawnModule.js';
+import { assertValidNumber } from '../../miscellaneous/asserts.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_TORQUE } from '../../miscellaneous/miscellaneous.js';
+import { FXSpawn } from './FXSpawn.js';
 
 /**
  * Assigns random angular velocity to particles.
  *
  * Torque (rotation speed) is chosen uniformly from the specified range.
  */
-class FXSpawnRandomTorque extends FXSpawnModule {
+class FXSpawnRandomTorque extends FXSpawn {
     /**
      * @param torque - Angular velocity range in radians/second. Accepts number, tuple, or range object
      */

package/dist/{spawnModules → emitter/spawn}/FXSpawnRandomVelocity.d.ts

@@ -1,7 +1,7 @@
 import { Vector3 } from "three";
-import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
-import { FXSpawnModule } from "./FXSpawnModule";
-export declare class FXSpawnRandomVelocity extends FXSpawnModule<{
+import type { FXRange, FXRangeConfig } from "../../miscellaneous/miscellaneous";
+import { FXSpawn } from "./FXSpawn";
+export declare class FXSpawnRandomVelocity extends FXSpawn<{
     builtin: "Matrix4";
 }> {
     private angleInternal;

package/dist/{spawnModules → emitter/spawn}/FXSpawnRandomVelocity.js

@@ -1,12 +1,12 @@
 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 { FXSpawnModule } from './FXSpawnModule.js';
+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();
-class FXSpawnRandomVelocity extends FXSpawnModule {
+class FXSpawnRandomVelocity extends FXSpawn {
     constructor(direction = new Vector3(0, 1, 0), angle = { min: 0, max: Math.PI }, magnitude = { min: -50, max: 50 }) {
         super();
         /** @internal */

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

@@ -0,0 +1,38 @@
+import { FXSpawn } from "./FXSpawn";
+/**
+ * Spawns particles at random positions within a spherical shell.
+ *
+ * The `angle` parameter controls the polar spread from the equatorial plane:
+ * - `0` - flat disk (XZ plane only)
+ * - `Math.PI / 2` - full sphere
+ * - Values in between produce a spherical band/zone
+ */
+export declare class FXSpawnSphere extends FXSpawn<{
+    builtin: "Matrix4";
+}> {
+    private innerRadiusInternal;
+    private outerRadiusInternal;
+    private angleInternal;
+    /**
+     * @param innerRadius - Minimum spawn radius (0 = spawn from center)
+     * @param outerRadius - Maximum spawn radius
+     * @param angle - Polar half-angle from equatorial plane: 0 = disk, Math.PI/2 = full sphere
+     */
+    constructor(innerRadius?: number, outerRadius?: number, angle?: number);
+    /**
+     * Polar half-angle from the equatorial plane.
+     * - `0` — flat disk
+     * - `Math.PI / 2` — full sphere
+     */
+    get angle(): number;
+    /** Minimum spawn radius */
+    get innerRadius(): number;
+    /** Maximum spawn radius */
+    get outerRadius(): number;
+    /** Minimum spawn radius */
+    set innerRadius(value: number);
+    /** Maximum spawn radius */
+    set outerRadius(value: number);
+    /** @see {@link angle} */
+    set angle(value: number);
+}

package/dist/emitter/spawn/FXSpawnSphere.js

@@ -0,0 +1,89 @@
+import { MathUtils } from 'three';
+import { assertValidNonNegativeNumber, assertValidNumber } from '../../miscellaneous/asserts.js';
+import { BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z } from '../../miscellaneous/miscellaneous.js';
+import { FXSpawn } from './FXSpawn.js';
+
+/**
+ * Spawns particles at random positions within a spherical shell.
+ *
+ * The `angle` parameter controls the polar spread from the equatorial plane:
+ * - `0` - flat disk (XZ plane only)
+ * - `Math.PI / 2` - full sphere
+ * - Values in between produce a spherical band/zone
+ */
+class FXSpawnSphere extends FXSpawn {
+    /**
+     * @param innerRadius - Minimum spawn radius (0 = spawn from center)
+     * @param outerRadius - Maximum spawn radius
+     * @param angle - Polar half-angle from equatorial plane: 0 = disk, Math.PI/2 = full sphere
+     */
+    constructor(innerRadius = 0, outerRadius = 1, angle = Math.PI / 2) {
+        super();
+        /** @internal */
+        this.requiredProperties = { builtin: "Matrix4" };
+        this._private_innerRadiusInternal = innerRadius;
+        this._private_outerRadiusInternal = outerRadius;
+        this._private_angleInternal = angle;
+        assertValidNonNegativeNumber(innerRadius, "FXSpawnSphere.constructor.innerRadius");
+        assertValidNonNegativeNumber(outerRadius, "FXSpawnSphere.constructor.outerRadius");
+        assertValidNumber(angle, "FXSpawnSphere.constructor.angle");
+    }
+    /**
+     * Polar half-angle from the equatorial plane.
+     * - `0` — flat disk
+     * - `Math.PI / 2` — full sphere
+     */
+    get angle() {
+        return this._private_angleInternal;
+    }
+    /** Minimum spawn radius */
+    get innerRadius() {
+        return this._private_innerRadiusInternal;
+    }
+    /** Maximum spawn radius */
+    get outerRadius() {
+        return this._private_outerRadiusInternal;
+    }
+    /** Minimum spawn radius */
+    set innerRadius(value) {
+        assertValidNonNegativeNumber(value, "FXSpawnSphere.innerRadius");
+        this._private_innerRadiusInternal = value;
+    }
+    /** Maximum spawn radius */
+    set outerRadius(value) {
+        assertValidNonNegativeNumber(value, "FXSpawnSphere.outerRadius");
+        this._private_outerRadiusInternal = value;
+    }
+    /** @see {@link angle} */
+    set angle(value) {
+        assertValidNumber(value, "FXSpawnSphere.angle");
+        this._private_angleInternal = value;
+    }
+    /** @internal */
+    spawn(properties, instanceBegin, instanceEnd) {
+        const { builtin } = properties;
+        const { array, itemSize } = builtin;
+        const inner = this._private_innerRadiusInternal;
+        const outer = this._private_outerRadiusInternal;
+        const sinAngle = Math.sin(this._private_angleInternal);
+        // Volume-uniform radius sampling within the shell
+        const inner3 = inner * inner * inner;
+        const outer3 = outer * outer * outer;
+        for (let i = instanceBegin; i < instanceEnd; i++) {
+            // Uniform volume-weighted radius
+            const r = Math.cbrt(MathUtils.randFloat(inner3, outer3));
+            // Uniform sampling on spherical zone:
+            // cosTheta in [-sinAngle, sinAngle] gives latitude range [-angle, +angle]
+            const cosTheta = MathUtils.randFloat(-sinAngle, sinAngle);
+            const sinTheta = Math.sqrt(1 - cosTheta * cosTheta);
+            const phi = MathUtils.randFloat(0, Math.PI * 2);
+            const itemOffset = i * itemSize;
+            array[itemOffset + BUILTIN_OFFSET_POSITION_X] = r * sinTheta * Math.cos(phi);
+            array[itemOffset + BUILTIN_OFFSET_POSITION_Y] = r * cosTheta;
+            array[itemOffset + BUILTIN_OFFSET_POSITION_Z] = r * sinTheta * Math.sin(phi);
+        }
+        builtin.needsUpdate = true;
+    }
+}
+
+export { FXSpawnSphere };

package/dist/index.d.ts

@@ -1,20 +1,28 @@
-export { FXBehaviorDirectionalGravity } from "./behaviorModules/FXBehaviorDirectionalGravity";
-export { FXBehaviorPointGravity } from "./behaviorModules/FXBehaviorPointGravity";
-export { FXBehaviorScaleOverLife } from "./behaviorModules/FXBehaviorScaleOverLife";
-export { FXBehaviorTorqueDamping } from "./behaviorModules/FXBehaviorTorqueDamping";
-export { FXBehaviorTorqueNoise } from "./behaviorModules/FXBehaviorTorqueNoise";
-export { FXBehaviorVelocityDamping } from "./behaviorModules/FXBehaviorVelocityDamping";
-export { FXBehaviorVelocityNoise } from "./behaviorModules/FXBehaviorVelocityNoise";
-export { FXColor } from "./color/FXColor";
-export { FXEmitter, FXParticleNormalsMode, FXParticleRenderingMode } from "./elements/FXEmitter";
-export { FXRenderingAnimatedTexture } from "./renderingModules/FXRenderingAnimatedTexture";
-export { FXRenderingColorOverLife } from "./renderingModules/FXRenderingColorOverLife";
-export { FXRenderingColorOverVelocity } from "./renderingModules/FXRenderingColorOverVelocity";
-export { FXRenderingTexture } from "./renderingModules/FXRenderingTexture";
-export { FXSpawnBox } from "./spawnModules/FXSpawnBox";
-export { FXSpawnOffset } from "./spawnModules/FXSpawnOffset";
-export { FXSpawnRandomLifetime } from "./spawnModules/FXSpawnRandomLifetime";
-export { FXSpawnRandomRotation } from "./spawnModules/FXSpawnRandomRotation";
-export { FXSpawnRandomScale } from "./spawnModules/FXSpawnRandomScale";
-export { FXSpawnRandomTorque } from "./spawnModules/FXSpawnRandomTorque";
-export { FXSpawnRandomVelocity } from "./spawnModules/FXSpawnRandomVelocity";
+export { FXBehaviorDirectionalGravity } from "./emitter/behavior/FXBehaviorDirectionalGravity";
+export { FXBehaviorPointGravity } from "./emitter/behavior/FXBehaviorPointGravity";
+export { FXBehaviorScaleOverLife } from "./emitter/behavior/FXBehaviorScaleOverLife";
+export { FXBehaviorTorqueDamping } from "./emitter/behavior/FXBehaviorTorqueDamping";
+export { FXBehaviorTorqueNoise } from "./emitter/behavior/FXBehaviorTorqueNoise";
+export { FXBehaviorVelocityDamping } from "./emitter/behavior/FXBehaviorVelocityDamping";
+export { FXBehaviorVelocityNoise } from "./emitter/behavior/FXBehaviorVelocityNoise";
+export { FXEmitter } from "./emitter/FXEmitter";
+export { FXSpawnBox } from "./emitter/spawn/FXSpawnBox";
+export { FXSpawnPoint as FXSpawnOffset } from "./emitter/spawn/FXSpawnPoint";
+export { FXSpawnRandomLifetime } from "./emitter/spawn/FXSpawnRandomLifetime";
+export { FXSpawnRandomRotation } from "./emitter/spawn/FXSpawnRandomRotation";
+export { FXSpawnRandomScale } from "./emitter/spawn/FXSpawnRandomScale";
+export { FXSpawnRandomTorque } from "./emitter/spawn/FXSpawnRandomTorque";
+export { FXSpawnRandomVelocity } from "./emitter/spawn/FXSpawnRandomVelocity";
+export { FXSpawnSphere } from "./emitter/spawn/FXSpawnSphere";
+export { FXDiffuseMaterial } from "./materials/FXDiffuseMaterial/FXDiffuseMaterial";
+export { FXMaterial } from "./materials/FXMaterial/FXMaterial";
+export { FXUnlitMaterial } from "./materials/FXUnlitMaterial/FXUnlitMaterial";
+export { FXColor } from "./miscellaneous/color/FXColor";
+export { FXColorNode } from "./nodes/color/FXColorNode";
+export { FXColorOverLifeNode } from "./nodes/color/FXColorOverLifeNode";
+export { FXFlatNormalNode } from "./nodes/normal/FXFlatNormalNode";
+export { FXNormalNode } from "./nodes/normal/FXNormalNode";
+export { FXSphericalNormalNode } from "./nodes/normal/FXSphericalNormalNode";
+export { FXAnimatedTextureNode } from "./nodes/texture/FXAnimatedTextureNode";
+export { FXStaticTextureNode } from "./nodes/texture/FXStaticTextureNode";
+export { FXTextureNode } from "./nodes/texture/FXTextureNode";

package/dist/index.js

@@ -1,22 +1,28 @@
-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 { FXSpawnPoint as FXSpawnOffset } from './emitter/spawn/FXSpawnPoint.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 { FXDiffuseMaterial } from './materials/FXDiffuseMaterial/FXDiffuseMaterial.js';
+export { FXMaterial } from './materials/FXMaterial/FXMaterial.js';
+export { FXUnlitMaterial } from './materials/FXUnlitMaterial/FXUnlitMaterial.js';
+export { FXColor } from './miscellaneous/color/FXColor.js';
+export { FXColorNode } from './nodes/color/FXColorNode.js';
+export { FXColorOverLifeNode } from './nodes/color/FXColorOverLifeNode.js';
+export { FXFlatNormalNode } from './nodes/normal/FXFlatNormalNode.js';
+export { FXNormalNode } from './nodes/normal/FXNormalNode.js';
+export { FXSphericalNormalNode } from './nodes/normal/FXSphericalNormalNode.js';
+export { FXAnimatedTextureNode } from './nodes/texture/FXAnimatedTextureNode.js';
+export { FXStaticTextureNode } from './nodes/texture/FXStaticTextureNode.js';
+export { FXTextureNode } from './nodes/texture/FXTextureNode.js';

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

@@ -1,13 +1,2 @@
-import { InstancedBufferGeometry, ShaderMaterial, type Blending } from "three";
-import type { GLProperty, GLTypeInfo } from "./shared";
-import { type FXProperty, type FXPropertyName } from "./shared";
+import { InstancedBufferGeometry } from "three";
 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,7 +1,4 @@
-import { InstancedBufferGeometry, BufferAttribute, Float32BufferAttribute, ShaderMaterial } from 'three';
-import { FXColor } from '../color/FXColor.js';
-import { checkSRGBSupport } from '../miscellaneous/webglCapabilities.js';
-import { resolveGLSLTypeInfo } from './shared.js';
+import { InstancedBufferGeometry, BufferAttribute, Float32BufferAttribute } from 'three';
 
 const INSTANCED_PARTICLE_GEOMETRY = (() => {
     const geometry = new InstancedBufferGeometry();
@@ -13,206 +10,5 @@ const INSTANCED_PARTICLE_GEOMETRY = (() => {
     geometry.setAttribute("uv", new Float32BufferAttribute(uvs, 2));
     return geometry;
 })();
-function collectProperties(keeper, modules, debugContext) {
-    for (const module of modules) {
-        if (module.requiredProperties === undefined) {
-            continue;
-        }
-        for (const key in module.requiredProperties) {
-            const existingTypeInfo = keeper[key];
-            const newTypeInfo = resolveGLSLTypeInfo(module.requiredProperties[key]);
-            if (existingTypeInfo === undefined) {
-                keeper[key] = newTypeInfo;
-            }
-            else if (existingTypeInfo.glslTypeName !== newTypeInfo.glslTypeName) {
-                throw new Error(`${debugContext}: property conflict for "${key}"`);
-            }
-        }
-    }
-}
-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 };

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,7 @@
+import type { Blending } from "three";
+import { MeshLambertMaterial } from "three";
+import type { GLTypeInfo } from "../../instancedParticle/shared";
+import type { FXColorNode } from "../../nodes/color/FXColorNode";
+import type { FXNormalNode } from "../../nodes/normal/FXNormalNode";
+import { FXTextureNode } from "../../nodes/texture/FXTextureNode";
+export declare function buildFXDiffuseMaterial(varyings: Record<string, GLTypeInfo>, blending: Blending, useAlphaHashing: boolean, alphaTest: number, albedoNodes: readonly (FXColorNode | FXTextureNode)[], normalNodes: readonly (FXTextureNode | FXNormalNode)[], emissionNodes: readonly (FXColorNode | FXTextureNode)[]): MeshLambertMaterial;