ris-framework 0.1.0 → 0.2.0-dev.12

package/src/webgpu/WebGpuTypes.ts

@@ -0,0 +1,288 @@
+/**
+ * Minimal hand-written WebGPU type declarations used by the WebGPU backend.
+ *
+ * TypeScript 5.9's `lib.dom` does not ship the WebGPU API, and the project avoids adding `@webgpu/types`.
+ * The types are module-scoped (prefixed with `Gpu`) instead of global, so they never clash with `@webgpu/types`
+ * in a consumer's project. Only what the backend uses is declared.
+ * @internal
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/** `GPUBufferUsage` flags. */
+export const GpuBufferUsage = {
+    MAP_READ: 0x0001,
+    MAP_WRITE: 0x0002,
+    COPY_SRC: 0x0004,
+    COPY_DST: 0x0008,
+    INDEX: 0x0010,
+    VERTEX: 0x0020,
+    UNIFORM: 0x0040,
+    STORAGE: 0x0080,
+    INDIRECT: 0x0100,
+    QUERY_RESOLVE: 0x0200,
+} as const;
+
+/** `GPUTextureUsage` flags. */
+export const GpuTextureUsage = {
+    COPY_SRC: 0x01,
+    COPY_DST: 0x02,
+    TEXTURE_BINDING: 0x04,
+    STORAGE_BINDING: 0x08,
+    RENDER_ATTACHMENT: 0x10,
+} as const;
+
+/** `GPUShaderStage` flags. */
+export const GpuShaderStage = {
+    VERTEX: 0x1,
+    FRAGMENT: 0x2,
+    COMPUTE: 0x4,
+} as const;
+
+export type GpuTextureFormat = string;
+export type GpuPowerPreference = "low-power" | "high-performance";
+export type GpuLoadOp = "load" | "clear";
+export type GpuStoreOp = "store" | "discard";
+export type GpuIndexFormat = "uint16" | "uint32";
+export type GpuPrimitiveTopology = "point-list" | "line-list" | "line-strip" | "triangle-list" | "triangle-strip";
+export type GpuCullMode = "none" | "front" | "back";
+export type GpuFrontFace = "ccw" | "cw";
+export type GpuBlendFactor = "zero" | "one" | "src-alpha" | "one-minus-src-alpha" | string;
+export type GpuBlendOperation = "add" | "subtract" | "reverse-subtract" | "min" | "max";
+export type GpuAddressMode = "clamp-to-edge" | "repeat" | "mirror-repeat";
+export type GpuFilterMode = "nearest" | "linear";
+export type GpuCompareFunction = "never" | "less" | "equal" | "less-equal" | "greater" | "not-equal" | "greater-equal" | "always";
+export type GpuVertexFormat = "float32" | "float32x2" | "float32x3" | "float32x4" | string;
+export type GpuVertexStepMode = "vertex" | "instance";
+
+export interface GpuObjectBase {
+    label: string;
+}
+
+export interface GpuAdapterInfo {
+    readonly vendor: string;
+    readonly architecture: string;
+    readonly device: string;
+    readonly description: string;
+}
+
+export interface GpuSupportedFeatures {
+    has(feature: string): boolean;
+}
+
+export interface Gpu {
+    requestAdapter(options?: { powerPreference?: GpuPowerPreference }): Promise<GpuAdapter | null>;
+    getPreferredCanvasFormat(): GpuTextureFormat;
+}
+
+export interface GpuAdapter {
+    readonly features: GpuSupportedFeatures;
+    readonly info?: GpuAdapterInfo;
+    requestDevice(descriptor?: { label?: string; requiredFeatures?: string[] }): Promise<GpuDevice>;
+}
+
+export interface GpuError {
+    readonly message: string;
+}
+
+export interface GpuDevice extends GpuObjectBase {
+    readonly features: GpuSupportedFeatures;
+    readonly queue: GpuQueue;
+    readonly lost: Promise<{ reason: string; message: string }>;
+    createBuffer(descriptor: { label?: string; size: number; usage: number; mappedAtCreation?: boolean }): GpuBuffer;
+    createTexture(descriptor: {
+        label?: string;
+        size: [number, number, number?] | { width: number; height?: number; depthOrArrayLayers?: number };
+        mipLevelCount?: number;
+        sampleCount?: number;
+        dimension?: "1d" | "2d" | "3d";
+        format: GpuTextureFormat;
+        usage: number;
+    }): GpuTexture;
+    createSampler(descriptor?: {
+        label?: string;
+        addressModeU?: GpuAddressMode;
+        addressModeV?: GpuAddressMode;
+        addressModeW?: GpuAddressMode;
+        magFilter?: GpuFilterMode;
+        minFilter?: GpuFilterMode;
+        mipmapFilter?: GpuFilterMode;
+        lodMinClamp?: number;
+        lodMaxClamp?: number;
+        compare?: GpuCompareFunction;
+        maxAnisotropy?: number;
+    }): GpuSampler;
+    createBindGroupLayout(descriptor: { label?: string; entries: GpuBindGroupLayoutEntry[] }): GpuBindGroupLayout;
+    createPipelineLayout(descriptor: { label?: string; bindGroupLayouts: GpuBindGroupLayout[] }): GpuPipelineLayout;
+    createBindGroup(descriptor: { label?: string; layout: GpuBindGroupLayout; entries: GpuBindGroupEntry[] }): GpuBindGroup;
+    createShaderModule(descriptor: { label?: string; code: string }): GpuShaderModule;
+    createRenderPipeline(descriptor: GpuRenderPipelineDescriptor): GpuRenderPipeline;
+    createCommandEncoder(descriptor?: { label?: string }): GpuCommandEncoder;
+    pushErrorScope(filter: "validation" | "out-of-memory" | "internal"): void;
+    popErrorScope(): Promise<GpuError | null>;
+    addEventListener(type: "uncapturederror", listener: (event: { error: GpuError }) => void): void;
+    destroy(): void;
+}
+
+export interface GpuQueue {
+    submit(commandBuffers: GpuCommandBuffer[]): void;
+    writeBuffer(buffer: GpuBuffer, bufferOffset: number, data: ArrayBufferLike | ArrayBufferView, dataOffset?: number, size?: number): void;
+    writeTexture(
+        destination: { texture: GpuTexture; mipLevel?: number; origin?: [number, number, number?] },
+        data: ArrayBufferView | ArrayBufferLike,
+        dataLayout: { offset?: number; bytesPerRow?: number; rowsPerImage?: number },
+        size: [number, number, number?] | { width: number; height?: number; depthOrArrayLayers?: number }): void;
+    copyExternalImageToTexture(
+        source: { source: any; flipY?: boolean },
+        destination: { texture: GpuTexture; mipLevel?: number; premultipliedAlpha?: boolean },
+        copySize: [number, number, number?] | { width: number; height?: number; depthOrArrayLayers?: number }): void;
+}
+
+export interface GpuBuffer extends GpuObjectBase {
+    readonly size: number;
+    destroy(): void;
+}
+
+export interface GpuTexture extends GpuObjectBase {
+    readonly width: number;
+    readonly height: number;
+    readonly format: GpuTextureFormat;
+    createView(descriptor?: { label?: string; format?: GpuTextureFormat; dimension?: string }): GpuTextureView;
+    destroy(): void;
+}
+
+export interface GpuTextureView extends GpuObjectBase {
+    readonly __brand?: "GPUTextureView";
+}
+
+export interface GpuSampler extends GpuObjectBase {
+    readonly __brand?: "GPUSampler";
+}
+
+export interface GpuBindGroupLayout extends GpuObjectBase {
+    readonly __brand?: "GPUBindGroupLayout";
+}
+
+export interface GpuPipelineLayout extends GpuObjectBase {
+    readonly __brand?: "GPUPipelineLayout";
+}
+
+export interface GpuBindGroup extends GpuObjectBase {
+    readonly __brand?: "GPUBindGroup";
+}
+
+export interface GpuShaderModule extends GpuObjectBase {
+    getCompilationInfo?(): Promise<{ messages: readonly { type: string; message: string; lineNum: number; linePos: number }[] }>;
+}
+
+export interface GpuRenderPipeline extends GpuObjectBase {
+    readonly __brand?: "GPURenderPipeline";
+}
+
+export interface GpuCommandBuffer extends GpuObjectBase {
+    readonly __brand?: "GPUCommandBuffer";
+}
+
+export interface GpuBindGroupLayoutEntry {
+    binding: number;
+    visibility: number;
+    buffer?: { type?: "uniform" | "storage" | "read-only-storage"; hasDynamicOffset?: boolean; minBindingSize?: number };
+    sampler?: { type?: "filtering" | "non-filtering" | "comparison" };
+    texture?: { sampleType?: "float" | "unfilterable-float" | "depth" | "sint" | "uint"; viewDimension?: string; multisampled?: boolean };
+}
+
+export interface GpuBindGroupEntry {
+    binding: number;
+    resource: GpuSampler | GpuTextureView | { buffer: GpuBuffer; offset?: number; size?: number };
+}
+
+export interface GpuVertexBufferLayout {
+    arrayStride: number;
+    stepMode?: GpuVertexStepMode;
+    attributes: { format: GpuVertexFormat; offset: number; shaderLocation: number }[];
+}
+
+export interface GpuBlendComponent {
+    operation?: GpuBlendOperation;
+    srcFactor?: GpuBlendFactor;
+    dstFactor?: GpuBlendFactor;
+}
+
+export interface GpuColorTargetState {
+    format: GpuTextureFormat;
+    blend?: { color: GpuBlendComponent; alpha: GpuBlendComponent };
+    writeMask?: number;
+}
+
+export interface GpuDepthStencilState {
+    format: GpuTextureFormat;
+    depthWriteEnabled?: boolean;
+    depthCompare?: GpuCompareFunction;
+}
+
+export interface GpuRenderPipelineDescriptor {
+    label?: string;
+    layout: GpuPipelineLayout | "auto";
+    vertex: { module: GpuShaderModule; entryPoint?: string; buffers?: GpuVertexBufferLayout[] };
+    fragment?: { module: GpuShaderModule; entryPoint?: string; targets: GpuColorTargetState[] };
+    primitive?: { topology?: GpuPrimitiveTopology; cullMode?: GpuCullMode; frontFace?: GpuFrontFace; stripIndexFormat?: GpuIndexFormat };
+    depthStencil?: GpuDepthStencilState;
+    multisample?: { count?: number };
+}
+
+export interface GpuRenderPassColorAttachment {
+    view: GpuTextureView;
+    resolveTarget?: GpuTextureView;
+    clearValue?: { r: number; g: number; b: number; a: number };
+    loadOp: GpuLoadOp;
+    storeOp: GpuStoreOp;
+}
+
+export interface GpuRenderPassDepthStencilAttachment {
+    view: GpuTextureView;
+    depthClearValue?: number;
+    depthLoadOp?: GpuLoadOp;
+    depthStoreOp?: GpuStoreOp;
+    stencilClearValue?: number;
+    stencilLoadOp?: GpuLoadOp;
+    stencilStoreOp?: GpuStoreOp;
+}
+
+export interface GpuRenderPassDescriptor {
+    label?: string;
+    colorAttachments: GpuRenderPassColorAttachment[];
+    depthStencilAttachment?: GpuRenderPassDepthStencilAttachment;
+}
+
+export interface GpuCommandEncoder extends GpuObjectBase {
+    beginRenderPass(descriptor: GpuRenderPassDescriptor): GpuRenderPassEncoder;
+    finish(descriptor?: { label?: string }): GpuCommandBuffer;
+}
+
+export interface GpuRenderPassEncoder extends GpuObjectBase {
+    setPipeline(pipeline: GpuRenderPipeline): void;
+    setVertexBuffer(slot: number, buffer: GpuBuffer, offset?: number, size?: number): void;
+    setIndexBuffer(buffer: GpuBuffer, format: GpuIndexFormat, offset?: number, size?: number): void;
+    setBindGroup(index: number, bindGroup: GpuBindGroup): void;
+    drawIndexed(indexCount: number, instanceCount?: number, firstIndex?: number, baseVertex?: number, firstInstance?: number): void;
+    draw(vertexCount: number, instanceCount?: number, firstVertex?: number, firstInstance?: number): void;
+    pushDebugGroup(label: string): void;
+    popDebugGroup(): void;
+    end(): void;
+}
+
+export interface GpuCanvasContext {
+    configure(configuration: { device: GpuDevice; format: GpuTextureFormat; usage?: number; alphaMode?: "opaque" | "premultiplied" }): void;
+    unconfigure(): void;
+    getCurrentTexture(): GpuTexture;
+}
+
+/**
+ * Returns `navigator.gpu`, or undefined when the browser has no WebGPU.
+ */
+export function getNavigatorGpu(): Gpu | undefined {
+    if (typeof navigator === "undefined") {
+        return undefined;
+    }
+    return (navigator as unknown as { gpu?: Gpu }).gpu ?? undefined;
+}

