sparcoon 0.7.2 → 0.9.0

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.Internal.js

@@ -1,103 +0,0 @@
-import { MeshBasicMaterial, DoubleSide, NormalBlending } from 'three';
-import { PARTICLE_DEFINES } from '../../miscellaneous/miscellaneous.js';
-import { buildAlbedoAndBlendingCode } from '../FXMaterial/FXBlending.Internal.js';
-import { FXBlending } from '../FXMaterial/FXMaterial.js';
-
-function buildFXUnlitMaterial(varyings, blending, useAlphaHashing, alphaTest, albedoNodes) {
-    const attributeDeclarations = [];
-    const varyingDeclarations = [];
-    const vertexAssignments = [];
-    for (const name in varyings) {
-        const { glslTypeName } = varyings[name];
-        attributeDeclarations.push(`attribute ${glslTypeName} a_${name};`);
-        varyingDeclarations.push(`varying ${glslTypeName} p_${name};`);
-        vertexAssignments.push(`p_${name} = a_${name};`);
-    }
-    const material = new MeshBasicMaterial({
-        name: "FXUnlitMaterial",
-        transparent: !useAlphaHashing,
-        depthWrite: useAlphaHashing,
-        depthTest: true,
-        alphaHash: useAlphaHashing,
-        blending: NormalBlending,
-        side: DoubleSide,
-        forceSinglePass: true,
-        alphaTest,
-        premultipliedAlpha: true,
-    });
-    material.onBeforeCompile = (shader) => {
-        const vertexPreamble = [
-            PARTICLE_DEFINES,
-            attributeDeclarations.join("\n"),
-            "varying vec2 p_uv;",
-            varyingDeclarations.join("\n"),
-        ].join("\n");
-        shader.vertexShader =
-            vertexPreamble +
-                "\n" +
-                shader.vertexShader
-                    .replace("#include <begin_vertex>", [
-                    "p_uv = uv;",
-                    vertexAssignments.join("\n"),
-                    "vec3 transformed = position;",
-                    "#ifdef USE_ALPHAHASH",
-                    "  vPosition = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z) + vec3(position.xy, 0.0);",
-                    "#endif",
-                ].join("\n"))
-                    .replace("#include <project_vertex>", `
-          // Scale and rotate the billboard offset in camera space
-          vec2 billboardOffset = position.xy;
-          billboardOffset.x *= PARTICLE_SCALE_X;
-          billboardOffset.y *= PARTICLE_SCALE_Y;
-
-          float cosRotation = cos(PARTICLE_ROTATION);
-          float sinRotation = sin(PARTICLE_ROTATION);
-          billboardOffset = vec2(
-            billboardOffset.x * cosRotation - billboardOffset.y * sinRotation,
-            billboardOffset.x * sinRotation + billboardOffset.y * cosRotation
-          );
-
-          // Move particle center to view space, then apply the billboard offset
-          vec3 particleCenter = vec3(PARTICLE_POSITION_X, PARTICLE_POSITION_Y, PARTICLE_POSITION_Z);
-          vec4 mvPosition = modelViewMatrix * vec4(particleCenter, 1.0);
-          mvPosition.xy += billboardOffset;
-          gl_Position = projectionMatrix * mvPosition;
-          `);
-        const seenCacheKeys = new Set();
-        const uniqueHelpers = (nodes) => nodes
-            .filter((node) => {
-            if (seenCacheKeys.has(node.cacheKey)) {
-                return false;
-            }
-            seenCacheKeys.add(node.cacheKey);
-            return true;
-        })
-            .map((node) => node.helperFunctions)
-            .join("\n");
-        const fragmentPreamble = [
-            PARTICLE_DEFINES,
-            "varying vec2 p_uv;",
-            varyingDeclarations.join("\n"),
-            albedoNodes.flatMap((node) => node.uniformDeclarations).join("\n"),
-            uniqueHelpers(albedoNodes),
-        ].join("\n");
-        for (const node of albedoNodes) {
-            Object.assign(shader.uniforms, node.uniforms);
-        }
-        const albedoCode = buildAlbedoAndBlendingCode(albedoNodes, blending, useAlphaHashing);
-        let fragmentShader = shader.fragmentShader;
-        if (albedoCode.mapFragment !== null) {
-            fragmentShader = fragmentShader.replace("#include <map_fragment>", albedoCode.mapFragment);
-        }
-        fragmentShader = fragmentShader.replace("#include <premultiplied_alpha_fragment>", albedoCode.premultChunk);
-        shader.fragmentShader = fragmentPreamble + "\n" + fragmentShader;
-    };
-    material.customProgramCacheKey = () => [
-        "fx-unlit",
-        albedoNodes.map((node) => node.cacheKey).join("-") || "none",
-        FXBlending[blending],
-    ].join("_");
-    return material;
-}
-
-export { buildFXUnlitMaterial };

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.d.ts

