@rings-webgpu/core 1.0.2 → 1.0.3

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

@@ -1,84 +0,0 @@
-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/src/gfx/graphics/webGpu/core/buffer/GPUBufferBase.js

@@ -1,493 +0,0 @@
-import { Color } from "../../../../../math/Color";
-import { Vector2 } from "../../../../../math/Vector2";
-import { Vector3 } from "../../../../../math/Vector3";
-import { Vector4 } from "../../../../../math/Vector4";
-import { Struct } from "../../../../../util/struct/Struct";
-import { webGPUContext } from "../../Context3D";
-import { MemoryDO } from "../../../../../core/pool/memory/MemoryDO";
-/* eslint-disable */
-export class GPUBufferBase {
-    constructor() {
-        this.visibility = GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT | GPUShaderStage.COMPUTE;
-        this.mapAsyncBuffersOutstanding = 0;
-        this._readFlag = false;
-        this.mapAsyncReady = [];
-    }
-    debug() { }
-    reset(clean = false, size = 0, data) {
-        this.seek = 0;
-        this.memory.reset();
-        if (clean) {
-            this.createBuffer(this.usage, size, data);
-        }
-    }
-    setBoolean(name, v) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(1 * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setX(v ? 1 : 0);
-    }
-    readBoole(name) {
-        let node = this.memoryNodes.get(name);
-        if (node) {
-            return node.getFloat() == 0 ? false : true;
-        }
-        return null;
-    }
-    setFloat(name, v) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(1 * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setX(v);
-    }
-    getFloat(name) {
-        let node = this.memoryNodes.get(name);
-        if (node) {
-            return node.getFloat();
-        }
-        return null;
-    }
-    setInt8(name, v) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(1 * 1);
-            this.memoryNodes.set(name, node);
-        }
-        node.setInt8(v);
-    }
-    getInt8(name) {
-        let node = this.memoryNodes.get(name);
-        if (node) {
-            return node.getInt8();
-        }
-        return null;
-    }
-    setInt16(name, v) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(1 * 2);
-            this.memoryNodes.set(name, node);
-        }
-        node.setInt16(v);
-    }
-    getInt16(name) {
-        let node = this.memoryNodes.get(name);
-        if (node) {
-            return node.getInt16();
-        }
-        return null;
-    }
-    setInt32(name, v) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(1 * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setInt32(v);
-    }
-    getInt32(name) {
-        let node = this.memoryNodes.get(name);
-        if (node) {
-            return node.getInt32();
-        }
-        return null;
-    }
-    setUint8(name, v) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(1 * 1);
-            this.memoryNodes.set(name, node);
-        }
-        node.setUint8(v);
-    }
-    getUint8(name) {
-        let node = this.memoryNodes.get(name);
-        if (node) {
-            return node.getUint8();
-        }
-        return null;
-    }
-    setUint16(name, v) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(1 * 2);
-            this.memoryNodes.set(name, node);
-        }
-        node.setUint16(v);
-    }
-    getUint16(name) {
-        let node = this.memoryNodes.get(name);
-        if (node) {
-            return node.getUint16();
-        }
-        return null;
-    }
-    setUint32(name, v) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(1 * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setUint32(v);
-    }
-    getUint32(name) {
-        let node = this.memoryNodes.get(name);
-        if (node) {
-            return node.getUint32();
-        }
-        return null;
-    }
-    setVector2(name, v2) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(2 * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setXY(v2.x, v2.y);
-    }
-    getVector2(name) {
-        let node = this.memoryNodes.get(name);
-        if (node) {
-            return new Vector2(node.x, node.y);
-        }
-        return null;
-    }
-    setVector3(name, v3) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(3 * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setXYZ(v3.x, v3.y, v3.z);
-    }
-    getVector3(name) {
-        let node = this.memoryNodes.get(name);
-        if (node) {
-            return new Vector3(node.x, node.y, node.z);
-        }
-        return null;
-    }
-    setVector4(name, v4) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(4 * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setXYZW(v4.x, v4.y, v4.z, v4.w);
-    }
-    getVector4(name) {
-        let node = this.memoryNodes.get(name);
-        if (node) {
-            return new Vector4(node.x, node.y, node.z, node.w);
-        }
-        return null;
-    }
-    setVector4Array(name, v4Array) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(4 * 4 * v4Array.length);
-            this.memoryNodes.set(name, node);
-        }
-        node.setVector4Array(v4Array);
-    }
-    setColor(name, color) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(4 * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setXYZW(color.r, color.g, color.b, color.a);
-    }
-    getColor(name) {
-        let node = this.memoryNodes.get(name);
-        if (node) {
-            return new Color(node.x, node.y, node.z, node.w);
-        }
-        return null;
-    }
-    setColorArray(name, colorArray) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(4 * 4 * colorArray.length);
-            this.memoryNodes.set(name, node);
-        }
-        node.setColorArray(colorArray);
-    }
-    setMatrix(name, mat) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(16 * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setFloatArray(0, mat.rawData);
-    }
-    setMatrixArray(name, mats) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(16 * 4 * mats.length);
-            this.memoryNodes.set(name, node);
-        }
-        for (let i = 0; i < mats.length; i++) {
-            const mat = mats[i];
-            node.setFloatArray(i * 16, mat.rawData);
-        }
-    }
-    setArray(name, data) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(data.length * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setArray(0, data);
-    }
-    setFloat32Array(name, data) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(data.length * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setFloat32Array(0, data);
-    }
-    setInt32Array(name, data) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(data.length * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setInt32Array(0, data);
-    }
-    setUint32Array(name, data) {
-        let node = this.memoryNodes.get(name);
-        if (!node) {
-            node = this.memory.allocation_node(data.length * 4);
-            this.memoryNodes.set(name, node);
-        }
-        node.setUint32Array(0, data);
-    }
-    setStruct(c, index, data, property) {
-        let ref = Struct.Ref(c);
-        let size = Struct.GetSize(c);
-        let name = index;
-        let node = this.memoryNodes.get(name);
-        node.reset();
-        let obj = data;
-        if (property) {
-            obj = obj[property];
-        }
-        for (let i = 0; i < ref.length; i++) {
-            const att = ref[i];
-            let value = obj[att.name];
-            this.writeValue(node, att, value);
-        }
-    }
-    writeValue(node, att, value) {
-        switch (att.type) {
-            case `Boolean`:
-                node.writeFloat(value);
-                break;
-            case `Number`:
-                node.writeFloat(value);
-                break;
-            case `Float32Array`:
-                node.writeFloat32Array(value);
-                break;
-            case `Float64Array`:
-                node.writeFloat32Array(new Float32Array(value));
-                break;
-            case `Vector2`:
-                node.writeVector2(value);
-                break;
-            case `Vector3`:
-                node.writeVector3(value);
-                break;
-            case `Vector4`:
-                node.writeVector4(value);
-                break;
-            case `Color`:
-                node.writeRGBColor(value);
-                break;
-            case `Array`:
-                node.writeArray(value);
-                break;
-        }
-    }
-    setStructArray(c, dataList, property) {
-        let len = dataList.length;
-        for (let i = 0; i < len; i++) {
-            const data = dataList[i];
-            this.setStruct(c, i, data, property);
-        }
-    }
-    clean() {
-        this._dataView.fill(0, 0, this._dataView.length);
-    }
-    apply() {
-        webGPUContext.device.queue.writeBuffer(this.buffer, 0, this.memory.shareDataBuffer); //, this.memory.shareFloat32Array.byteOffset, this.memory.shareFloat32Array.byteLength);
-    }
-    mapAsyncWrite(floatArray, len) {
-        let mapAsyncArray;
-        if (floatArray instanceof Float64Array) {
-            mapAsyncArray = new Float32Array(floatArray);
-        }
-        else {
-            mapAsyncArray = floatArray;
-        }
-        // Upload data using mapAsync and a queue of staging buffers.
-        let bytesLen = len;
-        let device = webGPUContext.device;
-        if (mapAsyncArray.length > 0) {
-            let tBuffer = null;
-            while (this.mapAsyncReady.length) {
-                tBuffer = this.mapAsyncReady.shift();
-                if (tBuffer["usedSize"] == mapAsyncArray.byteLength)
-                    break;
-                tBuffer.destroy();
-                this.mapAsyncBuffersOutstanding--;
-                tBuffer = null;
-            }
-            if (!tBuffer) {
-                tBuffer = device.createBuffer({
-                    size: mapAsyncArray.byteLength,
-                    usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
-                    mappedAtCreation: true,
-                });
-                tBuffer["usedSize"] = mapAsyncArray.byteLength;
-                this.mapAsyncBuffersOutstanding++;
-                if (this.mapAsyncBuffersOutstanding > 20) {
-                    console.warn(` Warning: mapAsync requests from ${this.mapAsyncBuffersOutstanding} frames ago have not resolved yet.  MB of staging buffers allocated.`);
-                }
-            }
-            let a = new Float32Array(mapAsyncArray.buffer, mapAsyncArray.byteOffset, len);
-            let b = new Float32Array(tBuffer.getMappedRange(0, len * 4));
-            b.set(a);
-            tBuffer.unmap();
-            const commandEncoder = device.createCommandEncoder();
-            commandEncoder.copyBufferToBuffer(tBuffer, 0, this.buffer, 0, len * 4);
-            // TODO: combine this submit with the main one, but we'll have to delay calling mapAsync until after the submit.
-            device.queue.submit([commandEncoder.finish()]);
-            // TODO: use this data during rendering.
-            tBuffer
-                .mapAsync(GPUMapMode.WRITE)
-                .then(() => this.mapAsyncReady.push(tBuffer));
-        }
-    }
-    destroy(force) {
-        if (this.memoryNodes) {
-            this.memoryNodes.forEach((v) => {
-                v.destroy();
-            });
-        }
-        this.bufferType = null;
-        this.seek = null;
-        this.byteSize = null;
-        this.usage = null;
-        this.visibility = null;
-        this.outFloat32Array = null;
-        if (this.buffer) {
-            this.buffer.destroy();
-        }
-        this.buffer = null;
-        if (this.memory) {
-            this.memory.destroy();
-        }
-        this.memory = null;
-        if (this._readBuffer) {
-            this._readBuffer.destroy();
-        }
-    }
-    createBuffer(usage, size, data, debugLabel) {
-        let device = webGPUContext.device;
-        if (this.buffer) {
-            this.destroy();
-        }
-        this.byteSize = size * 4;
-        this.usage = usage;
-        this.buffer = device.createBuffer({
-            label: debugLabel,
-            size: this.byteSize,
-            usage: usage,
-            mappedAtCreation: false,
-        });
-        this.memory = new MemoryDO();
-        this.memoryNodes = new Map();
-        this._dataView = new Float32Array(this.memory.shareDataBuffer);
-        this.memory.allocation(this.byteSize);
-        if (data) {
-            let m = this.memory.allocation_node(data.length * 4);
-            const buffer = data.buffer instanceof ArrayBuffer ? data.buffer : new Uint8Array(data.buffer).buffer;
-            m.setArrayBuffer(0, buffer);
-            this.apply();
-        }
-    }
-    resizeBuffer(size, data) {
-        this.createBuffer(this.usage, size, data);
-    }
-    createNewBuffer(usage, size) {
-        let device = webGPUContext.device;
-        let tByteSize = size * 4;
-        let tUsage = usage;
-        if (this.buffer) {
-            this.destroy();
-        }
-        let buffer = device.createBuffer({
-            size: tByteSize,
-            usage: tUsage,
-            mappedAtCreation: false,
-        });
-        return buffer;
-    }
-    createBufferByStruct(usage, struct, count) {
-        let structSize = Struct.GetSize(struct);
-        let totalLength = structSize * count;
-        let device = webGPUContext.device;
-        this.buffer = device.createBuffer({
-            label: "StructStorageGPUBuffer",
-            size: totalLength,
-            // size: totalLength * 4,
-            usage: usage,
-            mappedAtCreation: false,
-        });
-        this.memory = new MemoryDO();
-        this.memoryNodes = new Map();
-        this._dataView = new Float32Array(this.memory.shareDataBuffer);
-        this.memory.allocation(totalLength);
-        for (let i = 0; i < count; i++) {
-            let name = i;
-            let node = this.memoryNodes.get(name);
-            if (!node) {
-                node = this.memory.allocation_node(structSize);
-                this.memoryNodes.set(name, node);
-            }
-        }
-    }
-    readBuffer(promise = false) {
-        this.outFloat32Array ||= new Float32Array(this.memory.shareDataBuffer.byteLength / 4);
-        if (!this._readBuffer) {
-            this._readBuffer = webGPUContext.device.createBuffer({
-                size: this.memory.shareDataBuffer.byteLength,
-                usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-                mappedAtCreation: false,
-            });
-        }
-        let p = this.read();
-        return promise ? p : this.outFloat32Array;
-    }
-    async read() {
-        if (!this._readFlag) {
-            this._readFlag = true;
-            let command = webGPUContext.device.createCommandEncoder();
-            command.copyBufferToBuffer(this.buffer, 0, this._readBuffer, 0, this.memory.shareDataBuffer.byteLength);
-            webGPUContext.device.queue.submit([command.finish()]);
-            await this._readBuffer.mapAsync(GPUMapMode.READ);
-            const copyArrayBuffer = this._readBuffer.getMappedRange();
-            this.outFloat32Array.set(new Float32Array(copyArrayBuffer), 0);
-            this._readBuffer.unmap();
-            this._readFlag = false;
-        }
-        return this.outFloat32Array;
-    }
-}

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

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

