@galacean/engine-core 0.0.0-experimental-1.3-xr.9 → 0.0.0-experimental-1.4-small-language.0

package/types/postProcess/PostProcessEffectParameter.d.ts

@@ -0,0 +1,119 @@
+import { Color, Vector2, Vector3, Vector4 } from "@galacean/engine-math";
+import { Texture } from "../texture";
+/**
+ * Represents a parameter of a post process effect.
+ * @remarks
+ * The parameter will be mixed to a final value and be used in post process manager.
+ */
+export declare abstract class PostProcessEffectParameter<T> {
+    /**
+     * Whether the parameter is enabled.
+     */
+    enabled: boolean;
+    protected _needLerp: boolean;
+    protected _value: T;
+    /**
+     * The value of the parameter.
+     */
+    get value(): T;
+    set value(value: T);
+    constructor(value: T, needLerp?: boolean);
+}
+/**
+ * Represents a float parameter of a post process effect.
+ */
+export declare class PostProcessEffectFloatParameter extends PostProcessEffectParameter<number> {
+    readonly min: number;
+    readonly max: number;
+    get value(): number;
+    set value(v: number);
+    /**
+     * Create a new float parameter.
+     * @param value - The default value of the parameter
+     * @param _min - The minimum value of the parameter, default is Number.NEGATIVE_INFINITY
+     * @param _max - The maximum value of the parameter, default is Number.POSITIVE_INFINITY
+     * @param needLerp - Whether the parameter needs to be lerp, default is true
+     */
+    constructor(value: number, min?: number, max?: number, needLerp?: boolean);
+    _lerp(to: number, factor: number): void;
+}
+/**
+ * Represents a boolean parameter of a post process effect.
+ */
+export declare class PostProcessEffectBoolParameter extends PostProcessEffectParameter<boolean> {
+    /**
+     * Create a new boolean parameter.
+     * @param value - The default value of the parameter
+     */
+    constructor(value: boolean);
+}
+/**
+ * Represents a texture parameter of a post process effect.
+ */
+export declare class PostProcessEffectTextureParameter extends PostProcessEffectParameter<Texture> {
+    /**
+     * Create a new texture parameter.
+     * @param value - The default texture of the parameter
+     */
+    constructor(value: Texture);
+}
+/**
+ * Represents a color parameter of a post process effect.
+ */
+export declare class PostProcessEffectColorParameter extends PostProcessEffectParameter<Color> {
+    /**
+     * Create a new color parameter.
+     * @param value - The default color of the parameter
+     * @param needLerp - Whether the parameter needs to be lerp, default is true
+     */
+    constructor(value: Color, needLerp?: boolean);
+    _lerp(to: Color, factor: number): void;
+}
+/**
+ * Represents a vector2 parameter of a post process effect.
+ */
+export declare class PostProcessEffectVector2Parameter extends PostProcessEffectParameter<Vector2> {
+    /**
+     * Create a new vector2 parameter.
+     * @param value - The default vector2 of the parameter
+     * @param needLerp - Whether the parameter needs to be lerp, default is true
+     */
+    constructor(value: Vector2, needLerp?: boolean);
+    _lerp(to: Vector2, factor: number): void;
+}
+/**
+ * Represents a vector3 parameter of a post process effect.
+ */
+export declare class PostProcessEffectVector3Parameter extends PostProcessEffectParameter<Vector3> {
+    /**
+     * Create a new vector3 parameter.
+     * @param value - The default vector3 of the parameter
+     * @param needLerp - Whether the parameter needs to be lerp, default is true
+     */
+    constructor(value: Vector3, needLerp?: boolean);
+    _lerp(to: Vector3, factor: number): void;
+}
+/**
+ * Represents a vector4 parameter of a post process effect.
+ */
+export declare class PostProcessEffectVector4Parameter extends PostProcessEffectParameter<Vector4> {
+    /**
+     * Create a new vector4 parameter.
+     * @param value - The default vector4 of the parameter
+     * @param needLerp - Whether the parameter needs to be lerp, default is true
+     */
+    constructor(value: Vector4, needLerp?: boolean);
+    _lerp(to: Vector4, factor: number): void;
+}
+/**
+ * Represents a enum parameter of a post process effect.
+ */
+export declare class PostProcessEffectEnumParameter<T> extends PostProcessEffectParameter<T> {
+    readonly enumType: Record<string, number | string>;
+    /**
+     * Create a new enum parameter.
+     * @param enumType - The type of the enum
+     * @param value - The default enum value of the parameter
+     */
+    constructor(enumType: Record<string, number | string>, value: T);
+}

