@galacean/engine-core 0.9.0-beta.80

package/types/shader/index.d.ts

@@ -0,0 +1,12 @@
+export { RenderQueueType } from "./enums/RenderQueueType";
+export { BlendFactor } from "./enums/BlendFactor";
+export { BlendOperation } from "./enums/BlendOperation";
+export { ColorWriteMask } from "./enums/ColorWriteMask";
+export { CompareFunction } from "./enums/CompareFunction";
+export { CullMode } from "./enums/CullMode";
+export { ShaderPropertyType } from "./enums/ShaderPropertyType";
+export { StencilOperation } from "./enums/StencilOperation";
+export { Shader } from "./Shader";
+export { ShaderData } from "./ShaderData";
+export { ShaderPass } from "./ShaderPass";
+export { ShaderProperty } from "./ShaderProperty";

package/types/shader/state/BlendState.d.ts

@@ -0,0 +1,16 @@
+import { Color } from "@galacean/engine-math";
+import { RenderTargetBlendState } from "./RenderTargetBlendState";
+/**
+ * Blend state.
+ */
+export declare class BlendState {
+    private static _getGLBlendFactor;
+    private static _getGLBlendOperation;
+    /** The blend state of the render target. */
+    readonly targetBlendState: RenderTargetBlendState;
+    /** Constant blend color. */
+    readonly blendColor: Color;
+    /** Whether to use (Alpha-to-Coverage) technology. */
+    alphaToCoverage: boolean;
+    private _platformApply;
+}

package/types/shader/state/DepthState.d.ts

@@ -0,0 +1,14 @@
+import { CompareFunction } from "../enums/CompareFunction";
+/**
+ * Depth state.
+ */
+export declare class DepthState {
+    private static _getGLCompareFunction;
+    /** Whether to enable the depth test. */
+    enabled: boolean;
+    /** Whether the depth value can be written.*/
+    writeEnabled: boolean;
+    /** Depth comparison function. */
+    compareFunction: CompareFunction;
+    private _platformApply;
+}

package/types/shader/state/RasterState.d.ts

@@ -0,0 +1,13 @@
+import { CullMode } from "../enums/CullMode";
+/**
+ * Raster state.
+ */
+export declare class RasterState {
+    /** Specifies whether or not front- and/or back-facing polygons can be culled. */
+    cullMode: CullMode;
+    /** The multiplier by which an implementation-specific value is multiplied with to create a constant depth offset. */
+    depthBias: number;
+    /** The scale factor for the variable depth offset for each polygon. */
+    slopeScaledDepthBias: number;
+    private _platformApply;
+}

package/types/shader/state/RenderState.d.ts

@@ -0,0 +1,20 @@
+import { RenderQueueType } from "../enums/RenderQueueType";
+import { BlendState } from "./BlendState";
+import { DepthState } from "./DepthState";
+import { RasterState } from "./RasterState";
+import { StencilState } from "./StencilState";
+/**
+ * Render state.
+ */
+export declare class RenderState {
+    /** Blend state. */
+    readonly blendState: BlendState;
+    /** Depth state. */
+    readonly depthState: DepthState;
+    /** Stencil state. */
+    readonly stencilState: StencilState;
+    /** Raster state. */
+    readonly rasterState: RasterState;
+    /** Render queue type. */
+    renderQueueType: RenderQueueType;
+}

package/types/shader/state/RenderTargetBlendState.d.ts

@@ -0,0 +1,24 @@
+import { BlendOperation } from "../enums/BlendOperation";
+import { BlendFactor } from "../enums/BlendFactor";
+import { ColorWriteMask } from "../enums/ColorWriteMask";
+/**
+ * The blend state of the render target.
+ */
+export declare class RenderTargetBlendState {
+    /** Whether to enable blend. */
+    enabled: boolean;
+    /** color (RGB) blend operation. */
+    colorBlendOperation: BlendOperation;
+    /** alpha (A) blend operation. */
+    alphaBlendOperation: BlendOperation;
+    /** color blend factor (RGB) for source. */
+    sourceColorBlendFactor: BlendFactor;
+    /** alpha blend factor (A) for source. */
+    sourceAlphaBlendFactor: BlendFactor;
+    /** color blend factor (RGB) for destination. */
+    destinationColorBlendFactor: BlendFactor;
+    /** alpha blend factor (A) for destination. */
+    destinationAlphaBlendFactor: BlendFactor;
+    /** color mask. */
+    colorWriteMask: ColorWriteMask;
+}

package/types/shader/state/StencilState.d.ts

