@galacean/engine-core 2.0.0-alpha.43 → 2.0.0-alpha.45

package/types/Camera.d.ts

@@ -1,15 +1,23 @@
-import { Matrix, Ray, Rect, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
+import { BoundingFrustum, Matrix, Ray, Rect, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
 import { Component } from "./Component";
+import { Entity } from "./Entity";
 import { Layer } from "./Layer";
+import { BasicRenderPipeline } from "./RenderPipeline/BasicRenderPipeline";
+import { VirtualCamera } from "./VirtualCamera";
 import { AntiAliasing } from "./enums/AntiAliasing";
 import { CameraClearFlags } from "./enums/CameraClearFlags";
+import { CameraModifyFlags } from "./enums/CameraModifyFlags";
+import { CameraType } from "./enums/CameraType";
 import { DepthTextureMode } from "./enums/DepthTextureMode";
 import { Downsampling } from "./enums/Downsampling";
 import { MSAASamples } from "./enums/MSAASamples";
 import { ReplacementFailureStrategy } from "./enums/ReplacementFailureStrategy";
 import { Shader } from "./shader/Shader";
 import { ShaderData } from "./shader/ShaderData";
+import { ShaderMacroCollection } from "./shader/ShaderMacroCollection";
+import { ShaderProperty } from "./shader/ShaderProperty";
 import { ShaderTagKey } from "./shader/ShaderTagKey";
+import { TextureFormat } from "./texture";
 import { RenderTarget } from "./texture/RenderTarget";
 import { TextureCubeFace } from "./texture/enums/TextureCubeFace";
 /**
@@ -17,6 +25,12 @@ import { TextureCubeFace } from "./texture/enums/TextureCubeFace";
  * @decorator `@dependentComponents(Transform, DependentMode.CheckOnly)`
  */
 export declare class Camera extends Component {
+    /** @internal */
+    static _cameraDepthTextureProperty: ShaderProperty;
+    /** @internal */
+    static _cameraOpaqueTextureProperty: ShaderProperty;
+    /** @internal */
+    static _cameraAOTextureProperty: ShaderProperty;
     private static _inverseViewMatrixProperty;
     private static _cameraPositionProperty;
     private static _cameraForwardProperty;
@@ -70,6 +84,24 @@ export declare class Camera extends Component {
      * @defaultValue `false`
      */
     isAlphaOutputRequired: boolean;
+    /** @internal */
+    _cameraType: CameraType;
+    /** @internal */
+    _globalShaderMacro: ShaderMacroCollection;
+    /** @internal */
+    _frustum: BoundingFrustum;
+    /** @internal */
+    _renderPipeline: BasicRenderPipeline;
+    /** @internal */
+    _virtualCamera: VirtualCamera;
+    /** @internal */
+    _replacementShader: Shader;
+    /** @internal */
+    _replacementSubShaderTag: ShaderTagKey;
+    /** @internal */
+    _replacementFailureStrategy: ReplacementFailureStrategy;
+    /** @internal */
+    _cameraIndex: number;
     private _priority;
     private _isCustomViewMatrix;
     private _isCustomProjectionMatrix;
@@ -189,6 +221,10 @@ export declare class Camera extends Component {
      */
     get msaaSamples(): MSAASamples;
     set msaaSamples(value: MSAASamples);
+    /**
+     * @internal
+     */
+    constructor(entity: Entity);
     /**
      * Restore the view matrix to the world matrix of the entity.
      */
@@ -302,6 +338,40 @@ export declare class Camera extends Component {
      * @inheritdoc
      */
     _onDisableInScene(): void;
+    /**
+     * @internal
+     * Whether independent canvas is enabled.
+     */
+    _isIndependentCanvasEnabled(): boolean;
+    /**
+     * @internal
+     */
+    _getInternalColorTextureFormat(): TextureFormat;
+    /**
+     * @internal
+     */
+    _needFinalPass(): boolean;
+    /**
+     * @internal
+     */
+    _getTargetColorTextureFormat(): TextureFormat;
+    /**
+     * @internal
+     */
+    _isTargetFormatHDR(): boolean;
+    /**
+     * @internal
+     */
+    _registerModifyListener(onChange: (flag: CameraModifyFlags) => void): void;
+    /**
+     * @internal
+     */
+    _unRegisterModifyListener(onChange: (flag: CameraModifyFlags) => void): void;
+    /**
+     * @internal
+     * @inheritdoc
+     */
+    protected _onDestroy(): void;
     private _updatePixelViewport;
     private _adjustPixelViewport;
     private _viewMatrixChange;

package/types/Canvas.d.ts

@@ -1,7 +1,12 @@
+import { UpdateFlagManager } from "./UpdateFlagManager";
 /**
  * The canvas the engine renders to; owns the render-buffer resolution.
  */
 export declare abstract class Canvas {
+    /**
+     * @internal
+     */
+    _sizeUpdateFlagManager: UpdateFlagManager;
     private _width;
     private _height;
     /**
@@ -30,6 +35,14 @@ export declare abstract class Canvas {
      */
     abstract setAutoResolution(scale?: number): void;
     protected _setResolution(width: number, height: number): void;
+    /**
+     * @internal
+     */
+    _pumpPendingResolution(): void;
+    /**
+     * @internal
+     */
+    abstract _destroy(): void;
     protected _exitAutoResolution(): void;
     protected abstract _onResolutionChanged(width: number, height: number): void;
 }

package/types/Component.d.ts

@@ -1,11 +1,16 @@
 import { IReferable } from "./asset/IReferable";
 import { EngineObject } from "./base";
 import { Entity } from "./Entity";
+import { ActiveChangeFlag } from "./enums/ActiveChangeFlag";
 import { Scene } from "./Scene";
 /**
  * The base class of the components.
  */
 export declare class Component extends EngineObject {
+    /** @internal */
+    _entity: Entity;
+    /** @internal */
+    _awoken: boolean;
     protected _phasedActiveInScene: boolean;
     private _phasedActive;
     private _enabled;
@@ -23,5 +28,33 @@ export declare class Component extends EngineObject {
      */
     get scene(): Scene;
     constructor(entity: Entity);
+    /**
+     * @internal
+     */
+    _onAwake(): void;
+    /**
+     * @internal
+     */
+    _onEnable(): void;
+    /**
+     * @internal
+     */
+    _onDisable(): void;
+    /**
+     * @internal
+     */
+    _onEnableInScene(): void;
+    /**
+     * @internal
+     */
+    _onDisableInScene(): void;
+    /**
+     * @internal
+     */
+    _setActive(value: boolean, activeChangeFlag: ActiveChangeFlag): void;
     protected _addResourceReferCount(resource: IReferable, count: number): void;
+    /**
+     * @internal
+     */
+    protected _onDestroy(): void;
 }

package/types/ComponentsDependencies.d.ts

@@ -1,4 +1,29 @@
-import { ComponentConstructor } from "./Entity";
+import { ComponentConstructor, Entity } from "./Entity";
+/**
+ * @internal
+ * Used for component dependency registration.
+ */
+export declare class ComponentsDependencies {
+    private static _invDependenciesMap;
+    static _dependenciesMap: Map<ComponentConstructor, DependentInfo>;
+    /**
+     * @internal
+     */
+    static _addCheck(entity: Entity, type: ComponentConstructor): void;
+    /**
+     * @internal
+     */
+    static _removeCheck(entity: Entity, type: ComponentConstructor): void;
+    /**
+     * @internal
+     */
+    static _addDependency(targetInfo: DependentInfo, dependentComponent: ComponentConstructor, map: Map<DependentInfo, ComponentConstructor[]>): void;
+    /**
+     * @internal
+     */
+    static _addInvDependency(currentComponent: ComponentConstructor, dependentComponent: ComponentConstructor): void;
+    private constructor();
+}
 /**
  * Declare dependent component.
  * @param component - Dependent component
@@ -20,3 +45,11 @@ export declare enum DependentMode {
     /** Auto add if dependent components do not exist. */
     AutoAdd = 1
 }
+/**
+ * @internal
+ */
+interface DependentInfo {
+    mode: DependentMode;
+    components: ComponentConstructor[];
+}
+export {};

package/types/ComponentsManager.d.ts

@@ -4,10 +4,23 @@ import { Renderer } from "./Renderer";
 import { Script } from "./Script";
 import { Animator } from "./animation";
 import { IUICanvas } from "./ui/IUICanvas";
+import { DisorderedArray } from "./utils/DisorderedArray";
 /**
  * The manager of the components.
  */
 export declare class ComponentsManager {
+    /** @internal */
+    _cameraNeedSorting: boolean;
+    /** @internal */
+    _activeCameras: DisorderedArray<Camera>;
+    /** @internal */
+    _renderers: DisorderedArray<Renderer>;
+    /** @internal */
+    _overlayCanvases: DisorderedArray<IUICanvas>;
+    /** @internal */
+    _overlayCanvasesSortingDirty: boolean;
+    /** @internal */
+    _canvases: DisorderedArray<IUICanvas>;
     private _onStartScripts;
     private _onUpdateScripts;
     private _onLateUpdateScripts;
@@ -45,4 +58,8 @@ export declare class ComponentsManager {
     callCameraOnEndRender(camera: Camera): void;
     getActiveChangedTempList(): Component[];
     putActiveChangedTempList(componentContainer: Component[]): void;
+    /**
+     * @internal
+     */
+    _gc(): void;
 }

package/types/Engine.d.ts

@@ -1,24 +1,100 @@
-import { IHardwareRenderer, IInputOptions, IPhysics, IShaderCompiler, IXRDevice } from "@galacean/engine-design";
+import { IHardwareRenderer, IInputOptions, IPhysics, IPhysicsManager, IShaderCompiler, IXRDevice } from "@galacean/engine-design";
+import { CharRenderInfo } from "./2d/text/CharRenderInfo";
+import { Font } from "./2d/text/Font";
+import { BasicResources } from "./BasicResources";
 import { Canvas } from "./Canvas";
 import { EngineSettings } from "./EngineSettings";
 import { Entity } from "./Entity";
+import { BatcherManager } from "./RenderPipeline/BatcherManager";
+import { RenderContext } from "./RenderPipeline/RenderContext";
+import { RenderTargetPool } from "./RenderPipeline/RenderTargetPool";
+import { RenderElement } from "./RenderPipeline/RenderElement";
+import { Scene } from "./Scene";
 import { SceneManager } from "./SceneManager";
 import { RenderingStatistics } from "./asset/RenderingStatistics";
 import { ResourceManager } from "./asset/ResourceManager";
-import { EventDispatcher, Time } from "./base";
+import { EngineObject, EventDispatcher, Time } from "./base";
 import { InputManager } from "./input";
 import { ParticleBufferUtils } from "./particle/ParticleBufferUtils";
+import { ColliderShape } from "./physics/shape/ColliderShape";
 import { PostProcessPass } from "./postProcess/PostProcessPass";
+import { ShaderMacro } from "./shader/ShaderMacro";
+import { ShaderMacroCollection } from "./shader/ShaderMacroCollection";
+import { ShaderProgramMap } from "./shader/ShaderProgramMap";
+import { RenderState } from "./shader/state/RenderState";
+import { Texture2D } from "./texture";
+import { ClearableObjectPool } from "./utils/ClearableObjectPool";
+import { ReturnableObjectPool } from "./utils/ReturnableObjectPool";
 import { XRManager } from "./xr/XRManager";
 /**
  * Engine.
  */
 export declare class Engine extends EventDispatcher {
+    /** @internal */
+    static _noDepthTextureMacro: ShaderMacro;
+    /** @internal */
+    static _noSRGBSupportMacro: ShaderMacro;
+    /** @internal */
+    static _outputSRGBCorrectMacro: ShaderMacro;
+    /** @internal Conversion of space units to pixel units for 2D. */
+    static _pixelsPerUnit: number;
+    /** @internal */
+    static _physicalObjectsMap: Record<number, ColliderShape>;
+    /** @internal */
+    static _nativePhysics: IPhysics;
     /** Input manager of Engine. */
     readonly inputManager: InputManager;
     /** XR manager of Engine. */
     readonly xrManager: XRManager;
+    /** @internal */
+    _renderingStatistics: RenderingStatistics;
+    /** @internal */
+    _isDeviceLost: boolean;
+    /** @internal */
+    _batcherManager: BatcherManager;
     _particleBufferUtils: ParticleBufferUtils;
+    /** @internal */
+    _frameInProcess: boolean;
+    /** @internal */
+    _pendingDestroyObjects: EngineObject[];
+    /** @internal */
+    _processingPendingDestroys: boolean;
+    /** @internal */
+    _physicsInitialized: boolean;
+    /** @internal */
+    _nativePhysicsManager: IPhysicsManager;
+    /** @internal */
+    _hardwareRenderer: IHardwareRenderer;
+    /** @internal */
+    _renderTargetPool: RenderTargetPool;
+    /** @internal */
+    _lastRenderState: RenderState;
+    /** @internal */
+    _renderElementPool: ClearableObjectPool<RenderElement>;
+    /** @internal */
+    _textRenderElementPool: ClearableObjectPool<RenderElement>;
+    /** @internal */
+    _charRenderInfoPool: ReturnableObjectPool<CharRenderInfo>;
+    /** @internal */
+    _basicResources: BasicResources;
+    /** @internal */
+    _textDefaultFont: Font;
+    /** @internal */
+    _renderContext: RenderContext;
+    /** @internal */
+    _depthTexture2D: Texture2D;
+    /** @internal */
+    _renderCount: number;
+    /** @internal */
+    _shaderProgramMaps: ShaderProgramMap[];
+    /** @internal */
+    _fontMap: Record<string, Font>;
+    /** @internal */
+    _macroCollection: ShaderMacroCollection;
+    /** @internal */
+    _postProcessPassNeedRefresh: boolean;
+    /** @internal */
+    protected _canvas: Canvas;
     private _settings;
     private _resourceManager;
     private _sceneManager;
@@ -125,6 +201,18 @@ export declare class Engine extends EventDispatcher {
      * @param pass - Post process pass to add
      */
     addPostProcessPass(pass: PostProcessPass): void;
+    /**
+     * @internal
+     */
+    _removePostProcessPass(pass: PostProcessPass): void;
+    /**
+     * @internal
+     */
+    _refreshActivePostProcessPasses(): void;
+    /**
+     * @internal
+     */
+    _getActivePostProcessPasses(): ReadonlyArray<PostProcessPass>;
     private _processPendingDestroyObjects;
     private _destroy;
     /**
@@ -132,6 +220,22 @@ export declare class Engine extends EventDispatcher {
      * @remarks If call during frame execution will delay until the end of the frame
      */
     destroy(): void;
+    /**
+     * @internal
+     */
+    _getShaderProgramMap(index: number, trackMaps?: ShaderProgramMap[]): ShaderProgramMap;
+    /**
+     * @internal
+     */
+    _render(scenes: ReadonlyArray<Scene>): void;
+    /**
+     * @internal
+     */
+    _pendingGC(): void;
+    /**
+     * @internal
+     */
+    protected _initialize(configuration: EngineConfiguration): Promise<Engine>;
     private _onDeviceLost;
     private _onDeviceRestored;
     private _gc;

package/types/Entity.d.ts

@@ -4,16 +4,64 @@ import { Component } from "./Component";
 import { Engine } from "./Engine";
 import { Layer } from "./Layer";
 import { Scene } from "./Scene";
+import { Script } from "./Script";
 import { Transform } from "./Transform";
+import { UpdateFlagManager } from "./UpdateFlagManager";
+import { ReferResource } from "./asset/ReferResource";
 import { EngineObject } from "./base";
+import { ActiveChangeFlag } from "./enums/ActiveChangeFlag";
+import { EntityModifyFlags } from "./enums/EntityModifyFlags";
+import { DisorderedArray } from "./utils/DisorderedArray";
 /**
  * Entity, be used as components container.
  */
 export declare class Entity extends EngineObject {
+    /** @internal */
+    static _tempComponentConstructors: ComponentConstructor[];
+    /**
+     * @internal
+     */
+    static _findChildByName(entity: Entity, childIndex: number, paths: string[], pathIndex: number): Entity;
+    /**
+     * @internal
+     */
+    static _traverseSetOwnerScene(entity: Entity, scene: Scene): void;
+    /**
+     * @internal
+     */
+    static _removeFromChildren(children: Entity[], entity: Entity): void;
+    /**
+     * @internal
+     */
+    static _addToChildren(children: Entity[], entity: Entity, index?: number): void;
     /** The name of entity. */
     name: string;
     /** The layer the entity belongs to. */
     layer: Layer;
+    /** @internal */
+    _isActiveInHierarchy: boolean;
+    /** @internal */
+    _isActiveInScene: boolean;
+    /** @internal */
+    _components: Component[];
+    /** @internal */
+    _scripts: DisorderedArray<Script>;
+    /** @internal */
+    _scriptsVersion: number;
+    /** @internal */
+    _children: Entity[];
+    /** @internal */
+    _scene: Scene;
+    /** @internal */
+    _isRoot: boolean;
+    /** @internal */
+    _isActive: boolean;
+    /** @internal */
+    _siblingIndex: number;
+    /** @internal */
+    _isTemplate: boolean;
+    /** @internal */
+    _updateFlagManager: UpdateFlagManager;
     private _transform;
     private _templateResource;
     private _parent;
@@ -145,12 +193,52 @@ export declare class Entity extends EngineObject {
      * @returns Change flag
      */
     registerWorldChangeFlag(): BoolUpdateFlag;
+    /**
+     * @internal
+     */
+    _markAsTemplate(templateResource: ReferResource): void;
     private _createCloneEntity;
     private _parseCloneEntity;
     /**
      * Destroy self.
      */
     destroy(): void;
+    /**
+     * @internal
+     */
+    _removeComponent(component: Component): void;
+    /**
+     * @internal
+     */
+    _addScript(script: Script): void;
+    /**
+     * @internal
+     */
+    _removeScript(script: Script): void;
+    /**
+     * @internal
+     */
+    _removeFromParent(): void;
+    /**
+     * @internal
+     */
+    _processActive(activeChangeFlag: ActiveChangeFlag): void;
+    /**
+     * @internal
+     */
+    _processInActive(activeChangeFlag: ActiveChangeFlag): void;
+    /**
+     * @internal
+     */
+    _setParentChange(): void;
+    /**
+     * @internal
+     */
+    _registerModifyListener(onChange: (flag: EntityModifyFlags) => void): void;
+    /**
+     * @internal
+     */
+    _unRegisterModifyListener(onChange: (flag: EntityModifyFlags) => void): void;
     private _dispatchModify;
     private _addToChildrenList;
     private _setParent;

package/types/Polyfill.d.ts

@@ -1 +1,12 @@
-export {};
+/**
+ * @internal
+ */
+export declare class Polyfill {
+    static registerPolyfill(): void;
+    private static _registerMatchAll;
+    private static _registerAudioContext;
+    private static _registerOfflineAudioContext;
+    private static _promisifyDecodeAudioData;
+    private static _registerTextMetrics;
+    private static _registerPromiseFinally;
+}

package/types/RenderPipeline/BasicRenderPipeline.d.ts

@@ -1,12 +1,15 @@
 import { Camera } from "../Camera";
 import { CameraClearFlags } from "../enums/CameraClearFlags";
 import { TextureCubeFace } from "../texture";
+import { CullingResults } from "./CullingResults";
 import { RenderContext } from "./RenderContext";
 import { RenderElement } from "./RenderElement";
 /**
  * Basic render pipeline.
  */
 export declare class BasicRenderPipeline {
+    /** @internal */
+    _cullingResults: CullingResults;
     private _camera;
     private _lastCanvasSize;
     private _internalColorTarget;

package/types/RenderPipeline/BatcherManager.d.ts

@@ -1 +1,23 @@
-export {};
+import { Engine } from "../Engine";
+import { InstanceBuffer } from "./InstanceBuffer";
+import { PrimitiveChunkManager } from "./PrimitiveChunkManager";
+import { RenderElement } from "./RenderElement";
+/**
+ * @internal
+ */
+export declare class BatcherManager {
+    engine: Engine;
+    private _primitiveChunkManager2D;
+    private _primitiveChunkManagerMask;
+    private _primitiveChunkManagerUI;
+    private _instanceBuffer;
+    constructor(engine: Engine);
+    get instanceBuffer(): InstanceBuffer;
+    get primitiveChunkManager2D(): PrimitiveChunkManager;
+    get primitiveChunkManagerMask(): PrimitiveChunkManager;
+    get primitiveChunkManagerUI(): PrimitiveChunkManager;
+    destroy(): void;
+    batch(input: RenderElement[], output: RenderElement[]): void;
+    private static _flush;
+    uploadBuffer(): void;
+}

package/types/RenderPipeline/CullingResults.d.ts

@@ -1 +1,17 @@
-export {};
+import { BatcherManager } from "./BatcherManager";
+import { ContextRendererUpdateFlag } from "./RenderContext";
+import { RenderQueue } from "./RenderQueue";
+/**
+ * @internal
+ * Culling results.
+ */
+export declare class CullingResults {
+    readonly opaqueQueue: RenderQueue;
+    readonly transparentQueue: RenderQueue;
+    readonly alphaTestQueue: RenderQueue;
+    constructor();
+    reset(): void;
+    sortBatch(batcherManager: BatcherManager): void;
+    setRenderUpdateFlagTrue(rendererUpdateFlag: ContextRendererUpdateFlag): void;
+    destroy(): void;
+}

package/types/RenderPipeline/DepthOnlyPass.d.ts

@@ -1 +1,18 @@
-export {};
+import { Camera } from "../Camera";
+import { Engine } from "../Engine";
+import { PipelinePass } from "../RenderPipeline/PipelinePass";
+import { RenderTarget } from "../texture/RenderTarget";
+import { CullingResults } from "./CullingResults";
+import { RenderContext } from "./RenderContext";
+/**
+ * @internal
+ * Depth only pass.
+ */
+export declare class DepthOnlyPass extends PipelinePass {
+    readonly supportDepthTexture: boolean;
+    renderTarget: RenderTarget;
+    constructor(engine: Engine);
+    onConfig(camera: Camera): void;
+    onRender(context: RenderContext, cullingResults: CullingResults): void;
+    release(): void;
+}

package/types/RenderPipeline/InstanceBuffer.d.ts

@@ -1 +1,28 @@
-export {};
+import { Engine } from "../Engine";
+import { Buffer } from "../graphic/Buffer";
+import { Renderer } from "../Renderer";
+import { ShaderMacro } from "../shader/ShaderMacro";
+import { InstanceBufferLayout } from "../shader/ShaderFactory";
+/**
+ * @internal
+ * Manages a UBO for GPU instancing, packing per-instance renderer data (ModelMat, Layer, etc.).
+ */
+export declare class InstanceBuffer {
+    static gpuInstanceMacro: ShaderMacro;
+    buffer: Buffer;
+    private _engine;
+    private _layout;
+    private _data;
+    private _floatView;
+    private _intView;
+    constructor(engine: Engine);
+    /**
+     * Set UBO layout and allocate buffer if needed.
+     */
+    setLayout(layout: InstanceBufferLayout): void;
+    /**
+     * Pack renderer data into UBO and upload to GPU.
+     */
+    upload(renderers: Renderer[], start: number, count: number): void;
+    destroy(): void;
+}