sparcoon 0.0.7 → 0.1.0

package/dist/_virtual/2d.js

@@ -0,0 +1,3 @@
+var _2d = {};
+
+export { _2d as __exports };

package/dist/_virtual/3d.js

@@ -0,0 +1,3 @@
+var _3d = {};
+
+export { _3d as __exports };

package/dist/_virtual/4d.js

@@ -0,0 +1,3 @@
+var _4d = {};
+
+export { _4d as __exports };

package/dist/_virtual/mod.js

@@ -0,0 +1,5 @@
+import { __require as requireMod } from '../node_modules/fast-simplex-noise/lib/mod.js';
+
+var modExports = requireMod();
+
+export { modExports as m };

package/dist/_virtual/mod2.js

@@ -0,0 +1,3 @@
+var mod = {};
+
+export { mod as __exports };

package/dist/behaviorModules/FXBehaviorTorqueNoise.d.ts

@@ -1,4 +1,4 @@
-import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import type { FXRange, FXRangeConfig } from "../miscellaneous/miscellaneous";
 import { FXBehaviorModule } from "./FXBehaviorModule";
 /**
  * Applies noise-based angular acceleration to particles.

package/dist/behaviorModules/FXBehaviorTorqueNoise.js

@@ -1,8 +1,10 @@
+import { m as modExports } from '../_virtual/mod.js';
 import { MathUtils } from 'three';
 import { assertValidPositiveNumber, assertValidNonNegativeNumber } from '../miscellaneous/asserts.js';
-import { resolveFXRangeConfig, BUILTIN_OFFSET_RANDOM_C, generateNoise3D, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_TORQUE } from '../miscellaneous/miscellaneous.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_TORQUE } from '../miscellaneous/miscellaneous.js';
 import { FXBehaviorModule } from './FXBehaviorModule.js';
 
+const generateNoise3D = modExports.makeNoise3D();
 /**
  * Applies noise-based angular acceleration to particles.
  *

package/dist/behaviorModules/FXBehaviorVelocityNoise.d.ts

@@ -1,4 +1,4 @@
-import { type FXRange, type FXRangeConfig } from "../miscellaneous/miscellaneous";
+import type { FXRange, FXRangeConfig } from "../miscellaneous/miscellaneous";
 import { FXBehaviorModule } from "./FXBehaviorModule";
 /**
  * Applies noise-based acceleration to particles.

package/dist/behaviorModules/FXBehaviorVelocityNoise.js

@@ -1,8 +1,12 @@
+import { m as modExports } from '../_virtual/mod.js';
 import { MathUtils } from 'three';
 import { assertValidPositiveNumber, assertValidNonNegativeNumber } from '../miscellaneous/asserts.js';
-import { resolveFXRangeConfig, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z, generateNoise3D } from '../miscellaneous/miscellaneous.js';
+import { resolveFXRangeConfig, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z } from '../miscellaneous/miscellaneous.js';
 import { FXBehaviorModule } from './FXBehaviorModule.js';
 
+const generateNoise3D0 = modExports.makeNoise3D();
+const generateNoise3D1 = modExports.makeNoise3D();
+const generateNoise3D2 = modExports.makeNoise3D();
 /**
  * Applies noise-based acceleration to particles.
  *
@@ -56,9 +60,9 @@ class FXBehaviorVelocityNoise extends FXBehaviorModule {
             // Constant over the life of a particle but different for each particle
             const scaleT = array[itemOffset + BUILTIN_OFFSET_RANDOM_C];
             const scale = MathUtils.lerp(this._private_scaleInternal.min, this._private_scaleInternal.max, scaleT);
-            const noiseX = generateNoise3D(x * scale, y * scale, z * scale);
-            const noiseY = generateNoise3D((x + 100) * scale, (y + 100) * scale, (z + 100) * scale);
-            const noiseZ = generateNoise3D((x - 200) * scale, (y - 200) * scale, (z - 200) * scale);
+            const noiseX = generateNoise3D0(x * scale, y * scale, z * scale);
+            const noiseY = generateNoise3D1(x * scale, y * scale, z * scale);
+            const noiseZ = generateNoise3D2(x * scale, y * scale, z * scale);
             // Constant over the life of a particle but different for each particle
             const strengthT = array[itemOffset + BUILTIN_OFFSET_RANDOM_A];
             const strength = MathUtils.lerp(this._private_strengthInternal.min, this._private_strengthInternal.max, strengthT);

package/dist/elements/FXEmitter.Internal.d.ts

@@ -1,10 +1,12 @@
-export interface FXEmitterOptions {
-    expectedCapacity: number;
-    capacityStep: number;
-}
+import { FXParticleNormalsMode } from "../instancedParticle/FXParticleNormalsMode";
+import { FXParticleRenderingMode } from "../instancedParticle/FXParticleRenderingMode";
 export interface FXEmitterPlayOptions {
     duration: number;
 }
 export declare const EMITTER_DEFAULT_EXPECTED_CAPACITY = 32;
 export declare const EMITTER_DEFAULT_CAPACITY_STEP = 32;
 export declare const EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES = true;
+export declare const EMITTER_DEFAULT_CAST_SHADOW = false;
+export declare const EMITTER_DEFAULT_RECEIVE_SHADOW = false;
+export declare const EMITTER_DEFAULT_RENDERING_MODE = FXParticleRenderingMode.Unlit;
+export declare const EMITTER_DEFAULT_NORMALS_MODE = FXParticleNormalsMode.Flat;

package/dist/elements/FXEmitter.Internal.js

@@ -1,5 +1,12 @@
+import { FXParticleNormalsMode } from '../instancedParticle/FXParticleNormalsMode.js';
+import { FXParticleRenderingMode } from '../instancedParticle/FXParticleRenderingMode.js';
+
 const EMITTER_DEFAULT_EXPECTED_CAPACITY = 32;
 const EMITTER_DEFAULT_CAPACITY_STEP = 32;
 const EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES = true;
+const EMITTER_DEFAULT_CAST_SHADOW = false;
+const EMITTER_DEFAULT_RECEIVE_SHADOW = false;
+const EMITTER_DEFAULT_RENDERING_MODE = FXParticleRenderingMode.Unlit;
+const EMITTER_DEFAULT_NORMALS_MODE = FXParticleNormalsMode.Flat;
 
-export { EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES, EMITTER_DEFAULT_CAPACITY_STEP, EMITTER_DEFAULT_EXPECTED_CAPACITY };
+export { EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES, EMITTER_DEFAULT_CAPACITY_STEP, EMITTER_DEFAULT_CAST_SHADOW, EMITTER_DEFAULT_EXPECTED_CAPACITY, EMITTER_DEFAULT_NORMALS_MODE, EMITTER_DEFAULT_RECEIVE_SHADOW, EMITTER_DEFAULT_RENDERING_MODE };

package/dist/elements/FXEmitter.d.ts

@@ -1,14 +1,21 @@
 import { Object3D, type Blending } from "three";
 import type { FXBehaviorModule } from "../behaviorModules/FXBehaviorModule";
+import { FXParticleNormalsMode } from "../instancedParticle/FXParticleNormalsMode";
+import { FXParticleRenderingMode } from "../instancedParticle/FXParticleRenderingMode";
 import type { FXRenderingModule } from "../renderingModules/FXRenderingModule";
 import type { FXSpawnModule } from "../spawnModules/FXSpawnModule";
 import type { FXEmitterPlayOptions } from "./FXEmitter.Internal";
+export { FXParticleNormalsMode, FXParticleRenderingMode };
 export interface FXEmitterOptions {
     expectedCapacity: number;
     capacityStep: number;
     automaticallyDestroyModules: boolean;
     blending: Blending;
     useAlphaHashing: boolean;
+    castShadow: boolean;
+    receiveShadow: boolean;
+    renderingMode: FXParticleRenderingMode;
+    normalsMode: FXParticleNormalsMode;
 }
 export declare class FXEmitter extends Object3D {
     private readonly spawnSequence;

package/dist/elements/FXEmitter.js

@@ -1,9 +1,12 @@
 import { Object3D, NormalBlending } from 'three';
 import { FXInstancedParticle } from '../instancedParticle/FXInstancedParticle.js';
 import { collectProperties, collectUniforms } from '../instancedParticle/FXInstancedParticle.Internal.js';
+import { buildParticleDepthMaterial } from '../instancedParticle/FXParticleDepthMaterial.js';
+export { FXParticleNormalsMode } from '../instancedParticle/FXParticleNormalsMode.js';
+export { FXParticleRenderingMode } from '../instancedParticle/FXParticleRenderingMode.js';
 import { resolveGLSLTypeInfo } from '../instancedParticle/shared.js';
 import { BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_VELOCITY_Z, BUILTIN_OFFSET_ROTATION, BUILTIN_OFFSET_TORQUE, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_RANDOM_C } from '../miscellaneous/miscellaneous.js';
-import { EMITTER_DEFAULT_EXPECTED_CAPACITY, EMITTER_DEFAULT_CAPACITY_STEP, EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES } from './FXEmitter.Internal.js';
+import { EMITTER_DEFAULT_EXPECTED_CAPACITY, EMITTER_DEFAULT_CAPACITY_STEP, EMITTER_DEFAULT_RENDERING_MODE, EMITTER_DEFAULT_NORMALS_MODE, EMITTER_DEFAULT_CAST_SHADOW, EMITTER_DEFAULT_RECEIVE_SHADOW, EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES } from './FXEmitter.Internal.js';
 
 const INSTANCES = new Array();
 class FXEmitter extends Object3D {
@@ -80,7 +83,14 @@ class FXEmitter extends Object3D {
         collectProperties(collectedProperties, _private_renderingSequence, "FXEmitter.constructor.renderingSequence");
         const collectedUniforms = {};
         collectUniforms(collectedUniforms, _private_renderingSequence, "FXEmitter.constructor.renderingSequence");
-        this._private_mesh = new FXInstancedParticle(this._private_renderingSequence.map((module) => module.source), collectedUniforms, collectedProperties, options.expectedCapacity ?? EMITTER_DEFAULT_EXPECTED_CAPACITY, options.capacityStep ?? EMITTER_DEFAULT_CAPACITY_STEP, options.blending ?? NormalBlending, options.useAlphaHashing ?? false);
+        this._private_mesh = new FXInstancedParticle(_private_renderingSequence.map((module) => module.source), collectedUniforms, collectedProperties, options.expectedCapacity ?? EMITTER_DEFAULT_EXPECTED_CAPACITY, options.capacityStep ?? EMITTER_DEFAULT_CAPACITY_STEP, options.blending ?? NormalBlending, options.useAlphaHashing ?? false, options.renderingMode ?? EMITTER_DEFAULT_RENDERING_MODE, options.normalsMode ?? EMITTER_DEFAULT_NORMALS_MODE);
+        if (options.castShadow ?? EMITTER_DEFAULT_CAST_SHADOW) {
+            this._private_mesh.castShadow = true;
+            this._private_mesh.customDepthMaterial = buildParticleDepthMaterial();
+        }
+        if (options.receiveShadow ?? EMITTER_DEFAULT_RECEIVE_SHADOW) {
+            this._private_mesh.receiveShadow = true;
+        }
         this.automaticallyDestroyModules =
             options.automaticallyDestroyModules ?? EMITTER_DEFAULT_AUTOMATICALLY_DESTROY_MODULES;
         this.add(this._private_mesh);

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export { FXBehaviorTorqueNoise } from "./behaviorModules/FXBehaviorTorqueNoise";
 export { FXBehaviorVelocityDamping } from "./behaviorModules/FXBehaviorVelocityDamping";
 export { FXBehaviorVelocityNoise } from "./behaviorModules/FXBehaviorVelocityNoise";
 export { FXColor } from "./color/FXColor";
-export { FXEmitter } from "./elements/FXEmitter";
+export { FXEmitter, FXParticleNormalsMode, FXParticleRenderingMode } from "./elements/FXEmitter";
 export { FXRenderingAnimatedTexture } from "./renderingModules/FXRenderingAnimatedTexture";
 export { FXRenderingColorOverLife } from "./renderingModules/FXRenderingColorOverLife";
 export { FXRenderingColorOverVelocity } from "./renderingModules/FXRenderingColorOverVelocity";

package/dist/index.js

@@ -18,3 +18,5 @@ 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';

package/dist/instancedParticle/FXInstancedParticle.Internal.js

@@ -121,8 +121,9 @@ function buildParticleFragmentShader(uniformDeclarations, varyingDeclarations, s
         drawCalls += `draw${i}()`;
     }
     return `
+    #include <common>
+
     // Defines
-    #define PI 3.14159265359
     #define SRGB_SUPPORTED ${checkSRGBSupport() ? "1" : "0"}
 
     #define PARTICLE_POSITION_X p_builtin[0][0]

package/dist/instancedParticle/FXInstancedParticle.d.ts

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

package/dist/instancedParticle/FXInstancedParticle.js

@@ -1,18 +1,23 @@
 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';
 
 class FXInstancedParticle extends Mesh {
-    constructor(sources, uniforms, varyings, expectedCapacity, _private_capacityStep, blending, useAlphaHashing) {
+    constructor(sources, uniforms, varyings, expectedCapacity, _private_capacityStep, blending, useAlphaHashing, renderingMode, normalsMode) {
         const instancedGeometry = INSTANCED_PARTICLE_GEOMETRY.clone();
-        const shaderMaterial = buildParticleMaterial(sources, uniforms, varyings, blending, useAlphaHashing);
-        super(instancedGeometry, shaderMaterial);
+        const particleMaterial = renderingMode === FXParticleRenderingMode.Lambert
+            ? buildParticleLambertMaterial(sources, uniforms, varyings, blending, useAlphaHashing, normalsMode)
+            : buildParticleMaterial(sources, uniforms, varyings, blending, useAlphaHashing);
+        super(instancedGeometry, particleMaterial);
         this._private_capacityStep = _private_capacityStep;
         this.propertyBuffers = {};
         this.frustumCulled = false;
         this._private_instancedGeometry = instancedGeometry;
         this._private_instancedGeometry.instanceCount = 0;
-        this._private_shaderMaterial = shaderMaterial;
+        this._private_particleMaterial = particleMaterial;
         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];
@@ -61,7 +66,7 @@ class FXInstancedParticle extends Mesh {
     }
     destroy() {
         this._private_instancedGeometry.dispose();
-        this._private_shaderMaterial.dispose();
+        this._private_particleMaterial.dispose();
     }
     _private_ensureCapacity(requiredCapacity) {
         if (requiredCapacity <= this._private_capacity) {

package/dist/instancedParticle/FXParticleDepthMaterial.d.ts

@@ -0,0 +1,2 @@
+import { MeshDepthMaterial } from "three";
+export declare function buildParticleDepthMaterial(): MeshDepthMaterial;

package/dist/instancedParticle/FXParticleDepthMaterial.js

@@ -0,0 +1,52 @@
+import { MeshDepthMaterial, RGBADepthPacking } from 'three';
+
+const PARTICLE_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 vec2 vHighPrecisionZW;
+
+  void main() {
+    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;
+    vHighPrecisionZW = gl_Position.zw;
+  }
+`;
+function buildParticleDepthMaterial() {
+    const material = new MeshDepthMaterial({ depthPacking: RGBADepthPacking });
+    material.onBeforeCompile = (shader) => {
+        shader.vertexShader = PARTICLE_DEPTH_VERTEX_SHADER;
+    };
+    material.customProgramCacheKey = () => "fx-particle-depth";
+    return material;
+}
+
+export { buildParticleDepthMaterial };

package/dist/instancedParticle/FXParticleLambertMaterial.d.ts

@@ -0,0 +1,4 @@
+import { MeshLambertMaterial, type Blending } from "three";
+import { FXParticleNormalsMode } from "./FXParticleNormalsMode";
+import type { GLProperty, GLTypeInfo } from "./shared";
+export declare function buildParticleLambertMaterial(sources: string[], uniformProperties: Record<string, GLProperty>, varyingProperties: Record<string, GLTypeInfo>, blending: Blending, useAlphaHashing: boolean, normalsMode: FXParticleNormalsMode): MeshLambertMaterial;

package/dist/instancedParticle/FXParticleLambertMaterial.js

@@ -0,0 +1,152 @@
+import { MeshLambertMaterial } from 'three';
+import { FXColor } from '../color/FXColor.js';
+import { checkSRGBSupport } from '../miscellaneous/webglCapabilities.js';
+import { FXParticleNormalsMode } from './FXParticleNormalsMode.js';
+
+const PARTICLE_DEFINES = `
+  #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]
+`;
+function buildParticleLambertMaterial(sources, uniformProperties, varyingProperties, blending, useAlphaHashing, normalsMode) {
+    const uniformValues = {};
+    const uniformDeclarations = [];
+    const attributeDeclarations = [];
+    const varyingDeclarations = [];
+    const vertexAssignments = [];
+    for (const name in uniformProperties) {
+        const { value, glslTypeInfo } = uniformProperties[name];
+        uniformValues[`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};`);
+    }
+    const renamedSources = sources.map((source, index) => 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}()`;
+    }
+    const srgbSupported = checkSRGBSupport() ? "1" : "0";
+    const srgbHelper = `
+    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
+    }
+  `;
+    const material = new MeshLambertMaterial({
+        transparent: true,
+        depthWrite: false,
+        depthTest: true,
+        alphaHash: useAlphaHashing,
+        blending,
+    });
+    material.onBeforeCompile = (shader) => {
+        Object.assign(shader.uniforms, uniformValues);
+        // --- Vertex shader ---
+        const vertexPreamble = [
+            PARTICLE_DEFINES,
+            attributeDeclarations.join("\n"),
+            "varying vec2 p_uv;",
+            varyingDeclarations.join("\n"),
+        ].join("\n");
+        shader.vertexShader =
+            vertexPreamble +
+                "\n" +
+                shader.vertexShader
+                    // Hardcode objectNormal — no normal attribute on billboard geometry
+                    .replace("#include <beginnormal_vertex>", "vec3 objectNormal = vec3(0.0, 0.0, 1.0);")
+                    // Hardcode transformedNormal as view-space camera-facing (0,0,1)
+                    .replace("#include <defaultnormal_vertex>", "vec3 transformedNormal = vec3(0.0, 0.0, 1.0);")
+                    // Set p_uv, user varyings, placeholder transformed for downstream chunks
+                    .replace("#include <begin_vertex>", ["p_uv = uv;", vertexAssignments.join("\n"), "vec3 transformed = position;"].join("\n"))
+                    // Billboard projection: computes p_bp (screen offset) and p_c (center), sets mvPosition
+                    .replace("#include <project_vertex>", `
+          vec2 p_bp = position.xy;
+          p_bp.x *= PARTICLE_SCALE_X;
+          p_bp.y *= PARTICLE_SCALE_Y;
+          float p_cosR = cos(PARTICLE_ROTATION);
+          float p_sinR = sin(PARTICLE_ROTATION);
+          p_bp = vec2(
+            p_bp.x * p_cosR - p_bp.y * p_sinR,
+            p_bp.x * p_sinR + p_bp.y * p_cosR
+          );
+          vec3 p_c = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z);
+          vec4 mvPosition = modelViewMatrix * vec4(p_c, 1.0);
+          mvPosition.xy += p_bp;
+          gl_Position = projectionMatrix * mvPosition;
+          `)
+                    // Billboard world position — p_c and p_bp in scope from project_vertex above
+                    .replace("#include <worldpos_vertex>", `
+          #if defined(USE_SHADOWMAP) || defined(USE_ENVMAP) || defined(DISTANCE) || (NUM_SPOT_LIGHT_COORDS > 0)
+            vec3 p_cr = vec3(viewMatrix[0][0], viewMatrix[1][0], viewMatrix[2][0]);
+            vec3 p_cu = vec3(viewMatrix[0][1], viewMatrix[1][1], viewMatrix[2][1]);
+            vec4 worldPosition = vec4(
+              (modelMatrix * vec4(p_c, 1.0)).xyz + p_cr * p_bp.x + p_cu * p_bp.y,
+              1.0
+            );
+          #endif
+          `);
+        // --- Fragment shader ---
+        const fragmentPreamble = [
+            PARTICLE_DEFINES,
+            `#define SRGB_SUPPORTED ${srgbSupported}`,
+            uniformDeclarations.join("\n"),
+            "varying vec2 p_uv;",
+            varyingDeclarations.join("\n"),
+            srgbHelper,
+            renamedSources.join("\n"),
+        ].join("\n");
+        let fragmentShader = shader.fragmentShader;
+        if (normalsMode === FXParticleNormalsMode.Spherical) {
+            fragmentShader = fragmentShader.replace("#include <normal_fragment_begin>", `
+        float faceDirection = gl_FrontFacing ? 1.0 : -1.0;
+        vec2 p_sn = p_uv * 2.0 - 1.0;
+        vec3 normal = normalize(vec3(p_sn, sqrt(max(0.0, 1.0 - dot(p_sn, p_sn)))));
+        `);
+        }
+        else if (normalsMode === FXParticleNormalsMode.TowardsLight) {
+            fragmentShader = fragmentShader.replace("float dotNL = saturate( dot( geometryNormal, directLight.direction ) );", "float dotNL = 1.0;");
+        }
+        shader.fragmentShader =
+            fragmentPreamble +
+                "\n" +
+                fragmentShader
+                    // Inject custom diffuse color from draw() pipeline
+                    .replace("#include <map_fragment>", `
+          vec4 p_color = ${drawCalls};
+          if (p_color.a < 0.0035) discard;
+          diffuseColor = p_color;
+          `);
+    };
+    material.customProgramCacheKey = () => `fx-particle-lambert-${normalsMode}-${sources.join("|")}`;
+    return material;
+}
+
+export { buildParticleLambertMaterial };

package/dist/instancedParticle/FXParticleNormalsMode.d.ts

@@ -0,0 +1,5 @@
+export declare enum FXParticleNormalsMode {
+    Flat = "flat",
+    Spherical = "spherical",
+    TowardsLight = "towards-light"
+}

package/dist/instancedParticle/FXParticleNormalsMode.js

@@ -0,0 +1,8 @@
+var FXParticleNormalsMode;
+(function (FXParticleNormalsMode) {
+    FXParticleNormalsMode["Flat"] = "flat";
+    FXParticleNormalsMode["Spherical"] = "spherical";
+    FXParticleNormalsMode["TowardsLight"] = "towards-light";
+})(FXParticleNormalsMode || (FXParticleNormalsMode = {}));
+
+export { FXParticleNormalsMode };

package/dist/instancedParticle/FXParticleRenderingMode.d.ts

@@ -0,0 +1,4 @@
+export declare enum FXParticleRenderingMode {
+    Unlit = "unlit",
+    Lambert = "lambert"
+}

package/dist/instancedParticle/FXParticleRenderingMode.js

@@ -0,0 +1,7 @@
+var FXParticleRenderingMode;
+(function (FXParticleRenderingMode) {
+    FXParticleRenderingMode["Unlit"] = "unlit";
+    FXParticleRenderingMode["Lambert"] = "lambert";
+})(FXParticleRenderingMode || (FXParticleRenderingMode = {}));
+
+export { FXParticleRenderingMode };

package/dist/miscellaneous/miscellaneous.d.ts

@@ -13,7 +13,6 @@ export type FXAspectConfig = number | FXTextureConfig;
 export declare function resolveFXRangeConfig(config: FXRangeConfig): FXRange;
 export declare function resolveFXVector3Config(config: FXVector3Config): Vector3Like;
 export declare function resolveAspect(config: number | FXTextureConfig): number;
-export declare function generateNoise3D(x: number, y: number, z: number): number;
 export declare function buildGradientTexture(colors: FXColor[]): DataTexture;
 export declare const BUILTIN_OFFSET_POSITION_X = 0;
 export declare const BUILTIN_OFFSET_POSITION_Y = 1;

package/dist/miscellaneous/miscellaneous.js

@@ -27,10 +27,6 @@ function resolveAspect(config) {
     }
     return config.sourceSize.w / config.sourceSize.h;
 }
-function generateNoise3D(x, y, z) {
-    const noise = Math.sin(x * 12.9898 + y * 78.233 + z * 37.719) * 43758.5453123;
-    return (noise - Math.floor(noise)) * 2 - 1;
-}
 function buildGradientTexture(colors) {
     const width = colors.length;
     const height = 1;
@@ -63,4 +59,4 @@ const BUILTIN_OFFSET_RANDOM_A = 13;
 const BUILTIN_OFFSET_RANDOM_B = 14;
 const BUILTIN_OFFSET_RANDOM_C = 15;
 
-export { BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_LIFETIME, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_ROTATION, BUILTIN_OFFSET_SCALE_X, BUILTIN_OFFSET_SCALE_Y, BUILTIN_OFFSET_TORQUE, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z, buildGradientTexture, generateNoise3D, resolveAspect, resolveFXRangeConfig, resolveFXVector3Config };
+export { BUILTIN_OFFSET_AGE, BUILTIN_OFFSET_LIFETIME, BUILTIN_OFFSET_POSITION_X, BUILTIN_OFFSET_POSITION_Y, BUILTIN_OFFSET_POSITION_Z, BUILTIN_OFFSET_RANDOM_A, BUILTIN_OFFSET_RANDOM_B, BUILTIN_OFFSET_RANDOM_C, BUILTIN_OFFSET_ROTATION, BUILTIN_OFFSET_SCALE_X, BUILTIN_OFFSET_SCALE_Y, BUILTIN_OFFSET_TORQUE, BUILTIN_OFFSET_VELOCITY_X, BUILTIN_OFFSET_VELOCITY_Y, BUILTIN_OFFSET_VELOCITY_Z, buildGradientTexture, resolveAspect, resolveFXRangeConfig, resolveFXVector3Config };

package/dist/node_modules/fast-simplex-noise/lib/2d.js

@@ -0,0 +1,93 @@
+import { __exports as _2d } from '../../../_virtual/2d.js';
+
+var hasRequired_2d;
+
+function require_2d () {
+	if (hasRequired_2d) return _2d;
+	hasRequired_2d = 1;
+	/*
+	 * Based on example code by Stefan Gustavson (stegu@itn.liu.se).
+	 * Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
+	 * Better rank ordering method by Stefan Gustavson in 2012.
+	 *
+	 * This code was placed in the public domain by its original author,
+	 * Stefan Gustavson. You may use it as you see fit, but
+	 * attribution is appreciated.
+	 */
+	Object.defineProperty(_2d, "__esModule", { value: true });
+	_2d.makeNoise2D = void 0;
+	var G2 = (3.0 - Math.sqrt(3.0)) / 6.0;
+	var Grad = [
+	    [1, 1],
+	    [-1, 1],
+	    [1, -1],
+	    [-1, -1],
+	    [1, 0],
+	    [-1, 0],
+	    [1, 0],
+	    [-1, 0],
+	    [0, 1],
+	    [0, -1],
+	    [0, 1],
+	    [0, -1],
+	];
+	function makeNoise2D(random) {
+	    if (random === void 0) { random = Math.random; }
+	    var p = new Uint8Array(256);
+	    for (var i = 0; i < 256; i++)
+	        p[i] = i;
+	    var n;
+	    var q;
+	    for (var i = 255; i > 0; i--) {
+	        n = Math.floor((i + 1) * random());
+	        q = p[i];
+	        p[i] = p[n];
+	        p[n] = q;
+	    }
+	    var perm = new Uint8Array(512);
+	    var permMod12 = new Uint8Array(512);
+	    for (var i = 0; i < 512; i++) {
+	        perm[i] = p[i & 255];
+	        permMod12[i] = perm[i] % 12;
+	    }
+	    return function (x, y) {
+	        // Skew the input space to determine which simplex cell we're in
+	        var s = (x + y) * 0.5 * (Math.sqrt(3.0) - 1.0); // Hairy factor for 2D
+	        var i = Math.floor(x + s);
+	        var j = Math.floor(y + s);
+	        var t = (i + j) * G2;
+	        var X0 = i - t; // Unskew the cell origin back to (x,y) space
+	        var Y0 = j - t;
+	        var x0 = x - X0; // The x,y distances from the cell origin
+	        var y0 = y - Y0;
+	        // Determine which simplex we are in.
+	        var i1 = x0 > y0 ? 1 : 0;
+	        var j1 = x0 > y0 ? 0 : 1;
+	        // Offsets for corners
+	        var x1 = x0 - i1 + G2;
+	        var y1 = y0 - j1 + G2;
+	        var x2 = x0 - 1.0 + 2.0 * G2;
+	        var y2 = y0 - 1.0 + 2.0 * G2;
+	        // Work out the hashed gradient indices of the three simplex corners
+	        var ii = i & 255;
+	        var jj = j & 255;
+	        var g0 = Grad[permMod12[ii + perm[jj]]];
+	        var g1 = Grad[permMod12[ii + i1 + perm[jj + j1]]];
+	        var g2 = Grad[permMod12[ii + 1 + perm[jj + 1]]];
+	        // Calculate the contribution from the three corners
+	        var t0 = 0.5 - x0 * x0 - y0 * y0;
+	        var n0 = t0 < 0 ? 0.0 : Math.pow(t0, 4) * (g0[0] * x0 + g0[1] * y0);
+	        var t1 = 0.5 - x1 * x1 - y1 * y1;
+	        var n1 = t1 < 0 ? 0.0 : Math.pow(t1, 4) * (g1[0] * x1 + g1[1] * y1);
+	        var t2 = 0.5 - x2 * x2 - y2 * y2;
+	        var n2 = t2 < 0 ? 0.0 : Math.pow(t2, 4) * (g2[0] * x2 + g2[1] * y2);
+	        // Add contributions from each corner to get the final noise value.
+	        // The result is scaled to return values in the interval [-1, 1]
+	        return 70.14805770653952 * (n0 + n1 + n2);
+	    };
+	}
+	_2d.makeNoise2D = makeNoise2D;
+	return _2d;
+}
+
+export { require_2d as __require };

