@galacean/engine-core 1.6.8 → 1.6.9

package/types/sky/SkyProceduralMaterial.d.ts

@@ -0,0 +1,72 @@
+import { Color } from "@galacean/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);
+    /**
+     * @inheritDoc
+     */
+    clone(): SkyProceduralMaterial;
+}

package/types/sky/index.d.ts

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

package/types/texture/RenderTarget.d.ts

@@ -0,0 +1,91 @@
+import { GraphicsResource } from "../asset/GraphicsResource";
+import { Engine } from "../Engine";
+import { RenderBufferDepthFormat } from "./enums/RenderBufferDepthFormat";
+import { TextureFormat } from "./enums/TextureFormat";
+import { Texture } from "./Texture";
+/**
+ * The render target used for off-screen rendering.
+ */
+export declare class RenderTarget extends GraphicsResource {
+    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 TextureFormat.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?: TextureFormat | null | RenderBufferDepthFormat, 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 TextureFormat.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?: TextureFormat | null | RenderBufferDepthFormat, 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 - Render color texture index
+     */
+    getColorTexture(index?: number): Texture | null;
+    /**
+     * Generate the mipmap of each attachment texture of the renderTarget according to the configuration.
+     */
+    generateMipmaps(): void;
+}

package/types/texture/Texture.d.ts

@@ -0,0 +1,87 @@
+import { GraphicsResource } from "../asset/GraphicsResource";
+import { Engine } from "../Engine";
+import { TextureDepthCompareFunction } from "./enums/TextureDepthCompareFunction";
+import { TextureFilterMode } from "./enums/TextureFilterMode";
+import { TextureFormat } from "./enums/TextureFormat";
+import { TextureUsage } from "./enums/TextureUsage";
+import { TextureWrapMode } from "./enums/TextureWrapMode";
+/**
+ * The base class of texture, contains some common functions of texture-related classes.
+ */
+export declare abstract class Texture extends GraphicsResource {
+    name: string;
+    protected _format: TextureFormat;
+    protected _width: number;
+    protected _height: number;
+    protected _usage: TextureUsage;
+    protected _mipmapCount: number;
+    protected _isSRGBColorSpace: boolean;
+    private _wrapModeU;
+    private _wrapModeV;
+    private _filterMode;
+    private _anisoLevel;
+    private _depthCompareFunction;
+    private _useDepthCompareMode;
+    /**
+     * Whether the texture data is in sRGB color space, otherwise is linear color space.
+     */
+    get isSRGBColorSpace(): boolean;
+    /**
+     * Texture format.
+     */
+    get format(): TextureFormat;
+    /**
+     * The width of the texture.
+     */
+    get width(): number;
+    /**
+     * The height of the texture.
+     */
+    get height(): number;
+    /**
+     * The usage of the texture.
+     */
+    get usage(): TextureUsage;
+    /**
+     * 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);
+    constructor(engine: Engine, width: number, height: number, format: TextureFormat, mipmap: boolean, isSRGBColorSpace: boolean);
+    /**
+     * Generate multi-level textures based on the 0th level data.
+     */
+    generateMipmaps(): 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;
+    protected _isIntFormat(): boolean;
+}

package/types/texture/Texture2D.d.ts