@@ -0,0 +1,34 @@
+import { CompareFunction } from "../enums/CompareFunction";
+import { StencilOperation } from "../enums/StencilOperation";
+/**
+ * Stencil state.
+ */
+export declare class StencilState {
+    private static _getGLCompareFunction;
+    private static _getGLStencilOperation;
+    /** Whether to enable stencil test. */
+    enabled: boolean;
+    /** Write the reference value of the stencil buffer. */
+    referenceValue: number;
+    /** Specifying a bit-wise mask that is used to AND the reference value and the stored stencil value when the test is done. */
+    mask: number;
+    /** Specifying a bit mask to enable or disable writing of individual bits in the stencil planes. */
+    writeMask: number;
+    /** The comparison function of the reference value of the front face of the geometry and the current buffer storage value. */
+    compareFunctionFront: CompareFunction;
+    /** The comparison function of the reference value of the back of the geometry and the current buffer storage value. */
+    compareFunctionBack: CompareFunction;
+    /** specifying the function to use for front face when both the stencil test and the depth test pass. */
+    passOperationFront: StencilOperation;
+    /** specifying the function to use for back face when both the stencil test and the depth test pass. */
+    passOperationBack: StencilOperation;
+    /** specifying the function to use for front face when the stencil test fails. */
+    failOperationFront: StencilOperation;
+    /** specifying the function to use for back face when the stencil test fails. */
+    failOperationBack: StencilOperation;
+    /** specifying the function to use for front face when the stencil test passes, but the depth test fails. */
+    zFailOperationFront: StencilOperation;
+    /** specifying the function to use for back face when the stencil test passes, but the depth test fails. */
+    zFailOperationBack: StencilOperation;
+    private _platformApply;
+}

package/types/shaderlib/ShaderFactory.d.ts

@@ -0,0 +1,17 @@
+declare class ShaderFactory {
+    static parseCustomMacros(macros: string[]): string;
+    static parseIncludes(src: string): string;
+    /**
+     * GLSL extension.
+     * @param extensions - such as ["GL_EXT_shader_texture_lod"]
+     * */
+    static parseExtension(extensions: string[]): string;
+    /**
+     * Convert lower GLSL version to GLSL 300 es.
+     * @param shader - code
+     * @param isFrag - Whether it is a fragment shader.
+     * */
+    static convertTo300(shader: string, isFrag?: boolean): string;
+    private static _replaceMRTShader;
+}
+export { ShaderFactory };

package/types/shaderlib/ShaderLib.d.ts

@@ -0,0 +1,58 @@
+export declare const ShaderLib: {
+    normal_get: string;
+    pbr_frag_define: string;
+    pbr_helper: string;
+    brdf: string;
+    direct_irradiance_frag_define: string;
+    ibl_frag_define: string;
+    pbr_frag: string;
+    ShadowCoord: string;
+    ShadowFragmentDeclaration: string;
+    shadow_sample_tent: string;
+    ShadowVertexDeclaration: string;
+    ShadowVertex: string;
+    common: string;
+    common_vert: string;
+    transform_declare: string;
+    camera_declare: string;
+    color_share: string;
+    normal_share: string;
+    uv_share: string;
+    worldpos_share: string;
+    RendererFragmentDeclaration: string;
+    FogVertexDeclaration: string;
+    FogFragmentDeclaration: string;
+    begin_normal_vert: string;
+    begin_position_vert: string;
+    position_vert: string;
+    color_vert: string;
+    normal_vert: string;
+    skinning_vert: string;
+    blendShape_input: string;
+    blendShape_vert: string;
+    uv_vert: string;
+    worldpos_vert: string;
+    FogVertex: string;
+    light_frag_define: string;
+    mobile_material_frag: string;
+    FogFragment: string;
+    begin_mobile_frag: string;
+    begin_viewdir_frag: string;
+    mobile_blinnphong_frag: string;
+    noise_common: string;
+    noise_cellular_2D: string;
+    noise_cellular_2x2: string;
+    noise_cellular_2x2x2: string;
+    noise_cellular_3D: string;
+    noise_cellular: string;
+    noise_perlin_2D: string;
+    noise_perlin_3D: string;
+    noise_perlin_4D: string;
+    noise_perlin: string;
+    noise_psrd_2D: string;
+    noise_simplex_2D: string;
+    noise_simplex_3D_grad: string;
+    noise_simplex_3D: string;
+    noise_simplex_4D: string;
+    noise_simplex: string;
+};

package/types/shaderlib/index.d.ts

@@ -0,0 +1 @@
+export { ShaderFactory } from "./ShaderFactory";

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

