@galacean/engine-core 1.6.8 → 1.6.10

package/types/animation/enums/InterpolationType.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Animation interpolation method.
+ */
+export declare enum InterpolationType {
+    /** Linear interpolation */
+    Linear = 0,
+    /** Cubic spline interpolation */
+    CubicSpine = 1,
+    /** Stepped interpolation */
+    Step = 2,
+    /** Hermite interpolation */
+    Hermite = 3
+}

package/types/animation/enums/LayerState.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Layer state.
+ */
+export declare enum LayerState {
+    /** Standby state. */
+    Standby = 0,
+    /** Playing state. */
+    Playing = 1,
+    /** CrossFading state. */
+    CrossFading = 2,
+    /** FixedCrossFading state. */
+    FixedCrossFading = 3,
+    /** Finished state. */
+    Finished = 4
+}

package/types/animation/enums/PlayState.d.ts

@@ -0,0 +1,13 @@
+/**
+ * State play state.
+ */
+export declare enum PlayState {
+    /** Playing state. */
+    Playing = 0,
+    /** Crossing state. */
+    Crossing = 1,
+    /** Fading state. */
+    Fading = 2,
+    /** Finished state. */
+    Finished = 3
+}

package/types/animation/enums/WrapMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Animation wrap mode.
+ */
+export declare enum WrapMode {
+    /** Play once */
+    Once = 0,
+    /** Loop play */
+    Loop = 1
+}

package/types/animation/index.d.ts

@@ -0,0 +1,25 @@
+import "./internal/animationCurveOwner/assembler/PositionAnimationCurveOwnerAssembler";
+import "./internal/animationCurveOwner/assembler/RotationAnimationCurveOwnerAssembler";
+import "./internal/animationCurveOwner/assembler/ScaleAnimationCurveOwnerAssembler";
+import "./internal/animationCurveOwner/assembler/BlendShapeWeightsAnimationCurveOwnerAssembler";
+export { AnimationClip } from "./AnimationClip";
+export { AnimationClipCurveBinding } from "./AnimationClipCurveBinding";
+export * from "./animationCurve";
+export { AnimationEvent } from "./AnimationEvent";
+export { Animator } from "./Animator";
+export { AnimatorController } from "./AnimatorController";
+export { AnimatorControllerLayer } from "./AnimatorControllerLayer";
+export { AnimatorState } from "./AnimatorState";
+export { AnimatorStateMachine } from "./AnimatorStateMachine";
+export { AnimatorStateTransition } from "./AnimatorStateTransition";
+export { AnimatorConditionMode } from "./enums/AnimatorConditionMode";
+export { AnimatorLayerBlendingMode } from "./enums/AnimatorLayerBlendingMode";
+export { AnimatorCullingMode } from "./enums/AnimatorCullingMode";
+export { InterpolationType } from "./enums/InterpolationType";
+export { WrapMode } from "./enums/WrapMode";
+export * from "./Keyframe";
+export * from "./AnimatorLayerMask";
+export { StateMachineScript } from "./StateMachineScript";
+export { AnimatorCondition } from "./AnimatorCondition";
+export * from "./AnimatorControllerParameter";
+export { LayerPathMask } from "./LayerPathMask";

package/types/animation/internal/AnimationCurveLayerOwner.d.ts

@@ -0,0 +1 @@
+export {};

package/types/animation/internal/AnimationEventHandler.d.ts

@@ -0,0 +1 @@
+export {};

package/types/animation/internal/AnimatorLayerData.d.ts

@@ -0,0 +1 @@
+export {};

package/types/animation/internal/AnimatorStateData.d.ts

@@ -0,0 +1 @@
+export {};

package/types/animation/internal/AnimatorStatePlayData.d.ts

@@ -0,0 +1 @@
+export {};

package/types/animation/internal/AnimatorTempValue.d.ts

@@ -0,0 +1 @@
+export {};

package/types/animation/internal/animationCurveOwner/AnimationCurveOwner.d.ts

@@ -0,0 +1,5 @@
+import { KeyframeValueType } from "../../Keyframe";
+export interface IEvaluateData<V extends KeyframeValueType> {
+    curKeyframeIndex: number;
+    value: V;
+}

package/types/animation/internal/animationCurveOwner/assembler/BlendShapeWeightsAnimationCurveOwnerAssembler.d.ts

@@ -0,0 +1 @@
+export {};

package/types/animation/internal/animationCurveOwner/assembler/IAnimationCurveOwnerAssembler.d.ts

@@ -0,0 +1 @@
+export {};

