typegpu 0.11.9 → 0.12.1

package/tgsl/consoleLog/deserializers.js

@@ -1,117 +1,133 @@
-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 { f32, i32, u32 } from "../../data/numeric.js";
+import { sizeOf } from "../../data/sizeOf.js";
+import { vec2b, vec2f, vec2h, vec2i, vec2u, vec3b, vec3f, vec3h, vec3i, vec3u, vec4b, vec4f, vec4h, vec4i, vec4u, } from "../../data/vector.js";
+import { isWgslArray, isWgslData, isWgslStruct, } from "../../data/wgslTypes.js";
+import { niceStringify } from "../../shared/stringify.js";
+import { bitcast } 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);
+import { logger } from "../../tgpuLogger.js";
+const toF = (n) => bitcast(u32, f32)(n ?? 0);
+const toI = (n) => bitcast(u32, i32)(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]))
+    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) => 
+    // oxfmt-ignore
+    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) => 
+    // oxfmt-ignore
+    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])),
 };
+// -------
+// Helpers
+// -------
 /**
-* 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
-*/
+ * 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}`);
+    const maybeDeserializer = deserializerMap[dataType.type];
+    if (maybeDeserializer) {
+        return maybeDeserializer(data);
+    }
+    if (isWgslStruct(dataType)) {
+        const props = Object.keys(dataType.propTypes);
+        const propTypes = Object.values(dataType.propTypes);
+        const decodedProps = deserializeCompound(data, propTypes);
+        return Object.fromEntries(props.map((key, index) => [key, decodedProps[index]]));
+    }
+    if (isWgslArray(dataType)) {
+        const elementType = dataType.elementType;
+        const length = dataType.elementCount;
+        const result = deserializeCompound(data, Array.from({ length }, () => elementType));
+        return result;
+    }
+    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
-*/
+ * 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;
-	});
+    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);
+export 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("");
-			op.bind(console)(`%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();
+ * 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.
+ */
+export function logDataFromGPU(resources) {
+    const { indexBuffer, dataBuffer, logIdToMeta, options } = resources;
+    void 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('');
+            }
+            op.bind(console)(`%c${options.messagePrefix}%c ${results[0]}`, 'background: #936ff5; color: white;', 'color: inherit; background: none', ...results.slice(1));
+        });
+    });
+    void indexBuffer.read().then((totalCalls) => {
+        if (totalCalls > options.logCountLimit) {
+            logger.warn('log-limit-exceeded', `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.d.ts

@@ -0,0 +1,21 @@
+import type { TgpuRoot } from '../../core/root/rootTypes.ts';
+import { type Snippet } from '../../data/snippet.ts';
+import type { ResolutionCtx } from '../../internal.ts';
+import { type LogGenerator, type LogResources, type SupportedLogOp } from './types.ts';
+export declare class LogGeneratorNullImpl implements LogGenerator {
+    get logResources(): undefined;
+    generateLog(): Snippet;
+}
+export declare class LogGeneratorImpl implements LogGenerator {
+    #private;
+    constructor(root: TgpuRoot);
+    /**
+     * 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: ResolutionCtx, op: SupportedLogOp, args: Snippet[]): Snippet;
+    get logResources(): LogResources | undefined;
+}

package/tgsl/consoleLog/logGenerator.js

@@ -1,88 +1,93 @@
-import { $internal } from "../../shared/symbols.js";
-import { Void } from "../../data/wgslTypes.js";
+import { stitch } from "../../core/resolve/stitch.js";
+import { shaderStageSlot } from "../../core/slot/internalSlots.js";
+import { arrayOf } from "../../data/array.js";
+import { atomic } from "../../data/atomic.js";
 import { UnknownData, unptr } from "../../data/dataTypes.js";
+import { u32 } from "../../data/numeric.js";
 import { snip } from "../../data/snippet.js";
+import { struct } from "../../data/struct.js";
+import { Void, } from "../../data/wgslTypes.js";
 import { invariant } from "../../errors.js";
-import { stitch } from "../../core/resolve/stitch.js";
+import { $internal } from "../../shared/symbols.js";
+import { logger } from "../../tgpuLogger.js";
 import { convertToCommonType } from "../conversion.js";
-import { u32 } from "../../data/numeric.js";
 import { concretizeSnippet } 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";
-
-//#region src/tgsl/consoleLog/logGenerator.ts
+import {} from "./types.js";
 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' operations are not supported in vertex shaders.`);
-			return fallbackSnippet;
-		}
-		const id = this.#firstUnusedId++;
-		const concreteArgsWithStrings = args.map((arg) => {
-			if (arg.dataType === UnknownData) return arg;
-			const converted = convertToCommonType(ctx, [arg], [unptr(arg.dataType)])?.[0];
-			invariant(converted, `Internal error. Expected type ${arg.dataType} to be convertible to ${unptr(arg.dataType)}`);
-			return converted;
-		}).map(concretizeSnippet);
-		const concreteArgs = concreteArgsWithStrings.filter((arg) => arg.dataType !== UnknownData);
-		const logFn = createLoggingFunction(id, concreteArgs.map((e) => e.dataType), this.#dataBuffer, this.#indexBuffer, this.#options);
-		const functionSnippet = snip(stitch`${ctx.resolve(logFn).value}(${concreteArgs})`, Void, "runtime");
-		this.#logIdToMeta.set(id, {
-			op,
-			argTypes: concreteArgsWithStrings.map((e) => e?.dataType === UnknownData ? e?.value : e?.dataType)
-		});
-		return functionSnippet;
-	}
-	get logResources() {
-		return this.#firstUnusedId === 1 ? void 0 : {
-			dataBuffer: this.#dataBuffer,
-			indexBuffer: this.#indexBuffer,
-			options: this.#options,
-			logIdToMeta: this.#logIdToMeta
-		};
-	}
+    logCountLimit: 64,
+    logSizeLimit: 252,
+    messagePrefix: ' GPU ',
 };