@@ -1,7 +0,0 @@
-import { FXMaterial } from "../FXMaterial/FXMaterial";
-/**
- * Unlit particle material - renders particles without lighting or shadows
- */
-export declare class FXUnlitMaterial extends FXMaterial {
-    prepare(): void;
-}

package/dist/materials/FXUnlitMaterial/FXUnlitMaterial.js

@@ -1,21 +0,0 @@
-import { FXMaterial } from '../FXMaterial/FXMaterial.js';
-import { buildFXUnlitMaterial } from './FXUnlitMaterial.Internal.js';
-
-/**
- * Unlit particle material - renders particles without lighting or shadows
- */
-class FXUnlitMaterial extends FXMaterial {
-    /** @internal */
-    buildThreeMaterial(varyings) {
-        return buildFXUnlitMaterial(varyings, this.blending, this.useAlphaHashing, this.alphaTest, this.albedoNodes);
-    }
-    prepare() {
-        let i = 0;
-        for (const node of this.albedoNodes) {
-            node.prepare?.(i);
-            i += 1;
-        }
-    }
-}
-
-export { FXUnlitMaterial };

package/dist/miscellaneous/color/FXColor.Internal.d.ts

@@ -1,7 +0,0 @@
-import type { Color } from "three";
-import type { FXColor } from "./FXColor";
-/** Color configuration as Three.js Color, hex number, hex string, or FXColor */
-export type FXColorConfig = Color | number | string | FXColor;
-/** Predefined color names */
-export type FXColorName = "black" | "white" | "red" | "green" | "blue" | "yellow" | "cyan" | "magenta" | "gray" | "grey" | "silver" | "maroon" | "olive" | "lime" | "aqua" | "teal" | "navy" | "fuchsia" | "purple" | "orange" | "pink" | "brown" | "gold" | "violet" | "indigo" | "coral" | "salmon" | "khaki" | "plum" | "orchid" | "tan" | "beige" | "mint" | "lavender" | "crimson" | "azure" | "ivory" | "snow";
-export declare const COLORS: Record<string, number | undefined>;

package/dist/miscellaneous/color/FXColor.Internal.js

@@ -1,42 +0,0 @@
-const COLORS = {
-    black: 0x000000,
-    white: 0xffffff,
-    red: 0xff0000,
-    green: 0x008000,
-    blue: 0x0000ff,
-    yellow: 0xffff00,
-    cyan: 0x00ffff,
-    magenta: 0xff00ff,
-    gray: 0x808080,
-    grey: 0x808080,
-    silver: 0xc0c0c0,
-    maroon: 0x800000,
-    olive: 0x808000,
-    lime: 0x00ff00,
-    aqua: 0x00ffff,
-    teal: 0x008080,
-    navy: 0x000080,
-    fuchsia: 0xff00ff,
-    purple: 0x800080,
-    orange: 0xffa500,
-    pink: 0xffc0cb,
-    brown: 0xa52a2a,
-    gold: 0xffd700,
-    violet: 0xee82ee,
-    indigo: 0x4b0082,
-    coral: 0xff7f50,
-    salmon: 0xfa8072,
-    khaki: 0xf0e68c,
-    plum: 0xdda0dd,
-    orchid: 0xda70d6,
-    tan: 0xd2b48c,
-    beige: 0xf5f5dc,
-    mint: 0x98fb98,
-    lavender: 0xe6e6fa,
-    crimson: 0xdc143c,
-    azure: 0xf0ffff,
-    ivory: 0xfffff0,
-    snow: 0xfffafa,
-};
-
-export { COLORS };

package/dist/miscellaneous/color/FXColor.d.ts

