typegpu 0.10.1 → 0.11.0-rc.1

package/_virtual/_rolldown/runtime.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+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" });
+	return target;
+};
+//#endregion
+export { __exportAll };

package/builtin.d.ts

@@ -0,0 +1,50 @@
+import { BaseData, Bool, Builtin, Decorated, F32, U32, Vec3u, Vec4f, WgslArray } from "./data/wgslTypes.js";
+
+//#region src/builtin.d.ts
+type BuiltinVertexIndex = Decorated<U32, [Builtin<'vertex_index'>]>;
+type BuiltinInstanceIndex = Decorated<U32, [Builtin<'instance_index'>]>;
+type BuiltinClipDistances = Decorated<WgslArray<U32>, [Builtin<'clip_distances'>]>;
+type BuiltinPosition = Decorated<Vec4f, [Builtin<'position'>]>;
+type BuiltinFrontFacing = Decorated<Bool, [Builtin<'front_facing'>]>;
+type BuiltinFragDepth = Decorated<F32, [Builtin<'frag_depth'>]>;
+type BuiltinPrimitiveIndex = Decorated<U32, [Builtin<'primitive_index'>]>;
+type BuiltinSampleIndex = Decorated<U32, [Builtin<'sample_index'>]>;
+type BuiltinSampleMask = Decorated<U32, [Builtin<'sample_mask'>]>;
+type BuiltinLocalInvocationId = Decorated<Vec3u, [Builtin<'local_invocation_id'>]>;
+type BuiltinLocalInvocationIndex = Decorated<U32, [Builtin<'local_invocation_index'>]>;
+type BuiltinGlobalInvocationId = Decorated<Vec3u, [Builtin<'global_invocation_id'>]>;
+type BuiltinWorkgroupId = Decorated<Vec3u, [Builtin<'workgroup_id'>]>;
+type BuiltinNumWorkgroups = Decorated<Vec3u, [Builtin<'num_workgroups'>]>;
+type BuiltinSubgroupInvocationId = Decorated<U32, [Builtin<'subgroup_invocation_id'>]>;
+type BuiltinSubgroupSize = Decorated<U32, [Builtin<'subgroup_size'>]>;
+type BuiltinSubgroupId = Decorated<U32, [Builtin<'subgroup_id'>]>;
+type BuiltinNumSubgroups = Decorated<U32, [Builtin<'num_subgroups'>]>;
+declare const builtin: {
+  readonly vertexIndex: BuiltinVertexIndex;
+  readonly instanceIndex: BuiltinInstanceIndex;
+  readonly clipDistances: BuiltinClipDistances;
+  readonly position: BuiltinPosition;
+  readonly frontFacing: BuiltinFrontFacing;
+  readonly fragDepth: BuiltinFragDepth;
+  readonly primitiveIndex: BuiltinPrimitiveIndex;
+  readonly sampleIndex: BuiltinSampleIndex;
+  readonly sampleMask: BuiltinSampleMask;
+  readonly localInvocationId: BuiltinLocalInvocationId;
+  readonly localInvocationIndex: BuiltinLocalInvocationIndex;
+  readonly globalInvocationId: BuiltinGlobalInvocationId;
+  readonly workgroupId: BuiltinWorkgroupId;
+  readonly numWorkgroups: BuiltinNumWorkgroups;
+  readonly subgroupInvocationId: BuiltinSubgroupInvocationId;
+  readonly subgroupSize: BuiltinSubgroupSize;
+  readonly subgroupId: BuiltinSubgroupId;
+  readonly numSubgroups: BuiltinNumSubgroups;
+};
+type AnyBuiltin = (typeof builtin)[keyof typeof builtin];
+type AnyComputeBuiltin = BuiltinLocalInvocationId | BuiltinLocalInvocationIndex | BuiltinGlobalInvocationId | BuiltinWorkgroupId | BuiltinNumWorkgroups | BuiltinSubgroupInvocationId | BuiltinSubgroupSize | BuiltinSubgroupId | BuiltinNumSubgroups;
+type AnyVertexInputBuiltin = BuiltinVertexIndex | BuiltinInstanceIndex;
+type AnyVertexOutputBuiltin = BuiltinClipDistances | BuiltinPosition;
+type AnyFragmentInputBuiltin = BuiltinPosition | BuiltinFrontFacing | BuiltinPrimitiveIndex | BuiltinSampleIndex | BuiltinSampleMask | BuiltinSubgroupInvocationId | BuiltinSubgroupSize;
+type AnyFragmentOutputBuiltin = BuiltinFragDepth | BuiltinSampleMask;
+type OmitBuiltins<S> = S extends AnyBuiltin ? never : S extends BaseData ? S : { [Key in keyof S as S[Key] extends AnyBuiltin ? never : Key extends `$${string}` ? never : Key]: S[Key] };
+//#endregion
+export { AnyBuiltin, AnyComputeBuiltin, AnyFragmentInputBuiltin, AnyFragmentOutputBuiltin, AnyVertexInputBuiltin, AnyVertexOutputBuiltin, BuiltinClipDistances, BuiltinFragDepth, BuiltinFrontFacing, BuiltinGlobalInvocationId, BuiltinInstanceIndex, BuiltinLocalInvocationId, BuiltinLocalInvocationIndex, BuiltinNumWorkgroups, BuiltinPosition, BuiltinPrimitiveIndex, BuiltinSampleIndex, BuiltinSampleMask, BuiltinSubgroupInvocationId, BuiltinSubgroupSize, BuiltinVertexIndex, BuiltinWorkgroupId, OmitBuiltins, builtin };

