@galacean/engine-core 1.2.0-beta.6 → 1.2.0-beta.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-core",
-  "version": "1.2.0-beta.6",
+  "version": "1.2.0-beta.7",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
@@ -15,10 +15,10 @@
     "types/**/*"
   ],
   "dependencies": {
-    "@galacean/engine-math": "1.2.0-beta.6"
+    "@galacean/engine-math": "1.2.0-beta.7"
   },
   "devDependencies": {
-    "@galacean/engine-design": "1.2.0-beta.6"
+    "@galacean/engine-design": "1.2.0-beta.7"
   },
   "scripts": {
     "b:types": "tsc"

package/types/Camera.d.ts

@@ -5,6 +5,7 @@ import { CameraClearFlags } from "./enums/CameraClearFlags";
 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 { ShaderTagKey } from "./shader/ShaderTagKey";
@@ -245,22 +246,24 @@ export declare class Camera extends Component {
      * Set the replacement shader.
      * @param shader - Replacement shader
      * @param replacementTagName - Sub shader tag name
+     * @param failureStrategy - Replacement failure strategy, @defaultValue `ReplacementFailureStrategy.KeepOriginalShader`
      *
      * @remarks
      * If replacementTagName is not specified, the first sub shader will be replaced.
-     * If replacementTagName is specified, the replacement shader will find the first sub shader which has the same tag value get by replacementTagKey.
+     * If replacementTagName is specified, the replacement shader will find the first sub shader which has the same tag value get by replacementTagKey. If failed to find the sub shader, the strategy will be determined by failureStrategy.
      */
-    setReplacementShader(shader: Shader, replacementTagName?: string): any;
+    setReplacementShader(shader: Shader, replacementTagName?: string, failureStrategy?: ReplacementFailureStrategy): any;
     /**
      * Set the replacement shader.
      * @param shader - Replacement shader
      * @param replacementTag - Sub shader tag
+     * @param failureStrategy - Replacement failure strategy, @defaultValue `ReplacementFailureStrategy.KeepOriginalShader`
      *
      * @remarks
      * If replacementTag is not specified, the first sub shader will be replaced.
-     * If replacementTag is specified, the replacement shader will find the first sub shader which has the same tag value get by replacementTagKey.
+     * If replacementTag is specified, the replacement shader will find the first sub shader which has the same tag value get by replacementTagKey. If failed to find the sub shader, the strategy will be determined by failureStrategy.
      */
-    setReplacementShader(shader: Shader, replacementTag?: ShaderTagKey): any;
+    setReplacementShader(shader: Shader, replacementTag?: ShaderTagKey, failureStrategy?: ReplacementFailureStrategy): any;
     /**
      * Reset and clear the replacement shader.
      */

package/types/Entity.d.ts

@@ -58,9 +58,10 @@ export declare class Entity extends EngineObject {
     /**
      * Add component based on the component type.
      * @param type - The type of the component
+     * @param args - The arguments of the component
      * @returns	The component which has been added
      */
-    addComponent<T extends Component>(type: new (entity: Entity) => T): T;
+    addComponent<T extends new (entity: Entity, ...args: any[]) => Component>(type: T, ...args: ComponentArguments<T>): InstanceType<T>;
     /**
      * Get component which match the type.
      * @param type - The type of the component
@@ -152,3 +153,5 @@ export declare class Entity extends EngineObject {
      */
     getInvModelMatrix(): Matrix;
 }
+type ComponentArguments<T extends new (entity: Entity, ...args: any[]) => Component> = T extends new (entity: Entity, ...args: infer P) => Component ? P : never;
+export {};

package/types/RenderPipeline/BatchUtils.d.ts

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

package/types/RenderPipeline/BatcherManager.d.ts

@@ -1,12 +1 @@
-import { Engine } from "../Engine";
-import { RenderContext } from "./RenderContext";
-import { RenderData } from "./RenderData";
-import { RenderElement } from "./RenderElement";
-export declare class BatcherManager {
-    constructor(engine: Engine);
-    destroy(): void;
-    commitRenderData(context: RenderContext, data: RenderData): void;
-    batch(elements: Array<RenderElement>, batchedElements: Array<RenderElement>): void;
-    uploadBuffer(): void;
-    clear(): void;
-}
+export {};

package/types/RenderPipeline/MaskManager.d.ts

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

package/types/RenderPipeline/PrimitiveChunk.d.ts

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

package/types/RenderPipeline/PrimitiveChunkManager.d.ts

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

package/types/RenderPipeline/SubPrimitiveChunk.d.ts

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

package/types/RenderPipeline/SubRenderElement.d.ts

@@ -0,0 +1,22 @@
+import { Renderer } from "../Renderer";
+import { Primitive, SubMesh } from "../graphic";
+import { Material } from "../material";
+import { ShaderData, ShaderPass } from "../shader";
+import { Texture2D } from "../texture";
+import { IPoolElement } from "../utils/ObjectPool";
+import { RenderQueueFlags } from "./BasicRenderPipeline";
+import { SubPrimitiveChunk } from "./SubPrimitiveChunk";
+export declare class SubRenderElement implements IPoolElement {
+    component: Renderer;
+    primitive: Primitive;
+    material: Material;
+    subPrimitive: SubMesh;
+    shaderPasses: ReadonlyArray<ShaderPass>;
+    shaderData?: ShaderData;
+    batched: boolean;
+    renderQueueFlags: RenderQueueFlags;
+    texture?: Texture2D;
+    subChunk?: SubPrimitiveChunk;
+    set(component: Renderer, material: Material, primitive: Primitive, subPrimitive: SubMesh, texture?: Texture2D, subChunk?: SubPrimitiveChunk): void;
+    dispose(): void;
+}

package/types/RenderPipeline/VertexArea.d.ts

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

package/types/animation/AnimatorCondition.d.ts

@@ -0,0 +1,13 @@
+import { AnimatorControllerParameterValueType } from "./AnimatorControllerParameter";
+import { AnimatorConditionMode } from "./enums/AnimatorConditionMode";
+/**
+ * Condition that is used to determine if a transition must be taken.
+ */
+export declare class AnimatorCondition {
+    /** The mode of the condition. */
+    mode: AnimatorConditionMode;
+    /** The name of the parameter used in the condition. */
+    parameterName: string;
+    /** The AnimatorParameter's threshold value for the condition to be true. */
+    threshold?: AnimatorControllerParameterValueType;
+}

package/types/animation/AnimatorControllerParameter.d.ts

@@ -0,0 +1,10 @@
+export type AnimatorControllerParameterValueType = number | string | boolean;
+/**
+ * Used to communicate between scripting and the controller, parameters can be set in scripting and used by the controller.
+ */
+export declare class AnimatorControllerParameter {
+    /** The name of the parameter. */
+    name: string;
+    /** The value of the parameter. */
+    value: AnimatorControllerParameterValueType;
+}

package/types/animation/AnimatorStateTransition.d.ts

@@ -0,0 +1,51 @@
+import { AnimatorControllerParameterValueType } from "./AnimatorControllerParameter";
+import { AnimatorConditionMode } from "./enums/AnimatorConditionMode";
+import { AnimatorCondition } from "./AnimatorCondition";
+import { AnimatorState } from "./AnimatorState";
+/**
+ * Transitions define when and how the state machine switch from on state to another. AnimatorTransition always originate from a StateMachine or a StateMachine entry.
+ */
+export declare class AnimatorStateTransition {
+    /** The duration of the transition. This is represented in normalized time. */
+    duration: number;
+    /** The time at which the destination state will start. This is represented in normalized time. */
+    offset: number;
+    /** ExitTime represents the exact time at which the transition can take effect. This is represented in normalized time. */
+    exitTime: number;
+    /** The destination state of the transition. */
+    destinationState: AnimatorState;
+    /** Mutes the transition. The transition will never occur. */
+    mute: boolean;
+    private _conditions;
+    private _solo;
+    /**
+     * Is the transition destination the exit of the current state machine.
+     */
+    get isExit(): Readonly<boolean>;
+    /**
+     * Mutes all other transitions in the source state.
+     */
+    get solo(): boolean;
+    set solo(value: boolean);
+    /**
+     * The conditions in the transition.
+     */
+    get conditions(): Readonly<AnimatorCondition[]>;
+    /**
+     * Add a condition to a transition.
+     * @param mode - The AnimatorCondition mode of the condition
+     * @param parameterName - The name of the parameter
+     * @param threshold - The threshold value of the condition
+     */
+    addCondition(mode: AnimatorConditionMode, parameterName: string, threshold?: AnimatorControllerParameterValueType): AnimatorCondition;
+    /**
+     * Add a condition to a transition.
+     * @param animatorCondition - The condition to add
+     */
+    addCondition(animatorCondition: AnimatorCondition): AnimatorCondition;
+    /**
+     * Remove a condition from the transition.
+     * @param condition - The condition to remove
+     */
+    removeCondition(condition: AnimatorCondition): void;
+}

package/types/asset/ResourceManager.d.ts

@@ -102,11 +102,13 @@ export declare class ResourceManager {
     addContentRestorer<T extends EngineObject>(restorer: ContentRestorer<T>): void;
     private _assignDefaultOptions;
     private _loadSingleItem;
-    private _pushSubAssetPromiseCallback;
+    private _loadMainAsset;
+    private _createSubAssetPromiseCallback;
     private _gc;
     private _getResolveResource;
     private _parseURL;
     private _parseQueryPath;
+    private _releaseSubAssetPromiseCallback;
 }
 /**
  * Declare ResourceLoader's decorator.

package/types/enums/ReplacementFailureStrategy.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The strategy to use when a shader replacement fails.
+ */
+export declare enum ReplacementFailureStrategy {
+    /** Keep the original shader. */
+    KeepOriginalShader = 0,
+    /** Do not render. */
+    DoNotRender = 1
+}

package/types/index.d.ts

@@ -31,6 +31,7 @@ export { FogMode } from "./enums/FogMode";
 export { CameraClearFlags } from "./enums/CameraClearFlags";
 export { CameraType } from "./enums/CameraType";
 export { MSAASamples } from "./enums/MSAASamples";
+export { ReplacementFailureStrategy } from "./enums/ReplacementFailureStrategy";
 export { Downsampling } from "./enums/Downsampling";
 export { ColorSpace } from "./enums/ColorSpace";
 export { BackgroundTextureFillMode } from "./enums/BackgroundTextureFillMode";

package/types/postProcess/PostProcessManager.d.ts

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

package/types/postProcess/effects/BloomEffect.d.ts

@@ -0,0 +1,94 @@
+import { Color } from "@galacean/engine-math";
+import { RenderContext } from "../../RenderPipeline/RenderContext";
+import { Material } from "../../material";
+import { Texture2D } from "../../texture";
+/**
+ * This controls the size of the bloom texture.
+ */
+export declare enum BloomDownScaleMode {
+    /**
+     *  Use this to select half size as the starting resolution.
+     */
+    Half = 0,
+    /**
+     *  Use this to select quarter size as the starting resolution.
+     */
+    Quarter = 1
+}
+export declare class BloomEffect {
+    private _uberMaterial;
+    static readonly SHADER_NAME = "PostProcessEffect Bloom";
+    private static _hqMacro;
+    private static _dirtMacro;
+    private static _bloomParams;
+    private static _lowMipTextureProp;
+    private static _lowMipTexelSizeProp;
+    private static _enableMacro;
+    private static _bloomTextureProp;
+    private static _dirtTextureProp;
+    private static _tintProp;
+    private static _bloomIntensityParams;
+    private static _dirtTilingOffsetProp;
+    private _bloomMaterial;
+    private _threshold;
+    private _scatter;
+    private _highQualityFiltering;
+    private _mipDownRT;
+    private _mipUpRT;
+    private _maxIterations;
+    private _enabled;
+    /**
+     * Controls the starting resolution that this effect begins processing.
+     */
+    downScale: BloomDownScaleMode;
+    /**
+     * Indicates whether the post process effect is enabled.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * Set the level of brightness to filter out pixels under this level.
+     * @remarks This value is expressed in gamma-space.
+     */
+    get threshold(): number;
+    set threshold(value: number);
+    /**
+     * Controls the radius of the bloom effect.
+     */
+    get scatter(): number;
+    set scatter(value: number);
+    /**
+     * Controls the strength of the bloom effect.
+     */
+    get intensity(): number;
+    set intensity(value: number);
+    /**
+     * Specifies the tint of the bloom effect.
+     */
+    get tint(): Color;
+    set tint(value: Color);
+    /**
+     * Controls whether to use bicubic sampling instead of bilinear sampling for the upSampling passes.
+     * @remarks This is slightly more expensive but helps getting smoother visuals.
+     */
+    get highQualityFiltering(): boolean;
+    set highQualityFiltering(value: boolean);
+    /**
+     * Specifies a Texture to add smudges or dust to the bloom effect.
+     */
+    get dirtTexture(): Texture2D;
+    set dirtTexture(value: Texture2D);
+    /**
+     * Controls the strength of the lens dirt.
+     */
+    get dirtIntensity(): number;
+    set dirtIntensity(value: number);
+    constructor(_uberMaterial: Material);
+    onRender(context: RenderContext, srcTexture: Texture2D): void;
+    private _calculateMipCount;
+    private _prefilter;
+    private _downsample;
+    private _upsample;
+    private _setupUber;
+    private _releaseRenderTargets;
+}

package/types/postProcess/effects/TonemappingEffect.d.ts

@@ -0,0 +1,35 @@
+import { Material } from "../../material";
+/**
+ * Options to select a tonemapping algorithm to use.
+ */
+export declare enum TonemappingMode {
+    /**
+     * Neutral tonemapper
+     * @remarks Use this option if you only want range-remapping with minimal impact on color hue and saturation.
+     */
+    Neutral = 0,
+    /**
+     * ACES Filmic reference tonemapper (custom approximation)
+     * @remarks
+     * Use this option to apply a close approximation of the reference ACES tonemapper for a more filmic look.
+     * It is more contrasted than Neutral and has an effect on actual color hue and saturation.
+     */
+    ACES = 1
+}
+export declare class TonemappingEffect {
+    private _uberMaterial;
+    private static _enableMacro;
+    private _mode;
+    private _enabled;
+    /**
+     * Indicates whether the post process effect is enabled.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * Use this to select a tonemapping algorithm to use.
+     */
+    get mode(): TonemappingMode;
+    set mode(value: TonemappingMode);
+    constructor(_uberMaterial: Material);
+}

package/types/postProcess/effects/index.d.ts

@@ -0,0 +1,2 @@
+export { BloomDownScaleMode, BloomEffect } from "./BloomEffect";
+export { TonemappingEffect, TonemappingMode } from "./TonemappingEffect";

package/types/postProcess/index.d.ts

@@ -0,0 +1,3 @@
+import { _PostProcessManager } from "./PostProcessManager";
+export * from "./effects";
+export { _PostProcessManager };

package/types/ui/Image.d.ts

@@ -1,6 +1,5 @@
 import { Color } from "@galacean/engine-math";
 import { Sprite, SpriteDrawMode, SpriteTileMode } from "../2d";
-import { RenderElement } from "../RenderPipeline/RenderElement";
 import { UIRenderer } from "./UIRenderer";
 export declare class Image extends UIRenderer {
     private _color;
@@ -34,8 +33,6 @@ export declare class Image extends UIRenderer {
      */
     get color(): Color;
     set color(value: Color);
-    protected _canBatch(elementA: RenderElement, elementB: RenderElement): boolean;
-    protected _batchRenderElement(elementA: RenderElement, elementB?: RenderElement): void;
     protected _onDestroy(): void;
     private _onSpriteChange;
 }

package/types/ui/UICanvas.d.ts

@@ -17,7 +17,8 @@ export declare class UICanvas extends Component {
     private _referenceResolution;
     private _isRootCanvas;
     private _enableBlocked;
-    private _canvasHierarchyDirty;
+    private _parents;
+    private _hierarchyDirty;
     get enableBlocked(): boolean;
     set enableBlocked(value: boolean);
     get referenceResolution(): Vector2;
@@ -34,16 +35,21 @@ export declare class UICanvas extends Component {
     set distance(val: number);
     constructor(entity: Entity);
     _prepareRender(context: RenderContext): void;
-    private _onReferenceResolutionChanged;
-    private _onCameraTransformChange;
-    private _onCameraPropertyChange;
-    private _onCanvasSizeChange;
     private _adapterPoseInScreenSpace;
     private _adapterSizeInScreenSpace;
     private _walk;
     private _addCameraListener;
-    private _addCanvasListener;
     private _removeCameraListener;
+    private _onCameraPropertyListener;
+    private _onCameraTransformListener;
+    private _addCanvasListener;
     private _removeCanvasListener;
-    _onParentChange(seniority: number): void;
+    private _onCanvasSizeListener;
+    private _addParentListener;
+    private _removeParentListener;
+    private _onEntityListener;
+    private _onParentListener;
+    private _onReferenceResolutionChanged;
+    private _checkIsRootCanvas;
+    private _setIsRootCanvas;
 }

package/types/ui/UIRenderer.d.ts

@@ -1,20 +1,14 @@
 import { BoundingBox, Vector4 } from "@galacean/engine-math";
 import { Renderer } from "../Renderer";
-import { UICanvas } from "./UICanvas";
 import { UITransform, UITransformModifyFlags } from "./UITransform";
 export declare class UIRenderer extends Renderer {
-    private static _uiCanvas;
-    protected _canvas: UICanvas;
     protected _uiTransform: UITransform;
     protected _localBounds: BoundingBox;
     protected _rayCastTarget: boolean;
     protected _rayCastPadding: Vector4;
-    get canvas(): UICanvas;
-    set canvas(val: UICanvas);
     get rayCastTarget(): boolean;
     set rayCastTarget(value: boolean);
     get rayCastPadding(): Vector4;
     set rayCastPadding(value: Vector4);
-    _onParentChange(seniority: number): void;
     protected _onUITransformChanged(flag: UITransformModifyFlags): 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/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/index.d.ts

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