@@ -1,234 +0,0 @@
-import { Color, Vector4 } from "three";
-import type { FXColorConfig, FXColorName } from "./FXColor.Internal";
-/** RGBA color with RGB, HSL, hex, and named color support */
-export declare class FXColor {
-    private rInternal;
-    private gInternal;
-    private bInternal;
-    private aInternal;
-    private hInternal;
-    private sInternal;
-    private lInternal;
-    private dirtyInternal;
-    private rgbDirty;
-    private hslDirty;
-    constructor();
-    /**
-     * @param r - Red (0-1)
-     * @param g - Green (0-1)
-     * @param b - Blue (0-1)
-     * @param a - Alpha (0-1)
-     */
-    constructor(r: number, g: number, b: number, a?: number);
-    /**
-     * @param colorName - Named color
-     * @param a - Alpha (0-1)
-     */
-    constructor(colorName: FXColorName, a?: number);
-    /**
-     * @param threeColor - Three.js Color object
-     * @param a - Alpha (0-1)
-     */
-    constructor(threeColor: Color, a?: number);
-    /**
-     * @param hexRGB - Hex RGB value (e.g., 0xff0000)
-     * @param a - Alpha (0-1)
-     */
-    constructor(hexRGB: number, a?: number);
-    /**
-     * @param hexString - Hex string (e.g., "#ffffff" or "#ffffffff")
-     */
-    constructor(hexString?: string);
-    /**
-     * @param uiColor - FXColor object to copy from
-     */
-    constructor(uiColor?: FXColor);
-    /**
-     * @param uiColorConfig - FXColorConfig object
-     */
-    constructor(uiColorConfig?: FXColorConfig);
-    /** Black (0x000000) */
-    static get black(): FXColor;
-    /** White (0xffffff) */
-    static get white(): FXColor;
-    /** Red (0xff0000) */
-    static get red(): FXColor;
-    /** Green (0x008000) */
-    static get green(): FXColor;
-    /** Blue (0x0000ff) */
-    static get blue(): FXColor;
-    /** Yellow (0xffff00) */
-    static get yellow(): FXColor;
-    /** Cyan (0x00ffff) */
-    static get cyan(): FXColor;
-    /** Magenta (0xff00ff) */
-    static get magenta(): FXColor;
-    /** Gray (0x808080) */
-    static get gray(): FXColor;
-    /** Grey (0x808080) */
-    static get grey(): FXColor;
-    /** Silver (0xc0c0c0) */
-    static get silver(): FXColor;
-    /** Maroon (0x800000) */
-    static get maroon(): FXColor;
-    /** Olive (0x808000) */
-    static get olive(): FXColor;
-    /** Lime (0x00ff00) */
-    static get lime(): FXColor;
-    /** Aqua (0x00ffff) */
-    static get aqua(): FXColor;
-    /** Teal (0x008080) */
-    static get teal(): FXColor;
-    /** Navy (0x000080) */
-    static get navy(): FXColor;
-    /** Fuchsia (0xff00ff) */
-    static get fuchsia(): FXColor;
-    /** Purple (0x800080) */
-    static get purple(): FXColor;
-    /** Orange (0xffa500) */
-    static get orange(): FXColor;
-    /** Pink (0xffc0cb) */
-    static get pink(): FXColor;
-    /** Brown (0xa52a2a) */
-    static get brown(): FXColor;
-    /** Gold (0xffd700) */
-    static get gold(): FXColor;
-    /** Violet (0xee82ee) */
-    static get violet(): FXColor;
-    /** Indigo (0x4b0082) */
-    static get indigo(): FXColor;
-    /** Coral (0xff7f50) */
-    static get coral(): FXColor;
-    /** Salmon (0xfa8072) */
-    static get salmon(): FXColor;
-    /** Khaki (0xf0e68c) */
-    static get khaki(): FXColor;
-    /** Plum (0xdda0dd) */
-    static get plum(): FXColor;
-    /** Orchid (0xda70d6) */
-    static get orchid(): FXColor;
-    /** Tan (0xd2b48c) */
-    static get tan(): FXColor;
-    /** Beige (0xf5f5dc) */
-    static get beige(): FXColor;
-    /** Mint (0x98fb98) */
-    static get mint(): FXColor;
-    /** Lavender (0xe6e6fa) */
-    static get lavender(): FXColor;
-    /** Crimson (0xdc143c) */
-    static get crimson(): FXColor;
-    /** Azure (0xf0ffff) */
-    static get azure(): FXColor;
-    /** Ivory (0xfffff0) */
-    static get ivory(): FXColor;
-    /** Snow (0xfffafa) */
-    static get snow(): FXColor;
-    /** Red component (0 to 1) */
-    get r(): number;
-    /** Green component (0 to 1) */
-    get g(): number;
-    /** Blue component (0 to 1) */
-    get b(): number;
-    /** Alpha component (0 to 1) */
-    get a(): number;
-    /** Hue component (0 to 360) */
-    get hue(): number;
-    /** Saturation component (0 to 1) */
-    get saturation(): number;
-    /** Lightness component (0 to 1) */
-    get lightness(): number;
-    /** Red component (0 to 1) */
-    set r(value: number);
-    /** Green component (0 to 1) */
-    set g(value: number);
-    /** Blue component (0 to 1) */
-    set b(value: number);
-    /** Alpha component (0 to 1) */
-    set a(value: number);
-    /** Hue component (0 to 360) */
-    set hue(value: number);
-    /** Saturation component (0 to 1) */
-    set saturation(value: number);
-    /** Lightness component (0 to 1) */
-    set lightness(value: number);
-    /** Sets to white (default) */
-    set(): this;
-    /**
-     * @param r - Red (0-1)
-     * @param g - Green (0-1)
-     * @param b - Blue (0-1)
-     * @param a - Alpha (0-1)
-     */
-    set(r: number, g: number, b: number, a?: number): this;
-    /**
-     * @param colorName - Named color
-     * @param a - Alpha (0-1)
-     */
-    set(colorName: FXColorName, a?: number): this;
-    /**
-     * @param threeColor - Three.js Color object
-     * @param a - Alpha (0-1)
-     */
-    set(threeColor: Color, a?: number): this;
-    /**
-     * @param hexRGB - Hex RGB value (e.g., 0xff0000)
-     * @param a - Alpha (0-1)
-     */
-    set(hexRGB: number, a?: number): this;
-    /**
-     * @param hexString - Hex string (e.g., "#ffffff" or "#ffffffff")
-     */
-    set(hexString: string): this;
-    /**
-     * @param uiColor - FXColor object to copy from
-     */
-    set(uiColor: FXColor): this;
-    /**
-     * @param uiColorConfig - FXColorConfig object
-     */
-    set(uiColorConfig?: FXColorConfig): this;
-    /** Sets RGBA components directly */
-    setRGBA(r: number, g: number, b: number, a?: number): this;
-    /** Returns RGBA as 32-bit hex (RRGGBBAA) */
-    getHexRGBA(): number;
-    /** Returns RGB as 24-bit hex (RRGGBB) */
-    getHexRGB(): number;
-    /** Returns RGB as hex string ("#ffffff") */
-    getHexStringRGB(): string;
-    /** Returns RGBA as hex string ("#ffffffff") */
-    getHexStringRGBA(): string;
-    /** Sets from 32-bit hex RGBA (RRGGBBAA) */
-    setHexRGBA(hex: number): this;
-    /** Sets from 24-bit hex RGB (RRGGBB) */
-    setHexRGB(hex: number, a?: number): this;
-    /**
-     * Sets from hex string.
-     *
-     * @param hexString - Format: "#ffffff" or "#ffffffff"
-     * @throws If format invalid
-     */
-    setHexString(hexString: string): this;
-    /** Sets from HSL values */
-    setHSL(h: number, s: number, l: number, a?: number): this;
-    /**
-     * Sets from predefined name.
-     *
-     * @throws If color name unknown
-     */
-    setColorName(colorName: FXColorName, a?: number): this;
-    /** Sets from linear (GLSL) color space */
-    setGLSLColor(r: number, g: number, b: number, a?: number): this;
-    /** Sets from Three.js Color */
-    setThreeColor(threeColor: Color, a?: number): this;
-    /** Returns CSS color string ("rgba(255, 0, 0, 1)") */
-    toCSSColor(): string;
-    /** Converts to linear (GLSL) color space */
-    toGLSLColor(result?: Vector4): Vector4;
-    /** Converts to Three.js Color (without alpha) */
-    toThreeColor(result?: Color): Color;
-    /** Copies from another color */
-    copy(color: FXColor | Color): this;
-    /** Returns copy of this color */
-    clone(): FXColor;
-    private ensureHSLUpdatedFromRGB;
-}