package/types/animation/internal/animationCurveOwner/assembler/PositionAnimationCurveOwnerAssembler.d.ts

@@ -0,0 +1 @@
+export {};

package/types/animation/internal/animationCurveOwner/assembler/RotationAnimationCurveOwnerAssembler.d.ts

@@ -0,0 +1 @@
+export {};

package/types/animation/internal/animationCurveOwner/assembler/ScaleAnimationCurveOwnerAssembler.d.ts

@@ -0,0 +1 @@
+export {};

package/types/animation/internal/animationCurveOwner/assembler/UniversalAnimationCurveOwnerAssembler.d.ts

@@ -0,0 +1 @@
+export {};

package/types/asset/AssetPromise.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Asset Loading Promise.
+ */
+export declare class AssetPromise<T> implements PromiseLike<T> {
+    /**
+     * Creates a new resolved AssetPromise.
+     * @returns A resolved AssetPromise.
+     */
+    static resolve(): AssetPromise<void>;
+    /**
+     * Creates a new resolved AssetPromise fork the provided value.
+     * @param value - A value
+     * @returns A AssetPromise whose internal state matches the provided promise.
+     */
+    static resolve<T>(value: T): AssetPromise<Awaited<T>>;
+    /**
+     * Creates a new resolved AssetPromise for the provided value.
+     * @param value - A PromiseLike
+     * @returns A AssetPromise whose internal state matches the provided promise.
+     */
+    static resolve<T>(value: PromiseLike<T>): AssetPromise<Awaited<T>>;
+    /**
+     * Creates a AssetPromise that is resolved with an array of results when all of the provided PromiseLike resolve, or rejected when any PromiseLike is rejected.
+     * @param values An array of PromiseLikes
+     * @returns A new AssetPromise.
+     */
+    static all<T extends [] | unknown[]>(values: T extends [] ? [...T] : readonly [...T]): AssetPromise<{
+        [K in keyof T]: UnwrapPromise<T[K]>;
+    }>;
+    /**
+     * Creates a AssetPromise that is resolved with an array of results when all of the provided PromiseLikes resolve, or rejected when any PromiseLikes is rejected.
+     * @param values An iterable of PromiseLikes
+     * @returns A new AssetPromise.
+     */
+    static all<T>(values: Iterable<T | PromiseLike<T>>): AssetPromise<Awaited<T>[]>;
+    /** compatible with Promise */
+    get [Symbol.toStringTag](): string;
+    private _promise;
+    private _state;
+    private _taskCompleteProgress;
+    private _taskDetailProgress;
+    private _onTaskCompleteCallbacks;
+    private _onTaskDetailCallbacks;
+    private _onCancelHandler;
+    private _reject;
+    /**
+     * Create an asset loading Promise.
+     * @param executor - A callback used to initialize the promise. This callback is passed two arguments:
+     * a resolve callback used to resolve the promise with a value or the result of another promise,
+     * and a reject callback used to reject the promise with a provided reason or error.
+     * and a setProgress callback used to set promise progress with a percent.
+     */
+    constructor(executor: AssetPromiseExecutor<T>);
+    /**
+     * Progress callback.
+     * @param onTaskComplete - This callback function provides information about the overall progress of the task. For example, in batch processing tasks, you can use the loaded and total parameters to calculate the percentage of task completion or display a progress bar
+     * @param onTaskDetail - This callback function provides detailed progress information about the task. For instance, in file downloading scenarios, you can use the loaded and total parameters to calculate the download progress percentage and utilize the url parameter to provide additional details such as download speed and estimated remaining time
+     * @returns AssetPromise
+     */
+    onProgress(onTaskComplete: (loaded: number, total: number) => void, onTaskDetail?: (identifier: string, loaded: number, total: number) => void): AssetPromise<T>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): AssetPromise<TResult1 | TResult2>;
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onRejected - The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch(onRejected: (reason: any) => any): AssetPromise<T>;
+    /**
+     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected).
+     * The callback result is ignored and the original value/reason is preserved per Promise spec.
+     * Returns an AssetPromise to keep chainability with AssetPromise methods.
+     * @param onFinally - The callback to execute when the Promise is settled.
+     * @returns An AssetPromise for the completion of the callback.
+     */
+    finally(onFinally?: () => void): AssetPromise<T>;
+    /**
+     * Cancel promise request.
+     * @returns Asset promise
+     */
+    cancel(): AssetPromise<T>;
+}
+interface AssetPromiseExecutor<T> {
+    (resolve: (value?: T | PromiseLike<T>) => void, reject?: (reason?: any) => void, setTaskCompleteProgress?: TaskCompleteCallback, setTaskDetailProgress?: TaskDetailCallback, onCancel?: (callback: () => void) => void): void;
+}
+type TaskCompleteCallback = (loaded: number, total: number) => void;
+type TaskDetailCallback = (url: string, loaded: number, total: number) => void;
+type UnwrapPromise<T> = T extends PromiseLike<infer U> ? U : T;
+export {};

