@galacean/engine-core 0.0.0-experimental-animator-additive.1

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

package/types/base/EventDispatcher.d.ts

@@ -0,0 +1,79 @@
+import { Event } from "./Event";
+/**
+ * EventDispatcher, which can be inherited as a base class.
+ */
+export declare class EventDispatcher {
+    private _events;
+    private _eventCount;
+    private _dispatchingListeners;
+    /**
+     * Determine whether there is event listening.
+     * @param event - Event name
+     * @returns Returns whether there is a corresponding event
+     */
+    hasEvent(event: string): boolean;
+    /**
+     * Returns the names of all registered events.
+     * @returns All event names
+     */
+    eventNames(): string[];
+    /**
+     * Returns the number of listeners with the specified event name.
+     * @param event - Event name
+     * @returns The count of listeners
+     */
+    listenerCount(event: string): number;
+    /**
+     * Dispatch the event with the specified event name.
+     * @param event - Event name
+     * @param data - Data
+     * @returns - Whether the dispatching is successful
+     */
+    dispatch(event: string, data?: any): boolean;
+    /**
+     * Add a listener/
+     * @param event - Event name
+     * @param fn - Function
+     * @returns This
+     */
+    on(event: string, fn: Function): EventDispatcher;
+    /**
+     * Add a one-time listener.
+     * @param event - Event name
+     * @param fn - Function
+     * @returns This
+     */
+    once(event: string, fn: Function): EventDispatcher;
+    /**
+     * @deprecated Use `on/once` instead.
+     * Add a listener function with the specified event name.
+     * @param event - Event name
+     * @param fn - Function
+     * @param once - Is it a one-time listener
+     * @returns this
+     */
+    addEventListener(event: string, fn: Function, once?: boolean): EventDispatcher;
+    /**
+     * Remove the event listener(s) of the specified event name.
+     * @param event - Event name
+     * @param fn - Function, If is undefined, delete all corresponding event listeners.
+     */
+    off(event: string, fn?: Function): EventDispatcher;
+    /**
+     * @deprecated Use `off` instead.
+     * Remove the event listener(s) of the specified event name.
+     * @param event - Event name
+     * @param fn - Function, If is undefined, delete all corresponding event listeners.
+     */
+    removeEventListener(event: string, fn?: Function): EventDispatcher;
+    /**
+     * Remove all event listeners.
+     * @param event - Event name, delete all events if not passed
+     */
+    removeAllEventListeners(event?: string): void;
+    /**
+     * @deprecated Use `dispatch` instead.
+     */
+    trigger(e: Event): void;
+    private _clearEvent;
+}

package/types/base/Logger.d.ts

@@ -0,0 +1,11 @@
+export declare const Logger: {
+    debug: (message?: any, ...optionalParams: any[]) => void;
+    info: (message?: any, ...optionalParams: any[]) => void;
+    warn: (message?: any, ...optionalParams: any[]) => void;
+    error: (message?: any, ...optionalParams: any[]) => void;
+    isEnabled: boolean;
+    /** Turn on log */
+    enable(): void;
+    /** Turn off log */
+    disable(): void;
+};

package/types/base/StaticInterfaceImplement.d.ts

@@ -0,0 +1,5 @@
+/**
+ *  Static interface implement decorator.
+ *  https://stackoverflow.com/questions/13955157/how-to-define-static-property-in-typescript-interface
+ */
+export declare function StaticInterfaceImplement<T>(): <U extends T>(constructor: U) => void;

package/types/base/Time.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Tools for calculating the time per frame.
+ */
+export declare class Time {
+    private _clock;
+    private _timeScale;
+    private _deltaTime;
+    private _startTime;
+    private _lastTickTime;
+    get frameCount(): number;
+    /**
+     * Constructor of the Time.
+     */
+    constructor();
+    reset(): void;
+    /**
+     * Current Time
+     */
+    get nowTime(): number;
+    /**
+     * Time between two ticks
+     */
+    get deltaTime(): number;
+    /**
+     * Scaled delta time.
+     */
+    get timeScale(): number;
+    set timeScale(s: number);
+    /**
+     * Unscaled delta time.
+     */
+    get unscaledDeltaTime(): number;
+    /**
+     * The elapsed time, after the clock is initialized.
+     */
+    get timeSinceStartup(): number;
+    /**
+     * Call every frame, update delta time and other data.
+     */
+    tick(): void;
+}

package/types/base/Util.d.ts

