@rings-webgpu/core 1.0.0 → 1.0.2

package/dist/src/core/geometry/GeometryVertexBuffer.js

@@ -0,0 +1,243 @@
+import { VertexGPUBuffer } from "../../gfx/graphics/webGpu/core/buffer/VertexGPUBuffer";
+import { GeometryVertexType } from "./GeometryVertexType";
+import { VertexAttributeSize } from "./VertexAttributeSize";
+import { VertexAttributeName } from "./VertexAttributeName";
+export class GeometryVertexBuffer {
+    constructor() {
+        this.vertexCount = 0;
+        this.geometryType = GeometryVertexType.compose;
+        this._vertexBufferLayouts = [];
+        this._attributeLocation = {};
+        this._attributeSlotLayouts = [];
+    }
+    get vertexBufferLayouts() {
+        return this._vertexBufferLayouts;
+    }
+    createVertexBuffer(vertexDataInfos, shaderReflection) {
+        switch (this.geometryType) {
+            case GeometryVertexType.split:
+                this.createSplitVertexBuffer(vertexDataInfos, shaderReflection);
+                break;
+            case GeometryVertexType.compose:
+                this.createComposeVertexBuffer(vertexDataInfos, shaderReflection);
+                break;
+            case GeometryVertexType.compose_bin:
+                this.createComposBinVertexBuffer(vertexDataInfos, shaderReflection);
+                break;
+        }
+    }
+    createSplitVertexBuffer(vertexDataInfos, shaderReflection) {
+        let vertexOffset = 0;
+        for (let i = 0; i < shaderReflection.attributes.length; i++) {
+            const attributeInfo = shaderReflection.attributes[i];
+            if (attributeInfo.name == `index`)
+                continue;
+            this._attributeLocation[attributeInfo.name] = attributeInfo.location;
+            let attributeLayout = {
+                name: attributeInfo.name,
+                format: attributeInfo.format,
+                offset: 0,
+                shaderLocation: attributeInfo.location,
+                stride: VertexAttributeSize[attributeInfo.format],
+            };
+            this._attributeSlotLayouts[attributeInfo.location] = [attributeLayout];
+            let vertexInfo = vertexDataInfos.get(attributeInfo.name);
+            if (!vertexInfo) {
+                vertexInfo = {
+                    attribute: attributeInfo.name,
+                    data: new Float32Array(attributeInfo.size * this.vertexCount),
+                };
+                vertexDataInfos.set(attributeInfo.name, vertexInfo);
+            }
+            let len = vertexInfo.data.length / attributeLayout.stride;
+            if (this.vertexCount != 0 && this.vertexCount != len) {
+                console.error(" vertex count not match attribute count");
+            }
+            this.vertexCount = len;
+            this._vertexBufferLayouts[attributeInfo.location] = {
+                name: attributeInfo.name,
+                arrayStride: attributeInfo.size * 4,
+                stepMode: `vertex`,
+                attributes: this._attributeSlotLayouts[attributeInfo.location],
+                offset: vertexOffset * 4,
+                size: this.vertexCount * attributeInfo.size * 4,
+            };
+            vertexOffset += this.vertexCount * attributeInfo.size;
+        }
+        this.vertexGPUBuffer = new VertexGPUBuffer(vertexOffset);
+    }
+    createComposeVertexBuffer(vertexDataInfos, shaderReflection) {
+        this._attributeSlotLayouts[0] = [];
+        let attributeOffset = 0;
+        for (let i = 0; i < shaderReflection.attributes.length; i++) {
+            const attributeInfo = shaderReflection.attributes[i];
+            if (attributeInfo.name == `index`)
+                continue;
+            if (attributeInfo.type == `builtin`)
+                continue;
+            this._attributeLocation[attributeInfo.name] = attributeInfo.location;
+            let attributeLayout = {
+                name: attributeInfo.name,
+                format: attributeInfo.format,
+                offset: attributeOffset * 4,
+                shaderLocation: attributeInfo.location,
+                stride: VertexAttributeSize[attributeInfo.format],
+            };
+            this._attributeSlotLayouts[0][attributeInfo.location] = attributeLayout;
+            let vertexInfo = vertexDataInfos.get(attributeInfo.name);
+            if (!vertexInfo) {
+                vertexInfo = {
+                    attribute: attributeInfo.name,
+                    data: new Float32Array(attributeInfo.size * this.vertexCount),
+                };
+                vertexDataInfos.set(attributeInfo.name, vertexInfo);
+            }
+            if (vertexInfo.data) {
+                let len = vertexInfo.data.length / attributeLayout.stride;
+                if (this.vertexCount != 0 && this.vertexCount != len) {
+                    console.error(" vertex count not match attribute count");
+                }
+                this.vertexCount = len;
+            }
+            attributeOffset += attributeInfo.size;
+        }
+        this._vertexBufferLayouts[0] = {
+            name: `composeStruct`,
+            arrayStride: attributeOffset * 4,
+            stepMode: `vertex`,
+            attributes: this._attributeSlotLayouts[0],
+            offset: 0,
+            size: this.vertexCount * attributeOffset * 4,
+        };
+        this.vertexGPUBuffer = new VertexGPUBuffer(this.vertexCount * attributeOffset);
+    }
+    createComposBinVertexBuffer(vertexDataInfos, shaderReflection) {
+        this._attributeSlotLayouts[0] = [];
+        let attributeOffset = 0;
+        for (let i = 0; i < shaderReflection.attributes.length; i++) {
+            const attributeInfo = shaderReflection.attributes[i];
+            if (attributeInfo.name == `index`)
+                continue;
+            if (attributeInfo.type == `builtin`)
+                continue;
+            this._attributeLocation[attributeInfo.name] = attributeInfo.location;
+            let attributeLayout = {
+                name: attributeInfo.name,
+                format: attributeInfo.format,
+                offset: attributeOffset * 4,
+                shaderLocation: attributeInfo.location,
+                stride: VertexAttributeSize[attributeInfo.format],
+            };
+            this._attributeSlotLayouts[0][attributeInfo.location] = attributeLayout;
+            let vertexInfo = vertexDataInfos.get(attributeInfo.name);
+            if (!vertexInfo) {
+                vertexInfo = {
+                    attribute: attributeInfo.name,
+                    data: new Float32Array(attributeInfo.size * this.vertexCount),
+                };
+                vertexDataInfos.set(attributeInfo.name, vertexInfo);
+            }
+            if (vertexInfo.data) {
+                let len = vertexInfo.data.length / attributeLayout.stride;
+                if (this.vertexCount != 0 && this.vertexCount != len) {
+                    console.error(" vertex count not match attribute count");
+                }
+                this.vertexCount = len;
+            }
+            attributeOffset += attributeInfo.size;
+        }
+        let att_all = vertexDataInfos.get(VertexAttributeName.all);
+        let len = att_all.data.length / attributeOffset;
+        this.vertexCount = len;
+        this._vertexBufferLayouts[0] = {
+            name: `composeStruct`,
+            arrayStride: attributeOffset * 4,
+            stepMode: `vertex`,
+            attributes: this._attributeSlotLayouts[0],
+            offset: 0,
+            size: this.vertexCount * attributeOffset * 4,
+        };
+        this.vertexGPUBuffer = new VertexGPUBuffer(this.vertexCount * attributeOffset);
+    }
+    upload(attribute, vertexDataInfo) {
+        if (!this.vertexGPUBuffer)
+            return;
+        switch (this.geometryType) {
+            case GeometryVertexType.split:
+                {
+                    let location = this._attributeLocation[attribute];
+                    let vertexBufferLayout = this._vertexBufferLayouts[location];
+                    this.vertexGPUBuffer.node.setFloat32Array(vertexBufferLayout.offset / 4, vertexDataInfo.data);
+                }
+                break;
+            case GeometryVertexType.compose:
+                {
+                    for (let i = 0; i < this.vertexCount; i++) {
+                        const attributeLayout = this._attributeSlotLayouts[0][this._attributeLocation[attribute]];
+                        for (let k = 0; k < attributeLayout.stride; k++) {
+                            let atData = vertexDataInfo.data[i * attributeLayout.stride + k];
+                            let index = i * (this._vertexBufferLayouts[0].arrayStride / 4) +
+                                attributeLayout.offset / 4 +
+                                k;
+                            this.vertexGPUBuffer.node.setFloat(atData, index);
+                        }
+                    }
+                }
+                break;
+            case GeometryVertexType.compose_bin:
+                this.vertexGPUBuffer.node.setFloat32Array(0, vertexDataInfo.data);
+                break;
+        }
+        this.vertexGPUBuffer?.apply();
+    }
+    updateAttributes(vertexDataInfos) {
+        switch (this.geometryType) {
+            case GeometryVertexType.split:
+                {
+                    for (let i = 0; i < this._vertexBufferLayouts.length; i++) {
+                        const vertexBufferLayout = this._vertexBufferLayouts[i];
+                        let attributeData = vertexDataInfos.get(vertexBufferLayout.name);
+                        this.vertexGPUBuffer.node.setFloat32Array(vertexBufferLayout.offset / 4, attributeData.data);
+                    }
+                }
+                break;
+            case GeometryVertexType.compose:
+                {
+                    for (let i = 0; i < this.vertexCount; i++) {
+                        this._attributeSlotLayouts.forEach((v) => {
+                            for (let j = 0; j < v.length; j++) {
+                                const attributeLayout = v[j];
+                                let attributeData = vertexDataInfos.get(attributeLayout.name);
+                                for (let k = 0; k < attributeLayout.stride; k++) {
+                                    let atData = attributeData.data[i * attributeLayout.stride + k];
+                                    let index = i * (this._vertexBufferLayouts[0].arrayStride / 4) +
+                                        attributeLayout.offset / 4 +
+                                        k;
+                                    this.vertexGPUBuffer.node.setFloat(atData, index);
+                                }
+                            }
+                        });
+                    }
+                }
+                break;
+            case GeometryVertexType.compose_bin:
+                {
+                    let attributeData = vertexDataInfos.get(VertexAttributeName.all);
+                    this.vertexGPUBuffer.node.setFloat32Array(0, attributeData.data);
+                }
+                break;
+        }
+        this.vertexGPUBuffer.apply();
+    }
+    compute() { }
+    destroy(force) {
+        this.vertexCount = null;
+        this.geometryType = null;
+        this._vertexBufferLayouts = null;
+        this._attributeSlotLayouts = null;
+        this._attributeLocation = null;
+        if (this.vertexGPUBuffer)
+            this.vertexGPUBuffer.destroy(force);
+        this.vertexGPUBuffer = null;
+    }
+}

