@rings-webgpu/core 1.0.5 → 1.0.7

package/dist/types/gfx/generate/convert/BlurEffectCreator.d.ts

@@ -0,0 +1,7 @@
+export declare class BlurTexture2DBufferCreator {
+    static blurImageFromTexture(image: {
+        width: number;
+        height: number;
+        gpuTexture: GPUTexture;
+    }, dstWidth: number, dstHeight: number, blur: boolean): GPUTexture;
+}

package/dist/types/gfx/generate/convert/ErpImage2CubeMap.d.ts

@@ -0,0 +1,9 @@
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { Texture } from "../../graphics/webGpu/core/texture/Texture";
+export declare class ErpImage2CubeMap {
+    static convertRGBE2RGBA(image: VirtualTexture, data: Float32Array): void;
+    private static makeFaceTexturePipeline;
+    private static configBuffer;
+    private static quaternionBuffer;
+    static makeTextureCube(image: Texture, dstSize: number, dstView: GPUTextureView): void;
+}

package/dist/types/gfx/generate/convert/IBLEnvMapCreator.d.ts

@@ -0,0 +1,12 @@
+import { Texture } from "../../graphics/webGpu/core/texture/Texture";
+export declare class IBLEnvMapCreator {
+    private static configBuffer;
+    private static quaternionBuffer;
+    private static blurSettingBuffer;
+    private static pipeline;
+    static importantSample(image: {
+        width: number;
+        height: number;
+        erpTexture: Texture;
+    }, dstSize: number, roughness: number, dstView: GPUTextureView): void;
+}

package/dist/types/gfx/generate/convert/MergeRGBACreator.d.ts

@@ -0,0 +1,5 @@
+import { VirtualTexture } from "../../../textures/VirtualTexture";
+import { Texture } from "../../graphics/webGpu/core/texture/Texture";
+export declare class MergeRGBACreator {
+    static merge(textureR: Texture, textureG: Texture, textureB: Texture, textureA: Texture): VirtualTexture;
+}

package/dist/types/gfx/generate/convert/TextureCubeStdCreator.d.ts

@@ -0,0 +1,9 @@
+import { Texture } from "../../graphics/webGpu/core/texture/Texture";
+import { RenderTexture } from "../../../textures/RenderTexture";
+export declare class TextureCubeStdCreator {
+    private static createCube;
+    private static configBuffer;
+    private static blurSettingBuffer;
+    private static pipeline;
+    static createFace(index: number, size: number, inTex: Texture, outTex: RenderTexture): void;
+}

package/dist/types/gfx/generate/convert/TextureCubeUtils.d.ts

@@ -0,0 +1,12 @@
+import { Quaternion } from "../../../math/Quaternion";
+export declare enum CubeMapFaceEnum {
+    Left = 0,
+    Right = 1,
+    Bottom = 2,
+    Top = 3,
+    Back = 4,
+    Front = 5
+}
+export declare class TextureCubeUtils {
+    static getRotationToFace(face: number): Quaternion;
+}

package/dist/types/gfx/generate/convert/TextureScaleCompute.d.ts

@@ -0,0 +1,6 @@
+import { ComputeShader } from "../../..";
+import { Texture } from "../../graphics/webGpu/core/texture/Texture";
+export declare class TextureScaleCompute {
+    computeShader: ComputeShader;
+    setInputes(colorMap: Texture, inputs: Texture[], outputs: Texture[]): void;
+}

package/dist/types/gfx/graphics/webGpu/CanvasConfig.d.ts

@@ -0,0 +1,7 @@
+export type CanvasConfig = {
+    canvas?: HTMLCanvasElement;
+    alpha?: boolean;
+    zIndex?: number;
+    devicePixelRatio?: number;
+    backgroundImage?: string;
+};

package/dist/types/gfx/graphics/webGpu/Context3D.d.ts