package/dist/src/gfx/graphics/webGpu/core/buffer/GPUBufferType.js

@@ -1,10 +0,0 @@
-export var GPUBufferType;
-(function (GPUBufferType) {
-    GPUBufferType[GPUBufferType["IndicesGPUBuffer"] = 0] = "IndicesGPUBuffer";
-    GPUBufferType[GPUBufferType["VertexGPUBuffer"] = 1] = "VertexGPUBuffer";
-    GPUBufferType[GPUBufferType["UniformGPUBuffer"] = 2] = "UniformGPUBuffer";
-    GPUBufferType[GPUBufferType["StorageGPUBuffer"] = 3] = "StorageGPUBuffer";
-    GPUBufferType[GPUBufferType["ComputeGPUBuffer"] = 4] = "ComputeGPUBuffer";
-    GPUBufferType[GPUBufferType["MaterialDataUniformGPUBuffer"] = 5] = "MaterialDataUniformGPUBuffer";
-    GPUBufferType[GPUBufferType["StructStorageGPUBuffer"] = 6] = "StructStorageGPUBuffer";
-})(GPUBufferType || (GPUBufferType = {}));

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

@@ -1,14 +0,0 @@
-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/src/gfx/graphics/webGpu/core/buffer/IndicesGPUBuffer.js