@@ -0,0 +1,9 @@
+declare const _default: {
+    pbr_frag_define: string;
+    pbr_helper: string;
+    brdf: string;
+    direct_irradiance_frag_define: string;
+    ibl_frag_define: string;
+    pbr_frag: string;
+};
+export default _default;

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

@@ -0,0 +1,8 @@
+declare const _default: {
+    ShadowCoord: string;
+    ShadowFragmentDeclaration: string;
+    shadow_sample_tent: string;
+    ShadowVertexDeclaration: string;
+    ShadowVertex: string;
+};
+export default _default;

package/types/shadow/CascadedShadowCasterPass.d.ts

@@ -0,0 +1,47 @@
+import { Camera } from "../Camera";
+/**
+ * Cascade shadow caster.
+ */
+export declare class CascadedShadowCasterPass {
+    private static _lightShadowBiasProperty;
+    private static _lightDirectionProperty;
+    private static _shadowMatricesProperty;
+    private static _shadowMapSize;
+    private static _shadowInfosProperty;
+    private static _shadowMapsProperty;
+    private static _shadowSplitSpheresProperty;
+    private static _maxCascades;
+    private static _cascadesSplitDistance;
+    private static _clearColor;
+    private static _tempVector;
+    private static _tempMatrix0;
+    private readonly _camera;
+    private readonly _engine;
+    private readonly _shadowCasterShader;
+    private readonly _supportDepthTexture;
+    private _shadowMapResolution;
+    private _shadowMapSize;
+    private _shadowTileResolution;
+    private _shadowBias;
+    private _shadowMapFormat;
+    private _shadowCascadeMode;
+    private _shadowSliceData;
+    private _lightUp;
+    private _lightSide;
+    private _existShadowMap;
+    private _splitBoundSpheres;
+    /** The end is project prcision problem in shader. */
+    private _shadowMatrices;
+    private _shadowInfos;
+    private _depthTexture;
+    private _renderTargets;
+    private _viewportOffsets;
+    constructor(camera: Camera);
+    private _renderDirectShadowMap;
+    private _updateReceiversShaderData;
+    private _getCascadesSplitDistance;
+    private _getFarWithRadius;
+    private _getAvailableRenderTarget;
+    private _updateShadowSettings;
+    private _updateSingleShadowCasterShaderData;
+}

package/types/shadow/ShadowSliceData.d.ts

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

package/types/shadow/ShadowUtils.d.ts

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

package/types/shadow/enum/ShadowCascadesMode.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Number of cascades to use for directional light shadows.
+ */
+export declare enum ShadowCascadesMode {
+    /** No cascades */
+    NoCascades = 1,
+    /** Two cascades */
+    TwoCascades = 2,
+    /** Four cascades */
+    FourCascades = 4
+}

package/types/shadow/enum/ShadowResolution.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Default shadow resolution.
+ */
+export declare enum ShadowResolution {
+    /** Low shadow map resolution. */
+    Low = 0,
+    /** Medium shadow map resolution. */
+    Medium = 1,
+    /**  High shadow map resolution. */
+    High = 2,
+    /** Very high shadow map resolution. */
+    VeryHigh = 3
+}

package/types/shadow/enum/ShadowType.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Determines which type of shadows should be used.
+ */
+export declare enum ShadowType {
+    /** Disable Shadows. */
+    None = 0,
+    /** Hard Shadows Only. */
+    Hard = 1,
+    /** Cast "soft" shadows with low range. */
+    SoftLow = 2,
+    /** Cast "soft" shadows with large range. */
+    SoftHigh = 3
+}

package/types/shadow/index.d.ts

@@ -0,0 +1,3 @@
+export { ShadowCascadesMode } from "./enum/ShadowCascadesMode";
+export { ShadowResolution } from "./enum/ShadowResolution";
+export { ShadowType } from "./enum/ShadowType";

package/types/sky/Sky.d.ts

@@ -0,0 +1,14 @@
+import { Mesh } from "../graphic/Mesh";
+import { Material } from "../material";
+/**
+ * Sky.
+ */
+export declare class Sky {
+    private static _epsilon;
+    private static _viewProjMatrix;
+    private static _projectionMatrix;
+    /** Material of the sky. */
+    material: Material;
+    /** Mesh of the sky. */
+    mesh: Mesh;
+}

package/types/sky/SkyBoxMaterial.d.ts