@@ -0,0 +1,20 @@
+import { CEventDispatcher } from "../../../event/CEventDispatcher";
+import { CanvasConfig } from "./CanvasConfig";
+export declare class Context3D extends CEventDispatcher {
+    adapter: GPUAdapter | null;
+    device: GPUDevice;
+    context: GPUCanvasContext;
+    aspect: number;
+    presentationSize: number[];
+    presentationFormat: GPUTextureFormat;
+    canvas: HTMLCanvasElement;
+    windowWidth: number;
+    windowHeight: number;
+    canvasConfig: CanvasConfig;
+    private _pixelRatio;
+    private _resizeEvent;
+    get pixelRatio(): number;
+    init(canvasConfig?: CanvasConfig): Promise<boolean>;
+    updateSize(): void;
+}
+export declare let webGPUContext: Context3D;

package/dist/types/gfx/graphics/webGpu/PipelinePool.d.ts

@@ -0,0 +1,5 @@
+export declare class PipelinePool {
+    private static pipelineMap;
+    static getSharePipeline(shaderVariant: string): GPURenderPipeline;
+    static setSharePipeline(shaderVariant: string, pipeline: GPURenderPipeline): void;
+}

package/dist/types/gfx/graphics/webGpu/WebGPUConst.d.ts

@@ -0,0 +1,154 @@
+export declare let GPUAddressMode: {
+    clamp_to_edge: GPUAddressMode;
+    repeat: GPUAddressMode;
+    mirror_repeat: GPUAddressMode;
+};
+export declare let GPUBlendFactor: {
+    zero: GPUBlendFactor;
+    one: GPUBlendFactor;
+    src: GPUBlendFactor;
+    one_minus_src: GPUBlendFactor;
+    src_alpha: GPUBlendFactor;
+    one_minus_src_alpha: GPUBlendFactor;
+    dst: GPUBlendFactor;
+    one_minus_dst: GPUBlendFactor;
+    dst_alpha: GPUBlendFactor;
+    one_minus_dst_alpha: GPUBlendFactor;
+    src_alpha_saturated: GPUBlendFactor;
+    constant: GPUBlendFactor;
+    one_minus_constant: GPUBlendFactor;
+};
+export declare const blendComponent: {
+    srcFactor: string;
+    dstFactor: string;
+    operation: string;
+};
+export declare const stencilStateFace: {
+    compare: string;
+    failOp: string;
+    depthFailOp: string;
+    passOp: string;
+};
+export declare let GPUCompareFunction: {
+    never: GPUCompareFunction;
+    less: GPUCompareFunction;
+    equal: GPUCompareFunction;
+    less_equal: GPUCompareFunction;
+    greater: GPUCompareFunction;
+    not_equal: GPUCompareFunction;
+    greater_equal: GPUCompareFunction;
+    always: GPUCompareFunction;
+};
+export declare let GPUCullMode: {
+    none: GPUCullMode;
+    front: GPUCullMode;
+    back: GPUCullMode;
+};
+export type GPUFeatureName = "depth-clamping" | "depth24unorm-stencil8" | "depth32float-stencil8" | "pipeline-statistics-query" | "texture-compression-bc" | "timestamp-query";
+export declare let GPUFilterMode: {
+    nearest: GPUFilterMode;
+    linear: GPUFilterMode;
+};
+export type GPUFrontFace = "ccw" | "cw";
+export declare let GPUPrimitiveTopology: {
+    point_list: GPUPrimitiveTopology;
+    line_list: GPUPrimitiveTopology;
+    line_strip: GPUPrimitiveTopology;
+    triangle_list: GPUPrimitiveTopology;
+    triangle_strip: GPUPrimitiveTopology;
+};
+export declare let GPUTextureFormat: {
+    r8unorm: GPUTextureFormat;
+    r8snorm: GPUTextureFormat;
+    r8uint: GPUTextureFormat;
+    r8sint: GPUTextureFormat;
+    r16uint: GPUTextureFormat;
+    r16sint: GPUTextureFormat;
+    r16float: GPUTextureFormat;
+    rg8unorm: GPUTextureFormat;
+    rg8snorm: GPUTextureFormat;
+    rg8uint: GPUTextureFormat;
+    rg8sint: GPUTextureFormat;
+    r32uint: GPUTextureFormat;
+    r32sint: GPUTextureFormat;
+    r32float: GPUTextureFormat;
+    rg16uint: GPUTextureFormat;
+    rg16sint: GPUTextureFormat;
+    rg16float: GPUTextureFormat;
+    rgba8unorm: GPUTextureFormat;
+    rgba8unorm_srgb: GPUTextureFormat;
+    rgba8snorm: GPUTextureFormat;
+    rgba8uint: GPUTextureFormat;
+    rgba8sint: GPUTextureFormat;
+    bgra8unorm: GPUTextureFormat;
+    bgra8unorm_srgb: GPUTextureFormat;
+    rgb9e5ufloat: GPUTextureFormat;
+    rgb10a2unorm: GPUTextureFormat;
+    rg11b10ufloat: GPUTextureFormat;
+    rg32uint: GPUTextureFormat;
+    rg32sint: GPUTextureFormat;
+    rg32float: GPUTextureFormat;
+    rgba16uint: GPUTextureFormat;
+    rgba16sint: GPUTextureFormat;
+    rgba16float: GPUTextureFormat;
+    rgba32uint: GPUTextureFormat;
+    rgba32sint: GPUTextureFormat;
+    rgba32float: GPUTextureFormat;
+    stencil8: GPUTextureFormat;
+    depth16unorm: GPUTextureFormat;
+    depth24plus: GPUTextureFormat;
+    depth24plus_stencil8: GPUTextureFormat;
+    depth32float: GPUTextureFormat;
+    bc1_rgba_unorm: GPUTextureFormat;
+    bc1_rgba_unorm_srgb: GPUTextureFormat;
+    bc2_rgba_unorm: GPUTextureFormat;
+    bc2_rgba_unorm_srgb: GPUTextureFormat;
+    bc3_rgba_unorm: GPUTextureFormat;
+    bc3_rgba_unorm_srgb: GPUTextureFormat;
+    bc4_r_unorm: GPUTextureFormat;
+    bc4_r_snorm: GPUTextureFormat;
+    bc5_rg_unorm: GPUTextureFormat;
+    bc5_rg_snorm: GPUTextureFormat;
+    bc6h_rgb_ufloat: GPUTextureFormat;
+    bc6h_rgb_float: GPUTextureFormat;
+    bc7_rgba_unorm: GPUTextureFormat;
+    bc7_rgba_unorm_srgb: GPUTextureFormat;
+    depth24unorm_stencil8: GPUTextureFormat;
+    depth32float_stencil8: GPUTextureFormat;
+};
+export declare let GPUVertexFormat: {
+    uint8x2: GPUVertexFormat;
+    uint8x4: GPUVertexFormat;
+    sint8x2: GPUVertexFormat;
+    sint8x4: GPUVertexFormat;
+    unorm8x2: GPUVertexFormat;
+    unorm8x4: GPUVertexFormat;
+    snorm8x2: GPUVertexFormat;
+    snorm8x4: GPUVertexFormat;
+    uint16x2: GPUVertexFormat;
+    uint16x4: GPUVertexFormat;
+    sint16x2: GPUVertexFormat;
+    sint16x4: GPUVertexFormat;
+    unorm16x2: GPUVertexFormat;
+    unorm16x4: GPUVertexFormat;
+    snorm16x2: GPUVertexFormat;
+    snorm16x4: GPUVertexFormat;
+    float16x2: GPUVertexFormat;
+    float16x4: GPUVertexFormat;
+    float32: GPUVertexFormat;
+    float32x2: GPUVertexFormat;
+    float32x3: GPUVertexFormat;
+    float32x4: GPUVertexFormat;
+    uint32: GPUVertexFormat;
+    uint32x2: GPUVertexFormat;
+    uint32x3: GPUVertexFormat;
+    uint32x4: GPUVertexFormat;
+    sint32: GPUVertexFormat;
+    sint32x2: GPUVertexFormat;
+    sint32x3: GPUVertexFormat;
+    sint32x4: GPUVertexFormat;
+};
+export declare let GPUVertexStepMode: {
+    vertex: GPUVertexStepMode;
+    instance: GPUVertexStepMode;
+};