package/dist/node_modules/fast-simplex-noise/lib/3d.js

@@ -0,0 +1,142 @@
+import { __exports as _3d } from '../../../_virtual/3d.js';
+
+var hasRequired_3d;
+
+function require_3d () {
+	if (hasRequired_3d) return _3d;
+	hasRequired_3d = 1;
+	/*
+	 * Based on example code by Stefan Gustavson (stegu@itn.liu.se).
+	 * Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
+	 * Better rank ordering method by Stefan Gustavson in 2012.
+	 *
+	 * This code was placed in the public domain by its original author,
+	 * Stefan Gustavson. You may use it as you see fit, but
+	 * attribution is appreciated.
+	 */
+	Object.defineProperty(_3d, "__esModule", { value: true });
+	_3d.makeNoise3D = void 0;
+	var G3 = 1.0 / 6.0;
+	var Grad = [
+	    [1, 1, 0],
+	    [-1, 1, 0],
+	    [1, -1, 0],
+	    [-1, -1, 0],
+	    [1, 0, 1],
+	    [-1, 0, 1],
+	    [1, 0, -1],
+	    [-1, 0, -1],
+	    [0, 1, 1],
+	    [0, -1, -1],
+	    [0, 1, -1],
+	    [0, -1, -1],
+	];
+	function makeNoise3D(random) {
+	    if (random === void 0) { random = Math.random; }
+	    var p = new Uint8Array(256);
+	    for (var i = 0; i < 256; i++)
+	        p[i] = i;
+	    var n;
+	    var q;
+	    for (var i = 255; i > 0; i--) {
+	        n = Math.floor((i + 1) * random());
+	        q = p[i];
+	        p[i] = p[n];
+	        p[n] = q;
+	    }
+	    var perm = new Uint8Array(512);
+	    var permMod12 = new Uint8Array(512);
+	    for (var i = 0; i < 512; i++) {
+	        perm[i] = p[i & 255];
+	        permMod12[i] = perm[i] % 12;
+	    }
+	    return function (x, y, z) {
+	        // Skew the input space to determine which simplex cell we're in
+	        var s = (x + y + z) / 3.0; // Very nice and simple skew factor for 3D
+	        var i = Math.floor(x + s);
+	        var j = Math.floor(y + s);
+	        var k = Math.floor(z + s);
+	        var t = (i + j + k) * G3;
+	        var X0 = i - t; // Unskew the cell origin back to (x,y,z) space
+	        var Y0 = j - t;
+	        var Z0 = k - t;
+	        var x0 = x - X0; // The x,y,z distances from the cell origin
+	        var y0 = y - Y0;
+	        var z0 = z - Z0;
+	        // Deterine which simplex we are in
+	        var i1, j1, k1 // Offsets for second corner of simplex in (i,j,k) coords
+	        ;
+	        var i2, j2, k2 // Offsets for third corner of simplex in (i,j,k) coords
+	        ;
+	        if (x0 >= y0) {
+	            if (y0 >= z0) {
+	                i1 = i2 = j2 = 1;
+	                j1 = k1 = k2 = 0;
+	            }
+	            else if (x0 >= z0) {
+	                i1 = i2 = k2 = 1;
+	                j1 = k1 = j2 = 0;
+	            }
+	            else {
+	                k1 = i2 = k2 = 1;
+	                i1 = j1 = j2 = 0;
+	            }
+	        }
+	        else {
+	            if (y0 < z0) {
+	                k1 = j2 = k2 = 1;
+	                i1 = j1 = i2 = 0;
+	            }
+	            else if (x0 < z0) {
+	                j1 = j2 = k2 = 1;
+	                i1 = k1 = i2 = 0;
+	            }
+	            else {
+	                j1 = i2 = j2 = 1;
+	                i1 = k1 = k2 = 0;
+	            }
+	        }
+	        var x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
+	        var y1 = y0 - j1 + G3;
+	        var z1 = z0 - k1 + G3;
+	        var x2 = x0 - i2 + 2.0 * G3; // Offsets for third corner in (x,y,z) coords
+	        var y2 = y0 - j2 + 2.0 * G3;
+	        var z2 = z0 - k2 + 2.0 * G3;
+	        var x3 = x0 - 1.0 + 3.0 * G3; // Offsets for last corner in (x,y,z) coords
+	        var y3 = y0 - 1.0 + 3.0 * G3;
+	        var z3 = z0 - 1.0 + 3.0 * G3;
+	        // Work out the hashed gradient indices of the four simplex corners
+	        var ii = i & 255;
+	        var jj = j & 255;
+	        var kk = k & 255;
+	        var g0 = Grad[permMod12[ii + perm[jj + perm[kk]]]];
+	        var g1 = Grad[permMod12[ii + i1 + perm[jj + j1 + perm[kk + k1]]]];
+	        var g2 = Grad[permMod12[ii + i2 + perm[jj + j2 + perm[kk + k2]]]];
+	        var g3 = Grad[permMod12[ii + 1 + perm[jj + 1 + perm[kk + 1]]]];
+	        // Calculate the contribution from the four corners
+	        var t0 = 0.5 - x0 * x0 - y0 * y0 - z0 * z0;
+	        var n0 = t0 < 0
+	            ? 0.0
+	            : Math.pow(t0, 4) * (g0[0] * x0 + g0[1] * y0 + g0[2] * z0);
+	        var t1 = 0.5 - x1 * x1 - y1 * y1 - z1 * z1;
+	        var n1 = t1 < 0
+	            ? 0.0
+	            : Math.pow(t1, 4) * (g1[0] * x1 + g1[1] * y1 + g1[2] * z1);
+	        var t2 = 0.5 - x2 * x2 - y2 * y2 - z2 * z2;
+	        var n2 = t2 < 0
+	            ? 0.0
+	            : Math.pow(t2, 4) * (g2[0] * x2 + g2[1] * y2 + g2[2] * z2);
+	        var t3 = 0.5 - x3 * x3 - y3 * y3 - z3 * z3;
+	        var n3 = t3 < 0
+	            ? 0.0
+	            : Math.pow(t3, 4) * (g3[0] * x3 + g3[1] * y3 + g3[2] * z3);
+	        // Add contributions from each corner to get the final noise value.
+	        // The result is scaled to stay just inside [-1,1]
+	        return 94.68493150681972 * (n0 + n1 + n2 + n3);
+	    };
+	}
+	_3d.makeNoise3D = makeNoise3D;
+	return _3d;
+}
+
+export { require_3d as __require };