package/types/postProcess/PostProcessManager.d.ts

@@ -1 +1,37 @@
-export {};
+import { Scene } from "../Scene";
+import { PostProcessEffect } from "./PostProcessEffect";
+/**
+ * A global manager of the PostProcess.
+ */
+export declare class PostProcessManager {
+    readonly scene: Scene;
+    private static _tempColliders;
+    private static _tempVector3;
+    private _activePostProcesses;
+    private _swapRenderTarget;
+    private _srcRenderTarget;
+    private _destRenderTarget;
+    private _currentSourceRenderTarget;
+    private _currentDestRenderTarget;
+    private _blendEffectMap;
+    private _defaultEffectMap;
+    private _remainActivePassCount;
+    /**
+     * Create a PostProcessManager.
+     * @param scene - Scene to which the current PostProcessManager belongs
+     */
+    constructor(scene: Scene);
+    /**
+     * Get the blend effect by type.
+     * @remarks
+     * The blend effect is a post process effect that is used to blend all result of the effects by the type.
+     * @param type - The type of PostProcessEffect
+     * @returns The PostProcessEffect instance found
+     */
+    getBlendEffect<T extends typeof PostProcessEffect>(type: T): InstanceType<T>;
+    private _sortActivePostProcess;
+    private _resetDefaultValue;
+    private _initSwapRenderTarget;
+    private _swapRT;
+    private _getCurrentSourceTexture;
+}

package/types/postProcess/PostProcessPass.d.ts

@@ -0,0 +1,50 @@
+import { EngineObject } from "../base";
+import { Camera } from "../Camera";
+import { RenderTarget, Texture2D } from "../texture";
+import { PostProcessManager } from "./PostProcessManager";
+/**
+ * Controls when the post process pass executes.
+ */
+export declare enum PostProcessPassEvent {
+    /** Before the uber pass. */
+    BeforeUber = 0,
+    /** After the uber pass. */
+    AfterUber = 100
+}
+/**
+ * Post process pass.
+ */
+export declare abstract class PostProcessPass extends EngineObject {
+    private _event;
+    private _isActive;
+    /**
+     * When the post process pass is rendered.
+     * @remarks
+     * Users can also inject pass events in a specific point by doing PostProcessPassEvent + offset.
+     */
+    get event(): PostProcessPassEvent;
+    set event(value: PostProcessPassEvent);
+    /**
+     * Whether the post process pass is active.
+     */
+    get isActive(): boolean;
+    set isActive(value: boolean);
+    /**
+     * Whether the post process pass is valid in current post process manager.
+     * @remarks
+     * This method can be overridden to control the pass's real validity.
+     * @param postProcessManager - The post process manager
+     */
+    isValid(postProcessManager: PostProcessManager): boolean;
+    /**
+     * Execute the post process pass if it is active.
+     * @param camera - The camera used to render
+     * @param srcTexture - The source texture from last render target
+     * @param destTarget - The destination render target
+     */
+    abstract onRender(camera: Camera, srcTexture: Texture2D, destTarget: RenderTarget): void;
+    /**
+     * @inheritdoc
+     */
+    _onDestroy(): void;
+}

package/types/postProcess/PostProcessUberPass.d.ts

@@ -0,0 +1,25 @@
+import { Camera } from "../Camera";
+import { Engine } from "../Engine";
+import { RenderTarget, Texture2D } from "../texture";
+import { PostProcessPass } from "./PostProcessPass";
+import { PostProcessManager } from "./PostProcessManager";
+export declare class PostProcessUberPass extends PostProcessPass {
+    static readonly UBER_SHADER_NAME = "UberPost";
+    private _uberMaterial;
+    private _bloomMaterial;
+    private _mipDownRT;
+    private _mipUpRT;
+    constructor(engine: Engine);
+    /** @inheritdoc */
+    isValid(postProcessManager: PostProcessManager): boolean;
+    /**
+     * @inheritdoc
+     */
+    onRender(camera: Camera, srcTexture: Texture2D, destTarget: RenderTarget): void;
+    /**
+     * @inheritdoc
+     */
+    _onDestroy(): void;
+    private _setupBloom;
+    private _releaseBloomRenderTargets;
+}

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