package/dist/types/gfx/graphics/webGpu/compute/PreIntegratedLutCompute.d.ts

@@ -0,0 +1,8 @@
+import { VirtualTexture } from "../../../../textures/VirtualTexture";
+import { RenderShaderCompute } from "./RenderShaderCompute";
+import { Shader } from "../shader/Shader";
+export declare class PreIntegratedLutCompute extends RenderShaderCompute {
+    constructor(shader: Shader);
+    protected init(): VirtualTexture;
+    onFrame(): void;
+}

package/dist/types/gfx/graphics/webGpu/compute/RenderShaderCompute.d.ts

@@ -0,0 +1,12 @@
+import { Shader } from "../../../..";
+import { ComputeShader } from "../shader/ComputeShader";
+export declare class RenderShaderCompute {
+    protected sourceShader: Shader;
+    protected compute: ComputeShader;
+    protected needUpdate: boolean;
+    constructor(shaderStr: string, sourceShader: Shader);
+    protected init(): void;
+    protected onOnce?(): any;
+    protected onFrame?(): any;
+    onUpdate(): void;
+}

package/dist/types/gfx/graphics/webGpu/core/bindGroups/GlobalBindGroup.d.ts

@@ -0,0 +1,18 @@
+import { Camera3D } from "../../../../../core/Camera3D";
+import { Scene3D } from "../../../../../core/Scene3D";
+import { GlobalUniformGroup } from "./GlobalUniformGroup";
+import { LightEntries } from "./groups/LightEntries";
+import { ReflectionEntries } from "./groups/ReflectionEntries";
+import { MatrixBindGroup } from "./MatrixBindGroup";
+export declare class GlobalBindGroup {
+    private static _cameraBindGroups;
+    private static _lightEntriesMap;
+    private static _reflectionEntriesMap;
+    static modelMatrixBindGroup: MatrixBindGroup;
+    static init(): void;
+    static getAllCameraGroup(): Map<Camera3D, GlobalUniformGroup>;
+    static getCameraGroup(camera: Camera3D): GlobalUniformGroup;
+    static updateCameraGroup(camera: Camera3D): void;
+    static getLightEntries(scene: Scene3D): LightEntries;
+    static getReflectionEntries(scene: Scene3D): ReflectionEntries;
+}