package/dist/src/core/geometry/GeometryVertexType.d.ts

@@ -0,0 +1,5 @@
+export declare enum GeometryVertexType {
+    split = 0,
+    compose = 1,
+    compose_bin = 2
+}

package/dist/src/core/geometry/GeometryVertexType.js

@@ -0,0 +1,6 @@
+export var GeometryVertexType;
+(function (GeometryVertexType) {
+    GeometryVertexType[GeometryVertexType["split"] = 0] = "split";
+    GeometryVertexType[GeometryVertexType["compose"] = 1] = "compose";
+    GeometryVertexType[GeometryVertexType["compose_bin"] = 2] = "compose_bin";
+})(GeometryVertexType || (GeometryVertexType = {}));

package/dist/src/core/geometry/VertexAttribute.d.ts

@@ -0,0 +1,15 @@
+export declare class VertexBufferLayout implements GPUVertexBufferLayout {
+    name: string;
+    offset: number;
+    size: number;
+    arrayStride: number;
+    stepMode?: GPUVertexStepMode;
+    attributes: Iterable<GPUVertexAttribute>;
+}
+export declare class VertexAttribute implements GPUVertexAttribute {
+    name: string;
+    format: GPUVertexFormat;
+    offset: number;
+    shaderLocation: number;
+    stride: number;
+}

