typegpu 0.10.1 → 0.10.2

package/{chunk-BYypO7fO.js → _virtual/_rolldown/runtime.js}

@@ -15,4 +15,4 @@ var __exportAll = (all, no_symbols) => {
 };
 
 //#endregion
-export { __exportAll as t };
+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,37 @@
+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,26 @@
+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
+ * 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<{}, {
+  uv: Vec2f;
+}>;
+//#endregion
+export { fullScreenTriangle };

package/common/fullScreenTriangle.js

@@ -0,0 +1,36 @@
+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,8 @@
-import { c as fullScreenTriangle } from "../indexNamedExports-oL6tyaJ9.js";
+import { fullScreenTriangle } from "./fullScreenTriangle.js";
 
 //#region src/common/index.d.ts
 declare namespace index_d_exports {
   export { fullScreenTriangle };
 }
 //#endregion
-export { fullScreenTriangle, index_d_exports as t };
-//# sourceMappingURL=index.d.ts.map
+export { fullScreenTriangle, index_d_exports };

package/common/index.js

@@ -1,9 +1,8 @@
-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";
 
 //#region src/common/index.ts
 var common_exports = /* @__PURE__ */ __exportAll({ fullScreenTriangle: () => fullScreenTriangle });
 
 //#endregion
-export { fullScreenTriangle, common_exports as t };
-//# sourceMappingURL=index.js.map
+export { common_exports, fullScreenTriangle };

package/core/buffer/buffer.d.ts

