@galacean/engine-core 0.9.0-beta.80

package/types/animation/index.d.ts

@@ -0,0 +1,21 @@
+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 "./AnimatorTransition";
+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 { StateMachineScript } from "./StateMachineScript";

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,56 @@
+/**
+ * Asset Loading Promise.
+ */
+export declare class AssetPromise<T> implements PromiseLike<T> {
+    /**
+     * Return a new resource Promise through the provided asset promise collection.
+     * The resolved of the new AssetPromise will be triggered when all the Promises in the provided set are completed.
+     * @param - Promise Collection
+     * @returns AssetPromise
+     */
+    static all<T = any>(promises: (PromiseLike<T> | T)[]): AssetPromise<T[]>;
+    /** compatible with Promise */
+    get [Symbol.toStringTag](): string;
+    private _promise;
+    private _state;
+    private _onProgressCallback;
+    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 callback
+     * @returns AssetPromise
+     */
+    onProgress(callback: (progress: 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
+     * resolved value cannot be modified from the callback.
+     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+     * @returns A Promise for the completion of the callback.
+     */
+    finally(onFinally?: () => void): Promise<T>;
+    /**
+     * Cancel promise request.
+     * @returns Asset promise
+     */
+    cancel(): AssetPromise<T>;
+}
+interface AssetPromiseExecutor<T> {
+    (resolve: (value?: T | PromiseLike<T>) => void, reject?: (reason?: any) => void, setProgress?: (progress: number) => void, onCancel?: (callback: () => void) => void): void;
+}
+export {};

package/types/asset/AssetType.d.ts

@@ -0,0 +1,52 @@
+/**
+ * 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 = "texture-cube",
+    /** Material. */
+    Material = "material",
+    /** Mesh. */
+    Mesh = "mesh",
+    /** AnimationClip. */
+    AnimationClip = "AnimationClip",
+    /** AnimatorController. */
+    AnimatorController = "AnimatorController",
+    /** Prefab.*/
+    Prefab = "prefab",
+    /** Compress Texture. */
+    KTX = "ktx",
+    /** Cube Compress Texture. */
+    KTXCube = "ktx-cube",
+    /** Sprite. */
+    Sprite = "sprite",
+    /** Sprite Atlas. */
+    SpriteAtlas = "sprite-atlas",
+    /** Ambient light. */
+    Env = "environment",
+    /** Scene. */
+    Scene = "scene",
+    /** HDR to cube. */
+    HDR = "HDR",
+    /** Font. */
+    Font = "font",
+    /** Source Font, include ttf、 otf and woff. */
+    SourceFont = "source-font"
+}

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 {
+    protected constructor(engine: Engine);
+    /**
+     * @override
+     */
+    protected _onDestroy(): void;
+}

package/types/asset/IRefObject.d.ts

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

package/types/asset/IReferable.d.ts

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

package/types/asset/LoadItem.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Used to describe loading asset.
+ */
+export type LoadItem = {
+    /**
+     * Loading url.
+     */
+    url?: string;
+    /**
+     * Available when AssetType is TextureCube.
+     */
+    urls?: string[];
+    /**
+     * 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>;
+};

package/types/asset/Loader.d.ts

@@ -0,0 +1,30 @@
+import { AssetPromise } from "./AssetPromise";
+import { LoadItem } from "./LoadItem";
+import { RequestConfig } from "./request";
+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;
+    };
+    private static _engineObjects;
+    constructor(useCache: boolean);
+    request: <U>(url: string, config: RequestConfig) => AssetPromise<U>;
+    abstract load(item: LoadItem, resourceManager: ResourceManager): AssetPromise<T> | Record<string, AssetPromise<any>>;
+}

package/types/asset/RefObject.d.ts

@@ -0,0 +1,27 @@
+import { EngineObject } from "../base/EngineObject";
+import { Engine } from "../Engine";
+import { IRefObject } from "./IRefObject";
+/**
+ * The base class of assets, with reference counting capability.
+ */
+export declare abstract class RefObject extends EngineObject implements IRefObject {
+    /** Whether to ignore the garbage collection check, if it is true, it will not be affected by ResourceManager.gc(). */
+    isGCIgnored: boolean;
+    private _refCount;
+    /**
+     * 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;
+    /**
+     * Called when the resource is destroyed.
+     * Subclasses can override this function.
+     */
+    protected abstract _onDestroy(): void;
+}

package/types/asset/ReferResource.d.ts

@@ -0,0 +1,27 @@
+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;
+    /**
+     * Counted by valid references.
+     */
+    get refCount(): number;
+    protected constructor(engine: Engine);
+    /**
+     * @override
+     * 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;
+    /**
+     * @override
+     */
+    protected _onDestroy(): void;
+}

package/types/asset/ResourceManager.d.ts

@@ -0,0 +1,95 @@
+import { Engine } from "..";
+import { AssetPromise } from "./AssetPromise";
+import { Loader } from "./Loader";
+import { LoadItem } from "./LoadItem";
+/**
+ * ResourceManager
+ */
+export declare class ResourceManager {
+    readonly engine: Engine;
+    /** Loader collection. */
+    private static _loaders;
+    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;
+    /** Asset path pool, key is asset ID, value is asset path */
+    private _assetPool;
+    /** Asset pool, the key is the asset path and the value is the asset. */
+    private _assetUrlPool;
+    /** Reference counted object pool, key is the object ID, and reference counted objects are put into this pool. */
+    private _refObjectPool;
+    /** Loading promises. */
+    private _loadingPromises;
+    /**
+     * 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[]>;
+    /**
+     * 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;
+    /**
+     * Get asset url from instanceId.
+     * @param instanceId - Engine instance id
+     * @returns Asset url
+     */
+    getAssetPath(instanceId: number): string;
+    private _assignDefaultOptions;
+    private _loadSingleItem;
+    private _gc;
+    private _getResolveResource;
+    private _parseURL;
+    private _getParameterByName;
+    private _parseQueryPath;
+}
+/**
+ * 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,25 @@
+import { AssetPromise } from "./AssetPromise";
+export type RequestConfig = {
+    type?: XMLHttpRequestResponseType | "image";
+    retryCount?: number;
+    retryInterval?: number;
+    timeout?: number;
+} & RequestInit;
+/**
+ * Web request.
+ * @param url - The link
+ * @param config - Load configuration
+ */
+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;
+    constructor(execFunc: (count?: number) => Promise<any>, totalCount: number, interval: number);
+    private done;
+    start(done?: Function): void;
+    stop(): void;
+    private exec;
+}

