typegpu 0.11.8 → 0.12.0

package/data/partialIO.js

@@ -1,120 +1,131 @@
-import { isWgslArray, isWgslStruct } from "./wgslTypes.js";
-import { isDisarray, isUnstruct } from "./dataTypes.js";
-import { alignmentOf } from "./alignmentOf.js";
+import { BufferWriter, getSystemEndianness } from 'typed-binary';
 import { roundUp } from "../mathUtils.js";
-import { sizeOf } from "./sizeOf.js";
-import { offsetsForProps } from "./offsets.js";
+import { alignmentOf } from "./alignmentOf.js";
 import { getCompiledWriter } from "./compiledIO.js";
 import { writeData } from "./dataIO.js";
-import { BufferWriter, getSystemEndianness } from "typed-binary";
-
-//#region src/data/partialIO.ts
+import { isDisarray, isUnstruct } from "./dataTypes.js";
+import { offsetsForProps } from "./offsets.js";
+import { sizeOf } from "./sizeOf.js";
+import { isWgslArray, isWgslStruct } from "./wgslTypes.js";
 /**
-* Converts `{idx, value}[]` sparse arrays into `Record<number, T>` format.
-*/
-function convertPartialToPatch(schema, data) {
-	if (data === void 0 || data === null) return data;
-	if (isWgslStruct(schema) || isUnstruct(schema)) {
-		const result = {};
-		const record = data;
-		for (const key of Object.keys(schema.propTypes)) {
-			const subSchema = schema.propTypes[key];
-			const value = record[key];
-			if (value !== void 0 && subSchema) result[key] = convertPartialToPatch(subSchema, value);
-		}
-		return result;
-	}
-	if (isWgslArray(schema) || isDisarray(schema)) {
-		const arrSchema = schema;
-		const result = {};
-		for (const { idx, value } of data) result[idx] = convertPartialToPatch(arrSchema.elementType, value);
-		return result;
-	}
-	return data;
+ * Converts `{idx, value}[]` sparse arrays into `Record<number, T>` format.
+ */
+export function convertPartialToPatch(schema, data) {
+    if (data === undefined || data === null) {
+        return data;
+    }
+    if (isWgslStruct(schema) || isUnstruct(schema)) {
+        const result = {};
+        const record = data;
+        for (const key of Object.keys(schema.propTypes)) {
+            const subSchema = schema.propTypes[key];
+            const value = record[key];
+            if (value !== undefined && subSchema) {
+                result[key] = convertPartialToPatch(subSchema, value);
+            }
+        }
+        return result;
+    }
+    if (isWgslArray(schema) || isDisarray(schema)) {
+        const arrSchema = schema;
+        const result = {};
+        for (const { idx, value } of data) {
+            result[idx] = convertPartialToPatch(arrSchema.elementType, value);
+        }
+        return result;
+    }
+    return data;
 }
-const isLittleEndian = getSystemEndianness() === "little";
-function getPatchInstructions(schema, data, targetBuffer) {
-	const totalSize = sizeOf(schema);
-	if (totalSize === 0 || data === void 0 || data === null) return [];
-	const buf = targetBuffer ?? new ArrayBuffer(totalSize);
-	const writer = new BufferWriter(buf);
-	const compiledView = new DataView(buf);
-	const segments = [];
-	function collect(node, value, offset, padding) {
-		if (value === void 0 || value === null) return;
-		if (isWgslStruct(node) || isUnstruct(node)) {
-			const propOffsets = offsetsForProps(node);
-			for (const [key, propOffset] of Object.entries(propOffsets)) {
-				const childValue = value[key];
-				const subSchema = node.propTypes[key];
-				if (childValue !== void 0 && subSchema) collect(subSchema, childValue, offset + propOffset.offset, propOffset.padding ?? padding);
-			}
-			return;
-		}
-		if (isWgslArray(node) || isDisarray(node)) {
-			const arrSchema = node;
-			const elementSize = roundUp(sizeOf(arrSchema.elementType), alignmentOf(arrSchema.elementType));
-			const elementPadding = elementSize - sizeOf(arrSchema.elementType);
-			if (ArrayBuffer.isView(value)) {
-				const copyLen = Math.min(value.byteLength, arrSchema.elementCount * elementSize);
-				new Uint8Array(buf, offset, copyLen).set(new Uint8Array(value.buffer, value.byteOffset, copyLen));
-				segments.push({
-					start: offset,
-					end: offset + copyLen,
-					padding
-				});
-				return;
-			}
-			if (Array.isArray(value)) {
-				for (let i = 0; i < Math.min(arrSchema.elementCount, value.length); i++) collect(arrSchema.elementType, value[i], offset + i * elementSize, elementPadding);
-				return;
-			}
-			const sparse = value;
-			for (const key of Object.keys(sparse)) {
-				const idx = Number(key);
-				if (!Number.isNaN(idx)) collect(arrSchema.elementType, sparse[key], offset + idx * elementSize, elementPadding);
-			}
-			return;
-		}
-		const leafSize = sizeOf(node);
-		const compiledWriter = getCompiledWriter(node);
-		if (compiledWriter) compiledWriter(compiledView, offset, value, isLittleEndian, offset + leafSize);
-		else {
-			writer.seekTo(offset);
-			writeData(writer, node, value);
-		}
-		segments.push({
-			start: offset,
-			end: offset + leafSize,
-			padding
-		});
-	}
-	collect(schema, data, 0);
-	const instructions = [];
-	let run = null;
-	for (const seg of segments) if (run && seg.start === run.end + (run.padding ?? 0)) run = {
-		start: run.start,
-		end: seg.end,
-		padding: seg.padding
-	};
-	else {
-		if (run) instructions.push({
-			gpuOffset: run.start,
-			data: new Uint8Array(buf, run.start, run.end - run.start).slice()
-		});
-		run = seg;
-	}
-	if (run) instructions.push({
-		gpuOffset: run.start,
-		data: new Uint8Array(buf, run.start, run.end - run.start).slice()
-	});
-	return instructions;
+const isLittleEndian = getSystemEndianness() === 'little';
+export function getPatchInstructions(schema, data, targetBuffer) {
+    const totalSize = sizeOf(schema);
+    if (totalSize === 0 || data === undefined || data === null) {
+        return [];
+    }
+    const buf = targetBuffer ?? new ArrayBuffer(totalSize);
+    const writer = new BufferWriter(buf);
+    const compiledView = new DataView(buf);
+    const segments = [];
+    function collect(node, value, offset, padding) {
+        if (value === undefined || value === null) {
+            return;
+        }
+        if (isWgslStruct(node) || isUnstruct(node)) {
+            const propOffsets = offsetsForProps(node);
+            for (const [key, propOffset] of Object.entries(propOffsets)) {
+                const childValue = value[key];
+                const subSchema = node.propTypes[key];
+                if (childValue !== undefined && subSchema) {
+                    collect(subSchema, childValue, offset + propOffset.offset, propOffset.padding ?? padding);
+                }
+            }
+            return;
+        }
+        if (isWgslArray(node) || isDisarray(node)) {
+            const arrSchema = node;
+            const elementSize = roundUp(sizeOf(arrSchema.elementType), alignmentOf(arrSchema.elementType));
+            const elementPadding = elementSize - sizeOf(arrSchema.elementType);
+            if (ArrayBuffer.isView(value)) {
+                const copyLen = Math.min(value.byteLength, arrSchema.elementCount * elementSize);
+                new Uint8Array(buf, offset, copyLen).set(new Uint8Array(value.buffer, value.byteOffset, copyLen));
+                segments.push({ start: offset, end: offset + copyLen, padding });
+                return;
+            }
+            if (Array.isArray(value)) {
+                for (let i = 0; i < Math.min(arrSchema.elementCount, value.length); i++) {
+                    collect(arrSchema.elementType, value[i], offset + i * elementSize, elementPadding);
+                }
+                return;
+            }
+            const sparse = value;
+            for (const key of Object.keys(sparse)) {
+                const idx = Number(key);
+                if (!Number.isNaN(idx)) {
+                    collect(arrSchema.elementType, sparse[key], offset + idx * elementSize, elementPadding);
+                }
+            }
+            return;
+        }
+        const leafSize = sizeOf(node);
+        const compiledWriter = getCompiledWriter(node);
+        if (compiledWriter) {
+            compiledWriter(compiledView, offset, value, isLittleEndian, offset + leafSize);
+        }
+        else {
+            writer.seekTo(offset);
+            writeData(writer, node, value);
+        }
+        segments.push({ start: offset, end: offset + leafSize, padding });
+    }
+    collect(schema, data, 0);
+    const instructions = [];
+    let run = null;
+    for (const seg of segments) {
+        if (run && seg.start === run.end + (run.padding ?? 0)) {
+            run = { start: run.start, end: seg.end, padding: seg.padding };
+        }
+        else {
+            if (run) {
+                instructions.push({
+                    gpuOffset: run.start,
+                    data: new Uint8Array(buf, run.start, run.end - run.start).slice(),
+                });
+            }
+            run = seg;
+        }
+    }
+    if (run) {
+        instructions.push({
+            gpuOffset: run.start,
+            data: new Uint8Array(buf, run.start, run.end - run.start).slice(),
+        });
+    }
+    return instructions;
 }
-function patchArrayBuffer(buffer, schema, data) {
-	const instructions = getPatchInstructions(schema, data, buffer);
-	const mappedView = new Uint8Array(buffer);
-	for (const { data: data$1, gpuOffset } of instructions) mappedView.set(data$1, gpuOffset);
+export function patchArrayBuffer(buffer, schema, data) {
+    const instructions = getPatchInstructions(schema, data, buffer);
+    const mappedView = new Uint8Array(buffer);
+    for (const { data, gpuOffset } of instructions) {
+        mappedView.set(data, gpuOffset);
+    }
 }
-
-//#endregion
-export { convertPartialToPatch, getPatchInstructions, patchArrayBuffer };

package/data/ptr.d.ts

@@ -1,12 +1,12 @@
-import "./snippet.js";
-import { Ptr, StorableData } from "./wgslTypes.js";
-
-//#region src/data/ptr.d.ts
-declare function ptrFn<T extends StorableData>(inner: T): Ptr<'function', T, 'read-write'>;
-declare function ptrPrivate<T extends StorableData>(inner: T): Ptr<'private', T, 'read-write'>;
-declare function ptrWorkgroup<T extends StorableData>(inner: T): Ptr<'workgroup', T, 'read-write'>;
-declare function ptrStorage<T extends StorableData, TAccess extends 'read' | 'read-write' = 'read'>(inner: T, access?: TAccess): Ptr<'storage', T, TAccess>;
-declare function ptrUniform<T extends StorableData>(inner: T): Ptr<'uniform', T, 'read'>;
-declare function ptrHandle<T extends StorableData>(inner: T): Ptr<'handle', T, 'read'>;
-//#endregion
-export { ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup };
+import { type Origin } from './snippet.ts';
+import type { Access, AddressSpace, BaseData, Ptr, StorableData } from './wgslTypes.ts';
+export declare function ptrFn<T extends StorableData>(inner: T): Ptr<'function', T, 'read-write'>;
+export declare function ptrPrivate<T extends StorableData>(inner: T): Ptr<'private', T, 'read-write'>;
+export declare function ptrWorkgroup<T extends StorableData>(inner: T): Ptr<'workgroup', T, 'read-write'>;
+export declare function ptrStorage<T extends StorableData, TAccess extends 'read' | 'read-write' = 'read'>(inner: T, access?: TAccess): Ptr<'storage', T, TAccess>;
+export declare function ptrUniform<T extends StorableData>(inner: T): Ptr<'uniform', T, 'read'>;
+export declare function ptrHandle<T extends StorableData>(inner: T): Ptr<'handle', T, 'read'>;
+export declare function INTERNAL_createPtr<TAddressSpace extends AddressSpace, TInner extends BaseData, TAccess extends Access>(addressSpace: TAddressSpace, inner: TInner, access: TAccess, implicit?: boolean): Ptr<TAddressSpace, TInner, TAccess>;
+export declare function createPtrFromOrigin(origin: Origin, innerDataType: StorableData): Ptr | undefined;
+export declare function implicitFrom(ptr: Ptr): Ptr;
+export declare function explicitFrom(ptr: Ptr): Ptr;

package/data/ptr.js

@@ -1,46 +1,44 @@
 import { $internal } from "../shared/symbols.js";
 import { originToPtrParams } from "./snippet.js";
-
-//#region src/data/ptr.ts
-function ptrFn(inner) {
-	return INTERNAL_createPtr("function", inner, "read-write");
-}
-function ptrPrivate(inner) {
-	return INTERNAL_createPtr("private", inner, "read-write");
-}
-function ptrWorkgroup(inner) {
-	return INTERNAL_createPtr("workgroup", inner, "read-write");
-}
-function ptrStorage(inner, access = "read") {
-	return INTERNAL_createPtr("storage", inner, access);
-}
-function ptrUniform(inner) {
-	return INTERNAL_createPtr("uniform", inner, "read");
-}
-function ptrHandle(inner) {
-	return INTERNAL_createPtr("handle", inner, "read");
-}
-function INTERNAL_createPtr(addressSpace, inner, access, implicit = false) {
-	return {
-		[$internal]: {},
-		type: "ptr",
-		addressSpace,
-		inner,
-		access,
-		implicit,
-		toString: () => `ptr<${addressSpace}, ${inner}, ${access}>`
-	};
-}
-function createPtrFromOrigin(origin, innerDataType) {
-	const ptrParams = originToPtrParams[origin];
-	if (ptrParams) return INTERNAL_createPtr(ptrParams.space, innerDataType, ptrParams.access);
-}
-function implicitFrom(ptr) {
-	return INTERNAL_createPtr(ptr.addressSpace, ptr.inner, ptr.access, true);
-}
-function explicitFrom(ptr) {
-	return INTERNAL_createPtr(ptr.addressSpace, ptr.inner, ptr.access, false);
-}
-
-//#endregion
-export { createPtrFromOrigin, explicitFrom, implicitFrom, ptrFn, ptrHandle, ptrPrivate, ptrStorage, ptrUniform, ptrWorkgroup };
+export function ptrFn(inner) {
+    return INTERNAL_createPtr('function', inner, 'read-write');
+}
+export function ptrPrivate(inner) {
+    return INTERNAL_createPtr('private', inner, 'read-write');
+}
+export function ptrWorkgroup(inner) {
+    return INTERNAL_createPtr('workgroup', inner, 'read-write');
+}
+export function ptrStorage(inner, access = 'read') {
+    return INTERNAL_createPtr('storage', inner, access);
+}
+export function ptrUniform(inner) {
+    return INTERNAL_createPtr('uniform', inner, 'read');
+}
+export function ptrHandle(inner) {
+    return INTERNAL_createPtr('handle', inner, 'read');
+}
+export function INTERNAL_createPtr(addressSpace, inner, access, implicit = false) {
+    return {
+        [$internal]: {},
+        type: 'ptr',
+        addressSpace,
+        inner,
+        access,
+        implicit,
+        toString: () => `ptr<${addressSpace}, ${inner}, ${access}>`,
+    };
+}
+export function createPtrFromOrigin(origin, innerDataType) {
+    const ptrParams = originToPtrParams[origin];
+    if (ptrParams) {
+        return INTERNAL_createPtr(ptrParams.space, innerDataType, ptrParams.access);
+    }
+    return undefined;
+}
+export function implicitFrom(ptr) {
+    return INTERNAL_createPtr(ptr.addressSpace, ptr.inner, ptr.access, /* implicit */ true);
+}
+export function explicitFrom(ptr) {
+    return INTERNAL_createPtr(ptr.addressSpace, ptr.inner, ptr.access, /* implicit */ false);
+}

package/data/ref.d.ts

@@ -1,26 +1,24 @@
-import { $internal } from "../shared/symbols.js";
-import "./snippet.js";
-import { DualFn } from "../types.js";
-import "./wgslTypes.js";
-
-//#region src/data/ref.d.ts
+import { $internal, $ownSnippet, $resolve } from '../shared/symbols.ts';
+import type { DualFn, SelfResolvable } from '../types.ts';
+import { type ResolvedSnippet, type Snippet } from './snippet.ts';
+import { type Ptr } from './wgslTypes.ts';
 interface ref<T> {
-  readonly [$internal]: {
-    type: 'ref';
-  };
-  /**
-   * Derefences the reference, and gives access to the underlying value.
-   *
-   * @example ```ts
-   * const boid = Boid({ pos: d.vec3f(3, 2, 1) });
-   * const posRef = d.ref(boid.pos);
-   *
-   * // Actually updates `boid.pos`
-   * posRef.$ = d.vec3f(1, 2, 3);
-   * console.log(boid.pos); // Output: vec3f(1, 2, 3)
-   * ```
-   */
-  $: T;
+    readonly [$internal]: {
+        type: 'ref';
+    };
+    /**
+     * Derefences the reference, and gives access to the underlying value.
+     *
+     * @example ```ts
+     * const boid = Boid({ pos: d.vec3f(3, 2, 1) });
+     * const posRef = d.ref(boid.pos);
+     *
+     * // Actually updates `boid.pos`
+     * posRef.$ = d.vec3f(1, 2, 3);
+     * console.log(boid.pos); // Output: vec3f(1, 2, 3)
+     * ```
+     */
+    $: T;
 }
 /**
  * A reference to a value `T`. Can be passed to other functions to give them
@@ -28,10 +26,25 @@ interface ref<T> {
  *
  * Conceptually, it represents a WGSL pointer.
  */
-type _ref<T> = T extends object ? T & ref<T> : ref<T>;
+export type _ref<T> = T extends object ? T & ref<T> : ref<T>;
 type RefFn = DualFn<(<T>(value: T) => _ref<T>)> & {
-  [$internal]: true;
+    [$internal]: true;
 };
-declare const _ref: RefFn;
-//#endregion
-export { _ref };
+export declare const _ref: RefFn;
+export declare function isRef<T>(value: unknown): value is ref<T>;
+export declare function INTERNAL_createRef<T>(value: T): ref<T>;
+/**
+ * The result of calling `d.ref(...)`. The code responsible for
+ * generating shader code can check if the value of a snippet is
+ * an instance of `RefOperator`, and act accordingly.
+ */
+export declare class RefOperator implements SelfResolvable {
+    #private;
+    readonly [$internal]: true;
+    readonly snippet: Snippet;
+    constructor(snippet: Snippet, ptrType: Ptr | undefined);
+    get [$ownSnippet](): Snippet;
+    [$resolve](): ResolvedSnippet;
+}
+export declare function derefSnippet(snippet: Snippet): Snippet;
+export {};