package/types/asset/AssetType.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Asset Type.
+ */
+export declare enum AssetType {
+    /**
+     * Plain text.
+     * @remarks Will not be cached based on url in ResourceManager.
+     */
+    Text = "Text",
+    /**
+     * JSON.
+     * @remarks Will not be cached based on url in ResourceManager.
+     */
+    JSON = "JSON",
+    /**
+     * ArrayBuffer.
+     * @remarks Will not be cached based on url in ResourceManager.
+     */
+    Buffer = "Buffer",
+    /** 2D Texture. */
+    Texture2D = "Texture2D",
+    /** Cube Texture. */
+    TextureCube = "TextureCube",
+    /** Material. */
+    Material = "Material",
+    /** Shader. */
+    Shader = "Shader",
+    /** Mesh. */
+    Mesh = "Mesh",
+    /** AnimationClip. */
+    AnimationClip = "AnimationClip",
+    /** AnimatorController. */
+    AnimatorController = "AnimatorController",
+    /** Prefab.*/
+    Prefab = "Prefab",
+    /** GLTF.*/
+    GLTF = "GLTF",
+    /** Compress Texture. */
+    KTX = "KTX",
+    /** Cube Compress Texture. */
+    KTXCube = "KTXCube",
+    /** KTX2 Compress Texture */
+    KTX2 = "KTX2",
+    /** Sprite. */
+    Sprite = "Sprite",
+    /** PrimitiveMesh. */
+    PrimitiveMesh = "PrimitiveMesh",
+    /** Sprite Atlas. */
+    SpriteAtlas = "SpriteAtlas",
+    /** Ambient light. */
+    Env = "Environment",
+    /** Scene. */
+    Scene = "Scene",
+    /** HDR to cube. */
+    HDR = "HDR",
+    /** Font. */
+    Font = "Font",
+    /** Source Font, include ttf, otf and woff. */
+    SourceFont = "SourceFont",
+    /** AudioClip, include ogg, wav and mp3. */
+    Audio = "Audio",
+    /** Project asset. */
+    Project = "project",
+    /** PhysicsMaterial. */
+    PhysicsMaterial = "PhysicsMaterial"
+}

package/types/asset/ContentRestorer.d.ts

@@ -0,0 +1,17 @@
+import { EngineObject } from "../base";
+import { AssetPromise } from "./AssetPromise";
+/**
+ * ContentRestorer is a base class for all content restore info classes.
+ */
+export declare abstract class ContentRestorer<T extends EngineObject> {
+    resource: T;
+    /**
+     * @param resource - The resource object of the content restorer
+     */
+    constructor(resource: T);
+    /**
+     * Restore the content of the resource.
+     * @returns The promise of the restored content if the content is restored asynchronously, otherwise returns undefined
+     */
+    abstract restoreContent(): AssetPromise<T> | void;
+}

package/types/asset/GraphicsResource.d.ts

@@ -0,0 +1,9 @@
+import { Engine } from "../Engine";
+import { ReferResource } from "./ReferResource";
+export declare abstract class GraphicsResource extends ReferResource {
+    /**
+     * Whether the content of the resource is lost.
+     */
+    get isContentLost(): boolean;
+    protected constructor(engine: Engine);
+}

package/types/asset/IReferable.d.ts

@@ -0,0 +1,2 @@
+export interface IReferable {
+}

package/types/asset/LoadItem.d.ts

@@ -0,0 +1,40 @@
+type PickOnlyOne<T extends {}, Keys extends keyof T = keyof T> = Keys extends unknown ? {
+    [K in Keys]: T[Keys];
+} & {
+    [K in Exclude<keyof T, Keys>]?: never;
+} : never;
+/**
+ * Used to describe loading asset.
+ */
+export type LoadItem = {
+    /**
+     * Asset Type.
+     */
+    type?: string;
+    /**
+     * Number of retries after failed loading.
+     */
+    retryCount?: number;
+    /**
+     * Timeout.
+     */
+    timeout?: number;
+    /**
+     * Retry interval time.
+     */
+    retryInterval?: number;
+    /**
+     * Additional parameters for specified loader.
+     */
+    params?: Record<string, any>;
+} & PickOnlyOne<{
+    /**
+     * Loading url.
+     */
+    url: string;
+    /**
+     * Available when AssetType is TextureCube.
+     */
+    urls: string[];
+}>;
+export {};