package/dist/types/gfx/graphics/webGpu/core/bindGroups/GlobalBindGroupLayout.d.ts

@@ -0,0 +1,4 @@
+export declare class GlobalBindGroupLayout {
+    private static _globalDataBindGroupLayout;
+    static getGlobalDataBindGroupLayout(): GPUBindGroupLayout;
+}

package/dist/types/gfx/graphics/webGpu/core/bindGroups/GlobalUniformGroup.d.ts

@@ -0,0 +1,25 @@
+import { Camera3D } from "../../../../../core/Camera3D";
+import { UniformGPUBuffer } from "../buffer/UniformGPUBuffer";
+import { MatrixBindGroup } from "./MatrixBindGroup";
+export declare class GlobalUniformGroup {
+    uuid: string;
+    usage: number;
+    globalBindGroup: GPUBindGroup;
+    uniformGPUBuffer: UniformGPUBuffer;
+    private matrixBindGroup;
+    private uniformByteLength;
+    private matrixesByteLength;
+    private shadowMatrixRaw;
+    private csmMatrixRaw;
+    private csmShadowBias;
+    shadowLights: Float32Array<ArrayBuffer>;
+    dirShadowStart: number;
+    dirShadowEnd: number;
+    pointShadowStart: number;
+    pointShadowEnd: number;
+    constructor(matrixBindGroup: MatrixBindGroup);
+    createBindGroup(): void;
+    setCamera(camera: Camera3D): void;
+    setShadowCamera(camera: Camera3D): void;
+    setShadowLight(): void;
+}