@@ -1,94 +1,50 @@
-import { Color } from "@galacean/engine-math";
-import { RenderContext } from "../../RenderPipeline/RenderContext";
-import { Material } from "../../material";
-import { Texture2D } from "../../texture";
+import { PostProcessEffect } from "../PostProcessEffect";
+import { PostProcessEffectBoolParameter, PostProcessEffectColorParameter, PostProcessEffectEnumParameter, PostProcessEffectFloatParameter, PostProcessEffectTextureParameter } from "../PostProcessEffectParameter";
 /**
  * This controls the size of the bloom texture.
  */
 export declare enum BloomDownScaleMode {
-    /**
-     *  Use this to select half size as the starting resolution.
-     */
+    /** Use this to select half size as the starting resolution. */
     Half = 0,
-    /**
-     *  Use this to select quarter size as the starting resolution.
-     */
+    /** Use this to select quarter size as the starting resolution. */
     Quarter = 1
 }
-export declare class BloomEffect {
-    private _uberMaterial;
+export declare class BloomEffect extends PostProcessEffect {
     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 whether to use bicubic sampling instead of bilinear sampling for the upSampling passes.
+     * @remarks This is slightly more expensive but helps getting smoother visuals.
+     */
+    highQualityFiltering: PostProcessEffectBoolParameter;
     /**
      * Controls the starting resolution that this effect begins processing.
      */
-    downScale: BloomDownScaleMode;
+    downScale: PostProcessEffectEnumParameter<BloomDownScaleMode>;
     /**
-     * Indicates whether the post process effect is enabled.
+     * Specifies a Texture to add smudges or dust to the bloom effect.
      */
-    get enabled(): boolean;
-    set enabled(value: boolean);
+    dirtTexture: PostProcessEffectTextureParameter;
     /**
      * 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);
+    threshold: PostProcessEffectFloatParameter;
     /**
      * Controls the radius of the bloom effect.
      */
-    get scatter(): number;
-    set scatter(value: number);
+    scatter: PostProcessEffectFloatParameter;
     /**
      * 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);
+    intensity: PostProcessEffectFloatParameter;
     /**
-     * Specifies a Texture to add smudges or dust to the bloom effect.
+     * Controls the strength of the lens dirt.
      */
-    get dirtTexture(): Texture2D;
-    set dirtTexture(value: Texture2D);
+    dirtIntensity: PostProcessEffectFloatParameter;
     /**
-     * Controls the strength of the lens dirt.
+     * Specifies the tint of the bloom effect.
      */
-    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;
+    tint: PostProcessEffectColorParameter;
+    /** @inheritdoc */
+    isValid(): boolean;
 }

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

@@ -1,35 +1,25 @@
-import { Material } from "../../material";
+import { PostProcessEffect } from "../PostProcessEffect";
+import { PostProcessEffectEnumParameter } from "../PostProcessEffectParameter";
 /**
  * Options to select a tonemapping algorithm to use.
  */
 export declare enum TonemappingMode {
     /**
-     * Neutral tonemapper
+     * 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)
+     * 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);
+export declare class TonemappingEffect extends PostProcessEffect {
     /**
      * Use this to select a tonemapping algorithm to use.
      */
-    get mode(): TonemappingMode;
-    set mode(value: TonemappingMode);
-    constructor(_uberMaterial: Material);
+    mode: PostProcessEffectEnumParameter<TonemappingMode>;
 }

package/types/postProcess/index.d.ts

@@ -1,3 +1,7 @@
-import { _PostProcessManager } from "./PostProcessManager";
 export * from "./effects";
-export { _PostProcessManager };
+export { PostProcess } from "./PostProcess";
+export { PostProcessEffect } from "./PostProcessEffect";
+export { PostProcessEffectBoolParameter, PostProcessEffectColorParameter, PostProcessEffectEnumParameter, PostProcessEffectFloatParameter, PostProcessEffectParameter, PostProcessEffectTextureParameter, PostProcessEffectVector2Parameter, PostProcessEffectVector3Parameter, PostProcessEffectVector4Parameter } from "./PostProcessEffectParameter";
+export { PostProcessManager } from "./PostProcessManager";
+export { PostProcessPass, PostProcessPassEvent } from "./PostProcessPass";
+export { PostProcessUberPass } from "./PostProcessUberPass";

package/types/shader/Shader.d.ts

@@ -18,7 +18,7 @@ export declare class Shader implements IReferable {
      * ShaderLab must be enabled first as follows:
      * ```ts
      * // Import shaderLab
-     * import { ShaderLab } from "@galacean/engine-shader-lab";
+     * import { ShaderLab } from "@galacean/engine-shaderlab";
      * // Create engine with shaderLab
      * const engine = await WebGLEngine.create({ canvas: "canvas", shader: new ShaderLab() });
      * ...

package/types/shader/index.d.ts

@@ -5,6 +5,7 @@ export { CompareFunction } from "./enums/CompareFunction";
 export { CullMode } from "./enums/CullMode";
 export { RenderStateElementKey as RenderStateDataKey } from "./enums/RenderStateElementKey";
 export { RenderQueueType } from "./enums/RenderQueueType";
+export { ShaderDataGroup } from "./enums/ShaderDataGroup";
 export { ShaderPropertyType } from "./enums/ShaderPropertyType";
 export { StencilOperation } from "./enums/StencilOperation";
 export { ShaderPlatformTarget } from "./enums/ShaderPlatformTarget";

package/types/shaderlib/ShaderLib.d.ts

@@ -17,6 +17,8 @@ export declare const ShaderLib: {
     direct_irradiance_frag_define: string;
     ibl_frag_define: string;
     pbr_frag: string;
+    btdf: string;
+    refraction: string;
     ShadowCoord: string;
     ShadowFragmentDeclaration: string;
     shadow_sample_tent: string;

package/types/shaderlib/pbr/index.d.ts

@@ -5,5 +5,7 @@ declare const _default: {
     direct_irradiance_frag_define: string;
     ibl_frag_define: string;
     pbr_frag: string;
+    btdf: string;
+    refraction: string;
 };
 export default _default;

package/types/ui/UIUtils.d.ts

@@ -0,0 +1,11 @@
+import { Engine } from "../Engine";
+import { Scene } from "../Scene";
+import { DisorderedArray } from "../utils/DisorderedArray";
+import { IUICanvas } from "./IUICanvas";
+export declare class UIUtils {
+    private static _renderQueue;
+    private static _virtualCamera;
+    private static _viewport;
+    private static _overlayCamera;
+    static renderOverlay(engine: Engine, scene: Scene, uiCanvases: DisorderedArray<IUICanvas>): void;
+}

package/types/utils/DisorderedArray.d.ts

@@ -0,0 +1,70 @@
+/**
+ * High-performance unordered array, delete uses exchange method to improve performance, internal capacity only increases.
+ */
+export declare class DisorderedArray<T> {
+    /** The length of the array. */
+    length: number;
+    private _loopCounter;
+    private _blankCount;
+    /**
+     * Get whether the array is in the loop.
+     */
+    get isLopping(): boolean;
+    /**
+     * Create a DisorderedArray.
+     * @param count - The initial length of the array
+     */
+    constructor(count?: number);
+    /**
+     * Add an element to disordered array.
+     * @param element - The element to be added
+     */
+    add(element: T): void;
+    /**
+     * Delete the specified element.
+     * @param element - The element to be deleted
+     */
+    delete(element: T): void;
+    /**
+     * Set the element at the specified index.
+     * @param index - The index of the element to be set
+     * @param element - The element to be set
+     */
+    set(index: number, element: T): void;
+    /**
+     * Get the element at the specified index.
+     * @param index - The index of the element to be get
+     * @returns The element at the specified index
+     */
+    get(index: number): T;
+    /**
+     * Delete the element at the specified index.
+     * @param index - The index of the element to be deleted
+     * @returns The replaced item is used to reset its index
+     */
+    deleteByIndex(index: number): T;
+    /**
+     * Loop through all elements.
+     * @param callbackFn - The callback function
+     * @param swapFn - The swap function can process the element after the callback function, it will be called after end looping(`isLopping` = true)
+     */
+    forEach(callbackFn: (element: T, index: number) => void, swapFn?: (element: T, index: number) => void): void;
+    /**
+     * Loop through all elements and clean up the blank elements.
+     * @param callbackFn - The callback function
+     * @param swapFn - The swap function can process the element after the callback function,  it will be called after end looping(`isLopping` = true)
+     */
+    forEachAndClean(callbackFn: (element: T, index: number) => void, swapFn?: (element: T, index: number) => void): void;
+    /**
+     * Sort the array.
+     * @param compareFn - The comparison function
+     */
+    sort(compareFn: (a: T, b: T) => number): void;
+    /**
+     * Garbage collection, clean up all cached elements.
+     */
+    garbageCollection(): void;
+    private _startLoop;
+    private _endLoop;
+    private _endLoopAndClean;
+}