package/types/asset/Loader.d.ts

@@ -0,0 +1,37 @@
+import { Engine, EngineConfiguration } from "../Engine";
+import { AssetPromise } from "./AssetPromise";
+import { LoadItem } from "./LoadItem";
+import { ResourceManager } from "./ResourceManager";
+/**
+ * Loader abstract class.
+ */
+export declare abstract class Loader<T> {
+    readonly useCache: boolean;
+    /**
+     * Register a class with a string name for serialization and deserialization.
+     * @param key - class name
+     * @param obj - class object
+     */
+    static registerClass(className: string, classDefine: {
+        new (...args: any): any;
+    }): void;
+    /**
+     * Get the class object by class name.
+     * @param key - class name
+     * @returns class object
+     */
+    static getClass(className: string): {
+        new (...args: any): any;
+    };
+    /**
+     * Get the class name by class object.
+     * @param obj - class object
+     * @returns class name
+     */
+    static getClassName(obj: Object): string;
+    private static _engineObjects;
+    private static _classNameMap;
+    constructor(useCache: boolean);
+    initialize?(engine: Engine, configuration: EngineConfiguration): Promise<void>;
+    abstract load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<T>;
+}

package/types/asset/ReferResource.d.ts

@@ -0,0 +1,23 @@
+import { EngineObject } from "../base/EngineObject";
+import { Engine } from "../Engine";
+import { IReferable } from "./IReferable";
+/**
+ * The base class of assets, with reference counting capability.
+ */
+export declare abstract class ReferResource extends EngineObject implements IReferable {
+    /** Whether to ignore the garbage collection check, if it is true, it will not be affected by ResourceManager.gc(). */
+    isGCIgnored: boolean;
+    private _refCount;
+    private _superResources;
+    /**
+     * Counted by valid references.
+     */
+    get refCount(): number;
+    protected constructor(engine: Engine);
+    /**
+     * Destroy self.
+     * @param force - Whether to force the destruction, if it is false, refCount = 0 can be released successfully
+     * @returns Whether the release was successful
+     */
+    destroy(force?: boolean): boolean;
+}

package/types/asset/ResourceManager.d.ts

