typegpu 0.11.8 → 0.12.0

package/core/constant/tgpuConstant.js

@@ -1,70 +1,81 @@
-import { $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symbols.js";
-import { getName, setName } from "../../shared/meta.js";
 import { isData } from "../../data/dataTypes.js";
 import { snip } from "../../data/snippet.js";
-import { inCodegenMode } from "../../execMode.js";
-import { valueProxyHandler } from "../valueProxyUtils.js";
-
-//#region src/core/constant/tgpuConstant.ts
-function constant(dataType, value) {
-	if (!isData(dataType)) {
-		if (!Array.isArray(value)) throw new Error(`Expected an array value for a partially-applied array schema, but received: ${typeof value}.`);
-		return new TgpuConstImpl(dataType(value.length), value);
-	}
-	return new TgpuConstImpl(dataType, value);
+import {} from "../../data/wgslTypes.js";
+import { makeDereferenceable } from "../../tgsl/makeDereferenceable.js";
+import { makeResolvable } from "../../tgsl/makeResolvable.js";
+import { getName, setName } from "../../shared/meta.js";
+import { $gpuValueOf, $internal, $soul } from "../../shared/symbols.js";
+export function constant(dataType, value) {
+    if (!isData(dataType)) {
+        if (!Array.isArray(value)) {
+            throw new Error(`Expected an array value for a partially-applied array schema, but received: ${typeof value}.`);
+        }
+        return new TgpuConstImpl(dataType(value.length), value);
+    }
+    return new TgpuConstImpl(dataType, value);
 }
+// --------------
+// Implementation
+// --------------
 function deepFreeze(object) {
-	const propNames = Reflect.ownKeys(object);
-	for (const name of propNames) {
-		const value = object[name];
-		if (value && typeof value === "object" || typeof value === "function") deepFreeze(value);
-	}
-	return Object.freeze(object);
+    // Retrieve the property names defined on object
+    const propNames = Reflect.ownKeys(object);
+    // Freeze properties before freezing self
+    for (const name of propNames) {
+        // oxlint-disable-next-line typescript/no-explicit-any -- chill TypeScript
+        const value = object[name];
+        if ((value && typeof value === 'object') || typeof value === 'function') {
+            deepFreeze(value);
+        }
+    }
+    return Object.freeze(object);
+}
+class TgpuConstImpl {
+    [$soul];
+    static {
+        TgpuConstImpl.prototype[$internal] = {};
+        TgpuConstImpl.prototype.resourceType = 'const';
+        makeDereferenceable(makeResolvable(TgpuConstImpl.prototype, {
+            asString() {
+                return `const:${getName(this) ?? '<unnamed>'}`;
+            },
+            resolve(ctx) {
+                const id = ctx.makeUniqueIdentifier(getName(this), 'global');
+                return ctx.gen.declareGlobalConst({
+                    id,
+                    dataType: this.dataType,
+                    init: snip(this[$soul].value, this.dataType, 'constant'),
+                });
+            },
+        }), {
+            codegenMode: {
+                getBaseSnippet(trackingProxy) {
+                    return snip(trackingProxy, this.dataType, 'constant-immutable-def', 
+                    /* possibleSideEffects */ false);
+                },
+            },
+            normalMode: {
+                get() {
+                    return this[$soul].value;
+                },
+            },
+        });
+    }
+    constructor(dataType, value) {
+        this[$soul] = {
+            type: 'const',
+            dataType,
+            value: value && typeof value === 'object'
+                ? deepFreeze(value)
+                : value,
+            label: undefined,
+        };
+    }
+    get dataType() {
+        return this[$soul].dataType;
+    }
+    $name(label) {
+        setName(this, label);
+        return this;
+    }
 }
-var TgpuConstImpl = class {
-	[$internal] = {};
-	resourceType;
-	dataType;
-	#value;
-	constructor(dataType, value) {
-		this.resourceType = "const";
-		this.dataType = dataType;
-		this.#value = value && typeof value === "object" ? deepFreeze(value) : value;
-	}
-	$name(label) {
-		setName(this, label);
-		return this;
-	}
-	[$resolve](ctx) {
-		const id = ctx.makeUniqueIdentifier(getName(this), "global");
-		return ctx.gen.declareGlobalConst({
-			id,
-			dataType: this.dataType,
-			init: snip(this.#value, this.dataType, "constant")
-		});
-	}
-	toString() {
-		return `const:${getName(this) ?? "<unnamed>"}`;
-	}
-	get [$gpuValueOf]() {
-		const dataType = this.dataType;
-		return new Proxy({
-			[$internal]: true,
-			get [$ownSnippet]() {
-				return snip(this, dataType, "constant-immutable-def");
-			},
-			[$resolve]: (ctx) => ctx.resolve(this),
-			toString: () => `const:${getName(this) ?? "<unnamed>"}.$`
-		}, valueProxyHandler);
-	}
-	get $() {
-		if (inCodegenMode()) return this[$gpuValueOf];
-		return this.#value;
-	}
-	get value() {
-		return this.$;
-	}
-};
-
-//#endregion
-export { constant };

package/core/declare/tgpuDeclare.d.ts

@@ -1,10 +1,9 @@
-//#region src/core/declare/tgpuDeclare.d.ts
 /**
  * Extra declaration that shall be included in final WGSL code,
  * when resolving objects that use it.
  */
-interface TgpuDeclare {
-  $uses(dependencyMap: Record<string, unknown>): this;
+export interface TgpuDeclare {
+    $uses(dependencyMap: Record<string, unknown>): this;
 }
 /**
  * Allows defining extra declarations that shall be included in the final WGSL code,
@@ -13,6 +12,4 @@ interface TgpuDeclare {
  * Using this API is generally discouraged, as it shouldn't be necessary in any common scenario.
  * It was developed to ensure full compatibility of TypeGPU programs with current and future versions of WGSL.
  */
-declare function declare(declaration: string): TgpuDeclare;
-//#endregion
-export { TgpuDeclare, declare };
+export declare function declare(declaration: string): TgpuDeclare;

package/core/declare/tgpuDeclare.js

@@ -1,41 +1,40 @@
-import { $internal, $resolve } from "../../shared/symbols.js";
-import { Void } from "../../data/wgslTypes.js";
 import { snip } from "../../data/snippet.js";
-import { mergeExternals, replaceExternalsInWgsl } from "../resolve/externals.js";
-
-//#region src/core/declare/tgpuDeclare.ts
+import { Void } from "../../data/wgslTypes.js";
+import { $internal, $resolve } from "../../shared/symbols.js";
+import { replaceExternalsInWgsl } from "../resolve/externals.js";
 /**
-* Allows defining extra declarations that shall be included in the final WGSL code,
-* when resolving objects that use them.
-*
-* Using this API is generally discouraged, as it shouldn't be necessary in any common scenario.
-* It was developed to ensure full compatibility of TypeGPU programs with current and future versions of WGSL.
-*/
-function declare(declaration) {
-	return new TgpuDeclareImpl(declaration);
+ * Allows defining extra declarations that shall be included in the final WGSL code,
+ * when resolving objects that use them.
+ *
+ * Using this API is generally discouraged, as it shouldn't be necessary in any common scenario.
+ * It was developed to ensure full compatibility of TypeGPU programs with current and future versions of WGSL.
+ */
+export function declare(declaration) {
+    return new TgpuDeclareImpl(declaration);
+}
+// --------------
+// Implementation
+// --------------
+class TgpuDeclareImpl {
+    [$internal] = true;
+    #externals;
+    #declaration;
+    constructor(declaration) {
+        this.#declaration = declaration;
+    }
+    $uses(dependencyMap) {
+        if (this.#externals !== undefined) {
+            throw new Error("Cannot call '$uses' multiple times. If you wish to override dependencies, use slots or accessors instead.");
+        }
+        this.#externals = dependencyMap;
+        return this;
+    }
+    [$resolve](ctx) {
+        const replacedDeclaration = replaceExternalsInWgsl(ctx, this.#externals ?? {}, this.#declaration);
+        ctx.addDeclaration(replacedDeclaration);
+        return snip('', Void, /* origin */ 'constant');
+    }
+    toString() {
+        return `declare: ${this.#declaration}`;
+    }
 }
-var TgpuDeclareImpl = class {
-	[$internal] = true;
-	#externalsToApply = [];
-	#declaration;
-	constructor(declaration) {
-		this.#declaration = declaration;
-	}
-	$uses(dependencyMap) {
-		this.#externalsToApply.push(dependencyMap);
-		return this;
-	}
-	[$resolve](ctx) {
-		const externalMap = {};
-		for (const externals of this.#externalsToApply) mergeExternals(externalMap, externals);
-		const replacedDeclaration = replaceExternalsInWgsl(ctx, externalMap, this.#declaration);
-		ctx.addDeclaration(replacedDeclaration);
-		return snip("", Void, "constant");
-	}
-	toString() {
-		return `declare: ${this.#declaration}`;
-	}
-};
-
-//#endregion
-export { declare };

package/core/function/autoIO.d.ts

@@ -1,41 +1,69 @@
-import { Assume, RemoveIndexSignature } from "../../shared/utilityTypes.js";
-import { BuiltinClipDistances, BuiltinFragDepth, BuiltinFrontFacing, BuiltinInstanceIndex, BuiltinPosition, BuiltinPrimitiveIndex, BuiltinSampleIndex, BuiltinSampleMask, BuiltinSubgroupInvocationId, BuiltinSubgroupSize, BuiltinVertexIndex, OmitBuiltins } from "../../builtin.js";
-import "../../data/snippet.js";
-import { BaseIOData } from "./fnTypes.js";
-import { TgpuVertexAttrib } from "../../shared/vertexFormat.js";
-import "../../data/autoStruct.js";
-import { FormatToWGSLType } from "../../data/vertexFormatData.js";
-import "../../types.js";
-import { v4f } from "../../data/wgslTypes.js";
-import { InferGPU, InferGPURecord, InferRecord } from "../../shared/repr.js";
-
-//#region src/core/function/autoIO.d.ts
-type AnyAutoCustoms = Record<string, InferGPU<BaseIOData>>;
+import { type OmitBuiltins } from '../../builtin.ts';
+import { AutoStruct } from '../../data/autoStruct.ts';
+import type { ResolvedSnippet } from '../../data/snippet.ts';
+import type { FormatToWGSLType } from '../../data/vertexFormatData.ts';
+import type { BaseData, v4f } from '../../data/wgslTypes.ts';
+import type { InferGPU, InferGPURecord, InferRecord } from '../../shared/repr.ts';
+import { $internal, $resolve } from '../../shared/symbols.ts';
+import type { Assume, RemoveIndexSignature } from '../../shared/utilityTypes.ts';
+import type { TgpuVertexAttrib } from '../../shared/vertexFormat.ts';
+import type { ResolutionCtx, SelfResolvable } from '../../types.ts';
+import type { BaseIOData } from './fnTypes.ts';
+export type AnyAutoCustoms = Record<string, InferGPU<BaseIOData>>;
 declare const builtinVertexIn: {
-  readonly $vertexIndex: BuiltinVertexIndex;
-  readonly $instanceIndex: BuiltinInstanceIndex;
+    readonly $vertexIndex: import("../../builtin.ts").BuiltinVertexIndex;
+    readonly $instanceIndex: import("../../builtin.ts").BuiltinInstanceIndex;
 };
-type AutoVertexIn<T extends AnyAutoCustoms> = RemoveIndexSignature<T> & InferRecord<typeof builtinVertexIn>;
-type _AutoVertexIn<T> = AutoVertexIn<{ [Key in keyof T]: T[Key] extends TgpuVertexAttrib ? InferGPU<FormatToWGSLType<T[Key]['format']>> : Assume<T[Key], InferGPU<BaseIOData>> }>;
+export type AutoVertexIn<T extends AnyAutoCustoms> = RemoveIndexSignature<T> & InferRecord<typeof builtinVertexIn>;
+export type _AutoVertexIn<T> = AutoVertexIn<{
+    [Key in keyof T]: T[Key] extends TgpuVertexAttrib ? InferGPU<FormatToWGSLType<T[Key]['format']>> : Assume<T[Key], InferGPU<BaseIOData>>;
+}>;
 declare const builtinVertexOut: {
-  readonly $clipDistances: BuiltinClipDistances;
-  readonly $position: BuiltinPosition;
+    readonly $clipDistances: import("../../builtin.ts").BuiltinClipDistances;
+    readonly $position: import("../../builtin.ts").BuiltinPosition;
 };
-type AutoVertexOut<T extends AnyAutoCustoms> = OmitBuiltins<T> & Partial<InferGPURecord<typeof builtinVertexOut>>;
+export type AutoVertexOut<T extends AnyAutoCustoms> = OmitBuiltins<T> & Partial<InferGPURecord<typeof builtinVertexOut>>;
 declare const builtinFragmentIn: {
-  readonly $position: BuiltinPosition;
-  readonly $frontFacing: BuiltinFrontFacing;
-  readonly $primitiveIndex: BuiltinPrimitiveIndex;
-  readonly $sampleIndex: BuiltinSampleIndex;
-  readonly $sampleMask: BuiltinSampleMask;
-  readonly $subgroupInvocationId: BuiltinSubgroupInvocationId;
-  readonly $subgroupSize: BuiltinSubgroupSize;
+    readonly $position: import("../../builtin.ts").BuiltinPosition;
+    readonly $frontFacing: import("../../builtin.ts").BuiltinFrontFacing;
+    readonly $primitiveIndex: import("../../builtin.ts").BuiltinPrimitiveIndex;
+    readonly $sampleIndex: import("../../builtin.ts").BuiltinSampleIndex;
+    readonly $sampleMask: import("../../builtin.ts").BuiltinSampleMask;
+    readonly $subgroupInvocationId: import("../../builtin.ts").BuiltinSubgroupInvocationId;
+    readonly $subgroupSize: import("../../builtin.ts").BuiltinSubgroupSize;
 };
-type AutoFragmentIn<T extends AnyAutoCustoms> = RemoveIndexSignature<T> & InferRecord<typeof builtinFragmentIn>;
+export type AutoFragmentIn<T extends AnyAutoCustoms> = RemoveIndexSignature<T> & InferRecord<typeof builtinFragmentIn>;
 declare const builtinFragmentOut: {
-  readonly $fragDepth: BuiltinFragDepth;
-  readonly $sampleMask: BuiltinSampleMask;
+    readonly $fragDepth: import("../../builtin.ts").BuiltinFragDepth;
+    readonly $sampleMask: import("../../builtin.ts").BuiltinSampleMask;
 };
-type AutoFragmentOut<T extends undefined | v4f | AnyAutoCustoms> = T extends undefined | v4f ? T : T & Partial<InferGPURecord<typeof builtinFragmentOut>>;
-//#endregion
-export { AnyAutoCustoms, AutoFragmentIn, AutoFragmentOut, AutoVertexIn, AutoVertexOut, _AutoVertexIn };
+export type AutoFragmentOut<T extends undefined | v4f | AnyAutoCustoms> = T extends undefined | v4f ? T : T & Partial<InferGPURecord<typeof builtinFragmentOut>>;
+type AutoFragmentFnImpl = (input: AutoFragmentIn<Record<string, never>>) => AutoFragmentOut<undefined | v4f | AnyAutoCustoms>;
+/**
+ * Only used internally. Meant to be recreated on every resolution.
+ */
+export declare class AutoFragmentFn implements SelfResolvable {
+    #private;
+    [$internal]: true;
+    resourceType: 'auto-fragment-fn';
+    autoIn: AutoStruct;
+    autoOut: AutoStruct;
+    constructor(impl: AutoFragmentFnImpl, varyings: Record<string, BaseData>, locations?: Record<string, number>);
+    toString(): string;
+    [$resolve](ctx: ResolutionCtx): ResolvedSnippet;
+}
+type AutoVertexFnImpl = (input: AutoVertexIn<Record<string, never>>) => AutoVertexOut<AnyAutoCustoms>;
+/**
+ * Only used internally. Meant to be recreated on every resolution.
+ */
+export declare class AutoVertexFn implements SelfResolvable {
+    #private;
+    [$internal]: true;
+    resourceType: 'auto-vertex-fn';
+    autoIn: AutoStruct;
+    autoOut: AutoStruct;
+    constructor(impl: AutoVertexFnImpl, attribs: Record<string, BaseData>, locations?: Record<string, number>);
+    toString(): string;
+    [$resolve](ctx: ResolutionCtx): ResolvedSnippet;
+}
+export {};

package/core/function/autoIO.js

@@ -1,87 +1,82 @@
-import { $internal, $resolve } from "../../shared/symbols.js";
-import { getName, setName } from "../../shared/meta.js";
-import { vec4f } from "../../data/vector.js";
+import { builtin } from "../../builtin.js";
 import { AutoStruct } from "../../data/autoStruct.js";
-import { createFnCore } from "./fnCore.js";
+import { vec4f } from "../../data/vector.js";
+import { getName, setName } from "../../shared/meta.js";
+import { $internal, $resolve } from "../../shared/symbols.js";
 import { shaderStageSlot } from "../slot/internalSlots.js";
-import { builtin } from "../../builtin.js";
-
-//#region src/core/function/autoIO.ts
+import { createFnCore } from "./fnCore.js";
 const builtinVertexIn = {
-	$vertexIndex: builtin.vertexIndex,
-	$instanceIndex: builtin.instanceIndex
+    $vertexIndex: builtin.vertexIndex,
+    $instanceIndex: builtin.instanceIndex,
 };
 const builtinVertexOut = {
-	$clipDistances: builtin.clipDistances,
-	$position: builtin.position
+    $clipDistances: builtin.clipDistances,
+    $position: builtin.position,
 };
 const builtinFragmentIn = {
-	$position: builtin.position,
-	$frontFacing: builtin.frontFacing,
-	$primitiveIndex: builtin.primitiveIndex,
-	$sampleIndex: builtin.sampleIndex,
-	$sampleMask: builtin.sampleMask,
-	$subgroupInvocationId: builtin.subgroupInvocationId,
-	$subgroupSize: builtin.subgroupSize
+    $position: builtin.position,
+    $frontFacing: builtin.frontFacing,
+    $primitiveIndex: builtin.primitiveIndex,
+    $sampleIndex: builtin.sampleIndex,
+    $sampleMask: builtin.sampleMask,
+    $subgroupInvocationId: builtin.subgroupInvocationId,
+    $subgroupSize: builtin.subgroupSize,
 };
 const builtinFragmentOut = {
-	$fragDepth: builtin.fragDepth,
-	$sampleMask: builtin.sampleMask
+    $fragDepth: builtin.fragDepth,
+    $sampleMask: builtin.sampleMask,
 };
 /**
-* Only used internally. Meant to be recreated on every resolution.
-*/
-var AutoFragmentFn = class {
-	#core;
-	autoIn;
-	autoOut;
-	constructor(impl, varyings, locations) {
-		if (!getName(impl)) setName(impl, "fragmentFn");
-		this.#core = createFnCore(impl, "fragment");
-		this.autoIn = new AutoStruct({
-			...builtinFragmentIn,
-			...varyings
-		}, void 0, locations);
-		setName(this.autoIn, "FragmentIn");
-		this.autoOut = new AutoStruct(builtinFragmentOut, vec4f);
-		setName(this.autoOut, "FragmentOut");
-	}
-	toString() {
-		return "autoFragmentFn";
-	}
-	[$resolve](ctx) {
-		return ctx.withSlots([[shaderStageSlot, "fragment"]], () => this.#core.resolve(ctx, [this.autoIn], this.autoOut));
-	}
-};
+ * Only used internally. Meant to be recreated on every resolution.
+ */
+export class AutoFragmentFn {
+    #core;
+    autoIn;
+    autoOut;
+    constructor(impl, varyings, locations) {
+        // If the implementation is not named, we can fallback to "fragmentFn"
+        if (!getName(impl)) {
+            setName(impl, 'fragmentFn');
+        }
+        this.#core = createFnCore(impl, 'fragment');
+        this.autoIn = new AutoStruct({ ...builtinFragmentIn, ...varyings }, undefined, locations);
+        setName(this.autoIn, 'FragmentIn');
+        this.autoOut = new AutoStruct(builtinFragmentOut, vec4f);
+        setName(this.autoOut, 'FragmentOut');
+    }
+    toString() {
+        return 'autoFragmentFn';
+    }
+    [$resolve](ctx) {
+        return ctx.withSlots([[shaderStageSlot, 'fragment']], () => this.#core.resolve(ctx, [this.autoIn], this.autoOut));
+    }
+}
 AutoFragmentFn.prototype[$internal] = true;
-AutoFragmentFn.prototype.resourceType = "auto-fragment-fn";
+AutoFragmentFn.prototype.resourceType = 'auto-fragment-fn';
 /**
-* Only used internally. Meant to be recreated on every resolution.
-*/
-var AutoVertexFn = class {
-	#core;
-	autoIn;
-	autoOut;
-	constructor(impl, attribs, locations) {
-		if (!getName(impl)) setName(impl, "vertexFn");
-		this.#core = createFnCore(impl, "vertex");
-		this.autoIn = new AutoStruct({
-			...builtinVertexIn,
-			...attribs
-		}, void 0, locations);
-		setName(this.autoIn, "VertexIn");
-		this.autoOut = new AutoStruct(builtinVertexOut, void 0);
-		setName(this.autoOut, "VertexOut");
-	}
-	toString() {
-		return "autoVertexFn";
-	}
-	[$resolve](ctx) {
-		return ctx.withSlots([[shaderStageSlot, "vertex"]], () => this.#core.resolve(ctx, [this.autoIn], this.autoOut));
-	}
-};
+ * Only used internally. Meant to be recreated on every resolution.
+ */
+export class AutoVertexFn {
+    #core;
+    autoIn;
+    autoOut;
+    constructor(impl, attribs, locations) {
+        // If the implementation is not named, we can fallback to "vertexFn"
+        if (!getName(impl)) {
+            setName(impl, 'vertexFn');
+        }
+        this.#core = createFnCore(impl, 'vertex');
+        this.autoIn = new AutoStruct({ ...builtinVertexIn, ...attribs }, undefined, locations);
+        setName(this.autoIn, 'VertexIn');
+        this.autoOut = new AutoStruct(builtinVertexOut, undefined);
+        setName(this.autoOut, 'VertexOut');
+    }
+    toString() {
+        return 'autoVertexFn';
+    }
+    [$resolve](ctx) {
+        return ctx.withSlots([[shaderStageSlot, 'vertex']], () => this.#core.resolve(ctx, [this.autoIn], this.autoOut));
+    }
+}
 AutoVertexFn.prototype[$internal] = true;
-AutoVertexFn.prototype.resourceType = "auto-vertex-fn";
-
-//#endregion
-export { AutoFragmentFn, AutoVertexFn };
+AutoVertexFn.prototype.resourceType = 'auto-vertex-fn';

package/core/function/comptime.d.ts

@@ -1,15 +1,14 @@
-import { TgpuNamable } from "../../shared/meta.js";
-import { $getNameForward, $internal } from "../../shared/symbols.js";
-import { DualFn } from "../../types.js";
-
-//#region src/core/function/comptime.d.ts
+import { type TgpuNamable } from '../../shared/meta.ts';
+import { $getNameForward, $internal } from '../../shared/symbols.ts';
+import { type DualFn } from '../../types.ts';
 type AnyFn = (...args: never[]) => unknown;
-type TgpuComptime<T extends AnyFn = AnyFn> = DualFn<T> & TgpuNamable & {
-  [$getNameForward]: unknown;
-  [$internal]: {
-    isComptime: true;
-  };
+export type TgpuComptime<T extends AnyFn = AnyFn> = DualFn<T> & TgpuNamable & {
+    [$getNameForward]: unknown;
+    [$internal]: {
+        isComptime: true;
+    };
 };
+export declare function isComptimeFn(value: unknown): value is TgpuComptime;
 /**
  * Creates a version of `func` that can called safely in a TypeGPU function to
  * precompute and inject a value into the final shader code.
@@ -34,6 +33,5 @@ type TgpuComptime<T extends AnyFn = AnyFn> = DualFn<T> & TgpuNamable & {
  * };
  * ```
  */
-declare function comptime<T extends (...args: never[]) => unknown>(func: T): TgpuComptime<T>;
-//#endregion
-export { TgpuComptime, comptime };
+export declare function comptime<T extends (...args: never[]) => unknown>(func: T): TgpuComptime<T>;
+export {};