typegpu 0.11.8 → 0.12.0

package/data/attributes.js

@@ -1,147 +1,207 @@
 import { $internal } from "../shared/symbols.js";
-import { isAlignAttrib, isBuiltinAttrib, isDecorated, isSizeAttrib, isWgslData } from "./wgslTypes.js";
-import { isLooseData, isLooseDecorated } from "./dataTypes.js";
+import { $gpuRepr, $inRepr, $invalidSchemaReason, $memIdent, $repr, $reprPartial, $reprPatch, $validStorageSchema, $validUniformSchema, $validVertexSchema, } from "../shared/symbols.js";
 import { alignmentOf } from "./alignmentOf.js";
+import { isLooseData, isLooseDecorated, } from "./dataTypes.js";
 import { sizeOf } from "./sizeOf.js";
-
-//#region src/data/attributes.ts
-function attribute(data, attrib) {
-	if (isDecorated(data)) return new DecoratedImpl(data.inner, [attrib, ...data.attribs]);
-	if (isLooseDecorated(data)) return new LooseDecoratedImpl(data.inner, [attrib, ...data.attribs]);
-	if (isLooseData(data)) return new LooseDecoratedImpl(data, [attrib]);
-	return new DecoratedImpl(data, [attrib]);
+import { isAlignAttrib, isBuiltinAttrib, isDecorated, isSizeAttrib, isWgslData, } from "./wgslTypes.js";
+// ----------
+// Public API
+// ----------
+export const builtinNames = [
+    'vertex_index',
+    'instance_index',
+    'clip_distances',
+    'position',
+    'front_facing',
+    'frag_depth',
+    'primitive_index',
+    'sample_index',
+    'sample_mask',
+    'fragment',
+    'local_invocation_id',
+    'local_invocation_index',
+    'global_invocation_id',
+    'global_invocation_index',
+    'workgroup_id',
+    'workgroup_index',
+    'num_workgroups',
+    'subgroup_invocation_id',
+    'subgroup_size',
+    'subgroup_id',
+    'num_subgroups',
+];
+export function attribute(data, attrib) {
+    if (isDecorated(data)) {
+        return new DecoratedImpl(data.inner, [attrib, ...data.attribs]);
+    }
+    if (isLooseDecorated(data)) {
+        return new LooseDecoratedImpl(data.inner, [attrib, ...data.attribs]);
+    }
+    if (isLooseData(data)) {
+        return new LooseDecoratedImpl(data, [attrib]);
+    }
+    return new DecoratedImpl(data, [attrib]);
 }
 /**
-* Gives the wrapped data-type a custom byte alignment. Useful in order to
-* fulfill uniform alignment requirements.
-*
-* @example
-* const Data = d.struct({
-*   a: u32, // takes up 4 bytes
-*   // 12 bytes of padding, because `b` is custom aligned to multiples of 16 bytes
-*   b: d.align(16, u32),
-* });
-*
-* @param alignment The multiple of bytes this data should align itself to.
-* @param data The data-type to align.
-*/
-function align(alignment, data) {
-	return attribute(data, {
-		[$internal]: true,
-		type: "@align",
-		params: [alignment]
-	});
+ * Gives the wrapped data-type a custom byte alignment. Useful in order to
+ * fulfill uniform alignment requirements.
+ *
+ * @example
+ * const Data = d.struct({
+ *   a: u32, // takes up 4 bytes
+ *   // 12 bytes of padding, because `b` is custom aligned to multiples of 16 bytes
+ *   b: d.align(16, u32),
+ * });
+ *
+ * @param alignment The multiple of bytes this data should align itself to.
+ * @param data The data-type to align.
+ */
+export function align(alignment, data) {
+    return attribute(data, {
+        [$internal]: true,
+        type: '@align',
+        params: [alignment],
+        // oxlint-disable-next-line typescript/no-explicit-any -- tired of lying to types
+    });
 }
 /**
-* Adds padding bytes after the wrapped data-type, until the whole value takes up `size` bytes.
-*
-* @example
-* const Data = d.struct({
-*   a: d.size(16, u32), // takes up 16 bytes, instead of 4
-*   b: u32, // starts at byte 16, because `a` has a custom size
-* });
-*
-* @param size The amount of bytes that should be reserved for this data-type.
-* @param data The data-type to wrap.
-*/
-function size(size$1, data) {
-	return attribute(data, {
-		[$internal]: true,
-		type: "@size",
-		params: [size$1]
-	});
+ * Adds padding bytes after the wrapped data-type, until the whole value takes up `size` bytes.
+ *
+ * @example
+ * const Data = d.struct({
+ *   a: d.size(16, u32), // takes up 16 bytes, instead of 4
+ *   b: u32, // starts at byte 16, because `a` has a custom size
+ * });
+ *
+ * @param size The amount of bytes that should be reserved for this data-type.
+ * @param data The data-type to wrap.
+ */
+export function size(size, data) {
+    return attribute(data, {
+        [$internal]: true,
+        type: '@size',
+        params: [size],
+        // oxlint-disable-next-line typescript/no-explicit-any -- tired of lying to types
+    });
 }
 /**
-* Assigns an explicit numeric location to a struct member or a parameter that has this type.
-*
-* @example
-* const VertexOutput = {
-*   a: d.u32, // has implicit location 0
-*   b: d.location(5, d.u32),
-*   c: d.u32, // has implicit location 6
-* };
-*
-* @param location The explicit numeric location.
-* @param data The data-type to wrap.
-*/
-function location(location$1, data) {
-	return attribute(data, {
-		[$internal]: true,
-		type: "@location",
-		params: [location$1]
-	});
+ * Assigns an explicit numeric location to a struct member or a parameter that has this type.
+ *
+ * @example
+ * const VertexOutput = {
+ *   a: d.u32, // has implicit location 0
+ *   b: d.location(5, d.u32),
+ *   c: d.u32, // has implicit location 6
+ * };
+ *
+ * @param location The explicit numeric location.
+ * @param data The data-type to wrap.
+ */
+export function location(location, data) {
+    return attribute(data, {
+        [$internal]: true,
+        type: '@location',
+        params: [location],
+        // oxlint-disable-next-line typescript/no-explicit-any -- tired of lying to types
+    });
 }
-function interpolate(interpolationType, data) {
-	return attribute(data, {
-		[$internal]: true,
-		type: "@interpolate",
-		params: [interpolationType]
-	});
+export function interpolate(interpolationType, data) {
+    return attribute(data, {
+        [$internal]: true,
+        type: '@interpolate',
+        params: [interpolationType],
+        // oxlint-disable-next-line typescript/no-explicit-any -- tired of lying to types
+    });
 }
 /**
-* Marks a position built-in output value as invariant in vertex shaders.
-* If the data and control flow match for two position outputs in different
-* entry points, then the result values are guaranteed to be the same.
-*
-* Must only be applied to the position built-in value.
-*
-* @example
-* const VertexOutput = {
-*   pos: d.invariant(d.builtin.position),
-* };
-*
-* @param data The position built-in data-type to mark as invariant.
-*/
-function invariant(data) {
-	if (!isBuiltin(data)) throw new Error("The @invariant attribute must only be applied to the position built-in value.");
-	const builtinAttrib = isDecorated(data) || isLooseDecorated(data) ? data.attribs.find(isBuiltinAttrib) : void 0;
-	if (!builtinAttrib || builtinAttrib.params[0] !== "position") throw new Error("The @invariant attribute must only be applied to the position built-in value.");
-	return attribute(data, {
-		[$internal]: true,
-		type: "@invariant",
-		params: []
-	});
+ * Marks a position built-in output value as invariant in vertex shaders.
+ * If the data and control flow match for two position outputs in different
+ * entry points, then the result values are guaranteed to be the same.
+ *
+ * Must only be applied to the position built-in value.
+ *
+ * @example
+ * const VertexOutput = {
+ *   pos: d.invariant(d.builtin.position),
+ * };
+ *
+ * @param data The position built-in data-type to mark as invariant.
+ */
+export function invariant(data) {
+    // Validate that invariant is only applied to position built-in
+    if (!isBuiltin(data)) {
+        throw new Error('The @invariant attribute must only be applied to the position built-in value.');
+    }
+    // Find the builtin attribute to check if it's position
+    const builtinAttrib = isDecorated(data) || isLooseDecorated(data) ? data.attribs.find(isBuiltinAttrib) : undefined;
+    if (!builtinAttrib || builtinAttrib.params[0] !== 'position') {
+        throw new Error('The @invariant attribute must only be applied to the position built-in value.');
+    }
+    return attribute(data, {
+        [$internal]: true,
+        type: '@invariant',
+        params: [],
+        // oxlint-disable-next-line typescript/no-explicit-any -- tired of lying to types
+    });
 }
-function isBuiltin(value) {
-	return (isDecorated(value) || isLooseDecorated(value)) && value.attribs.find(isBuiltinAttrib) !== void 0;
+export function isBuiltin(value) {
+    return ((isDecorated(value) || isLooseDecorated(value)) &&
+        value.attribs.find(isBuiltinAttrib) !== undefined);
 }
-function getAttributesString(field) {
-	if (!isDecorated(field) && !isLooseDecorated(field)) return "";
-	return field.attribs.map((attrib) => {
-		if (attrib.params.length === 0) return `${attrib.type} `;
-		return `${attrib.type}(${attrib.params.join(", ")}) `;
-	}).join("");
+export function getAttributesString(field) {
+    if (!isDecorated(field) && !isLooseDecorated(field)) {
+        return '';
+    }
+    return field.attribs
+        .map((attrib) => {
+        if (attrib.params.length === 0) {
+            return `${attrib.type} `;
+        }
+        return `${attrib.type}(${attrib.params.join(', ')}) `;
+    })
+        .join('');
+}
+// --------------
+// Implementation
+// --------------
+class BaseDecoratedImpl {
+    [$internal] = {};
+    inner;
+    attribs;
+    // ---
+    constructor(inner, attribs) {
+        this.inner = inner;
+        this.attribs = attribs;
+        const alignAttrib = attribs.find(isAlignAttrib)?.params[0];
+        const sizeAttrib = attribs.find(isSizeAttrib)?.params[0];
+        if (alignAttrib !== undefined) {
+            if (alignAttrib <= 0) {
+                throw new Error(`Custom data alignment must be a positive number, got: ${alignAttrib}.`);
+            }
+            if (Math.log2(alignAttrib) % 1 !== 0) {
+                throw new Error(`Alignment has to be a power of 2, got: ${alignAttrib}.`);
+            }
+            if (isWgslData(this.inner)) {
+                if (alignAttrib % alignmentOf(this.inner) !== 0) {
+                    throw new Error(`Custom alignment has to be a multiple of the standard data alignment. Got: ${alignAttrib}, expected multiple of: ${alignmentOf(this.inner)}.`);
+                }
+            }
+        }
+        if (sizeAttrib !== undefined) {
+            if (sizeAttrib < sizeOf(this.inner)) {
+                throw new Error(`Custom data size cannot be smaller then the standard data size. Got: ${sizeAttrib}, expected at least: ${sizeOf(this.inner)}.`);
+            }
+            if (sizeAttrib <= 0) {
+                throw new Error(`Custom data size must be a positive number. Got: ${sizeAttrib}.`);
+            }
+        }
+    }
+}
+class DecoratedImpl extends BaseDecoratedImpl {
+    [$internal] = {};
+    type = 'decorated';
+}
+class LooseDecoratedImpl extends BaseDecoratedImpl {
+    [$internal] = {};
+    type = 'loose-decorated';
 }
-var BaseDecoratedImpl = class {
-	[$internal] = {};
-	inner;
-	attribs;
-	constructor(inner, attribs) {
-		this.inner = inner;
-		this.attribs = attribs;
-		const alignAttrib = attribs.find(isAlignAttrib)?.params[0];
-		const sizeAttrib = attribs.find(isSizeAttrib)?.params[0];
-		if (alignAttrib !== void 0) {
-			if (alignAttrib <= 0) throw new Error(`Custom data alignment must be a positive number, got: ${alignAttrib}.`);
-			if (Math.log2(alignAttrib) % 1 !== 0) throw new Error(`Alignment has to be a power of 2, got: ${alignAttrib}.`);
-			if (isWgslData(this.inner)) {
-				if (alignAttrib % alignmentOf(this.inner) !== 0) throw new Error(`Custom alignment has to be a multiple of the standard data alignment. Got: ${alignAttrib}, expected multiple of: ${alignmentOf(this.inner)}.`);
-			}
-		}
-		if (sizeAttrib !== void 0) {
-			if (sizeAttrib < sizeOf(this.inner)) throw new Error(`Custom data size cannot be smaller then the standard data size. Got: ${sizeAttrib}, expected at least: ${sizeOf(this.inner)}.`);
-			if (sizeAttrib <= 0) throw new Error(`Custom data size must be a positive number. Got: ${sizeAttrib}.`);
-		}
-	}
-};
-var DecoratedImpl = class extends BaseDecoratedImpl {
-	[$internal] = {};
-	type = "decorated";
-};
-var LooseDecoratedImpl = class extends BaseDecoratedImpl {
-	[$internal] = {};
-	type = "loose-decorated";
-};
-
-//#endregion
-export { align, attribute, getAttributesString, interpolate, invariant, isBuiltin, location, size };

package/data/autoStruct.d.ts

@@ -1,3 +1,36 @@
-import "./snippet.js";
-import "../types.js";
-import "./wgslTypes.js";
+import { $internal, $repr, $resolve } from '../shared/symbols.ts';
+import type { ResolutionCtx, SelfResolvable } from '../types.ts';
+import type { ResolvedSnippet } from './snippet.ts';
+import type { BaseData, WgslStruct } from './wgslTypes.ts';
+/**
+ * A requirement for the generated struct is that non-builtin properties need to
+ * have the same name in WGSL as they do in JS. This allows locations to be properly
+ * matched between the Vertex output and Fragment input.
+ */
+export declare class AutoStruct implements BaseData, SelfResolvable {
+    #private;
+    [$internal]: Record<string, never>;
+    type: 'auto-struct';
+    readonly [$repr]: Record<string, unknown>;
+    constructor(validProps: Record<string, BaseData>, typeForExtraProps: BaseData | undefined, locations?: Record<string, number>);
+    /**
+     * Used for accessing builtins, varying and attributes in code.
+     */
+    accessProp(key: string): {
+        prop: string;
+        type: BaseData;
+    } | undefined;
+    /**
+     * Used for providing new varyings.
+     *
+     * @privateRemarks
+     * Internally used by `accessProp`.
+     */
+    provideProp(key: string, dataType: BaseData): {
+        prop: string;
+        type: BaseData;
+    };
+    get completeStruct(): WgslStruct<Record<string, BaseData>>;
+    [$resolve](ctx: ResolutionCtx): ResolvedSnippet;
+    toString(): string;
+}

package/data/autoStruct.js

@@ -1,84 +1,87 @@
-import { $internal, $resolve } from "../shared/symbols.js";
-import { getName, setName } from "../shared/meta.js";
-import { validateProp } from "../nameUtils.js";
 import { createIoSchema } from "../core/function/ioSchema.js";
-
-//#region src/data/autoStruct.ts
+import { validateProp } from "../nameUtils.js";
+import { getName, setName } from "../shared/meta.js";
+import { $internal, $repr, $resolve } from "../shared/symbols.js";
 /**
-* A requirement for the generated struct is that non-builtin properties need to
-* have the same name in WGSL as they do in JS. This allows locations to be properly
-* matched between the Vertex output and Fragment input.
-*/
-var AutoStruct = class {
-	/**
-	* js key -> data type
-	*/
-	#validProps;
-	/**
-	* js key -> { prop: 'wgsl key', type: ... }
-	* @example '$position' -> { prop: 'position', type: ... }
-	*/
-	#allocated;
-	#usedWgslKeys;
-	#locations;
-	#cachedStruct;
-	#typeForExtraProps;
-	constructor(validProps, typeForExtraProps, locations) {
-		this.#validProps = validProps;
-		this.#typeForExtraProps = typeForExtraProps;
-		this.#allocated = {};
-		this.#locations = locations;
-		this.#usedWgslKeys = /* @__PURE__ */ new Set();
-	}
-	/**
-	* Used for accessing builtins, varying and attributes in code.
-	*/
-	accessProp(key) {
-		const dataType = this.#validProps[key] ?? this.#typeForExtraProps;
-		if (!dataType) return;
-		return this.provideProp(key, dataType);
-	}
-	/**
-	* Used for providing new varyings.
-	*
-	* @privateRemarks
-	* Internally used by `accessProp`.
-	*/
-	provideProp(key, dataType) {
-		let alloc = this.#allocated[key];
-		if (!alloc) {
-			const wgslKey = key.replaceAll("$", "");
-			if (this.#usedWgslKeys.has(wgslKey)) throw new Error(`Property name '${wgslKey}' causes naming clashes. Choose a different name.`);
-			const result = /* @__PURE__ */ validateProp(wgslKey);
-			if (!result.success) throw new Error(`Invalid property key '${key}'${result.error ? `: ${result.error}` : ""}`);
-			this.#usedWgslKeys.add(wgslKey);
-			alloc = {
-				prop: wgslKey,
-				type: dataType
-			};
-			this.#allocated[key] = alloc;
-		}
-		return alloc;
-	}
-	get completeStruct() {
-		if (!this.#cachedStruct) {
-			this.#cachedStruct = createIoSchema(Object.fromEntries(Object.values(this.#allocated).map((alloc) => {
-				return [alloc.prop, alloc.type];
-			})), this.#locations);
-			const ownName = getName(this);
-			if (ownName) setName(this.#cachedStruct, ownName);
-		}
-		return this.#cachedStruct;
-	}
-	[$resolve](ctx) {
-		return ctx.resolve(this.completeStruct);
-	}
-	toString() {
-		return `auto-struct:${getName(this) ?? "<unnamed>"}`;
-	}
-};
+ * A requirement for the generated struct is that non-builtin properties need to
+ * have the same name in WGSL as they do in JS. This allows locations to be properly
+ * matched between the Vertex output and Fragment input.
+ */
+export class AutoStruct {
+    // ---
+    /**
+     * js key -> data type
+     */
+    #validProps;
+    /**
+     * js key -> { prop: 'wgsl key', type: ... }
+     * @example '$position' -> { prop: 'position', type: ... }
+     */
+    #allocated;
+    #usedWgslKeys;
+    #locations;
+    #cachedStruct;
+    #typeForExtraProps;
+    constructor(validProps, typeForExtraProps, locations) {
+        this.#validProps = validProps;
+        this.#typeForExtraProps = typeForExtraProps;
+        this.#allocated = {};
+        this.#locations = locations;
+        this.#usedWgslKeys = new Set();
+    }
+    /**
+     * Used for accessing builtins, varying and attributes in code.
+     */
+    accessProp(key) {
+        // If the prop is not found in validProps, we consider it an extra property
+        const dataType = this.#validProps[key] ?? this.#typeForExtraProps;
+        if (!dataType) {
+            return undefined;
+        }
+        return this.provideProp(key, dataType);
+    }
+    /**
+     * Used for providing new varyings.
+     *
+     * @privateRemarks
+     * Internally used by `accessProp`.
+     */
+    provideProp(key, dataType) {
+        let alloc = this.#allocated[key];
+        if (!alloc) {
+            const wgslKey = key.replaceAll('$', '');
+            if (this.#usedWgslKeys.has(wgslKey)) {
+                throw new Error(`Property name '${wgslKey}' causes naming clashes. Choose a different name.`);
+            }
+            const result = validateProp(wgslKey);
+            if (!result.success) {
+                throw new Error(`Invalid property key '${key}'${result.error ? `: ${result.error}` : ''}`);
+            }
+            this.#usedWgslKeys.add(wgslKey);
+            alloc = { prop: wgslKey, type: dataType };
+            this.#allocated[key] = alloc;
+        }
+        return alloc;
+    }
+    get completeStruct() {
+        if (!this.#cachedStruct) {
+            this.#cachedStruct = createIoSchema(Object.fromEntries(Object.values(this.#allocated).map((alloc) => {
+                return [alloc.prop, alloc.type];
+            })), this.#locations);
+            const ownName = getName(this);
+            // Passing the given name forward
+            if (ownName) {
+                setName(this.#cachedStruct, ownName);
+            }
+        }
+        return this.#cachedStruct;
+    }
+    [$resolve](ctx) {
+        return ctx.resolve(this.completeStruct);
+    }
+    toString() {
+        return `auto-struct:${getName(this) ?? '<unnamed>'}`;
+    }
+}
 AutoStruct.prototype[$internal] = {};
-AutoStruct.prototype.type = "auto-struct";
-
-//#endregion
-export { AutoStruct };
+AutoStruct.prototype.type = 'auto-struct';

package/data/compiledIO.d.ts

@@ -0,0 +1,5 @@
+import * as wgsl from './wgslTypes.ts';
+export declare const EVAL_ALLOWED_IN_ENV: boolean;
+export type CompiledWriter = (output: DataView, offset: number, value: unknown, littleEndian?: boolean, endOffset?: number) => void;
+export declare function buildWriter(node: wgsl.BaseData, offsetExpr: string, valueExpr: string, depth?: number, partial?: boolean): string;
+export declare function getCompiledWriter(schema: wgsl.BaseData): CompiledWriter | undefined;