package/types/base/Constant.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Data type enumeration
+ */
+export declare enum DataType {
+    /** Float */
+    FLOAT = 5126,
+    /** Floating-point two-dimensional vector */
+    FLOAT_VEC2 = 35664,
+    /** Floating-point three-dimensional vector */
+    FLOAT_VEC3 = 35665,
+    /** Floating-point four-dimensional vector */
+    FLOAT_VEC4 = 35666,
+    /** Integer */
+    INT = 5124,
+    /** Integer two-dimensional vector */
+    INT_VEC2 = 35667,
+    /** Integer three-dimensional vector */
+    INT_VEC3 = 35668,
+    /** Integer four-dimensional vector */
+    INT_VEC4 = 35669,
+    /** Boolean */
+    BOOL = 35670,
+    /** Boolean two-dimensional vector */
+    BOOL_VEC2 = 35671,
+    /** Boolean three-dimensional vector */
+    BOOL_VEC3 = 35672,
+    /** Boolean four-dimensional vector */
+    BOOL_VEC4 = 35673,
+    /** Second-order matrix */
+    FLOAT_MAT2 = 35674,
+    /** Third-order matrix */
+    FLOAT_MAT3 = 35675,
+    /** Fourth-order matrix */
+    FLOAT_MAT4 = 35676,
+    /** Float array */
+    FLOAT_ARRAY = 35677,
+    /** Floating-point two-dimensional vector array */
+    FLOAT_VEC2_ARRAY = 100000,
+    /** Floating-point three-dimensional vector array */
+    FLOAT_VEC3_ARRAY = 100001,
+    /** Floating-point four-dimensional vector array */
+    FLOAT_VEC4_ARRAY = 100002,
+    /** Integer array */
+    INT_ARRAY = 100003,
+    /** Integer two-dimensional vector array */
+    INT_VEC2_ARRAY = 100004,
+    /** Integer three-dimensional vector array */
+    INT_VEC3_ARRAY = 100005,
+    /** Integer four-dimensional vector array */
+    INT_VEC4_ARRAY = 100006,
+    /** Second-order matrix array */
+    FLOAT_MAT2_ARRAY = 100007,
+    /** Third-order matrix array */
+    FLOAT_MAT3_ARRAY = 100008,
+    /** Fourth-order matrix array */
+    FLOAT_MAT4_ARRAY = 100009,
+    /** 2D texture sampler array */
+    SAMPLER_2D_ARRAY = 100010,
+    /** Cube map texture sampler array */
+    SAMPLER_CUBE_ARRAY = 100011,
+    /** 2D sampler */
+    SAMPLER_2D = 35678,
+    /** Cube map Texture sampler */
+    SAMPLER_CUBE = 35680,
+    /** Byte */
+    BYTE = 5120,
+    /** Unsigned byte */
+    UNSIGNED_BYTE = 5121,
+    /** Short */
+    SHORT = 5122,
+    /** Unsigned short */
+    UNSIGNED_SHORT = 5123,
+    /** Unsigned int */
+    UNSIGNED_INT = 5125
+}
+/**
+ * GL Capabilities
+ * Some capabilities can be smoothed out by extension, and some capabilities must use WebGL 2.0.
+ * */
+export declare enum GLCapabilityType {
+    shaderVertexID = "shaderVertexID",
+    standardDerivatives = "OES_standard_derivatives",
+    shaderTextureLod = "EXT_shader_texture_lod",
+    elementIndexUint = "OES_element_index_uint",
+    depthTexture = "WEBGL_depth_texture",
+    drawBuffers = "WEBGL_draw_buffers",
+    vertexArrayObject = "OES_vertex_array_object",
+    instancedArrays = "ANGLE_instanced_arrays",
+    multipleSample = "multipleSampleOnlySupportedInWebGL2",
+    textureFloat = "OES_texture_float",
+    textureFloatLinear = "OES_texture_float_linear",
+    textureHalfFloat = "OES_texture_half_float",
+    textureHalfFloatLinear = "OES_texture_half_float_linear",
+    WEBGL_colorBufferFloat = "WEBGL_color_buffer_float",
+    colorBufferFloat = "EXT_color_buffer_float",
+    colorBufferHalfFloat = "EXT_color_buffer_half_float",
+    textureFilterAnisotropic = "EXT_texture_filter_anisotropic",
+    blendMinMax = "EXT_blend_minmax",
+    astc = "WEBGL_compressed_texture_astc",
+    astc_webkit = "WEBKIT_WEBGL_compressed_texture_astc",
+    etc = "WEBGL_compressed_texture_etc",
+    etc_webkit = "WEBKIT_WEBGL_compressed_texture_etc",
+    etc1 = "WEBGL_compressed_texture_etc1",
+    etc1_webkit = "WEBKIT_WEBGL_compressed_texture_etc1",
+    pvrtc = "WEBGL_compressed_texture_pvrtc",
+    pvrtc_webkit = "WEBKIT_WEBGL_compressed_texture_pvrtc",
+    s3tc = "WEBGL_compressed_texture_s3tc",
+    s3tc_webkit = "WEBKIT_WEBGL_compressed_texture_s3tc"
+}
+export type TypedArray = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Uint8ClampedArray | Float32Array | Float64Array;