package/dist/node_modules/fast-simplex-noise/lib/4d.js

@@ -0,0 +1,196 @@
+import { __exports as _4d } from '../../../_virtual/4d.js';
+
+var hasRequired_4d;
+
+function require_4d () {
+	if (hasRequired_4d) return _4d;
+	hasRequired_4d = 1;
+	/*
+	 * Based on example code by Stefan Gustavson (stegu@itn.liu.se).
+	 * Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
+	 * Better rank ordering method by Stefan Gustavson in 2012.
+	 *
+	 * This code was placed in the public domain by its original author,
+	 * Stefan Gustavson. You may use it as you see fit, but
+	 * attribution is appreciated.
+	 */
+	Object.defineProperty(_4d, "__esModule", { value: true });
+	_4d.makeNoise4D = void 0;
+	var G4 = (5.0 - Math.sqrt(5.0)) / 20.0;
+	var Grad = [
+	    [0, 1, 1, 1],
+	    [0, 1, 1, -1],
+	    [0, 1, -1, 1],
+	    [0, 1, -1, -1],
+	    [0, -1, 1, 1],
+	    [0, -1, 1, -1],
+	    [0, -1, -1, 1],
+	    [0, -1, -1, -1],
+	    [1, 0, 1, 1],
+	    [1, 0, 1, -1],
+	    [1, 0, -1, 1],
+	    [1, 0, -1, -1],
+	    [-1, 0, 1, 1],
+	    [-1, 0, 1, -1],
+	    [-1, 0, -1, 1],
+	    [-1, 0, -1, -1],
+	    [1, 1, 0, 1],
+	    [1, 1, 0, -1],
+	    [1, -1, 0, 1],
+	    [1, -1, 0, -1],
+	    [-1, 1, 0, 1],
+	    [-1, 1, 0, -1],
+	    [-1, -1, 0, 1],
+	    [-1, -1, 0, -1],
+	    [1, 1, 1, 0],
+	    [1, 1, -1, 0],
+	    [1, -1, 1, 0],
+	    [1, -1, -1, 0],
+	    [-1, 1, 1, 0],
+	    [-1, 1, -1, 0],
+	    [-1, -1, 1, 0],
+	    [-1, -1, -1, 0],
+	];
+	function makeNoise4D(random) {
+	    if (random === void 0) { random = Math.random; }
+	    var p = new Uint8Array(256);
+	    for (var i = 0; i < 256; i++)
+	        p[i] = i;
+	    var n;
+	    var q;
+	    for (var i = 255; i > 0; i--) {
+	        n = Math.floor((i + 1) * random());
+	        q = p[i];
+	        p[i] = p[n];
+	        p[n] = q;
+	    }
+	    var perm = new Uint8Array(512);
+	    var permMod12 = new Uint8Array(512);
+	    for (var i = 0; i < 512; i++) {
+	        perm[i] = p[i & 255];
+	        permMod12[i] = perm[i] % 12;
+	    }
+	    return function (x, y, z, w) {
+	        // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
+	        var s = (x + y + z + w) * (Math.sqrt(5.0) - 1.0) / 4.0; // Factor for 4D skewing
+	        var i = Math.floor(x + s);
+	        var j = Math.floor(y + s);
+	        var k = Math.floor(z + s);
+	        var l = Math.floor(w + s);
+	        var t = (i + j + k + l) * G4; // Factor for 4D unskewing
+	        var X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
+	        var Y0 = j - t;
+	        var Z0 = k - t;
+	        var W0 = l - t;
+	        var x0 = x - X0; // The x,y,z,w distances from the cell origin
+	        var y0 = y - Y0;
+	        var z0 = z - Z0;
+	        var w0 = w - W0;
+	        // To find out which of the 24 possible simplices we're in, we need to determine the
+	        // magnitude ordering of x0, y0, z0 and w0. Six pair-wise comparisons are performed between
+	        // each possible pair of the four coordinates, and the results are used to rank the numbers.
+	        var rankx = 0;
+	        var ranky = 0;
+	        var rankz = 0;
+	        var rankw = 0;
+	        if (x0 > y0)
+	            rankx++;
+	        else
+	            ranky++;
+	        if (x0 > z0)
+	            rankx++;
+	        else
+	            rankz++;
+	        if (x0 > w0)
+	            rankx++;
+	        else
+	            rankw++;
+	        if (y0 > z0)
+	            ranky++;
+	        else
+	            rankz++;
+	        if (y0 > w0)
+	            ranky++;
+	        else
+	            rankw++;
+	        if (z0 > w0)
+	            rankz++;
+	        else
+	            rankw++;
+	        // simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
+	        // Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
+	        // impossible. Only the 24 indices which have non-zero entries make any sense.
+	        // We use a thresholding to set the coordinates in turn from the largest magnitude.
+	        // Rank 3 denotes the largest coordinate.
+	        var i1 = rankx >= 3 ? 1 : 0;
+	        var j1 = ranky >= 3 ? 1 : 0;
+	        var k1 = rankz >= 3 ? 1 : 0;
+	        var l1 = rankw >= 3 ? 1 : 0;
+	        // Rank 2 denotes the second largest coordinate.
+	        var i2 = rankx >= 2 ? 1 : 0;
+	        var j2 = ranky >= 2 ? 1 : 0;
+	        var k2 = rankz >= 2 ? 1 : 0;
+	        var l2 = rankw >= 2 ? 1 : 0;
+	        // Rank 1 denotes the second smallest coordinate.
+	        var i3 = rankx >= 1 ? 1 : 0;
+	        var j3 = ranky >= 1 ? 1 : 0;
+	        var k3 = rankz >= 1 ? 1 : 0;
+	        var l3 = rankw >= 1 ? 1 : 0;
+	        // The fifth corner has all coordinate offsets = 1, so no need to compute that.
+	        var x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
+	        var y1 = y0 - j1 + G4;
+	        var z1 = z0 - k1 + G4;
+	        var w1 = w0 - l1 + G4;
+	        var x2 = x0 - i2 + 2.0 * G4; // Offsets for third corner in (x,y,z,w) coords
+	        var y2 = y0 - j2 + 2.0 * G4;
+	        var z2 = z0 - k2 + 2.0 * G4;
+	        var w2 = w0 - l2 + 2.0 * G4;
+	        var x3 = x0 - i3 + 3.0 * G4; // Offsets for fourth corner in (x,y,z,w) coords
+	        var y3 = y0 - j3 + 3.0 * G4;
+	        var z3 = z0 - k3 + 3.0 * G4;
+	        var w3 = w0 - l3 + 3.0 * G4;
+	        var x4 = x0 - 1.0 + 4.0 * G4; // Offsets for last corner in (x,y,z,w) coords
+	        var y4 = y0 - 1.0 + 4.0 * G4;
+	        var z4 = z0 - 1.0 + 4.0 * G4;
+	        var w4 = w0 - 1.0 + 4.0 * G4;
+	        // Work out the hashed gradient indices of the five simplex corners
+	        var ii = i & 255;
+	        var jj = j & 255;
+	        var kk = k & 255;
+	        var ll = l & 255;
+	        var g0 = Grad[perm[ii + perm[jj + perm[kk + perm[ll]]]] %
+	            32];
+	        var g1 = Grad[perm[ii + i1 + perm[jj + j1 + perm[kk + k1 + perm[ll + l1]]]] % 32];
+	        var g2 = Grad[perm[ii + i2 + perm[jj + j2 + perm[kk + k2 + perm[ll + l2]]]] % 32];
+	        var g3 = Grad[perm[ii + i3 + perm[jj + j3 + perm[kk + k3 + perm[ll + l3]]]] % 32];
+	        var g4 = Grad[perm[ii + 1 + perm[jj + 1 + perm[kk + 1 + perm[ll + 1]]]] % 32];
+	        // Calculate the contribution from the five corners
+	        var t0 = 0.5 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0;
+	        var n0 = t0 < 0
+	            ? 0.0
+	            : Math.pow(t0, 4) * (g0[0] * x0 + g0[1] * y0 + g0[2] * z0 + g0[3] * w0);
+	        var t1 = 0.5 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1;
+	        var n1 = t1 < 0
+	            ? 0.0
+	            : Math.pow(t1, 4) * (g1[0] * x1 + g1[1] * y1 + g1[2] * z1 + g1[3] * w1);
+	        var t2 = 0.5 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2;
+	        var n2 = t2 < 0
+	            ? 0.0
+	            : Math.pow(t2, 4) * (g2[0] * x2 + g2[1] * y2 + g2[2] * z2 + g2[3] * w2);
+	        var t3 = 0.5 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3;
+	        var n3 = t3 < 0
+	            ? 0.0
+	            : Math.pow(t3, 4) * (g3[0] * x3 + g3[1] * y3 + g3[2] * z3 + g3[3] * w3);
+	        var t4 = 0.5 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4;
+	        var n4 = t4 < 0
+	            ? 0.0
+	            : Math.pow(t4, 4) * (g4[0] * x4 + g4[1] * y4 + g4[2] * z4 + g4[3] * w4);
+	        // Sum up and scale the result to cover the range [-1,1]
+	        return 72.37855765153665 * (n0 + n1 + n2 + n3 + n4);
+	    };
+	}
+	_4d.makeNoise4D = makeNoise4D;
+	return _4d;
+}
+
+export { require_4d as __require };

