@woosh/meep-engine 2.165.6 → 2.166.0

package/src/engine/asset/AssetManager.d.ts

@@ -1,61 +1,259 @@
-import ConcurrentExecutor from "../../core/process/executor/ConcurrentExecutor";
-import {Asset} from "./Asset";
-import {AssetRequestScope} from "./AssetRequestScope";
-import {AssetTransformer} from "./AssetTransformer";
-import {CrossOriginConfig} from "./CORS/CrossOriginConfig";
-import {AssetLoader} from "./loaders/AssetLoader";
-
-interface PromiseOptions {
-    scope?: AssetRequestScope
-    skip_queue?: boolean
-    progress?: (current: number, total: number) => any
-}
-
-interface AssetManagerOptions<CTX> {
-    context: CTX,
-    executor?: ConcurrentExecutor
-}
-
-interface GetOptions<T> {
-    type: string
-    path: string
-    callback?: (asset: Asset<T>) => any
-    failure?: (reason: any) => any
-    progress?: (current: number, total: number) => any
-    skip_queue?: boolean
-    scope?: AssetRequestScope
-}
-
-export declare class AssetManager<CTX> {
-    constructor(options?: AssetManagerOptions<CTX>)
-
-    public readonly crossOriginConfig: CrossOriginConfig
-
-    load_concurrency: number
-
-    rootPath: string
-
-    startup(): void
-
-    shutdown(immediate?: boolean): Promise<void>
-
-    get<T>(options: GetOptions<T>): void
-
-    promise<T>(path: string, type: string, options?: PromiseOptions): Promise<Asset<T>>
-
-    resolveNetworkPath(path: string): string
-
-    remove(path: string, type: string): boolean
-
-    clear(): void
-
-    registerLoader<T>(type: string, loader: AssetLoader<T, CTX>): Promise<AssetLoader<T, CTX>>
-
-    unregisterLoader(type: string): Promise<void>
-
-    getLoaderByType<T>(type: string): AssetLoader<T, CTX> | undefined
-
-    registerTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): void
-
-    unregisterTransformer<T extends Asset<X>, X = any>(type: string, transformer: AssetTransformer<T>): boolean
+/**
+ * Handles loading/generating assets
+ * @template CTX
+ * @class
+ */
+export class AssetManager<CTX> {
+    /**
+     *
+     * @param {CTX} context
+     * @param {ConcurrentExecutor} executor
+     * @constructor
+     */
+    constructor({ context, executor }?: CTX);
+    /**
+     *
+     * @type {HashMap<AssetDescription, Asset>}
+     * @private
+     */
+    private assets;
+    /**
+     *
+     * @type {ObservedMap<AssetDescription, PendingAsset>}
+     */
+    request_map: ObservedMap<AssetDescription, PendingAsset>;
+    /**
+     * Maximum number of top-level requests that can be handled at the same time.
+     * Since most of the requests are handled over the network, this can help you control network concurrency,
+     * this can be useful to keep some network slots available for high-priority requests such as UI related ones.
+     * Nested requests (made by a loader while servicing another load) are dispatched immediately and never wait
+     * on this limit: their parent occupies a slot until they resolve, so queueing them would deadlock.
+     * @type {number}
+     */
+    load_concurrency: number;
+    /**
+     * This will be added to asset path for actual network resolution.
+     * Paths exchanged with the manager ({@link get}, {@link promise}, cache keys) are never prefixed;
+     * loaders apply the prefix at the fetch boundary via {@link resolveNetworkPath}.
+     * @type {string}
+     * @private
+     */
+    private rootPath;
+    /**
+     *
+     * @type {CrossOriginConfig}
+     */
+    crossOriginConfig: CrossOriginConfig;
+    startup(): void;
+    /**
+     *
+     * @param {boolean} [immediate] should we let pending work finish, or shut down immediately?
+     * Defaults to false (wait until all in-flight requests are resolved and all responses are delivered).
+     * When true, outstanding requests are failed and all responses are delivered before the method returns.
+     * @return {Promise<void>}
+     */
+    shutdown(immediate?: boolean): Promise<void>;
+    /**
+     * Resolves a caller-facing asset path to the path used for actual network retrieval.
+     * Loaders that fetch over the network should apply this at the fetch boundary; paths passed to
+     * {@link get}/{@link promise} (including nested requests made by loaders) always stay un-prefixed,
+     * so they are keyed consistently in the cache.
+     * @param {string} path
+     * @returns {string}
+     */
+    resolveNetworkPath(path: string): string;
+    /**
+     * Remove asset if it is loaded, does nothing otherwise
+     * @param {String} path
+     * @param {String} type
+     * @returns {boolean} true if asset was removed, else otherwise
+     */
+    remove(path: string, type: string): boolean;
+    /**
+     * Clear out all loaded assets
+     */
+    clear(): void;
+    dumpLoadedAssetList(): string;
+    /**
+     * @param {String} path
+     * @param {String} type
+     * @param {AssetRequestScope} [scope]
+     * @param {boolean} [skip_queue] if true will skip the queue and dispatch request immediately
+     * @param {function(loaded:number, total:number)} [progress]
+     * @returns {Promise<Asset>}
+     */
+    promise(path: string, type: string, { scope, skip_queue, progress }?: AssetRequestScope): Promise<Asset>;
+    /**
+     * @template T
+     * @param {String} path
+     * @param {String} type
+     * @param {function(asset:Asset<T>)} [callback] success callback
+     * @param {function(reason:*)} [failure]
+     * @param {function(loaded:number, total:number)} [progress]
+     * @param {boolean} [skip_queue]
+     * @param {AssetRequestScope} [scope]
+     */
+    get<T>({ path, type, callback, failure, progress, skip_queue, scope }: string): void;
+    /**
+     * Checks if an asset is currently being loaded.
+     * Useful for avoiding redundant requests.
+     *
+     * @param {string} path
+     * @param {string} type
+     * @return {boolean}
+     */
+    isPending(path: string, type: string): boolean;
+    /**
+     * Whether the most recent load attempt for the asset failed.
+     * Advisory only: a new {@link get} will still retry the load.
+     * @param {string} path
+     * @param {string} type
+     * @returns {boolean}
+     * @see isPending
+     */
+    isFailed(path: string, type: string): boolean;
+    /**
+     * Checks if an asset is loaded.
+     * If the asset is loaded, calls to {@link tryGet} are guaranteed to succeed.
+     *
+     * @param {string} path
+     * @param {string} type
+     * @return {boolean}
+     */
+    isLoaded(path: string, type: string): boolean;
+    /**
+     * Same as {@link insert}, but will register the asset as pending until loader function resolves.
+     *
+     * NOTE: {@link AssetTransformer}s are not applied to the asset
+     *
+     * NOTE: any subsequent normal requests such as {@link get} will be routed to the same loader
+     *
+     * @template T
+     * @param {string} path
+     * @param {string} type
+     * @param {function(progress?:function(current:number, total:number)):Promise<Asset<T>>} loader
+     * @returns {Promise<Asset<T>>} loaded asset
+     * @see insert
+     * @example
+     *   manager.insertAsync('path/to/asset', 'my-type', async (progress) => {
+     *       const asset = await loadAssetFromNetwork('path/to/asset', 'type', progress);
+     *       return asset;
+     *   });
+     *
+     */
+    insertAsync<T_1>(path: string, type: string, loader: any): Promise<Asset<T_1>>;
+    /**
+     * Manually add a fully resolved resource.
+     * If a load for the same description is in flight, it is squashed: the inserted asset wins,
+     * all accumulated requests are answered with it exactly once, and the loader's late resolution is dropped.
+     *
+     * NOTE: {@link AssetTransformer}s are not applied to the asset
+     *
+     * @template T
+     * @param {string} path
+     * @param {string} type
+     * @param {Asset<T>} asset
+     */
+    insert<T_2>(path: string, type: string, asset: Asset<T_2>): void;
+    /**
+     *
+     * @param {AssetDescription} assetDescription
+     * @param {AssetRequest} request
+     * @param {PendingAsset|null} [parent_pending] the in-flight load this request was made from, if any
+     * @private
+     */
+    private submitRequest;
+    /**
+     *
+     * @param {string} type
+     * @return {boolean}
+     */
+    hasLoaderForType(type: string): boolean;
+    /**
+     *
+     * @param {string} type
+     * @returns {AssetLoader|undefined}
+     */
+    getLoaderByType(type: string): AssetLoader<any, any> | undefined;
+    /**
+     * Transformer will be applied to all assets of the given type in order of registration.
+     *
+     * Does not apply retroactively, assets that were already loaded will not be transformed.
+     *
+     * @template T
+     * @param {string} type
+     * @param {AssetTransformer<T>} transformer
+     * @returns {void}
+     * @see removeTransformer
+     */
+    registerTransformer<T_3>(type: string, transformer: AssetTransformer<T_3>): void;
+    /**
+     * @template T
+     * @param {string} type
+     * @param {AssetTransformer<T>} transformer
+     * @returns {boolean} true if removed, false if not found
+     * @see registerTransformer
+     */
+    unregisterTransformer<T_4>(type: string, transformer: AssetTransformer<T_4>): boolean;
+    /**
+     * Will register loader only if none exists for this type
+     * @template T
+     * @param {string} type
+     * @param {AssetLoader<T>} loader
+     * @returns {Promise<boolean>} true if registered, false otherwise
+     */
+    tryRegisterLoader<T_5>(type: string, loader: AssetLoader<T_5, any>): Promise<boolean>;
+    /**
+     * @template T
+     * @param {string} type
+     * @param {AssetLoader<T>} loader
+     * @throws {Error} if a loader is already registered for the given type
+     */
+    registerLoader<T_6>(type: string, loader: AssetLoader<T_6, any>): Promise<AssetLoader<any, any>>;
+    /**
+     *
+     * @param {string} type
+     */
+    unregisterLoader(type: string): Promise<void>;
+    /**
+     * Retrieve an asset if it is loaded, returns null if the asset is not loaded.
+     * Does not trigger loading if the asset is not loaded.
+     * @template T
+     * @param {String} path
+     * @param {String} type
+     * @returns {Asset<T>|null}
+     */
+    tryGet<T_7>(path: string, type: string): Asset<T_7> | null;
+    /**
+     * @template T
+     * @param {string} alias
+     * @return {Promise<Asset<T>>}
+     */
+    promiseByAlias<T_8>(alias: string): Promise<Asset<T_8>>;
+    /**
+     *
+     * @param {string} alias
+     * @return {AssetDescription|undefined}
+     */
+    resolveAlias(alias: string): AssetDescription | undefined;
+    /**
+     *
+     * @param {string} alias
+     * @param {string} path
+     * @param {string} type
+     */
+    assignAlias(alias: string, path: string, type: string): void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isAssetManager: boolean;
+    #private;
 }