package/builtin.js

@@ -0,0 +1,35 @@
+import { $internal } from "./shared/symbols.js";
+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, {
+		[$internal]: true,
+		type: "@builtin",
+		params: [value]
+	});
+}
+const builtin = {
+	vertexIndex: defineBuiltin(u32, "vertex_index"),
+	instanceIndex: defineBuiltin(u32, "instance_index"),
+	clipDistances: defineBuiltin(arrayOf(u32, 8), "clip_distances"),
+	position: defineBuiltin(vec4f, "position"),
+	frontFacing: defineBuiltin(bool, "front_facing"),
+	fragDepth: defineBuiltin(f32, "frag_depth"),
+	primitiveIndex: defineBuiltin(u32, "primitive_index"),
+	sampleIndex: defineBuiltin(u32, "sample_index"),
+	sampleMask: defineBuiltin(u32, "sample_mask"),
+	localInvocationId: defineBuiltin(vec3u, "local_invocation_id"),
+	localInvocationIndex: defineBuiltin(u32, "local_invocation_index"),
+	globalInvocationId: defineBuiltin(vec3u, "global_invocation_id"),
+	workgroupId: defineBuiltin(vec3u, "workgroup_id"),
+	numWorkgroups: defineBuiltin(vec3u, "num_workgroups"),
+	subgroupInvocationId: defineBuiltin(u32, "subgroup_invocation_id"),
+	subgroupSize: defineBuiltin(u32, "subgroup_size"),
+	subgroupId: defineBuiltin(u32, "subgroup_id"),
+	numSubgroups: defineBuiltin(u32, "num_subgroups")
+};
+//#endregion
+export { builtin };

package/common/fullScreenTriangle.d.ts

@@ -0,0 +1,22 @@
+import { TgpuVertexFn } from "../core/function/tgpuVertexFn.js";
+import { Vec2f } from "../data/wgslTypes.js";
+//#region src/common/fullScreenTriangle.d.ts
+/**
+ * A vertex function that defines a single full-screen triangle out
+ * of three points.
+ *
+ * @example
+ * ```ts
+ * import { common } from 'typegpu';
+ *
+ * const pipeline = root.createRenderPipeline({
+ *   vertex: common.fullScreenTriangle,
+ *   fragment: yourFragmentShader,
+ * });
+ *
+ * pipeline.draw(3);
+ * ```
+ */
+declare const fullScreenTriangle: TgpuVertexFn;
+//#endregion
+export { fullScreenTriangle };

package/common/fullScreenTriangle.js

@@ -0,0 +1,34 @@
+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
+* of three points.
+*
+* @example
+* ```ts
+* import { common } from 'typegpu';
+*
+* const pipeline = root.createRenderPipeline({
+*   vertex: common.fullScreenTriangle,
+*   fragment: yourFragmentShader,
+* });
+*
+* pipeline.draw(3);
+* ```
+*/
+const fullScreenTriangle = vertexFn({
+	in: { vertexIndex: builtin.vertexIndex },
+	out: {
+		pos: builtin.position,
+		uv: vec2f
+	}
+})`{
+  const pos = array<vec2f, 3>(vec2f(-1, -1), vec2f(3, -1), vec2f(-1, 3));
+  const uv = array<vec2f, 3>(vec2f(0, 1), vec2f(2, 1), vec2f(0, -1));
+
+  return Out(vec4f(pos[in.vertexIndex], 0, 1), uv[in.vertexIndex]);
+}`;
+//#endregion
+export { fullScreenTriangle };

