sparcoon 0.1.0 → 0.3.0

package/dist/nodes/texture/FXAnimatedTextureNode.js

@@ -0,0 +1,80 @@
+import { checkSRGBSupport } from '../../miscellaneous/webglCapabilities.js';
+import { FXTextureNode } from './FXTextureNode.js';
+
+class FXAnimatedTextureNode extends FXTextureNode {
+    constructor({ texture, columns, rows, interpolate = false }) {
+        super();
+        const gammaCorrection = checkSRGBSupport()
+            ? ""
+            : "color = vec4(pow(color.rgb, vec3(2.2)), color.a);";
+        this.affectsDepth = true;
+        this.cacheKey = interpolate ? "animated-interpolated" : "animated";
+        this.uniformDeclarations = [
+            "uniform sampler2D u_AnimatedTexture;",
+            "uniform float u_AnimatedTextureColumns;",
+            "uniform float u_AnimatedTextureRows;",
+        ];
+        this.uniforms = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            u_AnimatedTexture: { value: texture },
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            u_AnimatedTextureColumns: { value: columns },
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            u_AnimatedTextureRows: { value: rows },
+        };
+        this.helperFunctions = interpolate
+            ? `
+        vec2 frameToUV(vec2 uv, float frame, float columns, float rows) {
+          float column = mod(frame, columns);
+          float row = floor(frame / columns);
+          return vec2((column + uv.x) / columns, 1.0 - (row + 1.0 - uv.y) / rows);
+        }
+
+        vec4 sampleAnimatedTexture(sampler2D spriteSheet, vec2 uv, float columns, float rows) {
+          float totalFrames = columns * rows;
+
+          // Fractional frame position drives both frame selection and blend weight
+          float exactFrame = PARTICLE_AGE / PARTICLE_LIFETIME * totalFrames;
+          float currentFrame = clamp(floor(exactFrame), 0.0, totalFrames - 1.0);
+          float nextFrame    = clamp(currentFrame + 1.0, 0.0, totalFrames - 1.0);
+          float blendWeight  = fract(exactFrame);
+
+          vec4 color = mix(
+            texture2D(spriteSheet, frameToUV(uv, currentFrame, columns, rows)),
+            texture2D(spriteSheet, frameToUV(uv, nextFrame,    columns, rows)),
+            blendWeight
+          );
+
+          // Apply gamma correction when sRGB textures are not natively supported
+          ${gammaCorrection}
+
+          return color;
+        }
+      `
+            : `
+        vec4 sampleAnimatedTexture(sampler2D spriteSheet, vec2 uv, float columns, float rows) {
+          // Determine which frame to display based on normalized particle age
+          float totalFrames = columns * rows;
+          float frame = floor(PARTICLE_AGE / PARTICLE_LIFETIME * totalFrames);
+          frame = clamp(frame, 0.0, totalFrames - 1.0);
+
+          // Locate the frame's column and row in the sprite sheet grid
+          float column = mod(frame, columns);
+          float row = floor(frame / columns);
+
+          // Remap UV to the frame's tile region within the sprite sheet
+          vec2 frameUV = vec2((column + uv.x) / columns, 1.0 - (row + 1.0 - uv.y) / rows);
+          vec4 color = texture2D(spriteSheet, frameUV);
+
+          // Apply gamma correction when sRGB textures are not natively supported
+          ${gammaCorrection}
+
+          return color;
+        }
+      `;
+        this.colorExpression =
+            "sampleAnimatedTexture(u_AnimatedTexture, p_uv, u_AnimatedTextureColumns, u_AnimatedTextureRows)";
+    }
+}
+
+export { FXAnimatedTextureNode };

package/dist/nodes/texture/FXStaticTextureNode.d.ts

@@ -0,0 +1,5 @@
+import type { Texture } from "three";
+import { FXTextureNode } from "./FXTextureNode";
+export declare class FXStaticTextureNode extends FXTextureNode {
+    constructor(texture: Texture);
+}

package/dist/nodes/texture/FXStaticTextureNode.js

@@ -0,0 +1,26 @@
+import { checkSRGBSupport } from '../../miscellaneous/webglCapabilities.js';
+import { FXTextureNode } from './FXTextureNode.js';
+
+class FXStaticTextureNode extends FXTextureNode {
+    constructor(texture) {
+        super();
+        this.affectsDepth = true;
+        this.cacheKey = "static";
+        this.uniformDeclarations = ["uniform sampler2D u_StaticTexture;"];
+        this.uniforms = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            u_StaticTexture: { value: texture },
+        };
+        this.helperFunctions = `
+      vec4 sampleStaticTexture(sampler2D colorTexture, vec2 uv) {
+        vec4 color = texture2D(colorTexture, uv);
+        // Apply gamma correction when sRGB textures are not natively supported
+        ${checkSRGBSupport() ? "" : "color = vec4(pow(color.rgb, vec3(2.2)), color.a);"}
+        return color;
+      }
+    `;
+        this.colorExpression = "sampleStaticTexture(u_StaticTexture, p_uv)";
+    }
+}
+
+export { FXStaticTextureNode };

package/dist/nodes/texture/FXTextureNode.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class FXTextureNode {
+    destroy?(): void;
+}

package/dist/nodes/texture/FXTextureNode.js

@@ -0,0 +1,8 @@
+class FXTextureNode {
+    constructor() {
+        /** @internal */
+        this.affectsDepth = false;
+    }
+}
+
+export { FXTextureNode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sparcoon",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "",
   "keywords": [
     "particles",

package/dist/elements/FXEmitter.Internal.js

@@ -1,12 +0,0 @@
-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_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,38 +0,0 @@
-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;
-    private readonly behaviorSequence;
-    private readonly renderingSequence;
-    automaticallyDestroyModules: boolean;
-    private readonly mesh;
-    private emissionRate;
-    private emissionAccumulator;
-    private emissionDuration;
-    private emissionElapsed;
-    constructor(spawnSequence: FXSpawnModule[], behaviorSequence: readonly FXBehaviorModule[], renderingSequence: readonly FXRenderingModule[], options?: Partial<FXEmitterOptions>);
-    static onWillRender: (deltaTime: number) => void;
-    destroy(): void;
-    burst(count: number): void;
-    reset(): void;
-    play(rate: number, options?: Partial<FXEmitterPlayOptions>): void;
-    stop(): void;
-    private readonly onRendering;
-}

package/dist/instancedParticle/FXParticleDepthMaterial.d.ts

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

package/dist/instancedParticle/FXParticleDepthMaterial.js

@@ -1,52 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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

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

package/dist/instancedParticle/FXParticleNormalsMode.js

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

package/dist/instancedParticle/FXParticleRenderingMode.d.ts

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

package/dist/instancedParticle/FXParticleRenderingMode.js

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

package/dist/miscellaneous/texture/FXTextureView.Internal.js

@@ -1,6 +0,0 @@
-import { Texture } from 'three';
-
-const TEXTURE_DEFAULT_TEXTURE = new Texture();
-const TEXTURE_DEFAULT_SIZE = 2;
-
-export { TEXTURE_DEFAULT_SIZE, TEXTURE_DEFAULT_TEXTURE };