package/src/webgpu/blending/WebGpuBlendState.ts

@@ -0,0 +1,53 @@
+import type {BlendStateDescriptor} from "../../core/rendering/blending/blend-state-descriptor.ts";
+import type {IBlendState} from "../../api/index.ts";
+import type {GpuBlendComponent} from "../WebGpuTypes.ts";
+import {WebGpuConverter} from "../utilities/WebGpuConverter.ts";
+
+/**
+ * The WebGPU blend state. WebGPU bakes blending into the render pipeline, so this only holds the converted values.
+ * @internal
+ */
+export class WebGpuBlendState implements IBlendState {
+
+    /**
+     * The constructor.
+     * @param descriptor The blend state descriptor.
+     */
+    public constructor(descriptor: BlendStateDescriptor) {
+        this.blendingEnabled = descriptor.blendingEnabled;
+        this.color = {
+            srcFactor: WebGpuConverter.convertBlendFactor(descriptor.color.srcFactor),
+            dstFactor: WebGpuConverter.convertBlendFactor(descriptor.color.dstFactor),
+            operation: WebGpuConverter.convertBlendOperation(descriptor.color.operation),
+        };
+        this.alpha = {
+            srcFactor: WebGpuConverter.convertBlendFactor(descriptor.alpha.srcFactor),
+            dstFactor: WebGpuConverter.convertBlendFactor(descriptor.alpha.dstFactor),
+            operation: WebGpuConverter.convertBlendOperation(descriptor.alpha.operation),
+        };
+    }
+
+    /** Whether blending is enabled. */
+    public readonly blendingEnabled: boolean;
+
+    /** The color blend component. */
+    public readonly color: GpuBlendComponent;
+
+    /** The alpha blend component. */
+    public readonly alpha: GpuBlendComponent;
+
+    /** The `GPUBlendState` for a color target, or undefined when blending is disabled. */
+    public get gpuBlendState(): { color: GpuBlendComponent; alpha: GpuBlendComponent } | undefined {
+        return this.blendingEnabled ? {color: this.color, alpha: this.alpha} : undefined;
+    }
+
+    /** @inheritDoc */
+    public get nativePtr(): any {
+        return this.gpuBlendState;
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        // Nothing to release.
+    }
+}

