@galacean/engine-core 1.3.0-alpha.0 → 1.3.0-alpha.1

package/package.json

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

package/types/Camera.d.ts

@@ -64,6 +64,8 @@ export declare class Camera extends Component {
     private _renderTarget;
     private _depthBufferParams;
     private _opaqueTextureEnabled;
+    private _enableHDR;
+    private _enablePostProcess;
     private _frustumChangeFlag;
     private _transform;
     private _isViewMatrixDirty;
@@ -77,7 +79,6 @@ export declare class Camera extends Component {
      * If enabled, the opaque texture can be accessed in the shader using `camera_OpaqueTexture`.
      *
      * @defaultValue `false`
-     *
      * @remarks If enabled, the `independentCanvasEnabled` property will be forced to be true.
      */
     get opaqueTextureEnabled(): boolean;
@@ -153,10 +154,18 @@ export declare class Camera extends Component {
     set projectionMatrix(value: Matrix);
     /**
      * Whether to enable HDR.
-     * @todo When render pipeline modification
+     * @defaultValue `false`
+     * @remarks If enabled, the `independentCanvasEnabled` property will be forced to be true.
      */
     get enableHDR(): boolean;
     set enableHDR(value: boolean);
+    /**
+     * Whether to enable post process.
+     * @defaultValue `false`
+     * @remarks If enabled, the `independentCanvasEnabled` property will be forced to be true.
+     */
+    get enablePostProcess(): boolean;
+    set enablePostProcess(value: boolean);
     /**
      * RenderTarget. After setting, it will be rendered to the renderTarget. If it is empty, it will be rendered to the main canvas.
      */
@@ -286,7 +295,6 @@ export declare class Camera extends Component {
      * The inverse of the projection matrix.
      */
     private _getInverseProjectionMatrix;
-    private _forceUseInternalCanvas;
     private _onPixelViewportChanged;
     private _checkMainCanvasAntialiasWaste;
 }

package/types/RenderPipeline/PipelinePass.d.ts

@@ -5,7 +5,7 @@ import { RenderContext } from "../RenderPipeline/RenderContext";
  * PipelinePass is a base class for all pipeline passes.
  */
 export declare abstract class PipelinePass {
-    protected _engine: Engine;
+    readonly engine: Engine;
     constructor(engine: Engine);
     /**
      * Called before rendering a camera, override this method to configure the camera If you need to configure the camera clear flag or render target.

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

@@ -0,0 +1,13 @@
+/**
+ * This enum describes what should be done on the render target when the GPU is done rendering into it.
+ */
+export declare enum RenderBufferStoreAction {
+    /**
+     * Do nothing after rendering.
+     */
+    DontCare = 0,
+    /**
+     * Blit the MSAA render target after rendering.
+     */
+    BlitMSAA = 1
+}

package/types/RenderPipeline/index.d.ts

@@ -1,3 +1,3 @@
 export { BasicRenderPipeline } from "./BasicRenderPipeline";
-export { PipelineStage } from "./enums/PipelineStage";
 export { RenderQueue } from "./RenderQueue";
+export { PipelineStage } from "./enums/PipelineStage";

package/types/index.d.ts

@@ -57,3 +57,4 @@ export * from "./renderingHardwareInterface/index";
 export * from "./physics/index";
 export * from "./Utils";
 export { ShaderMacroCollection } from "./shader/ShaderMacroCollection";
+export * from "./postProcess";

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/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/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. */