+import { ObservedMap } from "../../core/collection/map/ObservedMap.js";
+import { AssetDescription } from "./AssetDescription.js";
+import { PendingAsset } from "./PendingAsset.js";
+import { CrossOriginConfig } from "./CORS/CrossOriginConfig.js";
+import { AssetRequestScope } from "./AssetRequestScope.js";
+import { AssetLoader } from "./loaders/AssetLoader.js";
+//# sourceMappingURL=AssetManager.d.ts.map

package/src/engine/asset/AssetRequestScope.d.ts

@@ -1,3 +1,27 @@
-export declare class AssetRequestScope{
-
-}
+export class AssetRequestScope {
+    /**
+     *
+     * @param {AssetRequestScope[]} sources
+     * @return {AssetRequestScope}
+     */
+    static from(sources: AssetRequestScope[]): AssetRequestScope;
+    id: number;
+    priority: number;
+    /**
+     *
+     * @type {AssetRequestScope[]}
+     */
+    sources: AssetRequestScope[];
+    /**
+     * Asset being loaded under this scope. Set by the {@link AssetManager} on scopes it creates when
+     * dispatching a load; lets requests made by the loader be traced back to the load they belong to.
+     * @type {AssetDescription|null}
+     */
+    description: AssetDescription | null;
+    get final_priority(): any;
+    toString(): string;
+}
+export namespace AssetRequestScope {
+    let GLOBAL: Readonly<AssetRequestScope>;
+}
+//# sourceMappingURL=AssetRequestScope.d.ts.map