@@ -0,0 +1,25 @@
+import { Engine } from "../Engine";
+import { Material } from "../material/Material";
+import { TextureCube } from "../texture";
+/**
+ * SkyboxMaterial
+ */
+export declare class SkyBoxMaterial extends Material {
+    private _decodeParam;
+    /**
+     * Whether to decode from texture with RGBM format.
+     */
+    get textureDecodeRGBM(): boolean;
+    set textureDecodeRGBM(value: boolean);
+    /**
+     * RGBM decode factor, default 5.0.
+     */
+    get RGBMDecodeFactor(): number;
+    set RGBMDecodeFactor(value: number);
+    /**
+     * Texture cube map of the sky box material.
+     */
+    get textureCubeMap(): TextureCube;
+    set textureCubeMap(v: TextureCube);
+    constructor(engine: Engine);
+}

package/types/sky/SkyProceduralMaterial.d.ts

@@ -0,0 +1,72 @@
+import { Color } from "@oasis-engine/math";
+import { Engine } from "../Engine";
+import { Material } from "../material/Material";
+/**
+ * Sun mode.
+ */
+export declare enum SunMode {
+    /** None */
+    None = 0,
+    /** Simple sun. */
+    Simple = 1,
+    /** High quality sun. */
+    HighQuality = 2
+}
+/**
+ * Sky procedural material.
+ */
+export declare class SkyProceduralMaterial extends Material {
+    private static _sunSizeProp;
+    private static _sunSizeConvergenceProp;
+    private static _atmosphereThicknessProp;
+    private static _skyTintProp;
+    private static _groundTintProp;
+    private static _exposureProp;
+    private static _sunHighQualityMacro;
+    private static _sunSimpleMacro;
+    private _sunDisk;
+    /**
+     * Sun mode.
+     */
+    get sunMode(): SunMode;
+    set sunMode(value: SunMode);
+    /**
+     * Sun size, range is 0 to 1.
+     */
+    get sunSize(): number;
+    set sunSize(value: number);
+    /**
+     * Sun size convergence, range is 0 to 20.
+     */
+    get sunSizeConvergence(): number;
+    set sunSizeConvergence(value: number);
+    /**
+     * Atmosphere thickness, range is 0 to 5.
+     */
+    get atmosphereThickness(): number;
+    set atmosphereThickness(value: number);
+    /**
+     * Sky tint.
+     */
+    get skyTint(): Color;
+    set skyTint(value: Color);
+    /**
+     * Ground tint.
+     */
+    get groundTint(): Color;
+    set groundTint(value: Color);
+    /**
+     * Exposure, range is 0 to 8.
+     */
+    get exposure(): number;
+    set exposure(value: number);
+    /**
+     * Constructor a SkyBoxProceduralMaterial instance.
+     * @param engine - Engine to which the material belongs
+     */
+    constructor(engine: Engine);
+    /**
+     * @override
+     */
+    clone(): SkyProceduralMaterial;
+}

package/types/sky/index.d.ts

@@ -0,0 +1,2 @@
+export { Sky } from "./Sky";
+export { SkyBoxMaterial } from "./SkyBoxMaterial";

package/types/texture/RenderTarget.d.ts