package/dist/src/core/geometry/VertexAttribute.js

@@ -0,0 +1,4 @@
+export class VertexBufferLayout {
+}
+export class VertexAttribute {
+}

package/dist/src/core/geometry/VertexAttributeData.d.ts

@@ -0,0 +1,5 @@
+import { ArrayBufferData } from "../../gfx/graphics/webGpu/core/buffer/ArrayBufferData";
+export type VertexAttributeData = {
+    attribute: string;
+    data: ArrayBufferData;
+};

package/dist/src/core/geometry/VertexAttributeData.js

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

package/dist/src/core/geometry/VertexAttributeName.d.ts

@@ -0,0 +1,23 @@
+export declare enum VertexAttributeName {
+    position = "position",
+    normal = "normal",
+    uv = "uv",
+    TANGENT = "TANGENT",
+    TEXCOORD_1 = "TEXCOORD_1",
+    TEXCOORD_2 = "TEXCOORD_2",
+    TEXCOORD_3 = "TEXCOORD_3",
+    TEXCOORD_4 = "TEXCOORD_4",
+    TEXCOORD_5 = "TEXCOORD_5",
+    TEXCOORD_6 = "TEXCOORD_6",
+    TEXCOORD_7 = "TEXCOORD_7",
+    color = "color",
+    joints0 = "joints0",
+    joints1 = "joints1",
+    weights0 = "weights0",
+    weights1 = "weights1",
+    weight = "weight",
+    indices = "indices",
+    vIndex = "vIndex",
+    a_morphPositions_0 = "a_morphPositions_0",
+    all = "all"
+}

