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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@galacean/engine-core",
-  "version": "1.2.0-beta.6",
+  "version": "1.2.0",
   "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"
   },
   "devDependencies": {
-    "@galacean/engine-design": "1.2.0-beta.6"
+    "@galacean/engine-design": "1.2.0"
   },
   "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/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/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/shader/enums/ShaderPlatformTarget.d.ts

@@ -0,0 +1,4 @@
+export declare enum ShaderPlatformTarget {
+    GLES100 = 0,
+    GLES300 = 1
+}

package/types/shader/enums/ShaderType.d.ts

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

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,4 @@
+export { ClearableObjectPool } from "./ClearableObjectPool";
+export type { IPoolElement } from "./ObjectPool";
+export { ReturnableObjectPool } from "./ReturnableObjectPool";
+export { SafeLoopArray } from "./SafeLoopArray";

package/types/RenderPipeline/RenderData2D.d.ts

@@ -1,14 +0,0 @@
-import { Primitive, SubMesh } from "../graphic";
-import { Material } from "../material/Material";
-import { Renderer } from "../Renderer";
-import { Texture2D } from "../texture";
-import { IPoolElement } from "../utils/Pool";
-import { Chunk } from "./DynamicGeometryData";
-import { RenderData } from "./RenderData";
-export declare class RenderData2D extends RenderData implements IPoolElement {
-    texture: Texture2D;
-    chunk: Chunk;
-    constructor();
-    set(component: Renderer, material: Material, primitive: Primitive, subPrimitive: SubMesh, texture?: Texture2D, chunk?: Chunk): void;
-    dispose(): void;
-}

package/types/RenderPipeline/RenderPass.d.ts

@@ -1,55 +0,0 @@
-import { Color } from "@galacean/engine-math";
-import { Camera } from "../Camera";
-import { CameraClearFlags } from "../enums/CameraClearFlags";
-import { Layer } from "../Layer";
-import { Material } from "../material/Material";
-import { RenderTarget } from "../texture/RenderTarget";
-import { RenderQueue } from "./RenderQueue";
-/**
- * RenderPass.
- */
-declare class RenderPass {
-    name: string;
-    enabled: boolean;
-    priority: number;
-    renderTarget: RenderTarget;
-    replaceMaterial: Material;
-    mask: Layer;
-    renderOverride: boolean;
-    clearFlags: CameraClearFlags | undefined;
-    clearColor: Color | undefined;
-    /**
-     * Create a RenderPass.
-     * @param name - Pass name
-     * @param priority - Priority, less than 0 before the default pass, greater than 0 after the default pass
-     * @param renderTarget - The specified Render Target
-     * @param replaceMaterial - Replaced material
-     * @param mask - Perform bit and operations with Entity.Layer to filter the objects that this Pass needs to render
-     */
-    constructor(name?: string, priority?: number, renderTarget?: any, replaceMaterial?: any, mask?: any);
-    /**
-     * Rendering callback, will be executed if renderOverride is set to true.
-     * @param camera - Camera
-     * @param opaqueQueue - Opaque queue
-     * @param alphaTestQueue - Alpha test queue
-     * @param transparentQueue - Transparent queue
-     */
-    render(camera: Camera, opaqueQueue: RenderQueue, alphaTestQueue: RenderQueue, transparentQueue: RenderQueue): void;
-    /**
-     * Post rendering callback.
-     * @param camera - Camera
-     * @param opaqueQueue - Opaque queue
-     * @param alphaTestQueue - Alpha test queue
-     * @param transparentQueue - Transparent queue
-     */
-    preRender(camera: Camera, opaqueQueue: RenderQueue, alphaTestQueue: RenderQueue, transparentQueue: RenderQueue): void;
-    /**
-     * Post rendering callback.
-     * @param camera - Camera
-     * @param opaqueQueue - Opaque queue
-     * @param alphaTestQueue - Alpha test queue
-     * @param transparentQueue - Transparent queue
-     */
-    postRender(camera: Camera, opaqueQueue: RenderQueue, alphaTestQueue: RenderQueue, transparentQueue: RenderQueue): void;
-}
-export { RenderPass };

package/types/RenderPipeline/enums/ForceUploadShaderDataFlag.d.ts

@@ -1,15 +0,0 @@
-/**
- * Force upload shader data flag.
- */
-export declare enum ForceUploadShaderDataFlag {
-    /** Upload nothing. */
-    None = 0,
-    /** Upload scene shader data. */
-    Scene = 1,
-    /** Upload camera shader data. */
-    Camera = 2,
-    /** Upload renderer shader data. */
-    Renderer = 4,
-    /** Upload material shader data. */
-    Material = 8
-}

package/types/RenderPipeline/enums/RenderDataUsage.d.ts

@@ -1,13 +0,0 @@
-/**
- * RenderData usage.
- */
-export declare enum RenderDataUsage {
-    /** Usage for mesh. */
-    Mesh = 0,
-    /** Usage for sprite. */
-    Sprite = 1,
-    /** Usage for sprite mask. */
-    SpriteMask = 2,
-    /** Usage for text. */
-    Text = 3
-}

package/types/input/pointer/PointerEvent.d.ts

@@ -1,4 +0,0 @@
-import { Pointer } from "./Pointer";
-export declare class PointerEvent {
-    pointer: Pointer;
-}

package/types/input/pointer/PointerEventType.d.ts

@@ -1,7 +0,0 @@
-export declare enum PointerEventType {
-    Down = 0,
-    Up = 1,
-    Click = 2,
-    Enter = 3,
-    Exit = 4
-}

package/types/renderingHardwareInterface/IHardwareRenderer.d.ts

@@ -1,6 +0,0 @@
-/**
- * Hardware graphics API renderer.
- */
-export interface IHardwareRenderer {
-    [key: string]: any;
-}

package/types/ui/Image.d.ts

@@ -1,41 +0,0 @@
-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;
-    private _sprite;
-    private _drawMode;
-    private _assembler;
-    private _tileMode;
-    private _tiledAdaptiveThreshold;
-    /**
-     * The draw mode of the sprite renderer.
-     */
-    get drawMode(): SpriteDrawMode;
-    set drawMode(value: SpriteDrawMode);
-    /**
-     * The tiling mode of the sprite renderer. (Only works in tiled mode.)
-     */
-    get tileMode(): SpriteTileMode;
-    set tileMode(value: SpriteTileMode);
-    /**
-     * Stretch Threshold in Tile Adaptive Mode, specified in normalized. (Only works in tiled adaptive mode.)
-     */
-    get tiledAdaptiveThreshold(): number;
-    set tiledAdaptiveThreshold(value: number);
-    /**
-     * The Sprite to render.
-     */
-    get sprite(): Sprite;
-    set sprite(value: Sprite | null);
-    /**
-     * Rendering color for the Sprite graphic.
-     */
-    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/RedBlackTree.d.ts

@@ -1,2 +0,0 @@
-export declare class RedBlackTree {
-}