@galacean/engine-core 0.0.0-experimental-animator-additive.1

package/types/2d/text/TextRenderer.d.ts

@@ -0,0 +1,123 @@
+import { BoundingBox, Color } from "@galacean/engine-math";
+import { ICustomClone } from "../../clone/ComponentCloner";
+import { Entity } from "../../Entity";
+import { Renderer } from "../../Renderer";
+import { RenderContext } from "../../RenderPipeline/RenderContext";
+import { TransformModifyFlags } from "../../Transform";
+import { FontStyle } from "../enums/FontStyle";
+import { SpriteMaskInteraction } from "../enums/SpriteMaskInteraction";
+import { TextHorizontalAlignment, TextVerticalAlignment } from "../enums/TextAlignment";
+import { OverflowMode } from "../enums/TextOverflow";
+import { Font } from "./Font";
+/**
+ * Renders a text for 2D graphics.
+ */
+export declare class TextRenderer extends Renderer implements ICustomClone {
+    private static _charRenderDataPool;
+    private static _tempVec30;
+    private static _tempVec31;
+    _dirtyFlag: number;
+    private _color;
+    private _text;
+    private _width;
+    private _height;
+    private _localBounds;
+    private _font;
+    private _fontSize;
+    private _fontStyle;
+    private _lineSpacing;
+    private _horizontalAlignment;
+    private _verticalAlignment;
+    private _enableWrapping;
+    private _overflowMode;
+    private _maskInteraction;
+    private _maskLayer;
+    /**
+     * Rendering color for the Text.
+     */
+    get color(): Color;
+    set color(value: Color);
+    /**
+     * Rendering string for the Text.
+     */
+    get text(): string;
+    set text(value: string);
+    /**
+     * The width of the TextRenderer (in 3D world coordinates).
+     */
+    get width(): number;
+    set width(value: number);
+    /**
+     * The height of the TextRenderer (in 3D world coordinates).
+     */
+    get height(): number;
+    set height(value: number);
+    /**
+     * The font of the Text.
+     */
+    get font(): Font;
+    set font(value: Font);
+    /**
+     * The font size of the Text.
+     */
+    get fontSize(): number;
+    set fontSize(value: number);
+    /**
+     * The style of the font.
+     */
+    get fontStyle(): FontStyle;
+    set fontStyle(value: FontStyle);
+    /**
+     * The space between two lines (in pixels).
+     */
+    get lineSpacing(): number;
+    set lineSpacing(value: number);
+    /**
+     * The horizontal alignment.
+     */
+    get horizontalAlignment(): TextHorizontalAlignment;
+    set horizontalAlignment(value: TextHorizontalAlignment);
+    /**
+     * The vertical alignment.
+     */
+    get verticalAlignment(): TextVerticalAlignment;
+    set verticalAlignment(value: TextVerticalAlignment);
+    /**
+     * Whether wrap text to next line when exceeds the width of the container.
+     */
+    get enableWrapping(): boolean;
+    set enableWrapping(value: boolean);
+    /**
+     * The overflow mode.
+     */
+    get overflowMode(): OverflowMode;
+    set overflowMode(value: OverflowMode);
+    /**
+     * Interacts with the masks.
+     */
+    get maskInteraction(): SpriteMaskInteraction;
+    set maskInteraction(value: SpriteMaskInteraction);
+    /**
+     * The mask layer the sprite renderer belongs to.
+     */
+    get maskLayer(): number;
+    set maskLayer(value: number);
+    /**
+     * The bounding volume of the TextRenderer.
+     */
+    get bounds(): BoundingBox;
+    constructor(entity: Entity);
+    /**
+     * @override
+     */
+    protected _updateBounds(worldBounds: BoundingBox): void;
+    /**
+     * @override
+     */
+    protected _render(context: RenderContext): void;
+    private _updateStencilState;
+    private _resetSubFont;
+    private _updatePosition;
+    private _updateLocalData;
+    protected _onTransformChanged(bit: TransformModifyFlags): void;
+}