package/dist/types/gfx/graphics/webGpu/core/bindGroups/MatrixBindGroup.d.ts

@@ -0,0 +1,11 @@
+import { MatrixGPUBuffer } from "../buffer/MatrixGPUBuffer";
+export declare class MatrixBindGroup {
+    uuid: string;
+    index: number;
+    usage: number;
+    groupBufferSize: number;
+    matrixBufferDst: MatrixGPUBuffer;
+    constructor();
+    private cacheWorldMatrix;
+    writeBuffer(len: number): void;
+}

package/dist/types/gfx/graphics/webGpu/core/bindGroups/groups/LightEntries.d.ts

@@ -0,0 +1,11 @@
+import { View3D } from "../../../../../../core/View3D";
+import { DDGIIrradianceVolume } from "../../../../../renderJob/passRenderer/ddgi/DDGIIrradianceVolume";
+import { StorageGPUBuffer } from "../../buffer/StorageGPUBuffer";
+export declare class LightEntries {
+    storageGPUBuffer: StorageGPUBuffer;
+    irradianceVolume: DDGIIrradianceVolume;
+    private _lightList;
+    constructor();
+    update(view: View3D): void;
+    private writeLightBytes;
+}

package/dist/types/gfx/graphics/webGpu/core/bindGroups/groups/ProbeEntries.d.ts

@@ -0,0 +1,10 @@
+import { MemoryDO } from "../../../../../../core/pool/memory/MemoryDO";
+import { Probe } from "../../../../../renderJob/passRenderer/ddgi/Probe";
+export declare class ProbeEntries {
+    gpuBuffer: GPUBuffer;
+    probes: Probe[];
+    memoryDo: MemoryDO;
+    private _probeInfoList;
+    initDataUniform(probes: Probe[]): void;
+    private updateGPUBuffer;
+}

package/dist/types/gfx/graphics/webGpu/core/bindGroups/groups/ReflectionEntries.d.ts

@@ -0,0 +1,12 @@
+import { View3D } from "../../../../../../core/View3D";
+import { RenderTexture } from "../../../../../../textures/RenderTexture";
+import { StorageGPUBuffer } from "../../buffer/StorageGPUBuffer";
+import { Texture } from "../../texture/Texture";
+export declare class ReflectionEntries {
+    storageGPUBuffer: StorageGPUBuffer;
+    reflectionMap: Texture;
+    sourceReflectionMap: RenderTexture;
+    count: number;
+    constructor();
+    update(view: View3D): void;
+}

package/dist/types/gfx/graphics/webGpu/core/buffer/ArrayBufferData.d.ts

@@ -0,0 +1 @@
+export type ArrayBufferData = Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array;

package/dist/types/gfx/graphics/webGpu/core/buffer/ComputeGPUBuffer.d.ts

@@ -0,0 +1,4 @@
+import { GPUBufferBase } from "./GPUBufferBase";
+export declare class ComputeGPUBuffer extends GPUBufferBase {
+    constructor(size: number, data?: Float32Array);
+}

package/dist/types/gfx/graphics/webGpu/core/buffer/GPUBufferBase.d.ts

