sparcoon 0.7.3 → 0.9.1

package/dist/miscellaneous/curve/FXCurve1D.js

@@ -1,94 +0,0 @@
-import { assertValidNumber } from '../asserts.js';
-
-/**
- * 1D curve defined by anchor points at explicit normalized positions.
- *
- * Anchors must be strictly ascending by `value`, first must be `0`, last must be `1`.
- * Output at each anchor is a value of type `T` - interpolation is left to the caller.
- */
-class FXCurve1D {
-    /**
-     * @param config - Explicit anchor points, a uniform shorthand array, or another {@link FXCurve1D} to copy
-     */
-    constructor(config) {
-        if (config instanceof FXCurve1D) {
-            this._private_anchorsInternal = config._private_anchorsInternal.map((anchor) => ({ ...anchor }));
-            return;
-        }
-        const isPointArray = config.length > 0 &&
-            typeof config[0] === "object" &&
-            !Array.isArray(config[0]) &&
-            "value" in config[0];
-        const points = isPointArray
-            ? config
-            : config.map((value, index) => ({
-                value,
-                position: index / (config.length - 1),
-            }));
-        if (points.length < 2) {
-            throw new Error("FXCurve1D: at least 2 anchor points are required");
-        }
-        if (points[0].position !== 0) {
-            throw new Error(`FXCurve1D: first anchor value must be 0, got ${points[0].position}`);
-        }
-        if (points[points.length - 1].position !== 1) {
-            throw new Error(`FXCurve1D: last anchor value must be 1, got ${points[points.length - 1].position}`);
-        }
-        this._private_anchorsInternal = [];
-        for (let index = 0; index < points.length; index++) {
-            const { value, position } = points[index];
-            if (position < 0 || position > 1) {
-                throw new Error(`FXCurve1D: anchor[${index}].value must be in [0, 1], got ${position}`);
-            }
-            if (index > 0 && position <= points[index - 1].position) {
-                throw new Error(`FXCurve1D: anchor[${index}].value (${position}) must be strictly greater than anchor[${index - 1}].value (${points[index - 1].position})`);
-            }
-            this._private_anchorsInternal.push({ value, position });
-        }
-    }
-    /** Resolved anchor points ordered ascending by `value`. */
-    get anchors() {
-        return this._private_anchorsInternal;
-    }
-    /**
-     * Samples the curve at normalized position `t`.
-     *
-     * Returns the two bracketing anchor values and the local interpolation factor `t` in [0, 1].
-     * The caller is responsible for interpolating between `a` and `b` using `t`.
-     *
-     * @param t - Normalized position in [0, 1]
-     * @internal
-     */
-    sample(t) {
-        assertValidNumber(t, "FXCurve1D.sample.t");
-        const anchors = this._private_anchorsInternal;
-        const anchorCount = anchors.length;
-        let segmentIndex;
-        if (anchorCount < 10) {
-            segmentIndex = 0;
-            while (segmentIndex < anchorCount - 2 && anchors[segmentIndex + 1].position <= t) {
-                segmentIndex++;
-            }
-        }
-        else {
-            let low = 0;
-            let high = anchorCount - 2;
-            while (low < high) {
-                const mid = (low + high + 1) >> 1;
-                if (anchors[mid].position <= t) {
-                    low = mid;
-                }
-                else {
-                    high = mid - 1;
-                }
-            }
-            segmentIndex = low;
-        }
-        const anchorA = anchors[segmentIndex];
-        const anchorB = anchors[segmentIndex + 1];
-        const localT = (t - anchorA.position) / (anchorB.position - anchorA.position);
-        return { a: anchorA.value, b: anchorB.value, t: localT };
-    }
-}
-
-export { FXCurve1D };

package/dist/miscellaneous/miscellaneous.d.ts

