@galacean/engine-core 1.2.0-beta.6 → 1.3.0-alpha.1

package/types/particle/modules/VelocityOverLifetimeModule.d.ts

@@ -3,6 +3,7 @@ import { ShaderProperty } from "../../shader/ShaderProperty";
 import { ParticleSimulationSpace } from "../enums/ParticleSimulationSpace";
 import { ParticleCompositeCurve } from "./ParticleCompositeCurve";
 import { ParticleGeneratorModule } from "./ParticleGeneratorModule";
+import { ParticleGenerator } from "../ParticleGenerator";
 /**
  * Velocity over lifetime module.
  */
@@ -20,15 +21,35 @@ export declare class VelocityOverLifetimeModule extends ParticleGeneratorModule
     static readonly _maxGradientYProperty: ShaderProperty;
     static readonly _maxGradientZProperty: ShaderProperty;
     static readonly _spaceProperty: ShaderProperty;
-    /** Velocity over lifetime for x axis. */
-    velocityX: ParticleCompositeCurve;
-    /** Velocity over lifetime for z axis. */
-    velocityY: ParticleCompositeCurve;
-    /** Velocity over lifetime for z axis. */
-    velocityZ: ParticleCompositeCurve;
-    /** Velocity space. */
-    space: ParticleSimulationSpace;
     private _velocityMinConstant;
     private _velocityMaxConstant;
     private _velocityMacro;
+    private _velocityX;
+    private _velocityY;
+    private _velocityZ;
+    private _space;
+    /**
+     * Velocity over lifetime for x axis.
+     */
+    get velocityX(): ParticleCompositeCurve;
+    set velocityX(value: ParticleCompositeCurve);
+    /**
+     * Velocity over lifetime for y axis.
+     */
+    get velocityY(): ParticleCompositeCurve;
+    set velocityY(value: ParticleCompositeCurve);
+    /**
+     * Velocity over lifetime for z axis.
+     */
+    get velocityZ(): ParticleCompositeCurve;
+    set velocityZ(value: ParticleCompositeCurve);
+    /**
+     * Velocity space.
+     */
+    get space(): ParticleSimulationSpace;
+    set space(value: ParticleSimulationSpace);
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    constructor(generator: ParticleGenerator);
+    private _onCompositeCurveChange;
 }

package/types/particle/modules/shape/BaseShape.d.ts

@@ -1,12 +1,22 @@
 import { ParticleShapeType } from "./enums/ParticleShapeType";
+import { UpdateFlagManager } from "../../../UpdateFlagManager";
 /**
  * Base class for all particle shapes.
  */
 export declare abstract class BaseShape {
     /** The type of shape to emit particles from. */
     abstract readonly shapeType: ParticleShapeType;
-    /** Specifies whether the ShapeModule is enabled or disabled. */
-    enabled: boolean;
-    /** Randomizes the starting direction of particles. */
-    randomDirectionAmount: number;
+    protected _updateManager: UpdateFlagManager;
+    private _enabled;
+    private _randomDirectionAmount;
+    /**
+     * Specifies whether the ShapeModule is enabled or disabled.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * Randomizes the starting direction of particles.
+     */
+    get randomDirectionAmount(): number;
+    set randomDirectionAmount(value: number);
 }

package/types/particle/modules/shape/BoxShape.d.ts

@@ -7,6 +7,11 @@ import { ParticleShapeType } from "./enums/ParticleShapeType";
 export declare class BoxShape extends BaseShape {
     private static _tempVector30;
     readonly shapeType = ParticleShapeType.Box;
-    /** The size of the box. */
-    size: Vector3;
+    private _size;
+    /**
+     * The size of the box.
+     */
+    get size(): Vector3;
+    set size(value: Vector3);
+    constructor();
 }

package/types/particle/modules/shape/CircleShape.d.ts

@@ -7,12 +7,29 @@ import { ParticleShapeType } from "./enums/ParticleShapeType";
 export declare class CircleShape extends BaseShape {
     private static _tempPositionPoint;
     readonly shapeType = ParticleShapeType.Circle;
-    /** Radius of the shape to emit particles from. */
-    radius: number;
-    /** Angle of the circle arc to emit particles from. */
-    arc: number;
-    /** The mode to generate particles around the arc. */
-    arcMode: ParticleShapeArcMode;
-    /** The speed of complete 360 degree rotation. */
-    arcSpeed: number;
+    private _radius;
+    private _arc;
+    private _arcMode;
+    private _arcSpeed;
+    /**
+     * Radius of the shape to emit particles from.
+     */
+    get radius(): number;
+    set radius(value: number);
+    /**
+     * Angle of the circle arc to emit particles from.
+     */
+    get arc(): number;
+    set arc(value: number);
+    /**
+     * The mode to generate particles around the arc.
+     */
+    get arcMode(): ParticleShapeArcMode;
+    set arcMode(value: ParticleShapeArcMode);
+    /**
+     * The speed of complete 360 degree rotation.
+     */
+    get arcSpeed(): number;
+    set arcSpeed(value: number);
+    private _getUnitArcRange;
 }

