@galacean/engine-core 0.9.0-beta.80

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/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): DataType;
+}

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

package/types/graphic/Mesh.d.ts

@@ -0,0 +1,70 @@
+import { BoundingBox } from "@galacean/engine-math";
+import { RefObject } from "../asset/RefObject";
+import { Engine } from "../Engine";
+import { MeshTopology } from "../graphic/enums/MeshTopology";
+import { IndexBufferBinding } from "../graphic/IndexBufferBinding";
+import { SubMesh } from "../graphic/SubMesh";
+import { VertexElement } from "../graphic/VertexElement";
+/**
+ * Mesh.
+ */
+export declare abstract class Mesh extends RefObject {
+    /** Name. */
+    name: string;
+    private _bounds;
+    private _subMeshes;
+    /**
+     * The bounding volume of the mesh.
+     */
+    get bounds(): BoundingBox;
+    set bounds(value: BoundingBox);
+    /**
+     * First sub-mesh. Rendered using the first material.
+     */
+    get subMesh(): SubMesh | null;
+    /**
+     * A collection of sub-mesh, each sub-mesh can be rendered with an independent material.
+     */
+    get subMeshes(): Readonly<SubMesh[]>;
+    /**
+     * Create mesh.
+     * @param engine - Engine
+     * @param name - Mesh name
+     */
+    constructor(engine: Engine, name?: string);
+    /**
+     * Add sub-mesh, each sub-mesh can correspond to an independent material.
+     * @param subMesh - Start drawing offset, if the index buffer is set, it means the offset in the index buffer, if not set, it means the offset in the vertex buffer
+     * @returns Sub-mesh
+     */
+    addSubMesh(subMesh: SubMesh): SubMesh;
+    /**
+     * Add sub-mesh, each sub-mesh can correspond to an independent material.
+     * @param start - Start drawing offset, if the index buffer is set, it means the offset in the index buffer, if not set, it means the offset in the vertex buffer
+     * @param count - Drawing count, if the index buffer is set, it means the count in the index buffer, if not set, it means the count in the vertex buffer
+     * @param topology - Drawing topology, default is MeshTopology.Triangles
+     * @returns Sub-mesh
+     */
+    addSubMesh(start: number, count: number, topology?: MeshTopology): SubMesh;
+    /**
+     * Remove sub-mesh.
+     * @param subMesh - Sub-mesh needs to be removed
+     */
+    removeSubMesh(subMesh: SubMesh): void;
+    /**
+     * Clear all sub-mesh.
+     */
+    clearSubMesh(): void;
+    /**
+     * @override
+     */
+    _addRefCount(value: number): void;
+    /**
+     * @override
+     * Destroy.
+     */
+    _onDestroy(): void;
+    protected _setVertexElements(elements: VertexElement[]): void;
+    protected _setIndexBufferBinding(binding: IndexBufferBinding | null): void;
+    private _onBoundsChanged;
+}

package/types/graphic/SubMesh.d.ts

@@ -0,0 +1,19 @@
+import { MeshTopology } from "./enums/MeshTopology";
+/**
+ * Sub-mesh, mainly contains drawing information.
+ */
+export declare class SubMesh {
+    /** Start drawing offset. */
+    start: number;
+    /** Drawing count. */
+    count: number;
+    /** Drawing topology. */
+    topology: MeshTopology;
+    /**
+     * Create a sub-mesh.
+     * @param start - Start drawing offset
+     * @param count - Drawing count
+     * @param topology - Drawing topology
+     */
+    constructor(start?: number, count?: number, topology?: MeshTopology);
+}

package/types/graphic/VertexBufferBinding.d.ts

@@ -0,0 +1,20 @@
+import { Buffer } from "./Buffer";
+/**
+ * Vertex buffer binding.
+ */
+export declare class VertexBufferBinding {
+    /**
+     * Vertex buffer.
+     */
+    get buffer(): Buffer;
+    /**
+     * Vertex buffer stride.
+     */
+    get stride(): number;
+    /**
+     * Create vertex buffer.
+     * @param buffer - Vertex buffer
+     * @param stride - Vertex buffer stride
+     */
+    constructor(buffer: Buffer, stride: number);
+}

package/types/graphic/VertexElement.d.ts

@@ -0,0 +1,44 @@
+import { ElementInfo } from "./BufferUtil";
+import { VertexElementFormat } from "./enums/VertexElementFormat";
+/**
+ * Vertex element.
+ */
+export declare class VertexElement {
+    _glElementInfo: ElementInfo;
+    private _semantic;
+    private _offset;
+    private _format;
+    private _bindingIndex;
+    private _instanceStepRate;
+    /**
+     * Vertex semantic.
+     */
+    get semantic(): string;
+    /**
+     * Vertex data byte offset.
+     */
+    get offset(): number;
+    set offset(value: number);
+    /**
+     * Vertex data format.
+     */
+    get format(): VertexElementFormat;
+    /**
+     * Vertex buffer binding index.
+     */
+    get bindingIndex(): number;
+    set bindingIndex(value: number);
+    /**
+     * Instance cadence, the number of instances drawn for each vertex in the buffer, non-instance elements must be 0.
+     */
+    get instanceStepRate(): number;
+    /**
+     * Create vertex element.
+     * @param semantic - Input vertex semantic
+     * @param offset - Vertex data byte offset
+     * @param format - Vertex data format
+     * @param bindingIndex - Vertex buffer binding index
+     * @param instanceStepRate - Instance cadence, the number of instances drawn for each vertex in the buffer, non-instance elements must be 0.
+     */
+    constructor(semantic: string, offset: number, format: VertexElementFormat, bindingIndex: number, instanceStepRate?: number);
+}