@@ -1,34 +0,0 @@
-import type { Vector3Tuple } from "three";
-import { DataTexture } from "three";
-import type { Vector3Like } from "../miscellaneous/math";
-import type { FXTextureConfig } from "../miscellaneous/texture/FXTextureView.Internal";
-import type { FXColor } from "./color/FXColor";
-import type { FXCurve1D } from "./curve/FXCurve1D";
-export interface FXRange {
-    min: number;
-    max: number;
-}
-export type FXRangeConfig = FXRange | [number, number, number] | number;
-export type FXVector3Config = Vector3Like | Vector3Tuple | number;
-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 buildGradientTexture(curve: FXCurve1D<FXColor>): DataTexture;
-export declare const BUILTIN_OFFSET_POSITION_X = 0;
-export declare const BUILTIN_OFFSET_POSITION_Y = 1;
-export declare const BUILTIN_OFFSET_POSITION_Z = 2;
-export declare const BUILTIN_OFFSET_VELOCITY_X = 3;
-export declare const BUILTIN_OFFSET_VELOCITY_Y = 4;
-export declare const BUILTIN_OFFSET_VELOCITY_Z = 5;
-export declare const BUILTIN_OFFSET_SCALE_X = 6;
-export declare const BUILTIN_OFFSET_SCALE_Y = 7;
-export declare const BUILTIN_OFFSET_SCALE_Z = 8;
-export declare const BUILTIN_OFFSET_ROTATION = 9;
-export declare const BUILTIN_OFFSET_TORQUE = 10;
-export declare const BUILTIN_OFFSET_LIFETIME = 11;
-export declare const BUILTIN_OFFSET_AGE = 12;
-export declare const BUILTIN_OFFSET_RANDOM_A = 13;
-export declare const BUILTIN_OFFSET_RANDOM_B = 14;
-export declare const BUILTIN_OFFSET_RANDOM_C = 15;
-export declare const PARTICLE_DEFINES = "\n  #define PARTICLE_POSITION_X p_builtin[0][0]\n  #define PARTICLE_POSITION_Y p_builtin[0][1]\n  #define PARTICLE_POSITION_Z p_builtin[0][2]\n\n  #define PARTICLE_VELOCITY_X p_builtin[0][3]\n  #define PARTICLE_VELOCITY_Y p_builtin[1][0]\n  #define PARTICLE_VELOCITY_Z p_builtin[1][1]\n\n  #define PARTICLE_SCALE_X p_builtin[1][2]\n  #define PARTICLE_SCALE_Y p_builtin[1][3]\n  #define PARTICLE_SCALE_Z p_builtin[2][0]\n\n  #define PARTICLE_ROTATION p_builtin[2][1]\n  #define PARTICLE_TORQUE p_builtin[2][2]\n\n  #define PARTICLE_LIFETIME p_builtin[2][3]\n  #define PARTICLE_AGE p_builtin[3][0]\n\n  #define PARTICLE_RANDOM_A p_builtin[3][1]\n  #define PARTICLE_RANDOM_B p_builtin[3][2]\n  #define PARTICLE_RANDOM_C p_builtin[3][3]\n";

package/dist/miscellaneous/miscellaneous.js