@@ -0,0 +1,84 @@
+import { ArrayBufferData } from "./ArrayBufferData";
+import { GPUBufferType } from "./GPUBufferType";
+import { Color } from "../../../../../math/Color";
+import { Matrix4 } from "../../../../../math/Matrix4";
+import { Quaternion } from "../../../../../math/Quaternion";
+import { Vector2 } from "../../../../../math/Vector2";
+import { Vector3 } from "../../../../../math/Vector3";
+import { Vector4 } from "../../../../../math/Vector4";
+import { Struct } from "../../../../../util/struct/Struct";
+import { MemoryDO } from "../../../../../core/pool/memory/MemoryDO";
+import { MemoryInfo } from "../../../../../core/pool/memory/MemoryInfo";
+import { FloatArray } from "@rings/wasm-matrix/WasmMatrix";
+export declare class GPUBufferBase {
+    bufferType: GPUBufferType;
+    buffer: GPUBuffer;
+    memory: MemoryDO;
+    memoryNodes: Map<string | number, MemoryInfo>;
+    seek: number;
+    outFloat32Array: Float32Array;
+    byteSize: number;
+    usage: GPUBufferUsageFlags;
+    visibility: number;
+    protected mapAsyncBuffersOutstanding: number;
+    protected mapAsyncReady: GPUBuffer[];
+    private _readBuffer;
+    private _dataView;
+    constructor();
+    debug(): void;
+    reset(clean?: boolean, size?: number, data?: Float32Array): void;
+    setBoolean(name: string, v: boolean): void;
+    readBoole(name: string): boolean;
+    setFloat(name: string, v: number): void;
+    getFloat(name: string): number;
+    setInt8(name: string, v: number): void;
+    getInt8(name: string): number;
+    setInt16(name: string, v: number): void;
+    getInt16(name: string): number;
+    setInt32(name: string, v: number): void;
+    getInt32(name: string): number;
+    setUint8(name: string, v: number): void;
+    getUint8(name: string): number;
+    setUint16(name: string, v: number): void;
+    getUint16(name: string): number;
+    setUint32(name: string, v: number): void;
+    getUint32(name: string): number;
+    setVector2(name: string, v2: Vector2): void;
+    getVector2(name: string): Vector2;
+    setVector3(name: string, v3: Vector3): void;
+    getVector3(name: string): Vector3;
+    setVector4(name: string, v4: Vector4 | Quaternion): void;
+    getVector4(name: string): Vector4;
+    setVector4Array(name: string, v4Array: Vector3[] | Vector4[] | Quaternion[]): void;
+    setColor(name: string, color: Color): void;
+    getColor(name: string): Color;
+    setColorArray(name: string, colorArray: Color[]): void;
+    setMatrix(name: string, mat: Matrix4): void;
+    setMatrixArray(name: string, mats: Matrix4[]): void;
+    setArray(name: string, data: number[]): void;
+    setFloat32Array(name: string, data: Float32Array): void;
+    setInt32Array(name: string, data: Int32Array): void;
+    setUint32Array(name: string, data: Uint32Array): void;
+    setStruct<T extends Struct>(c: {
+        new (): T;
+    }, index: number, data: any, property?: string): void;
+    private writeValue;
+    setStructArray<T extends Struct>(c: {
+        new (): T;
+    }, dataList: any[], property?: string): void;
+    clean(): void;
+    apply(): void;
+    mapAsyncWrite(floatArray: FloatArray, len: number): void;
+    destroy(force?: boolean): void;
+    protected createBuffer(usage: GPUBufferUsageFlags, size: number, data?: ArrayBufferData, debugLabel?: string): void;
+    resizeBuffer(size: number, data?: ArrayBufferData): void;
+    protected createNewBuffer(usage: GPUBufferUsageFlags, size: number): GPUBuffer;
+    protected createBufferByStruct<T extends Struct>(usage: GPUBufferUsageFlags, struct: {
+        new (): T;
+    }, count: number): void;
+    readBuffer(): Float32Array;
+    readBuffer(promise: false): Float32Array;
+    readBuffer(promise: true): Promise<Float32Array>;
+    private _readFlag;
+    private read;
+}

package/dist/types/gfx/graphics/webGpu/core/buffer/GPUBufferType.d.ts

@@ -0,0 +1,9 @@
+export declare enum GPUBufferType {
+    IndicesGPUBuffer = 0,
+    VertexGPUBuffer = 1,
+    UniformGPUBuffer = 2,
+    StorageGPUBuffer = 3,
+    ComputeGPUBuffer = 4,
+    MaterialDataUniformGPUBuffer = 5,
+    StructStorageGPUBuffer = 6
+}