@@ -0,0 +1,14 @@
+export declare const Util: {
+    isArray: (value: any) => boolean;
+    isArrayLike(x: any): boolean;
+    clone<T>(obj: T): T;
+    downloadBlob(blob: Blob, fileName?: string): void;
+};
+export declare const isArrayLike: <T>(x: any) => x is ArrayLike<T>;
+/**
+ * Fastly remove an element from array.
+ * @param array - Array
+ * @param item - Element
+ */
+export declare function removeFromArray(array: any[], item: any): boolean;
+export declare function ObjectValues(obj: any): any[];

package/types/base/index.d.ts

@@ -0,0 +1,7 @@
+export { Event } from "./Event";
+export { EventDispatcher } from "./EventDispatcher";
+export { Logger } from "./Logger";
+export { Time } from "./Time";
+export { Util, ObjectValues } from "./Util";
+export { EngineObject } from "./EngineObject";
+export * from "./Constant";

package/types/clone/CloneManager.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Property decorator, ignore the property when cloning.
+ */
+export declare function ignoreClone(target: Object, propertyKey: string): void;
+/**
+ * Property decorator, assign value to the property when cloning.
+ *
+ * @remarks
+ * If it's a primitive type, the value will be copied.
+ * If it's a class type, the reference will be copied.
+ */
+export declare function assignmentClone(target: Object, propertyKey: string): void;
+/**
+ * Property decorator, shallow clone the property when cloning.
+ * After cloning, it will keep its own reference independent, and use the method of assignment to clone all its internal properties.
+ * if the internal property is a primitive type, the value will be copied, if the internal property is a reference type, its reference address will be copied.。
+ *
+ * @remarks
+ * Applicable to Object, Array, TypedArray and Class types.
+ */
+export declare function shallowClone(target: Object, propertyKey: string): void;
+/**
+ * Property decorator, deep clone the property when cloning.
+ * After cloning, it will maintain its own reference independence, and all its internal deep properties will remain completely independent.
+ *
+ * @remarks
+ * Applicable to Object, Array, TypedArray and Class types.
+ * If Class is encountered during the deep cloning process, the custom cloning function of the object will be called first.
+ * Custom cloning requires the object to implement the IClone interface.
+ */
+export declare function deepClone(target: Object, propertyKey: string): void;

package/types/clone/ComponentCloner.d.ts

@@ -0,0 +1,14 @@
+import { Component } from "../Component";
+/**
+ * Custom clone interface.
+ */
+export interface ICustomClone {
+}
+export declare class ComponentCloner {
+    /**
+     * Clone component.
+     * @param source - Clone source
+     * @param target - Clone target
+     */
+    static cloneComponent(source: Component, target: Component): void;
+}

package/types/clone/enums/CloneMode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Clone mode.
+ */
+export declare enum CloneMode {
+    /** Ignore clone. */
+    Ignore = 0,
+    /** Assignment clone. */
+    Assignment = 1,
+    /** Shallow clone. */
+    Shallow = 2,
+    /** Deep clone. */
+    Deep = 3
+}

package/types/enums/BackgroundMode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Background mode enumeration.
+ */
+export declare enum BackgroundMode {
+    SolidColor = 0,
+    Sky = 1,
+    /** Texture */
+    Texture = 2
+}

package/types/enums/BackgroundTextureFillMode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Filling mode of background texture.
+ */
+export declare enum BackgroundTextureFillMode {
+    AspectFitWidth = 0,
+    AspectFitHeight = 1,
+    Fill = 2
+}

package/types/enums/CameraClearFlags.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Camera clear flags enumeration.
+ */
+export declare enum CameraClearFlags {
+    None = 0,
+    Color = 1,
+    Depth = 2,
+    Stencil = 4,
+    ColorDepth = 3,
+    ColorStencil = 5,
+    DepthStencil = 6,
+    All = 7
+}

package/types/enums/ColorSpace.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Color Space.
+ */
+export declare enum ColorSpace {
+    /** Linear color space. */
+    Linear = 0,
+    /** Gamma color space. */
+    Gamma = 1
+}

package/types/enums/FogMode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Fog Mode.
+ */
+export declare enum FogMode {
+    /** Disable fog. */
+    None = 0,
+    /** Linear fog. */
+    Linear = 1,
+    /** Exponential fog. */
+    Exponential = 2,
+    /** Exponential squared fog. */
+    ExponentialSquared = 3
+}

package/types/env-probe/CubeProbe.d.ts