@@ -1,85 +0,0 @@
-import { Texture, DataTexture, RGBAFormat, UnsignedByteType, UVMapping, ClampToEdgeWrapping, LinearFilter, SRGBColorSpace } from 'three';
-
-function resolveFXRangeConfig(config) {
-    if (typeof config === "number") {
-        return { min: config, max: config };
-    }
-    if (Array.isArray(config)) {
-        return { min: config[0], max: config[1] };
-    }
-    return config;
-}
-function resolveFXVector3Config(config) {
-    if (typeof config === "number") {
-        return { x: config, y: config, z: config };
-    }
-    if (Array.isArray(config)) {
-        return { x: config[0], y: config[1], z: config[2] };
-    }
-    return config;
-}
-function resolveAspect(config) {
-    if (typeof config === "number") {
-        return config;
-    }
-    if (config instanceof Texture) {
-        return config.image.naturalWidth / config.image.naturalHeight;
-    }
-    return config.sourceSize.w / config.sourceSize.h;
-}
-function buildGradientTexture(curve) {
-    const width = curve.anchors.length;
-    const height = 1;
-    const data = new Uint8Array(width * height * 4);
-    for (let i = 0; i < width; i++) {
-        const color = curve.anchors[i].value;
-        const index = i * 4;
-        data[index] = Math.round(color.r * 255);
-        data[index + 1] = Math.round(color.g * 255);
-        data[index + 2] = Math.round(color.b * 255);
-        data[index + 3] = Math.round(color.a * 255);
-    }
-    const texture = new DataTexture(data, width, height, RGBAFormat, UnsignedByteType, UVMapping, ClampToEdgeWrapping, ClampToEdgeWrapping, LinearFilter, LinearFilter, 1, SRGBColorSpace);
-    texture.needsUpdate = true;
-    return texture;
-}
-const BUILTIN_OFFSET_POSITION_X = 0;
-const BUILTIN_OFFSET_POSITION_Y = 1;
-const BUILTIN_OFFSET_POSITION_Z = 2;
-const BUILTIN_OFFSET_VELOCITY_X = 3;
-const BUILTIN_OFFSET_VELOCITY_Y = 4;
-const BUILTIN_OFFSET_VELOCITY_Z = 5;
-const BUILTIN_OFFSET_SCALE_X = 6;
-const BUILTIN_OFFSET_SCALE_Y = 7;
-const BUILTIN_OFFSET_ROTATION = 9;
-const BUILTIN_OFFSET_TORQUE = 10;
-const BUILTIN_OFFSET_LIFETIME = 11;
-const BUILTIN_OFFSET_AGE = 12;
-const BUILTIN_OFFSET_RANDOM_A = 13;
-const BUILTIN_OFFSET_RANDOM_B = 14;
-const BUILTIN_OFFSET_RANDOM_C = 15;
-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]
-`;
-
-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, PARTICLE_DEFINES, buildGradientTexture, resolveAspect, resolveFXRangeConfig, resolveFXVector3Config };

package/dist/miscellaneous/texture/FXTextureView.Internal.d.ts

@@ -1,49 +0,0 @@
-import { Texture } from "three";
-export declare const TEXTURE_DEFAULT_TEXTURE: Texture;
-export declare const TEXTURE_DEFAULT_SIZE = 2;
-/** Rectangle coordinates and dimensions in atlas */
-export interface FXTextureRect {
-    /** X coordinate in pixels */
-    x: number;
-    /** Y coordinate in pixels */
-    y: number;
-    /** Width in pixels */
-    w: number;
-    /** Height in pixels */
-    h: number;
-}
-/** Size dimensions */
-export interface FXTextureSize {
-    /** Width in pixels */
-    w: number;
-    /** Height in pixels */
-    h: number;
-}
-/** Transparent padding around visible content */
-export interface FXTextureTrim {
-    /** Left padding in world units */
-    left: number;
-    /** Right padding in world units */
-    right: number;
-    /** Top padding in world units */
-    top: number;
-    /** Bottom padding in world units */
-    bottom: number;
-}
-/** Configuration for texture atlas sprite */
-export interface FXTextureAtlasConfig {
-    /** Source texture atlas */
-    texture: Texture;
-    /** Rectangle in atlas containing sprite */
-    frame: FXTextureRect;
-    /** Whether sprite is rotated 90 degrees clockwise */
-    rotated?: boolean;
-    /** Position and size within original image before trimming */
-    spriteSourceSize: FXTextureRect;
-    /** Original image dimensions before trimming */
-    sourceSize: FXTextureSize;
-    /** Scale factor for resolution independence */
-    scale?: number;
-}
-/** Texture configuration from direct texture or atlas sprite */
-export type FXTextureConfig = Texture | FXTextureAtlasConfig;

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 };

package/dist/miscellaneous/texture/FXTextureView.d.ts

@@ -1,72 +0,0 @@
-import type { FerrsignView3 } from "ferrsign";
-import { Matrix3, Texture, Vector2 } from "three";
-import type { FXTextureConfig } from "./FXTextureView.Internal";
-/** Wrapper for Three.js texture with atlas and trim support. Does not own the underlying texture; user must dispose it. */
-export declare class FXTextureView {
-    private textureInternal;
-    private sourceWidth;
-    private sourceHeight;
-    private frameX;
-    private frameY;
-    private frameWidth;
-    private frameHeight;
-    private rotatedInternal;
-    private scaleInternal;
-    private trimLeft;
-    private trimRight;
-    private trimTop;
-    private trimBottom;
-    private textureDirtyInternal;
-    private uvTransformDirtyInternal;
-    private trimDirtyInternal;
-    private readonly signalDiminsionsChangedInternal;
-    /** @param config Texture or atlas configuration */
-    constructor(config?: FXTextureConfig);
-    /** Original width before trimming in world units */
-    get width(): number;
-    /** Original height before trimming in world units */
-    get height(): number;
-    /** Visible width after trimming in world units */
-    get trimmedWidth(): number;
-    /** Visible height after trimming in world units */
-    get trimmedHeight(): number;
-    /** Underlying Three.js texture */
-    get texture(): Texture;
-    /** Whether sprite is rotated in atlas */
-    get rotated(): boolean;
-    /** Scale factor for resolution independence */
-    get scale(): number;
-    /** Transparent padding around visible content */
-    get trim(): Readonly<{
-        left: number;
-        right: number;
-        top: number;
-        bottom: number;
-    }>;
-    get textureDirty(): boolean;
-    /** Whether UV transform inputs changed since last check */
-    get uvTransformDirty(): boolean;
-    /** Whether trim values changed since last check */
-    get trimDirty(): boolean;
-    get signalDiminsionsChanged(): FerrsignView3<number, number, FXTextureView>;
-    setTextureDirtyFalse(): void;
-    /**
-     * Calculates UV transform matrix for shader sampling.
-     * @param result Matrix to store result in
-     * @returns UV transform matrix
-     */
-    calculateUVTransform(result?: Matrix3): Matrix3;
-    /**
-     * Gets original dimensions before trimming.
-     * @param result Vector to store result in
-     * @returns Width and height in world units
-     */
-    getResolution(result?: Vector2): Vector2;
-    /**
-     * Replaces texture with new configuration.
-     * @param config Texture or atlas configuration
-     */
-    set(config: FXTextureConfig): void;
-    private setFromTexture;
-    private setFromAtlasConfig;
-}

package/dist/miscellaneous/texture/FXTextureView.js

@@ -1,234 +0,0 @@
-import { Ferrsign3 } from 'ferrsign';
-import { Matrix3, Vector2, Texture } from 'three';
-import { assertValidPositiveNumber, assertValidNonNegativeNumber } from '../asserts.js';
-import { TEXTURE_DEFAULT_TEXTURE, TEXTURE_DEFAULT_SIZE } from './FXTextureView.Internal.js';
-
-/** Wrapper for Three.js texture with atlas and trim support. Does not own the underlying texture; user must dispose it. */
-class FXTextureView {
-    /** @param config Texture or atlas configuration */
-    constructor(config) {
-        this._private_textureInternal = TEXTURE_DEFAULT_TEXTURE;
-        this._private_sourceWidth = TEXTURE_DEFAULT_SIZE;
-        this._private_sourceHeight = TEXTURE_DEFAULT_SIZE;
-        this._private_frameX = 0;
-        this._private_frameY = 0;
-        this._private_frameWidth = TEXTURE_DEFAULT_SIZE;
-        this._private_frameHeight = TEXTURE_DEFAULT_SIZE;
-        this._private_rotatedInternal = false;
-        this._private_scaleInternal = 1;
-        this._private_trimLeft = 0;
-        this._private_trimRight = 0;
-        this._private_trimTop = 0;
-        this._private_trimBottom = 0;
-        this._private_textureDirtyInternal = false;
-        this._private_uvTransformDirtyInternal = false;
-        this._private_trimDirtyInternal = false;
-        this._private_signalDiminsionsChangedInternal = new Ferrsign3();
-        if (config !== undefined) {
-            this.set(config);
-        }
-    }
-    /** Original width before trimming in world units */
-    get width() {
-        return this._private_sourceWidth / this._private_scaleInternal;
-    }
-    /** Original height before trimming in world units */
-    get height() {
-        return this._private_sourceHeight / this._private_scaleInternal;
-    }
-    /** Visible width after trimming in world units */
-    get trimmedWidth() {
-        const frameSize = this._private_rotatedInternal ? this._private_frameHeight : this._private_frameWidth;
-        return frameSize / this._private_scaleInternal;
-    }
-    /** Visible height after trimming in world units */
-    get trimmedHeight() {
-        const frameSize = this._private_rotatedInternal ? this._private_frameWidth : this._private_frameHeight;
-        return frameSize / this._private_scaleInternal;
-    }
-    /** Underlying Three.js texture */
-    get texture() {
-        return this._private_textureInternal;
-    }
-    /** Whether sprite is rotated in atlas */
-    get rotated() {
-        return this._private_rotatedInternal;
-    }
-    /** Scale factor for resolution independence */
-    get scale() {
-        return this._private_scaleInternal;
-    }
-    /** Transparent padding around visible content */
-    get trim() {
-        const scale = this._private_scaleInternal;
-        return {
-            left: this._private_trimLeft / scale,
-            right: this._private_trimRight / scale,
-            top: this._private_trimTop / scale,
-            bottom: this._private_trimBottom / scale,
-        };
-    }
-    get textureDirty() {
-        return this._private_textureDirtyInternal;
-    }
-    /** Whether UV transform inputs changed since last check */
-    get uvTransformDirty() {
-        return this._private_uvTransformDirtyInternal;
-    }
-    /** Whether trim values changed since last check */
-    get trimDirty() {
-        return this._private_trimDirtyInternal;
-    }
-    get signalDiminsionsChanged() {
-        return this._private_signalDiminsionsChangedInternal;
-    }
-    setTextureDirtyFalse() {
-        this._private_textureDirtyInternal = false;
-    }
-    /** Marks UV transform as clean. @internal */
-    setUVTransformDirtyFalse() {
-        this._private_uvTransformDirtyInternal = false;
-    }
-    /** Marks trim as clean. @internal */
-    setTrimDirtyFalse() {
-        this._private_trimDirtyInternal = false;
-    }
-    /**
-     * Calculates UV transform matrix for shader sampling.
-     * @param result Matrix to store result in
-     * @returns UV transform matrix
-     */
-    calculateUVTransform(result = new Matrix3()) {
-        const atlasWidth = this._private_textureInternal.image?.naturalWidth ?? TEXTURE_DEFAULT_SIZE;
-        const atlasHeight = this._private_textureInternal.image?.naturalHeight ?? TEXTURE_DEFAULT_SIZE;
-        if (this._private_rotatedInternal) {
-            const physicalWidth = this._private_frameHeight;
-            const physicalHeight = this._private_frameWidth;
-            const u0 = this._private_frameX / atlasWidth;
-            const v0 = (atlasHeight - this._private_frameY - physicalHeight) / atlasHeight;
-            const uSize = physicalWidth / atlasWidth;
-            const vSize = physicalHeight / atlasHeight;
-            result.set(0, uSize, u0, -vSize, 0, v0 + vSize, 0, 0, 1);
-        }
-        else {
-            const u0 = this._private_frameX / atlasWidth;
-            const v0 = (atlasHeight - this._private_frameY - this._private_frameHeight) / atlasHeight;
-            const uSize = this._private_frameWidth / atlasWidth;
-            const vSize = this._private_frameHeight / atlasHeight;
-            result.set(uSize, 0, u0, 0, vSize, v0, 0, 0, 1);
-        }
-        return result;
-    }
-    /**
-     * Gets original dimensions before trimming.
-     * @param result Vector to store result in
-     * @returns Width and height in world units
-     */
-    getResolution(result = new Vector2()) {
-        return result.set(this.width, this.height);
-    }
-    /**
-     * Replaces texture with new configuration.
-     * @param config Texture or atlas configuration
-     */
-    set(config) {
-        const lastWidth = this.width;
-        const lastHeight = this.height;
-        if (config instanceof Texture) {
-            this._private_setFromTexture(config);
-        }
-        else {
-            this._private_setFromAtlasConfig(config);
-        }
-        if (this.width !== lastWidth || this.height !== lastHeight) {
-            this._private_signalDiminsionsChangedInternal.emit(this.width, this.height, this);
-        }
-    }
-    _private_setFromTexture(texture) {
-        const width = texture.image?.naturalWidth ?? TEXTURE_DEFAULT_SIZE;
-        const height = texture.image?.naturalHeight ?? TEXTURE_DEFAULT_SIZE;
-        this._private_sourceWidth = width;
-        this._private_sourceHeight = height;
-        if (this.texture !== texture) {
-            this._private_textureInternal = texture;
-            this._private_textureDirtyInternal = true;
-        }
-        if (this._private_frameX !== 0 ||
-            this._private_frameY !== 0 ||
-            this._private_frameWidth !== width ||
-            this._private_frameHeight !== height ||
-            this._private_scaleInternal !== 1 || this._private_rotatedInternal) {
-            this._private_frameX = 0;
-            this._private_frameY = 0;
-            this._private_frameWidth = width;
-            this._private_frameHeight = height;
-            this._private_rotatedInternal = false;
-            this._private_scaleInternal = 1;
-            this._private_uvTransformDirtyInternal = true;
-        }
-        if (this._private_trimLeft !== 0 ||
-            this._private_trimRight !== 0 ||
-            this._private_trimTop !== 0 ||
-            this._private_trimBottom !== 0) {
-            this._private_trimLeft = 0;
-            this._private_trimRight = 0;
-            this._private_trimTop = 0;
-            this._private_trimBottom = 0;
-            this._private_trimDirtyInternal = true;
-        }
-    }
-    _private_setFromAtlasConfig(config) {
-        assertValidPositiveNumber(config.sourceSize.w, "FXTextureView.setFromAtlasConfig.config.sourceSize.w");
-        assertValidPositiveNumber(config.sourceSize.h, "FXTextureView.setFromAtlasConfig.config.sourceSize.h");
-        assertValidNonNegativeNumber(config.frame.x, "FXTextureView.setFromAtlasConfig.config.frame.x");
-        assertValidNonNegativeNumber(config.frame.y, "FXTextureView.setFromAtlasConfig.config.frame.y");
-        assertValidPositiveNumber(config.frame.w, "FXTextureView.setFromAtlasConfig.config.frame.w");
-        assertValidPositiveNumber(config.frame.h, "FXTextureView.setFromAtlasConfig.config.frame.h");
-        assertValidNonNegativeNumber(config.spriteSourceSize.x, "FXTextureView.setFromAtlasConfig.config.spriteSourceSize.x");
-        assertValidNonNegativeNumber(config.spriteSourceSize.y, "FXTextureView.setFromAtlasConfig.config.spriteSourceSize.y");
-        assertValidPositiveNumber(config.spriteSourceSize.w, "FXTextureView.setFromAtlasConfig.config.spriteSourceSize.w");
-        assertValidPositiveNumber(config.spriteSourceSize.h, "FXTextureView.setFromAtlasConfig.config.spriteSourceSize.h");
-        if (config.scale !== undefined) {
-            assertValidPositiveNumber(config.scale, "FXTextureView.setFromAtlasConfig.config.scale");
-        }
-        this._private_sourceWidth = config.sourceSize.w;
-        this._private_sourceHeight = config.sourceSize.h;
-        if (this.texture !== config.texture) {
-            this._private_textureInternal = config.texture;
-            this._private_textureDirtyInternal = true;
-        }
-        const scale = config.scale ?? 1;
-        const rotated = config.rotated ?? false;
-        if (this._private_frameX !== 0 ||
-            this._private_frameY !== 0 ||
-            this._private_frameWidth !== config.frame.w ||
-            this._private_frameHeight !== config.frame.h ||
-            this._private_scaleInternal !== scale ||
-            this._private_rotatedInternal !== rotated) {
-            this._private_frameX = config.frame.x;
-            this._private_frameY = config.frame.y;
-            this._private_frameWidth = config.frame.w;
-            this._private_frameHeight = config.frame.h;
-            this._private_scaleInternal = scale;
-            this._private_rotatedInternal = rotated;
-            this._private_uvTransformDirtyInternal = true;
-        }
-        const spriteSource = config.spriteSourceSize;
-        const trimLeft = spriteSource.x;
-        const trimTop = spriteSource.y;
-        const trimRight = this._private_sourceWidth - spriteSource.x - spriteSource.w;
-        const trimBottom = this._private_sourceHeight - spriteSource.y - spriteSource.h;
-        if (this._private_trimLeft !== trimLeft ||
-            this._private_trimRight !== trimRight ||
-            this._private_trimTop !== trimTop ||
-            this._private_trimBottom !== trimBottom) {
-            this._private_trimLeft = trimLeft;
-            this._private_trimRight = trimRight;
-            this._private_trimTop = trimTop;
-            this._private_trimBottom = trimBottom;
-            this._private_trimDirtyInternal = true;
-        }
-    }
-}
-
-export { FXTextureView };

package/dist/miscellaneous/webglCapabilities.d.ts

@@ -1 +0,0 @@
-export declare const checkSRGBSupport: () => boolean;

package/dist/miscellaneous/webglCapabilities.js

@@ -1,45 +0,0 @@
-/**
- * Checks sRGB support
- */
-function checkSRGBSupportInternal() {
-    const canvasElement = document.createElement("canvas");
-    const gl = canvasElement.getContext("webgl2") ?? canvasElement.getContext("webgl");
-    if (!gl) {
-        return false;
-    }
-    if (gl instanceof WebGL2RenderingContext) {
-        try {
-            const texture = gl.createTexture();
-            gl.bindTexture(gl.TEXTURE_2D, texture);
-            gl.texStorage2D(gl.TEXTURE_2D, 1, gl.SRGB8_ALPHA8, 2, 2);
-            const errorCode = gl.getError();
-            gl.deleteTexture(texture);
-            return errorCode === gl.NO_ERROR;
-        }
-        catch {
-            return false;
-        }
-    }
-    const extension = gl.getExtension("EXT_sRGB");
-    if (!extension) {
-        return false;
-    }
-    try {
-        const texture = gl.createTexture();
-        gl.bindTexture(gl.TEXTURE_2D, texture);
-        gl.texImage2D(gl.TEXTURE_2D, 0, extension.SRGB_ALPHA_EXT, 2, 2, 0, extension.SRGB_ALPHA_EXT, gl.UNSIGNED_BYTE, null);
-        const errorCode = gl.getError();
-        gl.deleteTexture(texture);
-        return errorCode === gl.NO_ERROR;
-    }
-    catch {
-        return false;
-    }
-}
-let SRGB_SUPPORTED_INTERNAL;
-const checkSRGBSupport = () => {
-    SRGB_SUPPORTED_INTERNAL ?? (SRGB_SUPPORTED_INTERNAL = checkSRGBSupportInternal());
-    return SRGB_SUPPORTED_INTERNAL;
-};
-
-export { checkSRGBSupport };