package/dist/node_modules/fast-simplex-noise/lib/mod.js

@@ -0,0 +1,24 @@
+import { __exports as mod } from '../../../_virtual/mod2.js';
+import { __require as require_2d } from './2d.js';
+import { __require as require_3d } from './3d.js';
+import { __require as require_4d } from './4d.js';
+
+var hasRequiredMod;
+
+function requireMod () {
+	if (hasRequiredMod) return mod;
+	hasRequiredMod = 1;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.makeNoise4D = exports$1.makeNoise3D = exports$1.makeNoise2D = void 0;
+		var _2d_1 = require_2d();
+		Object.defineProperty(exports$1, "makeNoise2D", { enumerable: true, get: function () { return _2d_1.makeNoise2D; } });
+		var _3d_1 = require_3d();
+		Object.defineProperty(exports$1, "makeNoise3D", { enumerable: true, get: function () { return _3d_1.makeNoise3D; } });
+		var _4d_1 = require_4d();
+		Object.defineProperty(exports$1, "makeNoise4D", { enumerable: true, get: function () { return _4d_1.makeNoise4D; } }); 
+	} (mod));
+	return mod;
+}
+
+export { requireMod as __require };

package/dist/renderingModules/FXRenderingShadow.d.ts

@@ -0,0 +1,12 @@
+import { FXRenderingModule } from "./FXRenderingModule";
+/**
+ * Applies directional light shadow attenuation to particles.
+ *
+ * Samples the first directional light's shadow map per billboard fragment,
+ * multiplying the particle color by the shadow factor.
+ *
+ * Requires a DirectionalLight with `castShadow = true` in the scene,
+ * and `receiveShadow = true` on the emitter (or its parent).
+ */
+export declare class FXRenderingShadow extends FXRenderingModule {
+}