package/types/particle/modules/shape/ConeShape.d.ts

@@ -9,14 +9,30 @@ export declare class ConeShape extends BaseShape {
     private static _tempVector30;
     private static _tempVector31;
     readonly shapeType = ParticleShapeType.Cone;
-    /** Angle of the cone to emit particles from. */
-    angle: number;
-    /** Radius of the shape to emit particles from. */
-    radius: number;
-    /** Length of the cone to emit particles from. */
-    length: number;
-    /** Cone emitter type. */
-    emitType: ConeEmitType;
+    private _angle;
+    private _radius;
+    private _length;
+    private _emitType;
+    /**
+     * Angle of the cone to emit particles from.
+     */
+    get angle(): number;
+    set angle(value: number);
+    /**
+     * Radius of the shape to emit particles from.
+     */
+    get radius(): number;
+    set radius(value: number);
+    /**
+     * Length of the cone to emit particles from.
+     */
+    get length(): number;
+    set length(value: number);
+    /**
+     * Cone emitter type.
+     */
+    get emitType(): ConeEmitType;
+    set emitType(value: ConeEmitType);
 }
 /**
  * Cone emitter type.

package/types/particle/modules/shape/HemisphereShape.d.ts

@@ -5,6 +5,10 @@ import { ParticleShapeType } from "./enums/ParticleShapeType";
  */
 export declare class HemisphereShape extends BaseShape {
     readonly shapeType = ParticleShapeType.Hemisphere;
-    /** Radius of the shape to emit particles from. */
-    radius: number;
+    private _radius;
+    /**
+     * Radius of the shape to emit particles from.
+     */
+    get radius(): number;
+    set radius(value: number);
 }

package/types/particle/modules/shape/SphereShape.d.ts

@@ -5,6 +5,10 @@ import { ParticleShapeType } from "./enums/ParticleShapeType";
  */
 export declare class SphereShape extends BaseShape {
     readonly shapeType = ParticleShapeType.Sphere;
-    /** Radius of the shape to emit particles from. */
-    radius: number;
+    private _radius;
+    /**
+     * Radius of the shape to emit particles from.
+     */
+    get radius(): number;
+    set radius(value: number);
 }

package/types/postProcess/PostProcessEffect.d.ts

@@ -0,0 +1,13 @@
+import { RenderContext } from "../RenderPipeline/RenderContext";
+import { RenderTarget, Texture2D } from "../texture";
+export declare abstract class PostProcessEffect {
+    readonly engine: any;
+    private _enabled;
+    /**
+     * Indicates whether the post process effect is enabled.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    constructor(engine: any);
+    abstract onRender(context: RenderContext, srcTexture: Texture2D, destRenderTarget: RenderTarget): void;
+}

package/types/postProcess/PostProcessManager.d.ts

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

package/types/postProcess/PostProcessPass.d.ts

@@ -0,0 +1,55 @@
+import { Engine } from "../Engine";
+import { PipelinePass } from "../RenderPipeline/PipelinePass";
+import { RenderContext } from "../RenderPipeline/RenderContext";
+import { PostProcessEffect } from "./PostProcessEffect";
+export declare class PostProcessPass extends PipelinePass {
+    private _isActive;
+    private _effects;
+    /** The name of pass. */
+    name: string;
+    /**
+     * Whether to activate current post process.
+     */
+    get isActive(): boolean;
+    set isActive(value: boolean);
+    /**
+     * Get the post process effect list.
+     */
+    get effects(): ReadonlyArray<PostProcessEffect>;
+    /**
+     * Create a post process pass.
+     * @param engine - The engine the pass belongs to
+     * @param name - The pass name if need
+     */
+    constructor(engine: Engine, name?: string);
+    onRender(context: RenderContext): void;
+    /**
+     * Get post process effect which match the type.
+     * @param type - The type of the post process effect
+     * @returns The first post process effect which match type
+     */
+    getEffect(type: typeof PostProcessEffect): PostProcessEffect | null;
+    /**
+     * Get post process effects which match the type.
+     * @param type - The type of the post process effect
+     * @param results - The effects which match type
+     * @returns The effects which match type
+     */
+    getEffects(type: typeof PostProcessEffect, results: PostProcessEffect[]): PostProcessEffect[];
+    /**
+     * Add post process effect.
+     * @param effect - The post process effect want to be added
+     */
+    addEffect(effect: PostProcessEffect): void;
+    /**
+     * Add post process at specified index.
+     * @param indexOrEffect - Specified index
+     * @param effect - The post process effect want to be added
+     */
+    addEffect(index: number, effect: PostProcessEffect): void;
+    /**
+     * Remove post process effect.
+     * @param effect - The post process effect want to be removed
+     */
+    removeEffect(effect: PostProcessEffect): void;
+}

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/ShaderDataGroup.d.ts