package/types/2d/text/TextUtils.d.ts

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

package/types/2d/text/index.d.ts

@@ -0,0 +1,2 @@
+export { Font } from "./Font";
+export { TextRenderer } from "./TextRenderer";

package/types/Background.d.ts

@@ -0,0 +1,43 @@
+import { Color } from "@galacean/engine-math";
+import { Engine } from "./Engine";
+import { BackgroundMode } from "./enums/BackgroundMode";
+import { BackgroundTextureFillMode } from "./enums/BackgroundTextureFillMode";
+import { Sky } from "./sky/Sky";
+import { Texture2D } from "./texture";
+/**
+ * Background of scene.
+ */
+export declare class Background {
+    private _engine;
+    /**
+     * Background mode.
+     * @defaultValue `BackgroundMode.SolidColor`
+     * @remarks If using `BackgroundMode.Sky` mode and material or mesh of the `sky` is not defined, it will downgrade to `BackgroundMode.SolidColor`.
+     */
+    mode: BackgroundMode;
+    /**
+     * Background solid color.
+     * @defaultValue `new Color(0.25, 0.25, 0.25, 1.0)`
+     * @remarks When `mode` is `BackgroundMode.SolidColor`, the property will take effects.
+     */
+    solidColor: Color;
+    /**
+     * Background sky.
+     * @remarks When `mode` is `BackgroundMode.Sky`, the property will take effects.
+     */
+    readonly sky: Sky;
+    private _texture;
+    /**
+     * Background texture.
+     * @remarks When `mode` is `BackgroundMode.Texture`, the property will take effects.
+     */
+    get texture(): Texture2D;
+    set texture(value: Texture2D);
+    set textureFillMode(value: BackgroundTextureFillMode);
+    /**
+     * Constructor of Background.
+     * @param _engine Engine Which the background belongs to.
+     */
+    constructor(_engine: Engine);
+    private _createPlane;
+}

package/types/BoolUpdateFlag.d.ts

@@ -0,0 +1,12 @@
+import { UpdateFlag } from "./UpdateFlag";
+/**
+ * Bool update flag.
+ */
+export declare class BoolUpdateFlag extends UpdateFlag {
+    /** Bool flag. */
+    flag: boolean;
+    /**
+     * @inheritdoc
+     */
+    dispatch(): void;
+}

package/types/Camera.d.ts