package/dist/types/gfx/graphics/webGpu/core/buffer/IndicesGPUBuffer.d.ts

@@ -0,0 +1,14 @@
+import { MemoryInfo } from "../../../../../core/pool/memory/MemoryInfo";
+import { ArrayBufferData } from "./ArrayBufferData";
+import { GPUBufferBase } from "./GPUBufferBase";
+/**
+ * 用于几何体索引的缓冲区
+ * 可在计算着色器或CPU代码中写入
+ * 使用标志: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT
+ * @group GFX
+ */
+export declare class IndicesGPUBuffer extends GPUBufferBase {
+    indicesNode: MemoryInfo;
+    constructor(data?: ArrayBufferData);
+    protected createIndicesBuffer(usage: GPUBufferUsageFlags, data?: ArrayBufferData): void;
+}

package/dist/types/gfx/graphics/webGpu/core/buffer/MaterialDataUniformGPUBuffer.d.ts

@@ -0,0 +1,10 @@
+import { UniformNode } from "../uniforms/UniformNode";
+import { GPUBufferBase } from "./GPUBufferBase";
+export declare class MaterialDataUniformGPUBuffer extends GPUBufferBase {
+    uniformNodes: UniformNode[];
+    private _onChange;
+    constructor();
+    initDataUniform(uniformNodes: UniformNode[]): void;
+    onChange(): void;
+    apply(): void;
+}

package/dist/types/gfx/graphics/webGpu/core/buffer/MatrixGPUBuffer.d.ts

@@ -0,0 +1,8 @@
+import { FloatArray } from "@rings/wasm-matrix/WasmMatrix";
+import { ArrayBufferData } from "./ArrayBufferData";
+import { GPUBufferBase } from "./GPUBufferBase";
+export declare class MatrixGPUBuffer extends GPUBufferBase {
+    size: number;
+    constructor(size: number, usage?: number, data?: ArrayBufferData);
+    writeBufferByHeap(floatArray: FloatArray, len: number): void;
+}

package/dist/types/gfx/graphics/webGpu/core/buffer/StorageGPUBuffer.d.ts

@@ -0,0 +1,5 @@
+import { ArrayBufferData } from "./ArrayBufferData";
+import { GPUBufferBase } from "./GPUBufferBase";
+export declare class StorageGPUBuffer extends GPUBufferBase {
+    constructor(size: number, usage?: number, data?: ArrayBufferData);
+}

package/dist/types/gfx/graphics/webGpu/core/buffer/StructStorageGPUBuffer.d.ts

@@ -0,0 +1,7 @@
+import { Struct } from "../../../../../util/struct/Struct";
+import { GPUBufferBase } from "./GPUBufferBase";
+export declare class StructStorageGPUBuffer<T extends Struct> extends GPUBufferBase {
+    constructor(struct: {
+        new (): T;
+    }, count: number, usage?: number);
+}

package/dist/types/gfx/graphics/webGpu/core/buffer/UniformGPUBuffer.d.ts

@@ -0,0 +1,5 @@
+import { GPUBufferBase } from "./GPUBufferBase";
+export declare class UniformGPUBuffer extends GPUBufferBase {
+    constructor(size: number, data?: Float32Array);
+    genUniformNodes(): void;
+}

package/dist/types/gfx/graphics/webGpu/core/buffer/VertexGPUBuffer.d.ts

@@ -0,0 +1,7 @@
+import { MemoryInfo } from "../../../../../core/pool/memory/MemoryInfo";
+import { GPUBufferBase } from "./GPUBufferBase";
+export declare class VertexGPUBuffer extends GPUBufferBase {
+    node: MemoryInfo;
+    constructor(size: number);
+    protected createVertexBuffer(usage: GPUBufferUsageFlags, size: number): void;
+}

package/dist/types/gfx/graphics/webGpu/core/texture/ITexture.d.ts