package/types/base/EngineObject.d.ts

@@ -0,0 +1,24 @@
+import { Engine } from "../Engine";
+/**
+ * EngineObject.
+ */
+export declare abstract class EngineObject {
+    private static _instanceIdCounter;
+    /** Engine unique id. */
+    readonly instanceId: number;
+    protected _engine: Engine;
+    protected _destroyed: boolean;
+    /**
+     * Get the engine which the object belongs.
+     */
+    get engine(): Engine;
+    /**
+     * Whether it has been destroyed.
+     */
+    get destroyed(): boolean;
+    constructor(engine: Engine);
+    /**
+     * Destroy self.
+     */
+    destroy(): void;
+}

package/types/base/Event.d.ts

@@ -0,0 +1,24 @@
+import { EventDispatcher } from "./EventDispatcher";
+export type Listener = ((e: Event) => any) & {
+    once?: boolean;
+};
+/** Event Object. * @class */
+export declare class Event {
+    get propagationStopped(): boolean;
+    get target(): EventDispatcher;
+    set target(t: EventDispatcher);
+    get timeStamp(): number;
+    get currentTarget(): EventDispatcher;
+    set currentTarget(t: EventDispatcher);
+    get bubbles(): boolean;
+    get type(): string | number;
+    data: any;
+    private _timeStamp;
+    private _target;
+    private _currentTarget;
+    private _bubbles;
+    private _propagationStopped;
+    private _type;
+    constructor(type: string | number, target?: EventDispatcher, data?: any, bubbles?: boolean);
+    stopPropagation(): void;
+}