@galacean/engine-core 1.6.8 → 1.6.10

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

@@ -0,0 +1,52 @@
+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;
+    onBeginRender(camera: Camera): void;
+    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,114 @@
+import { GraphicsResource } from "../asset/GraphicsResource";
+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 GraphicsResource {
+    private _type;
+    private _byteLength;
+    private _bufferUsage;
+    private _platformBuffer;
+    private _readable;
+    private _data;
+    /**
+     * Buffer binding flag.
+     */
+    get type(): BufferBindFlag;
+    /**
+     * Byte length.
+     */
+    get byteLength(): number;
+    /**
+     * Buffer usage.
+     */
+    get bufferUsage(): BufferUsage;
+    /**
+     * If buffer is readable.
+     */
+    get readable(): boolean;
+    /**
+     * Buffer data cache.
+     *
+     * @remarks
+     * Buffer must be readable.
+     * If the data you get is modified, must call `setData()` to update buffer to GPU.
+     */
+    get data(): Uint8Array;
+    /**
+     * Create Buffer.
+     * @param engine - Engine
+     * @param type - Buffer binding flag
+     * @param byteLength - Byte length
+     * @param bufferUsage - Buffer usage
+     * @param readable - If buffer is readable
+     */
+    constructor(engine: Engine, type: BufferBindFlag, byteLength: number, bufferUsage?: BufferUsage, readable?: boolean);
+    /**
+     * Create Buffer.
+     * @param engine - Engine
+     * @param type - Buffer binding flag
+     * @param data - Buffer data, if `readable` is true, the`data` property will store a copy of this
+     * @param bufferUsage - Buffer usage
+     * @param readable - If buffer is readable
+     */
+    constructor(engine: Engine, type: BufferBindFlag, data: ArrayBuffer | ArrayBufferView, bufferUsage?: BufferUsage, readable?: boolean);
+    /**
+     * 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;
+    /**
+     * Mark buffer as readable, the `data` property will be not accessible anymore.
+     */
+    markAsUnreadable(): void;
+    _rebuild(): void;
+}

package/types/graphic/BufferUtil.d.ts

@@ -0,0 +1,12 @@
+import { DataType } from "../base/Constant";
+import { IndexFormat } from "./enums/IndexFormat";
+export interface ElementInfo {
+    size: number;
+    type: DataType;
+    normalized: boolean;
+    normalizedScaleFactor: number;
+}
+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);
+}

package/types/graphic/Mesh.d.ts