package/dist/src/core/geometry/VertexAttributeName.js

@@ -0,0 +1,24 @@
+export var VertexAttributeName;
+(function (VertexAttributeName) {
+    VertexAttributeName["position"] = "position";
+    VertexAttributeName["normal"] = "normal";
+    VertexAttributeName["uv"] = "uv";
+    VertexAttributeName["TANGENT"] = "TANGENT";
+    VertexAttributeName["TEXCOORD_1"] = "TEXCOORD_1";
+    VertexAttributeName["TEXCOORD_2"] = "TEXCOORD_2";
+    VertexAttributeName["TEXCOORD_3"] = "TEXCOORD_3";
+    VertexAttributeName["TEXCOORD_4"] = "TEXCOORD_4";
+    VertexAttributeName["TEXCOORD_5"] = "TEXCOORD_5";
+    VertexAttributeName["TEXCOORD_6"] = "TEXCOORD_6";
+    VertexAttributeName["TEXCOORD_7"] = "TEXCOORD_7";
+    VertexAttributeName["color"] = "color";
+    VertexAttributeName["joints0"] = "joints0";
+    VertexAttributeName["joints1"] = "joints1";
+    VertexAttributeName["weights0"] = "weights0";
+    VertexAttributeName["weights1"] = "weights1";
+    VertexAttributeName["weight"] = "weight";
+    VertexAttributeName["indices"] = "indices";
+    VertexAttributeName["vIndex"] = "vIndex";
+    VertexAttributeName["a_morphPositions_0"] = "a_morphPositions_0";
+    VertexAttributeName["all"] = "all";
+})(VertexAttributeName || (VertexAttributeName = {}));

package/dist/src/core/geometry/VertexAttributeSize.d.ts

