@galacean/engine-core 1.6.8 → 1.6.9

package/types/texture/index.d.ts

@@ -0,0 +1,13 @@
+export { RenderBufferDepthFormat } from "./enums/RenderBufferDepthFormat";
+export { TextureCubeFace } from "./enums/TextureCubeFace";
+export { TextureDepthCompareFunction } from "./enums/TextureDepthCompareFunction";
+export { TextureFilterMode } from "./enums/TextureFilterMode";
+export { TextureFormat } from "./enums/TextureFormat";
+export { TextureUsage } from "./enums/TextureUsage";
+export { TextureWrapMode } from "./enums/TextureWrapMode";
+export { RenderTarget } from "./RenderTarget";
+export { Texture } from "./Texture";
+export { Texture2D } from "./Texture2D";
+export { Texture2DArray } from "./Texture2DArray";
+export { TextureCube } from "./TextureCube";
+export { TextureUtils } from "./TextureUtils";

package/types/trail/TrailMaterial.d.ts

@@ -0,0 +1,5 @@
+import { Engine } from "../Engine";
+import { Material } from "../material/Material";
+export declare class TrailMaterial extends Material {
+    constructor(engine: Engine);
+}

package/types/trail/TrailRenderer.d.ts

@@ -0,0 +1,35 @@
+import { Entity } from "../Entity";
+import { MeshRenderer } from "../mesh/MeshRenderer";
+import { Texture2D } from "../texture";
+/**
+ * @deprecated
+ */
+export declare class TrailRenderer extends MeshRenderer {
+    private _vertexStride;
+    private _vertices;
+    private _vertexBuffer;
+    private _stroke;
+    private _minSeg;
+    private _lifetime;
+    private _maxPointNum;
+    private _points;
+    private _pointStates;
+    private _strapPoints;
+    private _curPointNum;
+    private _prePointsNum;
+    /**
+     * @deprecated
+     */
+    constructor(entity: Entity, props: any);
+    /**
+     * @deprecated
+     * Set trail texture.
+     * @param texture
+     */
+    setTexture(texture: Texture2D): void;
+    private _initGeometry;
+    private _updateStrapVertices;
+    private _updateStrapCoords;
+    private _projectOnVector;
+    private _projectOnPlane;
+}

package/types/trail/index.d.ts

@@ -0,0 +1,2 @@
+export { TrailRenderer } from "./TrailRenderer";
+export { TrailMaterial } from "./TrailMaterial";

package/types/ui/IUICanvas.d.ts

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

package/types/ui/UIUtils.d.ts

@@ -0,0 +1,12 @@
+import { Engine } from "../Engine";
+import { Scene } from "../Scene";
+import { DisorderedArray } from "../utils/DisorderedArray";
+import { IUICanvas } from "./IUICanvas";
+export declare class UIUtils {
+    private static _shouldSRGBCorrect;
+    private static _renderQueue;
+    private static _virtualCamera;
+    private static _viewport;
+    private static _overlayCamera;
+    static renderOverlay(engine: Engine, scene: Scene, uiCanvases: DisorderedArray<IUICanvas>): void;
+}

package/types/utils/ClearableObjectPool.d.ts

@@ -0,0 +1,16 @@
+import { IPoolElement, ObjectPool } from "./ObjectPool";
+/**
+ * Clearable Object Pool.
+ */
+export declare class ClearableObjectPool<T extends IPoolElement> extends ObjectPool<T> {
+    private _usedElementCount;
+    constructor(type: new () => T);
+    /**
+     * Get an object.
+     */
+    get(): T;
+    /**
+     * Clear used object count to 0, not destroy any object, just change index.
+     */
+    clear(): void;
+}

package/types/utils/DisorderedArray.d.ts