@@ -8,6 +8,8 @@ export declare enum ShaderDataGroup {
     Camera = 1,
     /** Renderer group. */
     Renderer = 2,
-    /** material group. */
-    Material = 3
+    /** Material group. */
+    Material = 3,
+    /** Render element group. */
+    RenderElement = 4
 }

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/shader/state/RenderState.d.ts

@@ -17,4 +17,5 @@ export declare class RenderState {
     readonly rasterState: RasterState;
     /** Render queue type. */
     renderQueueType: RenderQueueType;
+    private _applyStatesByShaderData;
 }

package/types/texture/enums/PixelFormat.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Defines various pixel formats.
+ */
+export declare enum PixelFormat {
+    /** RGB format, 8 bits per channel. */
+    R8G8B8 = 0,
+    /** RGBA format, 8 bits per channel. */
+    R8G8B8A8 = 1,
+    /** RGBA format, 4 bits per channel. */
+    R4G4B4A4 = 2,
+    /** RGBA format, 5 bits in R channel, 5 bits in G channel, 5 bits in B channel, 1 bit in A channel. */
+    R5G5B5A1 = 3,
+    /** RGB format, 5 bits in R channel, 6 bits in G channel, 5 bits in B channel. */
+    R5G6B5 = 4,
+    /** Transparent format, 8 bits. */
+    Alpha8 = 5,
+    /** Luminance/alpha in RGB channel, alpha in A channel. */
+    LuminanceAlpha = 6,
+    /** RGBA format, 16 bits per channel. */
+    R16G16B16A16 = 7,
+    /** RGBA format, 32 bits per channel. */
+    R32G32B32A32 = 8,
+    /** RGB compressed format, 4 bits per pixel. */
+    BC1 = 9,
+    /** RGBA compressed format, 8 bits per pixel. */
+    BC3 = 10,
+    /** RGB(A) compressed format, 128 bits per 4x4 pixel block. */
+    BC7 = 11,
+    /** RGB compressed format, 4 bits per pixel. */
+    ETC1_RGB = 12,
+    /** RGB compressed format, 4 bits per pixel. */
+    ETC2_RGB = 13,
+    /** RGBA compressed format, 5 bits per pixel, 4 bit in RGB, 1 bit in A. */
+    ETC2_RGBA5 = 14,
+    /** RGB compressed format, 8 bits per pixel. */
+    ETC2_RGBA8 = 15,
+    /** RGB compressed format, 2 bits per pixel. */
+    PVRTC_RGB2 = 16,
+    /** RGBA compressed format, 2 bits per pixel. */
+    PVRTC_RGBA2 = 17,
+    /** RGB compressed format, 4 bits per pixel. */
+    PVRTC_RGB4 = 18,
+    /** RGBA compressed format, 4 bits per pixel. */
+    PVRTC_RGBA4 = 19,
+    /** RGB(A) compressed format, 128 bits per 4x4 pixel block. */
+    ASTC_4x4 = 20,
+    /** RGB(A) compressed format, 128 bits per 5x5 pixel block. */
+    ASTC_5x5 = 21,
+    /** RGB(A) compressed format, 128 bits per 6x6 pixel block. */
+    ASTC_6x6 = 22,
+    /** RGB(A) compressed format, 128 bits per 8x8 pixel block. */
+    ASTC_8x8 = 23,
+    /** RGB(A) compressed format, 128 bits per 10x10 pixel block. */
+    ASTC_10x10 = 24,
+    /** RGB(A) compressed format, 128 bits per 12x12 pixel block. */
+    ASTC_12x12 = 25,
+    /** Automatic depth format, engine will automatically select the supported precision. */
+    Depth = 26,
+    /** Render to stencil buffer. */
+    Stencil = 27,
+    /** Automatic depth stencil format, engine will automatically select the supported precision. */
+    DepthStencil = 28,
+    /** 16-bit depth format. */
+    Depth16 = 29,
+    /** 24-bit depth format. */
+    Depth24 = 30,
+    /** 32-bit depth format. */
+    Depth32 = 31,
+    /** 16-bit depth + 8-bit stencil format. */
+    Depth24Stencil8 = 32,
+    /** 32-bit depth + 8-bit stencil format. */
+    Depth32Stencil8 = 33
+}

package/types/texture/enums/TextureFormat.d.ts

@@ -22,6 +22,8 @@ export declare enum TextureFormat {
     R32G32B32A32 = 8,
     /** RGBA unsigned integer format, 32 bits per channel. */
     R32G32B32A32_UInt = 9,
+    /** RGB unsigned float format, 11 bits in R channel, 11 bits in G channel, 10 bits in B channel. */
+    R11G11B10_UFloat = 35,
     /** RGB compressed format, 4 bits per pixel. */
     BC1 = 10,
     /** RGBA compressed format, 8 bits per pixel. */

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";

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/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 {
-}