@@ -0,0 +1,11 @@
+export declare enum VertexAttributeSize {
+    "u32" = 1,
+    "f32" = 1,
+    "vec2<f32>" = 2,
+    "vec3<f32>" = 3,
+    "vec4<f32>" = 4,
+    "float32" = 1,
+    "float32x2" = 2,
+    "float32x3" = 3,
+    "float32x4" = 4
+}

package/dist/src/core/geometry/VertexAttributeSize.js

@@ -0,0 +1,12 @@
+export var VertexAttributeSize;
+(function (VertexAttributeSize) {
+    VertexAttributeSize[VertexAttributeSize["u32"] = 1] = "u32";
+    VertexAttributeSize[VertexAttributeSize["f32"] = 1] = "f32";
+    VertexAttributeSize[VertexAttributeSize["vec2<f32>"] = 2] = "vec2<f32>";
+    VertexAttributeSize[VertexAttributeSize["vec3<f32>"] = 3] = "vec3<f32>";
+    VertexAttributeSize[VertexAttributeSize["vec4<f32>"] = 4] = "vec4<f32>";
+    VertexAttributeSize[VertexAttributeSize["float32"] = 1] = "float32";
+    VertexAttributeSize[VertexAttributeSize["float32x2"] = 2] = "float32x2";
+    VertexAttributeSize[VertexAttributeSize["float32x3"] = 3] = "float32x3";
+    VertexAttributeSize[VertexAttributeSize["float32x4"] = 4] = "float32x4";
+})(VertexAttributeSize || (VertexAttributeSize = {}));

package/dist/src/core/geometry/VertexAttributeStride.d.ts

@@ -0,0 +1,15 @@
+export declare enum VertexAttributeStride {
+    position = 3,
+    normal = 3,
+    TANGENT = 4,
+    uv = 2,
+    TEXCOORD_1 = 2,
+    color = 4,
+    joints0 = 4,
+    weights0 = 4,
+    joints1 = 4,
+    weights1 = 4,
+    vIndex = 1,
+    weight = 1,
+    a_morphPositions_0 = 3
+}

package/dist/src/core/geometry/VertexAttributeStride.js

@@ -0,0 +1,16 @@
+export var VertexAttributeStride;
+(function (VertexAttributeStride) {
+    VertexAttributeStride[VertexAttributeStride["position"] = 3] = "position";
+    VertexAttributeStride[VertexAttributeStride["normal"] = 3] = "normal";
+    VertexAttributeStride[VertexAttributeStride["TANGENT"] = 4] = "TANGENT";
+    VertexAttributeStride[VertexAttributeStride["uv"] = 2] = "uv";
+    VertexAttributeStride[VertexAttributeStride["TEXCOORD_1"] = 2] = "TEXCOORD_1";
+    VertexAttributeStride[VertexAttributeStride["color"] = 4] = "color";
+    VertexAttributeStride[VertexAttributeStride["joints0"] = 4] = "joints0";
+    VertexAttributeStride[VertexAttributeStride["weights0"] = 4] = "weights0";
+    VertexAttributeStride[VertexAttributeStride["joints1"] = 4] = "joints1";
+    VertexAttributeStride[VertexAttributeStride["weights1"] = 4] = "weights1";
+    VertexAttributeStride[VertexAttributeStride["vIndex"] = 1] = "vIndex";
+    VertexAttributeStride[VertexAttributeStride["weight"] = 1] = "weight";
+    VertexAttributeStride[VertexAttributeStride["a_morphPositions_0"] = 3] = "a_morphPositions_0";
+})(VertexAttributeStride || (VertexAttributeStride = {}));

package/dist/src/core/geometry/VertexFormat.d.ts

@@ -0,0 +1 @@
+export declare let VertexFormat: GPUVertexFormat[];

package/dist/src/core/geometry/VertexFormat.js

@@ -0,0 +1,8 @@
+import { GPUVertexFormat } from "../../gfx/graphics/webGpu/WebGPUConst";
+export let VertexFormat = [
+    null,
+    GPUVertexFormat.float32,
+    GPUVertexFormat.float32x2,
+    GPUVertexFormat.float32x3,
+    GPUVertexFormat.float32x4,
+];

