@galacean/engine-core 0.0.0-experimental-animator-additive.1

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,57 @@
+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;
+    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/ShadowMode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Determines which type of shadows should be used.
+ */
+export declare enum ShadowMode {
+    /** 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/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/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;
+}

package/types/texture/Texture2D.d.ts

@@ -0,0 +1,68 @@
+import { Engine } from "../Engine";
+import { TextureFormat } from "./enums/TextureFormat";
+import { Texture } from "./Texture";
+/**
+ * Two-dimensional texture.
+ */
+export declare class Texture2D extends Texture {
+    /**
+     * Create Texture2D.
+     * @param engine - Define the engine to use to render this texture
+     * @param width - Texture width
+     * @param height - Texture height
+     * @param format - Texture format. default  `TextureFormat.R8G8B8A8`
+     * @param mipmap - Whether to use multi-level texture
+     */
+    constructor(engine: Engine, width: number, height: number, format?: TextureFormat, mipmap?: boolean);
+    /**
+     * Setting pixels data through color buffer data, designated area and texture mipmapping level,it's also applicable to compressed formats.
+     * @remarks If it is the WebGL1.0 platform and the texture format is compressed, the first upload must be filled with textures.
+     * @param colorBuffer - Color buffer data
+     * @param mipLevel - Texture mipmapping level
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     * @param width - Data width. if it's empty, width is the width corresponding to mipLevel minus x , width corresponding to mipLevel is Math.max(1, this.width >> mipLevel)
+     * @param height - Data height. if it's empty, height is the height corresponding to mipLevel minus y , height corresponding to mipLevel is Math.max(1, this.height >> mipLevel)
+     */
+    setPixelBuffer(colorBuffer: ArrayBufferView, mipLevel?: number, x?: number, y?: number, width?: number, height?: number): void;
+    /**
+     * Setting pixels data through TexImageSource, designated area and texture mipmapping level.
+     * @param imageSource - The source of texture
+     * @param mipLevel - Texture mipmapping level
+     * @param flipY - Whether to flip the Y axis
+     * @param premultiplyAlpha - Whether to premultiply the transparent channel
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     */
+    setImageSource(imageSource: TexImageSource | OffscreenCanvas, mipLevel?: number, flipY?: boolean, premultiplyAlpha?: boolean, x?: number, y?: number): void;
+    /**
+     * Get pixel color buffer.
+     * @param out - Color buffer
+     */
+    getPixelBuffer(out: ArrayBufferView): void;
+    /**
+     * Get the pixel color buffer according to the specified mip level.
+     * @param mipLevel - Tet mip level want to get
+     * @param out - Color buffer
+     */
+    getPixelBuffer(mipLevel: number, out: ArrayBufferView): void;
+    /**
+     * Get the pixel color buffer according to the specified area.
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     * @param width - Area width
+     * @param height - Area height
+     * @param out - Color buffer
+     */
+    getPixelBuffer(x: number, y: number, width: number, height: number, out: ArrayBufferView): void;
+    /**
+     * Get the pixel color buffer according to the specified area and mip level.
+     * @param x - X coordinate of area start
+     * @param y - Y coordinate of area start
+     * @param width - Area width
+     * @param height - Area height
+     * @param mipLevel - Tet mip level want to get
+     * @param out - Color buffer
+     */
+    getPixelBuffer(x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+}