@@ -0,0 +1,70 @@
+/**
+ * High-performance unordered array, delete uses exchange method to improve performance, internal capacity only increases.
+ */
+export declare class DisorderedArray<T> {
+    /** The length of the array. */
+    length: number;
+    private _loopCounter;
+    private _blankCount;
+    /**
+     * Get whether the array is in the loop.
+     */
+    get isLopping(): boolean;
+    /**
+     * Create a DisorderedArray.
+     * @param count - The initial length of the array
+     */
+    constructor(count?: number);
+    /**
+     * Add an element to disordered array.
+     * @param element - The element to be added
+     */
+    add(element: T): void;
+    /**
+     * Delete the specified element.
+     * @param element - The element to be deleted
+     */
+    delete(element: T): void;
+    /**
+     * Set the element at the specified index.
+     * @param index - The index of the element to be set
+     * @param element - The element to be set
+     */
+    set(index: number, element: T): void;
+    /**
+     * Get the element at the specified index.
+     * @param index - The index of the element to be get
+     * @returns The element at the specified index
+     */
+    get(index: number): T;
+    /**
+     * Delete the element at the specified index.
+     * @param index - The index of the element to be deleted
+     * @returns The replaced item is used to reset its index
+     */
+    deleteByIndex(index: number): T;
+    /**
+     * Loop through all elements.
+     * @param callbackFn - The callback function
+     * @param swapFn - The swap function can process the element after the callback function, it will be called after end looping(`isLopping` = true)
+     */
+    forEach(callbackFn: (element: T, index: number) => void, swapFn?: (element: T, index: number) => void): void;
+    /**
+     * Loop through all elements and clean up the blank elements.
+     * @param callbackFn - The callback function
+     * @param swapFn - The swap function can process the element after the callback function,  it will be called after end looping(`isLopping` = true)
+     */
+    forEachAndClean(callbackFn: (element: T, index: number) => void, swapFn?: (element: T, index: number) => void): void;
+    /**
+     * Sort the array.
+     * @param compareFn - The comparison function
+     */
+    sort(compareFn: (a: T, b: T) => number): void;
+    /**
+     * Garbage collection, clean up all cached elements.
+     */
+    garbageCollection(): void;
+    private _startLoop;
+    private _endLoop;
+    private _endLoopAndClean;
+}

package/types/utils/ObjectPool.d.ts

@@ -0,0 +1,16 @@
+export declare abstract class ObjectPool<T extends IPoolElement> {
+    protected _type: new () => T;
+    protected _elements: T[];
+    constructor(type: new () => T);
+    garbageCollection(): void;
+    abstract get(): T;
+}
+/**
+ * The basic interface for Object Pool's element.
+ */
+export interface IPoolElement {
+    /**
+     * Called when the object need be release.
+     */
+    dispose?(): void;
+}

package/types/utils/ReturnableObjectPool.d.ts

@@ -0,0 +1,16 @@
+import { IPoolElement, ObjectPool } from "./ObjectPool";
+/**
+ * Returnable Object Pool.
+ */
+export declare class ReturnableObjectPool<T extends IPoolElement> extends ObjectPool<T> {
+    private _lastElementIndex;
+    constructor(type: new () => T, initializeCount?: number);
+    /**
+     * Get an object from the pool.
+     */
+    get(): T;
+    /**
+     * Return an object to the pool.
+     */
+    return(element: T): void;
+}

package/types/utils/SafeLoopArray.d.ts

@@ -0,0 +1,46 @@
+export declare class SafeLoopArray<T> {
+    private _array;
+    private _loopArray;
+    private _loopArrayDirty;
+    /**
+     * Get the length of the array.
+     */
+    get length(): number;
+    /**
+     * Push item to the array.
+     * @param item - The item which want to be pushed
+     */
+    push(item: T): void;
+    /**
+     * Add item to the array.
+     * @param index - The index of the array
+     * @param item - The item which want to be added
+     */
+    add(index: number, item: T): void;
+    /**
+     * Remove item from the array.
+     * @param index - The index of the array
+     */
+    removeByIndex(index: number): void;
+    /**
+     * Remove item from array that pass the specified comparison function.
+     * @param filter - The comparison function
+     */
+    findAndRemove(filter: (value: T) => boolean): void;
+    /**
+     * The index of the item.
+     * @param item - The item which want to get the index
+     * @returns Index of the item
+     */
+    indexOf(item: T): number;
+    /**
+     * Get the array.
+     * @returns The array
+     */
+    getArray(): ReadonlyArray<T>;
+    /**
+     * Get the array use for loop.
+     * @returns The array use for loop
+     */
+    getLoopArray(): ReadonlyArray<T>;
+}

package/types/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { ClearableObjectPool } from "./ClearableObjectPool";
+export type { IPoolElement } from "./ObjectPool";
+export { ReturnableObjectPool } from "./ReturnableObjectPool";
+export { SafeLoopArray } from "./SafeLoopArray";

package/types/xr/XRManager.d.ts

@@ -0,0 +1,5 @@
+/**
+ * XRManager located in the main package, its implementation logic is XRManagerExtended in the sub-package engine-xr.
+ */
+export declare class XRManager {
+}