sparcoon 0.0.8 → 0.1.0

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/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.8",
+  "version": "0.1.0",
   "description": "",
   "keywords": [
     "particles",