@@ -0,0 +1,206 @@
+import { Matrix, Ray, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
+import { Component } from "./Component";
+import { CameraClearFlags } from "./enums/CameraClearFlags";
+import { Layer } from "./Layer";
+import { ShaderData } from "./shader/ShaderData";
+import { TextureCubeFace } from "./texture/enums/TextureCubeFace";
+import { RenderTarget } from "./texture/RenderTarget";
+/**
+ * Camera component, as the entrance to the three-dimensional world.
+ * @decorator `@dependentComponents(Transform)`
+ */
+export declare class Camera extends Component {
+    /** Shader data. */
+    readonly shaderData: ShaderData;
+    /** Rendering priority - A Camera with higher priority will be rendered on top of a camera with lower priority. */
+    priority: number;
+    /** Whether to enable frustum culling, it is enabled by default. */
+    enableFrustumCulling: boolean;
+    /**
+     * Determining what to clear when rendering by a Camera.
+     * @defaultValue `CameraClearFlags.All`
+     */
+    clearFlags: CameraClearFlags;
+    /**
+     * Culling mask - which layers the camera renders.
+     * @remarks Support bit manipulation, corresponding to `Layer`.
+     */
+    cullingMask: Layer;
+    private _isProjMatSetting;
+    private _nearClipPlane;
+    private _farClipPlane;
+    private _fieldOfView;
+    private _orthographicSize;
+    private _isProjectionDirty;
+    private _isInvProjMatDirty;
+    private _isFrustumProjectDirty;
+    private _customAspectRatio;
+    private _renderTarget;
+    private _frustumViewChangeFlag;
+    private _transform;
+    private _isViewMatrixDirty;
+    private _isInvViewProjDirty;
+    private _viewport;
+    private _inverseProjectionMatrix;
+    private _lastAspectSize;
+    private _invViewProjMat;
+    /**
+     * Near clip plane - the closest point to the camera when rendering occurs.
+     */
+    get nearClipPlane(): number;
+    set nearClipPlane(value: number);
+    /**
+     * Far clip plane - the furthest point to the camera when rendering occurs.
+     */
+    get farClipPlane(): number;
+    set farClipPlane(value: number);
+    /**
+     * The camera's view angle. activating when camera use perspective projection.
+     */
+    get fieldOfView(): number;
+    set fieldOfView(value: number);
+    /**
+     * Aspect ratio. The default is automatically calculated by the viewport's aspect ratio. If it is manually set,
+     * the manual value will be kept. Call resetAspectRatio() to restore it.
+     */
+    get aspectRatio(): number;
+    set aspectRatio(value: number);
+    /**
+     * Viewport, normalized expression, the upper left corner is (0, 0), and the lower right corner is (1, 1).
+     * @remarks Re-assignment is required after modification to ensure that the modification takes effect.
+     */
+    get viewport(): Vector4;
+    set viewport(value: Vector4);
+    /**
+     * Whether it is orthogonal, the default is false. True will use orthographic projection, false will use perspective projection.
+     */
+    get isOrthographic(): boolean;
+    set isOrthographic(value: boolean);
+    /**
+     * Half the size of the camera in orthographic mode.
+     */
+    get orthographicSize(): number;
+    set orthographicSize(value: number);
+    /**
+     * View matrix.
+     */
+    get viewMatrix(): Readonly<Matrix>;
+    /**
+     * The projection matrix is ​​calculated by the relevant parameters of the camera by default.
+     * If it is manually set, the manual value will be maintained. Call resetProjectionMatrix() to restore it.
+     */
+    set projectionMatrix(value: Matrix);
+    get projectionMatrix(): Matrix;
+    /**
+     * Whether to enable HDR.
+     * @todo When render pipeline modification
+     */
+    get enableHDR(): boolean;
+    set enableHDR(value: boolean);
+    /**
+     * RenderTarget. After setting, it will be rendered to the renderTarget. If it is empty, it will be rendered to the main canvas.
+     */
+    get renderTarget(): RenderTarget | null;
+    set renderTarget(value: RenderTarget | null);
+    /**
+     * Restore the automatic calculation of projection matrix through fieldOfView, nearClipPlane and farClipPlane.
+     */
+    resetProjectionMatrix(): void;
+    /**
+     * Restore the automatic calculation of the aspect ratio through the viewport aspect ratio.
+     */
+    resetAspectRatio(): void;
+    /**
+     * Transform a point from world space to viewport space.
+     * @param point - Point in world space
+     * @param out - Point in viewport space, X and Y are the camera viewport space coordinates, Z is in world space units from the plane that camera forward is normal to
+     * @returns Point in viewport space
+     */
+    worldToViewportPoint(point: Vector3, out: Vector3): Vector3;
+    /**
+     * Transform a point from viewport space to world space.
+     * @param point - Point in viewport space, X and Y are the camera viewport space coordinates, Z is in world space units from the plane that camera forward is normal to
+     * @param out - Point in world space
+     * @returns Point in world space
+     */
+    viewportToWorldPoint(point: Vector3, out: Vector3): Vector3;
+    /**
+     * Generate a ray by a point in viewport.
+     * @param point - Point in viewport space, X and Y are the camera viewport space coordinates
+     * @param out - Ray
+     * @returns Ray
+     */
+    viewportPointToRay(point: Vector2, out: Ray): Ray;
+    /**
+     * Transform the X and Y coordinates of a point from screen space to viewport space
+     * @param point - Point in screen space
+     * @param out - Point in viewport space
+     * @returns Point in viewport space
+     */
+    screenToViewportPoint<T extends Vector2 | Vector3>(point: Vector3 | Vector2, out: T): T;
+    /**
+     * Transform the X and Y coordinates of a point from viewport space to screen space.
+     * @param point - Point in viewport space
+     * @param out - Point in screen space
+     * @returns Point in screen space
+     */
+    viewportToScreenPoint<T extends Vector2 | Vector3 | Vector4>(point: T, out: T): T;
+    /**
+     * Transform a point from world space to screen space.
+     *
+     * @remarks
+     * Screen space is defined in pixels, the left-top of the screen is (0,0), the right-top is (canvasPixelWidth,canvasPixelHeight).
+     *
+     * @param point - Point in world space
+     * @param out - The result will be stored
+     * @returns X and Y are the coordinates of the point in screen space, Z is the distance from the camera in world space
+     */
+    worldToScreenPoint(point: Vector3, out: Vector3): Vector3;
+    /**
+     * Transform a point from screen space to world space.
+     *
+     * @param point - Screen space point, the top-left of the screen is (0,0), the right-bottom is (pixelWidth,pixelHeight), The z position is in world units from the camera
+     * @param out - Point in world space
+     * @returns Point in world space
+     */
+    screenToWorldPoint(point: Vector3, out: Vector3): Vector3;
+    /**
+     * Generate a ray by a point in screen.
+     * @param point - Point in screen space, the top-left of the screen is (0,0), the right-bottom is (pixelWidth,pixelHeight)
+     * @param out - Ray
+     * @returns Ray
+     */
+    screenPointToRay(point: Vector2, out: Ray): Ray;
+    /**
+     * Manually call the rendering of the camera.
+     * @param cubeFace - Cube rendering surface collection
+     * @param mipLevel - Set mip level the data want to write, only take effect in webgl2.0
+     */
+    render(cubeFace?: TextureCubeFace, mipLevel?: number): void;
+    /**
+     * @override
+     * @inheritdoc
+     */
+    _onEnable(): void;
+    /**
+     * @override
+     * @inheritdoc
+     */
+    _onDisable(): void;
+    /**
+     * @override
+     * @inheritdoc
+     */
+    _onDestroy(): void;
+    private _projMatChange;
+    private _innerViewportToWorldPoint;
+    private _updateShaderData;
+    /**
+     * The inverse matrix of view projection matrix.
+     */
+    private _getInvViewProjMat;
+    /**
+     * The inverse of the projection matrix.
+     */
+    private _getInverseProjectionMatrix;
+}

package/types/Canvas.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Canvas.
+ */
+export interface Canvas {
+    /** The width of the canvas. */
+    width: number;
+    /** The height of the canvas. */
+    height: number;
+}

package/types/Component.d.ts

@@ -0,0 +1,32 @@
+import { EngineObject } from "./base";
+import { Entity } from "./Entity";
+import { Scene } from "./Scene";
+/**
+ * The base class of the components.
+ */
+export declare class Component extends EngineObject {
+    private _phasedActive;
+    private _enabled;
+    /**
+     * Indicates whether the component is enabled.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * Indicates whether the component is destroyed.
+     */
+    get destroyed(): boolean;
+    /**
+     * The entity which the component belongs to.
+     */
+    get entity(): Entity;
+    /**
+     * The scene which the component's entity belongs to.
+     */
+    get scene(): Scene;
+    constructor(entity: Entity);
+    /**
+     * Destroy this instance.
+     */
+    destroy(): void;
+}

package/types/ComponentsDependencies.d.ts

@@ -0,0 +1,17 @@
+import { Component } from "./Component";
+import { Entity } from "./Entity";
+type ComponentConstructor = new (entity: Entity) => Component;
+/**
+ * Used for component dependency registration.
+ */
+export declare class ComponentsDependencies {
+    private static _invDependenciesMap;
+    private static _addDependency;
+    private constructor();
+}
+/**
+ * Dependent components, automatically added if they do not exist.
+ * @param components -  Dependent components
+ */
+export declare function dependentComponents(...components: ComponentConstructor[]): <T extends ComponentConstructor>(target: T) => void;
+export {};

package/types/ComponentsManager.d.ts

@@ -0,0 +1,46 @@
+import { Camera } from "./Camera";
+import { Component } from "./Component";
+import { Renderer } from "./Renderer";
+import { Script } from "./Script";
+/**
+ * The manager of the components.
+ */
+export declare class ComponentsManager {
+    private _onStartScripts;
+    private _onUpdateScripts;
+    private _onLateUpdateScripts;
+    private _onPhysicsUpdateScripts;
+    private _disableScripts;
+    private _pendingDestroyScripts;
+    private _disposeDestroyScripts;
+    private _onUpdateAnimations;
+    private _onUpdateRenderers;
+    private _componentsContainerPool;
+    addRenderer(renderer: Renderer): void;
+    removeRenderer(renderer: Renderer): void;
+    addOnStartScript(script: Script): void;
+    removeOnStartScript(script: Script): void;
+    addOnUpdateScript(script: Script): void;
+    removeOnUpdateScript(script: Script): void;
+    addOnLateUpdateScript(script: Script): void;
+    removeOnLateUpdateScript(script: Script): void;
+    addOnPhysicsUpdateScript(script: Script): void;
+    removeOnPhysicsUpdateScript(script: Script): void;
+    addOnUpdateAnimations(animation: Component): void;
+    removeOnUpdateAnimations(animation: Component): void;
+    addOnUpdateRenderers(renderer: Renderer): void;
+    removeOnUpdateRenderers(renderer: Renderer): void;
+    addDisableScript(component: Script): void;
+    addPendingDestroyScript(component: Script): void;
+    callScriptOnStart(): void;
+    callScriptOnUpdate(deltaTime: number): void;
+    callScriptOnLateUpdate(deltaTime: number): void;
+    callScriptOnPhysicsUpdate(): void;
+    callAnimationUpdate(deltaTime: number): void;
+    callRendererOnUpdate(deltaTime: number): void;
+    handlingInvalidScripts(): void;
+    callCameraOnBeginRender(camera: Camera): void;
+    callCameraOnEndRender(camera: Camera): void;
+    getActiveChangedTempList(): Component[];
+    putActiveChangedTempList(componentContainer: Component[]): void;
+}

package/types/DisorderedArray.d.ts

@@ -0,0 +1,18 @@
+/**
+ * High-performance unordered array, delete uses exchange method to improve performance, internal capacity only increases.
+ */
+export declare class DisorderedArray<T> {
+    _elements: T[];
+    length: number;
+    constructor(count?: number);
+    add(element: T): void;
+    delete(element: T): void;
+    get(index: number): T;
+    /**
+     *
+     * @param index
+     * @returns The replaced item is used to reset its index.
+     */
+    deleteByIndex(index: number): T;
+    garbageCollection(): void;
+}

package/types/Engine.d.ts

@@ -0,0 +1,140 @@
+import { Font } from "./2d/text/Font";
+import { ResourceManager } from "./asset/ResourceManager";
+import { EventDispatcher, Time } from "./base";
+import { Canvas } from "./Canvas";
+import { ComponentsManager } from "./ComponentsManager";
+import { EngineSettings } from "./EngineSettings";
+import { Entity } from "./Entity";
+import { InputManager } from "./input";
+import { LightManager } from "./lighting/LightManager";
+import { Material } from "./material/Material";
+import { PhysicsManager } from "./physics";
+import { IHardwareRenderer } from "./renderingHardwareInterface";
+import { ClassPool } from "./RenderPipeline/ClassPool";
+import { MeshRenderElement } from "./RenderPipeline/MeshRenderElement";
+import { RenderContext } from "./RenderPipeline/RenderContext";
+import { SpriteElement } from "./RenderPipeline/SpriteElement";
+import { SpriteMaskElement } from "./RenderPipeline/SpriteMaskElement";
+import { TextRenderElement } from "./RenderPipeline/TextRenderElement";
+import { Scene } from "./Scene";
+import { SceneManager } from "./SceneManager";
+import { RenderState } from "./shader/state/RenderState";
+/**
+ * Engine.
+ */
+export declare class Engine extends EventDispatcher {
+    /** Physics manager of Engine. */
+    readonly physicsManager: PhysicsManager;
+    readonly inputManager: InputManager;
+    _lightManager: LightManager;
+    _componentsManager: ComponentsManager;
+    _hardwareRenderer: IHardwareRenderer;
+    _lastRenderState: RenderState;
+    _renderElementPool: ClassPool<MeshRenderElement>;
+    _spriteElementPool: ClassPool<SpriteElement>;
+    _spriteMaskElementPool: ClassPool<SpriteMaskElement>;
+    _textElementPool: ClassPool<TextRenderElement>;
+    _spriteDefaultMaterial: Material;
+    _spriteMaskDefaultMaterial: Material;
+    _textDefaultFont: Font;
+    _renderContext: RenderContext;
+    protected _canvas: Canvas;
+    private _settings;
+    private _resourceManager;
+    private _sceneManager;
+    private _vSyncCount;
+    private _targetFrameRate;
+    private _time;
+    private _isPaused;
+    private _requestId;
+    private _timeoutId;
+    private _vSyncCounter;
+    private _targetFrameInterval;
+    private _destroyed;
+    private _frameInProcess;
+    private _waittingDestroy;
+    private _animate;
+    /**
+     * Settings of Engine.
+     */
+    get settings(): EngineSettings;
+    /**
+     * The canvas to use for rendering.
+     */
+    get canvas(): Canvas;
+    /**
+     * Get the resource manager.
+     */
+    get resourceManager(): ResourceManager;
+    /**
+     * Get the scene manager.
+     */
+    get sceneManager(): SceneManager;
+    /**
+     * Get the Time class.
+     */
+    get time(): Time;
+    /**
+     * Whether the engine is paused.
+     */
+    get isPaused(): boolean;
+    /**
+     * The number of vertical synchronization means the number of vertical blanking for one frame.
+     * @remarks 0 means that the vertical synchronization is turned off.
+     */
+    get vSyncCount(): number;
+    set vSyncCount(value: number);
+    /**
+     * Set the target frame rate you want to achieve.
+     * @remarks
+     * It only takes effect when vSyncCount = 0 (ie, vertical synchronization is turned off).
+     * The larger the value, the higher the target frame rate, Number.POSITIVE_INFINITY represents the infinite target frame rate.
+     */
+    get targetFrameRate(): number;
+    set targetFrameRate(value: number);
+    /**
+     * Indicates whether the engine is destroyed.
+     */
+    get destroyed(): boolean;
+    /**
+     * Create engine.
+     * @param canvas - The canvas to use for rendering
+     * @param hardwareRenderer - Graphics API renderer
+     * @param settings - Engine Settings
+     */
+    constructor(canvas: Canvas, hardwareRenderer: IHardwareRenderer, settings?: EngineSettings);
+    /**
+     * Create an entity.
+     * @param name - The name of the entity
+     * @returns Entity
+     */
+    createEntity(name?: string): Entity;
+    /**
+     * Pause the engine.
+     */
+    pause(): void;
+    /**
+     * Resume the engine.
+     */
+    resume(): void;
+    /**
+     * Update the engine loop manually. If you call engine.run(), you generally don't need to call this function.
+     */
+    update(): void;
+    /**
+     * Execution engine loop.
+     */
+    run(): void;
+    private _destroy;
+    /**
+     * Destroy engine.
+     * @remarks If call during frame execution will delay until the end of the frame
+     */
+    destroy(): void;
+    /**
+     * @intenral
+     */
+    _render(scene: Scene): void;
+    private _createSpriteMaterial;
+    private _createSpriteMaskMaterial;
+}

package/types/EngineSettings.d.ts

@@ -0,0 +1,8 @@
+import { ColorSpace } from "./enums/ColorSpace";
+/**
+ * Render settings.
+ */
+export interface EngineSettings {
+    /** Color space.*/
+    colorSpace?: ColorSpace;
+}