package/src/engine/asset/AssetTransformer.d.ts

@@ -1,5 +1,16 @@
-import {Asset} from "./Asset";
-
-export class AssetTransformer<A extends Asset<T>, T = any> {
-    transform(source: A): Promise<A>
-}
+/**
+ * Applies a transformation to an asset. Such as performing mesh simplification, for example.
+ * Transformation is executed by the {@link AssetManager}
+ * Useful for modifying/extending post-processing done on various asset types
+ * @template {Asset<T>} A
+ * @template T
+ */
+export class AssetTransformer<A extends Asset<T>, T> {
+    /**
+     * @param {A} source
+     * @param {AssetDescription} asset_description
+     * @returns {A}
+     */
+    transform(source: A, asset_description: AssetDescription): A;
+}
+//# sourceMappingURL=AssetTransformer.d.ts.map

package/src/engine/asset/CORS/CrossOriginConfig.d.ts

@@ -1,5 +1,8 @@
-import {CrossOriginKind} from "./CrossOriginKind";
-
-export class CrossOriginConfig{
-    public kind: CrossOriginKind
-}
+export class CrossOriginConfig {
+    kind: string;
+}
+export namespace CrossOriginConfig {
+    let _default: Readonly<CrossOriginConfig>;
+    export { _default as default };
+}
+//# sourceMappingURL=CrossOriginConfig.d.ts.map

