typegpu 0.11.9 → 0.12.1

package/tgsl/consoleLog/serializers.js

@@ -1,117 +1,117 @@
-import { isWgslArray, isWgslStruct } from "../../data/wgslTypes.js";
-import { getName } from "../../shared/meta.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)`() {
+import { mat2x2f, mat3x3f, mat4x4f } from "../../data/matrix.js";
+import { bool, f16, 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, isWgslStruct, } from "../../data/wgslTypes.js";
+import { getName } from "../../shared/meta.js";
+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) {
+}`
+    .$uses({ dataByteIndex })
+    .$name('nextByteIndex');
+const nextU32 = 'dataBuffer[dataBlockIndex].serializedData[nextByteIndex()]';
+export const serializerMap = {
+    f32: fn([f32]) `(n) {
   ${nextU32} = bitcast<u32>(n);
 }`,
-	f16: fn([f16])`(n) {
+    f16: fn([f16]) `(n) {
   ${nextU32} = pack2x16float(vec2f(f32(n), 0.0));
 }`,
-	i32: fn([i32])`(n) {
+    i32: fn([i32]) `(n) {
   ${nextU32} = bitcast<u32>(n);
 }`,
-	u32: fn([u32])`(n) {
+    u32: fn([u32]) `(n) {
   ${nextU32} = n;
 }`,
-	bool: fn([bool])`(b) {
+    bool: fn([bool]) `(b) {
   ${nextU32} = u32(b);
 }`,
-	vec2f: fn([vec2f])`(v) {
+    vec2f: fn([vec2f]) `(v) {
   ${nextU32} = bitcast<u32>(v.x);
   ${nextU32} = bitcast<u32>(v.y);
 }`,
-	vec3f: fn([vec3f])`(v) {
+    vec3f: fn([vec3f]) `(v) {
   ${nextU32} = bitcast<u32>(v.x);
   ${nextU32} = bitcast<u32>(v.y);
   ${nextU32} = bitcast<u32>(v.z);
 }`,
-	vec4f: fn([vec4f])`(v) {
+    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) {
+    vec2h: fn([vec2h]) `(v) {
   ${nextU32} = pack2x16float(vec2f(f32(v.x), f32(v.y)));
 }`,
-	vec3h: fn([vec3h])`(v) {
+    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) {
+    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) {
+    vec2i: fn([vec2i]) `(v) {
   ${nextU32} = bitcast<u32>(v.x);
   ${nextU32} = bitcast<u32>(v.y);
 }`,
-	vec3i: fn([vec3i])`(v) {
+    vec3i: fn([vec3i]) `(v) {
   ${nextU32} = bitcast<u32>(v.x);
   ${nextU32} = bitcast<u32>(v.y);
   ${nextU32} = bitcast<u32>(v.z);
 }`,
-	vec4i: fn([vec4i])`(v) {
+    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) {
+    vec2u: fn([vec2u]) `(v) {
   ${nextU32} = v.x;
   ${nextU32} = v.y;
 }`,
-	vec3u: fn([vec3u])`(v) {
+    vec3u: fn([vec3u]) `(v) {
   ${nextU32} = v.x;
   ${nextU32} = v.y;
   ${nextU32} = v.z;
 }`,
-	vec4u: fn([vec4u])`(v) {
+    vec4u: fn([vec4u]) `(v) {
   ${nextU32} = v.x;
   ${nextU32} = v.y;
   ${nextU32} = v.z;
   ${nextU32} = v.w;
 }`,
-	"vec2<bool>": fn([vec2b])`(v) {
+    'vec2<bool>': fn([vec2b]) `(v) {
   ${nextU32} = u32(v.x);
   ${nextU32} = u32(v.y);
 }`,
-	"vec3<bool>": fn([vec3b])`(v) {
+    'vec3<bool>': fn([vec3b]) `(v) {
   ${nextU32} = u32(v.x);
   ${nextU32} = u32(v.y);
   ${nextU32} = u32(v.z);
 }`,
-	"vec4<bool>": fn([vec4b])`(v) {
+    '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) {
+    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) {
+    mat3x3f: fn([mat3x3f]) `(m) {
   ${nextU32} = bitcast<u32>(m[0][0]);
   ${nextU32} = bitcast<u32>(m[0][1]);
   ${nextU32} = bitcast<u32>(m[0][2]);
@@ -125,7 +125,7 @@ const serializerMap = {
   ${nextU32} = bitcast<u32>(m[2][2]);
   ${nextU32} = 0u;
 }`,
-	mat4x4f: fn([mat4x4f])`(m) {
+    mat4x4f: fn([mat4x4f]) `(m) {
   ${nextU32} = bitcast<u32>(m[0][0]);
   ${nextU32} = bitcast<u32>(m[0][1]);
   ${nextU32} = bitcast<u32>(m[0][2]);
@@ -142,68 +142,88 @@ const serializerMap = {
   ${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
-});
+// rename the functions and add externals
+for (const [name, serializer] of Object.entries(serializerMap)) {
+    serializer
+        .$name(`serialize${name[0].toLocaleUpperCase()}${name.slice(1)}`)
+        .$uses({ dataBlockIndex, nextByteIndex, dataBuffer: dataBufferSlot });
+}
+// -------
+// Helpers
+// -------
 function generateHeader(argTypes) {
-	return `(${argTypes.map((_, i) => `_arg_${i}`).join(", ")})`;
+    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)
-*/
+ * 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}`);
+    const maybeSerializer = serializerMap[dataType.type];
+    if (maybeSerializer) {
+        return maybeSerializer.with(dataBufferSlot, dataBuffer);
+    }
+    if (isWgslStruct(dataType)) {
+        const props = Object.keys(dataType.propTypes);
+        const propTypes = Object.values(dataType.propTypes);
+        const propsSerializer = createCompoundSerializer(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)
-*/
+ * 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");
+    const usedSerializers = {};
+    const shell = fn(dataTypes);
+    const header = generateHeader(dataTypes);
+    const body = dataTypes
+        .map((arg, i) => {
+        usedSerializers[`serializer${i}`] = getSerializer(arg, dataBuffer);
+        return `  serializer${i}(_arg_${i});`;
+    })
+        .join('\n');
+    return shell `${header} {\n${body}\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} {
+ * 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 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;
@@ -212,14 +232,13 @@ function createLoggingFunction(id, dataTypes, dataBuffer, indexBuffer, logOption
   dataByteIndex = 0;
 
   compoundSerializer${header};
-}`.$uses({
-		indexBuffer,
-		dataBuffer,
-		dataBlockIndex,
-		dataByteIndex,
-		compoundSerializer
-	}).$name(`log${id}`);
+}`
+        .$uses({
+        indexBuffer,
+        dataBuffer,
+        dataBlockIndex,
+        dataByteIndex,
+        compoundSerializer,
+    })
+        .$name(`log${id}`);
 }
-
-//#endregion
-export { createLoggingFunction };

package/tgsl/consoleLog/types.d.ts

@@ -1,40 +1,39 @@
-import "../../data/snippet.js";
-import { TgpuMutable } from "../../core/buffer/bufferShorthand.js";
-import "../generationHelpers.js";
-import { supportedLogOps } from "../jsPolyfills.js";
-import { AnyWgslData, Atomic, U32, WgslArray, WgslStruct } from "../../data/wgslTypes.js";
-
-//#region src/tgsl/consoleLog/types.d.ts
-type SupportedLogOp = ReturnType<typeof supportedLogOps>[number];
+import type { TgpuMutable } from '../../core/buffer/bufferBinding.ts';
+import type { Snippet } from '../../data/snippet.ts';
+import type { AnyWgslData, Atomic, U32, WgslArray, WgslStruct } from '../../data/wgslTypes.ts';
+import type { ResolutionCtx } from '../../types.ts';
+import type { supportedLogOps } from '../jsPolyfills.ts';
+export type SupportedLogOp = ReturnType<typeof supportedLogOps>[number];
 /**
  * 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;
+export 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.
+     * Draws and dispatches recorded into a shared command encoder count against a single limit for the whole submission.
+     * @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>;
+export type SerializedLogCallData = WgslStruct<{
+    id: U32;
+    serializedData: WgslArray<U32>;
 }>;
-interface LogMeta {
-  op: SupportedLogOp;
-  argTypes: (string | AnyWgslData)[];
+export interface LogMeta {
+    op: SupportedLogOp;
+    argTypes: (string | AnyWgslData)[];
 }
 /**
  * The resources required for logging via console.log within TypeGPU functions.
@@ -44,11 +43,13 @@ interface LogMeta {
  * @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>;
+export interface LogResources {
+    indexBuffer: TgpuMutable<Atomic<U32>>;
+    dataBuffer: TgpuMutable<WgslArray<SerializedLogCallData>>;
+    options: Required<LogGeneratorOptions>;
+    logIdToMeta: Map<number, LogMeta>;
+}
+export interface LogGenerator {
+    generateLog(ctx: ResolutionCtx, op: SupportedLogOp, args: Snippet[]): Snippet;
+    get logResources(): LogResources | undefined;
 }
-//#endregion
-export { LogGeneratorOptions, LogResources, SupportedLogOp };

package/tgsl/consoleLog/types.js

@@ -0,0 +1 @@
+export {};

package/tgsl/conversion.d.ts

@@ -0,0 +1,33 @@
+import { UnknownData } from '../data/dataTypes.ts';
+import { type Snippet } from '../data/snippet.ts';
+import { type BaseData, type F16, type F32, type I32, type U32, type WgslStruct } from '../data/wgslTypes.ts';
+import type { ResolutionCtx } from '../types.ts';
+type ConversionAction = 'ref' | 'deref' | 'cast' | 'none';
+export type ConversionResultAction = {
+    sourceIndex: number;
+    action: ConversionAction;
+    targetType?: U32 | F32 | I32 | F16;
+};
+export type ConversionResult = {
+    targetType: BaseData;
+    actions: ConversionResultAction[];
+    hasImplicitConversions?: boolean;
+};
+export declare function getBestConversion(types: BaseData[], targetTypes?: BaseData[]): ConversionResult | undefined;
+/**
+ * Unifies input types to a common type.
+ */
+export declare function unify<T extends (BaseData | UnknownData)[] | []>(inTypes: T, restrictTo?: BaseData[]): {
+    [K in keyof T]: BaseData;
+} | undefined;
+/**
+ * Unifies input types to a common type.
+ * Unlike `unify`, it does not allow implicit conversions.
+ */
+export declare function unifyStrict<T extends (BaseData | UnknownData)[] | []>(inTypes: T, restrictTo?: BaseData[]): {
+    [K in keyof T]: BaseData;
+} | undefined;
+export declare function convertToCommonType<T extends Snippet[]>(ctx: ResolutionCtx, values: T, restrictTo?: BaseData[], verbose?: boolean): T | undefined;
+export declare function tryConvertSnippet(ctx: ResolutionCtx, snippet: Snippet, targetDataTypes: BaseData | BaseData[], verbose?: boolean): Snippet;
+export declare function convertStructValues(ctx: ResolutionCtx, structType: WgslStruct, values: Record<string, Snippet>): Snippet[];
+export {};