package/src/webgpu/buffers/WebGpuBuffersFactory.ts

@@ -0,0 +1,46 @@
+import {
+    BufferUsage,
+    type IBufferFactory,
+    type IFramework,
+    type IIndexBuffer,
+    type IUniformBuffer,
+    type IVertexBuffer,
+} from "../../api/index.ts";
+import {WebGpuVertexBuffer} from "./WebGpuVertexBuffer.ts";
+import {WebGpuIndexBuffer} from "./WebGpuIndexBuffer.ts";
+import {WebGpuUniformBuffer} from "./WebGpuUniformBuffer.ts";
+
+/**
+ * The WebGPU buffers factory.
+ * @internal
+ */
+export class WebGpuBuffersFactory implements IBufferFactory {
+
+    /**
+     * The constructor.
+     * @param _framework The framework.
+     */
+    public constructor(private readonly _framework: IFramework) {
+    }
+
+    /** @inheritDoc */
+    public createVertexBuffer(data: ArrayLike<number>, vertexStride: number, usage: BufferUsage = BufferUsage.VERTEX | BufferUsage.COPY_DST, label?: string): IVertexBuffer {
+        const buffer = new WebGpuVertexBuffer(this._framework, data, vertexStride, usage, label);
+        buffer.initialize();
+        return buffer;
+    }
+
+    /** @inheritDoc */
+    public createUniformBuffer(data: ArrayLike<number>, usage: BufferUsage = BufferUsage.UNIFORM | BufferUsage.COPY_DST, label?: string): IUniformBuffer {
+        const buffer = new WebGpuUniformBuffer(this._framework, data, usage, label);
+        buffer.initialize();
+        return buffer;
+    }
+
+    /** @inheritDoc */
+    public createIndexBuffer(data: ArrayLike<number>, label?: string): IIndexBuffer {
+        const buffer = new WebGpuIndexBuffer(this._framework, label);
+        buffer.initialize(data);
+        return buffer;
+    }
+}