package/src/engine/asset/CORS/CrossOriginConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CrossOriginConfig.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/CORS/CrossOriginConfig.js"],"names":[],"mappings":"AAEA;IACI,sBAAiC;CACpC;;kBAMS,SAAS,iBAAiB,CAAC;;;gCAVL,sBAAsB"}
+{"version":3,"file":"CrossOriginConfig.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/CORS/CrossOriginConfig.js"],"names":[],"mappings":"AAEA;IACI,aAAiC;CACpC;;kBAMS,SAAS,iBAAiB,CAAC"}

package/src/engine/asset/CORS/CrossOriginKind.d.ts

@@ -1,4 +1,5 @@
-export enum CrossOriginKind {
-    UseCredentials = 'use-credentials',
-    Anonymous = 'anonymous'
-}
+export namespace CrossOriginKind {
+    let UseCredentials: string;
+    let Anonymous: string;
+}
+//# sourceMappingURL=CrossOriginKind.d.ts.map

package/src/engine/asset/loaders/AssetLoader.d.ts

@@ -1,12 +1,50 @@
-import {Asset} from "../Asset";
-import {AssetRequestScope} from "../AssetRequestScope";
-
-export declare class AssetLoader<T, CTX> {
-    public load(
-        scope: AssetRequestScope,
-        path: string,
-        success: (asset: Asset<T>) => void,
-        failure: (reason: any) => void,
-        progress: (current: number, total: number) => void
-    )
-}
+/**
+ * @template CTX
+ * @template Asset
+ */
+export class AssetLoader<CTX, Asset> {
+    /**
+     *
+     * @type {AssetManager}
+     */
+    assetManager: AssetManager;
+    /**
+     *
+     * @type {CTX}
+     */
+    context: CTX;
+    /**
+     *
+     * @param {AssetManager} assetManager
+     * @param {CTX} context
+     */
+    link(assetManager: AssetManager, context: CTX): Promise<void>;
+    /**
+     * Release any held resources, finalizing operation of the loader
+     */
+    unlink(): Promise<void>;
+    /**
+     * Resolves a caller-facing asset path to the path used for actual network retrieval.
+     * Apply at the fetch boundary; paths passed back to the manager (nested requests) stay un-resolved.
+     * @param {string} path
+     * @returns {string}
+     * @see AssetManager#resolveNetworkPath
+     */
+    resolvePath(path: string): string;
+    /**
+     * Loads the asset for the given path.
+     *
+     * Exactly one of `success`/`failure` must eventually be invoked. The recommended shape is an
+     * `async` method that calls `success(asset)` — the manager treats a returned promise's rejection
+     * as a failure, so any throw (including from nested {@link AssetManager#promise} requests) is
+     * propagated instead of hanging the request.
+     *
+     * @param {AssetRequestScope} scope identifies this load; pass it on to any nested manager requests
+     * @param {string} path caller-facing path, see {@link resolvePath} for network retrieval
+     * @param {function(asset:Asset)} success
+     * @param {function} failure
+     * @param {function(current:number, total:number)} progress
+     */
+    load(scope: AssetRequestScope, path: string, success: any, failure: Function, progress: any): void;
+}
+//# sourceMappingURL=AssetLoader.d.ts.map