@@ -0,0 +1,58 @@
+import { BoundingBox } from "@galacean/engine-math";
+import { Engine } from "../Engine";
+import { ReferResource } from "../asset/ReferResource";
+import { SubMesh } from "../graphic/SubMesh";
+import { MeshTopology } from "../graphic/enums/MeshTopology";
+/**
+ * Mesh.
+ */
+export declare abstract class Mesh extends ReferResource {
+    /** 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;
+    _addReferCount(value: number): void;
+    private _onBoundsChanged;
+}

package/types/graphic/Primitive.d.ts

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

package/types/graphic/SubMesh.d.ts

@@ -0,0 +1,8 @@
+import { IPoolElement } from "../utils/ObjectPool";
+import { SubPrimitive } from "./SubPrimitive";
+/**
+ * Sub-mesh, mainly contains drawing information.
+ */
+export declare class SubMesh extends SubPrimitive implements IPoolElement {
+    dispose?(): void;
+}

package/types/graphic/SubPrimitive.d.ts

@@ -0,0 +1,19 @@
+import { MeshTopology } from "./enums/MeshTopology";
+/**
+ * Sub-primitive, mainly contains drawing information.
+ */
+export declare class SubPrimitive {
+    /** Start drawing offset. */
+    start: number;
+    /** Drawing count. */
+    count: number;
+    /** Drawing topology. */
+    topology: MeshTopology;
+    /**
+     * Create a sub-primitive.
+     * @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,48 @@
+import { ElementInfo } from "./BufferUtil";
+import { VertexElementFormat } from "./enums/VertexElementFormat";
+/**
+ * Vertex element.
+ */
+export declare class VertexElement {
+    _formatMetaInfo: ElementInfo;
+    private _attributeName;
+    private _offset;
+    private _format;
+    private _bindingIndex;
+    private _instanceStepRate;
+    /**
+     * Vertex attribute.
+     */
+    get attribute(): 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 attribute - Input attribute
+     * @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(attribute: string, offset: number, format: VertexElementFormat, bindingIndex: number, instanceStepRate?: number);
+    /**
+     * @deprecated use `attributeName` instead
+     */
+    get semantic(): string;
+}

package/types/graphic/enums/BufferBindFlag.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Buffer binding flag.
+ */
+export declare enum BufferBindFlag {
+    /** Vertex buffer binding flag */
+    VertexBuffer = 0,
+    /** Index buffer binding flag */
+    IndexBuffer = 1
+}

package/types/graphic/enums/BufferUsage.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Buffer usage.
+ */
+export declare enum BufferUsage {
+    /** The buffer content are intended to be specified once, and used many times */
+    Static = 0,
+    /** The buffer contents are intended to be respecified repeatedly, and used many times */
+    Dynamic = 1,
+    /** The buffer contents are intended to be specified once, and used at most a few times */
+    Stream = 2
+}

package/types/graphic/enums/IndexFormat.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Index format.
+ */
+export declare enum IndexFormat {
+    /** 8 bit */
+    UInt8 = 0,
+    /** 16 bit */
+    UInt16 = 1,
+    /** 32 bit */
+    UInt32 = 2
+}

package/types/graphic/enums/MeshTopology.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Mesh topology.
+ */
+export declare enum MeshTopology {
+    /** Draws a single dot */
+    Points = 0,
+    /** Draws a line between a pair of vertices */
+    Lines = 1,
+    /** Draws a straight line to the next vertex, and connects the last vertex back to the first */
+    LineLoop = 2,
+    /** Draws a straight line to the next vertex. */
+    LineStrip = 3,
+    /** Draws a triangle for a group of three vertices */
+    Triangles = 4,
+    /** Draws a triangle strip */
+    TriangleStrip = 5,
+    /** Draws a triangle fan */
+    TriangleFan = 6
+}

package/types/graphic/enums/SetDataOptions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Define update strategy when call bufferData/bufferSubData func.
+ */
+export declare enum SetDataOptions {
+    /** Can overwrite part of used buffer data and ensure correct rendering */
+    None = 0,
+    /** Discard old buffer and create a new buffer, and won't affect the previous rendering */
+    Discard = 1
+}

package/types/graphic/enums/VertexElementFormat.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Vertex element format.
+ */
+export declare enum VertexElementFormat {
+    /** 32-bit float */
+    Float = 0,
+    /** Two-dimensional 32-bit float */
+    Vector2 = 1,
+    /** Three-dimensional 32-bit float */
+    Vector3 = 2,
+    /** Four-dimensional 32-bit float */
+    Vector4 = 3,
+    /** Four-dimensional 8-bit integer,range is [-128,127] */
+    Byte4 = 4,
+    /** Four-dimensional 8-bit Unsigned integer, range is [0,255] */
+    UByte4 = 5,
+    /** Four-dimensional 8-bit Normalized integer, range is [-1,1] */
+    NormalizedByte4 = 6,
+    /** Four-dimensional 8-bit Normalized unsigned integer, range is [0,1] */
+    NormalizedUByte4 = 7,
+    /** Two-dimensional 16-bit integer, range is[-32768, 32767] */
+    Short2 = 8,
+    /** Two-dimensional 16-bit Unsigned integer, range is [0, 65535] */
+    UShort2 = 9,
+    /** Two-dimensional 16-bit Unsigned integer, range is [-1, 1] */
+    NormalizedShort2 = 10,
+    /** Two-dimensional 16-bit Normalized unsigned integer, range is [0, 1] */
+    NormalizedUShort2 = 11,
+    /** Four-dimensional 16-bit integer, range is [-32768, 32767] */
+    Short4 = 12,
+    /** Four-dimensional 16-bit Unsigned integer, range is [0, 65535] */
+    UShort4 = 13,
+    /** Four-dimensional 16-bit Normalized integer, range is[-1, 1] */
+    NormalizedShort4 = 14,
+    /** Four-dimensional 16-bit Normalized unsigned integer, range is [0, 1] */
+    NormalizedUShort4 = 15
+}

package/types/graphic/index.d.ts

@@ -0,0 +1,15 @@
+export { Buffer } from "./Buffer";
+export { BufferUtil } from "./BufferUtil";
+export { BufferBindFlag } from "./enums/BufferBindFlag";
+export { BufferUsage } from "./enums/BufferUsage";
+export { IndexFormat } from "./enums/IndexFormat";
+export { MeshTopology } from "./enums/MeshTopology";
+export { SetDataOptions } from "./enums/SetDataOptions";
+export { VertexElementFormat } from "./enums/VertexElementFormat";
+export { IndexBufferBinding } from "./IndexBufferBinding";
+export { Mesh } from "./Mesh";
+export { SubMesh } from "./SubMesh";
+export { VertexBufferBinding } from "./VertexBufferBinding";
+export { VertexElement } from "./VertexElement";
+export { Primitive } from "./Primitive";
+export { SubPrimitive } from "./SubPrimitive";

package/types/index.d.ts

@@ -0,0 +1,68 @@
+export { Platform } from "./Platform";
+export { Engine } from "./Engine";
+export { SystemInfo } from "./SystemInfo";
+export { Canvas } from "./Canvas";
+export { DisorderedArray } from "./utils/DisorderedArray";
+export { Scene } from "./Scene";
+export { SceneManager } from "./SceneManager";
+export { Entity } from "./Entity";
+export { Component } from "./Component";
+export { Script } from "./Script";
+export { Renderer, RendererUpdateFlags } from "./Renderer";
+export { dependentComponents, DependentMode } from "./ComponentsDependencies";
+export { Camera } from "./Camera";
+export { Transform, TransformModifyFlags } from "./Transform";
+export { BoolUpdateFlag } from "./BoolUpdateFlag";
+export type { EngineSettings } from "./EngineSettings";
+export type { EngineConfiguration } from "./Engine";
+export type { ComponentConstructor } from "./Entity";
+export { request } from "./asset/request";
+export type { RequestConfig } from "./asset/request";
+export { Loader } from "./asset/Loader";
+export { ContentRestorer } from "./asset/ContentRestorer";
+export { ResourceManager, resourceLoader } from "./asset/ResourceManager";
+export { AssetPromise } from "./asset/AssetPromise";
+export type { LoadItem } from "./asset/LoadItem";
+export { AssetType } from "./asset/AssetType";
+export { ReferResource } from "./asset/ReferResource";
+export * from "./RenderPipeline/index";
+export * from "./base";
+export { Background } from "./Background";
+export { BackgroundMode } from "./enums/BackgroundMode";
+export { DepthTextureMode } from "./enums/DepthTextureMode";
+export { FogMode } from "./enums/FogMode";
+export { CameraClearFlags } from "./enums/CameraClearFlags";
+export { CameraType } from "./enums/CameraType";
+export { CameraModifyFlags } from "./enums/CameraModifyFlags";
+export { EntityModifyFlags } from "./enums/EntityModifyFlags";
+export { MSAASamples } from "./enums/MSAASamples";
+export { ReplacementFailureStrategy } from "./enums/ReplacementFailureStrategy";
+export { Downsampling } from "./enums/Downsampling";
+export { BackgroundTextureFillMode } from "./enums/BackgroundTextureFillMode";
+export { SpriteMaskLayer } from "./enums/SpriteMaskLayer";
+export { XRManager } from "./xr/XRManager";
+export * from "./utils/index";
+export * from "./input/index";
+export * from "./lighting/index";
+export * from "./shadow/index";
+export * from "./material/index";
+export * from "./texture/index";
+export * from "./graphic/index";
+export * from "./2d/index";
+export * from "./shaderlib/index";
+export * from "./animation/index";
+export * from "./mesh/index";
+export * from "./sky/index";
+export * from "./particle/index";
+export * from "./trail/index";
+export * from "./env-probe/index";
+export * from "./shader/index";
+export * from "./Layer";
+export * from "./clone/CloneManager";
+export * from "./renderingHardwareInterface/index";
+export * from "./physics/index";
+export * from "./Utils";
+export * from "./audio/index";
+export { ShaderMacroCollection } from "./shader/ShaderMacroCollection";
+export * from "./postProcess";
+export { AntiAliasing } from "./enums/AntiAliasing";

package/types/input/InputManager.d.ts

@@ -0,0 +1,65 @@
+import { Vector3 } from "@galacean/engine-math";
+import { Keys } from "./enums/Keys";
+import { PointerButton } from "./enums/PointerButton";
+import { Pointer } from "./pointer/Pointer";
+/**
+ * InputManager manages device input such as mouse, touch, keyboard, etc.
+ */
+export declare class InputManager {
+    private _engine;
+    /** Sometimes the input module will not be initialized, such as off-screen rendering. */
+    private _initialized;
+    private _wheelManager;
+    private _pointerManager;
+    private _keyboardManager;
+    /**
+     * Pointer list.
+     */
+    get pointers(): Readonly<Pointer[]>;
+    /**
+     *  Whether to handle multi-pointer.
+     */
+    get multiPointerEnabled(): boolean;
+    set multiPointerEnabled(enabled: boolean);
+    /**
+     * Get the change of the scroll wheel on the x-axis.
+     * @returns Change value
+     */
+    get wheelDelta(): Readonly<Vector3 | null>;
+    /**
+     * Whether the key is being held down, if there is no parameter, return whether any key is being held down.
+     * @param key - The keys of the keyboard
+     * @returns Whether the key is being held down
+     */
+    isKeyHeldDown(key?: Keys): boolean;
+    /**
+     * Whether the key starts to be pressed down during the current frame, if there is no parameter, return whether any key starts to be pressed down during the current frame.
+     * @param key - The keys of the keyboard
+     * @returns Whether the key starts to be pressed down during the current frame
+     */
+    isKeyDown(key?: Keys): boolean;
+    /**
+     * Whether the key is released during the current frame, if there is no parameter, return whether any key released during the current frame.
+     * @param key - The keys of the keyboard
+     * @returns Whether the key is released during the current frame
+     */
+    isKeyUp(key?: Keys): boolean;
+    /**
+     * Whether the pointer is being held down, if there is no parameter, return whether any pointer is being held down.
+     * @param pointerButton - The pointerButton on a pointer device
+     * @returns Whether the pointer is being held down
+     */
+    isPointerHeldDown(pointerButton?: PointerButton): boolean;
+    /**
+     * Whether the pointer starts to be pressed down during the current frame, if there is no parameter, return whether any pointer starts to be pressed down during the current frame.
+     * @param pointerButton - The pointerButton on a pointer device
+     * @returns Whether the pointer starts to be pressed down during the current frame
+     */
+    isPointerDown(pointerButton?: PointerButton): boolean;
+    /**
+     * Whether the pointer is released during the current frame, if there is no parameter, return whether any pointer released during the current frame.
+     * @param pointerButton - The pointerButtons on a mouse device
+     * @returns Whether the pointer is released during the current frame
+     */
+    isPointerUp(pointerButton?: PointerButton): boolean;
+}