package/src/webgpu/buffers/WebGpuIndexBuffer.ts

@@ -0,0 +1,118 @@
+import {BufferUsage, type IFramework, type IIndexBuffer, IndexBufferType} from "../../api/index.ts";
+import type {WebGpuGraphicsDevice} from "../WebGpuGraphicsDevice.ts";
+import {GpuBufferUsage, type GpuBuffer, type GpuIndexFormat} from "../WebGpuTypes.ts";
+
+/**
+ * The WebGPU index buffer. Uses uint16 when every index fits, otherwise uint32.
+ * The allocation and the write are padded to 4 bytes, because WebGPU requires it (odd uint16 counts).
+ * @internal
+ */
+export class WebGpuIndexBuffer implements IIndexBuffer {
+
+    private readonly _graphicsDevice: WebGpuGraphicsDevice;
+    private readonly _label?: string;
+    private _type = IndexBufferType.UINT_16;
+    private _elementByteSize = 0;
+    private _indicesCount = 0;
+    private _byteSize = 0;
+    private _gpuBuffer: GpuBuffer | null = null;
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @param label The label.
+     */
+    public constructor(framework: IFramework, label?: string) {
+        this._graphicsDevice = framework.renderer.graphicsDevice as WebGpuGraphicsDevice;
+        this._label = label;
+    }
+
+    /** @inheritDoc */
+    public readonly usage: BufferUsage = BufferUsage.INDEX;
+
+    /** The WebGPU buffer. */
+    public get gpuBuffer(): GpuBuffer {
+        if (!this._gpuBuffer) {
+            throw new Error("WebGpuIndexBuffer: the buffer is not initialized or is disposed.");
+        }
+        return this._gpuBuffer;
+    }
+
+    /** The WebGPU index format. */
+    public get gpuIndexFormat(): GpuIndexFormat {
+        return this._type === IndexBufferType.UINT_16 ? "uint16" : "uint32";
+    }
+
+    /** The buffer size padded to 4 bytes, as used for `setIndexBuffer`. */
+    public get paddedByteSize(): number {
+        return (this._byteSize + 3) & ~3;
+    }
+
+    /** @inheritDoc */
+    public get type(): IndexBufferType {
+        return this._type;
+    }
+
+    /** @inheritDoc */
+    public get elementByteSize(): number {
+        return this._elementByteSize;
+    }
+
+    /** @inheritDoc */
+    public get label(): string {
+        return this._label ?? "";
+    }
+
+    /** @inheritDoc */
+    public get indicesCount(): number {
+        return this._indicesCount;
+    }
+
+    /** @inheritDoc */
+    public get byteSize(): number {
+        return this._byteSize;
+    }
+
+    private static _canUseUint16(values: ArrayLike<number>): boolean {
+        for (let i = 0; i < values.length; i++) {
+            const v = values[i];
+            if (v < 0 || v > 0xFFFF) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /** @inheritDoc */
+    public initialize(data: ArrayLike<number>): void {
+        this._gpuBuffer?.destroy();
+        const use16 = WebGpuIndexBuffer._canUseUint16(data);
+        this._type = use16 ? IndexBufferType.UINT_16 : IndexBufferType.UINT_32;
+        this._elementByteSize = use16 ? 2 : 4;
+        this._indicesCount = data.length;
+        this._byteSize = this._indicesCount * this._elementByteSize;
+
+        const padded = Math.max(4, this.paddedByteSize);
+        // Allocate the padded size so the write below can include the padding.
+        const bytes = new ArrayBuffer(padded);
+        if (use16) {
+            new Uint16Array(bytes, 0, data.length).set(data);
+        } else {
+            new Uint32Array(bytes, 0, data.length).set(data);
+        }
+
+        const device = this._graphicsDevice.device;
+        this._gpuBuffer = device.createBuffer({
+            label: this._label,
+            size: padded,
+            usage: GpuBufferUsage.INDEX | GpuBufferUsage.COPY_DST,
+        });
+        device.queue.writeBuffer(this._gpuBuffer, 0, bytes, 0, padded);
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        this._gpuBuffer?.destroy();
+        this._gpuBuffer = null;
+    }
+}

package/src/webgpu/buffers/WebGpuUniformBuffer.ts

@@ -0,0 +1,102 @@
+import {type BufferUsage, type IFramework, type IUniformBuffer} from "../../api/index.ts";
+import type {WebGpuGraphicsDevice} from "../WebGpuGraphicsDevice.ts";
+import {GpuBufferUsage, type GpuBuffer} from "../WebGpuTypes.ts";
+import {WebGpuConverter} from "../utilities/WebGpuConverter.ts";
+
+/**
+ * The WebGPU uniform buffer. The size is aligned to 16 bytes and the buffer always has UNIFORM | COPY_DST.
+ * @internal
+ */
+export class WebGpuUniformBuffer implements IUniformBuffer {
+
+    private static _nextId = 1;
+
+    private readonly _graphicsDevice: WebGpuGraphicsDevice;
+    private readonly _data: Float32Array;
+    private readonly _byteSize: number;
+    private _gpuBuffer: GpuBuffer | null = null;
+
+    /**
+     * The constructor.
+     * @param framework The framework.
+     * @param dataOrFloatCount The initial float data, or the number of floats.
+     * @param bufferUsage The buffer usage.
+     * @param label The label.
+     */
+    public constructor(framework: IFramework, dataOrFloatCount: ArrayLike<number> | number, bufferUsage: BufferUsage, label?: string) {
+        this._graphicsDevice = framework.renderer.graphicsDevice as WebGpuGraphicsDevice;
+        this.usage = bufferUsage;
+        this.label = label;
+        this.id = WebGpuUniformBuffer._nextId++;
+        const floatCount = typeof dataOrFloatCount === "number" ? dataOrFloatCount : dataOrFloatCount.length;
+        // Uniform buffer bindings must be a multiple of 16 bytes.
+        const alignedFloats = Math.max(4, Math.ceil(floatCount / 4) * 4);
+        this._data = new Float32Array(alignedFloats);
+        if (typeof dataOrFloatCount !== "number") {
+            this._data.set(dataOrFloatCount);
+        }
+        this._byteSize = this._data.byteLength;
+    }
+
+    /** A unique id, used to cache bind groups. */
+    public readonly id: number;
+
+    /** @inheritDoc */
+    public readonly label?: string;
+
+    /** @inheritDoc */
+    public readonly usage: BufferUsage;
+
+    /** @inheritDoc */
+    public get byteSize(): number {
+        return this._byteSize;
+    }
+
+    /** The WebGPU buffer. */
+    public get gpuBuffer(): GpuBuffer {
+        if (!this._gpuBuffer) {
+            throw new Error("WebGpuUniformBuffer: the buffer is not initialized or is disposed.");
+        }
+        return this._gpuBuffer;
+    }
+
+    /** @inheritDoc */
+    public initialize(): void {
+        const device = this._graphicsDevice.device;
+        this._gpuBuffer = device.createBuffer({
+            label: this.label,
+            size: this._byteSize,
+            usage: WebGpuConverter.convertBufferUsage(this.usage) | GpuBufferUsage.UNIFORM | GpuBufferUsage.COPY_DST,
+        });
+        device.queue.writeBuffer(this._gpuBuffer, 0, this._data.buffer, this._data.byteOffset, this._data.byteLength);
+    }
+
+    /**
+     * Updates the buffer. Only the data's length is written.
+     * @param data The float data.
+     * @param offset The first float to write.
+     * @param length The number of floats to write; defaults to the data's length after the offset.
+     */
+    public update(data: ArrayLike<number>, offset: number = 0, length?: number): void {
+        let count = length ?? data.length - offset;
+        count = Math.min(count, this._data.length - offset, data.length - offset);
+        if (count <= 0) {
+            return;
+        }
+        for (let i = 0; i < count; i++) {
+            this._data[offset + i] = data[offset + i];
+        }
+        this._graphicsDevice.device.queue.writeBuffer(
+            this.gpuBuffer,
+            offset * Float32Array.BYTES_PER_ELEMENT,
+            this._data.buffer,
+            this._data.byteOffset + offset * Float32Array.BYTES_PER_ELEMENT,
+            count * Float32Array.BYTES_PER_ELEMENT);
+    }
+
+    /** @inheritDoc */
+    public dispose(): void {
+        this._gpuBuffer?.destroy();
+        this._gpuBuffer = null;
+    }
+}