@@ -1,44 +0,0 @@
-import { MemoryDO } from "../../../../../core/pool/memory/MemoryDO";
-import { webGPUContext } from "../../Context3D";
-import { GPUBufferBase } from "./GPUBufferBase";
-import { GPUBufferType } from "./GPUBufferType";
-/**
- * 用于几何体索引的缓冲区
- * 可在计算着色器或CPU代码中写入
- * 使用标志: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT
- * @group GFX
- */
-export class IndicesGPUBuffer extends GPUBufferBase {
-    constructor(data) {
-        super();
-        this.bufferType = GPUBufferType.IndicesGPUBuffer; // 设置缓冲区类型为索引缓冲区
-        this.createIndicesBuffer(GPUBufferUsage.STORAGE |
-            GPUBufferUsage.COPY_DST |
-            GPUBufferUsage.INDEX |
-            GPUBufferUsage.INDIRECT, data);
-    }
-    createIndicesBuffer(usage, data) {
-        let device = webGPUContext.device;
-        this.byteSize = data.length * 4;
-        this.usage = usage;
-        if (this.buffer) {
-            this.destroy();
-        }
-        this.buffer = device.createBuffer({
-            label: "IndicesGPUBuffer",
-            size: this.byteSize,
-            usage: usage,
-            mappedAtCreation: false,
-        });
-        this.memory = new MemoryDO();
-        this.memoryNodes = new Map();
-        this.memory.allocation(this.byteSize);
-        if (data) {
-            // 分配内存节点并设置数据
-            this.indicesNode = this.memory.allocation_node(data.length * 4);
-            const buffer = data.buffer instanceof ArrayBuffer ? data.buffer : new Uint8Array(data.buffer).buffer;
-            this.indicesNode.setArrayBuffer(0, buffer);
-            this.apply();
-        }
-    }
-}

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

@@ -1,10 +0,0 @@
-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;
-}