typegpu 0.10.1 → 0.11.0-rc.1

package/tgsl/accessProp.js

@@ -0,0 +1,115 @@
+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 { coerceToSnippet } from "./generationHelpers.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 { EntryInputRouter } from "../core/function/entryInputRouter.js";
+import { add, bitShiftLeft, bitShiftRight, 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,
+	bitShiftLeft,
+	bitShiftRight
+};
+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 (target.dataType instanceof EntryInputRouter) return target.dataType.accessProp(propName);
+	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,115 @@
+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 };

package/tgsl/consoleLog/logGenerator.js

@@ -0,0 +1,84 @@
+import { $internal } from "../../shared/symbols.js";
+import { Void } from "../../data/wgslTypes.js";
+import { UnknownData } from "../../data/dataTypes.js";
+import { snip } from "../../data/snippet.js";
+import { stitch } from "../../core/resolve/stitch.js";
+import { u32 } from "../../data/numeric.js";
+import { concretizeSnippets } from "../generationHelpers.js";
+import { struct } from "../../data/struct.js";
+import { shaderStageSlot } from "../../core/slot/internalSlots.js";
+import { arrayOf } from "../../data/array.js";
+import { atomic } from "../../data/atomic.js";
+import { createLoggingFunction } from "./serializers.js";
+import { supportedLogOps } from "./types.js";
+//#region src/tgsl/consoleLog/logGenerator.ts
+const defaultOptions = {
+	logCountLimit: 64,
+	logSizeLimit: 252,
+	messagePrefix: " GPU "
+};
+const fallbackSnippet = snip("/* console.log() */", Void, "runtime");
+var LogGeneratorNullImpl = class {
+	get logResources() {}
+	generateLog() {
+		console.warn("'console.log' is only supported when resolving pipelines.");
+		return fallbackSnippet;
+	}
+};
+var LogGeneratorImpl = class {
+	#options;
+	#logIdToMeta;
+	#firstUnusedId = 1;
+	#indexBuffer;
+	#dataBuffer;
+	constructor(root) {
+		this.#options = {
+			...defaultOptions,
+			...root[$internal].logOptions
+		};
+		this.#logIdToMeta = /* @__PURE__ */ new Map();
+		const SerializedLogData = struct({
+			id: u32,
+			serializedData: arrayOf(u32, Math.ceil(this.#options.logSizeLimit / 4))
+		}).$name("SerializedLogData");
+		this.#dataBuffer = root.createMutable(arrayOf(SerializedLogData, this.#options.logCountLimit)).$name("dataBuffer");
+		this.#indexBuffer = root.createMutable(atomic(u32)).$name("indexBuffer");
+	}
+	/**
+	* Generates all necessary resources for serializing arguments for logging purposes.
+	*
+	* @param ctx Resolution context.
+	* @param args Argument snippets. Snippets of UnknownType will be treated as string literals.
+	* @returns A snippet containing the call to the logging function.
+	*/
+	generateLog(ctx, op, args) {
+		if (shaderStageSlot.$ === "vertex") {
+			console.warn(`'console.${op}' is not supported in vertex shaders.`);
+			return fallbackSnippet;
+		}
+		if (!supportedLogOps.includes(op)) {
+			console.warn(`Unsupported log method '${op}'.`);
+			return fallbackSnippet;
+		}
+		const concreteArgs = concretizeSnippets(args);
+		const id = this.#firstUnusedId++;
+		const nonStringArgs = concreteArgs.filter((e) => e.dataType !== UnknownData);
+		const logFn = createLoggingFunction(id, nonStringArgs.map((e) => e.dataType), this.#dataBuffer, this.#indexBuffer, this.#options);
+		const argTypes = concreteArgs.map((e) => e.dataType === UnknownData ? e.value : e.dataType);
+		this.#logIdToMeta.set(id, {
+			op,
+			argTypes
+		});
+		return snip(stitch`${ctx.resolve(logFn).value}(${nonStringArgs})`, Void, "runtime");
+	}
+	get logResources() {
+		return this.#firstUnusedId === 1 ? void 0 : {
+			dataBuffer: this.#dataBuffer,
+			indexBuffer: this.#indexBuffer,
+			options: this.#options,
+			logIdToMeta: this.#logIdToMeta
+		};
+	}
+};
+//#endregion
+export { LogGeneratorImpl, LogGeneratorNullImpl };

package/tgsl/consoleLog/serializers.js

