@galacean/engine-core 2.0.0-alpha.44 → 2.0.0-alpha.46

package/types/asset/RenderingStatistics.d.ts

@@ -2,6 +2,10 @@
  * Rendering statistics.
  */
 export declare class RenderingStatistics {
+    /** @internal */
+    _textureMemory: number;
+    /** @internal */
+    _bufferMemory: number;
     /**
      * Memory used by all textures, in bytes.
      */
@@ -14,4 +18,8 @@ export declare class RenderingStatistics {
      * Total memory used, in bytes.
      */
     get totalMemory(): number;
+    /**
+     * @internal
+     */
+    _reset(): void;
 }

package/types/asset/ResourceManager.d.ts

@@ -1,13 +1,26 @@
 import { ContentRestorer, Engine, EngineObject } from "..";
+import type { Shader } from "../shader/Shader";
 import { AssetPromise } from "./AssetPromise";
+import { GraphicsResource } from "./GraphicsResource";
 import { Loader } from "./Loader";
 import { LoadItem } from "./LoadItem";
+import { ReferResource } from "./ReferResource";
+import { RequestConfig } from "./request";
+type LoadableResource = EngineObject | Shader;
 /**
  * ResourceManager
  */
 export declare class ResourceManager {
     readonly engine: Engine;
+    /** @internal */
+    static _loaders: {
+        [key: string]: Loader<any>;
+    };
     private static _extTypeMapping;
+    /**
+     * @internal
+     */
+    static _addLoader(type: string, loader: Loader<any>, extNames: string[]): void;
     private static _getTypeByUrl;
     /** The number of retries after failing to load assets. */
     retryCount: number;
@@ -39,25 +52,25 @@ export declare class ResourceManager {
      * @param assetItem - AssetItem
      * @returns AssetPromise
      */
-    load<T extends EngineObject>(assetItem: LoadItem): AssetPromise<T>;
+    load<T extends LoadableResource>(assetItem: LoadItem): AssetPromise<T>;
     /**
      * Load the asset collection asynchronously by loading the information collection.
      * @param assetItems - Asset collection
      * @returns AssetPromise
      */
-    load<T extends EngineObject[]>(assetItems: LoadItem[]): AssetPromise<T>;
+    load<T extends LoadableResource[]>(assetItems: LoadItem[]): AssetPromise<T>;
     /**
      * Load asset collection asynchronously through urls.
      * @param paths - Path collections
      * @returns Asset Promise
      */
-    load<T extends EngineObject[]>(paths: string[]): AssetPromise<T>;
+    load<T extends LoadableResource[]>(paths: string[]): AssetPromise<T>;
     /**
      * Load asset asynchronously through the path.
      * @param path - Path
      * @returns Asset promise
      */
-    load<T extends EngineObject>(path: string): AssetPromise<T>;
+    load<T extends LoadableResource>(path: string): AssetPromise<T>;
     /**
      * Get the resource from cache by asset url, return the resource object if it loaded, otherwise return null.
      * @param url - Resource URL
@@ -100,6 +113,66 @@ export declare class ResourceManager {
      * @param restorer - The restorer
      */
     addContentRestorer<T extends EngineObject>(restorer: ContentRestorer<T>): void;
+    /**
+     * @internal
+     */
+    _getRemoteUrl(url: string): string;
+    /**
+     * @internal
+     */
+    _requestByRemoteUrl<T>(url: string, config: RequestConfig): AssetPromise<T>;
+    /**
+     * @internal
+     */
+    _request<T>(url: string, config: RequestConfig): AssetPromise<T>;
+    /**
+     * @internal
+     */
+    _onSubAssetSuccess<T>(remoteAssetBaseURL: string, assetSubPath: string, value: T): void;
+    /**
+     * @internal
+     */
+    _addAsset(path: string, asset: EngineObject): void;
+    /**
+     * @internal
+     */
+    _deleteAsset(asset: EngineObject): void;
+    /**
+     * @internal
+     */
+    _addReferResource(resource: ReferResource): void;
+    /**
+     * @internal
+     */
+    _deleteReferResource(resource: EngineObject): void;
+    /**
+     * @internal
+     */
+    _addGraphicResource(resource: GraphicsResource): void;
+    /**
+     * @internal
+     */
+    _deleteGraphicResource(resource: EngineObject): void;
+    /**
+     * @internal
+     */
+    _deleteContentRestorer(resource: EngineObject): void;
+    /**
+     * @internal
+     */
+    _restoreGraphicResources(): void;
+    /**
+     * @internal
+     */
+    _lostGraphicResources(): void;
+    /**
+     * @internal
+     */
+    _restoreResourcesContent(): Promise<void[]>;
+    /**
+     * @internal
+     */
+    _destroy(): void;
     private _resolveLoadItemOptions;
     private _loadSingleItem;
     private _loadSubpackageAndMainAsset;
@@ -112,12 +185,27 @@ export declare class ResourceManager {
     private _parseURL;
     private _parseQueryPath;
     private _releaseSubAssetPromiseCallback;
+    /** @internal */
+    _objectPool: {
+        [key: string]: any;
+    };
+    /** @internal */
+    _virtualPathResourceMap: Record<VirtualPath, VirtualResource>;
     /**
      * Register virtual asset paths and their load descriptors.
      * @remarks References inside runtime scenes and Prefabs can keep stable virtual paths while the backing URLs
      * are generated dynamically, such as object URLs created from a resource package.
      */
     registerVirtualResources(resources: readonly VirtualResource[]): void;
+    /**
+     * @internal
+     * @beta Just for internal editor, not recommended for developers.
+     */
+    getResourceByRef<T extends LoadableResource>(ref: {
+        url: string;
+        key?: string;
+        isClone?: boolean;
+    }): AssetPromise<T | null>;
 }
 /**
  * Declare ResourceLoader's decorator.
@@ -127,6 +215,7 @@ export declare class ResourceManager {
 export declare function resourceLoader(assetType: string, extNames: string[], useCache?: boolean): <T extends Loader<any>>(Target: {
     new (useCache: boolean): T;
 }) => void;
+type VirtualPath = string;
 export interface VirtualResource {
     virtualPath: string;
     path: string;
@@ -137,3 +226,4 @@ export interface VirtualResource {
     subpackageName?: string;
     params?: Record<string, any>;
 }
+export {};

package/types/audio/AudioClip.d.ts

@@ -20,5 +20,13 @@ export declare class AudioClip extends ReferResource {
      */
     get duration(): number;
     constructor(engine: Engine, name?: string);
+    /**
+     * @internal
+     */
+    _getAudioSource(): AudioBuffer;
+    /**
+     * @internal
+     */
+    _setAudioSource(value: AudioBuffer): void;
     protected _onDestroy(): void;
 }

package/types/audio/AudioManager.d.ts

@@ -2,6 +2,8 @@
  * Audio Manager for managing global audio context and settings.
  */
 export declare class AudioManager {
+    /** @internal */
+    static _playingCount: number;
     private static _context;
     private static _gainNode;
     private static _resumePromise;
@@ -19,6 +21,18 @@ export declare class AudioManager {
      * @returns A promise that resolves when the audio context is resumed
      */
     static resume(): Promise<void>;
+    /**
+     * @internal
+     */
+    static getContext(): AudioContext;
+    /**
+     * @internal
+     */
+    static getGainNode(): GainNode;
+    /**
+     * @internal
+     */
+    static isAudioContextRunning(): boolean;
     private static _onVisibilityChange;
     private static _recoverPlaybackContext;
     private static _onPageShow;

package/types/audio/AudioSource.d.ts

@@ -1,4 +1,5 @@
 import { Component } from "../Component";
+import { Entity } from "../Entity";
 import { AudioClip } from "./AudioClip";
 /**
  * Audio Source Component.
@@ -54,6 +55,10 @@ export declare class AudioSource extends Component {
      * Playback position in seconds.
      */
     get time(): number;
+    /**
+     * @internal
+     */
+    constructor(entity: Entity);
     /**
      * Play the clip.
      */
@@ -66,6 +71,18 @@ export declare class AudioSource extends Component {
      * Pauses playing the clip.
      */
     pause(): void;
+    /**
+     * @internal
+     */
+    _onEnable(): void;
+    /**
+     * @internal
+     */
+    _onDisable(): void;
+    /**
+     * @internal
+     */
+    protected _onDestroy(): void;
     private _onPlayEnd;
     private _ensureGainNode;
     private _startPlayback;

package/types/base/EngineObject.d.ts

@@ -5,6 +5,10 @@ import { Engine } from "../Engine";
 export declare class EngineObject {
     private static _instanceIdCounter;
     readonly instanceId: number;
+    /** @internal */
+    _engine: Engine;
+    /** @internal */
+    _pendingDestroy: boolean;
     protected _destroyed: boolean;
     /**
      * Get the engine which the object belongs.

package/types/base/Time.d.ts

@@ -1,3 +1,4 @@
+import { ShaderData } from "../shader/ShaderData";
 /**
  * Provide time related information.
  */
@@ -41,4 +42,16 @@ export declare class Time {
      * Constructor of the Time.
      */
     constructor();
+    /**
+     * @internal
+     */
+    _reset(): void;
+    /**
+     * @internal
+     */
+    _update(): void;
+    /**
+     * @internal
+     */
+    _updateSceneShaderData(shaderData: ShaderData): void;
 }

package/types/clone/CloneDecorators.d.ts

@@ -1,3 +1,17 @@
+/** @internal */
+export declare const defaultCloneModeKey: unique symbol;
+/** @internal */
+export declare const fieldCloneModesKey: unique symbol;
+/**
+ * @internal
+ */
+export declare const enum CloneMode {
+    Ignore = 0,
+    Assignment = 1,
+    Remap = 2,
+    Copy = 3,
+    Deep = 4
+}
 /**
  * Property decorator — deep clone this field's whole subtree, overriding the value type's default
  * clone mode (field-level decorators have the highest priority). The deep intent carries into
@@ -15,3 +29,9 @@ export declare function assignmentClone(target: object, propertyKey: string): vo
  * Property decorator — ignore this field when cloning; keep the clone's own constructor-built value.
  */
 export declare function ignoreClone(target: object, propertyKey: string): void;
+/**
+ * @internal
+ */
+export declare function registerDefaultCloneMode(target: {
+    prototype: object;
+}, mode: CloneMode): void;

package/types/clone/CloneUtil.d.ts

@@ -1 +1,30 @@
-export {};
+import { CloneMode } from "./CloneDecorators";
+/**
+ * @internal
+ */
+export declare class CloneUtil {
+    /**
+     * @internal
+     */
+    static _cloneObjectFields(source: any, target: object, cloneMap: Map<object, object>, deepCloneSubtree?: boolean): void;
+    /**
+     * @internal
+     */
+    static _cloneFieldValue(source: any, preset: any, cloneMap: Map<object, object>, fieldMode?: CloneMode, deepCloneSubtree?: boolean): any;
+    /**
+     * @internal
+     */
+    static _transferSlotOwnership(cloned: any, source: any, preset: any): void;
+    private static _cloneValueForDeepField;
+    private static _cloneValueByDefault;
+    private static _cloneCopyFromValue;
+    private static _cloneObjectByFields;
+    private static _createCloneTarget;
+    private static _deepCloneArrayBufferView;
+    private static _cloneArray;
+    private static _cloneMap;
+    private static _cloneSet;
+    private static _isPlainObject;
+    private static _hasOrdinaryObjectTag;
+    private static _getTypeName;
+}

package/types/clone/ComponentCloner.d.ts

@@ -1 +1,11 @@
-export {};
+import { Component } from "../Component";
+/**
+ * @internal
+ * Clones component fields and runs the component's post-clone hook.
+ */
+export declare class ComponentCloner {
+    /**
+     * @internal
+     */
+    static cloneComponent(source: Component, target: Component, cloneMap: Map<object, object>): void;
+}

package/types/enums/CameraType.d.ts

@@ -1 +1,9 @@
-export {};
+/**
+ * @internal
+ */
+export declare enum CameraType {
+    Normal = 0,
+    XRCenterCamera = 1,
+    XRLeftCamera = 2,
+    XRRightCamera = 4
+}

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

@@ -9,6 +9,8 @@ export declare class CubeProbe extends Probe {
      * The position of the probe can be set, the default is the origin [0,0,0].
      */
     position: Vector3;
+    /** @internal */
+    protected readonly _isCube: boolean;
     private oriViewMatrix;
     private _oriFieldOfView;
     onBeginRender(camera: Camera): void;

package/types/graphic/Buffer.d.ts

@@ -1,5 +1,7 @@
 import { GraphicsResource } from "../asset/GraphicsResource";
 import { Engine } from "../Engine";
+import { IPlatformBuffer } from "../renderingHardwareInterface";
+import { UpdateFlagManager } from "../UpdateFlagManager";
 import { BufferBindFlag } from "./enums/BufferBindFlag";
 import { BufferUsage } from "./enums/BufferUsage";
 import { SetDataOptions } from "./enums/SetDataOptions";
@@ -7,6 +9,10 @@ import { SetDataOptions } from "./enums/SetDataOptions";
  * Buffer.
  */
 export declare class Buffer extends GraphicsResource {
+    /** @internal */
+    _dataUpdateManager: UpdateFlagManager;
+    /** @internal */
+    _platformBuffer: IPlatformBuffer;
     private _type;
     private _byteLength;
     private _bufferUsage;
@@ -118,4 +124,8 @@ export declare class Buffer extends GraphicsResource {
      */
     markAsUnreadable(): void;
     _rebuild(): void;
+    /**
+     * @internal
+     */
+    protected _onDestroy(): void;
 }

package/types/graphic/BufferUtil.d.ts

@@ -1,5 +1,6 @@
 import { DataType } from "../base/Constant";
 import { IndexFormat } from "./enums/IndexFormat";
+import { VertexElementFormat } from "./enums/VertexElementFormat";
 export interface ElementInfo {
     size: number;
     type: DataType;
@@ -9,4 +10,8 @@ export interface ElementInfo {
 export declare class BufferUtil {
     static _getGLIndexType(indexFormat: IndexFormat): DataType;
     static _getGLIndexByteCount(indexFormat: IndexFormat): number;
+    /**
+     * @internal
+     */
+    static _getElementInfo(format: VertexElementFormat): ElementInfo;
 }

package/types/graphic/IndexBufferBinding.d.ts

@@ -4,6 +4,10 @@ import { Buffer } from "./Buffer";
  * Index buffer binding.
  */
 export declare class IndexBufferBinding {
+    /** @internal */
+    _buffer: Buffer;
+    /** @internal */
+    _format: IndexFormat;
     /**
      * Index buffer.
      */

package/types/graphic/Mesh.d.ts

@@ -1,14 +1,23 @@
 import { BoundingBox } from "@galacean/engine-math";
 import { Engine } from "../Engine";
+import { UpdateFlagManager } from "../UpdateFlagManager";
 import { ReferResource } from "../asset/ReferResource";
+import { IndexBufferBinding } from "../graphic/IndexBufferBinding";
 import { SubMesh } from "../graphic/SubMesh";
+import { VertexBufferBinding } from "../graphic/VertexBufferBinding";
+import { VertexElement } from "../graphic/VertexElement";
 import { MeshTopology } from "../graphic/enums/MeshTopology";
+import { Primitive } from "./Primitive";
 /**
  * Mesh.
  */
 export declare abstract class Mesh extends ReferResource {
     /** Name. */
     name: string;
+    /** @internal */
+    _primitive: Primitive;
+    /** @internal */
+    _updateFlagManager: UpdateFlagManager;
     private _bounds;
     private _subMeshes;
     /**
@@ -53,6 +62,51 @@ export declare abstract class Mesh extends ReferResource {
      * Clear all sub-mesh.
      */
     clearSubMesh(): void;
+    /**
+     * @internal
+     */
+    _clearVertexElements(): void;
+    /**
+     * @internal
+     */
+    _addVertexElement(element: VertexElement): void;
+    /**
+     * @internal
+     */
+    _removeVertexElement(index: number): void;
+    /**
+     * @internal
+     * @remarks should use together with `_setVertexElementsLength`
+     */
+    _setVertexElement(index: number, element: VertexElement): void;
+    /**
+     * @internal
+     *
+     */
+    _setVertexElementsLength(length: number): void;
+    /**
+     * @internal
+     */
+    _setVertexBufferBinding(index: number, binding: VertexBufferBinding): void;
     _addReferCount(value: number): void;
+    /**
+     * @internal
+     */
+    protected _onDestroy(): void;
+    /**
+     * @internal
+     */
+    protected _setVertexElements(elements: VertexElement[]): void;
+    /**
+     * @internal
+     */
+    protected _setIndexBufferBinding(binding: IndexBufferBinding | null): void;
     private _onBoundsChanged;
 }
+/**
+ * @internal
+ */
+export declare enum MeshModifyFlags {
+    Bounds = 1,
+    VertexElements = 2
+}

package/types/graphic/Primitive.d.ts

@@ -1 +1,50 @@
-export {};
+import { Engine } from "../Engine";
+import { GraphicsResource } from "../asset/GraphicsResource";
+import { ShaderProgram } from "../shader/ShaderProgram";
+import { IndexBufferBinding } from "./IndexBufferBinding";
+import { SubPrimitive } from "./SubPrimitive";
+import { VertexBufferBinding } from "./VertexBufferBinding";
+import { VertexElement } from "./VertexElement";
+/**
+ * @internal
+ * Primitive.
+ */
+export declare class Primitive extends GraphicsResource {
+    enableVAO: boolean;
+    instanceCount: number;
+    vertexBufferBindings: VertexBufferBinding[];
+    /** @internal */
+    _vertexElementMap: Record<string, VertexElement>;
+    /** @internal */
+    _glIndexType: number;
+    /** @internal */
+    _glIndexByteCount: number;
+    /** @internal */
+    _bufferStructChanged: boolean;
+    private _vertexElements;
+    private _indexBufferBinding;
+    private _platformPrimitive;
+    get vertexElements(): VertexElement[];
+    get indexBufferBinding(): IndexBufferBinding;
+    constructor(engine: Engine);
+    addVertexElement(element: VertexElement): void;
+    removeVertexElement(index: number): void;
+    clearVertexElements(): void;
+    /**
+     * @remarks should use together with `setVertexElementsLength`
+     */
+    setVertexElement(index: number, element: VertexElement): void;
+    setVertexElementsLength(length: number): void;
+    setVertexBufferBinding(index: number, binding: VertexBufferBinding): void;
+    /**
+     * Set vertex buffer binding.
+     * @param vertexBufferBindings - Vertex buffer binding
+     * @param firstIndex - First vertex buffer index, the default value is 0
+     */
+    setVertexBufferBindings(vertexBufferBindings: VertexBufferBinding[], firstIndex?: number): void;
+    setIndexBufferBinding(binding: IndexBufferBinding | null): void;
+    draw(shaderProgram: ShaderProgram, subMesh: SubPrimitive): void;
+    _addReferCount(value: number): void;
+    _rebuild(): void;
+    protected _onDestroy(): void;
+}

package/types/graphic/TransformFeedback.d.ts

@@ -1 +1,46 @@
-export {};
+import { GraphicsResource } from "../asset/GraphicsResource";
+import { Engine } from "../Engine";
+import { IPlatformTransformFeedback } from "../renderingHardwareInterface";
+import { Buffer } from "./Buffer";
+import { MeshTopology } from "./enums/MeshTopology";
+/**
+ * Transform Feedback object for GPU-based data capture.
+ * @internal
+ */
+export declare class TransformFeedback extends GraphicsResource {
+    /** @internal */
+    _platformTransformFeedback: IPlatformTransformFeedback;
+    constructor(engine: Engine);
+    /**
+     * Bind this Transform Feedback object as active.
+     */
+    bind(): void;
+    /**
+     * Bind a buffer range as output at the given index.
+     * @param index - Output binding point index (corresponds to varying index in shader)
+     * @param buffer - Output buffer to capture data into
+     * @param byteOffset - Starting byte offset in the buffer
+     * @param byteSize - Size in bytes of the capture range
+     */
+    bindBufferRange(index: number, buffer: Buffer, byteOffset: number, byteSize: number): void;
+    /**
+     * Begin a Transform Feedback pass.
+     * @param primitiveMode - Primitive topology mode
+     */
+    begin(primitiveMode: MeshTopology): void;
+    /**
+     * End the current Transform Feedback pass.
+     */
+    end(): void;
+    /**
+     * Unbind the output buffer at the given index from the Transform Feedback target.
+     * @param index - Output binding point index
+     */
+    unbindBuffer(index: number): void;
+    /**
+     * Unbind this Transform Feedback object.
+     */
+    unbind(): void;
+    _rebuild(): void;
+    protected _onDestroy(): void;
+}