package/dist/shaders/FXRenderingAnimatedTexture.glsl.js

@@ -1,3 +1,3 @@
-var source = "vec4 draw(){float totalFrames=p_count.x*p_count.y;float frame=floor(PARTICLE_AGE/PARTICLE_LIFETIME*totalFrames);frame=clamp(frame,0.0,totalFrames-1.0);float col=mod(frame,p_count.x);float row=floor(frame/p_count.x);vec2 frameSize=vec2(1.0/p_count.x,1.0/p_count.y);vec2 uv=(p_uv+vec2(col,(p_count.y-1.0-row)))*frameSize;return srgbTexture2D(p_texture,uv);}";
+var source = "vec4 draw(){\n float totalFrames=p_count.x*p_count.y;\n float frame=floor(PARTICLE_AGE/PARTICLE_LIFETIME*totalFrames);\n frame=clamp(frame,0.0,totalFrames-1.0);\n float col=mod(frame,p_count.x);\n float row=floor(frame/p_count.x);\n vec2 frameSize=vec2(1.0/p_count.x,1.0/p_count.y);\n vec2 uv=(p_uv+vec2(col,(p_count.y-1.0-row)))*frameSize;\n return srgbTexture2D(p_texture,uv);\n}";
 
 export { source as default };

package/dist/shaders/FXRenderingColorOverLife.glsl.js