package/dist/src/core/pool/ObjectPool.d.ts

@@ -0,0 +1,11 @@
+export declare class PoolNode<T> {
+    private _use;
+    private _unUse;
+    constructor();
+    pushBack(node: T): void;
+    getUseList(): T[];
+    getOne(instance: {
+        new (arg?: any): T;
+    }, param?: any): T;
+    hasFree(): boolean;
+}

package/dist/src/core/pool/ObjectPool.js

@@ -0,0 +1,33 @@
+export class PoolNode {
+    constructor() {
+        this._use = [];
+        this._unUse = [];
+    }
+    pushBack(node) {
+        let index = this._use.indexOf(node);
+        if (index != -1) {
+            this._use.splice(index, 1);
+            this._unUse.push(node);
+        }
+    }
+    getUseList() {
+        return this._use;
+    }
+    getOne(instance, param) {
+        let node;
+        if (this._unUse.length > 0) {
+            node = this._unUse[0];
+            this._unUse.splice(0, 1);
+            this._use.push(node);
+            return node;
+        }
+        else {
+            node = new instance(param);
+            this._use.push(node);
+        }
+        return node;
+    }
+    hasFree() {
+        return this._unUse.length > 0;
+    }
+}

package/dist/src/core/pool/memory/MemoryDO.d.ts

@@ -0,0 +1,14 @@
+import { MemoryInfo } from './MemoryInfo';
+/**
+ * @internal
+ * @group Core
+ */
+export declare class MemoryDO {
+    shareDataBuffer: ArrayBuffer;
+    private _byteOffset;
+    allocation(byteSize: number): void;
+    allocation_node(byteSize: number): MemoryInfo;
+    allocation_memory(memoryInfo: MemoryInfo): MemoryInfo;
+    reset(): void;
+    destroy(force?: boolean): void;
+}

package/dist/src/core/pool/memory/MemoryDO.js

@@ -0,0 +1,48 @@
+import { MemoryInfo } from './MemoryInfo';
+/**
+ * @internal
+ * @group Core
+ */
+export class MemoryDO {
+    constructor() {
+        this._byteOffset = 0;
+    }
+    allocation(byteSize) {
+        if (this.shareDataBuffer && this.shareDataBuffer.byteLength < byteSize) {
+            this._byteOffset = 0;
+        }
+        else {
+            this.shareDataBuffer = new ArrayBuffer(byteSize);
+        }
+    }
+    allocation_node(byteSize) {
+        if (this._byteOffset + byteSize > this.shareDataBuffer.byteLength) {
+            console.error('memory not enough!', this._byteOffset, byteSize, this.shareDataBuffer.byteLength);
+            return null;
+        }
+        let memoryInfo = new MemoryInfo();
+        memoryInfo.byteOffset = this._byteOffset;
+        memoryInfo.byteSize = byteSize;
+        memoryInfo.dataBytes = new DataView(this.shareDataBuffer, this._byteOffset, memoryInfo.byteSize);
+        this._byteOffset += memoryInfo.byteSize;
+        return memoryInfo;
+    }
+    allocation_memory(memoryInfo) {
+        if (this._byteOffset + memoryInfo.byteSize > this.shareDataBuffer.byteLength) {
+            console.error('memory not enough!', this._byteOffset, memoryInfo.byteSize, this.shareDataBuffer.byteLength);
+            return null;
+        }
+        memoryInfo.byteOffset = this._byteOffset;
+        memoryInfo.dataBytes = new DataView(this.shareDataBuffer, this._byteOffset, memoryInfo.byteSize);
+        this._byteOffset += memoryInfo.byteSize;
+        return memoryInfo;
+    }
+    reset() {
+        this._byteOffset = 0;
+    }
+    destroy(force) {
+        this.shareDataBuffer = null;
+        this._byteOffset = 0;
+    }
+}
+// export let MemoryPool = new _MemoryPool();

