typegpu 0.11.9 → 0.12.1

package/core/vertexLayout/connectAttributesToShader.js

@@ -1,59 +1,64 @@
-import { getCustomLocation, isData } from "../../data/dataTypes.js";
 import { isBuiltin } from "../../data/attributes.js";
-
-//#region src/core/vertexLayout/connectAttributesToShader.ts
-function isAttribute(value) {
-	return typeof value?.format === "string";
+import { getCustomLocation } from "../../data/dataTypes.js";
+import { isData } from "../../data/dataTypes.js";
+export function isAttribute(value) {
+    return typeof value?.format === 'string';
 }
-function connectAttributesToShader(shaderInputLayout, attributes) {
-	const usedVertexLayouts = [];
-	if (isData(shaderInputLayout)) {
-		if (!isAttribute(attributes)) throw new Error("Shader expected a single attribute, not a record of attributes to be passed in.");
-		usedVertexLayouts.push(attributes._layout);
-		return {
-			usedVertexLayouts,
-			bufferDefinitions: [{
-				arrayStride: attributes._layout.stride,
-				stepMode: attributes._layout.stepMode,
-				attributes: [{
-					format: attributes.format,
-					offset: attributes.offset,
-					shaderLocation: getCustomLocation(shaderInputLayout) ?? 0
-				}]
-			}]
-		};
-	}
-	const bufferDefinitions = [];
-	const layoutToAttribListMap = /* @__PURE__ */ new WeakMap();
-	let nextShaderLocation = 0;
-	for (const [key, member] of Object.entries(shaderInputLayout)) {
-		if (isBuiltin(member)) continue;
-		const matchingAttribute = attributes[key];
-		if (!matchingAttribute) throw new Error(`An attribute by the name of '${key}' was not provided to the shader.`);
-		const layout = matchingAttribute._layout;
-		let attribList = layoutToAttribListMap.get(layout);
-		if (!attribList) {
-			usedVertexLayouts.push(layout);
-			attribList = [];
-			bufferDefinitions.push({
-				arrayStride: layout.stride,
-				stepMode: layout.stepMode,
-				attributes: attribList
-			});
-			layoutToAttribListMap.set(layout, attribList);
-		}
-		nextShaderLocation = getCustomLocation(member) ?? nextShaderLocation;
-		attribList.push({
-			format: matchingAttribute.format,
-			offset: matchingAttribute.offset,
-			shaderLocation: nextShaderLocation++
-		});
-	}
-	return {
-		usedVertexLayouts,
-		bufferDefinitions
-	};
+export function connectAttributesToShader(shaderInputLayout, attributes) {
+    const usedVertexLayouts = [];
+    if (isData(shaderInputLayout)) {
+        // Expecting a single attribute, no record.
+        if (!isAttribute(attributes)) {
+            throw new Error('Shader expected a single attribute, not a record of attributes to be passed in.');
+        }
+        usedVertexLayouts.push(attributes._layout);
+        return {
+            usedVertexLayouts,
+            bufferDefinitions: [
+                {
+                    arrayStride: attributes._layout.stride,
+                    stepMode: attributes._layout.stepMode,
+                    attributes: [
+                        {
+                            format: attributes.format,
+                            offset: attributes.offset,
+                            shaderLocation: getCustomLocation(shaderInputLayout) ?? 0,
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    const bufferDefinitions = [];
+    const layoutToAttribListMap = new WeakMap();
+    let nextShaderLocation = 0;
+    for (const [key, member] of Object.entries(shaderInputLayout)) {
+        if (isBuiltin(member)) {
+            continue;
+        }
+        const matchingAttribute = attributes[key];
+        if (!matchingAttribute) {
+            throw new Error(`An attribute by the name of '${key}' was not provided to the shader.`);
+        }
+        const layout = matchingAttribute._layout;
+        let attribList = layoutToAttribListMap.get(layout);
+        if (!attribList) {
+            // First time seeing this layout
+            usedVertexLayouts.push(layout);
+            attribList = [];
+            bufferDefinitions.push({
+                arrayStride: layout.stride,
+                stepMode: layout.stepMode,
+                attributes: attribList,
+            });
+            layoutToAttribListMap.set(layout, attribList);
+        }
+        nextShaderLocation = getCustomLocation(member) ?? nextShaderLocation;
+        attribList.push({
+            format: matchingAttribute.format,
+            offset: matchingAttribute.offset,
+            shaderLocation: nextShaderLocation++,
+        });
+    }
+    return { usedVertexLayouts, bufferDefinitions };
 }
-
-//#endregion
-export { connectAttributesToShader, isAttribute };

package/core/vertexLayout/vertexAttribute.d.ts

@@ -1,10 +1,7 @@
-import { KindToAcceptedAttribMap, KindToDefaultFormatMap, TgpuVertexAttrib, VertexFormat } from "../../shared/vertexFormat.js";
-import { FormatToWGSLType } from "../../data/vertexFormatData.js";
-import { Decorated, WgslArray, WgslStruct } from "../../data/wgslTypes.js";
-import { Disarray, LooseDecorated, Unstruct } from "../../data/dataTypes.js";
-
-//#region src/core/vertexLayout/vertexAttribute.d.ts
-
+import type { Disarray, LooseDecorated, Unstruct } from '../../data/dataTypes.ts';
+import type { FormatToAcceptedData, FormatToWGSLType } from '../../data/vertexFormatData.ts';
+import type { Decorated, WgslArray, WgslStruct } from '../../data/wgslTypes.ts';
+import type { KindToAcceptedAttribMap, KindToDefaultFormatMap, TgpuVertexAttrib, VertexFormat } from '../../shared/vertexFormat.ts';
 /**
  * The array can hold T, where T is a single/multi-component numeric, or a struct with members of type T.
  * Examples of valid array members:
@@ -13,18 +10,25 @@ import { Disarray, LooseDecorated, Unstruct } from "../../data/dataTypes.js";
  * - WgslStruct<{ a: Vec3f, b: unorm8x2 }>
  * - WgslStruct<{ nested: WgslStruct<{ a: Vec3f }> }>
  */
-type DataToContainedAttribs<T> = T extends WgslStruct | Unstruct ? { [Key in keyof T['propTypes']]: DataToContainedAttribs<T['propTypes'][Key]> } : T extends {
-  type: VertexFormat;
+export type DataToContainedAttribs<T> = T extends WgslStruct | Unstruct ? {
+    [Key in keyof T['propTypes']]: DataToContainedAttribs<T['propTypes'][Key]>;
+} : T extends {
+    type: VertexFormat;
 } ? TgpuVertexAttrib<T['type']> : T extends {
-  type: keyof KindToDefaultFormatMap;
+    type: keyof KindToDefaultFormatMap;
 } ? TgpuVertexAttrib<KindToDefaultFormatMap[T['type']]> : T extends Decorated<infer TInner> ? DataToContainedAttribs<TInner> : T extends LooseDecorated<infer TInner> ? DataToContainedAttribs<TInner> : never;
 /**
  * Interprets an array as a set of vertex attributes.
  */
-type ArrayToContainedAttribs<T extends WgslArray | Disarray> = DataToContainedAttribs<T['elementType']>;
-type LayoutToAllowedAttribs<T> = T extends {
-  type: keyof KindToAcceptedAttribMap;
-} ? KindToAcceptedAttribMap[T['type']] : T extends Record<string, unknown> ? { [Key in keyof T]: LayoutToAllowedAttribs<T[Key]> } : never;
-type AttribRecordToDefaultDataTypes<T extends Record<string, TgpuVertexAttrib>> = { [Key in keyof T]: FormatToWGSLType<T[Key]['format']> };
-//#endregion
-export { ArrayToContainedAttribs, AttribRecordToDefaultDataTypes, LayoutToAllowedAttribs };
+export type ArrayToContainedAttribs<T extends WgslArray | Disarray> = DataToContainedAttribs<T['elementType']>;
+export type LayoutToAllowedAttribs<T> = T extends {
+    type: keyof KindToAcceptedAttribMap;
+} ? KindToAcceptedAttribMap[T['type']] : T extends Record<string, unknown> ? {
+    [Key in keyof T]: LayoutToAllowedAttribs<T[Key]>;
+} : never;
+export type AttribRecordToDefaultDataTypes<T extends Record<string, TgpuVertexAttrib>> = {
+    [Key in keyof T]: FormatToWGSLType<T[Key]['format']>;
+};
+export type AttribRecordToAcceptedDataTypes<T extends Record<string, TgpuVertexAttrib>> = {
+    [Key in keyof T]: FormatToAcceptedData[T[Key]['format']];
+};

package/core/vertexLayout/vertexAttribute.js

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

package/core/vertexLayout/vertexLayout.d.ts

@@ -1,19 +1,25 @@
-import { TgpuNamable } from "../../shared/meta.js";
-import { $internal } from "../../shared/symbols.js";
-import { ArrayToContainedAttribs } from "./vertexAttribute.js";
-import { WgslArray } from "../../data/wgslTypes.js";
-import { Disarray } from "../../data/dataTypes.js";
-
-//#region src/core/vertexLayout/vertexLayout.d.ts
-interface TgpuVertexLayout<TData extends WgslArray | Disarray = WgslArray | Disarray> extends TgpuNamable {
-  readonly [$internal]: true;
-  readonly resourceType: 'vertex-layout';
-  readonly stride: number;
-  readonly stepMode: 'vertex' | 'instance';
-  readonly attrib: ArrayToContainedAttribs<TData>;
-  readonly vertexLayout: GPUVertexBufferLayout;
-  schemaForCount(n: number): TData;
+import type { Disarray } from '../../data/dataTypes.ts';
+import type { WgslArray } from '../../data/wgslTypes.ts';
+import type { TgpuNamable } from '../../shared/meta.ts';
+import type { TgpuSoul } from '../../shared/soul.ts';
+import { $internal, $soul } from '../../shared/symbols.ts';
+import type { ArrayToContainedAttribs } from './vertexAttribute.ts';
+export interface TgpuVertexLayoutSoul extends TgpuSoul<'vertex-layout'> {
+    readonly schema: WgslArray | Disarray;
+    readonly stepMode: 'vertex' | 'instance';
 }
-declare function vertexLayout<TData extends WgslArray | Disarray>(schemaForCount: (count: number) => TData, stepMode?: 'vertex' | 'instance'): TgpuVertexLayout<TData>;
-//#endregion
-export { TgpuVertexLayout, vertexLayout };
+export interface TgpuVertexLayout<TData extends WgslArray | Disarray = WgslArray | Disarray> extends TgpuNamable {
+    readonly [$internal]: true;
+    readonly [$soul]: TgpuVertexLayoutSoul;
+    readonly resourceType: 'vertex-layout';
+    readonly stride: number;
+    readonly stepMode: 'vertex' | 'instance';
+    readonly attrib: ArrayToContainedAttribs<TData>;
+    readonly vertexLayout: GPUVertexBufferLayout;
+    schemaForCount(n: number): TData;
+}
+export interface INTERNAL_TgpuVertexAttrib {
+    readonly _layout: TgpuVertexLayout;
+}
+export declare function vertexLayout<TData extends WgslArray | Disarray>(schemaForCount: (count: number) => TData, stepMode?: 'vertex' | 'instance'): TgpuVertexLayout<TData>;
+export declare function isVertexLayout(value: unknown): value is TgpuVertexLayout;

package/core/vertexLayout/vertexLayout.js

@@ -1,105 +1,136 @@
-import { $internal } from "../../shared/symbols.js";
-import { isDecorated, isWgslStruct } from "../../data/wgslTypes.js";
-import { setName } from "../../shared/meta.js";
-import { kindToDefaultFormatMap, vertexFormats } from "../../shared/vertexFormat.js";
-import { getCustomLocation, isLooseDecorated, isUnstruct } from "../../data/dataTypes.js";
 import { alignmentOf, customAlignmentOf } from "../../data/alignmentOf.js";
-import { roundUp } from "../../mathUtils.js";
+import { getCustomLocation, isLooseDecorated, isUnstruct } from "../../data/dataTypes.js";
 import { sizeOf } from "../../data/sizeOf.js";
-
-//#region src/core/vertexLayout/vertexLayout.ts
-function vertexLayout(schemaForCount, stepMode = "vertex") {
-	return new TgpuVertexLayoutImpl(schemaForCount, stepMode);
+import { isDecorated, isWgslStruct } from "../../data/wgslTypes.js";
+import { roundUp } from "../../mathUtils.js";
+import { setName } from "../../shared/meta.js";
+import { $internal, $soul } from "../../shared/symbols.js";
+import { kindToDefaultFormatMap, vertexFormats, } from "../../shared/vertexFormat.js";
+export function vertexLayout(schemaForCount, stepMode = 'vertex') {
+    return new TgpuVertexLayoutImpl(schemaForCount, stepMode);
 }
-function isVertexLayout(value) {
-	return value?.resourceType === "vertex-layout";
+export function isVertexLayout(value) {
+    return value?.resourceType === 'vertex-layout';
 }
-const defaultAttribEntry = Symbol("defaultAttribEntry");
+// --------------
+// Implementation
+// --------------
+const defaultAttribEntry = Symbol('defaultAttribEntry');
 function dataToContainedAttribs(layout, data, offset, customLocationMap, key) {
-	if (isDecorated(data) || isLooseDecorated(data)) {
-		const customLocation = getCustomLocation(data);
-		if (customLocation !== void 0) customLocationMap[key ?? defaultAttribEntry] = customLocation;
-		return dataToContainedAttribs(layout, data.inner, roundUp(offset, customAlignmentOf(data)), customLocationMap);
-	}
-	if (isWgslStruct(data)) {
-		let memberOffset = offset;
-		const propTypes = data.propTypes;
-		return Object.fromEntries(Object.entries(propTypes).map(([key$1, value]) => {
-			memberOffset = roundUp(memberOffset, alignmentOf(value));
-			const attrib = [key$1, dataToContainedAttribs(layout, value, memberOffset, customLocationMap, key$1)];
-			memberOffset += sizeOf(value);
-			return attrib;
-		}));
-	}
-	if (isUnstruct(data)) {
-		let memberOffset = offset;
-		const propTypes = data.propTypes;
-		return Object.fromEntries(Object.entries(propTypes).map(([key$1, value]) => {
-			memberOffset = roundUp(memberOffset, customAlignmentOf(value));
-			const attrib = [key$1, dataToContainedAttribs(layout, value, memberOffset, customLocationMap, key$1)];
-			memberOffset += sizeOf(value);
-			return attrib;
-		}));
-	}
-	if ("type" in data && typeof data.type === "string") {
-		if (vertexFormats.includes(data.type)) return {
-			_layout: layout,
-			format: data.type,
-			offset
-		};
-		const format = kindToDefaultFormatMap[data.type];
-		if (format) return {
-			_layout: layout,
-			format,
-			offset
-		};
-	}
-	throw new Error(`Unsupported data used in vertex layout: ${String(data)}`);
+    if (isDecorated(data) || isLooseDecorated(data)) {
+        const customLocation = getCustomLocation(data);
+        if (customLocation !== undefined) {
+            customLocationMap[key ?? defaultAttribEntry] = customLocation;
+        }
+        return dataToContainedAttribs(layout, data.inner, roundUp(offset, customAlignmentOf(data)), customLocationMap);
+    }
+    if (isWgslStruct(data)) {
+        let memberOffset = offset;
+        const propTypes = data.propTypes;
+        return Object.fromEntries(Object.entries(propTypes).map(([key, value]) => {
+            memberOffset = roundUp(memberOffset, alignmentOf(value));
+            const attrib = [
+                key,
+                dataToContainedAttribs(layout, value, memberOffset, customLocationMap, key),
+            ];
+            memberOffset += sizeOf(value);
+            return attrib;
+        }));
+    }
+    if (isUnstruct(data)) {
+        let memberOffset = offset;
+        const propTypes = data.propTypes;
+        return Object.fromEntries(Object.entries(propTypes).map(([key, value]) => {
+            memberOffset = roundUp(memberOffset, customAlignmentOf(value));
+            const attrib = [
+                key,
+                dataToContainedAttribs(layout, value, memberOffset, customLocationMap, key),
+            ];
+            memberOffset += sizeOf(value);
+            return attrib;
+        }));
+    }
+    if ('type' in data && typeof data.type === 'string') {
+        if (vertexFormats.includes(data.type)) {
+            return {
+                _layout: layout, // hidden property, used to determine which buffers to apply when executing the pipeline
+                format: data.type,
+                offset,
+                // oxlint-disable-next-line typescript/no-explicit-any -- too many type shenanigans
+            };
+        }
+        const format = kindToDefaultFormatMap[data.type];
+        if (format) {
+            return {
+                _layout: layout, // hidden property, used to determine which buffers to apply when executing the pipeline
+                format,
+                offset,
+                // oxlint-disable-next-line typescript/no-explicit-any -- too many type shenanigans
+            };
+        }
+    }
+    throw new Error(`Unsupported data used in vertex layout: ${String(data)}`);
+}
+class TgpuVertexLayoutImpl {
+    [$internal] = true;
+    [$soul];
+    resourceType = 'vertex-layout';
+    stride;
+    attrib;
+    schemaForCount;
+    #customLocationMap = {};
+    constructor(schemaForCount, stepMode) {
+        this.schemaForCount = schemaForCount;
+        // `0` signals that the data-type is runtime-sized, and should not be used to create buffers.
+        const arraySchema = schemaForCount(0);
+        this[$soul] = {
+            type: 'vertex-layout',
+            schema: arraySchema,
+            stepMode,
+            label: undefined,
+        };
+        this.stride = roundUp(sizeOf(arraySchema.elementType), alignmentOf(arraySchema));
+        this.attrib = dataToContainedAttribs(this, arraySchema.elementType, 0, this.#customLocationMap);
+    }
+    get stepMode() {
+        return this[$soul].stepMode;
+    }
+    get vertexLayout() {
+        // If defaultAttribEntry is in the custom location map,
+        // it means that the vertex layout is based on a single attribute
+        if (this.#customLocationMap[defaultAttribEntry] !== undefined) {
+            if (typeof this.attrib.format !== 'string' || typeof this.attrib.offset !== 'number') {
+                throw new Error('Single attribute vertex layouts must have a format and offset.');
+            }
+            return {
+                arrayStride: this.stride,
+                stepMode: this.stepMode,
+                attributes: [
+                    {
+                        format: this.attrib.format,
+                        offset: this.attrib.offset,
+                        shaderLocation: this.#customLocationMap[defaultAttribEntry],
+                    },
+                ],
+            };
+        }
+        // check if all attributes have custom locations
+        const allAttributesHaveCustomLocations = Object.keys(this.attrib).every((key) => this.#customLocationMap[key] !== undefined);
+        if (!allAttributesHaveCustomLocations) {
+            throw new Error('All attributes must have custom locations in order to unwrap a vertex layout.');
+        }
+        return {
+            arrayStride: this.stride,
+            stepMode: this.stepMode,
+            attributes: Object.entries(this.attrib).map(([key, attrib]) => ({
+                format: attrib.format,
+                offset: attrib.offset,
+                shaderLocation: this.#customLocationMap[key],
+            })),
+        };
+    }
+    $name(label) {
+        setName(this, label);
+        return this;
+    }
 }
-var TgpuVertexLayoutImpl = class {
-	[$internal] = true;
-	resourceType = "vertex-layout";
-	stride;
-	attrib;
-	schemaForCount;
-	stepMode;
-	#customLocationMap = {};
-	constructor(schemaForCount, stepMode) {
-		this.schemaForCount = schemaForCount;
-		this.stepMode = stepMode;
-		const arraySchema = schemaForCount(0);
-		this.stride = roundUp(sizeOf(arraySchema.elementType), alignmentOf(arraySchema));
-		this.attrib = dataToContainedAttribs(this, arraySchema.elementType, 0, this.#customLocationMap);
-	}
-	get vertexLayout() {
-		if (this.#customLocationMap[defaultAttribEntry] !== void 0) {
-			if (typeof this.attrib.format !== "string" || typeof this.attrib.offset !== "number") throw new Error("Single attribute vertex layouts must have a format and offset.");
-			return {
-				arrayStride: this.stride,
-				stepMode: this.stepMode,
-				attributes: [{
-					format: this.attrib.format,
-					offset: this.attrib.offset,
-					shaderLocation: this.#customLocationMap[defaultAttribEntry]
-				}]
-			};
-		}
-		if (!Object.keys(this.attrib).every((key) => this.#customLocationMap[key] !== void 0)) throw new Error("All attributes must have custom locations in order to unwrap a vertex layout.");
-		return {
-			arrayStride: this.stride,
-			stepMode: this.stepMode,
-			attributes: Object.entries(this.attrib).map(([key, attrib]) => ({
-				format: attrib.format,
-				offset: attrib.offset,
-				shaderLocation: this.#customLocationMap[key]
-			}))
-		};
-	}
-	$name(label) {
-		setName(this, label);
-		return this;
-	}
-};
-
-//#endregion
-export { isVertexLayout, vertexLayout };

package/core/whitespaces.d.ts

@@ -0,0 +1,2 @@
+export declare const lineBreaks: Set<string>;
+export declare const blankSpaces: Set<string>;

package/core/whitespaces.js

@@ -0,0 +1,16 @@
+export const lineBreaks = new Set([
+    '\u000A', // line feed
+    '\u000B', // vertical tab
+    '\u000C', // form feed
+    '\u000D', // carriage return
+    '\u0085', // next line
+    '\u2028', // line separator
+    '\u2029', // paragraph separator
+]);
+export const blankSpaces = new Set([
+    ...lineBreaks,
+    '\u0020', // space
+    '\u0009', // horizontal tab
+    '\u200E', // left-to-right mark
+    '\u200F', // right-to-left mark
+]);

package/data/alignIO.d.ts

@@ -0,0 +1,7 @@
+import type { IMeasurer, ISerialInput, ISerialOutput } from 'typed-binary';
+/**
+ * @param io the IO to align
+ * @param baseAlignment must be power of 2
+ */
+declare function alignIO(io: ISerialInput | ISerialOutput | IMeasurer, baseAlignment: number): void;
+export default alignIO;

package/data/alignIO.js

@@ -1,16 +1,16 @@
-//#region src/data/alignIO.ts
 /**
-* @param io the IO to align
-* @param baseAlignment must be power of 2
-*/
+ * @param io the IO to align
+ * @param baseAlignment must be power of 2
+ */
 function alignIO(io, baseAlignment) {
-	const currentPos = "size" in io ? io.size : io.currentByteOffset;
-	const bitMask = baseAlignment - 1;
-	const offset = currentPos & bitMask;
-	if ("skipBytes" in io) io.skipBytes(baseAlignment - offset & bitMask);
-	else io.add(baseAlignment - offset & bitMask);
+    const currentPos = 'size' in io ? io.size : io.currentByteOffset;
+    const bitMask = baseAlignment - 1;
+    const offset = currentPos & bitMask;
+    if ('skipBytes' in io) {
+        io.skipBytes((baseAlignment - offset) & bitMask);
+    }
+    else {
+        io.add((baseAlignment - offset) & bitMask);
+    }
 }
-var alignIO_default = alignIO;
-
-//#endregion
-export { alignIO_default as default };
+export default alignIO;

package/data/alignmentOf.d.ts

@@ -1,11 +1,8 @@
-import "./wgslTypes.js";
-import { AnyData } from "./dataTypes.js";
-
-//#region src/data/alignmentOf.d.ts
-
+import { type AnyData } from './dataTypes.ts';
+import { type BaseData } from './wgslTypes.ts';
+export declare function alignmentOf(data: BaseData): number;
+export declare function customAlignmentOf(data: BaseData): number;
 /**
  * Returns the alignment (in bytes) of data represented by the `schema`.
  */
-declare function PUBLIC_alignmentOf(schema: AnyData): number;
-//#endregion
-export { PUBLIC_alignmentOf };
+export declare function PUBLIC_alignmentOf(schema: AnyData): number;