@solidtv/renderer 1.0.0

package/dist/src/core/textures/SubTexture.js

@@ -0,0 +1,99 @@
+import { assertTruthy } from '../../utils.js';
+import { ImageTexture } from './ImageTexture.js';
+import { Texture, TextureType, } from './Texture.js';
+let subTextureId = 0;
+/**
+ * A Texture that is a sub-region of another Texture.
+ *
+ * @remarks
+ * The parent texture can be a Sprite Sheet/Texture Atlas and set using the
+ * {@link SubTextureProps.texture} prop. The sub-region relative to the parent
+ * texture is defined with the {@link SubTextureProps.x},
+ * {@link SubTextureProps.y}, {@link SubTextureProps.w}, and
+ * {@link SubTextureProps.h} pixel values.
+ */
+export class SubTexture extends Texture {
+    props;
+    parentTexture;
+    type = TextureType.subTexture;
+    subtextureId = `subtexture-${subTextureId++}`;
+    constructor(txManager, props) {
+        super(txManager);
+        this.props = props;
+        assertTruthy(this.props.texture, 'SubTexture requires a parent texture');
+        assertTruthy(this.props.texture instanceof ImageTexture, 'SubTexture requires an ImageTexture parent');
+        // Resolve parent texture from cache or fallback to provided texture
+        this.parentTexture = txManager.resolveParentTexture(this.props.texture);
+        if (this.renderableOwners.length > 0) {
+            this.parentTexture.setRenderableOwner(this.subtextureId, true);
+        }
+        // If parent texture is already loaded / failed, trigger loaded event manually
+        // so that users get a consistent event experience.
+        // We do this in a microtask to allow listeners to be attached in the same
+        // synchronous task after calling loadTexture()
+        queueMicrotask(() => {
+            const parentTx = this.parentTexture;
+            if (parentTx.state === 'loaded' && parentTx.dimensions !== null) {
+                this.onParentTxLoaded(parentTx, parentTx.dimensions);
+            }
+            else if (parentTx.state === 'loading') {
+                this.onParentTxLoading();
+            }
+            else if (parentTx.state === 'failed' && parentTx.error !== null) {
+                this.onParentTxFailed(parentTx, parentTx.error);
+            }
+            else if (parentTx.state === 'freed') {
+                this.onParentTxFreed();
+            }
+            parentTx.on('loading', this.onParentTxLoading);
+            parentTx.on('loaded', this.onParentTxLoaded);
+            parentTx.on('failed', this.onParentTxFailed);
+            parentTx.on('freed', this.onParentTxFreed);
+        });
+    }
+    onParentTxLoaded = () => {
+        // We ignore the parent's passed dimensions, and simply use the SubTexture's
+        // configured dimensions (because that's all that matters here)
+        this.setState('loaded', {
+            w: this.props.w,
+            h: this.props.h,
+        });
+    };
+    onParentTxFailed = (target, error) => {
+        this.retryCount = this.parentTexture.retryCount - 1;
+        this.setState('failed', error);
+    };
+    onParentTxLoading = () => {
+        this.setState('loading');
+    };
+    onParentTxFreed = () => {
+        this.setState('freed');
+    };
+    onChangeIsRenderable(isRenderable) {
+        // Propagate the renderable owner change to the parent texture
+        this.parentTexture.setRenderableOwner(this.subtextureId, isRenderable);
+    }
+    async getTextureSource() {
+        // Check if parent texture is loaded
+        return new Promise((resolve, reject) => {
+            resolve({
+                data: this.props,
+            });
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static makeCacheKey(props) {
+        return false;
+    }
+    static resolveDefaults(props) {
+        return {
+            texture: props.texture,
+            x: props.x || 0,
+            y: props.y || 0,
+            w: props.w || 0,
+            h: props.h || 0,
+        };
+    }
+    static z$__type__Props;
+}
+//# sourceMappingURL=SubTexture.js.map

package/dist/src/core/textures/SubTexture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubTexture.js","sourceRoot":"","sources":["../../../../src/core/textures/SubTexture.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EACL,OAAO,EACP,WAAW,GAKZ,MAAM,cAAc,CAAC;AAEtB,IAAI,YAAY,GAAG,CAAC,CAAC;AAwCrB;;;;;;;;;GASG;AACH,MAAM,OAAO,UAAW,SAAQ,OAAO;IACrC,KAAK,CAA4B;IACjC,aAAa,CAAU;IAEP,IAAI,GAAgB,WAAW,CAAC,UAAU,CAAC;IACpD,YAAY,GAAG,cAAc,YAAY,EAAE,EAAE,CAAC;IAErD,YAAY,SAA6B,EAAE,KAAgC;QACzE,KAAK,CAAC,SAAS,CAAC,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QAEnB,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,sCAAsC,CAAC,CAAC;QACzE,YAAY,CACV,IAAI,CAAC,KAAK,CAAC,OAAO,YAAY,YAAY,EAC1C,4CAA4C,CAC7C,CAAC;QAEF,oEAAoE;QACpE,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC,oBAAoB,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAExE,IAAI,IAAI,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACrC,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;QACjE,CAAC;QAED,8EAA8E;QAC9E,mDAAmD;QACnD,0EAA0E;QAC1E,+CAA+C;QAC/C,cAAc,CAAC,GAAG,EAAE;YAClB,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC;YACpC,IAAI,QAAQ,CAAC,KAAK,KAAK,QAAQ,IAAI,QAAQ,CAAC,UAAU,KAAK,IAAI,EAAE,CAAC;gBAChE,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,CAAC;YACvD,CAAC;iBAAM,IAAI,QAAQ,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;gBACxC,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,CAAC;iBAAM,IAAI,QAAQ,CAAC,KAAK,KAAK,QAAQ,IAAI,QAAQ,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;gBAClE,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC;YAClD,CAAC;iBAAM,IAAI,QAAQ,CAAC,KAAK,KAAK,OAAO,EAAE,CAAC;gBACtC,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,CAAC;YAED,QAAQ,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;YAC/C,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;YAC7C,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;YAC7C,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;QAC7C,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,gBAAgB,GAA8B,GAAG,EAAE;QACzD,4EAA4E;QAC5E,+DAA+D;QAC/D,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE;YACtB,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;YACf,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;SAChB,CAAC,CAAC;IACL,CAAC,CAAC;IAEM,gBAAgB,GAA8B,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;QACtE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,UAAU,GAAG,CAAC,CAAC;QACpD,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACjC,CAAC,CAAC;IAEM,iBAAiB,GAAG,GAAG,EAAE;QAC/B,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;IAC3B,CAAC,CAAC;IAEM,eAAe,GAAG,GAAG,EAAE;QAC7B,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC,CAAC;IAEO,oBAAoB,CAAC,YAAqB;QACjD,8DAA8D;QAC9D,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;IACzE,CAAC;IAEQ,KAAK,CAAC,gBAAgB;QAC7B,oCAAoC;QACpC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,OAAO,CAAC;gBACN,IAAI,EAAE,IAAI,CAAC,KAAK;aACjB,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED,6DAA6D;IAC7D,MAAM,CAAU,YAAY,CAAC,KAAsB;QACjD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,CAAU,eAAe,CAC7B,KAAsB;QAEtB,OAAO;YACL,OAAO,EAAE,KAAK,CAAC,OAAO;YACtB,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC;YACf,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC;YACf,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC;YACf,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC;SAChB,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,eAAe,CAAkB;CACzC"}

package/dist/src/core/textures/Texture.d.ts

@@ -0,0 +1,275 @@
+import type { CoreTextureManager } from '../CoreTextureManager.js';
+import type { SubTextureProps } from './SubTexture.js';
+import type { Dimensions } from '../../common/CommonTypes.js';
+import { EventEmitter } from '../../common/EventEmitter.js';
+import type { CoreContextTexture } from '../renderers/CoreContextTexture.js';
+import type { Bound } from '../lib/utils.js';
+import type { TextureError } from '../TextureError.js';
+/**
+ * Event handler for when a Texture is freed
+ */
+export type TextureFreedEventHandler = (target: any) => void;
+/**
+ * Event handler for when a Texture is loading
+ */
+export type TextureLoadingEventHandler = (target: any) => void;
+/**
+ * Event handler for when a Texture is loaded
+ */
+export type TextureLoadedEventHandler = (target: any, dimensions: Readonly<Dimensions>) => void;
+/**
+ * Represents compressed texture data.
+ */
+export interface CompressedData {
+    /**
+     * GLenum spcifying compression format
+     */
+    glInternalFormat: number;
+    /**
+     * All mipmap levels
+     */
+    mipmaps: ArrayBuffer[];
+    /**
+     * Supported container types ('pvr' or 'ktx').
+     */
+    type: 'pvr' | 'ktx' | 'astc';
+    /**
+     * The width of the compressed texture in pixels. Defaults to 0.
+     *
+     * @default 0
+     */
+    w: number;
+    /**
+     * The height of the compressed texture in pixels.
+     **/
+    h: number;
+    /**
+     * block info compressed texture format
+     */
+    blockInfo: {
+        width: number;
+        height: number;
+        bytes: number;
+    };
+}
+/**
+ * Event handler for when a Texture fails to load
+ */
+export type TextureFailedEventHandler = (target: any, error: TextureError) => void;
+/**
+ * TextureData that is used to populate a CoreContextTexture
+ */
+export interface TextureData {
+    /**
+     * The texture data
+     */
+    data: ImageBitmap | ImageData | SubTextureProps | CompressedData | HTMLImageElement | Uint8Array | null;
+    /**
+     * Premultiply alpha when uploading texture data to the GPU
+     *
+     * @defaultValue `false`
+     */
+    premultiplyAlpha?: boolean | null;
+}
+/**
+ * TextureCoords generally numbers between 0 - 1
+ */
+export type TextureCoords = Bound;
+export type TextureState = 'initial' | 'fetching' | 'fetched' | 'loading' | 'loaded' | 'failed' | 'freed';
+export declare enum TextureType {
+    'generic' = 0,
+    'color' = 1,
+    'image' = 2,
+    'noise' = 3,
+    'renderToTexture' = 4,
+    'subTexture' = 5
+}
+/**
+ * Represents a source of texture data for a CoreContextTexture.
+ *
+ * @remarks
+ * Texture sources are used to populate a CoreContextTexture when that texture
+ * is loaded. Texture data retrieved by the CoreContextTexture by the
+ * `getTextureData` method. It's the responsibility of the concerete `Texture`
+ * subclass to implement this method appropriately.
+ */
+export declare abstract class Texture extends EventEmitter {
+    protected txManager: CoreTextureManager;
+    /**
+     * The dimensions of the texture
+     *
+     * @remarks
+     * Until the texture data is loaded for the first time the value will be
+     * `null`.
+     */
+    private _dimensions;
+    private _error;
+    state: TextureState;
+    readonly renderableOwners: any[];
+    readonly renderable: boolean;
+    type: TextureType;
+    preventCleanup: boolean;
+    ctxTexture: CoreContextTexture | undefined;
+    textureData: TextureData | null;
+    memUsed: number;
+    /**
+     * Memory used by this texture in bytes
+     *
+     * @remarks
+     * This is tracked by the TextureMemoryManager and updated when the texture
+     * is loaded/freed. Set to 0 when texture is not loaded.
+     */
+    retryCount: number;
+    maxRetryCount: number;
+    /**
+     * Timestamp when texture was created (for startup grace period)
+     */
+    private createdAt;
+    /**
+     * Flag to track if grace period has expired to avoid repeated Date.now() calls
+     */
+    private gracePeriodExpired;
+    /**
+     * Grace period in milliseconds to prevent premature cleanup during app startup
+     * This helps prevent race conditions when bounds calculation is delayed
+     */
+    private static readonly STARTUP_GRACE_PERIOD;
+    constructor(txManager: CoreTextureManager);
+    get dimensions(): Dimensions | null;
+    get error(): TextureError | null;
+    /**
+     * Checks if the texture is within the startup grace period.
+     * During this period, textures are protected from cleanup to prevent
+     * race conditions during app initialization.
+     */
+    isWithinStartupGracePeriod(): boolean;
+    /**
+     * Checks if the texture can be safely cleaned up.
+     * Considers the renderable state, startup grace period, and renderable owners.
+     */
+    canBeCleanedUp(): boolean;
+    /**
+     * Add/remove an owner to/from the Texture based on its renderability.
+     *
+     * @remarks
+     * Any object can own a texture, be it a CoreNode or even the state object
+     * from a Text Renderer.
+     *
+     * When the reference to the texture that an owner object holds is replaced
+     * or cleared it must call this with `renderable=false` to release the owner
+     * association.
+     *
+     * @param owner
+     * @param renderable
+     */
+    setRenderableOwner(owner: string | number, renderable: boolean): void;
+    load(): void;
+    /**
+     * Event called when the Texture becomes renderable or unrenderable.
+     *
+     * @remarks
+     * Used by subclasses like SubTexture propogate then renderability of the
+     * Texture to other referenced Textures.
+     *
+     * @param isRenderable `true` if this Texture has renderable owners.
+     */
+    onChangeIsRenderable?(isRenderable: boolean): void;
+    /**
+     * Load the core context texture for this Texture.
+     * The ctxTexture is created by the renderer and lives on the GPU.
+     *
+     * @returns
+     */
+    loadCtxTexture(): CoreContextTexture;
+    /**
+     * Free the core context texture for this Texture.
+     *
+     * @remarks
+     * The ctxTexture is created by the renderer and lives on the GPU.
+     */
+    free(): void;
+    /**
+     * Release the texture data and core context texture for this Texture without changing state.
+     *
+     * @remarks
+     * The ctxTexture is created by the renderer and lives on the GPU.
+     */
+    release(): void;
+    /**
+     * Destroy the texture.
+     *
+     * @remarks
+     * This method is called when the texture is no longer needed and should be
+     * cleaned up.
+     */
+    destroy(): void;
+    /**
+     * Free the source texture data for this Texture.
+     *
+     * @remarks
+     * The texture data is the source data that is used to populate the CoreContextTexture.
+     * e.g. ImageData that is downloaded from a URL.
+     */
+    freeTextureData(): void;
+    setState(state: TextureState, errorOrDimensions?: TextureError | Dimensions): void;
+    /**
+     * Get the texture data for this texture.
+     *
+     * @remarks
+     * This method is called by the CoreContextTexture when the texture is loaded.
+     * The texture data is then used to populate the CoreContextTexture.
+     *
+     * @returns
+     * The texture data for this texture.
+     */
+    getTextureData(): Promise<TextureData>;
+    /**
+     * Task for queueMicrotask to free texture data.
+     *
+     * @remarks
+     * This method is called in a microtask to free the texture data.
+     */
+    private freeTextureDataTask;
+    /**
+     * Task for queueMicrotask to release the texture.
+     *
+     * @remarks
+     * This method is called in a microtask to release the texture.
+     */
+    private releaseTask;
+    /**
+     * Get the texture source for this texture.
+     *
+     * @remarks
+     * This method is called by the CoreContextTexture when the texture is loaded.
+     * The texture source is then used to populate the CoreContextTexture.
+     */
+    abstract getTextureSource(): Promise<TextureData>;
+    /**
+     * Make a cache key for this texture.
+     *
+     * @remarks
+     * Each concrete `Texture` subclass must implement this method to provide an
+     * appropriate cache key for the texture type including the texture's
+     * properties that uniquely identify a copy of the texture. If the texture
+     * type does not support caching, then this method should return `false`.
+     *
+     * @param props
+     * @returns
+     * A cache key for this texture or `false` if the texture type does not
+     * support caching.
+     */
+    static makeCacheKey(props: unknown): string | false;
+    /**
+     * Resolve the default values for the texture's properties.
+     *
+     * @remarks
+     * Each concrete `Texture` subclass must implement this method to provide
+     * default values for the texture's optional properties.
+     *
+     * @param props
+     * @returns
+     * The default values for the texture's properties.
+     */
+    static resolveDefaults(props: unknown): Record<string, any>;
+}

package/dist/src/core/textures/Texture.js

@@ -0,0 +1,326 @@
+import { EventEmitter } from '../../common/EventEmitter.js';
+export var TextureType;
+(function (TextureType) {
+    TextureType[TextureType["generic"] = 0] = "generic";
+    TextureType[TextureType["color"] = 1] = "color";
+    TextureType[TextureType["image"] = 2] = "image";
+    TextureType[TextureType["noise"] = 3] = "noise";
+    TextureType[TextureType["renderToTexture"] = 4] = "renderToTexture";
+    TextureType[TextureType["subTexture"] = 5] = "subTexture";
+})(TextureType || (TextureType = {}));
+/**
+ * Represents a source of texture data for a CoreContextTexture.
+ *
+ * @remarks
+ * Texture sources are used to populate a CoreContextTexture when that texture
+ * is loaded. Texture data retrieved by the CoreContextTexture by the
+ * `getTextureData` method. It's the responsibility of the concerete `Texture`
+ * subclass to implement this method appropriately.
+ */
+export class Texture extends EventEmitter {
+    txManager;
+    /**
+     * The dimensions of the texture
+     *
+     * @remarks
+     * Until the texture data is loaded for the first time the value will be
+     * `null`.
+     */
+    _dimensions = null;
+    _error = null;
+    // aggregate state
+    state = 'initial';
+    renderableOwners = [];
+    renderable = false;
+    type = TextureType.generic;
+    preventCleanup = false;
+    ctxTexture;
+    textureData = null;
+    memUsed = 0;
+    /**
+     * Memory used by this texture in bytes
+     *
+     * @remarks
+     * This is tracked by the TextureMemoryManager and updated when the texture
+     * is loaded/freed. Set to 0 when texture is not loaded.
+     */
+    retryCount = 0;
+    maxRetryCount;
+    /**
+     * Timestamp when texture was created (for startup grace period)
+     */
+    createdAt = Date.now();
+    /**
+     * Flag to track if grace period has expired to avoid repeated Date.now() calls
+     */
+    gracePeriodExpired = false;
+    /**
+     * Grace period in milliseconds to prevent premature cleanup during app startup
+     * This helps prevent race conditions when bounds calculation is delayed
+     */
+    static STARTUP_GRACE_PERIOD = 2000; // 2 seconds
+    constructor(txManager) {
+        super();
+        this.txManager = txManager;
+        this.maxRetryCount = this.txManager.maxRetryCount;
+    }
+    get dimensions() {
+        return this._dimensions;
+    }
+    get error() {
+        return this._error;
+    }
+    /**
+     * Checks if the texture is within the startup grace period.
+     * During this period, textures are protected from cleanup to prevent
+     * race conditions during app initialization.
+     */
+    isWithinStartupGracePeriod() {
+        // If grace period already expired, return false immediately
+        if (this.gracePeriodExpired === true) {
+            return false;
+        }
+        // Check if grace period has expired now
+        const hasExpired = Date.now() - this.createdAt >= Texture.STARTUP_GRACE_PERIOD;
+        if (hasExpired) {
+            // Cache the result to avoid future Date.now() calls
+            this.gracePeriodExpired = true;
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Checks if the texture can be safely cleaned up.
+     * Considers the renderable state, startup grace period, and renderable owners.
+     */
+    canBeCleanedUp() {
+        // Never cleanup if explicitly prevented
+        if (this.preventCleanup) {
+            return false;
+        }
+        // Don't cleanup if still within startup grace period
+        if (this.isWithinStartupGracePeriod()) {
+            return false;
+        }
+        // Don't cleanup if not renderable
+        if (this.renderable === true) {
+            return false;
+        }
+        // Don't cleanup if there are still renderable owners
+        if (this.renderableOwners.length > 0) {
+            return false;
+        }
+        // Safe to cleanup
+        return true;
+    }
+    /**
+     * Add/remove an owner to/from the Texture based on its renderability.
+     *
+     * @remarks
+     * Any object can own a texture, be it a CoreNode or even the state object
+     * from a Text Renderer.
+     *
+     * When the reference to the texture that an owner object holds is replaced
+     * or cleared it must call this with `renderable=false` to release the owner
+     * association.
+     *
+     * @param owner
+     * @param renderable
+     */
+    setRenderableOwner(owner, renderable) {
+        const oldSize = this.renderableOwners.length;
+        const hasOwnerIndex = this.renderableOwners.indexOf(owner);
+        if (renderable === true) {
+            if (hasOwnerIndex === -1) {
+                // Add the owner to the set
+                this.renderableOwners.push(owner);
+            }
+            const newSize = this.renderableOwners.length;
+            if (oldSize !== newSize && newSize === 1) {
+                this.renderable = true;
+                this.onChangeIsRenderable?.(true);
+                this.load();
+            }
+        }
+        else {
+            if (hasOwnerIndex !== -1) {
+                this.renderableOwners.splice(hasOwnerIndex, 1);
+            }
+            const newSize = this.renderableOwners.length;
+            if (oldSize !== newSize && newSize === 0) {
+                this.renderable = false;
+                this.onChangeIsRenderable?.(false);
+                // note, not doing a cleanup here, cleanup is managed by the Stage/TextureMemoryManager
+                // when it deems appropriate based on memory pressure
+            }
+        }
+    }
+    load() {
+        if (this.retryCount > this.maxRetryCount) {
+            // We've exceeded the max retry count, do not attempt to load again
+            return;
+        }
+        this.txManager.loadTexture(this);
+    }
+    /**
+     * Load the core context texture for this Texture.
+     * The ctxTexture is created by the renderer and lives on the GPU.
+     *
+     * @returns
+     */
+    loadCtxTexture() {
+        if (this.ctxTexture === undefined) {
+            this.ctxTexture = this.txManager.renderer.createCtxTexture(this);
+        }
+        return this.ctxTexture;
+    }
+    /**
+     * Free the core context texture for this Texture.
+     *
+     * @remarks
+     * The ctxTexture is created by the renderer and lives on the GPU.
+     */
+    free() {
+        this.ctxTexture?.free();
+    }
+    /**
+     * Release the texture data and core context texture for this Texture without changing state.
+     *
+     * @remarks
+     * The ctxTexture is created by the renderer and lives on the GPU.
+     */
+    release() {
+        this.ctxTexture?.release();
+        this.ctxTexture = undefined;
+        this.freeTextureData();
+    }
+    /**
+     * Destroy the texture.
+     *
+     * @remarks
+     * This method is called when the texture is no longer needed and should be
+     * cleaned up.
+     */
+    destroy() {
+        // Only free GPU resources if we're in a state where they exist
+        if (this.state === 'loaded') {
+            this.free();
+        }
+        // Always free texture data regardless of state
+        this.freeTextureData();
+    }
+    /**
+     * Free the source texture data for this Texture.
+     *
+     * @remarks
+     * The texture data is the source data that is used to populate the CoreContextTexture.
+     * e.g. ImageData that is downloaded from a URL.
+     */
+    freeTextureData() {
+        queueMicrotask(this.freeTextureDataTask);
+    }
+    setState(state, errorOrDimensions) {
+        if (this.state === state) {
+            return;
+        }
+        let payload = null;
+        if (state === 'loaded') {
+            if (errorOrDimensions !== undefined &&
+                'w' in errorOrDimensions === true &&
+                'h' in errorOrDimensions === true &&
+                errorOrDimensions.w !== undefined &&
+                errorOrDimensions.h !== undefined) {
+                this._dimensions = errorOrDimensions;
+            }
+            payload = this._dimensions;
+        }
+        else if (state === 'failed') {
+            this._error = errorOrDimensions;
+            payload = this._error;
+            // increment the retry count for the texture
+            // this is used to compare against maxRetryCount, if set
+            // to determine if we should try loading again
+            this.retryCount += 1;
+            queueMicrotask(this.releaseTask);
+        }
+        else if (state === 'loading') {
+            this._error = null;
+            this._dimensions = null;
+        }
+        else {
+            this._error = null;
+        }
+        // emit the new state
+        this.state = state;
+        this.emit(state, payload);
+    }
+    /**
+     * Get the texture data for this texture.
+     *
+     * @remarks
+     * This method is called by the CoreContextTexture when the texture is loaded.
+     * The texture data is then used to populate the CoreContextTexture.
+     *
+     * @returns
+     * The texture data for this texture.
+     */
+    async getTextureData() {
+        if (this.textureData === null) {
+            this.textureData = await this.getTextureSource();
+        }
+        return this.textureData;
+    }
+    /**
+     * Task for queueMicrotask to free texture data.
+     *
+     * @remarks
+     * This method is called in a microtask to free the texture data.
+     */
+    freeTextureDataTask = () => {
+        this.textureData = null;
+    };
+    /**
+     * Task for queueMicrotask to release the texture.
+     *
+     * @remarks
+     * This method is called in a microtask to release the texture.
+     */
+    releaseTask = () => {
+        this.release();
+    };
+    /**
+     * Make a cache key for this texture.
+     *
+     * @remarks
+     * Each concrete `Texture` subclass must implement this method to provide an
+     * appropriate cache key for the texture type including the texture's
+     * properties that uniquely identify a copy of the texture. If the texture
+     * type does not support caching, then this method should return `false`.
+     *
+     * @param props
+     * @returns
+     * A cache key for this texture or `false` if the texture type does not
+     * support caching.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static makeCacheKey(props) {
+        return false;
+    }
+    /**
+     * Resolve the default values for the texture's properties.
+     *
+     * @remarks
+     * Each concrete `Texture` subclass must implement this method to provide
+     * default values for the texture's optional properties.
+     *
+     * @param props
+     * @returns
+     * The default values for the texture's properties.
+     */
+    static resolveDefaults(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    props) {
+        return {};
+    }
+}
+//# sourceMappingURL=Texture.js.map