package/dist/src/core/pool/memory/MemoryInfo.d.ts

@@ -0,0 +1,83 @@
+import { FloatArray } from '@rings/wasm-matrix/WasmMatrix';
+import { Color } from '../../../math/Color';
+import { Quaternion } from '../../../math/Quaternion';
+import { Vector2 } from '../../../math/Vector2';
+import { Vector3 } from '../../../math/Vector3';
+import { Vector4 } from '../../../math/Vector4';
+/**
+ * @internal
+ * @group Core
+ */
+export declare class MemoryInfo {
+    byteOffset: number;
+    byteSize: number;
+    offset: number;
+    dataBytes: DataView;
+    get x(): number;
+    set x(v: number);
+    get y(): number;
+    set y(v: number);
+    get z(): number;
+    set z(v: number);
+    get w(): number;
+    set w(v: number);
+    setX(x: number): void;
+    setXY(x: number, y: number): void;
+    setXYZ(x: number, y: number, z: number): void;
+    setXYZW(x: number, y: number, z: number, w: number): void;
+    setVector2Array(vs: Vector2[]): void;
+    setVector3Array(vs: Vector3[]): void;
+    setVector4Array(vs: Vector3[] | Vector4[] | Quaternion[]): void;
+    setColorArray(colorArray: Color[]): void;
+    setInt8(v: number, index?: number): void;
+    getInt8(index?: number): number;
+    setInt16(v: number, index?: number): void;
+    getInt16(index?: number): number;
+    setInt32(v: number, index?: number): void;
+    getInt32(index?: number): number;
+    setFloat(v: number, index?: number): void;
+    getFloat(index?: number): number;
+    setUint8(v: number, index?: number): void;
+    getUint8(index?: number): number;
+    setUint16(v: number, index?: number): void;
+    getUint16(index?: number): number;
+    setUint32(v: number, index?: number): void;
+    getUint32(index?: number): number;
+    setArray(index: number, data: number[]): void;
+    setFloat32Array(index: number, data: Float32Array): void;
+    setFloatArray(index: number, value: FloatArray): void;
+    setArrayBuffer(index: number, arrayBuffer: ArrayBuffer): void;
+    setInt8Array(index: number, data: Int8Array): void;
+    setInt16Array(index: number, data: Int16Array): void;
+    setInt32Array(index: number, data: Int32Array): void;
+    setUint8Array(index: number, data: Uint8Array): void;
+    setUint16Array(index: number, data: Uint16Array): void;
+    setUint32Array(index: number, data: Uint32Array): void;
+    setData(index: number, data: number): void;
+    setVector2(index: number, data: Vector2): void;
+    setVector3(index: number, data: Vector3): void;
+    setVector4(index: number, data: Vector4): void;
+    setColor(index: number, data: Color): void;
+    getData(index: number): number;
+    writeFloat(v: number): void;
+    writeInt8(v: number): void;
+    writeInt16(v: number): void;
+    writeInt32(v: number): void;
+    writeUint8(v: number): void;
+    writeUint16(v: number): void;
+    writeUint32(v: number): void;
+    writeVector2(v: Vector2): void;
+    writeVector3(v: Vector3): void;
+    writeVector4(v: Vector4): void;
+    writeRGBColor(v: Color): void;
+    writeArray(v: number[]): void;
+    writeFloat32Array(v: Float32Array): void;
+    writeInt8Array(v: Int8Array): void;
+    writeInt16Array(v: Int16Array): void;
+    writeInt32Array(v: Int32Array): void;
+    writeUint8Array(v: Uint8Array): void;
+    writeUint16Array(v: Uint16Array): void;
+    writeUint32Array(v: Uint32Array): void;
+    reset(): void;
+    destroy(): void;
+}