package/src/engine/asset/loaders/GLTFAssetLoader.d.ts

@@ -1,6 +1,71 @@
-import {AssetLoader} from "./AssetLoader";
-import {Object3D} from "three";
-
-export class GLTFAssetLoader extends AssetLoader<Object3D, any> {
-    setDracoDecoderPath(path: string): void
-}
+export class GLTFAssetLoader extends AssetLoader<any, any> {
+    constructor();
+    __dracoLoader: DRACOLoader;
+    loader: GLTFLoader;
+    /**
+     * Asset optimization flag
+     * Whether or not geometry de-duping should be done
+     * @type {boolean}
+     * @private
+     */
+    private __enable_geometry_cache;
+    /**
+     * Asset optimization flag
+     * Whether or not texture de-duping should be done
+     * @type {boolean}
+     * @private
+     */
+    private __enable_texture_cache;
+    /**
+     *
+     * @type {HashSet<THREE.BufferGeometry>}
+     * @private
+     */
+    private __geometry_cache;
+    /**
+     *
+     * @type {HashSet<Texture>}
+     * @private
+     */
+    private __texture_cache;
+    /**
+     *
+     * @param {string} p
+     */
+    setDracoDecoderPath(p: string): void;
+    /**
+     *
+     * @param {boolean} v
+     */
+    set is_micron_enabled(arg: boolean);
+    /**
+     *
+     * @returns {boolean}
+     */
+    get is_micron_enabled(): boolean;
+    link(assetManager: any, engine: any): Promise<void>;
+    /**
+     *
+     * @param {THREE.Mesh|THREE.Object3D} object
+     * @private
+     */
+    private __prepareObjectMaterial;
+    /**
+     *
+     * @param {THREE.Mesh|THREE.SkinnedMesh} mesh
+     * @private
+     */
+    private __processMesh;
+    /**
+     * Build the engine asset from a parsed GLTF payload
+     * @param {Object} gltf
+     * @returns {Promise<Asset>}
+     * @private
+     */
+    private __process_gltf;
+    load(scope: any, path: any, success: any, failure: any, progress: any): void;
+}
+import { AssetLoader } from "./AssetLoader.js";
+import { DRACOLoader } from "three/examples/jsm/loaders/DRACOLoader.js";
+import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
+//# sourceMappingURL=GLTFAssetLoader.d.ts.map

package/src/engine/asset/loaders/image/ImageRGBADataAsset.d.ts

@@ -27,7 +27,6 @@ export class ImageRGBADataAsset extends Asset<any> {
      * @type {number}
      */
     itemSize: number;
-    byteSize: number;
     create(): Sampler2D;
 }
 import { Asset } from "../../Asset.js";

package/src/engine/asset/loaders/image/ImageRGBADataAsset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImageRGBADataAsset.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/image/ImageRGBADataAsset.js"],"names":[],"mappings":"AAGA;IACI;;;;;;OAMG;IACH,kBALW,MAAM,EAAE,GAAC,UAAU,SACnB,MAAM,UACN,MAAM,aACN,MAAM,EA8BhB;IAzBG;;;OAGG;IACH,MAFU,MAAM,EAAE,CAEF;IAEhB;;;OAGG;IACH,OAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,QAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAExB,iBAA2B;IAG/B,oBAEC;CACJ;sBA5CqB,gBAAgB;0BACZ,gDAAgD"}
+{"version":3,"file":"ImageRGBADataAsset.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/image/ImageRGBADataAsset.js"],"names":[],"mappings":"AAGA;IACI;;;;;;OAMG;IACH,kBALW,MAAM,EAAE,GAAC,UAAU,SACnB,MAAM,UACN,MAAM,aACN,MAAM,EA8BhB;IAzBG;;;OAGG;IACH,MAFU,MAAM,EAAE,CAEF;IAEhB;;;OAGG;IACH,OAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,QAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,UAFU,MAAM,CAEQ;IAK5B,oBAEC;CACJ;sBA5CqB,gBAAgB;0BACZ,gDAAgD"}