package/common/index.d.ts

@@ -1,9 +1,9 @@
-import { c as fullScreenTriangle } from "../indexNamedExports-oL6tyaJ9.js";
+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 as t };
-//# sourceMappingURL=index.d.ts.map
+export { fullScreenTriangle, index_d_exports, writeSoA };

package/common/index.js

@@ -1,9 +1,10 @@
-import { t as __exportAll } from "../chunk-BYypO7fO.js";
-import { t as fullScreenTriangle } from "../fullScreenTriangle-CfFyQd_0.js";
-
+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 { fullScreenTriangle, common_exports as t };
-//# sourceMappingURL=index.js.map
+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

@@ -0,0 +1,79 @@
+import { TgpuNamable } from "../../shared/meta.js";
+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 { BaseData } from "../../data/wgslTypes.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;
+}
+/**
+ * @deprecated Use UniformFlag instead.
+ */
+type Uniform = UniformFlag;
+interface VertexFlag {
+  usableAsVertex: true;
+}
+interface IndexFlag {
+  usableAsIndex: true;
+}
+interface IndirectFlag {
+  usableAsIndirect: true;
+}
+/**
+ * @deprecated Use VertexFlag instead.
+ */
+type Vertex = VertexFlag;
+type UsageLiteral = 'uniform' | 'storage' | 'vertex' | 'index' | 'indirect';
+type LiteralToUsageType<T extends UsageLiteral> = T extends 'uniform' ? UniformFlag : T extends 'storage' ? StorageFlag : T extends 'vertex' ? VertexFlag : T extends 'index' ? IndexFlag : T extends 'indirect' ? IndirectFlag : never;
+type ViewUsages<TBuffer extends TgpuBuffer<BaseData>> = (boolean extends TBuffer['usableAsUniform'] ? never : 'uniform') | (boolean extends TBuffer['usableAsStorage'] ? never : 'readonly' | 'mutable');
+type UsageTypeToBufferUsage<TData extends BaseData> = {
+  uniform: TgpuBufferUniform<TData> & TgpuFixedBufferUsage<TData>;
+  mutable: TgpuBufferMutable<TData> & TgpuFixedBufferUsage<TData>;
+  readonly: TgpuBufferReadonly<TData> & TgpuFixedBufferUsage<TData>;
+};
+/**
+ * Done as an object to later Prettify it
+ */
+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?: InferInput<TData> | undefined;
+  readonly arrayBuffer: ArrayBuffer;
+  readonly buffer: GPUBuffer;
+  readonly destroyed: boolean;
+  usableAsUniform: boolean;
+  usableAsStorage: boolean;
+  usableAsVertex: boolean;
+  usableAsIndex: boolean;
+  usableAsIndirect: boolean;
+  $usage<T extends [Prettify<InnerValidUsagesFor<TData>>['usage'], ...Prettify<InnerValidUsagesFor<TData>>['usage'][]]>(...usages: T): this & UnionToIntersection<LiteralToUsageType<T[number]>>;
+  $addFlags(flags: GPUBufferUsageFlags): this;
+  as<T extends ViewUsages<this>>(usage: T): UsageTypeToBufferUsage<TData>[T];
+  compileWriter(): 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>>;
+  destroy(): void;
+  toString(): string;
+}
+declare function isBuffer(value: unknown): value is TgpuBuffer<BaseData>;
+declare function isUsableAsVertex<T extends TgpuBuffer<BaseData>>(buffer: T): buffer is T & VertexFlag;
+//#endregion
+export { BufferWriteOptions, IndexFlag, IndirectFlag, TgpuBuffer, Uniform, UniformFlag, ValidUsagesFor, Vertex, VertexFlag, isBuffer, isUsableAsVertex };

package/core/buffer/buffer.js