@@ -0,0 +1,95 @@
+import { EngineObject } from "../base";
+import { Engine } from "../Engine";
+import { RenderBufferDepthFormat } from "./enums/RenderBufferDepthFormat";
+import { Texture } from "./Texture";
+/**
+ * The render target used for off-screen rendering.
+ */
+export declare class RenderTarget extends EngineObject {
+    private _autoGenerateMipmaps;
+    private _width;
+    private _height;
+    private _colorTextures;
+    private _depthTexture;
+    /**
+     * Whether to automatically generate multi-level textures.
+     */
+    get autoGenerateMipmaps(): boolean;
+    set autoGenerateMipmaps(value: boolean);
+    /**
+     * Render target width.
+     */
+    get width(): number;
+    /**
+     * Render target height.
+     */
+    get height(): number;
+    /**
+     * Render color texture count.
+     */
+    get colorTextureCount(): number;
+    /**
+     * Depth texture.
+     */
+    get depthTexture(): Texture | null;
+    /**
+     * Anti-aliasing level.
+     * @remarks If the anti-aliasing level set is greater than the maximum level supported by the hardware, the maximum level of the hardware will be used.
+     */
+    get antiAliasing(): number;
+    /**
+     * Create a render target through color texture and depth format.
+     * @param engine - Define the engine to use for this off-screen rendering
+     * @param width - Render target width
+     * @param height - Render target height
+     * @param colorTexture - Render color texture
+     * @param depthFormat - Depth format. default RenderBufferDepthFormat.Depth, engine will automatically select the supported precision
+     * @param antiAliasing - Anti-aliasing level, default is 1
+     */
+    constructor(engine: Engine, width: number, height: number, colorTexture: Texture, depthFormat?: RenderBufferDepthFormat | null, antiAliasing?: number);
+    /**
+     * Create a render target through color texture and depth format.
+     * @remarks If the color texture is not transmitted, only the depth texture is generated.
+     * @param engine - Define the engine to use for this off-screen rendering
+     * @param width - Render target width
+     * @param height - Render target height
+     * @param colorTexture - Render color texture
+     * @param depthTexture - Render depth texture
+     * @param antiAliasing - Anti-aliasing level, default is 1
+     */
+    constructor(engine: Engine, width: number, height: number, colorTexture: Texture | null, depthTexture: Texture, antiAliasing?: number);
+    /**
+     * Create a render target with color texture array and depth format.
+     * @param engine - Define the engine to use for this off-screen rendering
+     * @param width - Render target width
+     * @param height - Render target height
+     * @param colorTextures - Render color texture array
+     * @param depthFormat - Depth format. default RenderBufferDepthFormat.Depth,engine will automatically select the supported precision
+     * @param antiAliasing - Anti-aliasing level, default is 1
+     */
+    constructor(engine: Engine, width: number, height: number, colorTextures: Texture[], depthFormat?: RenderBufferDepthFormat | null, antiAliasing?: number);
+    /**
+     * Create a render target with color texture array and depth texture.
+     * @param engine - Define the engine to use for this off-screen rendering
+     * @param width - Render target width
+     * @param height - Render target height
+     * @param colorTextures - Render color texture array
+     * @param depthTexture - Depth texture
+     * @param antiAliasing - Anti-aliasing level, default is 1
+     */
+    constructor(engine: Engine, width: number, height: number, colorTextures: Texture[], depthTexture: Texture, antiAliasing?: number);
+    /**
+     *
+     * Get the render color texture by index.
+     * @param index
+     */
+    getColorTexture(index?: number): Texture | null;
+    /**
+     * Generate the mipmap of each attachment texture of the renderTarget according to the configuration.
+     */
+    generateMipmaps(): void;
+    /**
+     * Destroy render target.
+     */
+    destroy(): void;
+}

package/types/texture/Texture.d.ts

@@ -0,0 +1,77 @@
+import { RefObject } from "../asset/RefObject";
+import { TextureDepthCompareFunction } from "./enums/TextureDepthCompareFunction";
+import { TextureFilterMode } from "./enums/TextureFilterMode";
+import { TextureFormat } from "./enums/TextureFormat";
+import { TextureWrapMode } from "./enums/TextureWrapMode";
+/**
+ * The base class of texture, contains some common functions of texture-related classes.
+ */
+export declare abstract class Texture extends RefObject {
+    name: string;
+    protected _format: TextureFormat;
+    protected _width: number;
+    protected _height: number;
+    protected _mipmapCount: number;
+    private _wrapModeU;
+    private _wrapModeV;
+    private _filterMode;
+    private _anisoLevel;
+    private _depthCompareFunction;
+    private _useDepthCompareMode;
+    /**
+     * Texture format.
+     */
+    get format(): TextureFormat;
+    /**
+     * The width of the texture.
+     */
+    get width(): number;
+    /**
+     * The height of the texture.
+     */
+    get height(): number;
+    /**
+     * Wrapping mode for texture coordinate S.
+     */
+    get wrapModeU(): TextureWrapMode;
+    set wrapModeU(value: TextureWrapMode);
+    /**
+     * Wrapping mode for texture coordinate T.
+     */
+    get wrapModeV(): TextureWrapMode;
+    set wrapModeV(value: TextureWrapMode);
+    /**
+     * Texture mipmapping count.
+     */
+    get mipmapCount(): number;
+    /**
+     * Filter mode for texture.
+     */
+    get filterMode(): TextureFilterMode;
+    set filterMode(value: TextureFilterMode);
+    /**
+     * Anisotropic level for texture.
+     */
+    get anisoLevel(): number;
+    set anisoLevel(value: number);
+    /**
+     * Filter mode when texture as depth Texture.
+     * @remarks Only depth-related formats take effect.
+     */
+    get depthCompareFunction(): TextureDepthCompareFunction;
+    set depthCompareFunction(value: TextureDepthCompareFunction);
+    /**
+     * Generate multi-level textures based on the 0th level data.
+     */
+    generateMipmaps(): void;
+    /**
+     * @override
+     */
+    _onDestroy(): void;
+    /**
+     * Get the maximum mip level of the corresponding size:rounding down.
+     * @remarks http://download.nvidia.com/developer/Papers/2005/NP2_Mipmapping/NP2_Mipmap_Creation.pdf
+     */
+    protected _getMaxMiplevel(size: number): number;
+    protected _getMipmapCount(): number;
+}