typegpu 0.10.2 → 0.11.0

package/_virtual/_rolldown/runtime.js

@@ -2,17 +2,12 @@
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
-	for (var name in all) {
-		__defProp(target, name, {
-			get: all[name],
-			enumerable: true
-		});
-	}
-	if (!no_symbols) {
-		__defProp(target, Symbol.toStringTag, { value: "Module" });
-	}
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
 	return target;
 };
-
 //#endregion
-export { __exportAll };
+export { __exportAll };

package/builtin.js

@@ -3,7 +3,6 @@ import { bool, f32, u32 } from "./data/numeric.js";
 import { vec3u, vec4f } from "./data/vector.js";
 import { attribute } from "./data/attributes.js";
 import { arrayOf } from "./data/array.js";
-
 //#region src/builtin.ts
 function defineBuiltin(dataType, value) {
 	return attribute(dataType, {
@@ -32,6 +31,5 @@ const builtin = {
 	subgroupId: defineBuiltin(u32, "subgroup_id"),
 	numSubgroups: defineBuiltin(u32, "num_subgroups")
 };
-
 //#endregion
-export { builtin };
+export { builtin };

package/common/fullScreenTriangle.d.ts

@@ -1,7 +1,5 @@
 import { TgpuVertexFn } from "../core/function/tgpuVertexFn.js";
 import { Vec2f } from "../data/wgslTypes.js";
-import "../indexNamedExports.js";
-
 //#region src/common/fullScreenTriangle.d.ts
 /**
  * A vertex function that defines a single full-screen triangle out
@@ -19,8 +17,6 @@ import "../indexNamedExports.js";
  * pipeline.draw(3);
  * ```
  */
-declare const fullScreenTriangle: TgpuVertexFn<{}, {
-  uv: Vec2f;
-}>;
+declare const fullScreenTriangle: TgpuVertexFn;
 //#endregion
 export { fullScreenTriangle };

package/common/fullScreenTriangle.js

@@ -1,7 +1,6 @@
 import { vec2f } from "../data/vector.js";
 import { builtin } from "../builtin.js";
 import { vertexFn } from "../core/function/tgpuVertexFn.js";
-
 //#region src/common/fullScreenTriangle.ts
 /**
 * A vertex function that defines a single full-screen triangle out
@@ -31,6 +30,5 @@ const fullScreenTriangle = vertexFn({
 
   return Out(vec4f(pos[in.vertexIndex], 0, 1), uv[in.vertexIndex]);
 }`;
-
 //#endregion
-export { fullScreenTriangle };
+export { fullScreenTriangle };

package/common/index.d.ts

@@ -1,8 +1,9 @@
 import { fullScreenTriangle } from "./fullScreenTriangle.js";
+import { writeSoA } from "./writeSoA.js";
 
 //#region src/common/index.d.ts
 declare namespace index_d_exports {
-  export { fullScreenTriangle };
+  export { fullScreenTriangle, writeSoA };
 }
 //#endregion
-export { fullScreenTriangle, index_d_exports };
+export { fullScreenTriangle, index_d_exports, writeSoA };

package/common/index.js

@@ -1,8 +1,10 @@
 import { __exportAll } from "../_virtual/_rolldown/runtime.js";
 import { fullScreenTriangle } from "./fullScreenTriangle.js";
-
+import { writeSoA } from "./writeSoA.js";
 //#region src/common/index.ts
-var common_exports = /* @__PURE__ */ __exportAll({ fullScreenTriangle: () => fullScreenTriangle });
-
+var common_exports = /* @__PURE__ */ __exportAll({
+	fullScreenTriangle: () => fullScreenTriangle,
+	writeSoA: () => writeSoA
+});
 //#endregion
-export { common_exports, fullScreenTriangle };
+export { common_exports, fullScreenTriangle, writeSoA };

package/common/writeSoA.d.ts

@@ -0,0 +1,16 @@
+import { Prettify } from "../shared/utilityTypes.js";
+import { BufferWriteOptions, TgpuBuffer } from "../core/buffer/buffer.js";
+import { BaseData, TypedArrayFor, WgslArray, WgslStruct } from "../data/wgslTypes.js";
+import { Undecorate } from "../data/dataTypes.js";
+
+//#region src/common/writeSoA.d.ts
+type PackedScalarFor<T> = Undecorate<T> extends WgslArray<infer TElement> ? PackedScalarFor<TElement> : Undecorate<T>;
+type PackedSoAInputFor<T> = TypedArrayFor<PackedScalarFor<T>>;
+type SoAFieldsFor<T extends Record<string, BaseData>> = { [K in keyof T as [PackedSoAInputFor<T[K]>] extends [never] ? never : K]: PackedSoAInputFor<T[K]> };
+type SoAInputFor<T extends Record<string, BaseData>> = [keyof T] extends [keyof SoAFieldsFor<T>] ? Prettify<SoAFieldsFor<T>> : never;
+declare function writeSoA<TProps extends Record<string, BaseData>>(buffer: TgpuBuffer<WgslArray<WgslStruct<TProps>>>, data: SoAInputFor<TProps>, options?: BufferWriteOptions): void;
+declare namespace writeSoA {
+  type InputFor<TProps extends Record<string, BaseData>> = SoAInputFor<TProps>;
+}
+//#endregion
+export { writeSoA };

package/common/writeSoA.js

@@ -0,0 +1,90 @@
+import { isAtomic, isMat, isMat2x2f, isMat3x3f, isWgslArray } from "../data/wgslTypes.js";
+import { undecorate } from "../data/dataTypes.js";
+import { invariant } from "../errors.js";
+import { alignmentOf } from "../data/alignmentOf.js";
+import { roundUp } from "../mathUtils.js";
+import { sizeOf } from "../data/sizeOf.js";
+import { offsetsForProps } from "../data/offsets.js";
+//#region src/common/writeSoA.ts
+function packedSchemaOf(schema) {
+	const unpackedSchema = undecorate(schema);
+	return isAtomic(unpackedSchema) ? unpackedSchema.inner : unpackedSchema;
+}
+function packedMatrixDimOf(schema) {
+	return isMat3x3f(schema) ? 3 : isMat2x2f(schema) ? 2 : isMat(schema) ? 4 : void 0;
+}
+function packedSizeOf(schema) {
+	const packedSchema = packedSchemaOf(schema);
+	const matrixDim = packedMatrixDimOf(packedSchema);
+	if (matrixDim) return matrixDim * matrixDim * 4;
+	if (isWgslArray(packedSchema)) return packedSchema.elementCount * packedSizeOf(packedSchema.elementType);
+	return sizeOf(packedSchema);
+}
+function computeSoAByteLength(arraySchema, soaData) {
+	const structSchema = arraySchema.elementType;
+	let inferredCount;
+	for (const key in structSchema.propTypes) {
+		const srcArray = soaData[key];
+		const fieldSchema = structSchema.propTypes[key];
+		if (srcArray === void 0 || fieldSchema === void 0) continue;
+		const packedFieldSize = packedSizeOf(fieldSchema);
+		if (packedFieldSize === 0) continue;
+		const fieldElementCount = Math.floor(srcArray.byteLength / packedFieldSize);
+		inferredCount = inferredCount === void 0 ? fieldElementCount : Math.min(inferredCount, fieldElementCount);
+	}
+	if (inferredCount === void 0) return;
+	const elementStride = roundUp(sizeOf(structSchema), alignmentOf(structSchema));
+	return inferredCount * elementStride;
+}
+function writePackedValue(target, schema, srcBytes, dstOffset, srcOffset) {
+	const unpackedSchema = undecorate(schema);
+	const packedSchema = isAtomic(unpackedSchema) ? unpackedSchema.inner : unpackedSchema;
+	const matrixDim = packedMatrixDimOf(packedSchema);
+	if (matrixDim) {
+		const packedColumnSize = matrixDim * 4;
+		const gpuColumnStride = roundUp(packedColumnSize, alignmentOf(schema));
+		for (let col = 0; col < matrixDim; col++) target.set(srcBytes.subarray(srcOffset + col * packedColumnSize, srcOffset + col * packedColumnSize + packedColumnSize), dstOffset + col * gpuColumnStride);
+		return;
+	}
+	if (isWgslArray(unpackedSchema)) {
+		const packedElementSize = packedSizeOf(unpackedSchema.elementType);
+		const gpuElementStride = roundUp(sizeOf(unpackedSchema.elementType), alignmentOf(unpackedSchema.elementType));
+		for (let i = 0; i < unpackedSchema.elementCount; i++) writePackedValue(target, unpackedSchema.elementType, srcBytes, dstOffset + i * gpuElementStride, srcOffset + i * packedElementSize);
+		return;
+	}
+	target.set(srcBytes.subarray(srcOffset, srcOffset + sizeOf(packedSchema)), dstOffset);
+}
+function scatterSoA(target, arraySchema, soaData, startOffset, endOffset) {
+	const structSchema = arraySchema.elementType;
+	const elementStride = roundUp(sizeOf(structSchema), alignmentOf(structSchema));
+	invariant(startOffset % elementStride === 0, `startOffset (${startOffset}) must be aligned to the element stride (${elementStride})`);
+	const startElement = Math.floor(startOffset / elementStride);
+	const endElement = Math.min(arraySchema.elementCount, Math.ceil(endOffset / elementStride));
+	const elementCount = Math.max(0, endElement - startElement);
+	const offsets = offsetsForProps(structSchema);
+	for (const key in structSchema.propTypes) {
+		const fieldSchema = structSchema.propTypes[key];
+		if (fieldSchema === void 0) continue;
+		const srcArray = soaData[key];
+		invariant(srcArray !== void 0, `Missing SoA data for field '${key}'`);
+		const fieldOffset = offsets[key]?.offset;
+		invariant(fieldOffset !== void 0, `Field ${key} not found in struct schema`);
+		const packedFieldSize = packedSizeOf(fieldSchema);
+		const srcBytes = new Uint8Array(srcArray.buffer, srcArray.byteOffset, srcArray.byteLength);
+		for (let i = 0; i < elementCount; i++) writePackedValue(target, fieldSchema, srcBytes, (startElement + i) * elementStride + fieldOffset, i * packedFieldSize);
+	}
+}
+function writeSoA(buffer, data, options) {
+	const arrayBuffer = buffer.arrayBuffer;
+	const startOffset = options?.startOffset ?? 0;
+	const bufferSize = sizeOf(buffer.dataType);
+	const naturalSize = computeSoAByteLength(buffer.dataType, data);
+	const endOffset = options?.endOffset ?? (naturalSize === void 0 ? bufferSize : Math.min(startOffset + naturalSize, bufferSize));
+	scatterSoA(new Uint8Array(arrayBuffer), buffer.dataType, data, startOffset, endOffset);
+	buffer.write(arrayBuffer, {
+		startOffset,
+		endOffset
+	});
+}
+//#endregion
+export { writeSoA };

package/core/buffer/buffer.d.ts

@@ -3,11 +3,8 @@ import { $internal } from "../../shared/symbols.js";
 import { Prettify, UnionToIntersection } from "../../shared/utilityTypes.js";
 import { StorageFlag } from "../../extension.js";
 import { TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform, TgpuFixedBufferUsage } from "./bufferUsage.js";
-import "../root/rootTypes.js";
 import { BaseData } from "../../data/wgslTypes.js";
-import { Infer, InferPartial, IsValidIndexSchema, IsValidStorageSchema, IsValidUniformSchema, IsValidVertexSchema, MemIdentity } from "../../shared/repr.js";
-import "../../data/dataTypes.js";
-
+import { Infer, InferInput, InferPartial, InferPatch, IsValidIndexSchema, IsValidStorageSchema, IsValidUniformSchema, IsValidVertexSchema, MemIdentity } from "../../shared/repr.js";
 //#region src/core/buffer/buffer.d.ts
 interface UniformFlag {
   usableAsUniform: true;
@@ -44,11 +41,16 @@ type InnerValidUsagesFor<T> = {
   usage: (IsValidStorageSchema<T> extends true ? 'storage' : never) | (IsValidUniformSchema<T> extends true ? 'uniform' : never) | (IsValidVertexSchema<T> extends true ? 'vertex' : never) | (IsValidIndexSchema<T> extends true ? 'index' : never) | 'indirect';
 };
 type ValidUsagesFor<T> = InnerValidUsagesFor<T>['usage'];
+type BufferWriteOptions = {
+  startOffset?: number;
+  endOffset?: number;
+};
 interface TgpuBuffer<TData extends BaseData> extends TgpuNamable {
   readonly [$internal]: true;
   readonly resourceType: 'buffer';
   readonly dataType: TData;
-  readonly initial?: Infer<TData> | undefined;
+  readonly initial?: InferInput<TData> | undefined;
+  readonly arrayBuffer: ArrayBuffer;
   readonly buffer: GPUBuffer;
   readonly destroyed: boolean;
   usableAsUniform: boolean;
@@ -60,8 +62,11 @@ interface TgpuBuffer<TData extends BaseData> extends TgpuNamable {
   $addFlags(flags: GPUBufferUsageFlags): this;
   as<T extends ViewUsages<this>>(usage: T): UsageTypeToBufferUsage<TData>[T];
   compileWriter(): void;
-  write(data: Infer<TData>): void;
+  write(data: InferInput<TData>, options?: BufferWriteOptions): void;
+  write(data: ArrayBuffer, options?: BufferWriteOptions): void;
+  /** @deprecated Use {@link patch} instead. */
   writePartial(data: InferPartial<TData>): void;
+  patch(data: InferPatch<TData>): void;
   clear(): void;
   copyFrom(srcBuffer: TgpuBuffer<MemIdentity<TData>>): void;
   read(): Promise<Infer<TData>>;
@@ -71,4 +76,4 @@ interface TgpuBuffer<TData extends BaseData> extends TgpuNamable {
 declare function isBuffer(value: unknown): value is TgpuBuffer<BaseData>;
 declare function isUsableAsVertex<T extends TgpuBuffer<BaseData>>(buffer: T): buffer is T & VertexFlag;
 //#endregion
-export { IndexFlag, IndirectFlag, TgpuBuffer, Uniform, UniformFlag, ValidUsagesFor, Vertex, VertexFlag, isBuffer, isUsableAsVertex };
+export { BufferWriteOptions, IndexFlag, IndirectFlag, TgpuBuffer, Uniform, UniformFlag, ValidUsagesFor, Vertex, VertexFlag, isBuffer, isUsableAsVertex };

package/core/buffer/buffer.js

@@ -1,14 +1,15 @@
 import { $internal } from "../../shared/symbols.js";
 import { getName, setName } from "../../shared/meta.js";
-import { isWgslData } from "../../data/wgslTypes.js";
+import { isWgslArray, isWgslData } from "../../data/wgslTypes.js";
 import { isGPUBuffer } from "../../types.js";
+import { alignmentOf } from "../../data/alignmentOf.js";
+import { roundUp } from "../../mathUtils.js";
 import { sizeOf } from "../../data/sizeOf.js";
-import { getCompiledWriterForSchema } from "../../data/compiledIO.js";
+import { getCompiledWriter } from "../../data/compiledIO.js";
 import { readData, writeData } from "../../data/dataIO.js";
-import { getWriteInstructions } from "../../data/partialIO.js";
+import { convertPartialToPatch, getPatchInstructions } from "../../data/partialIO.js";
 import { mutable, readonly, uniform } from "./bufferUsage.js";
 import { BufferReader, BufferWriter, getSystemEndianness } from "typed-binary";
-
 //#region src/core/buffer/buffer.ts
 const usageToUsageConstructor = {
 	uniform,
@@ -30,57 +31,79 @@ var TgpuBufferImpl = class {
 	[$internal] = true;
 	resourceType = "buffer";
 	flags = GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC;
+	dataType;
 	#device;
-	_buffer = null;
-	_ownBuffer;
-	_destroyed = false;
-	_hostBuffer;
+	#buffer = null;
+	#ownBuffer;
+	#destroyed = false;
+	#internalBuffer;
+	get #hostBuffer() {
+		return this.#internalBuffer ??= new ArrayBuffer(sizeOf(this.dataType));
+	}
+	#mappedRange;
+	#initialCallback;
+	#disallowedUsages;
 	initial;
 	usableAsUniform = false;
 	usableAsStorage = false;
 	usableAsVertex = false;
 	usableAsIndex = false;
 	usableAsIndirect = false;
-	constructor(root, dataType, initialOrBuffer, _disallowedUsages) {
+	constructor(root, dataType, initialOrBuffer, disallowedUsages) {
 		this.dataType = dataType;
-		this.initialOrBuffer = initialOrBuffer;
-		this._disallowedUsages = _disallowedUsages;
+		this.#disallowedUsages = disallowedUsages;
 		this.#device = root.device;
 		if (isGPUBuffer(initialOrBuffer)) {
-			this._ownBuffer = false;
-			this._buffer = initialOrBuffer;
+			this.#ownBuffer = false;
+			this.#buffer = initialOrBuffer;
 		} else {
-			this._ownBuffer = true;
-			this.initial = initialOrBuffer;
+			this.#ownBuffer = true;
+			if (typeof initialOrBuffer === "function") this.#initialCallback = initialOrBuffer;
+			else this.initial = initialOrBuffer;
 		}
 	}
 	get buffer() {
-		if (this._destroyed) throw new Error("This buffer has been destroyed");
-		if (!this._buffer) {
-			this._buffer = this.#device.createBuffer({
+		if (this.#destroyed) throw new Error("This buffer has been destroyed");
+		if (!this.#buffer) {
+			this.#buffer = this.#device.createBuffer({
 				size: sizeOf(this.dataType),
 				usage: this.flags,
-				mappedAtCreation: !!this.initial,
+				mappedAtCreation: !!this.initial || !!this.#initialCallback,
 				label: getName(this) ?? "<unnamed>"
 			});
-			if (this.initial) {
-				this._writeToTarget(this._buffer.getMappedRange(), this.initial);
-				this._buffer.unmap();
+			if (this.initial || this.#initialCallback) {
+				if (this.#initialCallback) this.#initialCallback(this);
+				else if (this.initial) this.#writeToTarget(this.#getMappedRange(), this.initial);
+				this.#unmapBuffer();
 			}
 		}
-		return this._buffer;
+		return this.#buffer;
 	}
 	get destroyed() {
-		return this._destroyed;
+		return this.#destroyed;
+	}
+	get arrayBuffer() {
+		if (this.buffer.mapState === "mapped") return this.#getMappedRange();
+		return this.#hostBuffer;
+	}
+	#getMappedRange() {
+		if (!this.#buffer || this.#buffer.mapState !== "mapped") throw new Error("Buffer is not mapped.");
+		this.#mappedRange ??= this.#buffer.getMappedRange();
+		return this.#mappedRange;
+	}
+	#unmapBuffer() {
+		if (!this.#buffer || this.#buffer.mapState !== "mapped") return;
+		this.#mappedRange = void 0;
+		this.#buffer.unmap();
 	}
 	$name(label) {
 		setName(this, label);
-		if (this._buffer) this._buffer.label = label;
+		if (this.#buffer) this.#buffer.label = label;
 		return this;
 	}
 	$usage(...usages) {
 		for (const usage of usages) {
-			if (this._disallowedUsages?.includes(usage)) throw new Error(`Buffer of type ${this.dataType.type} cannot be used as ${usage}`);
+			if (this.#disallowedUsages?.includes(usage)) throw new Error(`Buffer of type ${this.dataType.type} cannot be used as ${usage}`);
 			this.flags |= usage === "uniform" ? GPUBufferUsage.UNIFORM : 0;
 			this.flags |= usage === "storage" ? GPUBufferUsage.STORAGE : 0;
 			this.flags |= usage === "vertex" ? GPUBufferUsage.VERTEX : 0;
@@ -95,7 +118,7 @@ var TgpuBufferImpl = class {
 		return this;
 	}
 	$addFlags(flags) {
-		if (!this._ownBuffer) throw new Error("Cannot add flags to a buffer that is not managed by TypeGPU.");
+		if (!this.#ownBuffer) throw new Error("Cannot add flags to a buffer that is not managed by TypeGPU.");
 		if (flags & GPUBufferUsage.MAP_READ) {
 			this.flags = GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ;
 			return this;
@@ -108,43 +131,69 @@ var TgpuBufferImpl = class {
 		return this;
 	}
 	compileWriter() {
-		getCompiledWriterForSchema(this.dataType);
-	}
-	_writeToTarget(target, data) {
-		const compiledWriter = getCompiledWriterForSchema(this.dataType);
+		getCompiledWriter(this.dataType);
+	}
+	#writeToTarget(target, data, options) {
+		const startOffset = options?.startOffset ?? 0;
+		const endOffset = options?.endOffset ?? target.byteLength;
+		if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+			const src = data instanceof ArrayBuffer ? new Uint8Array(data) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+			const regionSize = endOffset - startOffset;
+			if (src.byteLength !== regionSize) console.warn(`Buffer size mismatch: expected ${regionSize} bytes, got ${src.byteLength}. ` + (src.byteLength < regionSize ? "Data truncated." : "Excess ignored."));
+			const copyLen = Math.min(src.byteLength, regionSize);
+			new Uint8Array(target).set(src.subarray(0, copyLen), startOffset);
+			return;
+		}
+		const dataView = new DataView(target);
+		const isLittleEndian = endianness === "little";
+		const compiledWriter = getCompiledWriter(this.dataType);
 		if (compiledWriter) try {
-			compiledWriter(new DataView(target), 0, data, endianness === "little");
+			compiledWriter(dataView, startOffset, data, isLittleEndian, endOffset);
 			return;
 		} catch (error) {
 			console.error(`Error when using compiled writer for buffer ${getName(this) ?? "<unnamed>"} - this is likely a bug, please submit an issue at https://github.com/software-mansion/TypeGPU/issues\nUsing fallback writer instead.`, error);
 		}
-		writeData(new BufferWriter(target), this.dataType, data);
+		const writer = new BufferWriter(target);
+		writer.seekTo(startOffset);
+		writeData(writer, this.dataType, data);
 	}
-	write(data) {
+	write(data, options) {
 		const gpuBuffer = this.buffer;
+		const bufferSize = sizeOf(this.dataType);
+		const startOffset = options?.startOffset ?? 0;
+		let naturalSize = void 0;
+		if (isWgslArray(this.dataType) && Array.isArray(data)) naturalSize = data.length * roundUp(sizeOf(this.dataType.elementType), alignmentOf(this.dataType.elementType));
+		else if (ArrayBuffer.isView(data) || data instanceof ArrayBuffer) naturalSize = data.byteLength;
+		const naturalEndOffset = naturalSize !== void 0 ? Math.min(startOffset + naturalSize, bufferSize) : void 0;
+		const size = (options?.endOffset ?? naturalEndOffset ?? bufferSize) - startOffset;
 		if (gpuBuffer.mapState === "mapped") {
-			const mapped = gpuBuffer.getMappedRange();
-			this._writeToTarget(mapped, data);
+			const mapped = this.#getMappedRange();
+			if (data instanceof ArrayBuffer && data === mapped) return;
+			this.#writeToTarget(mapped, data, options);
 			return;
 		}
-		const size = sizeOf(this.dataType);
-		if (!this._hostBuffer) this._hostBuffer = new ArrayBuffer(size);
-		this._writeToTarget(this._hostBuffer, data);
-		this.#device.queue.writeBuffer(gpuBuffer, 0, this._hostBuffer, 0, size);
+		if (!(data instanceof ArrayBuffer && data === this.#hostBuffer)) this.#writeToTarget(this.#hostBuffer, data, options);
+		this.#device.queue.writeBuffer(gpuBuffer, startOffset, this.#hostBuffer, startOffset, size);
 	}
+	/** @deprecated Use {@link patch} instead. */
 	writePartial(data) {
+		this.#applyInstructions(getPatchInstructions(this.dataType, convertPartialToPatch(this.dataType, data), this.#hostBuffer));
+	}
+	patch(data) {
+		this.#applyInstructions(getPatchInstructions(this.dataType, data, this.#hostBuffer));
+	}
+	#applyInstructions(instructions) {
 		const gpuBuffer = this.buffer;
-		const instructions = getWriteInstructions(this.dataType, data);
 		if (gpuBuffer.mapState === "mapped") {
-			const mappedRange = gpuBuffer.getMappedRange();
+			const mappedRange = this.#getMappedRange();
 			const mappedView = new Uint8Array(mappedRange);
-			for (const instruction of instructions) mappedView.set(instruction.data, instruction.data.byteOffset);
-		} else for (const instruction of instructions) this.#device.queue.writeBuffer(gpuBuffer, instruction.data.byteOffset, instruction.data, 0, instruction.data.byteLength);
+			for (const { data, gpuOffset } of instructions) mappedView.set(data, gpuOffset);
+		} else for (const { data, gpuOffset } of instructions) this.#device.queue.writeBuffer(gpuBuffer, gpuOffset, data);
 	}
 	clear() {
 		const gpuBuffer = this.buffer;
 		if (gpuBuffer.mapState === "mapped") {
-			new Uint8Array(gpuBuffer.getMappedRange()).fill(0);
+			new Uint8Array(this.#getMappedRange()).fill(0);
 			return;
 		}
 		const encoder = this.#device.createCommandEncoder();
@@ -160,11 +209,11 @@ var TgpuBufferImpl = class {
 	}
 	async read() {
 		const gpuBuffer = this.buffer;
-		if (gpuBuffer.mapState === "mapped") return readData(new BufferReader(gpuBuffer.getMappedRange()), this.dataType);
+		if (gpuBuffer.mapState === "mapped") return readData(new BufferReader(this.#getMappedRange()), this.dataType);
 		if (gpuBuffer.usage & GPUBufferUsage.MAP_READ) {
 			await gpuBuffer.mapAsync(GPUMapMode.READ);
-			const res = readData(new BufferReader(gpuBuffer.getMappedRange()), this.dataType);
-			gpuBuffer.unmap();
+			const res = readData(new BufferReader(this.#getMappedRange()), this.dataType);
+			this.#unmapBuffer();
 			return res;
 		}
 		const stagingBuffer = this.#device.createBuffer({
@@ -184,14 +233,14 @@ var TgpuBufferImpl = class {
 		return usageToUsageConstructor[usage]?.(this);
 	}
 	destroy() {
-		if (this._destroyed) return;
-		this._destroyed = true;
-		if (this._ownBuffer) this._buffer?.destroy();
+		if (this.#destroyed) return;
+		this.#destroyed = true;
+		this.#mappedRange = void 0;
+		if (this.#ownBuffer) this.#buffer?.destroy();
 	}
 	toString() {
 		return `buffer:${getName(this) ?? "<unnamed>"}`;
 	}
 };
-
 //#endregion
-export { INTERNAL_createBuffer, isBuffer, isUsableAsVertex };
+export { INTERNAL_createBuffer, isBuffer, isUsableAsVertex };

package/core/buffer/bufferShorthand.d.ts

@@ -1,17 +1,17 @@
 import { TgpuNamable } from "../../shared/meta.js";
 import { $gpuValueOf, $internal } from "../../shared/symbols.js";
 import { StorageFlag } from "../../extension.js";
-import "../../data/snippet.js";
-import { TgpuBuffer, UniformFlag } from "./buffer.js";
-import "../../types.js";
+import { BufferWriteOptions, TgpuBuffer, UniformFlag } from "./buffer.js";
 import { BaseData } from "../../data/wgslTypes.js";
-import { Infer, InferGPU, InferPartial } from "../../shared/repr.js";
+import { Infer, InferGPU, InferInput, InferPartial, InferPatch } from "../../shared/repr.js";
 
 //#region src/core/buffer/bufferShorthand.d.ts
 interface TgpuBufferShorthandBase<TData extends BaseData> extends TgpuNamable {
   readonly [$internal]: true;
-  write(data: Infer<TData>): void;
+  write(data: InferInput<TData>, options?: BufferWriteOptions): void;
+  /** @deprecated Use {@link patch} instead. */
   writePartial(data: InferPartial<TData>): void;
+  patch(data: InferPatch<TData>): void;
   read(): Promise<Infer<TData>>;
   readonly [$gpuValueOf]: InferGPU<TData>;
 }

package/core/buffer/bufferShorthand.js

@@ -1,6 +1,5 @@
 import { $getNameForward, $gpuValueOf, $internal, $resolve } from "../../shared/symbols.js";
 import { getName, setName } from "../../shared/meta.js";
-
 //#region src/core/buffer/bufferShorthand.ts
 function isBufferShorthand(value) {
 	return value instanceof TgpuBufferShorthandImpl;
@@ -8,6 +7,8 @@ function isBufferShorthand(value) {
 var TgpuBufferShorthandImpl = class {
 	[$internal] = true;
 	[$getNameForward];
+	resourceType;
+	buffer;
 	#usage;
 	constructor(resourceType, buffer) {
 		this.resourceType = resourceType;
@@ -19,12 +20,16 @@ var TgpuBufferShorthandImpl = class {
 		setName(this, label);
 		return this;
 	}
-	write(data) {
-		this.buffer.write(data);
+	write(data, options) {
+		this.buffer.write(data, options);
 	}
+	/** @deprecated Use {@link patch} instead. */
 	writePartial(data) {
 		this.buffer.writePartial(data);
 	}
+	patch(data) {
+		this.buffer.patch(data);
+	}
 	read() {
 		return this.buffer.read();
 	}
@@ -44,6 +49,5 @@ var TgpuBufferShorthandImpl = class {
 		return ctx.resolve(this.#usage);
 	}
 };
-
 //#endregion
-export { TgpuBufferShorthandImpl, isBufferShorthand };
+export { TgpuBufferShorthandImpl, isBufferShorthand };

package/core/buffer/bufferUsage.d.ts

@@ -1,7 +1,5 @@
 import { TgpuNamable } from "../../shared/meta.js";
 import { $gpuValueOf, $internal, $repr } from "../../shared/symbols.js";
-import "../../data/snippet.js";
-import "../../tgpuBindGroupLayout.js";
 import { TgpuBuffer, UniformFlag } from "./buffer.js";
 import { BindableBufferUsage } from "../../types.js";
 import { BaseData } from "../../data/wgslTypes.js";

package/core/buffer/bufferUsage.js

@@ -8,7 +8,6 @@ import { schemaCallWrapper } from "../../data/schemaCallWrapper.js";
 import { assertExhaustive } from "../../shared/utilityTypes.js";
 import { valueProxyHandler } from "../valueProxyUtils.js";
 import { isUsableAsStorage } from "../../extension.js";
-
 //#region src/core/buffer/bufferUsage.ts
 function isUsableAsUniform(buffer) {
 	return !!buffer.usableAsUniform;
@@ -20,6 +19,8 @@ const usageToVarTemplateMap = {
 };
 var TgpuFixedBufferImpl = class {
 	resourceType = "buffer-usage";
+	usage;
+	buffer;
 	[$internal];
 	[$getNameForward];
 	constructor(usage, buffer) {
@@ -90,11 +91,13 @@ var TgpuFixedBufferImpl = class {
 var TgpuLaidOutBufferImpl = class {
 	[$internal];
 	resourceType = "buffer-usage";
+	usage;
+	dataType;
 	#membership;
 	constructor(usage, dataType, membership) {
+		this[$internal] = { dataType };
 		this.usage = usage;
 		this.dataType = dataType;
-		this[$internal] = { dataType };
 		this.#membership = membership;
 		setName(this, membership.key);
 	}
@@ -158,6 +161,5 @@ function uniform(buffer) {
 	}
 	return usage;
 }
-
 //#endregion
-export { TgpuLaidOutBufferImpl, isUsableAsUniform, mutable, readonly, uniform };
+export { TgpuLaidOutBufferImpl, isUsableAsUniform, mutable, readonly, uniform };

package/core/constant/tgpuConstant.d.ts

@@ -1,6 +1,6 @@
 import { TgpuNamable } from "../../shared/meta.js";
 import { $gpuValueOf, $internal } from "../../shared/symbols.js";
-import { BaseData } from "../../data/wgslTypes.js";
+import { AnyWgslData, BaseData, WgslArray } from "../../data/wgslTypes.js";
 import { InferGPU } from "../../shared/repr.js";
 import { AnyData } from "../../data/dataTypes.js";
 
@@ -24,5 +24,6 @@ interface TgpuConst<TDataType extends BaseData = BaseData> extends TgpuNamable {
  * Creates a module constant with specified value.
  */
 declare function constant<TDataType extends AnyData>(dataType: TDataType, value: InferGPU<TDataType>): TgpuConst<TDataType>;
+declare function constant<TElement extends AnyWgslData>(dataType: (elementCount: number) => WgslArray<TElement>, value: InferGPU<WgslArray<TElement>>): TgpuConst<WgslArray<TElement>>;
 //#endregion
 export { TgpuConst, constant };