@@ -1,3 +1,3 @@
-var source = "vec4 draw(){float t=clamp(PARTICLE_AGE/PARTICLE_LIFETIME,0.0,1.0);return srgbTexture2D(p_colorOverLifeTexture,vec2(t,0.5));}";
+var source = "vec4 draw(){\n float t=clamp(PARTICLE_AGE/PARTICLE_LIFETIME,0.0,1.0);\n return srgbTexture2D(p_colorOverLifeTexture,vec2(t,0.5));\n}";
 
 export { source as default };

package/dist/shaders/FXRenderingColorOverVelocity.glsl.js

@@ -1,3 +1,3 @@
-var source = "#define COLOR_OVER_VELOCITY_MAX vec4 draw(){float t=clamp(length(vec3(PARTICLE_VELOCITY_X,PARTICLE_VELOCITY_Y,PARTICLE_VELOCITY_Z))/COLOR_OVER_VELOCITY_MAX,0.0,1.0);return srgbTexture2D(p_colorOverVelocityTexture,vec2(t,0.5));}";
+var source = "#define COLOR_OVER_VELOCITY_MAX \nvec4 draw(){\n float t=clamp(length(vec3(PARTICLE_VELOCITY_X,PARTICLE_VELOCITY_Y,PARTICLE_VELOCITY_Z))/COLOR_OVER_VELOCITY_MAX,0.0,1.0);\n return srgbTexture2D(p_colorOverVelocityTexture,vec2(t,0.5));\n}";
 
 export { source as default };