@@ -0,0 +1,74 @@
+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 "../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";
+
+//#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'];
+interface TgpuBuffer<TData extends BaseData> extends TgpuNamable {
+  readonly [$internal]: true;
+  readonly resourceType: 'buffer';
+  readonly dataType: TData;
+  readonly initial?: Infer<TData> | undefined;
+  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: Infer<TData>): void;
+  writePartial(data: InferPartial<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 { IndexFlag, IndirectFlag, TgpuBuffer, Uniform, UniformFlag, ValidUsagesFor, Vertex, VertexFlag, isBuffer, isUsableAsVertex };

package/core/buffer/buffer.js

@@ -0,0 +1,197 @@
+import { $internal } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.js";
+import { isWgslData } from "../../data/wgslTypes.js";
+import { isGPUBuffer } from "../../types.js";
+import { sizeOf } from "../../data/sizeOf.js";
+import { getCompiledWriterForSchema } from "../../data/compiledIO.js";
+import { readData, writeData } from "../../data/dataIO.js";
+import { getWriteInstructions } 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;
+	#device;
+	_buffer = null;
+	_ownBuffer;
+	_destroyed = false;
+	_hostBuffer;
+	initial;
+	usableAsUniform = false;
+	usableAsStorage = false;
+	usableAsVertex = false;
+	usableAsIndex = false;
+	usableAsIndirect = false;
+	constructor(root, dataType, initialOrBuffer, _disallowedUsages) {
+		this.dataType = dataType;
+		this.initialOrBuffer = initialOrBuffer;
+		this._disallowedUsages = _disallowedUsages;
+		this.#device = root.device;
+		if (isGPUBuffer(initialOrBuffer)) {
+			this._ownBuffer = false;
+			this._buffer = initialOrBuffer;
+		} else {
+			this._ownBuffer = true;
+			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,
+				label: getName(this) ?? "<unnamed>"
+			});
+			if (this.initial) {
+				this._writeToTarget(this._buffer.getMappedRange(), this.initial);
+				this._buffer.unmap();
+			}
+		}
+		return this._buffer;
+	}
+	get destroyed() {
+		return this._destroyed;
+	}
+	$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() {
+		getCompiledWriterForSchema(this.dataType);
+	}
+	_writeToTarget(target, data) {
+		const compiledWriter = getCompiledWriterForSchema(this.dataType);
+		if (compiledWriter) try {
+			compiledWriter(new DataView(target), 0, data, endianness === "little");
+			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);
+	}
+	write(data) {
+		const gpuBuffer = this.buffer;
+		if (gpuBuffer.mapState === "mapped") {
+			const mapped = gpuBuffer.getMappedRange();
+			this._writeToTarget(mapped, data);
+			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);
+	}
+	writePartial(data) {
+		const gpuBuffer = this.buffer;
+		const instructions = getWriteInstructions(this.dataType, data);
+		if (gpuBuffer.mapState === "mapped") {
+			const mappedRange = gpuBuffer.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);
+	}
+	clear() {
+		const gpuBuffer = this.buffer;
+		if (gpuBuffer.mapState === "mapped") {
+			new Uint8Array(gpuBuffer.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(gpuBuffer.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();
+			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;
+		if (this._ownBuffer) this._buffer?.destroy();
+	}
+	toString() {
+		return `buffer:${getName(this) ?? "<unnamed>"}`;
+	}
+};
+
+//#endregion
+export { INTERNAL_createBuffer, isBuffer, isUsableAsVertex };

package/core/buffer/bufferShorthand.d.ts

@@ -0,0 +1,48 @@
+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 { BaseData } from "../../data/wgslTypes.js";
+import { Infer, InferGPU, InferPartial } 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;
+  writePartial(data: InferPartial<TData>): void;
+  read(): Promise<Infer<TData>>;
+  readonly [$gpuValueOf]: InferGPU<TData>;
+}
+interface TgpuMutable<out TData extends BaseData> extends TgpuBufferShorthandBase<TData> {
+  readonly resourceType: 'mutable';
+  readonly buffer: TgpuBuffer<TData> & StorageFlag;
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  value: InferGPU<TData>;
+  $: InferGPU<TData>;
+}
+interface TgpuReadonly<out TData extends BaseData> extends TgpuBufferShorthandBase<TData> {
+  readonly resourceType: 'readonly';
+  readonly buffer: TgpuBuffer<TData> & StorageFlag;
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: InferGPU<TData>;
+  readonly $: InferGPU<TData>;
+}
+interface TgpuUniform<out TData extends BaseData> extends TgpuBufferShorthandBase<TData> {
+  readonly resourceType: 'uniform';
+  readonly buffer: TgpuBuffer<TData> & UniformFlag;
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: InferGPU<TData>;
+  readonly $: InferGPU<TData>;
+}
+type TgpuBufferShorthand<TData extends BaseData> = TgpuMutable<TData> | TgpuReadonly<TData> | TgpuUniform<TData>;
+declare function isBufferShorthand<TData extends BaseData>(value: unknown): value is TgpuBufferShorthand<TData>;
+//#endregion
+export { TgpuBufferShorthand, TgpuMutable, TgpuReadonly, TgpuUniform, isBufferShorthand };

package/core/buffer/bufferShorthand.js

@@ -0,0 +1,49 @@
+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;
+}
+var TgpuBufferShorthandImpl = class {
+	[$internal] = true;
+	[$getNameForward];
+	#usage;
+	constructor(resourceType, buffer) {
+		this.resourceType = resourceType;
+		this.buffer = buffer;
+		this[$getNameForward] = buffer;
+		this.#usage = this.buffer.as(this.resourceType);
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+	write(data) {
+		this.buffer.write(data);
+	}
+	writePartial(data) {
+		this.buffer.writePartial(data);
+	}
+	read() {
+		return this.buffer.read();
+	}
+	get [$gpuValueOf]() {
+		return this.#usage.$;
+	}
+	get $() {
+		return this.#usage.$;
+	}
+	get value() {
+		return this.$;
+	}
+	toString() {
+		return `${this.resourceType}BufferShorthand:${getName(this) ?? "<unnamed>"}`;
+	}
+	[$resolve](ctx) {
+		return ctx.resolve(this.#usage);
+	}
+};
+
+//#endregion
+export { TgpuBufferShorthandImpl, isBufferShorthand };

package/core/buffer/bufferUsage.d.ts

@@ -0,0 +1,45 @@
+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";
+import { Infer, InferGPU } from "../../shared/repr.js";
+
+//#region src/core/buffer/bufferUsage.d.ts
+interface TgpuBufferUsage<TData extends BaseData = BaseData, TUsage extends BindableBufferUsage = BindableBufferUsage> {
+  readonly resourceType: 'buffer-usage';
+  readonly usage: TUsage;
+  readonly [$repr]: Infer<TData>;
+  readonly [$gpuValueOf]: InferGPU<TData>;
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  value: InferGPU<TData>;
+  $: InferGPU<TData>;
+  readonly [$internal]: {
+    readonly dataType: TData;
+  };
+}
+interface TgpuBufferUniform<TData extends BaseData> extends TgpuBufferUsage<TData, 'uniform'> {
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: InferGPU<TData>;
+  readonly $: InferGPU<TData>;
+}
+interface TgpuBufferReadonly<TData extends BaseData> extends TgpuBufferUsage<TData, 'readonly'> {
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: InferGPU<TData>;
+  readonly $: InferGPU<TData>;
+}
+interface TgpuFixedBufferUsage<TData extends BaseData> extends TgpuNamable {
+  readonly buffer: TgpuBuffer<TData>;
+}
+interface TgpuBufferMutable<TData extends BaseData> extends TgpuBufferUsage<TData, 'mutable'> {}
+declare function isUsableAsUniform<T extends TgpuBuffer<BaseData>>(buffer: T): buffer is T & UniformFlag;
+//#endregion
+export { TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform, TgpuBufferUsage, TgpuFixedBufferUsage, isUsableAsUniform };