@@ -0,0 +1,34 @@
+import { Vector3 } from "@galacean/engine-math";
+import { Camera } from "../Camera";
+import { Probe } from "./Probe";
+/**
+ * Cube probe, generate cubeTexture, used for dynamic environment reflection and other effects.
+ */
+export declare class CubeProbe extends Probe {
+    /**
+     * The position of the probe can be set, the default is the origin [0,0,0].
+     */
+    position: Vector3;
+    /**
+     * @override
+     */
+    protected readonly _isCube: boolean;
+    private oriViewMatrix;
+    private _oriFieldOfView;
+    /**
+     * @override
+     */
+    onBeginRender(camera: Camera): void;
+    /**
+     * Store original camera parameters.
+     */
+    private _storeCamera;
+    /**
+     * Restore camera parameters.
+     */
+    private _restoreCamera;
+    /**
+     * Set camera parameters according to the rendering surface.
+     */
+    private _setCamera;
+}

package/types/env-probe/Probe.d.ts

@@ -0,0 +1,58 @@
+import { Camera } from "../Camera";
+import { Layer } from "../Layer";
+import { Script } from "../Script";
+import { Texture } from "../texture";
+/**
+ * Environmental probes, providing necessary capabilities such as reflection and refraction.
+ * @example
+ * ```ts
+ * const probe = cameraEntity.addComponent( CubeProbe )
+ * probe.onTextureChange = cubeTexture => {
+ *   envLight.specularTexture = cubeTexture;
+ *   skybox.specularTexture = cubeTexture;
+ * }
+ * ```
+ */
+export declare abstract class Probe extends Script {
+    /**
+     * Probe's layer, render everything by default.
+     */
+    probeLayer: Layer;
+    /**
+     * The width of the probe rendering target.
+     */
+    width: number;
+    /**
+     * The height of the probe rendering target.
+     */
+    height: number;
+    /**
+     * When using WebGL2, you can turn on MSAA at the hardware layer.
+     */
+    antiAliasing: number;
+    /**
+     * Whether the probe is rendered to the cube color texture.
+     */
+    protected readonly _isCube: boolean;
+    private _oriCameraRenderTarget;
+    private _renderTarget;
+    private _renderTargetSwap;
+    private _activeRenderTarget;
+    private _camera;
+    private _oriCameraCullingMask;
+    private get _texture();
+    /**
+     * Provide hooks for users to exchange Texture.
+     * @remarks Prevent issue: Feedback Loops Between Textures and the Framebuffer.
+     */
+    onTextureChange(renderColorTexture: Texture): void;
+    /**
+     * @override
+     */
+    onBeginRender(camera: Camera): void;
+    /**
+     * @override
+     */
+    onEndRender(camera: Camera): void;
+    protected _reset(): void;
+}

package/types/env-probe/index.d.ts

@@ -0,0 +1,2 @@
+export { Probe } from "./Probe";
+export { CubeProbe } from "./CubeProbe";

package/types/fog/EXP2Fog.d.ts

@@ -0,0 +1,15 @@
+import { Entity } from "../Entity";
+import { Fog } from "./Fog";
+/**
+ * Exponential fog.
+ */
+export declare class EXP2Fog extends Fog {
+    private static _densityProperty;
+    /**
+     * Density of fog.
+     */
+    get density(): number;
+    set density(value: number);
+    private _density;
+    constructor(entity: Entity);
+}

package/types/fog/Fog.d.ts

@@ -0,0 +1,14 @@
+import { Color } from "@oasis-engine/math";
+import { Component } from "../Component";
+/**
+ * Fog.
+ */
+export declare class Fog extends Component {
+    protected static _colorProperty: import("..").ShaderProperty;
+    /**
+     * Fog color.
+     */
+    get color(): Color;
+    set color(value: Color);
+    private _color;
+}

package/types/fog/LinearFog.d.ts

@@ -0,0 +1,22 @@
+import { Entity } from "../Entity";
+import { Fog } from "./Fog";
+/**
+ * Linear fog, according to the distance of the camera linear difference fog density.
+ */
+export declare class LinearFog extends Fog {
+    private static _nearProperty;
+    private static _farProperty;
+    /**
+     * Start of fog.
+     */
+    get near(): number;
+    set near(value: number);
+    /**
+     * End of fog.
+     */
+    get far(): number;
+    set far(value: number);
+    private _near;
+    private _far;
+    constructor(entity: Entity);
+}

package/types/fog/index.d.ts

@@ -0,0 +1,3 @@
+export { EXP2Fog } from "./EXP2Fog";
+export { Fog } from "./Fog";
+export { LinearFog } from "./LinearFog";

package/types/graphic/Buffer.d.ts