package/src/engine/asset/loaders/material/StaticMaterialCache.d.ts

@@ -1,7 +1,30 @@
-import {Material} from "three";
-
-export class StaticMaterialCache {
-    public acquire(material: Material): Material
-
-    public static Global: StaticMaterialCache
-}
+export class StaticMaterialCache {
+    /**
+     *
+     * @type {Cache<Material, Material>}
+     */
+    materialCache: Cache<Material, Material>;
+    /**
+     *
+     * @type {Cache<Texture, Texture>}
+     */
+    textureCache: Cache<Texture, Texture>;
+    /**
+     *
+     * @param {Material} material
+     * @returns {Material}
+     */
+    acquire(material: Material): Material;
+    /**
+     *
+     * @param {function(string)} error_consumer
+     * @param {*} [thisArg]
+     * @returns {boolean}
+     */
+    validate(error_consumer: (arg0: string) => any, thisArg?: any): boolean;
+}
+export namespace StaticMaterialCache {
+    let Global: StaticMaterialCache;
+}
+import { Cache } from "../../../../core/cache/Cache.js";
+//# sourceMappingURL=StaticMaterialCache.d.ts.map

package/src/engine/asset/loaders/material/computeMaterialEquality.d.ts

@@ -1,3 +1,8 @@
-import {Material} from "three";
-
-export function computeMaterialEquality(a: Material, b: Material): boolean
+/**
+ * NOTE: does not do deep comparison on textures, only checks the IDs
+ * @param {Material|MeshStandardMaterial|MeshDepthMaterial|MeshMatcapMaterial} a
+ * @param {Material|MeshStandardMaterial|MeshDepthMaterial|MeshMatcapMaterial} b
+ * @returns {boolean}
+ */
+export function computeMaterialEquality(a: Material | MeshStandardMaterial | MeshDepthMaterial | MeshMatcapMaterial, b: Material | MeshStandardMaterial | MeshDepthMaterial | MeshMatcapMaterial): boolean;
+//# sourceMappingURL=computeMaterialEquality.d.ts.map

package/src/engine/asset/loaders/material/computeMaterialHash.d.ts

@@ -1,3 +1,7 @@
-import {Material} from "three";
-
-export function computeMaterialHash(material: Material): number
+/**
+ *
+ * @param {Material|MeshStandardMaterial|ShaderMaterial} material
+ * @returns {number}
+ */
+export function computeMaterialHash(material: Material | MeshStandardMaterial | ShaderMaterial): number;
+//# sourceMappingURL=computeMaterialHash.d.ts.map

package/src/engine/asset/loaders/material/traverseMaterialTextures.d.ts

@@ -1,3 +1,8 @@
-import {Material} from "three";
-
-export function traverseMaterialTextures(material: Material, callback: (texture) => void, thisArg?: any): void
+/**
+ *
+ * @param {Material} material
+ * @param {function(THREE.Texture, TextureAttachment)} callback
+ * @param {*} [thisArg]
+ */
+export function traverseMaterialTextures(material: Material, callback: (arg0: THREE.Texture, arg1: TextureAttachment) => any, thisArg?: any): void;
+//# sourceMappingURL=traverseMaterialTextures.d.ts.map

package/src/engine/asset/loaders/texture/TextureAssetLoader.d.ts

@@ -1,6 +1,6 @@
-import {AssetLoader} from "../AssetLoader";
-import {Texture} from "three";
-
-export class TextureAssetLoader extends AssetLoader<Texture, any> {
-
-}
+export class TextureAssetLoader extends AssetLoader<any, any> {
+    constructor();
+    load(scope: any, path: any, success: any, failure: any, progress: any): void;
+}
+import { AssetLoader } from "../AssetLoader.js";
+//# sourceMappingURL=TextureAssetLoader.d.ts.map