package/dist/shaders/FXRenderingTexture.glsl.js

@@ -1,3 +1,3 @@
-var source = "vec4 draw(){vec2 transformedUV=(p_textureTransform*vec3(p_uv,1.0)).xy;return srgbTexture2D(p_texture,transformedUV);}";
+var source = "vec4 draw(){\n vec2 transformedUV=(p_textureTransform*vec3(p_uv,1.0)).xy;\n return srgbTexture2D(p_texture,transformedUV);\n}";
 
 export { source as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sparcoon",
-  "version": "0.0.7",
+  "version": "0.1.0",
   "description": "",
   "keywords": [
     "particles",
@@ -39,8 +39,9 @@
     }
   },
   "peerDependencies": {
-    "three": ">=0.157.0 <0.180.0",
-    "ferrsign": "^0.0.4"
+    "fast-simplex-noise": "^4.0.0",
+    "ferrsign": "^0.0.4",
+    "three": ">=0.157.0 <0.180.0"
   },
   "devDependencies": {
     "@rollup/plugin-node-resolve": "^16.0.1",
@@ -54,5 +55,8 @@
     "rollup-plugin-typescript2": "^0.36.0",
     "ts-transformer-minify-privates": "^1.0.0",
     "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@rollup/plugin-commonjs": "^29.0.2"
   }
 }