@@ -0,0 +1,121 @@
+import { ContentRestorer, Engine, EngineObject } from "..";
+import { AssetPromise } from "./AssetPromise";
+import { Loader } from "./Loader";
+import { LoadItem } from "./LoadItem";
+/**
+ * ResourceManager
+ */
+export declare class ResourceManager {
+    readonly engine: Engine;
+    private static _extTypeMapping;
+    private static _getTypeByUrl;
+    /** The number of retries after failing to load assets. */
+    retryCount: number;
+    /** Retry delay time after failed to load assets, in milliseconds. */
+    retryInterval: number;
+    /** The default timeout period for loading assets, in milliseconds. */
+    timeout: number;
+    /** Base url for loading assets. */
+    baseUrl: string | null;
+    private _loadingPromises;
+    /** Asset path pool, key is the `instanceID` of resource, value is asset path. */
+    private _assetPool;
+    /** Asset url pool, key is the asset path and the value is the asset. */
+    private _assetUrlPool;
+    /** Referable resource pool, key is the `instanceID` of resource. */
+    private _referResourcePool;
+    /** Graphic resource pool, key is the `instanceID` of resource. */
+    private _graphicResourcePool;
+    /** Restorable resource information pool, key is the `instanceID` of resource. */
+    private _contentRestorerPool;
+    private _subAssetPromiseCallbacks;
+    /**
+     * Create a ResourceManager.
+     * @param engine - Engine to which the current ResourceManager belongs
+     */
+    constructor(engine: Engine);
+    /**
+     * Load asset asynchronously through the path.
+     * @param path - Path
+     * @returns Asset promise
+     */
+    load<T>(path: string): AssetPromise<T>;
+    /**
+     * Load asset collection asynchronously through urls.
+     * @param paths - Path collections
+     * @returns Asset Promise
+     */
+    load(paths: string[]): AssetPromise<Object[]>;
+    /**
+     * Load the asset asynchronously by asset item information.
+     * @param assetItem - AssetItem
+     * @returns AssetPromise
+     */
+    load<T>(assetItem: LoadItem): AssetPromise<T>;
+    /**
+     * Load the asset collection asynchronously by loading the information collection.
+     * @param assetItems - Asset collection
+     * @returns AssetPromise
+     */
+    load(assetItems: LoadItem[]): AssetPromise<Object[]>;
+    /**
+     * Get the resource from cache by asset url, return the resource object if it loaded, otherwise return null.
+     * @param url - Resource url
+     * @returns Resource object
+     */
+    getFromCache<T>(url: string): T;
+    /**
+     * Find the resource by type.
+     * @param type - Resource type
+     * @returns - Resource collection
+     */
+    findResourcesByType<T extends EngineObject>(type: new (...args: any[]) => T): T[];
+    /**
+     * Get asset url from instanceId.
+     * @param instanceId - Engine instance id
+     * @returns Asset url
+     */
+    getAssetPath(instanceId: number): string;
+    /**
+     * Cancel all assets that have not finished loading.
+     */
+    cancelNotLoaded(): void;
+    /**
+     * Cancel assets whose url has not finished loading.
+     * @param url - Resource url
+     */
+    cancelNotLoaded(url: string): void;
+    /**
+     * Cancel the incompletely loaded assets in urls.
+     * @param urls - Resource urls
+     */
+    cancelNotLoaded(urls: string[]): void;
+    /**
+     * Garbage collection will release resource objects managed by reference counting.
+     * @remarks The release principle is that it is not referenced by the components, including direct and indirect reference.
+     */
+    gc(): void;
+    /**
+     * Add content restorer.
+     * @param restorer - The restorer
+     */
+    addContentRestorer<T extends EngineObject>(restorer: ContentRestorer<T>): void;
+    private _assignDefaultOptions;
+    private _loadSingleItem;
+    private _loadSubpackageAndMainAsset;
+    private _loadMainAsset;
+    private _createSubAssetPromiseCallback;
+    private _gc;
+    private _getResolveResource;
+    private _parseURL;
+    private _parseQueryPath;
+    private _releaseSubAssetPromiseCallback;
+}
+/**
+ * Declare ResourceLoader's decorator.
+ * @param assetType - Type of asset
+ * @param extNames - Name of file extension
+ */
+export declare function resourceLoader(assetType: string, extNames: string[], useCache?: boolean): <T extends Loader<any>>(Target: {
+    new (useCache: boolean): T;
+}) => void;

package/types/asset/request.d.ts

@@ -0,0 +1,36 @@
+import { AssetPromise } from "./AssetPromise";
+/**
+ * Configuration options for `request`.
+ * @remarks
+ * This type extends the standard `RequestInit` options with additional
+ * properties for handling retries, timeouts, and custom response types.
+ */
+export type RequestConfig = {
+    type?: XMLHttpRequestResponseType | "image";
+    retryCount?: number;
+    retryInterval?: number;
+    timeout?: number;
+} & RequestInit;
+/**
+ * Sends a request to the specified URL and returns a promise for the response.
+ * @param url - The URL to send the request to
+ * @param config - Configuration options for the request
+ * @returns A promise that resolves with the response of type `T`
+ */
+export declare function request<T>(url: string, config?: RequestConfig): AssetPromise<T>;
+export declare class MultiExecutor {
+    private execFunc;
+    private totalCount;
+    private interval;
+    private _timeoutId;
+    private _currentCount;
+    private _onComplete;
+    private _onError;
+    private _error;
+    constructor(execFunc: (count?: number) => Promise<any>, totalCount: number, interval: number);
+    start(): this;
+    onComplete(func: Function): this;
+    onError(func: Function): this;
+    cancel(): void;
+    private exec;
+}

package/types/audio/AudioClip.d.ts

@@ -0,0 +1,24 @@
+import { Engine } from "../Engine";
+import { ReferResource } from "../asset/ReferResource";
+/**
+ * Audio Clip.
+ */
+export declare class AudioClip extends ReferResource {
+    private _audioBuffer;
+    /** Name of clip. */
+    name: string;
+    /**
+     * Number of discrete audio channels.
+     */
+    get channels(): number;
+    /**
+     * Sample rate, in samples per second.
+     */
+    get sampleRate(): number;
+    /**
+     * Duration, in seconds.
+     */
+    get duration(): number;
+    constructor(engine: Engine, name?: string);
+    protected _onDestroy(): void;
+}

package/types/audio/AudioManager.d.ts

@@ -0,0 +1 @@
+export {};