@@ -0,0 +1,71 @@
+import { Engine } from "../Engine";
+import { TextureFormat } from "./enums/TextureFormat";
+import { TextureUsage } from "./enums/TextureUsage";
+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
+     * @param isSRGBColorSpace - Whether the texture data is in sRGB color space, otherwise is linear color space. @defaultValue `true`
+     * @param usage - Texture usage
+     */
+    constructor(engine: Engine, width: number, height: number, format?: TextureFormat, mipmap?: boolean, isSRGBColorSpace?: boolean, usage?: TextureUsage);
+    /**
+     * 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, 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;
+}

package/types/texture/Texture2DArray.d.ts

@@ -0,0 +1,82 @@
+import { Engine } from "../Engine";
+import { TextureFormat } from "./enums/TextureFormat";
+import { Texture } from "./Texture";
+/**
+ * Two-dimensional texture array.
+ */
+export declare class Texture2DArray extends Texture {
+    private readonly _length;
+    /**
+     * The length of the texture.
+     */
+    get length(): number;
+    /**
+     * Create Texture2D Array.
+     * @param engine - Define the engine to use to render this texture
+     * @param width - Texture width
+     * @param height - Texture height
+     * @param length - Texture length
+     * @param format - Texture format. default `TextureFormat.R8G8B8A8`
+     * @param mipmap - Whether to use multi-level texture
+     * @param isSRGBColorSpace - Whether the texture data is in sRGB color space, otherwise is linear color space. @defaultValue `true`
+     */
+    constructor(engine: Engine, width: number, height: number, length: number, format?: TextureFormat, mipmap?: boolean, isSRGBColorSpace?: 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 offsetIndex - The texture array element offset index
+     * @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)
+     * @param length - Data length. if it's empty, length is the length of Texture2DArray.length
+     */
+    setPixelBuffer(offsetIndex: number, colorBuffer: ArrayBufferView, mipLevel?: number, x?: number, y?: number, width?: number, height?: number, length?: number): void;
+    /**
+     * Setting pixels data through TexImageSource, designated area and texture mipmapping level.
+     * @param elementIndex - The texture array element index
+     * @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(elementIndex: number, imageSource: TexImageSource, mipLevel?: number, flipY?: boolean, premultiplyAlpha?: boolean, x?: number, y?: number): void;
+    /**
+     * Get pixel color buffer.
+     * @param elementIndex - The texture array element index
+     * @param out - Color buffer
+     */
+    getPixelBuffer(elementIndex: number, out: ArrayBufferView): void;
+    /**
+     * Get the pixel color buffer according to the specified mip level.
+     * @param elementIndex - The texture array element index
+     * @param mipLevel - Tet mip level want to get
+     * @param out - Color buffer
+     */
+    getPixelBuffer(elementIndex: number, mipLevel: number, out: ArrayBufferView): void;
+    /**
+     * Get the pixel color buffer according to the specified area.
+     * @param elementIndex - The texture array element index
+     * @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(elementIndex: number, 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 elementIndex - The texture array element index
+     * @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(elementIndex: number, x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+}

package/types/texture/TextureCube.d.ts

@@ -0,0 +1,71 @@
+import { Engine } from "../Engine";
+import { TextureCubeFace } from "./enums/TextureCubeFace";
+import { TextureFormat } from "./enums/TextureFormat";
+import { Texture } from "./Texture";
+/**
+ * Cube texture.
+ */
+export declare class TextureCube extends Texture {
+    /**
+     * Create TextureCube.
+     * @param engine - Define the engine to use to render this texture
+     * @param size - Texture size. texture width must be equal to height in cube texture
+     * @param format - Texture format,default TextureFormat.R8G8B8A8
+     * @param mipmap - Whether to use multi-level texture
+     * @param isSRGBColorSpace - Whether the texture data is in sRGB color space, otherwise is linear color space. @defaultValue `true`
+     */
+    constructor(engine: Engine, size: number, format?: TextureFormat, mipmap?: boolean, isSRGBColorSpace?: boolean);
+    /**
+     * Setting pixels data through cube face,color buffer data, designated area and texture mipmapping level,it's also applicable to compressed formats.
+     * @remarks When compressed texture is in WebGL1, the texture must be filled first before writing the sub-region
+     * @param face - Cube face
+     * @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(face: TextureCubeFace, colorBuffer: ArrayBufferView, mipLevel?: number, x?: number, y?: number, width?: number, height?: number): void;
+    /**
+     * Setting pixels data through cube face, TexImageSource, designated area and texture mipmapping level.
+     * @param face - Cube face
+     * @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(face: TextureCubeFace, imageSource: TexImageSource, mipLevel?: number, flipY?: boolean, premultiplyAlpha?: boolean, x?: number, y?: number): void;
+    /**
+     * Get pixel color buffer.
+     * @param out - Color buffer
+     */
+    getPixelBuffer(face: TextureCubeFace, 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(face: TextureCubeFace, 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(face: TextureCubeFace, 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(face: TextureCubeFace, x: number, y: number, width: number, height: number, mipLevel: number, out: ArrayBufferView): void;
+}

package/types/texture/TextureUtils.d.ts

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

package/types/texture/enums/RenderBufferDepthFormat.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @deprecated Please use `TextureFormat` instead.
+ *
+ * Render buffer depth format enumeration.
+ */
+export declare enum RenderBufferDepthFormat {
+    /** Render to depth buffer,engine will automatically select the supported precision. */
+    Depth = 27,
+    /** Render to stencil buffer. */
+    Stencil = 28,
+    /** Render to depth stencil buffer, engine will automatically select the supported precision. */
+    DepthStencil = 29,
+    /** Force 16-bit depth buffer. */
+    Depth16 = 30,
+    /** Force 24-bit depth buffer. */
+    Depth24 = 31,
+    /** Force 32-bit depth buffer. */
+    Depth32 = 32,
+    /** Force 16-bit depth + 8-bit stencil buffer. */
+    Depth24Stencil8 = 33,
+    /** Force 32-bit depth + 8-bit stencil buffer. */
+    Depth32Stencil8 = 34
+}

package/types/texture/enums/TextureCubeFace.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Define the face of the cube texture.
+ */
+export declare enum TextureCubeFace {
+    /** Positive X face for a cube-mapped texture. */
+    PositiveX = 0,
+    /** Negative X face for a cube-mapped texture. */
+    NegativeX = 1,
+    /** Positive Y face for a cube-mapped texture. */
+    PositiveY = 2,
+    /** Negative Y face for a cube-mapped texture. */
+    NegativeY = 3,
+    /** Positive Z face for a cube-mapped texture. */
+    PositiveZ = 4,
+    /** Negative Z face for a cube-mapped texture. */
+    NegativeZ = 5
+}

package/types/texture/enums/TextureDepthCompareFunction.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Define the compare mode of depth texture.
+ */
+export declare enum TextureDepthCompareFunction {
+    /** never pass. */
+    Never = 0,
+    /** pass if the compare value is less than the sample value. */
+    Less = 1,
+    /** pass if the compare value equals the sample value. */
+    Equal = 2,
+    /** pass if the compare value is less than or equal to the sample value. */
+    LessEqual = 3,
+    /** pass if the compare value is greater than the sample value. */
+    Greater = 4,
+    /** pass if the compare value is not equal to the sample value. */
+    NotEqual = 5,
+    /** pass if the compare value is greater than or equal to the sample value. */
+    GreaterEqual = 6,
+    /** always pass. */
+    Always = 7
+}

package/types/texture/enums/TextureFilterMode.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The filter mode of the texture.
+ */
+export declare enum TextureFilterMode {
+    /** Point filtering. */
+    Point = 0,
+    /** Bilinear filtering. */
+    Bilinear = 1,
+    /** Trilinear filtering. */
+    Trilinear = 2
+}

package/types/texture/enums/TextureFormat.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Texture format enumeration.
+ */
+export declare enum TextureFormat {
+    /** RGB format, 8 bits per channel. */
+    R8G8B8 = 0,
+    /** RGBA format, 8 bits per channel. */
+    R8G8B8A8 = 1,
+    /** RGBA format, 4 bits per channel. */
+    R4G4B4A4 = 2,
+    /** RGBA format, 5 bits in R channel, 5 bits in G channel, 5 bits in B channel, 1 bit in A channel. */
+    R5G5B5A1 = 3,
+    /** RGB format, 5 bits in R channel, 6 bits in G channel, 5 bits in B channel. */
+    R5G6B5 = 4,
+    /** RGBA format, 16 bits per channel. */
+    R16G16B16A16 = 7,
+    /** RGBA format, 32 bits per channel. */
+    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,
+    /** R float format, 8 bits. */
+    R8 = 36,
+    /** RG float format, 8 bits per channel. */
+    R8G8 = 37,
+    /** RGB compressed format, 4 bits per pixel. */
+    BC1 = 10,
+    /** RGBA compressed format, 8 bits per pixel. */
+    BC3 = 11,
+    /** RGB(A) compressed format, 128 bits per 4x4 pixel block. */
+    BC7 = 12,
+    /** RGB HDR compressed format, 8 bits per pixel. */
+    BC6H = 100,
+    /** RGB compressed format, 4 bits per pixel. */
+    ETC1_RGB = 13,
+    /** RGB compressed format, 4 bits per pixel. */
+    ETC2_RGB = 14,
+    /** RGBA compressed format, 5 bits per pixel, 4 bit in RGB, 1 bit in A. */
+    ETC2_RGBA5 = 15,
+    /** RGB compressed format, 8 bits per pixel. */
+    ETC2_RGBA8 = 16,
+    /** RGB compressed format, 2 bits per pixel. */
+    PVRTC_RGB2 = 17,
+    /** RGBA compressed format, 2 bits per pixel. */
+    PVRTC_RGBA2 = 18,
+    /** RGB compressed format, 4 bits per pixel. */
+    PVRTC_RGB4 = 19,
+    /** RGBA compressed format, 4 bits per pixel. */
+    PVRTC_RGBA4 = 20,
+    /** RGB(A) compressed format, 128 bits per 4x4 pixel block. */
+    ASTC_4x4 = 21,
+    /** RGB(A) compressed format, 128 bits per 5x5 pixel block. */
+    ASTC_5x5 = 22,
+    /** RGB(A) compressed format, 128 bits per 6x6 pixel block. */
+    ASTC_6x6 = 23,
+    /** RGB(A) compressed format, 128 bits per 8x8 pixel block. */
+    ASTC_8x8 = 24,
+    /** RGB(A) compressed format, 128 bits per 10x10 pixel block. */
+    ASTC_10x10 = 25,
+    /** RGB(A) compressed format, 128 bits per 12x12 pixel block. */
+    ASTC_12x12 = 26,
+    /** Automatic depth format, engine will automatically select the supported precision. */
+    Depth = 27,
+    /** Render to stencil buffer. */
+    Stencil = 28,
+    /** Automatic depth stencil format, engine will automatically select the supported precision. */
+    DepthStencil = 29,
+    /** 16-bit depth format. */
+    Depth16 = 30,
+    /** 24-bit depth format. */
+    Depth24 = 31,
+    /** 32-bit depth format. */
+    Depth32 = 32,
+    /** 16-bit depth + 8-bit stencil format. */
+    Depth24Stencil8 = 33,
+    /** 32-bit depth + 8-bit stencil format. */
+    Depth32Stencil8 = 34,
+    /** @deprecated Use 'TextureFormat.R8' instead. */
+    Alpha8 = 5,
+    /** @deprecated Use 'TextureFormat.R8G8' instead. */
+    LuminanceAlpha = 6,
+    /** @deprecated Use `TextureFormat.BC1` instead. */
+    DXT1 = 10,
+    /** @deprecated Use `TextureFormat.BC3` instead. */
+    DXT5 = 11
+}

package/types/texture/enums/TextureUsage.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Texture usage.
+ */
+export declare enum TextureUsage {
+    /** The content of the texture is intended to be specified once.  */
+    Static = 0,
+    /** The content of the texture is intended to be updated frequently, with better performance. */
+    Dynamic = 1
+}

package/types/texture/enums/TextureWrapMode.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Wrapping mode of the texture.
+ */
+export declare enum TextureWrapMode {
+    /** Clamping mode. use the color of edge pixels beyond the texture boundary. */
+    Clamp = 0,
+    /** Repeating mode. tiling will be repeated if it exceeds the texture boundary. */
+    Repeat = 1,
+    /** Mirror repeat mode. tiling will be mirrored and repeated if it exceeds the texture boundary. */
+    Mirror = 2
+}