@@ -0,0 +1,246 @@
+import { $internal } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.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 { getCompiledWriter } from "../../data/compiledIO.js";
+import { readData, writeData } from "../../data/dataIO.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,
+	mutable,
+	readonly
+};
+function INTERNAL_createBuffer(group, typeSchema, initialOrBuffer) {
+	if (!isWgslData(typeSchema)) return new TgpuBufferImpl(group, typeSchema, initialOrBuffer, ["storage", "uniform"]);
+	return new TgpuBufferImpl(group, typeSchema, initialOrBuffer);
+}
+function isBuffer(value) {
+	return value.resourceType === "buffer";
+}
+function isUsableAsVertex(buffer) {
+	return !!buffer.usableAsVertex;
+}
+const endianness = getSystemEndianness();
+var TgpuBufferImpl = class {
+	[$internal] = true;
+	resourceType = "buffer";
+	flags = GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC;
+	dataType;
+	#device;
+	#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) {
+		this.dataType = dataType;
+		this.#disallowedUsages = disallowedUsages;
+		this.#device = root.device;
+		if (isGPUBuffer(initialOrBuffer)) {
+			this.#ownBuffer = false;
+			this.#buffer = initialOrBuffer;
+		} else {
+			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({
+				size: sizeOf(this.dataType),
+				usage: this.flags,
+				mappedAtCreation: !!this.initial || !!this.#initialCallback,
+				label: getName(this) ?? "<unnamed>"
+			});
+			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;
+	}
+	get 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;
+		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}`);
+			this.flags |= usage === "uniform" ? GPUBufferUsage.UNIFORM : 0;
+			this.flags |= usage === "storage" ? GPUBufferUsage.STORAGE : 0;
+			this.flags |= usage === "vertex" ? GPUBufferUsage.VERTEX : 0;
+			this.flags |= usage === "index" ? GPUBufferUsage.INDEX : 0;
+			this.flags |= usage === "indirect" ? GPUBufferUsage.INDIRECT : 0;
+			this.usableAsUniform = this.usableAsUniform || usage === "uniform";
+			this.usableAsStorage = this.usableAsStorage || usage === "storage";
+			this.usableAsVertex = this.usableAsVertex || usage === "vertex";
+			this.usableAsIndex = this.usableAsIndex || usage === "index";
+			this.usableAsIndirect = this.usableAsIndirect || usage === "indirect";
+		}
+		return this;
+	}
+	$addFlags(flags) {
+		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;
+		}
+		if (flags & GPUBufferUsage.MAP_WRITE) {
+			this.flags = GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE;
+			return this;
+		}
+		this.flags |= flags;
+		return this;
+	}
+	compileWriter() {
+		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(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);
+		}
+		const writer = new BufferWriter(target);
+		writer.seekTo(startOffset);
+		writeData(writer, this.dataType, 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 = this.#getMappedRange();
+			if (data instanceof ArrayBuffer && data === mapped) return;
+			this.#writeToTarget(mapped, data, options);
+			return;
+		}
+		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;
+		if (gpuBuffer.mapState === "mapped") {
+			const mappedRange = this.#getMappedRange();
+			const mappedView = new Uint8Array(mappedRange);
+			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(this.#getMappedRange()).fill(0);
+			return;
+		}
+		const encoder = this.#device.createCommandEncoder();
+		encoder.clearBuffer(gpuBuffer);
+		this.#device.queue.submit([encoder.finish()]);
+	}
+	copyFrom(srcBuffer) {
+		if (this.buffer.mapState === "mapped") throw new Error("Cannot copy to a mapped buffer.");
+		const size = sizeOf(this.dataType);
+		const encoder = this.#device.createCommandEncoder();
+		encoder.copyBufferToBuffer(srcBuffer.buffer, 0, this.buffer, 0, size);
+		this.#device.queue.submit([encoder.finish()]);
+	}
+	async read() {
+		const gpuBuffer = this.buffer;
+		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(this.#getMappedRange()), this.dataType);
+			this.#unmapBuffer();
+			return res;
+		}
+		const stagingBuffer = this.#device.createBuffer({
+			size: sizeOf(this.dataType),
+			usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ
+		});
+		const commandEncoder = this.#device.createCommandEncoder();
+		commandEncoder.copyBufferToBuffer(gpuBuffer, 0, stagingBuffer, 0, sizeOf(this.dataType));
+		this.#device.queue.submit([commandEncoder.finish()]);
+		await stagingBuffer.mapAsync(GPUMapMode.READ, 0, sizeOf(this.dataType));
+		const res = readData(new BufferReader(stagingBuffer.getMappedRange()), this.dataType);
+		stagingBuffer.unmap();
+		stagingBuffer.destroy();
+		return res;
+	}
+	as(usage) {
+		return usageToUsageConstructor[usage]?.(this);
+	}
+	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 };