@@ -0,0 +1,223 @@
+import { getName } from "../../shared/meta.js";
+import { isWgslArray, isWgslStruct } from "../../data/wgslTypes.js";
+import { 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 { sizeOf } from "../../data/sizeOf.js";
+import { mat2x2f, mat3x3f, mat4x4f } from "../../data/matrix.js";
+import { fn } from "../../core/function/tgpuFn.js";
+import { slot } from "../../core/slot/slot.js";
+import { privateVar } from "../../core/variable/tgpuVariable.js";
+//#region src/tgsl/consoleLog/serializers.ts
+const dataBlockIndex = privateVar(u32, 0).$name("dataBlockIndex");
+const dataByteIndex = privateVar(u32, 0).$name("dataByteIndex");
+const dataBufferSlot = slot().$name("dataBuffer");
+const nextByteIndex = fn([], u32)`() {
+  let i = dataByteIndex;
+  dataByteIndex = dataByteIndex + 1u;
+  return i;
+}`.$uses({ dataByteIndex }).$name("nextByteIndex");
+const nextU32 = "dataBuffer[dataBlockIndex].serializedData[nextByteIndex()]";
+const serializerMap = {
+	f32: fn([f32])`(n) {
+  ${nextU32} = bitcast<u32>(n);
+}`,
+	f16: fn([f16])`(n) {
+  ${nextU32} = pack2x16float(vec2f(f32(n), 0.0));
+}`,
+	i32: fn([i32])`(n) {
+  ${nextU32} = bitcast<u32>(n);
+}`,
+	u32: fn([u32])`(n) {
+  ${nextU32} = n;
+}`,
+	bool: fn([bool])`(b) {
+  ${nextU32} = u32(b);
+}`,
+	vec2f: fn([vec2f])`(v) {
+  ${nextU32} = bitcast<u32>(v.x);
+  ${nextU32} = bitcast<u32>(v.y);
+}`,
+	vec3f: fn([vec3f])`(v) {
+  ${nextU32} = bitcast<u32>(v.x);
+  ${nextU32} = bitcast<u32>(v.y);
+  ${nextU32} = bitcast<u32>(v.z);
+}`,
+	vec4f: fn([vec4f])`(v) {
+  ${nextU32} = bitcast<u32>(v.x);
+  ${nextU32} = bitcast<u32>(v.y);
+  ${nextU32} = bitcast<u32>(v.z);
+  ${nextU32} = bitcast<u32>(v.w);
+}`,
+	vec2h: fn([vec2h])`(v) {
+  ${nextU32} = pack2x16float(vec2f(f32(v.x), f32(v.y)));
+}`,
+	vec3h: fn([vec3h])`(v) {
+  ${nextU32} = pack2x16float(vec2f(f32(v.x), f32(v.y)));
+  ${nextU32} = pack2x16float(vec2f(f32(v.z), 0.0));
+}`,
+	vec4h: fn([vec4h])`(v) {
+  ${nextU32} = pack2x16float(vec2f(f32(v.x), f32(v.y)));
+  ${nextU32} = pack2x16float(vec2f(f32(v.z), f32(v.w)));
+}`,
+	vec2i: fn([vec2i])`(v) {
+  ${nextU32} = bitcast<u32>(v.x);
+  ${nextU32} = bitcast<u32>(v.y);
+}`,
+	vec3i: fn([vec3i])`(v) {
+  ${nextU32} = bitcast<u32>(v.x);
+  ${nextU32} = bitcast<u32>(v.y);
+  ${nextU32} = bitcast<u32>(v.z);
+}`,
+	vec4i: fn([vec4i])`(v) {
+  ${nextU32} = bitcast<u32>(v.x);
+  ${nextU32} = bitcast<u32>(v.y);
+  ${nextU32} = bitcast<u32>(v.z);
+  ${nextU32} = bitcast<u32>(v.w);
+}`,
+	vec2u: fn([vec2u])`(v) {
+  ${nextU32} = v.x;
+  ${nextU32} = v.y;
+}`,
+	vec3u: fn([vec3u])`(v) {
+  ${nextU32} = v.x;
+  ${nextU32} = v.y;
+  ${nextU32} = v.z;
+}`,
+	vec4u: fn([vec4u])`(v) {
+  ${nextU32} = v.x;
+  ${nextU32} = v.y;
+  ${nextU32} = v.z;
+  ${nextU32} = v.w;
+}`,
+	"vec2<bool>": fn([vec2b])`(v) {
+  ${nextU32} = u32(v.x);
+  ${nextU32} = u32(v.y);
+}`,
+	"vec3<bool>": fn([vec3b])`(v) {
+  ${nextU32} = u32(v.x);
+  ${nextU32} = u32(v.y);
+  ${nextU32} = u32(v.z);
+}`,
+	"vec4<bool>": fn([vec4b])`(v) {
+  ${nextU32} = u32(v.x);
+  ${nextU32} = u32(v.y);
+  ${nextU32} = u32(v.z);
+  ${nextU32} = u32(v.w);
+}`,
+	mat2x2f: fn([mat2x2f])`(m) {
+  ${nextU32} = bitcast<u32>(m[0][0]);
+  ${nextU32} = bitcast<u32>(m[0][1]);
+  ${nextU32} = bitcast<u32>(m[1][0]);
+  ${nextU32} = bitcast<u32>(m[1][1]);
+}`,
+	mat3x3f: fn([mat3x3f])`(m) {
+  ${nextU32} = bitcast<u32>(m[0][0]);
+  ${nextU32} = bitcast<u32>(m[0][1]);
+  ${nextU32} = bitcast<u32>(m[0][2]);
+  ${nextU32} = 0u;
+  ${nextU32} = bitcast<u32>(m[1][0]);
+  ${nextU32} = bitcast<u32>(m[1][1]);
+  ${nextU32} = bitcast<u32>(m[1][2]);
+  ${nextU32} = 0u;
+  ${nextU32} = bitcast<u32>(m[2][0]);
+  ${nextU32} = bitcast<u32>(m[2][1]);
+  ${nextU32} = bitcast<u32>(m[2][2]);
+  ${nextU32} = 0u;
+}`,
+	mat4x4f: fn([mat4x4f])`(m) {
+  ${nextU32} = bitcast<u32>(m[0][0]);
+  ${nextU32} = bitcast<u32>(m[0][1]);
+  ${nextU32} = bitcast<u32>(m[0][2]);
+  ${nextU32} = bitcast<u32>(m[0][3]);
+  ${nextU32} = bitcast<u32>(m[1][0]);
+  ${nextU32} = bitcast<u32>(m[1][1]);
+  ${nextU32} = bitcast<u32>(m[1][2]);
+  ${nextU32} = bitcast<u32>(m[1][3]);
+  ${nextU32} = bitcast<u32>(m[2][0]);
+  ${nextU32} = bitcast<u32>(m[2][1]);
+  ${nextU32} = bitcast<u32>(m[2][2]);
+  ${nextU32} = bitcast<u32>(m[2][3]);
+  ${nextU32} = bitcast<u32>(m[3][0]);
+  ${nextU32} = bitcast<u32>(m[3][1]);
+  ${nextU32} = bitcast<u32>(m[3][2]);
+  ${nextU32} = bitcast<u32>(m[3][3]);
+}`
+};
+for (const [name, serializer] of Object.entries(serializerMap)) serializer.$name(`serialize${name[0].toLocaleUpperCase()}${name.slice(1)}`).$uses({
+	dataBlockIndex,
+	nextByteIndex,
+	dataBuffer: dataBufferSlot
+});
+function generateHeader(argTypes) {
+	return `(${argTypes.map((_, i) => `_arg_${i}`).join(", ")})`;
+}
+/**
+* Returns a serializer TGPU function for a given WGSL data type.
+* If the data type is a base type, one of the preexisting functions (with the `dataBufferSlot` filled) is returned.
+* Otherwise, a new function is generated.
+*
+* @param dataType - The WGSL data type descriptor to return a serializer for
+* @param dataBuffer - A buffer to store serialized log call data (a necessary external for the returned function)
+*/
+function getSerializer(dataType, dataBuffer) {
+	const maybeSerializer = serializerMap[dataType.type];
+	if (maybeSerializer) return maybeSerializer.with(dataBufferSlot, dataBuffer);
+	if (isWgslStruct(dataType)) {
+		const props = Object.keys(dataType.propTypes);
+		const propsSerializer = createCompoundSerializer(Object.values(dataType.propTypes), dataBuffer);
+		return fn([dataType])`(arg) {\n  propsSerializer(${props.map((prop) => `arg.${prop}`).join(", ")});\n}`.$uses({ propsSerializer }).$name(`${getName(dataType) ?? "struct"}Serializer`);
+	}
+	if (isWgslArray(dataType)) {
+		const elementType = dataType.elementType;
+		const length = dataType.elementCount;
+		const elementSerializer = getSerializer(elementType, dataBuffer);
+		return fn([dataType])`(arg) {\n${Array.from({ length }, (_, i) => `  elementSerializer(arg[${i}]);`).join("\n")}\n}`.$uses({ elementSerializer }).$name("arraySerializer");
+	}
+	throw new Error(`Cannot serialize data of type ${dataType.type}`);
+}
+/**
+* Creates a compound serializer TGPU function that serializes multiple arguments of different types to the data buffer.
+*
+* @param dataTypes - Array of WGSL data types that define the types of arguments to be serialized
+* @param dataBuffer - A buffer to store serialized log call data (a necessary external for the returned function)
+*/
+function createCompoundSerializer(dataTypes, dataBuffer) {
+	const usedSerializers = {};
+	return fn(dataTypes)`${generateHeader(dataTypes)} {\n${dataTypes.map((arg, i) => {
+		usedSerializers[`serializer${i}`] = getSerializer(arg, dataBuffer);
+		return `  serializer${i}(_arg_${i});`;
+	}).join("\n")}\n}`.$uses(usedSerializers).$name("compoundSerializer");
+}
+/**
+* Creates a TGPU function that serializes data to the log buffer.
+*
+* @param id - Identifier for this logging function instance
+* @param dataTypes - Array of WGSL data types that will be logged by this function
+* @param dataBuffer - Mutable buffer array to store serialized log call data
+* @param indexBuffer - Atomic counter buffer to track the next available log data slot
+* @param logOptions - Configuration options
+*/
+function createLoggingFunction(id, dataTypes, dataBuffer, indexBuffer, logOptions) {
+	const serializedSize = dataTypes.map(sizeOf).reduce((a, b) => a + b, 0);
+	if (serializedSize > logOptions.logSizeLimit) throw new Error(`Logged data needs to fit in ${logOptions.logSizeLimit} bytes (one of the logs requires ${serializedSize} bytes). Consider increasing the limit by passing appropriate options to tgpu.init().`);
+	const compoundSerializer = createCompoundSerializer(dataTypes, dataBuffer).$name(`log${id}serializer`);
+	const header = generateHeader(dataTypes);
+	return fn(dataTypes)`${header} {
+  dataBlockIndex = atomicAdd(&indexBuffer, 1);
+  if (dataBlockIndex >= ${logOptions.logCountLimit}) {
+    return;
+  }
+  dataBuffer[dataBlockIndex].id = ${id};
+  dataByteIndex = 0;
+
+  compoundSerializer${header};
+}`.$uses({
+		indexBuffer,
+		dataBuffer,
+		dataBlockIndex,
+		dataByteIndex,
+		compoundSerializer
+	}).$name(`log${id}`);
+}
+//#endregion
+export { createLoggingFunction };

package/tgsl/consoleLog/types.d.ts

@@ -0,0 +1,52 @@
+import { TgpuMutable } from "../../core/buffer/bufferShorthand.js";
+import { AnyWgslData, Atomic, U32, WgslArray, WgslStruct } from "../../data/wgslTypes.js";
+
+//#region src/tgsl/consoleLog/types.d.ts
+/**
+ * Options for configuring GPU log generation.
+ */
+interface LogGeneratorOptions {
+  /**
+   * The maximum number of logs that appear during a single draw/dispatch call.
+   * If this number is exceeded, a warning containing the total number of calls is logged and further logs are dropped.
+   * @default 64
+   */
+  logCountLimit?: number;
+  /**
+   * The total number of bytes reserved for each log call.
+   * If this number is exceeded, an exception is thrown during resolution.
+   * @default 252
+   */
+  logSizeLimit?: number;
+  /**
+   * The prefix attached to each log call.
+   * @default ' GPU '
+   */
+  messagePrefix?: string;
+}
+type SerializedLogCallData = WgslStruct<{
+  id: U32;
+  serializedData: WgslArray<U32>;
+}>;
+interface LogMeta {
+  op: SupportedLogOps;
+  argTypes: (string | AnyWgslData)[];
+}
+/**
+ * The resources required for logging via console.log within TypeGPU functions.
+ *
+ * @property indexBuffer - A buffer used for indexing log entries. Needs to be cleared after each dispatch/draw.
+ * @property dataBuffer - A buffer containing an array of serialized log call data.
+ * @property options - The configuration options for the LogGenerator.
+ * @property logIdToMeta - A mapping from log identifiers to an object containing the corresponding log op and argument types.
+ */
+interface LogResources {
+  indexBuffer: TgpuMutable<Atomic<U32>>;
+  dataBuffer: TgpuMutable<WgslArray<SerializedLogCallData>>;
+  options: Required<LogGeneratorOptions>;
+  logIdToMeta: Map<number, LogMeta>;
+}
+declare const supportedLogOps: readonly ["log", "debug", "info", "warn", "error", "clear"];
+type SupportedLogOps = (typeof supportedLogOps)[number];
+//#endregion
+export { LogGeneratorOptions, LogResources };

package/tgsl/consoleLog/types.js

@@ -0,0 +1,11 @@
+//#region src/tgsl/consoleLog/types.ts
+const supportedLogOps = [
+	"log",
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"clear"
+];
+//#endregion
+export { supportedLogOps };