@@ -0,0 +1,105 @@
+import { RefObject } from "../asset/RefObject";
+import { Engine } from "../Engine";
+import { BufferBindFlag } from "./enums/BufferBindFlag";
+import { BufferUsage } from "./enums/BufferUsage";
+import { SetDataOptions } from "./enums/SetDataOptions";
+/**
+ * Buffer.
+ */
+export declare class Buffer extends RefObject {
+    _glBindTarget: number;
+    _glBufferUsage: number;
+    _nativeBuffer: WebGLBuffer;
+    private _hardwareRenderer;
+    private _type;
+    private _byteLength;
+    private _bufferUsage;
+    /**
+     * Buffer binding flag.
+     */
+    get type(): BufferBindFlag;
+    /**
+     * Byte length.
+     */
+    get byteLength(): number;
+    /**
+     * Buffer usage.
+     */
+    get bufferUsage(): BufferUsage;
+    /**
+     * Create Buffer.
+     * @param engine - Engine
+     * @param type - Buffer binding flag
+     * @param byteLength - Byte length
+     * @param bufferUsage - Buffer usage
+     */
+    constructor(engine: Engine, type: BufferBindFlag, byteLength: number, bufferUsage?: BufferUsage);
+    /**
+     * Create Buffer.
+     * @param engine - Engine
+     * @param type - Buffer binding flag
+     * @param data - Byte
+     * @param bufferUsage - Buffer usage
+     */
+    constructor(engine: Engine, type: BufferBindFlag, data: ArrayBuffer | ArrayBufferView, bufferUsage?: BufferUsage);
+    /**
+     * Bind buffer.
+     */
+    bind(): void;
+    /**
+     * Set buffer data.
+     * @param data - Input buffer data
+     */
+    setData(data: ArrayBuffer | ArrayBufferView): void;
+    /**
+     * Set buffer data.
+     * @param data - Input buffer data
+     * @param bufferByteOffset - buffer byte offset
+     */
+    setData(data: ArrayBuffer | ArrayBufferView, bufferByteOffset: number): void;
+    /**
+     * Set buffer data.
+     * @param data - Input buffer data
+     * @param bufferByteOffset - Buffer byte offset
+     * @param dataOffset - Buffer byte offset
+     * @param dataLength - Data length
+     */
+    setData(data: ArrayBuffer | ArrayBufferView, bufferByteOffset: number, dataOffset: number, dataLength?: number): void;
+    /**
+     * Set buffer data.
+     * @param data - Input buffer data
+     * @param bufferByteOffset - Buffer byte offset
+     * @param dataOffset - Buffer byte offset
+     * @param dataLength - Data length
+     * @param options - Update strategy: None/Discard/NoOverwrite
+     */
+    setData(data: ArrayBuffer | ArrayBufferView, bufferByteOffset: number, dataOffset: number, dataLength: number, options: SetDataOptions): void;
+    /**
+     * Get buffer data.
+     * @param data - Output buffer data
+     */
+    getData(data: ArrayBufferView): void;
+    /**
+     * Get buffer data.
+     * @param data - Output buffer data
+     * @param bufferByteOffset - Buffer byte offset
+     */
+    getData(data: ArrayBufferView, bufferByteOffset: number): void;
+    /**
+     * Get buffer data.
+     * @param data - Output buffer data
+     * @param bufferByteOffset - Buffer byte offset
+     * @param dataOffset - Output data offset
+     * @param dataLength - Output data length
+     */
+    getData(data: ArrayBufferView, bufferByteOffset: number, dataOffset: number, dataLength: number): void;
+    /**
+     * @override
+     * Destroy.
+     */
+    _onDestroy(): void;
+    /**
+     * @deprecated
+     */
+    resize(dataLength: number): void;
+}

package/types/graphic/BufferUtil.d.ts

@@ -0,0 +1,11 @@
+import { DataType } from "../base/Constant";
+import { IndexFormat } from "./enums/IndexFormat";
+export interface ElementInfo {
+    size: number;
+    type: DataType;
+    normalized: boolean;
+}
+export declare class BufferUtil {
+    static _getGLIndexType(indexFormat: IndexFormat): DataType;
+    static _getGLIndexByteCount(indexFormat: IndexFormat): number;
+}

package/types/graphic/IndexBufferBinding.d.ts

@@ -0,0 +1,21 @@
+import { IndexFormat } from "./enums/IndexFormat";
+import { Buffer } from "./Buffer";
+/**
+ * Index buffer binding.
+ */
+export declare class IndexBufferBinding {
+    /**
+     * Index buffer.
+     */
+    get buffer(): Buffer;
+    /**
+     * Index buffer format.
+     */
+    get format(): IndexFormat;
+    /**
+     * Create index buffer binding.
+     * @param buffer - Index buffer
+     * @param format - Index buffer format
+     */
+    constructor(buffer: Buffer, format: IndexFormat);
+}