@galacean/engine-core 1.4.0-alpha.1 → 1.4.0-alpha.3

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,52 @@
 import { Color } from "@galacean/engine-math";
-import { RenderContext } from "../../RenderPipeline/RenderContext";
-import { Material } from "../../material";
 import { Texture2D } from "../../texture";
+import { PostProcessEffect } from "../PostProcessEffect";
+import { PostProcessEffectParameter } 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: PostProcessEffectParameter<boolean>;
     /**
      * Controls the starting resolution that this effect begins processing.
      */
-    downScale: BloomDownScaleMode;
+    downScale: PostProcessEffectParameter<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: PostProcessEffectParameter<Texture2D>;
     /**
      * 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: PostProcessEffectParameter<number>;
     /**
      * Controls the radius of the bloom effect.
      */
-    get scatter(): number;
-    set scatter(value: number);
+    scatter: PostProcessEffectParameter<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);
+    intensity: PostProcessEffectParameter<number>;
     /**
-     * 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: PostProcessEffectParameter<number>;
     /**
-     * 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: PostProcessEffectParameter<Color>;
+    /** @inheritdoc */
+    isValid(): boolean;
 }

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

@@ -1,35 +1,25 @@
-import { Material } from "../../material";
+import { PostProcessEffect } from "../PostProcessEffect";
+import { PostProcessEffectParameter } 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: PostProcessEffectParameter<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 { PostProcessEffectParameter } 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() });
      * ...