@zephyr3d/device 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3873 @@
+import { TypedArray, IEventTarget, CubeFace, VectorBase, Vector4 } from '@zephyr3d/base';
+
+/**
+ * Struct layout types
+ * @public
+ */
+type PBStructLayout = 'default' | 'std140' | 'std430' | 'packed';
+/**
+ * Primitive types
+ * @public
+ */
+declare enum PBPrimitiveType {
+    NONE = 0,
+    F16,
+    F16VEC2,
+    F16VEC3,
+    F16VEC4,
+    F32,
+    F32VEC2,
+    F32VEC3,
+    F32VEC4,
+    BOOL,
+    BVEC2,
+    BVEC3,
+    BVEC4,
+    I8,
+    I8VEC2,
+    I8VEC3,
+    I8VEC4,
+    I8_NORM,
+    I8VEC2_NORM,
+    I8VEC3_NORM,
+    I8VEC4_NORM,
+    I16,
+    I16VEC2,
+    I16VEC3,
+    I16VEC4,
+    I16_NORM,
+    I16VEC2_NORM,
+    I16VEC3_NORM,
+    I16VEC4_NORM,
+    I32,
+    I32VEC2,
+    I32VEC3,
+    I32VEC4,
+    I32_NORM,
+    I32VEC2_NORM,
+    I32VEC3_NORM,
+    I32VEC4_NORM,
+    U8,
+    U8VEC2,
+    U8VEC3,
+    U8VEC4,
+    U8_NORM,
+    U8VEC2_NORM,
+    U8VEC3_NORM,
+    U8VEC4_NORM,
+    U16,
+    U16VEC2,
+    U16VEC3,
+    U16VEC4,
+    U16_NORM,
+    U16VEC2_NORM,
+    U16VEC3_NORM,
+    U16VEC4_NORM,
+    U32,
+    U32VEC2,
+    U32VEC3,
+    U32VEC4,
+    U32_NORM,
+    U32VEC2_NORM,
+    U32VEC3_NORM,
+    U32VEC4_NORM,
+    MAT2,
+    MAT2x3,
+    MAT2x4,
+    MAT3x2,
+    MAT3,
+    MAT3x4,
+    MAT4x2,
+    MAT4x3,
+    MAT4
+}
+/**
+ * Texture types
+ * @public
+ */
+declare enum PBTextureType {
+    TEX_1D = 257,
+    ITEX_1D = 513,
+    UTEX_1D = 1025,
+    TEX_2D = 258,
+    ITEX_2D = 514,
+    UTEX_2D = 1026,
+    TEX_2D_ARRAY = 274,
+    ITEX_2D_ARRAY = 530,
+    UTEX_2D_ARRAY = 1042,
+    TEX_3D = 260,
+    ITEX_3D = 516,
+    UTEX_3D = 1028,
+    TEX_CUBE = 264,
+    ITEX_CUBE = 520,
+    UTEX_CUBE = 1032,
+    TEX_CUBE_ARRAY = 280,
+    ITEX_CUBE_ARRAY = 536,
+    UTEX_CUBE_ARRAY = 1048,
+    TEX_MULTISAMPLED_2D = 290,
+    ITEX_MULTISAMPLED_2D = 546,
+    UTEX_MULTISAMPLED_2D = 1058,
+    TEX_STORAGE_1D = 65,
+    TEX_STORAGE_2D = 66,
+    TEX_STORAGE_2D_ARRAY = 82,
+    TEX_STORAGE_3D = 68,
+    TEX_DEPTH_2D = 130,
+    TEX_DEPTH_2D_ARRAY = 146,
+    TEX_DEPTH_CUBE = 136,
+    TEX_DEPTH_CUBE_ARRAY = 152,
+    TEX_DEPTH_MULTISAMPLED_2D = 162,
+    TEX_EXTERNAL = 2048
+}
+/**
+ * Sampler access mode
+ * @public
+ */
+declare enum PBSamplerAccessMode {
+    UNKNOWN = 0,
+    SAMPLE = 1,
+    COMPARISON = 2
+}
+/**
+ * Shader variable address space
+ * @public
+ */
+declare enum PBAddressSpace {
+    UNKNOWN = "unknown",
+    FUNCTION = "function",
+    PRIVATE = "private",
+    WORKGROUP = "workgroup",
+    UNIFORM = "uniform",
+    STORAGE = "storage"
+}
+/**
+ * Type detail information
+ * @public
+ */
+type TypeDetailInfo = PrimitiveTypeDetail | StructTypeDetail | ArrayTypeDetail | PointerTypeDetail | AtomicTypeInfoDetail | SamplerTypeDetail | TextureTypeDetail | FunctionTypeDetail | null;
+/**
+ * Detail informations for primitive type
+ * @public
+ */
+interface PrimitiveTypeDetail {
+    primitiveType?: PBPrimitiveType;
+}
+/**
+ * Detail informations for struct type
+ * @public
+ */
+interface StructTypeDetail {
+    /** Layout of the struct type */
+    layout: PBStructLayout;
+    /** Name of the struct type */
+    structName?: string;
+    /** Members of the struct type */
+    structMembers?: {
+        /** Name of the struct member */
+        name: string;
+        /** Type of the struct member */
+        type: PBPrimitiveTypeInfo | PBArrayTypeInfo | PBAtomicI32TypeInfo | PBAtomicU32TypeInfo | PBStructTypeInfo;
+        /** Alignment of the struct member */
+        alignment: number;
+        /** Byte size of the struct member */
+        size: number;
+    }[];
+}
+/**
+ * Detail informations for array type
+ * @public
+ */
+interface ArrayTypeDetail {
+    /** Type of array elements */
+    elementType: PBPrimitiveTypeInfo | PBArrayTypeInfo | PBStructTypeInfo | PBAnyTypeInfo;
+    /** Array dimension */
+    dimension: number;
+}
+/**
+ * Detail informations for pointer type
+ * @public
+ */
+interface PointerTypeDetail {
+    /** Type of the pointer */
+    pointerType: PBTypeInfo;
+    /** Address space of the pointer */
+    addressSpace: PBAddressSpace;
+}
+/**
+ * Detail information for atomic type
+ * @public
+ */
+interface AtomicTypeInfoDetail {
+    /** Primitive type of the atomic type */
+    type: PBPrimitiveType;
+}
+/**
+ * Detail informations for sampler type
+ * @public
+ */
+interface SamplerTypeDetail {
+    /** Access mode of the sampler type */
+    accessMode: PBSamplerAccessMode;
+}
+/**
+ * Detail informations for texture type
+ * @public
+ */
+interface TextureTypeDetail {
+    /** type of the texture */
+    textureType: PBTextureType;
+    /** texture format if this is a storage texture */
+    storageTexelFormat: TextureFormat;
+    /** true if this is a readable storage texture type */
+    readable: boolean;
+    /** true if this is a writable storage texture type */
+    writable: boolean;
+}
+/**
+ * Detail information for a function type
+ * @public
+ */
+interface FunctionTypeDetail {
+    /** The function name */
+    name: string;
+    /** Return type of the function */
+    returnType: PBTypeInfo;
+    /** Type information for function arguments */
+    argTypes: {
+        /** Type of the argument */
+        type: PBTypeInfo;
+        /** true if this argument will be passed by reference */
+        byRef?: boolean;
+    }[];
+}
+/**
+ * Abstract base class for any type
+ * @public
+ */
+declare abstract class PBTypeInfo<DetailType extends TypeDetailInfo = TypeDetailInfo> {
+    /** Get unique id for this type */
+    get typeId(): string;
+    /** returns true if this is a void type */
+    isVoidType(): this is PBVoidTypeInfo;
+    /** returns true if this is an any type */
+    isAnyType(): this is PBAnyTypeInfo;
+    /** returns true if this is a primitive type */
+    isPrimitiveType(): this is PBPrimitiveTypeInfo;
+    /** returns true if this is a struct type */
+    isStructType(): this is PBStructTypeInfo;
+    /** returns true if this is an array type */
+    isArrayType(): this is PBArrayTypeInfo;
+    /** returns true if this is a pointer type */
+    isPointerType(): this is PBPointerTypeInfo;
+    /** returns true if this is an atomic int type */
+    isAtomicI32(): this is PBAtomicI32TypeInfo;
+    /** returns true if this is an atomic uint type */
+    isAtomicU32(): this is PBAtomicU32TypeInfo;
+    /** returns true if this is a sampler type */
+    isSamplerType(): this is PBSamplerTypeInfo;
+    /** returns true if this is a texture type */
+    isTextureType(): this is PBTextureTypeInfo;
+    /**
+     * Check whether a given type is compatible with this type
+     * @param other - The type to be checked
+     * @returns true if the given type is compatible with this type, othewise false
+     */
+    isCompatibleType(other: PBTypeInfo): boolean;
+    /**
+    * Creates a buffer layout from this type
+    * @param offset - Byte offset of the layout
+    * @param layout - Type of the layout
+    * @returns The created buffer layout
+    */
+    abstract toBufferLayout(offset: number, layout: PBStructLayout): UniformBufferLayout;
+}
+/**
+ * The void type info
+ * @public
+ */
+declare class PBVoidTypeInfo extends PBTypeInfo<null> {
+    constructor();
+    /** {@inheritDoc PBTypeInfo.isVoidType} */
+    isVoidType(): this is PBVoidTypeInfo;
+    /** {@inheritDoc PBTypeInfo.toBufferLayout} */
+    toBufferLayout(offset: number): UniformBufferLayout;
+}
+/**
+ * The void type info
+ * @public
+ */
+declare class PBAnyTypeInfo extends PBTypeInfo<null> {
+    constructor();
+    /** {@inheritDoc PBTypeInfo.isAnyType} */
+    isAnyType(): this is PBAnyTypeInfo;
+    /** {@inheritDoc PBTypeInfo.toBufferLayout} */
+    toBufferLayout(offset: number): UniformBufferLayout;
+    /** {@inheritDoc PBTypeInfo.isCompatibleType} */
+    isCompatibleType(other: PBTypeInfo<TypeDetailInfo>): boolean;
+}
+/**
+ * The primitive type info
+ * @public
+ */
+declare class PBPrimitiveTypeInfo extends PBTypeInfo<PrimitiveTypeDetail> {
+    constructor(type: PBPrimitiveType);
+    /** Get or create a PBPrimitiveTypeInfo instance for a given prmitive type */
+    static getCachedTypeInfo(primitiveType: PBPrimitiveType): PBPrimitiveTypeInfo;
+    /** Get the primitive type */
+    get primitiveType(): PBPrimitiveType;
+    /** Whether the type is signed or unsigned integer scalar or vector */
+    isInteger(): boolean;
+    /** Get the scalar type */
+    get scalarType(): PBPrimitiveType;
+    /** Get number of rows */
+    get rows(): number;
+    /** Get number of columns */
+    get cols(): number;
+    /** Get if this is a normalized primitive type */
+    get normalized(): boolean;
+    /**
+     * Creates a new primitive type info by changing row and column of this type
+     * @param rows - The new value of row
+     * @param cols - The new value of column
+     * @returns The new primitive type
+     */
+    resizeType(rows: number, cols: number): PBPrimitiveType;
+    /** Returns true if this is a scalar type */
+    isScalarType(): boolean;
+    /** Returns true if this is a vector type */
+    isVectorType(): boolean;
+    /** Returns true if this is a matrix type */
+    isMatrixType(): boolean;
+    /** {@inheritDoc PBTypeInfo.isPrimitiveType} */
+    isPrimitiveType(): this is PBPrimitiveTypeInfo;
+    /** {@inheritDoc PBTypeInfo.toBufferLayout} */
+    toBufferLayout(offset: number): UniformBufferLayout;
+}
+/**
+ * The struct type info
+ * @public
+ */
+declare class PBStructTypeInfo extends PBTypeInfo<StructTypeDetail> {
+    constructor(name: string, layout: PBStructLayout, members: {
+        name: string;
+        type: PBPrimitiveTypeInfo | PBArrayTypeInfo | PBAtomicI32TypeInfo | PBAtomicU32TypeInfo | PBStructTypeInfo;
+    }[]);
+    /** Get the layout type */
+    get layout(): PBStructLayout;
+    /** Get name of the struct type */
+    get structName(): string;
+    set structName(val: string);
+    /** Get member types of the struct type */
+    get structMembers(): {
+        /** Name of the struct member */
+        name: string;
+        /** Type of the struct member */
+        type: PBPrimitiveTypeInfo | PBArrayTypeInfo | PBStructTypeInfo | PBAtomicI32TypeInfo | PBAtomicU32TypeInfo;
+        /** Alignment of the struct member */
+        alignment: number;
+        /** Byte size of the struct member */
+        size: number;
+        /** @internal */
+        defaultAlignment: number;
+        /** @internal */
+        defaultSize: number;
+    }[];
+    /**
+     * Creates a new struct type by extending this type
+     * @param name - Name of the new struct type
+     * @param members - additional struct members
+     * @returns The new struct type
+     */
+    extends(name: string, members: {
+        name: string;
+        type: PBPrimitiveTypeInfo | PBArrayTypeInfo | PBStructTypeInfo;
+    }[]): PBStructTypeInfo;
+    /** {@inheritDoc PBTypeInfo.isStructType} */
+    isStructType(): this is PBStructTypeInfo;
+    /** {@inheritDoc PBTypeInfo.toBufferLayout} */
+    toBufferLayout(offset: number, layout: PBStructLayout): UniformBufferLayout;
+}
+/**
+ * The array type info
+ * @public
+ */
+declare class PBArrayTypeInfo extends PBTypeInfo<ArrayTypeDetail> {
+    constructor(elementType: PBPrimitiveTypeInfo | PBArrayTypeInfo | PBStructTypeInfo | PBAnyTypeInfo, dimension?: number);
+    /** Get the element type */
+    get elementType(): PBPrimitiveTypeInfo | PBArrayTypeInfo | PBStructTypeInfo | PBAnyTypeInfo;
+    /** Get dimension of the array type */
+    get dimension(): number;
+    /** {@inheritDoc PBTypeInfo.isArrayType} */
+    isArrayType(): this is PBArrayTypeInfo;
+    /** {@inheritDoc PBTypeInfo.toBufferLayout} */
+    toBufferLayout(offset: number): UniformBufferLayout;
+    isCompatibleType(other: PBTypeInfo<TypeDetailInfo>): boolean;
+}
+/**
+ * The pointer type info
+ * @public
+ */
+declare class PBPointerTypeInfo extends PBTypeInfo<PointerTypeDetail> {
+    constructor(pointerType: PBTypeInfo, addressSpace: PBAddressSpace);
+    /** Get type of the pointer */
+    get pointerType(): PBTypeInfo;
+    /** Get address space of the pointer */
+    get addressSpace(): PBAddressSpace;
+    set addressSpace(val: PBAddressSpace);
+    /** {@inheritDoc PBTypeInfo.isPointerType} */
+    isPointerType(): this is PBPointerTypeInfo;
+    /** {@inheritDoc PBTypeInfo.toBufferLayout} */
+    toBufferLayout(offset: number): UniformBufferLayout;
+}
+/**
+ * The atomic int type info
+ * @public
+ */
+declare class PBAtomicI32TypeInfo extends PBTypeInfo<null> {
+    constructor();
+    /** {@inheritDoc PBTypeInfo.toBufferLayout} */
+    toBufferLayout(offset: number): UniformBufferLayout;
+}
+/**
+ * The atomic int type info
+ * @public
+ */
+declare class PBAtomicU32TypeInfo extends PBTypeInfo<null> {
+    constructor();
+    /** {@inheritDoc PBTypeInfo.toBufferLayout} */
+    toBufferLayout(offset: number): UniformBufferLayout;
+}
+/**
+ * The sampler type info
+ * @public
+ */
+declare class PBSamplerTypeInfo extends PBTypeInfo<SamplerTypeDetail> {
+    constructor(accessMode: PBSamplerAccessMode);
+    /** Get the access mode */
+    get accessMode(): PBSamplerAccessMode;
+    /** {@inheritDoc PBTypeInfo.toBufferLayout} */
+    toBufferLayout(offset: number): UniformBufferLayout;
+}
+/**
+ * The texture type info
+ * @public
+ */
+declare class PBTextureTypeInfo extends PBTypeInfo<TextureTypeDetail> {
+    constructor(textureType: PBTextureType, texelFormat?: TextureFormat, readable?: boolean, writable?: boolean);
+    /** Get the texture type */
+    get textureType(): PBTextureType;
+    /** Get texture format if this is a storage texture */
+    get storageTexelFormat(): TextureFormat;
+    /** Returns true if this is a readable storage texture type */
+    get readable(): boolean;
+    /** Returns true if this is a writable storage texture type */
+    get writable(): boolean;
+    /** Returns true if this is a 2D texture type */
+    is2DTexture(): boolean;
+    /** Returns true if this is a 3D texture type */
+    is3DTexture(): boolean;
+    /** Returns true if this is a cube texture type */
+    isCubeTexture(): boolean;
+    /** Returns true if this is an array texture type */
+    isArrayTexture(): boolean;
+    /** Returns true if this is a storage texture type */
+    isStorageTexture(): boolean;
+    /** Return s true if this is a depth texture type */
+    isDepthTexture(): boolean;
+    /** Returns true if this is a multisampled texture type */
+    isMultisampledTexture(): boolean;
+    /** Returns true if this is an external texture type */
+    isExternalTexture(): boolean;
+    /** Returns true if the texture format is of type integer  */
+    isIntTexture(): boolean;
+    /** Returns true if the texture format is of type unsigned integer  */
+    isUIntTexture(): boolean;
+    /** {@inheritDoc PBTypeInfo.toBufferLayout} */
+    toBufferLayout(offset: number): UniformBufferLayout;
+}
+/**
+ * The function type info
+ * @public
+ */
+declare class PBFunctionTypeInfo extends PBTypeInfo<FunctionTypeDetail> {
+    constructor(name: string, returnType: PBTypeInfo, argTypes: {
+        type: PBTypeInfo;
+        byRef?: boolean;
+    }[]);
+    /** Get name of the function */
+    get name(): string;
+    /** Get return type of the function */
+    get returnType(): PBTypeInfo;
+    /** Get all the argument types for this function */
+    get argTypes(): {
+        type: PBTypeInfo;
+        byRef?: boolean;
+    }[];
+    /** Get hash for parameter types */
+    get argHash(): string;
+    /** {@inheritDoc PBTypeInfo.toBufferLayout} */
+    toBufferLayout(offset: number): UniformBufferLayout;
+}
+
+/**
+ * Vertex buffer information
+ * @public
+ */
+type VertexBufferInfo = {
+    buffer: StructuredBuffer;
+    offset: number;
+    stride: number;
+    drawOffset: number;
+    type: PBPrimitiveTypeInfo;
+    stepMode: VertexStepMode;
+};
+/**
+ * The vertex data class
+ * @public
+ */
+declare class VertexData {
+    constructor();
+    /**
+     * Creates a new instance of VertexData by copying from this object
+     * @returns New instance of VertexData
+     */
+    clone(): VertexData;
+    /** Vertex buffer information list */
+    get vertexBuffers(): VertexBufferInfo[];
+    /** Index buffer */
+    get indexBuffer(): IndexBuffer<unknown>;
+    /** Draw offset */
+    getDrawOffset(): number;
+    setDrawOffset(offset: number): void;
+    /**
+     * Gets the vertex buffer by specific vertex semantic
+     * @param semantic - The vertex semantic
+     * @returns Vertex buffer of the given semantic
+     */
+    getVertexBuffer(semantic: VertexSemantic): StructuredBuffer;
+    /**
+     * Gets the vertex buffer information by specific vertex semantic
+     * @param semantic - The vertex semantic
+     * @returns Vertex buffer information of the given semantic
+     */
+    getVertexBufferInfo(semantic: VertexSemantic): VertexBufferInfo;
+    /**
+     * Gets the index buffer
+     * @returns The index buffer
+     */
+    getIndexBuffer(): IndexBuffer;
+    /**
+     * Sets a vertex buffer
+     * @param buffer - The vertex buffer object
+     * @param stepMode - Step mode of the buffer
+     * @returns The buffer that was set
+     */
+    setVertexBuffer(buffer: StructuredBuffer, stepMode?: VertexStepMode): StructuredBuffer;
+    /**
+     * Removes a vertex buffer
+     * @param buffer - Vertex buffer to be removed
+     * @returns true if the buffer was successfully removed, otherwise false
+     */
+    removeVertexBuffer(buffer: StructuredBuffer): boolean;
+    /**
+     * Sets the index buffer
+     * @param buffer - Index buffer to be set
+     * @returns The index buffer that was set
+     */
+    setIndexBuffer(buffer: IndexBuffer): IndexBuffer;
+}
+
+/**
+ * The types of image element that can be uploaded to textures
+ * @public
+ */
+type TextureImageElement = ImageBitmap | HTMLCanvasElement;
+/**
+ * The vertex format types
+ * @public
+ */
+type VertexAttribFormat = 'position_u8normx2' | 'position_u8normx4' | 'position_i8normx2' | 'position_i8normx4' | 'position_u16x2' | 'position_u16x4' | 'position_i16x2' | 'position_i16x4' | 'position_u16normx2' | 'position_u16normx4' | 'position_i16normx2' | 'position_i16normx4' | 'position_f16x2' | 'position_f16x4' | 'position_f32' | 'position_f32x2' | 'position_f32x3' | 'position_f32x4' | 'position_i32' | 'position_i32x2' | 'position_i32x3' | 'position_i32x4' | 'position_u32' | 'position_u32x2' | 'position_u32x3' | 'position_u32x4' | 'normal_f16x4' | 'normal_f32x3' | 'normal_f32x4' | 'diffuse_u8normx4' | 'diffuse_u16x4' | 'diffuse_u16normx4' | 'diffuse_f16x4' | 'diffuse_f32x3' | 'diffuse_f32x4' | 'diffuse_u32x3' | 'diffuse_u32x4' | 'tangent_f16x4' | 'tangent_f32x3' | 'tangent_f32x4' | 'tex0_u8normx2' | 'tex0_u8normx4' | 'tex0_i8normx2' | 'tex0_i8normx4' | 'tex0_u16x2' | 'tex0_u16x4' | 'tex0_i16x2' | 'tex0_i16x4' | 'tex0_u16normx2' | 'tex0_u16normx4' | 'tex0_i16normx2' | 'tex0_i16normx4' | 'tex0_f16x2' | 'tex0_f16x4' | 'tex0_f32' | 'tex0_f32x2' | 'tex0_f32x3' | 'tex0_f32x4' | 'tex0_i32' | 'tex0_i32x2' | 'tex0_i32x3' | 'tex0_i32x4' | 'tex0_u32' | 'tex0_u32x2' | 'tex0_u32x3' | 'tex0_u32x4' | 'tex1_u8normx2' | 'tex1_u8normx4' | 'tex1_i8normx2' | 'tex1_i8normx4' | 'tex1_u16x2' | 'tex1_u16x4' | 'tex1_i16x2' | 'tex1_i16x4' | 'tex1_u16normx2' | 'tex1_u16normx4' | 'tex1_i16normx2' | 'tex1_i16normx4' | 'tex1_f16x2' | 'tex1_f16x4' | 'tex1_f32' | 'tex1_f32x2' | 'tex1_f32x3' | 'tex1_f32x4' | 'tex1_i32' | 'tex1_i32x2' | 'tex1_i32x3' | 'tex1_i32x4' | 'tex1_u32' | 'tex1_u32x2' | 'tex1_u32x3' | 'tex1_u32x4' | 'tex2_u8normx2' | 'tex2_u8normx4' | 'tex2_i8normx2' | 'tex2_i8normx4' | 'tex2_u16x2' | 'tex2_u16x4' | 'tex2_i16x2' | 'tex2_i16x4' | 'tex2_u16normx2' | 'tex2_u16normx4' | 'tex2_i16normx2' | 'tex2_i16normx4' | 'tex2_f16x2' | 'tex2_f16x4' | 'tex2_f32' | 'tex2_f32x2' | 'tex2_f32x3' | 'tex2_f32x4' | 'tex2_i32' | 'tex2_i32x2' | 'tex2_i32x3' | 'tex2_i32x4' | 'tex2_u32' | 'tex2_u32x2' | 'tex2_u32x3' | 'tex2_u32x4' | 'tex3_u8normx2' | 'tex3_u8normx4' | 'tex3_i8normx2' | 'tex3_i8normx4' | 'tex3_u16x2' | 'tex3_u16x4' | 'tex3_i16x2' | 'tex3_i16x4' | 'tex3_u16normx2' | 'tex3_u16normx4' | 'tex3_i16normx2' | 'tex3_i16normx4' | 'tex3_f16x2' | 'tex3_f16x4' | 'tex3_f32' | 'tex3_f32x2' | 'tex3_f32x3' | 'tex3_f32x4' | 'tex3_i32' | 'tex3_i32x2' | 'tex3_i32x3' | 'tex3_i32x4' | 'tex3_u32' | 'tex3_u32x2' | 'tex3_u32x3' | 'tex3_u32x4' | 'tex4_u8normx2' | 'tex4_u8normx4' | 'tex4_i8normx2' | 'tex4_i8normx4' | 'tex4_u16x2' | 'tex4_u16x4' | 'tex4_i16x2' | 'tex4_i16x4' | 'tex4_u16normx2' | 'tex4_u16normx4' | 'tex4_i16normx2' | 'tex4_i16normx4' | 'tex4_f16x2' | 'tex4_f16x4' | 'tex4_f32' | 'tex4_f32x2' | 'tex4_f32x3' | 'tex4_f32x4' | 'tex4_i32' | 'tex4_i32x2' | 'tex4_i32x3' | 'tex4_i32x4' | 'tex4_u32' | 'tex4_u32x2' | 'tex4_u32x3' | 'tex4_u32x4' | 'tex5_u8normx2' | 'tex5_u8normx4' | 'tex5_i8normx2' | 'tex5_i8normx4' | 'tex5_u16x2' | 'tex5_u16x4' | 'tex5_i16x2' | 'tex5_i16x4' | 'tex5_u16normx2' | 'tex5_u16normx4' | 'tex5_i16normx2' | 'tex5_i16normx4' | 'tex5_f16x2' | 'tex5_f16x4' | 'tex5_f32' | 'tex5_f32x2' | 'tex5_f32x3' | 'tex5_f32x4' | 'tex5_i32' | 'tex5_i32x2' | 'tex5_i32x3' | 'tex5_i32x4' | 'tex5_u32' | 'tex5_u32x2' | 'tex5_u32x3' | 'tex5_u32x4' | 'tex6_u8normx2' | 'tex6_u8normx4' | 'tex6_i8normx2' | 'tex6_i8normx4' | 'tex6_u16x2' | 'tex6_u16x4' | 'tex6_i16x2' | 'tex6_i16x4' | 'tex6_u16normx2' | 'tex6_u16normx4' | 'tex6_i16normx2' | 'tex6_i16normx4' | 'tex6_f16x2' | 'tex6_f16x4' | 'tex6_f32' | 'tex6_f32x2' | 'tex6_f32x3' | 'tex6_f32x4' | 'tex6_i32' | 'tex6_i32x2' | 'tex6_i32x3' | 'tex6_i32x4' | 'tex6_u32' | 'tex6_u32x2' | 'tex6_u32x3' | 'tex6_u32x4' | 'tex7_u8normx2' | 'tex7_u8normx4' | 'tex7_i8normx2' | 'tex7_i8normx4' | 'tex7_u16x2' | 'tex7_u16x4' | 'tex7_i16x2' | 'tex7_i16x4' | 'tex7_u16normx2' | 'tex7_u16normx4' | 'tex7_i16normx2' | 'tex7_i16normx4' | 'tex7_f16x2' | 'tex7_f16x4' | 'tex7_f32' | 'tex7_f32x2' | 'tex7_f32x3' | 'tex7_f32x4' | 'tex7_i32' | 'tex7_i32x2' | 'tex7_i32x3' | 'tex7_i32x4' | 'tex7_u32' | 'tex7_u32x2' | 'tex7_u32x3' | 'tex7_u32x4' | 'blendweights_f16x4' | 'blendweights_f32x4' | 'blendindices_u16x4' | 'blendindices_f16x4' | 'blendindices_f32x4' | 'blendindices_u32x4';
+/**
+ * The semantic type of vertex
+ * @public
+ */
+type VertexSemantic = 'position' | 'normal' | 'diffuse' | 'tangent' | 'blendIndices' | 'blendWeights' | 'texCoord0' | 'texCoord1' | 'texCoord2' | 'texCoord3' | 'texCoord4' | 'texCoord5' | 'texCoord6' | 'texCoord7';
+/**
+ * Options for creating vertex layout
+ * @public
+ */
+type VertexLayoutOptions = {
+    /**
+     * vertex buffers in this vertex layout
+     */
+    vertexBuffers: {
+        /**
+         * vertex buffer object created by device
+         */
+        buffer: StructuredBuffer;
+        /**
+         * the vertex buffer step mode,
+         * value can be 'vertex' or 'instance', default is 'vertex'
+         */
+        stepMode?: VertexStepMode;
+    }[];
+    /**
+     * optional index buffer in this vertex layout
+     */
+    indexBuffer?: IndexBuffer;
+};
+/**
+ * Supported colorspace types for texture
+ * @public
+ */
+type TextureColorSpace = 'srgb' | 'linear';
+/**
+ * Buffer usage type
+ * @public
+ */
+type BufferUsage = 'vertex' | 'index' | 'uniform' | 'read' | 'write';
+/**
+ * Common options for createing texture or buffer
+ * @public
+ */
+interface BaseCreationOptions {
+    /**
+     * Whether the object should be dynamic, default is false
+     */
+    dynamic?: boolean;
+}
+/**
+ * Options for creating texture
+ * @public
+ */
+interface TextureCreationOptions extends BaseCreationOptions {
+    writable?: boolean;
+    texture?: BaseTexture;
+    samplerOptions?: SamplerOptions;
+}
+/**
+ * Options for creating gpu buffer
+ * @public
+ */
+interface BufferCreationOptions extends BaseCreationOptions {
+    /** The buffer usage */
+    usage?: BufferUsage;
+    /** true if we are creating a storage buffer */
+    storage?: boolean;
+    /** Whether the object content should be managed, default true for vertex buffer of index buffer */
+    managed?: boolean;
+}
+/**
+ * The gpu resource usage flags
+ * @public
+ */
+declare enum GPUResourceUsageFlags {
+    TF_LINEAR_COLOR_SPACE = 2,
+    TF_NO_MIPMAP = 4,
+    TF_WRITABLE = 8,
+    TF_NO_GC = 16,
+    BF_VERTEX = 32,
+    BF_INDEX = 64,
+    BF_READ = 128,
+    BF_WRITE = 256,
+    BF_UNIFORM = 512,
+    BF_STORAGE = 1024,
+    DYNAMIC = 2048,
+    MANAGED = 4096
+}
+/**
+ * Get vertex format by semantic and component type and component count
+ * @param semantic - The vertex semantic
+ * @param type - Data type of vertex component
+ * @param count - The count of vertex components
+ * @returns Vertex format
+ * @public
+ */
+declare function getVertexAttribFormat(semantic: VertexSemantic, type: DataType, count: number): VertexAttribFormat;
+/**
+ * Get the length of a vertex buffer by specified structure type of the vertex buffer
+ * @param vertexBufferType - The structure type of the vertex buffer
+ * @returns The length of the vertex buffer
+ * @public
+ */
+declare function getVertexBufferLength(vertexBufferType: PBStructTypeInfo): number;
+/**
+ * Get byte stride of a vertex buffer by specified structure type of the vertex buffer
+ * @param vertexBufferType - The structure type of the vertex buffer
+ * @returns The byte stride of the vertex buffer
+ * @public
+ */
+declare function getVertexBufferStride(vertexBufferType: PBStructTypeInfo): number;
+/**
+ * Get primitive type of a vertex attribute by specified vertex semantic
+ * @param vertexBufferType - The structure type of the vertex buffer
+ * @param semantic - The vertex semantic
+ * @returns - The primitive type of the vertex attribute
+ * @public
+ */
+declare function getVertexBufferAttribTypeBySemantic(vertexBufferType: PBStructTypeInfo, semantic: VertexSemantic): PBPrimitiveTypeInfo;
+/**
+ * Get primitive type of a vertex attribute by specified vertex attribute index
+ * @param vertexBufferType - The structure type of the vertex buffer
+ * @param semantic - The vertex attribute index
+ * @returns - The primitive type of the vertex attribute
+ * @public
+ */
+declare function getVertexBufferAttribType(vertexBufferType: PBStructTypeInfo, attrib: number): PBPrimitiveTypeInfo;
+/**
+ * Get the structure type of a vertex buffer by specified vertex attribute formats and the length of the vertex buffer
+ * @param length - The length of the vertex buffer
+ * @param attributes - The vertex attributes
+ * @returns The structure type of the vertex buffer
+ * @public
+ */
+declare function makeVertexBufferType(length: number, ...attributes: VertexAttribFormat[]): PBStructTypeInfo;
+/**
+ * Vertex step mode.
+ * @public
+ */
+type VertexStepMode = 'vertex' | 'instance';
+/**
+ * Vertex semantic list
+ * @public
+ */
+declare const semanticList: string[];
+/**
+ * A data structure that holds the texture data of a mipmap level
+ * @public
+ */
+interface TextureMipmapLevelData {
+    /** The texture data */
+    data: TypedArray;
+    /** Width of the mipmap level */
+    width: number;
+    /** Height of the mipmap level */
+    height: number;
+}
+/**
+ * A data structure that holds the texture data of all mipmap levels
+ * @public
+ */
+interface TextureMipmapData {
+    /** Texture width of mipmap level 0 */
+    width: number;
+    /** Texture height of mipmap level 0 */
+    height: number;
+    /** Texture depth of mipmap level 0 */
+    depth: number;
+    /** true if it holds texture data for cube texture */
+    isCubemap: boolean;
+    /** true if it holds texture data for 3d texture */
+    isVolume: boolean;
+    /** true if it holds texture array */
+    isArray: boolean;
+    /** true if the texture data are in compressed format */
+    isCompressed: boolean;
+    /** The array size if it holds texture data for array texture  */
+    arraySize: number;
+    /** How many mipmap levels in the texture data */
+    mipLevels: number;
+    /** The texture format */
+    format: TextureFormat;
+    /** The mipmap level datas */
+    mipDatas: TextureMipmapLevelData[][];
+}
+/**
+ * Frame buffer texture attachment information
+ * @public
+ */
+interface FrameBufferTextureAttachment {
+    /** Texture for this attachment */
+    texture?: BaseTexture;
+    /** The attached face index for cube texture */
+    face?: number;
+    /** The layer index for array texture */
+    layer?: number;
+    /** Which mipmap level is currently attached */
+    level?: number;
+    /** Whether automatically generate mipmaps for color attachments */
+    generateMipmaps?: boolean;
+}
+/**
+ * The frame buffer creation options
+ * @public
+ */
+interface FrameBufferOptions {
+    /** Sample count of the frame buffer */
+    sampleCount?: number;
+    /** Whether to ignore the depth stencil attachment when resolving multisample frame buffer */
+    ignoreDepthStencil?: boolean;
+}
+/**
+ * The uniform buffer layout
+ * @public
+ */
+interface UniformBufferLayout {
+    /** Byte size of the uniform buffer */
+    byteSize: number;
+    /** Entries for the uniform buffer */
+    entries: UniformLayout[];
+}
+/**
+ * Layout of a uniform in a uniform buffer
+ * @public
+ */
+interface UniformLayout {
+    /** Name of the uniform */
+    name: string;
+    /** Byte offset of the uniform buffer */
+    offset: number;
+    /** Byte size of the uniform */
+    byteSize: number;
+    /** The array length if the uniform is array type */
+    arraySize: number;
+    /** The primitive type of the uniform */
+    type: PBPrimitiveType;
+    /** Layout of the members if the uniform is struct type */
+    subLayout: UniformBufferLayout;
+}
+/**
+ * Binding layout of a uniform buffer or storage buffer
+ * @public
+ */
+interface BufferBindingLayout {
+    /** The bind type */
+    type?: 'uniform' | 'storage' | 'read-only-storage';
+    /** Whether the buffer should be accessed by a dynamic offset */
+    hasDynamicOffset: boolean;
+    /** layout for the buffer */
+    uniformLayout: UniformBufferLayout;
+    /** minimum binding size of the buffer */
+    minBindingSize?: number;
+}
+/**
+ * Binding layout of a sampler
+ * @public
+ */
+interface SamplerBindingLayout {
+    /** The bind type */
+    type: 'filtering' | 'non-filtering' | 'comparison';
+}
+/**
+ * Binding layout of a texture for sampling
+ * @public
+ */
+interface TextureBindingLayout {
+    /** Sample type of the texture */
+    sampleType: 'float' | 'unfilterable-float' | 'depth' | 'sint' | 'uint';
+    /** View dimension for the texture */
+    viewDimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
+    /** Whether the textur is a multisampled texture */
+    multisampled: boolean;
+    /** name of the default sampler uniform when using WebGPU device */
+    autoBindSampler: string;
+    /** name of the default comparison sampler uniform when using WebGPU device */
+    autoBindSamplerComparison: string;
+}
+/**
+ * Binding layout of a storage texture
+ * @public
+ */
+interface StorageTextureBindingLayout {
+    /** Access mode */
+    access: 'write-only';
+    /** The texture format */
+    format: TextureFormat;
+    /** View dimension */
+    viewDimension: '1d' | '2d';
+}
+/**
+ * Binding layout of an external texture
+ * @public
+ */
+interface ExternalTextureBindingLayout {
+    /** name of the default sampler uniform when using WebGPU device */
+    autoBindSampler: string;
+}
+/**
+ * Information of bind group entries
+ * @public
+ */
+interface BindGroupLayoutEntry {
+    /** The binding location */
+    binding: number;
+    /** Name of this binding resource */
+    name: string;
+    /** Visibility mask */
+    visibility: number;
+    /** Type of the binding resource */
+    type: PBTypeInfo;
+    /** Binding layout if the resource is a buffer */
+    buffer?: BufferBindingLayout;
+    /** Binding layout if the resource is a sampler */
+    sampler?: SamplerBindingLayout;
+    /** Binding layout if the resource is a texture for sampling */
+    texture?: TextureBindingLayout;
+    /** Binding layout if the resource is a storage texture */
+    storageTexture?: StorageTextureBindingLayout;
+    /** Binding layout if the resource is an external texture */
+    externalTexture?: ExternalTextureBindingLayout;
+}
+/**
+ * Defines how the resources bound in a {@link BindGroup}
+ * @public
+ */
+interface BindGroupLayout {
+    /** Label of the layout */
+    label?: string;
+    /** The name map */
+    nameMap?: Record<string, string>;
+    /** A list of {@link BindGroupLayoutEntry} */
+    entries: BindGroupLayoutEntry[];
+}
+/**
+ * Binding point information for a uniform
+ * @public
+ */
+interface BindPointInfo {
+    group: number;
+    binding: number;
+    type: PBTypeInfo;
+}
+/**
+ * Sampler creation options
+ * @public
+ */
+interface SamplerOptions {
+    addressU?: TextureAddressMode;
+    addressV?: TextureAddressMode;
+    addressW?: TextureAddressMode;
+    magFilter?: TextureFilterMode;
+    minFilter?: TextureFilterMode;
+    mipFilter?: TextureFilterMode;
+    lodMin?: number;
+    lodMax?: number;
+    compare?: CompareFunc;
+    maxAnisotropy?: number;
+}
+/**
+ * Base class for a GPU object
+ * @public
+ */
+interface GPUObject<T = unknown> extends IEventTarget<{
+    disposed: null;
+}> {
+    /** The object was created by which device */
+    readonly device: AbstractDevice;
+    /** The internal GPU object  */
+    readonly object: T;
+    /** unique id */
+    readonly uid: number;
+    readonly cid: number;
+    readonly disposed: boolean;
+    name: string;
+    restoreHandler: (tex: GPUObject) => Promise<void>;
+    isVertexLayout(): this is VertexLayout;
+    isFramebuffer(): this is FrameBuffer;
+    isSampler(): this is TextureSampler;
+    isTexture(): this is BaseTexture;
+    isTexture2D(): this is Texture2D;
+    isTexture2DArray(): this is Texture2DArray;
+    isTexture3D(): this is Texture3D;
+    isTextureCube(): this is TextureCube;
+    isTextureVideo(): this is TextureVideo;
+    isProgram(): this is GPUProgram;
+    isBuffer(): this is GPUDataBuffer;
+    isBindGroup(): this is BindGroup;
+    dispose(): void;
+    reload(): Promise<void>;
+    destroy(): void;
+    restore(): Promise<void>;
+}
+/**
+ * Abstract interface for texture sampler
+ * @public
+ */
+interface TextureSampler<T = unknown> extends GPUObject<T> {
+    readonly addressModeU: TextureAddressMode;
+    readonly addressModeV: TextureAddressMode;
+    readonly addressModeW: TextureAddressMode;
+    readonly magFilter: TextureFilterMode;
+    readonly minFilter: TextureFilterMode;
+    readonly mipFilter: TextureFilterMode;
+    readonly lodMin: number;
+    readonly lodMax: number;
+    readonly compare: CompareFunc;
+    readonly maxAnisotropy: number;
+}
+/**
+ * Abstract interface for texture
+ * @public
+ */
+interface BaseTexture<T = unknown> extends GPUObject<T> {
+    readonly target: TextureType;
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    readonly format: TextureFormat;
+    readonly mipLevelCount: number;
+    samplerOptions: SamplerOptions;
+    init(): void;
+    generateMipmaps(): void;
+    isSRGBFormat(): boolean;
+    isFloatFormat(): boolean;
+    isIntegerFormat(): boolean;
+    isSignedFormat(): boolean;
+    isCompressedFormat(): boolean;
+    isFilterable(): boolean;
+    isDepth(): boolean;
+    getDefaultSampler(comparison: boolean): TextureSampler;
+    readPixels(x: number, y: number, w: number, h: number, faceOrLayer: number, mipLevel: number, buffer: TypedArray): Promise<void>;
+    readPixelsToBuffer(x: number, y: number, w: number, h: number, faceOrLayer: number, mipLevel: number, buffer: GPUDataBuffer): void;
+}
+/**
+ * Abstract interface for 2D texture
+ * @public
+ */
+interface Texture2D<T = unknown> extends BaseTexture<T> {
+    update(data: TypedArray, xOffset: number, yOffset: number, width: number, height: number): void;
+    updateFromElement(data: TextureImageElement, destX: number, destY: number, srcX: number, srcY: number, width: number, height: number): void;
+    loadFromElement(element: TextureImageElement, sRGB: boolean, creationFlags?: number): void;
+    createWithMipmapData(data: TextureMipmapData, sRGB: boolean, creationFlags?: number): void;
+}
+/**
+ * Abstract interface for 2D array texture
+ * @public
+ */
+interface Texture2DArray<T = unknown> extends BaseTexture<T> {
+    update(data: TypedArray, xOffset: number, yOffset: number, zOffset: number, width: number, height: number, depth: number): void;
+    updateFromElement(data: TextureImageElement, xOffset: number, yOffset: number, layerIndex: number, x: number, y: number, width: number, height: number): void;
+    createWithMipmapData(data: TextureMipmapData, creationFlags?: number): void;
+}
+/**
+ * Abstract interface for 3D texture
+ * @public
+ */
+interface Texture3D<T = unknown> extends BaseTexture<T> {
+    update(data: TypedArray, xOffset: number, yOffset: number, zOffset: number, width: number, height: number, depth: number): void;
+    createWithMipmapData(data: TextureMipmapData, creationFlags?: number): void;
+}
+/**
+ * Abstract interface for cube texture
+ * @public
+ */
+interface TextureCube<T = unknown> extends BaseTexture<T> {
+    update(data: TypedArray, xOffset: number, yOffset: number, width: number, height: number, face: CubeFace): void;
+    updateFromElement(data: TextureImageElement, xOffset: number, yOffset: number, face: number, x: number, y: number, width: number, height: number): void;
+    createWithMipmapData(data: TextureMipmapData, sRGB: boolean, creationFlags?: number): void;
+}
+/**
+ * Abstract interface for video texture
+ * @public
+ */
+interface TextureVideo<T = unknown> extends BaseTexture<T> {
+    readonly source: HTMLVideoElement;
+    updateVideoFrame(): boolean;
+}
+/**
+ * Abstract interface for GPU buffer
+ * @public
+ */
+interface GPUDataBuffer<T = unknown> extends GPUObject<T> {
+    readonly byteLength: number;
+    readonly usage: number;
+    bufferSubData(dstByteOffset: number, data: TypedArray, srcOffset?: number, srcLength?: number): void;
+    getBufferSubData(dstBuffer?: Uint8Array, offsetInBytes?: number, sizeInBytes?: number): Promise<Uint8Array>;
+}
+/**
+ * Abstract interface for index buffer
+ * @public
+ */
+interface IndexBuffer<T = unknown> extends GPUDataBuffer<T> {
+    readonly indexType: PBPrimitiveTypeInfo;
+    readonly length: number;
+}
+/**
+ * Abstract interface for structured buffer
+ * @public
+ */
+interface StructuredBuffer<T = unknown> extends GPUDataBuffer<T> {
+    structure: PBStructTypeInfo;
+    set(name: string, value: StructuredValue): any;
+}
+/**
+ * Abstract interface for vertex layout
+ * @public
+ */
+interface VertexLayout<T = unknown> extends GPUObject<T> {
+    readonly vertexBuffers: {
+        [semantic: number]: {
+            buffer: StructuredBuffer;
+            offset: number;
+        };
+    };
+    readonly indexBuffer: IndexBuffer;
+    setDrawOffset(buffer: StructuredBuffer, byteOffset: number): void;
+    getVertexBuffer(semantic: VertexSemantic): StructuredBuffer;
+    getVertexBufferInfo(semantic: VertexSemantic): VertexBufferInfo;
+    getIndexBuffer(): IndexBuffer;
+    bind(): void;
+    draw(primitiveType: PrimitiveType, first: number, count: number): void;
+    drawInstanced(primitiveType: PrimitiveType, first: number, count: number, numInstances: number): any;
+}
+/**
+ * Abstract interface for frame buffer
+ * @public
+ */
+interface FrameBuffer<T = unknown> extends GPUObject<T> {
+    getWidth(): number;
+    getHeight(): number;
+    getSampleCount(): number;
+    setColorAttachmentCubeFace(index: number, face: CubeFace): void;
+    setColorAttachmentMipLevel(index: number, level: number): void;
+    setColorAttachmentLayer(index: number, layer: number): void;
+    setColorAttachmentGenerateMipmaps(index: number, generateMipmaps: boolean): void;
+    setDepthAttachmentCubeFace(face: CubeFace): void;
+    setDepthAttachmentLayer(layer: number): void;
+    getColorAttachments(): BaseTexture[];
+    getDepthAttachment(): BaseTexture;
+    bind(): boolean;
+    unbind(): void;
+}
+/**
+ * Abstract interface for GPU program
+ * @public
+ */
+interface GPUProgram<T = unknown> extends GPUObject<T> {
+    readonly bindGroupLayouts: BindGroupLayout[];
+    readonly type: 'render' | 'compute';
+    getShaderSource(kind: ShaderKind): string;
+    getCompileError(): string;
+    getBindingInfo(name: string): BindPointInfo;
+    createUniformBuffer(uniform: string): StructuredBuffer;
+    use(): void;
+}
+/**
+ * Type of values that can be set to a structured buffer
+ * @public
+ */
+type StructuredValue = number | TypedArray | VectorBase | {
+    [name: string]: StructuredValue;
+};
+/**
+ * Abstract interface for bind group
+ * @public
+ */
+interface BindGroup extends GPUObject<unknown> {
+    getLayout(): BindGroupLayout;
+    getBuffer(name: string): GPUDataBuffer;
+    getTexture(name: string): BaseTexture;
+    setBuffer(name: string, buffer: GPUDataBuffer): void;
+    setValue(name: string, value: StructuredValue): any;
+    setRawData(name: string, byteOffset: number, data: TypedArray, srcPos?: number, srcLength?: number): any;
+    setTexture(name: string, texture: BaseTexture, sampler?: TextureSampler): any;
+    setTextureView(name: string, value: BaseTexture, level?: number, face?: number, mipCount?: number, sampler?: TextureSampler): any;
+    setSampler(name: string, sampler: TextureSampler): any;
+}
+/**
+ * Creates the default name for the type of given gpu object
+ * @param obj - The gpu object
+ * @returns The default name
+ * @public
+ */
+declare function genDefaultName(obj: GPUObject): "unknown" | "sampler" | "texture_2d" | "texture_2darray" | "texture_3d" | "texture_cube" | "texture_video" | "buffer" | "framebuffer" | "program" | "vbo";
+
+/** @public */
+interface ShaderExpTagRecord {
+    [name: string]: ShaderExpTagValue;
+}
+/** @public */
+type ShaderExpTagValue = string[] | string | ShaderExpTagRecord;
+/**
+ * type of a shader variable constructor
+ * @public
+ */
+type ShaderTypeFunc = {
+    (...args: any[]): PBShaderExp;
+    ptr: ShaderTypeFunc;
+    [dim: number]: ShaderTypeFunc;
+};
+/**
+ * Base class for proxiable object
+ * @public
+ */
+declare abstract class Proxiable<T> {
+    constructor();
+    get $thisProxy(): T;
+}
+/**
+ * Base class for a expression in the shader
+ * @public
+ */
+declare class PBShaderExp extends Proxiable<PBShaderExp> {
+    [name: string]: any;
+    get $group(): number;
+    set $group(val: number);
+    /**
+     * Point out that the variable should be in uniform address space
+     * @param group - The bind group index
+     * @returns self
+     */
+    uniform(group: number): PBShaderExp;
+    /**
+     * Point out that the variable should be an uniform buffer
+     * @param group - The bind group index
+     * @returns self
+     */
+    uniformBuffer(group: number): PBShaderExp;
+    /**
+     * Point out that the variable should be in workgroup address space
+     *
+     * @remarks
+     * WebGPU device only
+     *
+     * @returns self
+     */
+    workgroup(): PBShaderExp;
+    /**
+     * Point out that the variable should be in storage address space
+     * @param group - The bind group index
+     * @returns self
+     */
+    storage(group: number): PBShaderExp;
+    /**
+     * Point out that the variable should be a storage buffer
+     * @param group - The bind group index
+     * @returns self
+     */
+    storageBuffer(group: number): PBShaderExp;
+    inout(): PBShaderExp;
+    out(): PBShaderExp;
+    /**
+     * Point out that the variable is a input vertex attribute
+     * @param attr - The vertex semantic
+     * @returns self
+     */
+    attrib(attr: VertexSemantic): PBShaderExp;
+    /**
+     * Create tags for the variable
+     * @param args - tags
+     * @returns self
+     */
+    tag(...args: ShaderExpTagValue[]): PBShaderExp;
+    /**
+     * Set sample type for the variable if the variable is of type texture
+     * @param type - sample type
+     * @returns self
+     */
+    sampleType(type: 'float' | 'unfilterable-float' | 'sint' | 'uint' | 'depth'): PBShaderExp;
+    /**
+     * Get element in the array by index
+     * @param index - index of the element
+     * @returns the element variable
+     */
+    at(index: number | PBShaderExp): PBShaderExp;
+    /**
+     * Set element in the array by index
+     * @param index - index of the element
+     * @param val - value to set
+     */
+    setAt(index: number | PBShaderExp, val: number | boolean | PBShaderExp): void;
+    /**
+     * Point out that the variable should be in high precision
+     * @returns self
+     */
+    highp(): PBShaderExp;
+    /**
+     * Points out that the variable should be in medium precision
+     * @returns self
+     */
+    mediump(): PBShaderExp;
+    /**
+     * Points out that the variable should be in low precision
+     * @returns self
+     */
+    lowp(): PBShaderExp;
+    /**
+     * Determine if this variable is of vector type
+     * @returns true if the variable is of vector type, otherwise false
+     */
+    isVector(): boolean;
+    /**
+     * Get vector component count of the variable if this variable is of vector type
+     * @returns the vector component count
+     */
+    numComponents(): number;
+    /**
+     * Get type name of this variable
+     * @returns The type name of this variable
+     */
+    getTypeName(): string;
+}
+
+/**
+ * Shader variable getter function type
+ * @public
+ */
+type PBReflectionTagGetter = (scope: PBGlobalScope) => PBShaderExp;
+/**
+ * Reflection interface for program builder
+ * @public
+ */
+declare class PBReflection {
+    constructor(builder: ProgramBuilder);
+    /** Gets all the vertex attributes that was used by the program */
+    get vertexAttributes(): number[];
+    /**
+     * Check if specified vertex attribute was used by the program
+     * @param attrib - The vertex attribute to check
+     */
+    hasVertexAttribute(attrib: number): boolean;
+    /**
+     * Clear all contents
+     */
+    clear(): void;
+    /**
+     * Gets the variable that has tagged with given string
+     * @param name - The tag string
+     */
+    tag(name: string): PBShaderExp;
+    /**
+     * Creates a new tag by specifying a function to get the tagged variable
+     * @param name - The tag name
+     * @param getter - The getter function
+     */
+    tag(name: string, getter: PBReflectionTagGetter): void;
+    /**
+     * Creates multiple tags from an object that contains the tag names and the getter functions
+     * @param values - The object that contains the tag names and the getter functions
+     */
+    tag(values: Record<string, PBReflectionTagGetter>): void;
+    /**
+     * Gets the variable which is the vertex attribute of specified semantic
+     * @param attrib - The vertex semantic
+     */
+    attribute(attrib: VertexSemantic): PBShaderExp;
+}
+
+declare const StorageTextureFormatMap: {
+    rgba8unorm: string;
+    rgba8snorm: string;
+    rgba8uint: string;
+    rgba8sint: string;
+    rgba16uint: string;
+    rgba16sint: string;
+    rgba16float: string;
+    r32float: string;
+    r32uint: string;
+    r32sint: string;
+    rg32float: string;
+    rg32uint: string;
+    rg32sint: string;
+    rgba32float: string;
+    rgba32uint: string;
+    rgba32sint: string;
+};
+type StorageTextureConstructor = {
+    [k in keyof typeof StorageTextureFormatMap]: (s?: string) => PBShaderExp;
+};
+
+/**
+ * Non-array value type of shader expression
+ * @public
+ */
+type ExpValueNonArrayType = number | boolean | PBShaderExp;
+/**
+ * Value type for shader of shader expression
+ * @public
+ */
+type ExpValueType = ExpValueNonArrayType | Array<ExpValueType>;
+/**
+ * Render program build options
+ * @public
+ */
+interface PBRenderOptions {
+    /** program label for debugging */
+    label?: string;
+    /**
+     * Vertex shader generator.
+     * @param this - Global scope object of the vertex shader
+     * @param pb - The program builder instance
+     */
+    vertex(this: PBGlobalScope, pb: ProgramBuilder): any;
+    /**
+     * Fragment shader generator.
+     * @param this - Global scope object of the fragment shader
+     * @param pb - The program builder instance
+     */
+    fragment(this: PBGlobalScope, pb: ProgramBuilder): any;
+}
+/**
+ * Compute program build options
+ * @public
+ */
+interface PBComputeOptions {
+    /** program label for debugging */
+    label?: string;
+    /** workgroup size */
+    workgroupSize: [number, number, number];
+    /** compute shader */
+    compute(this: PBGlobalScope, pb: ProgramBuilder): any;
+}
+/**
+ * The program builder interface
+ * @public
+ */
+interface ProgramBuilder {
+    /** Get the device */
+    getDevice(): AbstractDevice;
+    /** Gets the global scope */
+    getGlobalScope(): PBGlobalScope;
+    /** Gets the current scope */
+    getCurrentScope(): PBScope;
+    /**
+     * Query the global variable by the name
+     * @param name - Name of the variable
+     * @returns The variable or null if not exists
+     */
+    queryGlobal(name: string): PBShaderExp;
+    /**
+     * Query the global variable by the name
+     * @param name - Name of the variable
+     * @returns The variable or null if not exists
+     */
+    $query(name: string): PBShaderExp;
+    /**
+     * Generates shader codes for a render program
+     * @param options - The build options
+     * @returns a tuple made by vertex shader source, fragment shader source, bind group layouts and vertex attributes used, or null if build faild
+     */
+    buildRender(options: PBRenderOptions): readonly [string, string, BindGroupLayout[], number[]];
+    /**
+     * Generates shader code for a compute program
+     * @param options - The build programs
+     * @returns a tuple made by compute shader source and bind group layouts, or null if build failed
+     */
+    buildCompute(options: PBComputeOptions): readonly [string, BindGroupLayout[]];
+    /**
+     * Creates a shader program for render
+     * @param options - The build options
+     * @returns The created program or null if build failed
+     */
+    buildRenderProgram(options: PBRenderOptions): GPUProgram;
+    /**
+     * Creates a shader program for compute
+     * @param options - The build options
+     * @returns The created program or null if build failed
+     */
+    buildComputeProgram(options: PBComputeOptions): GPUProgram;
+    /**
+     * Creates a structure type variable
+     * @param structName - Name of the structure type
+     * @param instanceName - Name of the variable
+     * @returns the created variable
+     */
+    struct(structName: string, instanceName: string): PBShaderExp;
+    /**
+     * Defines a structure type
+     * @param members - Members of the structure
+     * @param structName - Name of the type, if not given, the name will be automatically generated
+     * @returns The structure type constructor
+     */
+    defineStruct(members: PBShaderExp[], structName?: string): ShaderTypeFunc;
+    /**
+     * Defines a structure type
+     * @param structType - The structure type info
+     * @returns The structure type constructor
+     */
+    defineStructByType(structType: PBStructTypeInfo): ShaderTypeFunc;
+    /**
+     * Creates a 'discard' statement
+     */
+    discard(): void;
+    /**
+     * Creates a function
+     * @param name - Name of the function
+     * @param params - Parameters of the function
+     * @param body - The generator function
+     */
+    func(name: string, params: PBShaderExp[], body?: (this: PBFunctionScope) => void): void;
+    /**
+     * Create the main entry function of the shader
+     * @param body - The shader generator function
+     */
+    main(body?: (this: PBFunctionScope) => void): void;
+    /**
+     * Create an 'AddressOf' expression for WGSL
+     * @param ref - The reference variable
+     * @returns the 'AddressOf' expression
+     */
+    addressOf(ref: PBShaderExp): PBShaderExp;
+    /**
+     * Creates a 'referenceOf' expression for WGSL
+     * @param ptr - The pointer variable
+     * @returns the 'referenceOf' expression
+     */
+    referenceOf(ptr: PBShaderExp): PBShaderExp;
+    /** float type variable constructors */
+    float: {
+        (): PBShaderExp;
+        (rhs: number): PBShaderExp;
+        (rhs: boolean): PBShaderExp;
+        (rhs: PBShaderExp): PBShaderExp;
+        (name: string): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** int type variable constructors */
+    int: {
+        (): PBShaderExp;
+        (rhs: number | boolean | PBShaderExp | string): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** uint type variable constructors */
+    uint: {
+        (): PBShaderExp;
+        (rhs: number | boolean | PBShaderExp | string): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** boolean type variable constructors */
+    bool: {
+        (): PBShaderExp;
+        (rhs: number | boolean | PBShaderExp | string): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** vec2 type variable constructors */
+    vec2: {
+        (): PBShaderExp;
+        (rhs: number | PBShaderExp | string): PBShaderExp;
+        (x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** ivec2 type variable constructors */
+    ivec2: {
+        (): PBShaderExp;
+        (rhs: number | PBShaderExp | string): PBShaderExp;
+        (x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** uvec2 type variable constructors */
+    uvec2: {
+        (): PBShaderExp;
+        (rhs: number | PBShaderExp | string): PBShaderExp;
+        (x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** bvec2 type variable constructors */
+    bvec2: {
+        (): PBShaderExp;
+        (rhs: number | boolean | PBShaderExp | string): PBShaderExp;
+        (x: number | boolean | PBShaderExp, y: number | boolean | PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** vec3 type variable constructors */
+    vec3: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (x: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, y: number | PBShaderExp, z: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, yz: PBShaderExp): PBShaderExp;
+        (xy: PBShaderExp, z: number | PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** ivec3 type variable constructors */
+    ivec3: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (x: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, y: number | PBShaderExp, z: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, yz: PBShaderExp): PBShaderExp;
+        (xy: PBShaderExp, z: number | PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** uvec3 type variable constructors */
+    uvec3: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (x: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, y: number | PBShaderExp, z: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, yz: PBShaderExp): PBShaderExp;
+        (xy: PBShaderExp, z: number | PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** bvec3 type variable constructors */
+    bvec3: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (x: boolean | PBShaderExp): PBShaderExp;
+        (x: boolean | PBShaderExp, y: boolean | PBShaderExp, z: boolean | PBShaderExp): PBShaderExp;
+        (x: boolean | PBShaderExp, yz: PBShaderExp): PBShaderExp;
+        (xy: PBShaderExp, z: boolean | PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** vec4 type variable constructors */
+    vec4: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (x: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, y: number | PBShaderExp, z: number | PBShaderExp, w: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, y: number | PBShaderExp, zw: PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, yz: PBShaderExp, w: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, yzw: PBShaderExp): PBShaderExp;
+        (xy: PBShaderExp, z: number | PBShaderExp, w: number | PBShaderExp): PBShaderExp;
+        (xy: PBShaderExp, zw: PBShaderExp): PBShaderExp;
+        (xyz: PBShaderExp, w: number | PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** ivec4 type variable constructors */
+    ivec4: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (x: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, y: number | PBShaderExp, z: number | PBShaderExp, w: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, y: number | PBShaderExp, zw: PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, yz: PBShaderExp, w: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, yzw: PBShaderExp): PBShaderExp;
+        (xy: PBShaderExp, z: number | PBShaderExp, w: number | PBShaderExp): PBShaderExp;
+        (xy: PBShaderExp, zw: PBShaderExp): PBShaderExp;
+        (xyz: PBShaderExp, w: number | PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** uvec4 type variable constructors */
+    uvec4: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (x: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, y: number | PBShaderExp, z: number | PBShaderExp, w: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, y: number | PBShaderExp, zw: PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, yz: PBShaderExp, w: number | PBShaderExp): PBShaderExp;
+        (x: number | PBShaderExp, yzw: PBShaderExp): PBShaderExp;
+        (xy: PBShaderExp, z: number | PBShaderExp, w: number | PBShaderExp): PBShaderExp;
+        (xy: PBShaderExp, zw: PBShaderExp): PBShaderExp;
+        (xyz: PBShaderExp, w: number | PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** bvec4 type variable constructors */
+    bvec4: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (x: boolean | PBShaderExp): PBShaderExp;
+        (x: boolean | PBShaderExp, y: boolean | PBShaderExp, z: boolean | PBShaderExp, w: boolean | PBShaderExp): PBShaderExp;
+        (x: boolean | PBShaderExp, y: boolean | PBShaderExp, zw: PBShaderExp): PBShaderExp;
+        (x: boolean | PBShaderExp, yz: PBShaderExp, w: boolean | PBShaderExp): PBShaderExp;
+        (x: boolean | PBShaderExp, yzw: PBShaderExp): PBShaderExp;
+        (xy: PBShaderExp, z: boolean | PBShaderExp, w: boolean | PBShaderExp): PBShaderExp;
+        (xy: PBShaderExp, zw: PBShaderExp): PBShaderExp;
+        (xyz: PBShaderExp, w: boolean | PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** mat2 type variable constructors */
+    mat2: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (m00: number | PBShaderExp, m01: number | PBShaderExp, m10: number | PBShaderExp, m11: number | PBShaderExp): PBShaderExp;
+        (m0: PBShaderExp, m1: PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** mat2x3 type variable constructors */
+    mat2x3: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (m00: number | PBShaderExp, m01: number | PBShaderExp, m02: number | PBShaderExp, m10: number | PBShaderExp, m11: number | PBShaderExp, m12: number | PBShaderExp): PBShaderExp;
+        (m0: PBShaderExp, m1: PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** mat2x4 type variable constructors */
+    mat2x4: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (m00: number | PBShaderExp, m01: number | PBShaderExp, m02: number | PBShaderExp, m03: number | PBShaderExp, m10: number | PBShaderExp, m11: number | PBShaderExp, m12: number | PBShaderExp, m13: number | PBShaderExp): PBShaderExp;
+        (m0: PBShaderExp, m1: PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** mat3 type variable constructors */
+    mat3: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (m00: number | PBShaderExp, m01: number | PBShaderExp, m02: number | PBShaderExp, m10: number | PBShaderExp, m11: number | PBShaderExp, m12: number | PBShaderExp, m20: number | PBShaderExp, m21: number | PBShaderExp, m22: number | PBShaderExp): PBShaderExp;
+        (m0: PBShaderExp, m1: PBShaderExp, m2: PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** mat3x2 type variable constructors */
+    mat3x2: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (m00: number | PBShaderExp, m01: number | PBShaderExp, m10: number | PBShaderExp, m11: number | PBShaderExp, m20: number | PBShaderExp, m21: number | PBShaderExp): PBShaderExp;
+        (m0: PBShaderExp, m1: PBShaderExp, m2: PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** mat3x4 type variable constructors */
+    mat3x4: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (m00: number | PBShaderExp, m01: number | PBShaderExp, m02: number | PBShaderExp, m03: number | PBShaderExp, m10: number | PBShaderExp, m11: number | PBShaderExp, m12: number | PBShaderExp, m13: number | PBShaderExp, m20: number | PBShaderExp, m21: number | PBShaderExp, m22: number | PBShaderExp, m23: number | PBShaderExp): PBShaderExp;
+        (m0: PBShaderExp, m1: PBShaderExp, m2: PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** mat4 type variable constructors */
+    mat4: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (m00: number | PBShaderExp, m01: number | PBShaderExp, m02: number | PBShaderExp, m03: number | PBShaderExp, m10: number | PBShaderExp, m11: number | PBShaderExp, m12: number | PBShaderExp, m13: number | PBShaderExp, m20: number | PBShaderExp, m21: number | PBShaderExp, m22: number | PBShaderExp, m23: number | PBShaderExp, m30: number | PBShaderExp, m31: number | PBShaderExp, m32: number | PBShaderExp, m33: number | PBShaderExp): PBShaderExp;
+        (m0: PBShaderExp, m1: PBShaderExp, m2: PBShaderExp, m3: PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** mat4x2 type variable constructors */
+    mat4x2: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (m00: number | PBShaderExp, m01: number | PBShaderExp, m10: number | PBShaderExp, m11: number | PBShaderExp, m20: number | PBShaderExp, m21: number | PBShaderExp, m30: number | PBShaderExp, m31: number | PBShaderExp): PBShaderExp;
+        (m0: PBShaderExp, m1: PBShaderExp, m2: PBShaderExp, m3: PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** mat4x3 type variable constructors */
+    mat4x3: {
+        (): PBShaderExp;
+        (name: string): PBShaderExp;
+        (m00: number | PBShaderExp, m01: number | PBShaderExp, m02: number | PBShaderExp, m10: number | PBShaderExp, m11: number | PBShaderExp, m12: number | PBShaderExp, m20: number | PBShaderExp, m21: number | PBShaderExp, m22: number | PBShaderExp, m30: number | PBShaderExp, m31: number | PBShaderExp, m32: number | PBShaderExp): PBShaderExp;
+        (m0: PBShaderExp, m1: PBShaderExp, m2: PBShaderExp, m3: PBShaderExp): PBShaderExp;
+        ptr: ShaderTypeFunc;
+        [dim: number]: ShaderTypeFunc;
+    };
+    /** tex1D type variable constructors */
+    tex1D(rhs?: string): PBShaderExp;
+    /** tex2D type variable constructors */
+    tex2D(rhs?: string): PBShaderExp;
+    /** tex3D type variable constructors */
+    tex3D(rhs?: string): PBShaderExp;
+    /** texCube type variable constructors */
+    texCube(rhs?: string): PBShaderExp;
+    /** texExternal type variable constructors */
+    texExternal(rhs?: string): PBShaderExp;
+    /** tex2DShadow type variable constructors */
+    tex2DShadow(rhs?: string): PBShaderExp;
+    /** texCubeShadow type variable constructors */
+    texCubeShadow(rhs?: string): PBShaderExp;
+    /** tex2DArray type variable constructors */
+    tex2DArray(rhs?: string): PBShaderExp;
+    /** tex2DArrayShadow type variable constructors */
+    tex2DArrayShadow(rhs?: string): PBShaderExp;
+    /** itex1D type variable constructors */
+    itex1D(rhs?: string): PBShaderExp;
+    /** itex2D type variable constructors */
+    itex2D(rhs?: string): PBShaderExp;
+    /** itex3D type variable constructors */
+    itex3D(rhs?: string): PBShaderExp;
+    /** itexCube type variable constructors */
+    itexCube(rhs?: string): PBShaderExp;
+    /** itex2DArray type variable constructors */
+    itex2DArray(rhs?: string): PBShaderExp;
+    /** utex1D type variable constructors */
+    utex1D(rhs?: string): PBShaderExp;
+    /** utex2D type variable constructors */
+    utex2D(rhs?: string): PBShaderExp;
+    /** utex3D type variable constructors */
+    utex3D(rhs?: string): PBShaderExp;
+    /** utexCube type variable constructors */
+    utexCube(rhs?: string): PBShaderExp;
+    /** utex2DArray type variable constructors */
+    utex2DArray(rhs?: string): PBShaderExp;
+    /** texStorage1D type variable constructors */
+    texStorage1D: StorageTextureConstructor;
+    /** texStorage2D type variable constructors */
+    texStorage2D: StorageTextureConstructor;
+    /** texStorage2DArray type variable constructors */
+    texStorage2DArray: StorageTextureConstructor;
+    /** texStorage3D type variable constructors */
+    texStorage3D: StorageTextureConstructor;
+    /** sampler type variable constructors */
+    sampler(rhs?: string): PBShaderExp;
+    /** samplerComparison type variable constructors */
+    samplerComparison(rhs?: string): PBShaderExp;
+    /** Same as radians builtin function in GLSL and WGSL */
+    radians(val: number | PBShaderExp): PBShaderExp;
+    /** Same as degrees builtin function in GLSL and WGSL */
+    degrees(val: number | PBShaderExp): PBShaderExp;
+    /** Same as sin builtin function in GLSL and WGSL */
+    sin(val: number | PBShaderExp): PBShaderExp;
+    /** Same as cos builtin function in GLSL and WGSL */
+    cos(val: number | PBShaderExp): PBShaderExp;
+    /** Same as tan builtin function in GLSL and WGSL */
+    tan(val: number | PBShaderExp): PBShaderExp;
+    /** Same as asin builtin function in GLSL and WGSL */
+    asin(val: number | PBShaderExp): PBShaderExp;
+    /** Same as acos builtin function in GLSL and WGSL */
+    acos(val: number | PBShaderExp): PBShaderExp;
+    /** Same as atan builtin function in GLSL and WGSL */
+    atan(val: number | PBShaderExp): PBShaderExp;
+    /** Same as atan builtin function in GLSL and atan2 builtin function in WGSL */
+    atan2(y: number | PBShaderExp, x: number | PBShaderExp): PBShaderExp;
+    /** Same as sinh builtin function in GLSL and WGSL */
+    sinh(val: number | PBShaderExp): PBShaderExp;
+    /** Same as cosh builtin function in GLSL and WGSL */
+    cosh(val: number | PBShaderExp): PBShaderExp;
+    /** Same as tanh builtin function in GLSL and WGSL */
+    tanh(val: number | PBShaderExp): PBShaderExp;
+    /** Same as asinh builtin function in GLSL and WGSL */
+    asinh(val: number | PBShaderExp): PBShaderExp;
+    /** Same as acosh builtin function in GLSL and WGSL */
+    acosh(val: number | PBShaderExp): PBShaderExp;
+    /** Same as atanh builtin function in GLSL and WGSL */
+    atanh(val: number | PBShaderExp): PBShaderExp;
+    /** Same as pow builtin function in GLSL and WGSL */
+    pow(x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+    /** Same as exp builtin function in GLSL and WGSL */
+    exp(val: number | PBShaderExp): PBShaderExp;
+    /** Same as exp2 builtin function in GLSL and WGSL */
+    exp2(val: number | PBShaderExp): PBShaderExp;
+    /** Same as log builtin function in GLSL and WGSL */
+    log(val: number | PBShaderExp): PBShaderExp;
+    /** Same as log2 builtin function in GLSL and WGSL */
+    log2(val: number | PBShaderExp): PBShaderExp;
+    /** Same as sqrt builtin function in GLSL and WGSL */
+    sqrt(val: number | PBShaderExp): PBShaderExp;
+    /** Same as inversesqrt builtin function in GLSL and WGSL */
+    inverseSqrt(val: number | PBShaderExp): PBShaderExp;
+    /** Same as abs builtin function in GLSL and WGSL */
+    abs(val: number | PBShaderExp): PBShaderExp;
+    /** Same as sign builtin function in GLSL and WGSL */
+    sign(val: number | PBShaderExp): PBShaderExp;
+    /** Same as floor builtin function in GLSL and WGSL */
+    floor(val: number | PBShaderExp): PBShaderExp;
+    /** Same as ceil builtin function in GLSL and WGSL */
+    ceil(val: number | PBShaderExp): PBShaderExp;
+    /** Same as fract builtin function in GLSL and WGSL */
+    fract(val: number | PBShaderExp): PBShaderExp;
+    /** Same as mod builtin function in GLSL and WGSL */
+    mod(x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+    /** Same as fma builtin function in WGSL, only valid for WebGPU device */
+    fma(x: number | PBShaderExp, y: number | PBShaderExp, z: number | PBShaderExp): PBShaderExp;
+    /** Same as round builtin function in WGSL, only valid for WebGPU device */
+    round(val: number | PBShaderExp): PBShaderExp;
+    /** Same as trunc builtin function in WGSL, only valid for WebGPU device */
+    trunc(val: number | PBShaderExp): PBShaderExp;
+    /** Same as min builtin function in GLSL and WGSL */
+    min(x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+    /** Same as max builtin function in GLSL and WGSL */
+    max(x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+    /** Same as clamp builtin function in GLSL and WGSL */
+    clamp(x: number | PBShaderExp, y: number | PBShaderExp, z: number | PBShaderExp): PBShaderExp;
+    /** Same as mix builtin function in GLSL and WGSL */
+    mix(x: number | PBShaderExp, y: number | PBShaderExp, z: number | PBShaderExp): PBShaderExp;
+    /** Same as step builtin function in GLSL and WGSL */
+    step(x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+    /** Same as smoothstep builtin function in GLSL and WGSL */
+    smoothStep(x: number | PBShaderExp, y: number | PBShaderExp, z: number | PBShaderExp): PBShaderExp;
+    /** Same as isnan builtin function in GLSL, only valid for WebGL2 device */
+    isnan(x: number | PBShaderExp): PBShaderExp;
+    /** Same as isinf builtin function in GLSL, only valid for WebGL2 device */
+    isinf(x: number | PBShaderExp): PBShaderExp;
+    /** add two values */
+    add_2(x: number | PBShaderExp, y: number | PBShaderExp): any;
+    /** add a couple of values togeter */
+    add(x: number | PBShaderExp, ...rest: (number | PBShaderExp)[]): any;
+    /** subtract two values */
+    sub(x: number | PBShaderExp, y: number | PBShaderExp): any;
+    /** multiply two values */
+    mul_2(x: number | PBShaderExp, y: number | PBShaderExp): any;
+    /** multiply a couple of values togeter */
+    mul(x: number | PBShaderExp, ...rest: (number | PBShaderExp)[]): any;
+    /** divide the first number by the second number */
+    div(x: number | PBShaderExp, y: number | PBShaderExp): any;
+    /** Same as length builtin function in GLSL and WGSL */
+    length(x: number | PBShaderExp): PBShaderExp;
+    /** Same as distance builtin function in GLSL and WGSL */
+    distance(x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+    /** Same as dot builtin function in GLSL and WGSL */
+    dot(x: PBShaderExp, y: PBShaderExp): PBShaderExp;
+    /** Same as cross builtin function in GLSL and WGSL */
+    cross(x: PBShaderExp, y: PBShaderExp): PBShaderExp;
+    /** Same as normalize builtin function in GLSL and WGSL. */
+    normalize(x: PBShaderExp): PBShaderExp;
+    /** Same as faceForward builtin function in WGSL, only valid for WebGPU device */
+    faceForward(x: PBShaderExp, y: PBShaderExp, z: PBShaderExp): PBShaderExp;
+    /** Same as reflect builtin function in GLSL and WGSL */
+    reflect(x: PBShaderExp, y: PBShaderExp): PBShaderExp;
+    /** Same as refract builtin function in GLSL and WGSL */
+    refract(x: PBShaderExp, y: PBShaderExp, z: number | PBShaderExp): PBShaderExp;
+    /** Same as frexp builtin function in WGSL, only valid for WebGPU device */
+    frexp(x: number | PBShaderExp): PBShaderExp;
+    /** Same as outerProduct builtin function in GLSL, only valid for WebGL2 device */
+    outerProduct(x: PBShaderExp, y: PBShaderExp): PBShaderExp;
+    /** Same as transpose builtin function in GLSL and WGSL, only valid for WebGL2 and WebGPU device */
+    transpose(mat: PBShaderExp): PBShaderExp;
+    /** Same as determinant builtin function in GLSL and WGSL, only valid for WebGL2 and WebGPU device */
+    determinant(mat: PBShaderExp): PBShaderExp;
+    /** Same as inverse builtin function in GLSL, only valid for WebGL2 device */
+    inverse(mat: PBShaderExp): PBShaderExp;
+    /** return true if x is less than y, otherwise false */
+    lessThan(x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+    /** return true if x is less than or equals y, otherwise false, per component */
+    lessThanEqual(x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+    /** return true if x is greater than y, otherwise false, per component */
+    greaterThan(x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+    /** return true if x is greater than or equals y, otherwise false, per component */
+    greaterThanEqual(x: number | PBShaderExp, y: number | PBShaderExp): PBShaderExp;
+    /** return true if x equals y, otherwise false, per component */
+    compEqual(x: PBShaderExp, y: PBShaderExp): PBShaderExp;
+    /** return true if x is not equal to y, otherwise false, per component */
+    compNotEqual(x: PBShaderExp, y: PBShaderExp): PBShaderExp;
+    /** return true if x equals y, otherwise false */
+    equal(x: PBShaderExp | number, y: PBShaderExp | number): PBShaderExp;
+    /** return true if x is not equal to y, otherwise false */
+    notEqual(x: PBShaderExp | number, y: PBShaderExp | number): PBShaderExp;
+    /** return x && y */
+    and_2(x: PBShaderExp | number | boolean, y: PBShaderExp | number | boolean): PBShaderExp;
+    /** return x && y && ... */
+    and(x: PBShaderExp | number | boolean, y: PBShaderExp | number | boolean, ...rest: (PBShaderExp | number | boolean)[]): any;
+    /** return x & y, per component */
+    compAnd(x: PBShaderExp | number, y: PBShaderExp | number): PBShaderExp;
+    /** return x ^ y, per component */
+    compXor(x: PBShaderExp | number, y: PBShaderExp | number): PBShaderExp;
+    /** return x || y */
+    or_2(x: PBShaderExp | boolean, y: PBShaderExp | boolean): PBShaderExp;
+    /** return x || y */
+    or(x: PBShaderExp | boolean, y: PBShaderExp | boolean, ...rest: (PBShaderExp | boolean)[]): PBShaderExp;
+    /** return x || y, per component */
+    compOr(x: PBShaderExp | number | boolean, y: PBShaderExp | number | boolean): PBShaderExp;
+    /** check whether any element of a boolean vector is true */
+    any(x: PBShaderExp): PBShaderExp;
+    /** check whether all elements of a boolean vector are true */
+    all(x: PBShaderExp): PBShaderExp;
+    /** logically invert a boolean vector */
+    not(x: boolean | PBShaderExp): PBShaderExp;
+    /** return the negate of the given value */
+    neg(x: number | PBShaderExp): PBShaderExp;
+    /** shift arithmetic left, not valid for WebGL1 device */
+    sal(a: number | PBShaderExp, b: number | PBShaderExp): any;
+    /** shift arithmetic right, not valid for WebGL1 device */
+    sar(a: number | PBShaderExp, b: number | PBShaderExp): any;
+    /** Same as the arrayLength builtin function in WGSL, only valid for WebGPU device */
+    arrayLength(x: PBShaderExp): PBShaderExp;
+    /** Same as the select builtin function in WGSL, only valid for WebGPU device */
+    select(x: number | PBShaderExp, y: number | PBShaderExp, cond: boolean | PBShaderExp): PBShaderExp;
+    /** Same as floatBitsToInt builtin function in GLSL, only valid for WebGL2 device */
+    floatBitsToInt(x: number | PBShaderExp): PBShaderExp;
+    /** Same as floatBitsToUint builtin function in GLSL, only valid for WebGL2 device */
+    floatBitsToUint(x: number | PBShaderExp): PBShaderExp;
+    /** Same as intBitsToFloat builtin function in GLSL, only valid for WebGL2 device */
+    intBitsToFloat(x: number | PBShaderExp): PBShaderExp;
+    /** Same as uintBitsToFloat builtin function in GLSL, only valid for WebGL2 device */
+    uintBitsToFloat(x: number | PBShaderExp): PBShaderExp;
+    /** Same as pack4x8snorm builtin function in WGSL, only valid for WebGPU device */
+    pack4x8snorm(x: PBShaderExp): PBShaderExp;
+    /** Same as unpack4x8snorm builtin function in WGSL, only valid for WebGPU device */
+    unpack4x8snorm(x: number | PBShaderExp): PBShaderExp;
+    /** Same as pack4x8unorm builtin function in WGSL, only valid for WebGPU device */
+    pack4x8unorm(x: PBShaderExp): PBShaderExp;
+    /** Same as unpack4x8unorm builtin function in WGSL, only valid for WebGPU device */
+    unpack4x8unorm(x: number | PBShaderExp): PBShaderExp;
+    /** Same as pack2x16snom builtin function in WGSL, only valid for WebGPU device */
+    pack2x16snorm(x: PBShaderExp): PBShaderExp;
+    /** Same as unpack2x16snorm builtin function in WGSL, only valid for WebGPU device */
+    unpack2x16snorm(x: number | PBShaderExp): PBShaderExp;
+    /** Same as pack2x16unorm builtin function in WGSL, only valid for WebGPU device */
+    pack2x16unorm(x: PBShaderExp): PBShaderExp;
+    /** Same as unpack2x16unorm builtin function in WGSL, only valid for WebGPU device */
+    unpack2x16unorm(x: number | PBShaderExp): PBShaderExp;
+    /** Same as pack2x16float builtin function in WGSL, only valid for WebGPU device */
+    pack2x16float(x: PBShaderExp): PBShaderExp;
+    /** Same as unpack2x16float builtin function in WGSL, only valid for WebGPU device */
+    unpack2x16float(x: number | PBShaderExp): PBShaderExp;
+    /** Same as matrixCompMult builtin function in GLSL, only valid for WebGL/WebGL2 device */
+    matrixCompMult(x: PBShaderExp, y: PBShaderExp): PBShaderExp;
+    /** Same as dFdx builtin function in GLSL and dpdx builtin function in WGSL */
+    dpdx(x: PBShaderExp): PBShaderExp;
+    /** Same as dFdy builtin function in GLSL and dpdy builtin function in WGSL */
+    dpdy(x: PBShaderExp): PBShaderExp;
+    /** Same as fwidth builtin function in GLSL and WGSL */
+    fwidth(x: PBShaderExp): PBShaderExp;
+    /** Same as dFdx builtin function in GLSL and dpdxCoarse builtin function in WGSL */
+    dpdxCoarse(x: PBShaderExp): PBShaderExp;
+    /** Same as dFdx builtin function in GLSL and dpdxFine builtin function in WGSL */
+    dpdxFine(x: PBShaderExp): PBShaderExp;
+    /** Same as dFdy builtin function in GLSL and dpdyCoarse builtin function in WGSL */
+    dpdyCoarse(x: PBShaderExp): PBShaderExp;
+    /** Same as dFdy builtin function in GLSL and dpdyFine builtin function in WGSL */
+    dpdyFine(x: PBShaderExp): PBShaderExp;
+    /** Same as textureSize builtin function in GLSL and textureDimensions builtin function in WGSL, only valid for WebGL2 device and WebGPU device */
+    textureDimensions(tex: PBShaderExp, level?: number | PBShaderExp): PBShaderExp;
+    /** Same as textureGather builtin function in WGSL, only valid for WebGPU device */
+    textureGather(tex: PBShaderExp, sampler: PBShaderExp, coords: PBShaderExp): PBShaderExp;
+    /** Same as textureGather builtin function in WGSL, only valid for WebGPU device */
+    textureGather(component: number | PBShaderExp, tex: PBShaderExp, sampler: PBShaderExp, coords: PBShaderExp): PBShaderExp;
+    /** Same as textureGather builtin function in WGSL, only valid for WebGPU device */
+    textureArrayGather(tex: PBShaderExp, sampler: PBShaderExp, coords: PBShaderExp, arrayIndex: number | PBShaderExp): PBShaderExp;
+    /** Same as textureGather builtin function in WGSL, only valid for WebGPU device */
+    textureArrayGather(component: number | PBShaderExp, tex: PBShaderExp, sampler: PBShaderExp, coords: PBShaderExp, arrayIndex: number | PBShaderExp): PBShaderExp;
+    /** Same as textureGatherCompare builtin function in WGSL, only valid for WebGPU device */
+    textureGatherCompare(tex: PBShaderExp, samplerCompare: PBShaderExp, coords: PBShaderExp, depthRef: number | PBShaderExp): PBShaderExp;
+    /** Same as textureGatherCompare builtin function in WGSL, only valid for WebGPU device */
+    textureArrayGatherCompare(tex: PBShaderExp, samplerCompare: PBShaderExp, coords: PBShaderExp, arrayIndex: number | PBShaderExp, depthRef: number | PBShaderExp): PBShaderExp;
+    /** Same as texelFetch builtin function in GLSL and textureLoad builtin function in WGSL, only valid for WebGL2 and WebGPU device */
+    textureLoad(tex: PBShaderExp, coords: number | PBShaderExp, levelOrSampleIndex: number | PBShaderExp): PBShaderExp;
+    /** Same as texelFetch builtin function in GLSL and textureLoad builtin function in WGSL, only valid for WebGL2 and WebGPU device */
+    textureArrayLoad(tex: PBShaderExp, coords: number | PBShaderExp, arrayIndex: number | PBShaderExp, level: number | PBShaderExp): PBShaderExp;
+    /** Same as textureStore builtin function in WGSL, only valid for WebGPU device */
+    textureStore(tex: PBShaderExp, coords: number | PBShaderExp, value: PBShaderExp): void;
+    /** Same as textureStore builtin function in WGSL, only valid for WebGPU device */
+    textureArrayStore(tex: PBShaderExp, coords: PBShaderExp, arrayIndex: number | PBShaderExp, value: PBShaderExp): void;
+    /** Same as textureNumLayers builtin function in WGSL, only valid for WebGPU device */
+    textureNumLayers(tex: PBShaderExp): PBShaderExp;
+    /** Same as textureNumLevels builtin function in WGSL, only valid for WebGPU device */
+    textureNumLevels(tex: PBShaderExp): PBShaderExp;
+    /** Same as textureNumSamples builtin function in WGSL, only valid for WebGPU device */
+    textureNumSamples(tex: PBShaderExp): PBShaderExp;
+    /** Same as textureSample builtin function in WebGPU and texture/texture2D/textureCube builtin function in GLSL */
+    textureSample(tex: PBShaderExp, coords: number | PBShaderExp): PBShaderExp;
+    /** Same as textureSample builtin function in WebGPU and texture builtin function in GLSL, only valid for WebGL2 and WebGPU device */
+    textureArraySample(tex: PBShaderExp, coords: PBShaderExp, arrayIndex: number | PBShaderExp): PBShaderExp;
+    /** Same as textureSampleBias builtin function in WebGPU and texture/texture2D/textureCube builtin function in GLSL */
+    textureSampleBias(tex: PBShaderExp, coords: PBShaderExp, bias: number | PBShaderExp): PBShaderExp;
+    /** Same as textureSampleBias builtin function in WebGPU and texture builtin function in GLSL, only valid for WebGL2 and WebGPU device */
+    textureArraySampleBias(tex: PBShaderExp, coords: PBShaderExp, arrayIndex: number | PBShaderExp, bias: number | PBShaderExp): PBShaderExp;
+    /** Same as textureSampleCompare builtin function in WebGPU and texture builtin function in GLSL, only valid for WebGL2 and WebGPU device */
+    textureSampleCompare(tex: PBShaderExp, coords: PBShaderExp, depthRef: number | PBShaderExp): PBShaderExp;
+    /** Same as textureSampleCompare builtin function in WebGPU and texture builtin function in GLSL, only valid for WebGL2 and WebGPU device */
+    textureArraySampleCompare(tex: PBShaderExp, coords: PBShaderExp, arrayIndex: number | PBShaderExp, depthRef: number | PBShaderExp): PBShaderExp;
+    /** Same as textureSampleLevel builtin function in WebGPU and textureLod/texture2DLodExt/textureCubeLodExt builtin function in GLSL */
+    textureSampleLevel(tex: PBShaderExp, coords: PBShaderExp): PBShaderExp;
+    /** Same as textureSampleLevel builtin function in WebGPU and textureLod/texture2DLodExt/textureCubeLodExt builtin function in GLSL */
+    textureSampleLevel(tex: PBShaderExp, coords: PBShaderExp, level: number | PBShaderExp): PBShaderExp;
+    /** Same as textureSampleLevel builtin function in WebGPU and textureLod builtin function in GLSL, only valid for WebGL2 and WebGPU device */
+    textureArraySampleLevel(tex: PBShaderExp, coords: PBShaderExp, arrayIndex: number | PBShaderExp, level: number | PBShaderExp): PBShaderExp;
+    /** Same as textureSampleCompareLevel builtin function in WebGPU and texture/textureLod builtin function in GLSL, only valid for WebGL2 and WebGPU device */
+    textureSampleCompareLevel(tex: PBShaderExp, coords: PBShaderExp, depthRef: number | PBShaderExp): PBShaderExp;
+    /** Same as textureSampleCompareLevel builtin function in WebGPU and texture builtin function in GLSL, only valid for WebGL2 and WebGPU device */
+    textureArraySampleCompareLevel(tex: PBShaderExp, coords: PBShaderExp, arrayIndex: number | PBShaderExp, depthRef: number | PBShaderExp): PBShaderExp;
+    /** Same as textureSampleGrad builtin function in WebGPU and textureGrad/texture2DGradExt/textureCubeGradExt builtin function in GLSL */
+    textureSampleGrad(tex: PBShaderExp, coords: PBShaderExp, ddx: PBShaderExp, ddy: PBShaderExp): PBShaderExp;
+    /** Same as textureSampleGrad builtin function in WebGPU and textureGrad builtin function in GLSL, only valid for WebGL2 and WebGPU device */
+    textureArraySampleGrad(tex: PBShaderExp, coords: PBShaderExp, arrayIndex: number | PBShaderExp, ddx: PBShaderExp, ddy: PBShaderExp): PBShaderExp;
+    /** Same as storageBarrier builtin function in WebGPU, only valid for WebGPU device */
+    storageBarrier(): void;
+    /** Same as workgroupBarrier builtin function in WebGPU, only valid for WebGPU device */
+    workgroupBarrier(): void;
+    /** atomicLoad, only valid for WebGPU device */
+    atomicLoad(ptr: PBShaderExp): any;
+    /** atomicStore, only valid for WebGPU device */
+    atomicStore(ptr: PBShaderExp, value: number | PBShaderExp): any;
+    /** atomicAdd, only valid for WebGPU device */
+    atomicAdd(ptr: PBShaderExp, value: number | PBShaderExp): PBShaderExp;
+    /** atomicSub, only valid for WebGPU device */
+    atomicSub(ptr: PBShaderExp, value: number | PBShaderExp): PBShaderExp;
+    /** atomicMax, only valid for WebGPU device */
+    atomicMax(ptr: PBShaderExp, value: number | PBShaderExp): PBShaderExp;
+    /** atomicMin, only valid for WebGPU device */
+    atomicMin(ptr: PBShaderExp, value: number | PBShaderExp): PBShaderExp;
+    /** atomicAnd, only valid for WebGPU device */
+    atomicAnd(ptr: PBShaderExp, value: number | PBShaderExp): PBShaderExp;
+    /** atomicOr, only valid for WebGPU device */
+    atomicOr(ptr: PBShaderExp, value: number | PBShaderExp): PBShaderExp;
+    /** atomicXor, only valid for WebGPU device */
+    atomicXor(ptr: PBShaderExp, value: number | PBShaderExp): PBShaderExp;
+}
+/**
+ * The program builder class
+ * @public
+ */
+declare class ProgramBuilder {
+    /**
+     * Creates a program builder for given device
+     * @param device - The device
+     */
+    constructor(device: AbstractDevice);
+    /** Get last error */
+    get lastError(): string;
+    /** Current shader kind */
+    get shaderKind(): ShaderKind;
+    get emulateDepthClamp(): boolean;
+    set emulateDepthClamp(val: boolean);
+    /** Get the shader code reflection interface */
+    getReflection(): PBReflection;
+}
+/**
+ * Base class for scope of the shader program
+ * @public
+ */
+declare class PBScope extends Proxiable<PBScope> {
+    [props: string]: any;
+    /** Get the program builder */
+    get $builder(): ProgramBuilder;
+    /** Returns the scope of the builtin variables */
+    get $builtins(): PBBuiltinScope;
+    /** Returns the scope of the input variables */
+    get $inputs(): PBInputScope;
+    /** Returns the scope of the output variables */
+    get $outputs(): PBOutputScope;
+    /**
+     * Get the input vertex attribute by specified semantic
+     *
+     * @remarks
+     * Can only be called only in vertex shader
+     *
+     * @param semantic - The vertex semantic
+     * @returns The input vertex attribute or null if not exists
+     */
+    $getVertexAttrib(semantic: VertexSemantic): PBShaderExp;
+    /** Get the current local scope */
+    get $l(): PBLocalScope;
+    /** Get the global scope */
+    get $g(): PBGlobalScope;
+    /**
+     * Query the global variable by the name
+     * @param name - Name of the variable
+     * @returns The variable or null if not exists
+     */
+    $query(name: string): PBShaderExp;
+}
+/**
+ * The local scope of a shader
+ * @public
+ */
+declare class PBLocalScope extends PBScope {
+    [props: string]: any;
+    constructor(scope: PBScope);
+}
+/**
+ * The builtin scope of a shader
+ * @public
+ */
+interface PBBuiltinScope {
+    position: PBShaderExp;
+    pointSize: PBShaderExp | number;
+    fragDepth: PBShaderExp;
+    readonly fragCoord: PBShaderExp;
+    readonly frontFacing: PBShaderExp;
+    readonly vertexIndex: PBShaderExp;
+    readonly instanceIndex: PBShaderExp;
+    readonly localInvocationId: PBShaderExp;
+    readonly globalInvocationId: PBShaderExp;
+    readonly workGroupId: PBShaderExp;
+    readonly numWorkGroups: PBShaderExp;
+    readonly sampleMaskIn: PBShaderExp;
+    sampleMaskOut: PBShaderExp;
+    readonly sampleIndex: PBShaderExp;
+}
+/**
+ * The builtin scope of a shader
+ * @public
+ */
+declare class PBBuiltinScope extends PBScope {
+    constructor();
+}
+/**
+ * The input scope of a shader
+ * @public
+ */
+declare class PBInputScope extends PBScope {
+}
+/**
+ * The output scope of a shader
+ * @public
+ */
+declare class PBOutputScope extends PBScope {
+    constructor();
+}
+/**
+ * The global scope of a shader
+ * @public
+ */
+declare class PBGlobalScope extends PBScope {
+}
+/**
+ * Scope that is inside a function
+ * @public
+ */
+declare class PBInsideFunctionScope extends PBScope {
+    /**
+     * Creates a 'return' statement
+     * @param retval - The return value
+     */
+    $return(retval?: ExpValueType): void;
+    /**
+     * Creates a new scope
+     * @param body - Generator function for the scope
+     * @returns The created scope
+     */
+    $scope(body: (this: PBInsideFunctionScope) => void): PBInsideFunctionScope;
+    /**
+     * Creates an 'if' statement
+     * @param condition - Condition expression for the if statement
+     * @param body - Generator function for the scope inside the if statement
+     * @returns The scope inside the if statement
+     */
+    $if(condition: ExpValueNonArrayType, body: (this: PBIfScope) => void): PBIfScope;
+    /**
+     * Creates a select statement: condition ? first : second
+     * @param condition - Condition expression
+     * @param first - The first value
+     * @param second - The second value
+     * @returns The first value if condition evaluates to true, otherwise returns the second value
+     */
+    $choice(condition: ExpValueNonArrayType, first: ExpValueNonArrayType, second: ExpValueNonArrayType): PBShaderExp;
+    /** Creates a 'break' statement */
+    $break(): void;
+    /** Creates a 'continue' statement */
+    $continue(): void;
+    /**
+     * Creates a 'for' statement
+     * @param counter - The repeat counter variable declaration
+     * @param init - initial value of the repeat counter variable
+     * @param end - end value of the counter exclusive
+     * @param body - Generator function for the scope that inside the for statement
+     */
+    $for(counter: PBShaderExp, init: number | PBShaderExp, end: number | PBShaderExp, body: (this: PBForScope) => void): void;
+    /**
+     * Creates a 'do..while' statement
+     * @param body - Generator function for the scope that inside the do..while statment
+     * @returns The scope that inside the do..while statement
+     */
+    $do(body: (this: PBDoWhileScope) => void): PBDoWhileScope;
+    /**
+     * Creates a 'while' statement
+     * @param condition - Condition expression for the while statement
+     * @param body - Generator function for the scope that inside the while statement
+     */
+    $while(condition: ExpValueNonArrayType, body: (this: PBWhileScope) => void): void;
+}
+/**
+ * Scope that insides a function
+ * @public
+ */
+declare class PBFunctionScope extends PBInsideFunctionScope {
+}
+/**
+ * Scope that insides a while statement
+ * @public
+ */
+declare class PBWhileScope extends PBInsideFunctionScope {
+}
+/**
+ * Scope that insides a do..while statement
+ * @public
+ */
+declare class PBDoWhileScope extends PBInsideFunctionScope {
+    $while(condition: ExpValueNonArrayType): void;
+}
+/**
+ * Scope that insides a for statement
+ * @public
+ */
+declare class PBForScope extends PBInsideFunctionScope {
+}
+/**
+ * A naked scope
+ * @public
+ */
+declare class PBNakedScope extends PBInsideFunctionScope {
+}
+/**
+ * Scope that insides an if statement
+ * @public
+ */
+declare class PBIfScope extends PBInsideFunctionScope {
+    /**
+     * Creates an 'else if' branch
+     * @param condition - Condition expression for the else if branch
+     * @param body - Generator function for the scope that insides the else if statement
+     * @returns The scope that insides the else if statement
+     */
+    $elseif(condition: ExpValueNonArrayType, body: (this: PBIfScope) => void): PBIfScope;
+    /**
+     * Creates an 'else' branch
+     * @param body - Generator function for the scope that insides the else statement
+     */
+    $else(body: (this: PBIfScope) => void): void;
+}
+
+/**
+ * The render states related to the fragment output
+ * @public
+ */
+interface ColorState {
+    /** Creates a new ColorState by copying this one */
+    clone(): ColorState;
+    /** true if it is enabled to write to the red channel */
+    redMask: boolean;
+    /** true if it is enabled to write to the green channel */
+    greenMask: boolean;
+    /** true if it is enabled to write to the blue channel */
+    blueMask: boolean;
+    /** true if it is enabled to write to the alpha channel */
+    alphaMask: boolean;
+    /**
+     * Set fragment write mask
+     * @param r - true if writing to the red channel is allowed
+     * @param g - true if writing to the green channel is allowed
+     * @param b - true if writing to the blue channel is allowed
+     * @param a - true if writing to the alpha channel is allowed
+     */
+    setColorMask(r: boolean, g: boolean, b: boolean, a: boolean): this;
+}
+/**
+ * Type of the alpha blending equations
+ * @public
+ */
+type BlendEquation = 'add' | 'subtract' | 'reverse-subtract' | 'min' | 'max';
+/**
+ * Type of the blending functions
+ * @public
+ */
+type BlendFunc = 'zero' | 'one' | 'src-alpha' | 'inv-src-alpha' | 'src-alpha-saturate' | 'dst-alpha' | 'inv-dst-alpha' | 'src-color' | 'inv-src-color' | 'dst-color' | 'inv-dst-color' | 'const-color' | 'inv-const-color' | 'const-alpha' | 'inv-const-alpha';
+/**
+ * The render states related to alpha blending
+ * @public
+ */
+interface BlendingState {
+    /** Creates a new BlendingState by copying this one */
+    clone(): BlendingState;
+    /** true if alpha blending is enabled */
+    enabled: boolean;
+    /** true if alpha to coverage is enabled */
+    alphaToCoverageEnabled: boolean;
+    /** The source blending factor for RGB channels */
+    srcBlendRGB: BlendFunc;
+    /** The destination blending factor for RGB channels */
+    dstBlendRGB: BlendFunc;
+    /** The source blending factor for alpha channel */
+    srcBlendAlpha: BlendFunc;
+    /** The destination blending factor for alpha channel */
+    dstBlendAlpha: BlendFunc;
+    /** The blending equation for RGB channels */
+    rgbEquation: BlendEquation;
+    /** The blending equation for alpha channel */
+    alphaEquation: BlendEquation;
+    /**
+     * Enable or disable alpha blending
+     * @param b - true if enable
+     * @returns self
+     */
+    enable(b: boolean): this;
+    /**
+     * Enable or disable alpha to coverage
+     * @param b - true if enable
+     * @returns self
+     */
+    enableAlphaToCoverage(b: boolean): this;
+    /**
+     * Sets the blending function for both RGB channels and the alpha channel
+     * @param src - The source blending function
+     * @param dest - The destination blending function
+     * @returns self
+     */
+    setBlendFunc(src: BlendFunc, dest: BlendFunc): this;
+    /**
+     * Sets the blending function for RGB channels
+     * @param src - The source blending function
+     * @param dest - The destination blending function
+     * @returns self
+     */
+    setBlendFuncRGB(src: BlendFunc, dest: BlendFunc): this;
+    /**
+     * Sets the blending function for the alpha channel
+     * @param src - The source blending function
+     * @param dest - The destination blending function
+     * @returns self
+     */
+    setBlendFuncAlpha(src: BlendFunc, dest: BlendFunc): this;
+    /**
+     * Sets the blending equations for RGB channels and the alpha channel
+     * @param rgb - The blending equation for RGB channels
+     * @param alpha - The blending equation for the alpha channel
+     * @returns self
+     */
+    setBlendEquation(rgb: BlendEquation, alpha: BlendEquation): this;
+}
+/**
+ * The face mode
+ * @public
+ */
+type FaceMode = 'none' | 'front' | 'back';
+/**
+ * The type of face winding
+ * @public
+ */
+type FaceWinding = 'cw' | 'ccw';
+/**
+ * The render states related to primitive rasterization
+ * @public
+ */
+interface RasterizerState {
+    /** Creates a new RasterizerState by copying this one */
+    clone(): RasterizerState;
+    /** Triangle cull mode */
+    cullMode: FaceMode;
+    /** Depth clamp enabled */
+    depthClampEnabled: boolean;
+    /**
+     * Sets the cull mode
+     * @param mode - The cull mode to set
+     * @returns self
+     */
+    setCullMode(mode: FaceMode): this;
+    /**
+     * Enable or disable depth clamp if supported
+     * @param enable - Enables depth clamp if true, otherwise disable
+     */
+    enableDepthClamp(enable: boolean): this;
+}
+/**
+ * The render states related to depth buffer
+ * @public
+ */
+interface DepthState {
+    /** Creates a new DepthState by copying this one */
+    clone(): DepthState;
+    /** true if depth testing should be enabled */
+    testEnabled: boolean;
+    /** true if depth writing should be enabled */
+    writeEnabled: boolean;
+    /** The comparison function for depth testing */
+    compareFunc: CompareFunc;
+    /**
+     * Enable or disable depth testing
+     * @param b - true if enable
+     * @returns self
+     */
+    enableTest(b: boolean): this;
+    /**
+     * Enable or disable depth writing
+     * @param b - true if enable
+     * @returns self
+     */
+    enableWrite(b: boolean): this;
+    /**
+     * Sets the comparison function for depth testing
+     * @param func - The comparison function
+     * @returns self
+     */
+    setCompareFunc(func: CompareFunc): this;
+}
+/**
+ * Stencil operations
+ * @public
+ */
+type StencilOp = 'keep' | 'zero' | 'replace' | 'incr' | 'incr-wrap' | 'decr' | 'decr-wrap' | 'invert';
+/**
+ * The render states related to the stencil buffer
+ * @public
+ */
+interface StencilState {
+    /** Creates a new StencilState by copying this one */
+    clone(): StencilState;
+    /** true if stencil testing should be enabled */
+    enabled: boolean;
+    /** The function to use for front stencil state when the stencil test fails */
+    failOp: StencilOp;
+    /** The function to use for back stencil state when the stencil test fails of the back stencil state */
+    failOpBack: StencilOp;
+    /** The function to use for front stencil state when the stencil test passes but depth test fails */
+    zFailOp: StencilOp;
+    /** The function to use for back stencil state when the stencil test passes but depth test fails */
+    zFailOpBack: StencilOp;
+    /** The function to use for front stencil state when both the stencil test and the depth test pass */
+    passOp: StencilOp;
+    /** The function to use for back stencil state when both the stencil test and the depth test pass */
+    passOpBack: StencilOp;
+    /** The test function for front stencil state */
+    func: CompareFunc;
+    /** The test function for back stencil state */
+    funcBack: CompareFunc;
+    /** The reference value for the stencil test */
+    ref: number;
+    /** A bit mask to control which bits can be written while writing to the stencil buffer */
+    writeMask: number;
+    /** A bit mask that is used to AND the reference value and the stored stencil value */
+    readMask: number;
+    /**
+     * Enables or disables the stencil test
+     * @param b - true if stencil test should be enabled
+     * @returns self
+     */
+    enable(b: boolean): this;
+    /**
+     * Sets the stencil operations for front stencil state
+     * @param fail - The function to use when the stencil test fails
+     * @param zfail - The function to use when the stencil test passes bug depth test fails
+     * @param pass - The function to use when both the stencil test and the depth test pass
+     * @returns self
+     */
+    setFrontOp(fail: StencilOp, zfail: StencilOp, pass: StencilOp): this;
+    /**
+     * Sets the stencil operations for back stencil state
+     * @param fail - The function to use when the stencil test fails
+     * @param zfail - The function to use when the stencil test passes bug depth test fails
+     * @param pass - The function to use when both the stencil test and the depth test pass
+     * @returns self
+     */
+    setBackOp(fail: StencilOp, zfail: StencilOp, pass: StencilOp): this;
+    /**
+     * Sets the compare function for front stencil state
+     * @param func - The compare function
+     * @returns self
+     */
+    setFrontCompareFunc(func: CompareFunc): this;
+    /**
+     * Sets the compare function for back stencil state
+     * @param func - The compare function
+     * @returns self
+     */
+    setBackCompareFunc(func: CompareFunc): this;
+    /**
+     * Sets the reference value for the stencil test
+     * @param ref - The reference value
+     * @returns self
+     */
+    setReference(ref: number): this;
+    /**
+     * Sets the bit mask for writing to the stencil buffer
+     * @param mask - The write mask
+     * @returns self
+     */
+    setWriteMask(mask: number): this;
+    /**
+     * Sets the bit mask for reading from the stencil buffer and reference value
+     * @param mask - The read mask
+     * @returns self
+     */
+    setReadMask(mask: number): this;
+}
+/**
+ * Set of the render statements
+ * @public
+ */
+interface RenderStateSet {
+    /** Creates a new RenderStateSet by copying this one */
+    copyFrom(stateSet: RenderStateSet): void;
+    /** Fragment output related render statements or null if the default values should be used */
+    readonly colorState: ColorState;
+    /** Alpha blending related render statements or null if the default values should be used */
+    readonly blendingState: BlendingState;
+    /** Rasterization related render statements or null if the default values should be used */
+    readonly rasterizerState: RasterizerState;
+    /** Depth buffer related render statements or null if the default values should be used */
+    readonly depthState: DepthState;
+    /** Stencil buffer related render statements or null if the default values should be used */
+    readonly stencilState: StencilState;
+    /**
+     * Allocates a ColorState
+     * @returns The created ColorState
+     */
+    useColorState(state?: ColorState): ColorState;
+    /**
+     * Deletes the ColorState that was allocated by {@link RenderStateSet.useColorState}, so that the default value will be used
+     */
+    defaultColorState(): void;
+    /**
+     * Allocates a BlendingState
+     * @returns The created BlendingState
+     */
+    useBlendingState(state?: BlendingState): BlendingState;
+    /**
+     * Deletes the BlendingState that was allocated by {@link RenderStateSet.useBlendingState}, so that the default value will be used
+     */
+    defaultBlendingState(): void;
+    /**
+     * Allocates a RasterizerState
+     * @returns The created RasterizerState
+     */
+    useRasterizerState(state?: RasterizerState): RasterizerState;
+    /**
+     * Deletes the RasterizerState that was allocated by {@link RenderStateSet.useRasterizerState}, so that the default value will be used
+     */
+    defaultRasterizerState(): void;
+    /**
+     * Allocates a DepthState
+     * @returns The created DepthState
+     */
+    useDepthState(state?: DepthState): DepthState;
+    /**
+     * Deletes the DepthState that was allocated by {@link RenderStateSet.useDepthState}, so that the default value will be used
+     */
+    defaultDepthState(): void;
+    /**
+     * Allocates a StencilState
+     * @returns The created StencilState
+     */
+    useStencilState(state?: StencilState): StencilState;
+    /**
+     * Deletes the StencilState that was allocated by {@link RenderStateSet.useStencilState}, so that the default value will be used
+     */
+    defaultStencilState(): void;
+    /**
+     * Applis the render statements to current device
+     * @param force - Force applying all render statements
+     */
+    apply(force?: boolean): void;
+}
+
+/**
+ * The webgl context type
+ * @public
+ */
+type WebGLContext = WebGLRenderingContext | WebGL2RenderingContext;
+/**
+ * The texture type
+ * @public
+ */
+type TextureType = '2d' | '3d' | 'cube' | '2darray';
+/**
+ * The comparison function type
+ * @public
+ */
+type CompareFunc = 'always' | 'le' | 'ge' | 'lt' | 'gt' | 'eq' | 'ne' | 'never';
+/**
+ * The texture address mode
+ * @public
+ */
+type TextureAddressMode = 'repeat' | 'mirrored-repeat' | 'clamp';
+/**
+ * The texture filter mode
+ * @public
+ */
+type TextureFilterMode = 'none' | 'nearest' | 'linear';
+/**
+ * Scalar data type
+ * @public
+ */
+type DataType = 'u8' | 'u8norm' | 'i8' | 'i8norm' | 'u16' | 'u16norm' | 'i16' | 'i16norm' | 'u32' | 'i32' | 'f16' | 'f32';
+/**
+ * Texture format type
+ * @public
+ */
+type TextureFormat = 'unknown' | 'r8unorm' | 'r8snorm' | 'r16f' | 'r32f' | 'r8ui' | 'r8i' | 'r16ui' | 'r16i' | 'r32ui' | 'r32i' | 'rg8unorm' | 'rg8snorm' | 'rg16f' | 'rg32f' | 'rg8ui' | 'rg8i' | 'rg16ui' | 'rg16i' | 'rg32ui' | 'rg32i' | 'rgba8unorm' | 'rgba8unorm-srgb' | 'rgba8snorm' | 'bgra8unorm' | 'bgra8unorm-srgb' | 'rgba16f' | 'rgba32f' | 'rgba8ui' | 'rgba8i' | 'rgba16ui' | 'rgba16i' | 'rgba32ui' | 'rgba32i' | 'rg11b10uf' | 'd16' | 'd24' | 'd32f' | 'd24s8' | 'd32fs8' | 'dxt1' | 'dxt1-srgb' | 'dxt3' | 'dxt3-srgb' | 'dxt5' | 'dxt5-srgb';
+/**
+ * Converts a non-sRGB texture format to the corresponding sRGB texture format
+ * @param format - The texture format to be converted
+ * @returns The sRGB texture format
+ * @public
+ */
+declare function linearTextureFormatToSRGB(format: TextureFormat): TextureFormat;
+/**
+ * Check if a given texture format contains an alpha channel.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format contains an alpha channel, otherwise false
+ * @public
+ */
+declare function hasAlphaChannel(format: TextureFormat): boolean;
+/**
+ * Check if a given texture format contains a red channel.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format contains a red channel, otherwise false
+ * @public
+ */
+declare function hasRedChannel(format: TextureFormat): boolean;
+/**
+ * Check if a given texture format contains a green channel.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format contains a green channel, otherwise false
+ * @public
+ */
+declare function hasGreenChannel(format: TextureFormat): boolean;
+/**
+ * Check if a given texture format contains a blue channel.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format contains a blue channel, otherwise false
+ * @public
+ */
+declare function hasBlueChannel(format: TextureFormat): boolean;
+/**
+ * Check if a given texture format contains a depth channel.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format contains a depth channel, otherwise false
+ * @public
+ */
+declare function hasDepthChannel(format: TextureFormat): boolean;
+/**
+ * Check if a given texture format contains a stencil channel.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format contains a stencil channel, otherwise false
+ * @public
+ */
+declare function hasStencilChannel(format: TextureFormat): boolean;
+/**
+ * Check whether a given texture format is floating-point.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format is floating-point, otherwise false
+ * @public
+ */
+declare function isFloatTextureFormat(format: TextureFormat): boolean;
+/**
+ * Check whether a given texture format is integer.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format is integer, otherwise false
+ * @public
+ */
+declare function isIntegerTextureFormat(format: TextureFormat): boolean;
+/**
+ * Check whether a given texture format is signed.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format is signed, otherwise false
+ * @public
+ */
+declare function isSignedTextureFormat(format: TextureFormat): boolean;
+/**
+ * Check whether a given texture format is a compressed format.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format is a compressed format, otherwise false
+ * @public
+ */
+declare function isCompressedTextureFormat(format: TextureFormat): boolean;
+/**
+ * Check whether a given texture format is sRGB format.
+ * @param format - The texture format to be checked.
+ * @returns true if the texture format is sRGB format, otherwise false
+ * @public
+ */
+declare function isSRGBTextureFormat(format: TextureFormat): boolean;
+/**
+ * Get block size of given texture format
+ * @param format - The texture format
+ * @returns The block size
+ * @public
+ */
+declare function getTextureFormatBlockSize(format: TextureFormat): number;
+/**
+ * Get block width of given texture format
+ * @param format - The texture format
+ * @returns The block width
+ * @public
+ */
+declare function getTextureFormatBlockWidth(format: TextureFormat): number;
+/**
+ * Get block height of given texture format
+ * @param format - The texture format
+ * @returns The block height
+ * @public
+ */
+declare function getTextureFormatBlockHeight(format: TextureFormat): number;
+/**
+ * The primitive type
+ * @public
+ */
+type PrimitiveType = 'triangle-list' | 'triangle-strip' | 'triangle-fan' | 'line-list' | 'line-strip' | 'point-list';
+/**
+ * Shader type
+ * @public
+ */
+declare enum ShaderType {
+    Vertex = 1,
+    Fragment = 2,
+    Compute = 4
+}
+/**
+ * Shader kind
+ * @public
+ */
+type ShaderKind = 'vertex' | 'fragment' | 'compute';
+/**
+ * Frame information
+ * @public
+ */
+interface FrameInfo {
+    /** counter of frames */
+    frameCounter: number;
+    /** timestamp of current frame, in milliseconds */
+    frameTimestamp: number;
+    /** time spent by the CPU from last frame, in milliseconds */
+    elapsedTimeCPU: number;
+    /** time spent by the GPU from last frame, in milliseconds */
+    elapsedTimeGPU: number;
+    /** time spent from last frame, in milliseconds */
+    elapsedFrame: number;
+    /** time spent from the first frame, in milliseconds */
+    elapsedOverall: number;
+    /** the FPS calculated for the last one second  */
+    FPS: number;
+    /** How many draw calls were sent to the GPU in current frame */
+    drawCalls: number;
+    /** How many compute calls were sent to the GPU in current frame */
+    computeCalls: number;
+}
+/**
+ * List of all gpu objects
+ * @public
+ */
+interface GPUObjectList {
+    /** list of textures */
+    textures: BaseTexture[];
+    /** list of samplers */
+    samplers: TextureSampler[];
+    /** list of buffers */
+    buffers: GPUDataBuffer[];
+    /** list of programs */
+    programs: GPUProgram[];
+    /** list of frame buffers */
+    framebuffers: FrameBuffer[];
+    /** list of vertex layouts */
+    vertexArrayObjects: VertexLayout[];
+    /** list of bind groups */
+    bindGroups: BindGroup[];
+}
+/**
+ * The device capabilities
+ * @public
+ */
+interface DeviceCaps {
+    /** Miscellaneous capabilities */
+    miscCaps: MiscCaps;
+    /** Frame buffer related capabilities */
+    framebufferCaps: FramebufferCaps;
+    /** Shader related capabilities */
+    shaderCaps: ShaderCaps;
+    /** Texture related capabilities */
+    textureCaps: TextureCaps;
+}
+/**
+ * Frame buffer related capabilities of the device
+ * @public
+ */
+interface FramebufferCaps {
+    /** The maximum number of framebuffer color attachment points */
+    maxDrawBuffers: number;
+    /** True if device supports multisampled frame buffer */
+    supportMultisampledFramebuffer: boolean;
+    /** True if device supports blending on float point frame buffer */
+    supportFloatBlending: boolean;
+    /** True if device supports 32bits float depth buffer */
+    supportDepth32float: boolean;
+    /** True if device supports 32bits float depth buffer with 8bits stencil */
+    supportDepth32floatStencil8: boolean;
+    /** Maximum color attachment bytes per sample */
+    maxColorAttachmentBytesPerSample: number;
+}
+/**
+ * Miscellaneous capabilities of the device
+ * @public
+ */
+interface MiscCaps {
+    /** True if the device supports oversized viewport */
+    supportOversizedViewport: boolean;
+    /** True if the device supports minimum and maximum blending equations */
+    supportBlendMinMax: boolean;
+    /** True if the device supports 32-bits index buffer */
+    support32BitIndex: boolean;
+    /** The maximum number of {@link BindGroupLayout}'s in a shader program */
+    maxBindGroups: number;
+    /** The maximum number of texture coordinate index */
+    maxTexCoordIndex: number;
+}
+/**
+ * Shader related capabilities of the device
+ * @public
+ */
+interface ShaderCaps {
+    /** True if the device supports writing depth value in a fragment shader */
+    supportFragmentDepth: boolean;
+    /** True if the device supports derivative functions in a fragment shader */
+    supportStandardDerivatives: boolean;
+    /** True if the device supports explicit control of texture LOD in a fragment shader */
+    supportShaderTextureLod: boolean;
+    /** True if the device supports high precison float number for shader programs */
+    supportHighPrecisionFloat: boolean;
+    /** True if the device supports high precison integer number for shader programs */
+    supportHighPrecisionInt: boolean;
+    /** The maximum number of bytes of uniform buffer */
+    maxUniformBufferSize: number;
+    /** The uniform buffer offset alignment */
+    uniformBufferOffsetAlignment: number;
+}
+/**
+ * Information of a texture format
+ * @public
+ */
+interface TextureFormatInfo {
+    /** True if the texture format supports linear filtering */
+    filterable: boolean;
+    /** True if the texture format can be used as a render target */
+    renderable: boolean;
+    /** True if the texture format is a compressed format */
+    compressed: boolean;
+}
+/**
+ * Texture related capabilities of the device'
+ * @public
+ */
+interface TextureCaps {
+    /** The maximum size for 2d texture */
+    maxTextureSize: number;
+    /** The maximum size for cube texture */
+    maxCubeTextureSize: number;
+    /** True if mipmapping is supported for non power of 2 textures */
+    npo2Mipmapping: boolean;
+    /** True if repeat address mode is supported for non power of 2 textures */
+    npo2Repeating: boolean;
+    /** True if device supports dxt1, dxt3, dxt5 texture format */
+    supportS3TC: boolean;
+    /** True if device supports dxt1_srgb, dxt3-srgb, dxt5-srgb texture format */
+    supportS3TCSRGB: boolean;
+    /** True if device supports depth texture */
+    supportDepthTexture: boolean;
+    /** True if device supports 3d texture */
+    support3DTexture: boolean;
+    /** True if device supports sRGB texture */
+    supportSRGBTexture: boolean;
+    /** True if device supports 32bit floating-point texture */
+    supportFloatTexture: boolean;
+    /** True if device supports linear filtering on 32bit floating-point textures */
+    supportLinearFloatTexture: boolean;
+    /** True if device supports 16bit floating-point texture */
+    supportHalfFloatTexture: boolean;
+    /** True if device supports linear filtering on 16bit floating-point textures */
+    supportLinearHalfFloatTexture: boolean;
+    /** True if device supports anisotropic filtering */
+    supportAnisotropicFiltering: boolean;
+    /** True if device supports rendering into a 32bit floating-point frame buffer */
+    supportFloatColorBuffer: boolean;
+    /** True if device supports rendering into a 16bit floating-point frame buffer */
+    supportHalfFloatColorBuffer: boolean;
+    /** True if device supports alpha blending with floating-point frame buffer */
+    supportFloatBlending: boolean;
+    /**
+     * Get information of a given texture format
+     * @param format - The texture format
+     * @returns the texture format infomation
+     */
+    getTextureFormatInfo(format: TextureFormat): TextureFormatInfo;
+}
+/**
+ * Creation options of rendering shader program
+ * @public
+ */
+interface RenderProgramConstructParams {
+    /** The vertex shader source code */
+    vs: string;
+    /** The fragment shader source code */
+    fs: string;
+    /** Bind group layouts for the program */
+    bindGroupLayouts: BindGroupLayout[];
+    /** Vertex attributes used in the program */
+    vertexAttributes: number[];
+}
+/**
+ * Creation options of computing shader program
+ * @public
+ */
+interface ComputeProgramConstructParams {
+    /** The shader source */
+    source: string;
+    /** Bind group layouts for the program */
+    bindGroupLayouts: BindGroupLayout[];
+}
+/**
+ * Creation options for shader program
+ * @public
+ */
+interface GPUProgramConstructParams {
+    /** Type of the program to be created */
+    type: 'render' | 'compute';
+    /** Label of the program */
+    label?: string;
+    /** The creation options */
+    params: RenderProgramConstructParams | ComputeProgramConstructParams;
+}
+/**
+ * Event that will be fired when device is lost
+ * @public
+ */
+declare class DeviceLostEvent {
+    /** The event name */
+    static readonly NAME: "devicelost";
+    type: "devicelost";
+}
+/**
+ * Event that will be fired when device has just been restored
+ * @public
+ */
+declare class DeviceRestoreEvent {
+    /** The event name */
+    static readonly NAME: "devicerestored";
+    type: "devicerestored";
+}
+/**
+ * Event that will be fired when size of back buffer has changed
+ * @public
+ */
+declare class DeviceResizeEvent {
+    /** The event name */
+    static readonly NAME: "resize";
+    width: number;
+    height: number;
+    type: "resize";
+    constructor(width: number, height: number);
+}
+/**
+ * Event that will be fired when any gpu object is created
+ * @public
+ */
+declare class DeviceGPUObjectAddedEvent {
+    /** the event name */
+    static readonly NAME: "gpuobject_added";
+    object: GPUObject;
+    type: "gpuobject_added";
+    constructor(obj: GPUObject);
+}
+/**
+ * Event that will be fired when any gpu object is disposed
+ * @public
+ */
+declare class DeviceGPUObjectRemovedEvent {
+    /** The event name */
+    static readonly NAME: 'gpuobject_removed';
+    object: GPUObject;
+    type: "gpuobject_removed";
+    constructor(obj: GPUObject);
+}
+/**
+ * Event that will be fired when any gpu object name is changed
+ * @public
+ */
+declare class DeviceGPUObjectRenameEvent {
+    /** The event name */
+    static readonly NAME: 'gpuobject_rename';
+    object: GPUObject;
+    lastName: string;
+    type: "gpuobject_rename";
+    constructor(obj: GPUObject, lastName: string);
+}
+/**
+ * Creation options for device
+ * @public
+ */
+interface DeviceOptions {
+    /** True if the device must have a MSAA back buffer */
+    msaa?: boolean;
+    /** The device pixel ratio */
+    dpr?: number;
+}
+/**
+ * The device event map
+ * @public
+ */
+type DeviceEventMap = {
+    [DeviceResizeEvent.NAME]: DeviceResizeEvent;
+    [DeviceLostEvent.NAME]: DeviceLostEvent;
+    [DeviceRestoreEvent.NAME]: DeviceRestoreEvent;
+    [DeviceGPUObjectAddedEvent.NAME]: DeviceGPUObjectAddedEvent;
+    [DeviceGPUObjectRemovedEvent.NAME]: DeviceGPUObjectRemovedEvent;
+    [DeviceGPUObjectRenameEvent.NAME]: DeviceGPUObjectRenameEvent;
+};
+/**
+ * Structure that contains the device viewport information
+ * @public
+ */
+type DeviceViewport = {
+    /** viewport left */
+    x: number;
+    /** viewport top */
+    y: number;
+    /** viewport width */
+    width: number;
+    /** viewport height */
+    height: number;
+    /**
+     * A boolean value that indicates whether this is full screen viewport
+     * @remarks
+     * The full screen viewport will be automatically resized when the screen size chenged
+     */
+    default: boolean;
+};
+/**
+ * Abstract interface for the rendering device.
+ * @public
+ */
+interface AbstractDevice extends IEventTarget<DeviceEventMap> {
+    /** Get sample count of current frame buffer */
+    getFrameBufferSampleCount(): number;
+    /** Returns true if device context is lost. */
+    isContextLost(): boolean;
+    /** Get the value of device pixel ratio */
+    getScale(): number;
+    /** Get the width of current frame buffer */
+    getDrawingBufferWidth(): number;
+    /** Get the height of current frame buffer */
+    getDrawingBufferHeight(): number;
+    /** Get the width of back buffer */
+    getBackBufferWidth(): number;
+    /** Get the height of back buffer */
+    getBackBufferHeight(): number;
+    /** Get the device capabilities */
+    getDeviceCaps(): DeviceCaps;
+    /** Set font for drawText function */
+    setFont(fontName: string): any;
+    /**
+     * Draw a string
+     * @param text - The string that will be drawn
+     * @param x - x coordinate in pixels related to the viewport origin
+     * @param y - y coordinate in pixels related to the viewport origin
+     * @param color - A CSS color value
+     */
+    drawText(text: string, x: number, y: number, color: string): any;
+    /**
+     * Clears the current frame buffer
+     * @param clearColor - If not null, the color buffer will be cleared to this value.
+     * @param clearDepth - If not null, the depth buffer will be cleared to this value.
+     * @param clearStencil - If not null, the stencil buffer will be cleared to this value.
+     */
+    clearFrameBuffer(clearColor: Vector4, clearDepth: number, clearStencil: number): any;
+    /** Creates a render state set object */
+    createRenderStateSet(): RenderStateSet;
+    /**
+     * Creates a texture sampler object
+     * @param options - The creation options
+     */
+    createSampler(options: SamplerOptions): TextureSampler;
+    /**
+     * Creates a texture from given mipmap data
+     * @param data - Mipmap data
+     * @param options - Texture creation options
+     * @returns The created texture
+     */
+    createTextureFromMipmapData<T extends BaseTexture = BaseTexture>(data: TextureMipmapData, sRGB: boolean, options?: TextureCreationOptions): T;
+    /**
+     * Creates a 2d texture
+     * @param format - The texture format
+     * @param width - Pixel width of the texture
+     * @param height - Pixel height of the texture
+     * @param options - The creation options
+     */
+    createTexture2D(format: TextureFormat, width: number, height: number, options?: TextureCreationOptions): Texture2D;
+    /**
+     * Creates a 2d texture from given mipmap data
+     * @param data - The mipmap data
+     * @param options - The creation options
+     */
+    createTexture2DFromMipmapData(data: TextureMipmapData, sRGB: boolean, options?: TextureCreationOptions): Texture2D;
+    /**
+     * Creates a 2d texture from a image element
+     * @param element - The image element
+     * @param options - The creation options
+     */
+    createTexture2DFromImage(element: TextureImageElement, sRGB: boolean, options?: TextureCreationOptions): Texture2D;
+    /**
+     * Creates a 2d array texture
+     * @param format - The texture format
+     * @param width - Pixel width of the texture
+     * @param height - Pixel height of the texture
+     * @param depth - Array length of the texture
+     * @param options - The creation options
+     */
+    createTexture2DArray(format: TextureFormat, width: number, height: number, depth: number, options?: TextureCreationOptions): Texture2DArray;
+    /**
+     * Creates a 2d array texture from mipmap data
+     * @param data - mipmap data
+     * @param sRGB - whether texture should have sRGB texture format
+     * @param options - The creation options
+     */
+    createTexture2DArrayFromMipmapData(data: TextureMipmapData, options?: TextureCreationOptions): Texture2DArray;
+    /**
+     * Creates a 2d array texture from a seris of image elements
+     * @remarks image elements must have the same size.
+     * @param elements - image elements
+     * @param options - The creation options
+     */
+    createTexture2DArrayFromImages(elements: TextureImageElement[], sRGB: boolean, options?: TextureCreationOptions): Texture2DArray;
+    /**
+     * Creates a 3d texture
+     * @param format - The texture format
+     * @param width - Pixel width of the texture
+     * @param height - Pixel height of the texture
+     * @param depth - Pixel depth of the texture
+     * @param options - The creation options
+     */
+    createTexture3D(format: TextureFormat, width: number, height: number, depth: number, options?: TextureCreationOptions): Texture3D;
+    /**
+     * Creates a cube texture
+     * @param format - The texture format
+     * @param size - Pixel width of the texture
+     * @param options - The creation options
+     */
+    createCubeTexture(format: TextureFormat, size: number, options?: TextureCreationOptions): TextureCube;
+    /**
+     * Creates a cube texture from given mipmap data
+     * @param data - The mipmap data
+     * @param options - The creation options
+     */
+    createCubeTextureFromMipmapData(data: TextureMipmapData, sRGB: boolean, options?: TextureCreationOptions): TextureCube;
+    /**
+     * Creates a video texture from a video element
+     * @param el - The video element
+     */
+    createTextureVideo(el: HTMLVideoElement, samplerOptions?: SamplerOptions): TextureVideo;
+    /**
+     * Set wether to reverse the winding order
+     *
+     * @remarks
+     * The default winding order is counter-clockwise.
+     *
+     * @param reverse - true if the winding order should be reversed.
+     */
+    reverseVertexWindingOrder(reverse: boolean): void;
+    /**
+     * Check if the current winding order is reversed.
+     */
+    isWindingOrderReversed(): boolean;
+    /**
+     * Creates a gpu program
+     * @param params - The creation options
+     */
+    createGPUProgram(params: GPUProgramConstructParams): GPUProgram;
+    /**
+     * Creates a bind group
+     * @param layout - Layout of the bind group
+     */
+    createBindGroup(layout: BindGroupLayout): BindGroup;
+    /**
+     * Creates a gpu buffer
+     * @param sizeInBytes - Size of the buffer in bytes
+     * @param options - The creation options
+     */
+    createBuffer(sizeInBytes: number, options: BufferCreationOptions): GPUDataBuffer;
+    /**
+     * Creates an index buffer
+     * @param data - Data of the index buffer
+     * @param options - The creation options
+     */
+    createIndexBuffer(data: Uint16Array | Uint32Array, options?: BufferCreationOptions): IndexBuffer;
+    /**
+     * Creates a structured buffer
+     * @param structureType - The structure type
+     * @param options - The creation options
+     * @param data - Data to be filled with
+     */
+    createStructuredBuffer(structureType: PBStructTypeInfo, options: BufferCreationOptions, data?: TypedArray): StructuredBuffer;
+    /**
+     * Creates a vertex layout
+     * @param options - The creation options
+     */
+    createVertexLayout(options: VertexLayoutOptions): VertexLayout;
+    /**
+     * Creates a frame buffer
+     * @param options - The creation options
+     */
+    createFrameBuffer(colorAttachments: BaseTexture[], depthAttachment: BaseTexture, options?: FrameBufferOptions): FrameBuffer;
+    /**
+     * Set viewport from an array that contains the position and size
+     *
+     * @param vp - The viewport position and size, if not specified, the viewport will be set to [0, 0, drawingBufferWidth, drawingBufferHeight]
+     */
+    setViewport(vp?: DeviceViewport | number[]): void;
+    /** Get current viewport as [x, y, width, height] */
+    getViewport(): DeviceViewport;
+    /**
+     * Set scissor rectangle from an array that contains the position and size
+     * @param scissor - The scissor rectangle position and size, if not specified, the scissor rectangle will be set to [0, 0, drawingBufferWidth,drawingBufferHeight]
+     */
+    setScissor(scissor?: DeviceViewport | number[]): void;
+    /**
+     * Get current scissor rectangle
+     */
+    getScissor(): DeviceViewport;
+    /**
+     * Set current GPU program
+     * @param program - The GPU program to be set
+     */
+    setProgram(program: GPUProgram): void;
+    /**
+     * Get current GPU program
+     */
+    getProgram(): GPUProgram;
+    /**
+     * Set current vertex layout
+     *
+     * @param vertexData - The vertex layout to be set
+     */
+    setVertexLayout(vertexData: VertexLayout): void;
+    /** Get current vertex layout */
+    getVertexLayout(): VertexLayout;
+    /**
+     * Set current render states
+     *
+     * @param renderStates - The render state set
+     */
+    setRenderStates(renderStates: RenderStateSet): void;
+    /** Get current render states */
+    getRenderStates(): RenderStateSet;
+    /**
+     * Set current frame buffer
+     *
+     * @param rt - The frame buffer
+     */
+    setFramebuffer(rt: FrameBuffer): void;
+    /** Get current frame buffer */
+    getFramebuffer(): FrameBuffer;
+    /**
+     * Set current bind group
+     *
+     * @param index - index of the bind group
+     * @param bindGroup - The bind group to be set
+     * @param dynamicOffsets - dynamic uniform buffer offsets of the bind group or null
+     */
+    setBindGroup(index: number, bindGroup: BindGroup, dynamicOffsets?: Iterable<number>): any;
+    /**
+     * Get current bind group
+     * @param index - index of the bind group to get
+     */
+    getBindGroup(index: number): [BindGroup, Iterable<number>];
+    /** Flush the gpu command buffer */
+    flush(): void;
+    /**
+     * Read pixel values from current frame buffer
+     *
+     * @remarks
+     * This method reads the data asynchronously to prevent GPU stall.
+     * For WebGL1 devices, the GPU stall is still inevitable.
+     *
+     * @param index - color attachment index
+     * @param x - x position of the reading area
+     * @param y - y position of the reading area
+     * @param w - width of the reading area
+     * @param h - height of the reading area
+     * @param buffer - The output buffer
+     */
+    readPixels(index: number, x: number, y: number, w: number, h: number, buffer: TypedArray): Promise<void>;
+    /**
+     * Read pixel values from current frame buffer to a GPU buffer
+     *
+     * @remarks
+     * This method does not support WebGL1 device
+     *
+     * @param index - color attachment index
+     * @param x - x position of the reading area
+     * @param y - y position of the reading area
+     * @param w - width of the reading area
+     * @param h - height of the reading area
+     * @param buffer - The output buffer
+     */
+    readPixelsToBuffer(index: number, x: number, y: number, w: number, h: number, buffer: GPUDataBuffer): void;
+    /** Get the video memory usage in bytes */
+    videoMemoryUsage: number;
+    /** Get the current frame information */
+    frameInfo: FrameInfo;
+    /** Check if the device is running a rendering loop by calling {@link AbstractDevice.runLoop} */
+    isRendering: boolean;
+    /** Get the canvas element for this device */
+    canvas: HTMLCanvasElement;
+    /** Get the device type */
+    type: string;
+    /** Get the program builder */
+    programBuilder: ProgramBuilder;
+    /** Get the run loop callback function */
+    runLoopFunction: (device: AbstractDevice) => void;
+    /**
+     * Begins a frame for rendering
+     *
+     * @remarks
+     * All rendering call must occur between the {@link AbstractDevice.beginFrame} and {@link AbstractDevice.endFrame} methods
+     */
+    beginFrame(): boolean;
+    /**
+     * Ends a frame for rendering
+     *
+     * @remarks
+     * All rendering call must occur between the {@link AbstractDevice.beginFrame} and {@link AbstractDevice.endFrame} methods
+     */
+    endFrame(): void;
+    /**
+     * Get the vertex attribute format from vertex semantic and data type
+     *
+     * @param semantic - The vertex semantic
+     * @param dataType - The data type
+     * @param componentCount - The component count
+     */
+    getVertexAttribFormat(semantic: VertexSemantic, dataType: DataType, componentCount: number): VertexAttribFormat;
+    /**
+     * Creates an interleaved vertex buffer
+     *
+     * @param attribFormats - The vertex attribute formats for each vertex stream in the vertex buffer
+     * @param data - Data to be filled with
+     * @param options - The creation options
+     */
+    createInterleavedVertexBuffer(attribFormats: VertexAttribFormat[], data: TypedArray, options?: BufferCreationOptions): StructuredBuffer;
+    /**
+     * Creates a non-interleaved vertex buffer
+     *
+     * @param attribFormat - The vertex attribute format
+     * @param data - Data to be filled with
+     * @param options - The creation options
+     */
+    createVertexBuffer(attribFormat: VertexAttribFormat, data: TypedArray, options?: BufferCreationOptions): StructuredBuffer;
+    /**
+     * Draw primitives
+     *
+     * @param primitiveType - The primitive type
+     * @param first - The vertex offset (or index offset if an index buffer exists)
+     * @param count - The vertex count (or index count if an index buffer exists) to be drawn
+     */
+    draw(primitiveType: PrimitiveType, first: number, count: number): void;
+    /**
+     * Draw multiple instances of primitives
+     *
+     * @param primitiveType - The primitive type
+     * @param first - The vertex offset (or index offset if an index buffer exists)
+     * @param count - The vertex count (or index count if an index buffer exists) to be drawn
+     * @param numInstances - How many instances to be drawn
+     */
+    drawInstanced(primitiveType: PrimitiveType, first: number, count: number, numInstances: number): void;
+    /**
+     * Dispatches a compute task to the GPU
+     *
+     * @param workgroupCountX - X dimension of the grid of workgroups to be dispatch
+     * @param workgroupCountY - Y dimension of the grid of workgroups to be dispatch
+     * @param workgroupCountZ - Z dimension of the grid of workgroups to be dispatch
+     */
+    compute(workgroupCountX: number, workgroupCountY: number, workgroupCountZ: number): void;
+    /**
+     * Schedules a function to be executed at the beginning of the next frame
+     *
+     * @param f - The function to be scheduled
+     */
+    runNextFrame(f: () => void): void;
+    /**
+     * Canels a pre scheduled function
+     *
+     * @param f - The function to be cancled
+     */
+    cancelNextFrameCall(f: () => void): void;
+    /** Exits from current rendering loop */
+    exitLoop(): void;
+    /**
+     * Begins a rendering loop
+     *
+     * @param func - The function to be executed at every frame
+     */
+    runLoop(func: (device: AbstractDevice) => void): void;
+    /** Get all GPU objects */
+    getGPUObjects(): GPUObjectList;
+    /**
+     * Get GPU object by id
+     *
+     * @param uid - id of the GPU object
+     */
+    getGPUObjectById(uid: number): GPUObject;
+    /**
+     * Calculates the actual position of current frame buffer from screen position.
+     *
+     * @remarks
+     * If current frame buffer is the back buffer, the value will be scaled by the device pixel ratio.
+     *
+     * @param val - The screen position in pixels
+     */
+    screenToDevice(val: number): number;
+    /**
+     * Calculates the screen position from position of current frame buffer.
+     *
+     * @remarks
+     * If current frame buffer is the back buffer, the value will be divided by the device pixel ratio.
+     *
+     * @param val - The position of current frame buffer in pixels
+     */
+    deviceToScreen(val: number): number;
+    /** Builds render program */
+    buildRenderProgram(options: PBRenderOptions): GPUProgram;
+    /** Builds compute program */
+    buildComputeProgram(options: PBComputeOptions): GPUProgram;
+    /** Pushes current FrameBuffer state */
+    pushDeviceStates(): any;
+    /** Pops last FrameBuffer state */
+    popDeviceStates(): any;
+}
+
+/**
+ * Abstract timer interface
+ * @public
+ */
+interface ITimer {
+    begin(): void;
+    end(): void;
+    ended(): boolean;
+    elapsed(): number;
+}
+/**
+ * CPU timer class
+ * @public
+ */
+declare class CPUTimer implements ITimer {
+    constructor();
+    now(): number;
+    begin(): void;
+    end(): void;
+    ended(): boolean;
+    elapsed(): number;
+}
+
+/**
+ * The device backend interface
+ * @public
+ */
+interface DeviceBackend {
+    typeName(): string;
+    supported(): boolean;
+    createDevice(cvs: HTMLCanvasElement, options?: DeviceOptions): Promise<AbstractDevice>;
+}
+/**
+ * Base class for rendering device
+ * @public
+ */
+declare abstract class BaseDevice {
+    protected _canvas: HTMLCanvasElement;
+    protected _canvasClientWidth: number;
+    protected _canvasClientHeight: number;
+    protected _gpuObjectList: GPUObjectList;
+    protected _gpuMemCost: number;
+    protected _disposeObjectList: GPUObject[];
+    protected _beginFrameTime: number;
+    protected _endFrameTime: number;
+    protected _frameInfo: FrameInfo;
+    protected _cpuTimer: CPUTimer;
+    protected _gpuTimer: ITimer;
+    protected _runningLoop: number;
+    protected _fpsCounter: {
+        time: number;
+        frame: number;
+    };
+    protected _runLoopFunc: (device: AbstractDevice) => void;
+    protected _backend: DeviceBackend;
+    protected _beginFrameCounter: number;
+    protected _programBuilder: ProgramBuilder;
+    private _stateStack;
+    constructor(cvs: HTMLCanvasElement, backend: DeviceBackend);
+    abstract getFrameBufferSampleCount(): number;
+    abstract isContextLost(): boolean;
+    abstract getScale(): number;
+    abstract getDrawingBufferWidth(): number;
+    abstract getDrawingBufferHeight(): number;
+    abstract getBackBufferWidth(): number;
+    abstract getBackBufferHeight(): number;
+    abstract getDeviceCaps(): DeviceCaps;
+    abstract initContext(): Promise<void>;
+    abstract clearFrameBuffer(clearColor: Vector4, clearDepth: number, clearStencil: number): any;
+    abstract createGPUTimer(): ITimer;
+    abstract createRenderStateSet(): RenderStateSet;
+    abstract createSampler(options: SamplerOptions): TextureSampler;
+    abstract createTextureFromMipmapData<T extends BaseTexture>(data: TextureMipmapData, sRGB: boolean, options?: TextureCreationOptions): T;
+    abstract createTexture2D(format: TextureFormat, width: number, height: number, options?: TextureCreationOptions): Texture2D;
+    abstract createTexture2DFromMipmapData(data: TextureMipmapData, sRGB: boolean, options?: TextureCreationOptions): Texture2D;
+    abstract createTexture2DFromImage(element: TextureImageElement, sRGB: boolean, options?: TextureCreationOptions): Texture2D;
+    abstract createTexture2DArray(format: TextureFormat, width: number, height: number, depth: number, options?: TextureCreationOptions): Texture2DArray;
+    abstract createTexture2DArrayFromMipmapData(data: TextureMipmapData, options?: TextureCreationOptions): Texture2DArray;
+    abstract createTexture2DArrayFromImages(elements: TextureImageElement[], sRGB: boolean, options?: TextureCreationOptions): Texture2DArray;
+    abstract createTexture3D(format: TextureFormat, width: number, height: number, depth: number, options?: TextureCreationOptions): Texture3D;
+    abstract createCubeTexture(format: TextureFormat, size: number, options?: TextureCreationOptions): TextureCube;
+    abstract createCubeTextureFromMipmapData(data: TextureMipmapData, sRGB: boolean, options?: TextureCreationOptions): TextureCube;
+    abstract createTextureVideo(el: HTMLVideoElement, samplerOptions?: SamplerOptions): TextureVideo;
+    abstract reverseVertexWindingOrder(reverse: boolean): void;
+    abstract isWindingOrderReversed(): boolean;
+    abstract createGPUProgram(params: GPUProgramConstructParams): GPUProgram;
+    abstract createBindGroup(layout: BindGroupLayout): BindGroup;
+    abstract createBuffer(sizeInBytes: number, options: BufferCreationOptions): GPUDataBuffer;
+    abstract createIndexBuffer(data: Uint16Array | Uint32Array, options?: BufferCreationOptions): IndexBuffer;
+    abstract createStructuredBuffer(structureType: PBStructTypeInfo, options: BufferCreationOptions, data?: TypedArray): StructuredBuffer;
+    abstract createVertexLayout(options: VertexLayoutOptions): VertexLayout;
+    abstract createFrameBuffer(colorAttachments: BaseTexture[], depthAttachment: BaseTexture, options?: FrameBufferOptions): FrameBuffer;
+    abstract setViewport(vp?: number[] | DeviceViewport): void;
+    abstract getViewport(): DeviceViewport;
+    abstract setScissor(scissor?: number[] | DeviceViewport): void;
+    abstract getScissor(): DeviceViewport;
+    abstract setProgram(program: GPUProgram): void;
+    abstract getProgram(): GPUProgram;
+    abstract setVertexLayout(vertexData: VertexLayout): void;
+    abstract getVertexLayout(): VertexLayout;
+    abstract setRenderStates(renderStates: RenderStateSet): void;
+    abstract getRenderStates(): RenderStateSet;
+    abstract setFramebuffer(rt: FrameBuffer): void;
+    abstract getFramebuffer(): FrameBuffer;
+    abstract setBindGroup(index: number, bindGroup: BindGroup, dynamicOffsets?: Iterable<number>): any;
+    abstract getBindGroup(index: number): [BindGroup, Iterable<number>];
+    abstract flush(): void;
+    abstract readPixels(index: number, x: number, y: number, w: number, h: number, buffer: TypedArray): Promise<void>;
+    abstract readPixelsToBuffer(index: number, x: number, y: number, w: number, h: number, buffer: GPUDataBuffer): void;
+    abstract looseContext(): void;
+    abstract restoreContext(): void;
+    protected abstract _draw(primitiveType: PrimitiveType, first: number, count: number): void;
+    protected abstract _drawInstanced(primitiveType: PrimitiveType, first: number, count: number, numInstances: number): void;
+    protected abstract _compute(workgroupCountX: number, workgroupCountY: number, workgroupCountZ: number): void;
+    get backend(): DeviceBackend;
+    get videoMemoryUsage(): number;
+    get frameInfo(): FrameInfo;
+    get isRendering(): boolean;
+    get canvas(): HTMLCanvasElement;
+    get type(): string;
+    get runLoopFunction(): (device: AbstractDevice) => void;
+    get programBuilder(): ProgramBuilder;
+    setFont(fontName: string): void;
+    drawText(text: string, x: number, y: number, color: string): void;
+    disposeObject(obj: GPUObject, remove?: boolean): void;
+    restoreObject(obj: GPUObject): Promise<void>;
+    enableGPUTimeRecording(enable: boolean): void;
+    beginFrame(): boolean;
+    endFrame(): void;
+    getVertexAttribFormat(semantic: VertexSemantic, dataType: DataType, componentCount: number): VertexAttribFormat;
+    createInterleavedVertexBuffer(attribFormats: VertexAttribFormat[], data: TypedArray, options?: BufferCreationOptions): StructuredBuffer;
+    createVertexBuffer(attribFormat: VertexAttribFormat, data: TypedArray, options?: BufferCreationOptions): StructuredBuffer;
+    draw(primitiveType: PrimitiveType, first: number, count: number): void;
+    drawInstanced(primitiveType: PrimitiveType, first: number, count: number, numInstances: number): void;
+    compute(workgroupCountX: any, workgroupCountY: any, workgroupCountZ: any): void;
+    runNextFrame(f: () => void): void;
+    cancelNextFrameCall(f: () => void): void;
+    exitLoop(): void;
+    runLoop(func: (device: AbstractDevice) => void): void;
+    pushDeviceStates(): void;
+    popDeviceStates(): void;
+    getGPUObjects(): GPUObjectList;
+    getGPUObjectById(uid: number): GPUObject;
+    screenToDevice(val: number): number;
+    deviceToScreen(val: number): number;
+    buildRenderProgram(options: PBRenderOptions): GPUProgram;
+    buildComputeProgram(options: PBComputeOptions): GPUProgram;
+    addGPUObject(obj: GPUObject): void;
+    removeGPUObject(obj: GPUObject): void;
+    updateVideoMemoryCost(delta: number): void;
+    protected abstract onBeginFrame(): boolean;
+    protected abstract onEndFrame(): void;
+    private _onresize;
+    private _registerEventHandlers;
+    private updateFrameInfo;
+    private getGPUObjectList;
+    protected invalidateAll(): void;
+    protected reloadAll(): Promise<void>;
+    protected parseTextureOptions(options?: TextureCreationOptions): number;
+    protected parseBufferOptions(options: BufferCreationOptions, defaultUsage?: BufferUsage): number;
+}
+/**
+ * Merge event target interface
+ * @public
+ */
+interface BaseDevice extends IEventTarget<DeviceEventMap> {
+}
+
+/**
+ * Information of a texture atlas
+ * @public
+ */
+interface AtlasInfo {
+    atlasIndex: number;
+    width: number;
+    height: number;
+    uMin: number;
+    vMin: number;
+    uMax: number;
+    vMax: number;
+}
+/**
+ * Texture atlas manager
+ * @public
+ */
+declare class TextureAtlasManager {
+    /**
+     * Creates a new texture atlas manager instance
+     * @param device - The render device
+     * @param binWidth - Width of an atlas bin
+     * @param binHeight - Height of an atlas bin
+     * @param rectBorderWidth - Border width of an atlas
+     * @param linearSpace - true if the texture space is linear
+     */
+    constructor(device: AbstractDevice, binWidth: number, binHeight: number, rectBorderWidth: number, linearSpace?: boolean);
+    /**
+     * The texture restore handler callback function
+     * This callback function will be called whenever the device has been restored
+     */
+    get atlasTextureRestoreHandler(): (tex: BaseTexture) => Promise<void>;
+    set atlasTextureRestoreHandler(f: (tex: BaseTexture) => Promise<void>);
+    /**
+     * Gets the atlas texture of a given index
+     * @param index - Index of the atlas bin
+     * @returns Atlas texture for given index
+     */
+    getAtlasTexture(index: number): Texture2D;
+    /**
+     * Gets the information about specified atlas
+     * @param key - Key of the atlas
+     * @returns Information of the atlas
+     */
+    getAtlasInfo(key: string): AtlasInfo;
+    /**
+     * Check if no atlas has been created
+     * @returns true if no atlas has been created
+     */
+    isEmpty(): boolean;
+    /**
+     * Removes all created atlases
+     */
+    clear(): void;
+    /**
+     * Inserts a rectangle of a canvas to the atlas texture
+     * @param key - Key of the atlas
+     * @param ctx - The canvas context
+     * @param x - x offset of the rectangle
+     * @param y - y offset of the rectangle
+     * @param w - width of the rectangle
+     * @param h - height of the rectangle
+     * @returns The atals info or null if insert failed
+     */
+    pushCanvas(key: string, ctx: CanvasRenderingContext2D, x: number, y: number, w: number, h: number): AtlasInfo;
+    /**
+     * Inserts a bitmap to the atlas texture
+     * @param key - Key of the atlas
+     * @param bitmap - The bitmap object
+     * @returns The atals info or null if insert failed
+     */
+    pushBitmap(key: string, bitmap: ImageData | ImageBitmap): AtlasInfo;
+}
+
+/**
+ * The font class
+ * @public
+ */
+declare class Font {
+    /**
+     * Creates a instance of font class from font name and the scale value
+     * @param name - The font name
+     * @param scale - The scale value
+     */
+    constructor(name: string, scale: number);
+    /**
+     * Fetch a font from cache
+     * @param name - The font name
+     * @param scale - The scale value
+     * @returns The font object
+     */
+    static fetchFont(name: string, scale: number): Font;
+    /** Gets the font name */
+    get fontName(): string;
+    set fontName(name: string);
+    /** Gets the scaled font name */
+    get fontNameScaled(): string;
+    /** Gets the font size */
+    get size(): number;
+    /** Gets the font family */
+    get family(): string;
+    /** Gets top position of the font */
+    get top(): number;
+    /** Gets the bottom position of the font */
+    get bottom(): number;
+    /** Gets the scaled top position of the font */
+    get topScaled(): number;
+    /** Gets the scaled bottom position of the font */
+    get bottomScaled(): number;
+    /** Gets the maximum height of the font */
+    get maxHeight(): number;
+    /** Gets the scaled maximum height of the font */
+    get maxHeightScaled(): number;
+    /** Tests if two fonts are the same */
+    equalTo(other: Font): boolean;
+}
+
+/**
+ * Manager of texture glyphs
+ * @public
+ */
+declare class GlyphManager extends TextureAtlasManager {
+    /**
+     * Creates a new glyph manager instance
+     * @param device - The render device
+     * @param binWidth - Width of an atlas bin
+     * @param binHeight - Height of an atlas bin
+     * @param border - Border width of an atlas
+     */
+    constructor(device: AbstractDevice, binWidth: number, binHeight: number, border: number);
+    /**
+     * Gets the atlas information for given character
+     * @param char - The character
+     * @param font - Font of the character
+     * @returns Atlas information for the glyph
+     */
+    getGlyphInfo(char: string, font: Font): AtlasInfo;
+    /**
+     * Measuring the width of a string
+     * @param str - The string to be measured
+     * @param charMargin - margin size between characters
+     * @param font - Font of the string
+     * @returns Width of the string
+     */
+    measureStringWidth(str: string, charMargin: number, font: Font): number;
+    /**
+     * Clips a string so that it's width is not larger than the given value
+     * @param str - The string to be clipped
+     * @param width - The desired maximum width
+     * @param charMargin - Margin size between characters
+     * @param start - Start index of the string to be clipped
+     * @param font - Font of the string
+     * @returns
+     */
+    clipStringToWidth(str: string, width: number, charMargin: number, start: number, font: Font): number;
+    /**
+     * Measuring width of a character
+     * @param char - The character to be measured
+     * @param font - Font of the character
+     * @returns Width of the character
+     */
+    getCharWidth(char: string, font: Font): number;
+}
+
+/**
+ * Helper class to draw some text onto the screen
+ * @public
+ */
+declare class DrawText {
+    /**
+     * Set the font that will be used to draw strings
+     * @param device - The render device
+     * @param name - The font name
+     */
+    static setFont(device: AbstractDevice, name: string): void;
+    /**
+     * Draw text onto the screen
+     * @param device - The render device
+     * @param text - The text to be drawn
+     * @param color - The text color
+     * @param x - X coordinate of the text
+     * @param y - Y coordinate of the text
+     */
+    static drawText(device: AbstractDevice, text: string, color: string, x: number, y: number): void;
+}
+
+/**
+ * Structured buffer data
+ * @public
+ */
+declare class StructuredBufferData {
+    /**
+     * Creates a new structured buffer data
+     * @param layout - Layout of the structure
+     * @param buffer - Buffer that holds the data
+     */
+    constructor(layout: UniformBufferLayout, buffer?: StructuredBuffer | ArrayBuffer);
+    /** The buffer size in bytes */
+    get byteLength(): number;
+    /** Get the data cache buffer */
+    get buffer(): ArrayBuffer;
+    /** Get all the uniform datas */
+    get uniforms(): Record<string, TypedArray>;
+    /**
+     * Sets the value of a structure member
+     * @param name - Name of the member
+     * @param value - Value to set
+     */
+    set(name: string, value: StructuredValue): void;
+}
+
+export { AbstractDevice, ArrayTypeDetail, AtlasInfo, AtomicTypeInfoDetail, BaseCreationOptions, BaseDevice, BaseTexture, BindGroup, BindGroupLayout, BindGroupLayoutEntry, BindPointInfo, BlendEquation, BlendFunc, BlendingState, BufferBindingLayout, BufferCreationOptions, BufferUsage, CPUTimer, ColorState, CompareFunc, ComputeProgramConstructParams, DataType, DepthState, DeviceBackend, DeviceCaps, DeviceEventMap, DeviceGPUObjectAddedEvent, DeviceGPUObjectRemovedEvent, DeviceGPUObjectRenameEvent, DeviceLostEvent, DeviceOptions, DeviceResizeEvent, DeviceRestoreEvent, DeviceViewport, DrawText, ExpValueNonArrayType, ExpValueType, ExternalTextureBindingLayout, FaceMode, FaceWinding, Font, FrameBuffer, FrameBufferOptions, FrameBufferTextureAttachment, FrameInfo, FramebufferCaps, FunctionTypeDetail, GPUDataBuffer, GPUObject, GPUObjectList, GPUProgram, GPUProgramConstructParams, GPUResourceUsageFlags, GlyphManager, ITimer, IndexBuffer, MiscCaps, PBAddressSpace, PBAnyTypeInfo, PBArrayTypeInfo, PBAtomicI32TypeInfo, PBAtomicU32TypeInfo, PBBuiltinScope, PBComputeOptions, PBDoWhileScope, PBForScope, PBFunctionScope, PBFunctionTypeInfo, PBGlobalScope, PBIfScope, PBInputScope, PBInsideFunctionScope, PBLocalScope, PBNakedScope, PBOutputScope, PBPointerTypeInfo, PBPrimitiveType, PBPrimitiveTypeInfo, PBReflection, PBReflectionTagGetter, PBRenderOptions, PBSamplerAccessMode, PBSamplerTypeInfo, PBScope, PBShaderExp, PBStructLayout, PBStructTypeInfo, PBTextureType, PBTextureTypeInfo, PBTypeInfo, PBVoidTypeInfo, PBWhileScope, PointerTypeDetail, PrimitiveType, PrimitiveTypeDetail, ProgramBuilder, Proxiable, RasterizerState, RenderProgramConstructParams, RenderStateSet, SamplerBindingLayout, SamplerOptions, SamplerTypeDetail, ShaderCaps, ShaderExpTagRecord, ShaderExpTagValue, ShaderKind, ShaderType, ShaderTypeFunc, StencilOp, StencilState, StorageTextureBindingLayout, StructTypeDetail, StructuredBuffer, StructuredBufferData, StructuredValue, Texture2D, Texture2DArray, Texture3D, TextureAddressMode, TextureAtlasManager, TextureBindingLayout, TextureCaps, TextureColorSpace, TextureCreationOptions, TextureCube, TextureFilterMode, TextureFormat, TextureFormatInfo, TextureImageElement, TextureMipmapData, TextureMipmapLevelData, TextureSampler, TextureType, TextureTypeDetail, TextureVideo, TypeDetailInfo, UniformBufferLayout, UniformLayout, VertexAttribFormat, VertexBufferInfo, VertexData, VertexLayout, VertexLayoutOptions, VertexSemantic, VertexStepMode, WebGLContext, genDefaultName, getTextureFormatBlockHeight, getTextureFormatBlockSize, getTextureFormatBlockWidth, getVertexAttribFormat, getVertexBufferAttribType, getVertexBufferAttribTypeBySemantic, getVertexBufferLength, getVertexBufferStride, hasAlphaChannel, hasBlueChannel, hasDepthChannel, hasGreenChannel, hasRedChannel, hasStencilChannel, isCompressedTextureFormat, isFloatTextureFormat, isIntegerTextureFormat, isSRGBTextureFormat, isSignedTextureFormat, linearTextureFormatToSRGB, makeVertexBufferType, semanticList };