typegpu 0.10.1 → 0.10.2

package/tgpuBindGroupLayout.js

@@ -0,0 +1,271 @@
+import { $gpuValueOf, $internal } from "./shared/symbols.js";
+import { getName, setName } from "./shared/meta.js";
+import { NotUniformError } from "./errors.js";
+import { safeStringify } from "./shared/stringify.js";
+import { f32, i32, u32 } from "./data/numeric.js";
+import { comparisonSampler, sampler } from "./data/sampler.js";
+import { textureDescriptorToSchema } from "./data/texture.js";
+import { NotStorageError, isUsableAsStorage } from "./extension.js";
+import { TgpuLaidOutBufferImpl, isUsableAsUniform } from "./core/buffer/bufferUsage.js";
+import { isBuffer } from "./core/buffer/buffer.js";
+import { TgpuLaidOutSamplerImpl, isComparisonSampler, isSampler } from "./core/sampler/sampler.js";
+import { TgpuExternalTextureImpl } from "./core/texture/externalTexture.js";
+import { TgpuLaidOutTextureViewImpl, isTexture, isTextureView } from "./core/texture/texture.js";
+import { NotSampledError, isUsableAsSampled } from "./core/texture/usageExtension.js";
+
+//#region src/tgpuBindGroupLayout.ts
+/**
+* Converts legacy entries to new API format
+*/
+function convertLegacyEntries(entries) {
+	const result = {};
+	for (const [key, entry] of Object.entries(entries)) {
+		if (entry === null) {
+			result[key] = null;
+			continue;
+		}
+		if ("texture" in entry && typeof entry.texture === "string") {
+			const sampleType = entry.texture;
+			result[key] = {
+				...entry,
+				texture: textureDescriptorToSchema({
+					dimension: entry.viewDimension ?? "2d",
+					sampleType: sampleType === "sint" ? i32 : sampleType === "uint" ? u32 : f32,
+					multisampled: entry.multisampled ?? false
+				})
+			};
+		} else if ("storageTexture" in entry && typeof entry.storageTexture === "string") {
+			const accessMap = {
+				readonly: "read-only",
+				writeonly: "write-only",
+				mutable: "read-write"
+			};
+			result[key] = {
+				...entry,
+				storageTexture: textureDescriptorToSchema({
+					access: accessMap[entry.access ?? "writeonly"],
+					format: entry.storageTexture,
+					dimension: entry.viewDimension ?? "2d"
+				})
+			};
+		} else if ("externalTexture" in entry && Object.keys(entry.externalTexture).length === 0) result[key] = {
+			...entry,
+			externalTexture: {
+				type: "texture_external",
+				dimension: "2d"
+			}
+		};
+		else result[key] = entry;
+	}
+	return result;
+}
+function bindGroupLayout(entries) {
+	return new TgpuBindGroupLayoutImpl(convertLegacyEntries(entries));
+}
+function isBindGroupLayout(value) {
+	return !!value && value.resourceType === "bind-group-layout";
+}
+function isBindGroup(value) {
+	return !!value && value.resourceType === "bind-group";
+}
+/**
+* @category Errors
+*/
+var MissingBindingError = class MissingBindingError extends Error {
+	constructor(groupLabel, key) {
+		super(`Bind group '${groupLabel ?? "<unnamed>"}' is missing a required binding '${key}'`);
+		Object.setPrototypeOf(this, MissingBindingError.prototype);
+	}
+};
+const DEFAULT_MUTABLE_VISIBILITY = ["compute", "fragment"];
+const DEFAULT_READONLY_VISIBILITY = [
+	"compute",
+	"vertex",
+	"fragment"
+];
+var TgpuBindGroupLayoutImpl = class {
+	[$internal];
+	_index;
+	resourceType = "bind-group-layout";
+	value = {};
+	$ = this.value;
+	get [$gpuValueOf]() {
+		return this.$;
+	}
+	constructor(entries) {
+		this.entries = entries;
+		let idx = 0;
+		const bound = {};
+		this[$internal] = { bound };
+		for (const [key, entry] of Object.entries(entries)) {
+			if (entry === null) {
+				idx++;
+				continue;
+			}
+			const membership = {
+				layout: this,
+				key,
+				idx
+			};
+			if ("uniform" in entry) bound[key] = new TgpuLaidOutBufferImpl("uniform", entry.uniform, membership);
+			if ("storage" in entry) {
+				const dataType = "type" in entry.storage ? entry.storage : entry.storage(0);
+				bound[key] = new TgpuLaidOutBufferImpl(entry.access ?? "readonly", dataType, membership);
+			}
+			if ("texture" in entry) bound[key] = new TgpuLaidOutTextureViewImpl(entry.texture, membership);
+			if ("storageTexture" in entry) bound[key] = new TgpuLaidOutTextureViewImpl(entry.storageTexture, membership);
+			if ("externalTexture" in entry) bound[key] = new TgpuExternalTextureImpl(entry.externalTexture, membership);
+			if ("sampler" in entry) bound[key] = new TgpuLaidOutSamplerImpl(entry.sampler === "comparison" ? comparisonSampler() : sampler(), membership);
+			Object.defineProperty(this.value, key, { get: () => {
+				return bound[key].value;
+			} });
+			idx++;
+		}
+	}
+	toString() {
+		return `bindGroupLayout:${getName(this) ?? "<unnamed>"}`;
+	}
+	get index() {
+		return this._index;
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+	get bound() {
+		return this[$internal].bound;
+	}
+	$idx(index) {
+		this._index = index;
+		return this;
+	}
+	unwrap(unwrapper) {
+		return unwrapper.device.createBindGroupLayout({
+			label: getName(this) ?? "<unnamed>",
+			entries: Object.values(this.entries).map((entry, idx) => {
+				if (entry === null) return null;
+				let visibility = entry.visibility;
+				const binding = {
+					binding: idx,
+					visibility: 0
+				};
+				if ("uniform" in entry) {
+					visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
+					binding.buffer = { type: "uniform" };
+				} else if ("storage" in entry) {
+					visibility = visibility ?? (entry.access === "mutable" ? DEFAULT_MUTABLE_VISIBILITY : DEFAULT_READONLY_VISIBILITY);
+					binding.buffer = { type: entry.access === "mutable" ? "storage" : "read-only-storage" };
+				} else if ("sampler" in entry) {
+					visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
+					binding.sampler = { type: entry.sampler };
+				} else if ("texture" in entry) {
+					visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
+					const { multisampled, dimension, bindingSampleType } = entry.texture;
+					binding.texture = {
+						sampleType: entry.sampleType ?? bindingSampleType[0],
+						viewDimension: dimension,
+						multisampled
+					};
+				} else if ("storageTexture" in entry) {
+					visibility = visibility ?? DEFAULT_MUTABLE_VISIBILITY;
+					const { dimension, access, format } = entry.storageTexture;
+					binding.storageTexture = {
+						access,
+						format,
+						viewDimension: dimension
+					};
+				} else if ("externalTexture" in entry) {
+					visibility = visibility ?? DEFAULT_READONLY_VISIBILITY;
+					binding.externalTexture = {};
+				}
+				if (visibility?.includes("compute")) binding.visibility |= GPUShaderStage.COMPUTE;
+				if (visibility?.includes("vertex")) binding.visibility |= GPUShaderStage.VERTEX;
+				if (visibility?.includes("fragment")) binding.visibility |= GPUShaderStage.FRAGMENT;
+				return binding;
+			}).filter((v) => v !== null)
+		});
+	}
+};
+var TgpuBindGroupImpl = class {
+	resourceType = "bind-group";
+	constructor(layout, entries) {
+		this.layout = layout;
+		this.entries = entries;
+		for (const key of Object.keys(layout.entries)) if (layout.entries[key] !== null && !(key in entries)) throw new MissingBindingError(getName(layout), key);
+	}
+	unwrap(unwrapper) {
+		return unwrapper.device.createBindGroup({
+			label: getName(this.layout) ?? "<unnamed>",
+			layout: unwrapper.unwrap(this.layout),
+			entries: Object.entries(this.layout.entries).map(([key, entry], idx) => {
+				if (entry === null) return null;
+				const value = this.entries[key];
+				if (value === void 0) throw new Error(`'${key}' is a resource required to populate bind group layout '${getName(this.layout) ?? "<unnamed>"}'.`);
+				if ("uniform" in entry) {
+					let resource;
+					if (isBuffer(value)) {
+						if (!isUsableAsUniform(value)) throw new NotUniformError(value);
+						resource = { buffer: unwrapper.unwrap(value) };
+					} else resource = { buffer: value };
+					return {
+						binding: idx,
+						resource
+					};
+				}
+				if ("storage" in entry) {
+					let resource;
+					if (isBuffer(value)) {
+						if (!isUsableAsStorage(value)) throw new NotStorageError(value);
+						resource = { buffer: unwrapper.unwrap(value) };
+					} else resource = { buffer: value };
+					return {
+						binding: idx,
+						resource
+					};
+				}
+				if ("texture" in entry) {
+					let resource;
+					if (isTexture(value)) {
+						if (!isUsableAsSampled(value)) throw new NotSampledError(value);
+						resource = unwrapper.unwrap(value.createView(entry.texture));
+					} else if (isTextureView(value)) resource = unwrapper.unwrap(value);
+					else resource = value;
+					return {
+						binding: idx,
+						resource
+					};
+				}
+				if ("storageTexture" in entry) {
+					let resource;
+					if (isTexture(value)) {
+						if (!isUsableAsStorage(value)) throw new NotStorageError(value);
+						resource = unwrapper.unwrap(value.createView(entry.storageTexture));
+					} else if (isTextureView(value)) resource = unwrapper.unwrap(value);
+					else resource = value;
+					return {
+						binding: idx,
+						resource
+					};
+				}
+				if ("sampler" in entry) {
+					if (isComparisonSampler(value) || isSampler(value)) return {
+						binding: idx,
+						resource: unwrapper.unwrap(value)
+					};
+					return {
+						binding: idx,
+						resource: value
+					};
+				}
+				if ("externalTexture" in entry) return {
+					binding: idx,
+					resource: value
+				};
+				throw new Error(`Malformed bind group entry: ${safeStringify(value)}`);
+			}).filter((v) => v !== null)
+		});
+	}
+};
+
+//#endregion
+export { TgpuBindGroupImpl, bindGroupLayout, isBindGroup, isBindGroupLayout };

package/tgpuUnstable.d.ts

@@ -0,0 +1,48 @@
+import { computeFn } from "./core/function/tgpuComputeFn.js";
+import { privateVar, workgroupVar } from "./core/variable/tgpuVariable.js";
+import { fragmentFn } from "./core/function/tgpuFragmentFn.js";
+import { vertexFn } from "./core/function/tgpuVertexFn.js";
+import { vertexLayout } from "./core/vertexLayout/vertexLayout.js";
+import { declare } from "./core/declare/tgpuDeclare.js";
+import { fn } from "./core/function/tgpuFn.js";
+import { constant } from "./core/constant/tgpuConstant.js";
+import { comptime } from "./core/function/comptime.js";
+import { namespace } from "./core/resolve/namespace.js";
+import { slot } from "./core/slot/slot.js";
+import { lazy } from "./core/slot/lazy.js";
+import { accessor, mutableAccessor } from "./core/slot/accessor.js";
+import { rawCodeSnippet } from "./core/rawCodeSnippet/tgpuRawCodeSnippet.js";
+import { simulate } from "./core/simulate/tgpuSimulate.js";
+
+//#region src/tgpuUnstable.d.ts
+declare namespace tgpuUnstable_d_exports {
+  export { _accessor as accessor, _comptime as comptime, _computeFn as computeFn, _constant as const, declare, _lazy as derived, _fn as fn, _fragmentFn as fragmentFn, _mutableAccessor as mutableAccessor, namespace, _privateVar as privateVar, rawCodeSnippet, simulate, _slot as slot, _vertexFn as vertexFn, _vertexLayout as vertexLayout, _workgroupVar as workgroupVar };
+}
+/** @deprecated This feature is now stable, use tgpu.const. */
+declare const _constant: typeof constant;
+/** @deprecated This feature is now stable, use tgpu.comptime. */
+declare const _comptime: typeof comptime;
+/** @deprecated This feature is now stable, use tgpu.computeFn. */
+declare const _computeFn: typeof computeFn;
+/** @deprecated This feature is now stable, use tgpu.fn. */
+declare const _fn: typeof fn;
+/** @deprecated This feature is now stable, use tgpu.fragmentFn. */
+declare const _fragmentFn: typeof fragmentFn;
+/** @deprecated This feature is now stable, use tgpu.vertexFn. */
+declare const _vertexFn: typeof vertexFn;
+/** @deprecated This feature is now stable, use tgpu.accessor. */
+declare const _accessor: typeof accessor;
+/** @deprecated This feature is now stable, use tgpu.mutableAccessor. */
+declare const _mutableAccessor: typeof mutableAccessor;
+/** @deprecated This feature is now stable, use tgpu.lazy. */
+declare const _lazy: typeof lazy;
+/** @deprecated This feature is now stable, use tgpu.slot. */
+declare const _slot: typeof slot;
+/** @deprecated This feature is now stable, use tgpu.privateVar. */
+declare const _privateVar: typeof privateVar;
+/** @deprecated This feature is now stable, use tgpu.workgroupVar. */
+declare const _workgroupVar: typeof workgroupVar;
+/** @deprecated This feature is now stable, use tgpu.vertexLayout. */
+declare const _vertexLayout: typeof vertexLayout;
+//#endregion
+export { tgpuUnstable_d_exports };

package/tgpuUnstable.js

@@ -0,0 +1,66 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { comptime } from "./core/function/comptime.js";
+import { constant } from "./core/constant/tgpuConstant.js";
+import { fn } from "./core/function/tgpuFn.js";
+import { namespace } from "./core/resolve/namespace.js";
+import { slot } from "./core/slot/slot.js";
+import { privateVar, workgroupVar } from "./core/variable/tgpuVariable.js";
+import { computeFn } from "./core/function/tgpuComputeFn.js";
+import { vertexLayout } from "./core/vertexLayout/vertexLayout.js";
+import { lazy } from "./core/slot/lazy.js";
+import { accessor, mutableAccessor } from "./core/slot/accessor.js";
+import { fragmentFn } from "./core/function/tgpuFragmentFn.js";
+import { vertexFn } from "./core/function/tgpuVertexFn.js";
+import { declare } from "./core/declare/tgpuDeclare.js";
+import { rawCodeSnippet } from "./core/rawCodeSnippet/tgpuRawCodeSnippet.js";
+import { simulate } from "./core/simulate/tgpuSimulate.js";
+
+//#region src/tgpuUnstable.ts
+var tgpuUnstable_exports = /* @__PURE__ */ __exportAll({
+	accessor: () => _accessor,
+	comptime: () => _comptime,
+	computeFn: () => _computeFn,
+	const: () => _constant,
+	declare: () => declare,
+	derived: () => _lazy,
+	fn: () => _fn,
+	fragmentFn: () => _fragmentFn,
+	mutableAccessor: () => _mutableAccessor,
+	namespace: () => namespace,
+	privateVar: () => _privateVar,
+	rawCodeSnippet: () => rawCodeSnippet,
+	simulate: () => simulate,
+	slot: () => _slot,
+	vertexFn: () => _vertexFn,
+	vertexLayout: () => _vertexLayout,
+	workgroupVar: () => _workgroupVar
+});
+/** @deprecated This feature is now stable, use tgpu.const. */
+const _constant = constant;
+/** @deprecated This feature is now stable, use tgpu.comptime. */
+const _comptime = comptime;
+/** @deprecated This feature is now stable, use tgpu.computeFn. */
+const _computeFn = computeFn;
+/** @deprecated This feature is now stable, use tgpu.fn. */
+const _fn = fn;
+/** @deprecated This feature is now stable, use tgpu.fragmentFn. */
+const _fragmentFn = fragmentFn;
+/** @deprecated This feature is now stable, use tgpu.vertexFn. */
+const _vertexFn = vertexFn;
+/** @deprecated This feature is now stable, use tgpu.accessor. */
+const _accessor = accessor;
+/** @deprecated This feature is now stable, use tgpu.mutableAccessor. */
+const _mutableAccessor = mutableAccessor;
+/** @deprecated This feature is now stable, use tgpu.lazy. */
+const _lazy = lazy;
+/** @deprecated This feature is now stable, use tgpu.slot. */
+const _slot = slot;
+/** @deprecated This feature is now stable, use tgpu.privateVar. */
+const _privateVar = privateVar;
+/** @deprecated This feature is now stable, use tgpu.workgroupVar. */
+const _workgroupVar = workgroupVar;
+/** @deprecated This feature is now stable, use tgpu.vertexLayout. */
+const _vertexLayout = vertexLayout;
+
+//#endregion
+export { tgpuUnstable_exports };

package/tgsl/accessIndex.js

@@ -0,0 +1,45 @@
+import { isNaturallyEphemeral, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
+import { MatrixColumnsAccess, UnknownData, isDisarray } from "../data/dataTypes.js";
+import { isEphemeralSnippet, snip } from "../data/snippet.js";
+import { isKnownAtComptime } from "../types.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { derefSnippet } from "../data/ref.js";
+import { vec2f, vec3f, vec4f } from "../data/vector.js";
+import { coerceToSnippet } from "./generationHelpers.js";
+import { accessProp } from "./accessProp.js";
+
+//#region src/tgsl/accessIndex.ts
+const indexableTypeToResult = {
+	mat2x2f: vec2f,
+	mat3x3f: vec3f,
+	mat4x4f: vec4f
+};
+function accessIndex(target, indexArg) {
+	const index = typeof indexArg === "number" ? coerceToSnippet(indexArg) : indexArg;
+	if (isWgslArray(target.dataType) || isDisarray(target.dataType)) {
+		const elementType = target.dataType.elementType;
+		const isElementNatEph = isNaturallyEphemeral(elementType);
+		const isTargetEphemeral = isEphemeralSnippet(target);
+		const isIndexConstant = index.origin === "constant";
+		let origin;
+		if (target.origin === "constant-tgpu-const-ref") if (isIndexConstant) origin = isElementNatEph ? "constant" : "constant-tgpu-const-ref";
+		else origin = isElementNatEph ? "runtime" : "runtime-tgpu-const-ref";
+		else if (target.origin === "runtime-tgpu-const-ref") origin = isElementNatEph ? "runtime" : "runtime-tgpu-const-ref";
+		else if (!isTargetEphemeral && !isElementNatEph) origin = target.origin;
+		else if (isIndexConstant && target.origin === "constant") origin = "constant";
+		else origin = "runtime";
+		return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, elementType, origin);
+	}
+	if (isVec(target.dataType)) return snip(isKnownAtComptime(target) && isKnownAtComptime(index) ? target.value[index.value] : stitch`${target}[${index}]`, target.dataType.primitive, target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");
+	if (isPtr(target.dataType)) return accessIndex(derefSnippet(target), index);
+	if (target.value instanceof MatrixColumnsAccess) {
+		const propType = indexableTypeToResult[target.value.matrix.dataType.type];
+		return snip(stitch`${target.value.matrix}[${index}]`, propType, target.origin);
+	}
+	if (target.dataType.type in indexableTypeToResult) throw new Error("The only way of accessing matrix elements in TypeGPU functions is through the 'columns' property.");
+	if (isKnownAtComptime(target) && isKnownAtComptime(index) || target.dataType === UnknownData) return coerceToSnippet(target.value[index.value]);
+	if (isWgslStruct(target.dataType) && isKnownAtComptime(index) && typeof index.value === "string") return accessProp(target, index.value);
+}
+
+//#endregion
+export { accessIndex };

package/tgsl/accessProp.js

@@ -0,0 +1,113 @@
+import { $gpuCallable } from "../shared/symbols.js";
+import { isMat, isNaturallyEphemeral, isPtr, isVec, isWgslArray, isWgslStruct } from "../data/wgslTypes.js";
+import { InfixDispatch, MatrixColumnsAccess, UnknownData, isUnstruct, undecorate } from "../data/dataTypes.js";
+import { isEphemeralSnippet, snip } from "../data/snippet.js";
+import { isKnownAtComptime } from "../types.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { derefSnippet } from "../data/ref.js";
+import { abstractInt, bool, f16, f32, i32, u32 } from "../data/numeric.js";
+import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u } from "../data/vector.js";
+import { AutoStruct } from "../data/autoStruct.js";
+import { coerceToSnippet } from "./generationHelpers.js";
+import { add, div, mod, mul, sub } from "../std/operators.js";
+
+//#region src/tgsl/accessProp.ts
+const infixKinds = [
+	"vec2f",
+	"vec3f",
+	"vec4f",
+	"vec2h",
+	"vec3h",
+	"vec4h",
+	"vec2i",
+	"vec3i",
+	"vec4i",
+	"vec2u",
+	"vec3u",
+	"vec4u",
+	"mat2x2f",
+	"mat3x3f",
+	"mat4x4f"
+];
+const infixOperators = {
+	add,
+	sub,
+	mul,
+	div,
+	mod
+};
+const swizzleLenToType = {
+	f: {
+		1: f32,
+		2: vec2f,
+		3: vec3f,
+		4: vec4f
+	},
+	h: {
+		1: f16,
+		2: vec2h,
+		3: vec3h,
+		4: vec4h
+	},
+	i: {
+		1: i32,
+		2: vec2i,
+		3: vec3i,
+		4: vec4i
+	},
+	u: {
+		1: u32,
+		2: vec2u,
+		3: vec3u,
+		4: vec4u
+	},
+	b: {
+		1: bool,
+		2: vec2b,
+		3: vec3b,
+		4: vec4b
+	}
+};
+function accessProp(target, propName) {
+	if (infixKinds.includes(target.dataType.type) && propName in infixOperators) {
+		const operator = infixOperators[propName];
+		return snip(new InfixDispatch(propName, target, operator[$gpuCallable].call.bind(operator)), UnknownData, target.origin);
+	}
+	if (isWgslArray(target.dataType) && propName === "length") {
+		if (target.dataType.elementCount === 0) return snip(stitch`arrayLength(&${target})`, u32, "runtime");
+		return snip(target.dataType.elementCount, abstractInt, "constant");
+	}
+	if (isMat(target.dataType) && propName === "columns") return snip(new MatrixColumnsAccess(target), UnknownData, target.origin);
+	if (isWgslStruct(target.dataType) || isUnstruct(target.dataType)) {
+		let propType = target.dataType.propTypes[propName];
+		if (!propType) return;
+		propType = undecorate(propType);
+		return snip(stitch`${target}.${propName}`, propType, target.origin === "argument" ? "argument" : !isEphemeralSnippet(target) && !isNaturallyEphemeral(propType) ? target.origin : target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");
+	}
+	if (target.dataType instanceof AutoStruct) {
+		const result = target.dataType.accessProp(propName);
+		if (!result) return;
+		return snip(stitch`${target}.${result.prop}`, result.type, "argument");
+	}
+	if (isPtr(target.dataType)) {
+		const derefed = derefSnippet(target);
+		if (propName === "$") return derefed;
+		return accessProp(derefed, propName);
+	}
+	if (isVec(target.dataType)) {
+		if (propName === "kind") return snip(target.dataType.type, UnknownData, "constant");
+	}
+	const propLength = propName.length;
+	if (isVec(target.dataType) && propLength >= 1 && propLength <= 4) {
+		const isXYZW = /^[xyzw]+$/.test(propName);
+		const isRGBA = /^[rgba]+$/.test(propName);
+		if (!isXYZW && !isRGBA) return;
+		const swizzleType = swizzleLenToType[target.dataType.type.includes("bool") ? "b" : target.dataType.type[4]][propLength];
+		if (!swizzleType) return;
+		return snip(isKnownAtComptime(target) ? target.value[propName] : stitch`${target}.${propName}`, swizzleType, target.origin === "argument" && propLength === 1 ? "argument" : target.origin === "constant" || target.origin === "constant-tgpu-const-ref" ? "constant" : "runtime");
+	}
+	if (isKnownAtComptime(target) || target.dataType === UnknownData) return coerceToSnippet(target.value[propName]);
+}
+
+//#endregion
+export { accessProp, infixOperators };

package/tgsl/consoleLog/deserializers.js

@@ -0,0 +1,117 @@
+import { isWgslArray, isWgslData, isWgslStruct } from "../../data/wgslTypes.js";
+import { niceStringify } from "../../shared/stringify.js";
+import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u } from "../../data/vector.js";
+import { sizeOf } from "../../data/sizeOf.js";
+import { mat2x2f, mat3x3f, mat4x4f } from "../../data/matrix.js";
+import { bitcastU32toF32, bitcastU32toI32 } from "../../std/bitcast.js";
+import { unpack2x16float } from "../../std/packing.js";
+
+//#region src/tgsl/consoleLog/deserializers.ts
+const toF = (n) => bitcastU32toF32(n ?? 0);
+const toI = (n) => bitcastU32toI32(n ?? 0);
+const unpack = (n) => unpack2x16float(n ?? 0);
+const deserializerMap = {
+	f32: (d) => toF(d[0]),
+	f16: (d) => unpack(d[0]).x,
+	i32: (d) => toI(d[0]),
+	u32: (d) => d[0] ?? 0,
+	bool: (d) => !!d[0],
+	vec2f: (d) => vec2f(toF(d[0]), toF(d[1])),
+	vec3f: (d) => vec3f(toF(d[0]), toF(d[1]), toF(d[2])),
+	vec4f: (d) => vec4f(toF(d[0]), toF(d[1]), toF(d[2]), toF(d[3])),
+	vec2h(d) {
+		const xyVec = unpack(d[0]);
+		return vec2h(xyVec.x, xyVec.y);
+	},
+	vec3h(d) {
+		const xyVec = unpack(d[0]);
+		const zVec = unpack(d[1]);
+		return vec3h(xyVec.x, xyVec.y, zVec.x);
+	},
+	vec4h(d) {
+		const xyVec = unpack(d[0]);
+		const zwVec = unpack(d[1]);
+		return vec4h(xyVec.x, xyVec.y, zwVec.x, zwVec.y);
+	},
+	vec2i: (d) => vec2i(toI(d[0]), toI(d[1])),
+	vec3i: (d) => vec3i(toI(d[0]), toI(d[1]), toI(d[2])),
+	vec4i: (d) => vec4i(toI(d[0]), toI(d[1]), toI(d[2]), toI(d[3])),
+	vec2u: (d) => vec2u(d[0] ?? 0, d[1] ?? 0),
+	vec3u: (d) => vec3u(d[0] ?? 0, d[1] ?? 0, d[2] ?? 0),
+	vec4u: (d) => vec4u(d[0] ?? 0, d[1] ?? 0, d[2] ?? 0, d[3] ?? 0),
+	"vec2<bool>": (d) => vec2b(!!d[0], !!d[1]),
+	"vec3<bool>": (d) => vec3b(!!d[0], !!d[1], !!d[2]),
+	"vec4<bool>": (d) => vec4b(!!d[0], !!d[1], !!d[2], !!d[3]),
+	mat2x2f: (d) => mat2x2f(toF(d[0]), toF(d[1]), toF(d[2]), toF(d[3])),
+	mat3x3f: (d) => mat3x3f(toF(d[0]), toF(d[1]), toF(d[2]), toF(d[4]), toF(d[5]), toF(d[6]), toF(d[8]), toF(d[9]), toF(d[10])),
+	mat4x4f: (d) => mat4x4f(toF(d[0]), toF(d[1]), toF(d[2]), toF(d[3]), toF(d[4]), toF(d[5]), toF(d[6]), toF(d[7]), toF(d[8]), toF(d[9]), toF(d[10]), toF(d[11]), toF(d[12]), toF(d[13]), toF(d[14]), toF(d[15]))
+};
+/**
+* Deserializes binary data from a Uint32Array into a JavaScript value based on the provided WGSL data type.
+*
+* @param data - The binary data as a Uint32Array to be deserialized
+* @param dataType - The WGSL data type specification that determines how to interpret the binary data
+*/
+function deserialize(data, dataType) {
+	const maybeDeserializer = deserializerMap[dataType.type];
+	if (maybeDeserializer) return maybeDeserializer(data);
+	if (isWgslStruct(dataType)) {
+		const props = Object.keys(dataType.propTypes);
+		const decodedProps = deserializeCompound(data, Object.values(dataType.propTypes));
+		return Object.fromEntries(props.map((key, index) => [key, decodedProps[index]]));
+	}
+	if (isWgslArray(dataType)) {
+		const elementType = dataType.elementType;
+		const length = dataType.elementCount;
+		return deserializeCompound(data, Array.from({ length }, () => elementType));
+	}
+	throw new Error(`Cannot deserialize data of type ${dataType.type}`);
+}
+/**
+* Deserializes a list of elements from a Uint32Array buffer using provided type information.
+* If there is a string value among the type information, it is returned as is.
+*
+* @param data - The Uint32Array buffer containing the serialized data
+* @param dataTypes - The WGSL data type specification that determines how to interpret the binary data, or string literals
+*/
+function deserializeCompound(data, dataTypes) {
+	let index = 0;
+	return dataTypes.map((info) => {
+		if (!isWgslData(info)) return info;
+		const size = Math.ceil(sizeOf(info) / 4);
+		const value = deserialize(data.subarray(index, index + size), info);
+		index += size;
+		return value;
+	});
+}
+function deserializeAndStringify(serializedData, argTypes) {
+	return deserializeCompound(serializedData, argTypes).map(niceStringify);
+}
+/**
+* Reads and deserializes log data from GPU buffers, logging results to the console.
+*
+* @remarks
+* - Log entries with IDs equal to 0 are filtered out.
+* - Console messages are prepended with options.messagePrefix styled with purple background and white text.
+* - A warning is displayed if the log count exceeds the limit passed in options.
+* - After processing, the index buffer and the data buffer are cleared.
+*/
+function logDataFromGPU(resources) {
+	const { indexBuffer, dataBuffer, logIdToMeta, options } = resources;
+	dataBuffer.read().then((data) => {
+		data.filter((e) => e.id).forEach(({ id, serializedData }) => {
+			const { argTypes, op } = logIdToMeta.get(id);
+			const results = deserializeAndStringify(new Uint32Array(serializedData), argTypes);
+			if (results.length === 0) results.push("");
+			console[op](`%c${options.messagePrefix}%c ${results[0]}`, "background: #936ff5; color: white;", "color: inherit; background: none", ...results.slice(1));
+		});
+	});
+	indexBuffer.read().then((totalCalls) => {
+		if (totalCalls > options.logCountLimit) console.warn(`Log count limit per dispatch (${options.logCountLimit}) exceeded by ${totalCalls - options.logCountLimit} calls. Consider increasing the limit by passing appropriate options to tgpu.init().`);
+	});
+	dataBuffer.buffer.clear();
+	indexBuffer.buffer.clear();
+}
+
+//#endregion
+export { logDataFromGPU };