@@ -0,0 +1,18 @@
+export interface ITexture {
+    /**
+     * create binding layout description
+     */
+    internalCreateBindingLayoutDesc(): any;
+    /**
+     * create texture instance
+     */
+    internalCreateTexture(): any;
+    /**
+     * create GPU View
+     */
+    internalCreateView(): any;
+    /**
+     * create CPU Sample
+     */
+    internalCreateSampler(): any;
+}

package/dist/types/gfx/graphics/webGpu/core/texture/Texture.d.ts

@@ -0,0 +1,79 @@
+export declare class Texture implements GPUSamplerDescriptor {
+    name: string;
+    url: string;
+    protected gpuTexture: GPUTexture;
+    pid: number;
+    view: GPUTextureView | GPUExternalTexture;
+    gpuSampler: GPUSampler;
+    gpuSampler_comparison: GPUSampler;
+    format: GPUTextureFormat;
+    usage: GPUFlagsConstant;
+    width: number;
+    height: number;
+    depthOrArrayLayers: number;
+    numberLayer: number;
+    viewDescriptor: GPUTextureViewDescriptor;
+    textureDescriptor: GPUTextureDescriptor;
+    visibility: number;
+    textureBindingLayout: GPUTextureBindingLayout;
+    samplerBindingLayout: GPUSamplerBindingLayout;
+    sampler_comparisonBindingLayout: GPUSamplerBindingLayout;
+    flipY: boolean;
+    isVideoTexture?: boolean;
+    isHDRTexture?: boolean;
+    private _useMipmap;
+    private _sourceImageData;
+    private _addressModeU?;
+    private _addressModeV?;
+    private _addressModeW?;
+    private _magFilter?;
+    private _minFilter?;
+    private _mipmapFilter?;
+    private _lodMinClamp?;
+    private _lodMaxClamp?;
+    private _compare?;
+    private _maxAnisotropy?;
+    mipmapCount: number;
+    protected _textureChange: boolean;
+    constructor(width?: number, height?: number, numberLayer?: number);
+    init(): this;
+    protected createTextureDescriptor(width: number, height: number, mipLevelCount: number, format: GPUTextureFormat, usage?: number, sizeCount?: number, sampleCount?: number): void;
+    protected generate(imageBitmap: HTMLCanvasElement | ImageBitmap | OffscreenCanvas): void;
+    private createTexture;
+    get useMipmap(): boolean;
+    set useMipmap(value: boolean);
+    get sourceImageData(): HTMLCanvasElement | ImageBitmap | OffscreenCanvas;
+    getMipmapCount(): number;
+    protected updateTextureDescription(): void;
+    protected updateGPUTexture(): void;
+    getGPUTexture(): GPUTexture;
+    getGPUView(index?: number): GPUTextureView | GPUExternalTexture;
+    protected _stateChangeRef: Map<any, Function>;
+    bindStateChange(fun: Function, ref: any): void;
+    unBindStateChange(ref: any): void;
+    protected noticeChange(): void;
+    destroy(force?: boolean): void;
+    get addressModeU(): GPUAddressMode;
+    set addressModeU(value: GPUAddressMode);
+    get addressModeV(): GPUAddressMode;
+    set addressModeV(value: GPUAddressMode);
+    get addressModeW(): GPUAddressMode;
+    set addressModeW(value: GPUAddressMode);
+    get magFilter(): GPUFilterMode;
+    set magFilter(value: GPUFilterMode);
+    get minFilter(): GPUFilterMode;
+    set minFilter(value: GPUFilterMode);
+    get mipmapFilter(): GPUMipmapFilterMode;
+    set mipmapFilter(value: GPUMipmapFilterMode);
+    get lodMinClamp(): number;
+    set lodMinClamp(value: number);
+    get lodMaxClamp(): number;
+    set lodMaxClamp(value: number);
+    get compare(): GPUCompareFunction;
+    set compare(value: GPUCompareFunction);
+    get maxAnisotropy(): number;
+    set maxAnisotropy(value: number);
+    private static _texs;
+    static delayDestroyTexture(tex: GPUTexture): void;
+    static destroyTexture(): void;
+}