-
-//#endregion
-export { LogGeneratorImpl, LogGeneratorNullImpl };
+const fallbackSnippet = snip('/* console.log() */', Void, /* origin */ 'runtime');
+export class LogGeneratorNullImpl {
+    get logResources() {
+        return undefined;
+    }
+    generateLog() {
+        logger.warn('fallback', "'console.log' is only supported when resolving pipelines.");
+        return fallbackSnippet;
+    }
+}
+export class LogGeneratorImpl {
+    #options;
+    #logIdToMeta;
+    #firstUnusedId = 1;
+    #indexBuffer;
+    #dataBuffer;
+    constructor(root) {
+        this.#options = { ...defaultOptions, ...root[$internal].logOptions };
+        this.#logIdToMeta = 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') {
+            logger.warn('suspicious', `'console' operations are not supported in vertex shaders.`);
+            return fallbackSnippet;
+        }
+        const id = this.#firstUnusedId++;
+        const concreteArgsWithStrings = args
+            .map((arg) => {
+            if (arg.dataType === UnknownData) {
+                return arg;
+            }
+            const converted = convertToCommonType(ctx, [arg], [unptr(arg.dataType)])?.[0];
+            invariant(converted, `Internal error. Expected type ${arg.dataType} to be convertible to ${unptr(arg.dataType)}`);
+            return converted;
+        })
+            .map(concretizeSnippet);
+        const concreteArgs = concreteArgsWithStrings.filter((arg) => arg.dataType !== UnknownData);
+        const logFn = createLoggingFunction(id, concreteArgs.map((e) => e.dataType), this.#dataBuffer, this.#indexBuffer, this.#options);
+        const functionSnippet = snip(stitch `${ctx.resolve(logFn).value}(${concreteArgs})`, Void, 
+        /* origin */ 'runtime');
+        this.#logIdToMeta.set(id, {
+            op,
+            argTypes: concreteArgsWithStrings.map((e) => e?.dataType === UnknownData ? e?.value : e?.dataType),
+        });
+        return functionSnippet;
+    }
+    get logResources() {
+        return this.#firstUnusedId === 1
+            ? undefined
+            : {
+                dataBuffer: this.#dataBuffer,
+                indexBuffer: this.#indexBuffer,
+                options: this.#options,
+                logIdToMeta: this.#logIdToMeta,
+            };
+    }
+}

package/tgsl/consoleLog/serializers.d.ts

@@ -0,0 +1,21 @@
+import type { TgpuMutable } from '../../core/buffer/bufferBinding.ts';
+import { type TgpuFn } from '../../core/function/tgpuFn.ts';
+import { type AnyWgslData, type Atomic, type U32, type Void, type WgslArray } from '../../data/wgslTypes.ts';
+import type { LogGeneratorOptions, SerializedLogCallData } from './types.ts';
+type SerializerMap = {
+    [K in AnyWgslData['type']]?: TgpuFn<(args_0: Extract<AnyWgslData, {
+        type: K;
+    }>) => Void>;
+};
+export declare const serializerMap: SerializerMap;
+/**
+ * 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
+ */
+export declare function createLoggingFunction(id: number, dataTypes: AnyWgslData[], dataBuffer: TgpuMutable<WgslArray<SerializedLogCallData>>, indexBuffer: TgpuMutable<Atomic<U32>>, logOptions: Required<LogGeneratorOptions>): TgpuFn;
+export {};