typegpu 0.10.1 → 0.10.2

package/core/buffer/bufferUsage.js

@@ -0,0 +1,163 @@
+import { $getNameForward, $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.js";
+import { isNaturallyEphemeral } from "../../data/wgslTypes.js";
+import { snip } from "../../data/snippet.js";
+import { IllegalBufferAccessError } from "../../errors.js";
+import { getExecMode, inCodegenMode, isInsideTgpuFn } from "../../execMode.js";
+import { schemaCallWrapper } from "../../data/schemaCallWrapper.js";
+import { assertExhaustive } from "../../shared/utilityTypes.js";
+import { valueProxyHandler } from "../valueProxyUtils.js";
+import { isUsableAsStorage } from "../../extension.js";
+
+//#region src/core/buffer/bufferUsage.ts
+function isUsableAsUniform(buffer) {
+	return !!buffer.usableAsUniform;
+}
+const usageToVarTemplateMap = {
+	uniform: "uniform",
+	mutable: "storage, read_write",
+	readonly: "storage, read"
+};
+var TgpuFixedBufferImpl = class {
+	resourceType = "buffer-usage";
+	[$internal];
+	[$getNameForward];
+	constructor(usage, buffer) {
+		this.usage = usage;
+		this.buffer = buffer;
+		this[$internal] = { dataType: buffer.dataType };
+		this[$getNameForward] = buffer;
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+	[$resolve](ctx) {
+		const dataType = this.buffer.dataType;
+		const id = ctx.getUniqueName(this);
+		const { group, binding } = ctx.allocateFixedEntry(this.usage === "uniform" ? { uniform: dataType } : {
+			storage: dataType,
+			access: this.usage
+		}, this.buffer);
+		const usage = usageToVarTemplateMap[this.usage];
+		ctx.addDeclaration(`@group(${group}) @binding(${binding}) var<${usage}> ${id}: ${ctx.resolve(dataType).value};`);
+		return snip(id, dataType, isNaturallyEphemeral(dataType) ? "runtime" : this.usage);
+	}
+	toString() {
+		return `${this.usage}:${getName(this) ?? "<unnamed>"}`;
+	}
+	get [$gpuValueOf]() {
+		const dataType = this.buffer.dataType;
+		const usage = this.usage;
+		return new Proxy({
+			[$internal]: true,
+			get [$ownSnippet]() {
+				return snip(this, dataType, isNaturallyEphemeral(dataType) ? "runtime" : usage);
+			},
+			[$resolve]: (ctx) => ctx.resolve(this),
+			toString: () => `${this.usage}:${getName(this) ?? "<unnamed>"}.$`
+		}, valueProxyHandler);
+	}
+	get $() {
+		const mode = getExecMode();
+		const insideTgpuFn = isInsideTgpuFn();
+		if (mode.type === "normal") throw new IllegalBufferAccessError(insideTgpuFn ? `Cannot access ${String(this.buffer)}. TypeGPU functions that depends on GPU resources need to be part of a compute dispatch, draw call or simulation` : ".$ is inaccessible during normal JS execution. Try `.read()`");
+		if (mode.type === "codegen") return this[$gpuValueOf];
+		if (mode.type === "simulate") {
+			if (!mode.buffers.has(this.buffer)) mode.buffers.set(this.buffer, schemaCallWrapper(this.buffer.dataType, this.buffer.initial));
+			return mode.buffers.get(this.buffer);
+		}
+		return assertExhaustive(mode, "bufferUsage.ts#TgpuFixedBufferImpl/$");
+	}
+	get value() {
+		return this.$;
+	}
+	set $(value) {
+		const mode = getExecMode();
+		const insideTgpuFn = isInsideTgpuFn();
+		if (mode.type === "normal") throw new IllegalBufferAccessError(insideTgpuFn ? `Cannot access ${String(this.buffer)}. TypeGPU functions that depends on GPU resources need to be part of a compute dispatch, draw call or simulation` : ".$ is inaccessible during normal JS execution. Try `.write()`");
+		if (mode.type === "codegen") throw new Error("Unreachable bufferUsage.ts#TgpuFixedBufferImpl/$");
+		if (mode.type === "simulate") {
+			mode.buffers.set(this.buffer, value);
+			return;
+		}
+		assertExhaustive(mode, "bufferUsage.ts#TgpuFixedBufferImpl/$");
+	}
+	set value(value) {
+		this.$ = value;
+	}
+};
+var TgpuLaidOutBufferImpl = class {
+	[$internal];
+	resourceType = "buffer-usage";
+	#membership;
+	constructor(usage, dataType, membership) {
+		this.usage = usage;
+		this.dataType = dataType;
+		this[$internal] = { dataType };
+		this.#membership = membership;
+		setName(this, membership.key);
+	}
+	[$resolve](ctx) {
+		const id = ctx.getUniqueName(this);
+		const group = ctx.allocateLayoutEntry(this.#membership.layout);
+		const usage = usageToVarTemplateMap[this.usage];
+		ctx.addDeclaration(`@group(${group}) @binding(${this.#membership.idx}) var<${usage}> ${id}: ${ctx.resolve(this.dataType).value};`);
+		return snip(id, this.dataType, isNaturallyEphemeral(this.dataType) ? "runtime" : this.usage);
+	}
+	toString() {
+		return `${this.usage}:${getName(this) ?? "<unnamed>"}`;
+	}
+	get [$gpuValueOf]() {
+		const schema = this.dataType;
+		const usage = this.usage;
+		return new Proxy({
+			[$internal]: true,
+			get [$ownSnippet]() {
+				return snip(this, schema, isNaturallyEphemeral(schema) ? "runtime" : usage);
+			},
+			[$resolve]: (ctx) => ctx.resolve(this),
+			toString: () => `${this.usage}:${getName(this) ?? "<unnamed>"}.$`
+		}, valueProxyHandler);
+	}
+	get $() {
+		if (inCodegenMode()) return this[$gpuValueOf];
+		throw new Error("Direct access to buffer values is possible only as part of a compute dispatch or draw call. Try .read() or .write() instead");
+	}
+	get value() {
+		return this.$;
+	}
+};
+const mutableUsageMap = /* @__PURE__ */ new WeakMap();
+function mutable(buffer) {
+	if (!isUsableAsStorage(buffer)) throw new Error(`Cannot call as('mutable') on ${buffer}, as it is not allowed to be used as storage. To allow it, call .$usage('storage') when creating the buffer.`);
+	let usage = mutableUsageMap.get(buffer);
+	if (!usage) {
+		usage = new TgpuFixedBufferImpl("mutable", buffer);
+		mutableUsageMap.set(buffer, usage);
+	}
+	return usage;
+}
+const readonlyUsageMap = /* @__PURE__ */ new WeakMap();
+function readonly(buffer) {
+	if (!isUsableAsStorage(buffer)) throw new Error(`Cannot call as('readonly') on ${buffer}, as it is not allowed to be used as storage. To allow it, call .$usage('storage') when creating the buffer.`);
+	let usage = readonlyUsageMap.get(buffer);
+	if (!usage) {
+		usage = new TgpuFixedBufferImpl("readonly", buffer);
+		readonlyUsageMap.set(buffer, usage);
+	}
+	return usage;
+}
+const uniformUsageMap = /* @__PURE__ */ new WeakMap();
+function uniform(buffer) {
+	if (!isUsableAsUniform(buffer)) throw new Error(`Cannot call as('uniform') on ${buffer}, as it is not allowed to be used as a uniform. To allow it, call .$usage('uniform') when creating the buffer.`);
+	let usage = uniformUsageMap.get(buffer);
+	if (!usage) {
+		usage = new TgpuFixedBufferImpl("uniform", buffer);
+		uniformUsageMap.set(buffer, usage);
+	}
+	return usage;
+}
+
+//#endregion
+export { TgpuLaidOutBufferImpl, isUsableAsUniform, mutable, readonly, uniform };

package/core/constant/tgpuConstant.d.ts

@@ -0,0 +1,28 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $gpuValueOf, $internal } from "../../shared/symbols.js";
+import { BaseData } from "../../data/wgslTypes.js";
+import { InferGPU } from "../../shared/repr.js";
+import { AnyData } from "../../data/dataTypes.js";
+
+//#region src/core/constant/tgpuConstant.d.ts
+type DeepReadonly<T> = T extends {
+  [$internal]: unknown;
+} ? T : T extends unknown[] ? ReadonlyArray<DeepReadonly<T[number]>> : T extends Record<string, unknown> ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T;
+interface TgpuConst<TDataType extends BaseData = BaseData> extends TgpuNamable {
+  readonly resourceType: 'const';
+  readonly [$gpuValueOf]: DeepReadonly<InferGPU<TDataType>>;
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: DeepReadonly<InferGPU<TDataType>>;
+  readonly $: DeepReadonly<InferGPU<TDataType>>;
+  readonly [$internal]: {
+    /** Makes it differentiable on the type level. Does not exist at runtime. */dataType?: TDataType;
+  };
+}
+/**
+ * Creates a module constant with specified value.
+ */
+declare function constant<TDataType extends AnyData>(dataType: TDataType, value: InferGPU<TDataType>): TgpuConst<TDataType>;
+//#endregion
+export { TgpuConst, constant };

package/core/constant/tgpuConstant.js

@@ -0,0 +1,67 @@
+import { $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.js";
+import { isNaturallyEphemeral } from "../../data/wgslTypes.js";
+import { snip } from "../../data/snippet.js";
+import { inCodegenMode } from "../../execMode.js";
+import { valueProxyHandler } from "../valueProxyUtils.js";
+
+//#region src/core/constant/tgpuConstant.ts
+/**
+* Creates a module constant with specified value.
+*/
+function constant(dataType, value) {
+	return new TgpuConstImpl(dataType, value);
+}
+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);
+}
+var TgpuConstImpl = class {
+	[$internal] = {};
+	resourceType;
+	#value;
+	constructor(dataType, value) {
+		this.dataType = dataType;
+		this.resourceType = "const";
+		this.#value = value && typeof value === "object" ? deepFreeze(value) : value;
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+	[$resolve](ctx) {
+		const id = ctx.getUniqueName(this);
+		const resolvedDataType = ctx.resolve(this.dataType).value;
+		const resolvedValue = ctx.resolve(this.#value, this.dataType).value;
+		ctx.addDeclaration(`const ${id}: ${resolvedDataType} = ${resolvedValue};`);
+		return snip(id, this.dataType, isNaturallyEphemeral(this.dataType) ? "constant" : "constant-tgpu-const-ref");
+	}
+	toString() {
+		return `const:${getName(this) ?? "<unnamed>"}`;
+	}
+	get [$gpuValueOf]() {
+		const dataType = this.dataType;
+		return new Proxy({
+			[$internal]: true,
+			get [$ownSnippet]() {
+				return snip(this, dataType, isNaturallyEphemeral(dataType) ? "constant" : "constant-tgpu-const-ref");
+			},
+			[$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

@@ -0,0 +1,18 @@
+//#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;
+}
+/**
+ * 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.
+ */
+declare function declare(declaration: string): TgpuDeclare;
+//#endregion
+export { TgpuDeclare, declare };

package/core/declare/tgpuDeclare.js

@@ -0,0 +1,40 @@
+import { $internal, $resolve } from "../../shared/symbols.js";
+import { Void } from "../../data/wgslTypes.js";
+import { snip } from "../../data/snippet.js";
+import { applyExternals, replaceExternalsInWgsl } from "../resolve/externals.js";
+
+//#region src/core/declare/tgpuDeclare.ts
+/**
+* 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);
+}
+var TgpuDeclareImpl = class {
+	[$internal] = true;
+	externalsToApply = [];
+	constructor(declaration) {
+		this.declaration = declaration;
+	}
+	$uses(dependencyMap) {
+		this.externalsToApply.push(dependencyMap);
+		return this;
+	}
+	[$resolve](ctx) {
+		const externalMap = {};
+		for (const externals of this.externalsToApply) applyExternals(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

@@ -0,0 +1,37 @@
+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 "../../data/autoStruct.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>>;
+declare const builtinVertexIn: {
+  readonly $vertexIndex: BuiltinVertexIndex;
+  readonly $instanceIndex: BuiltinInstanceIndex;
+};
+type AutoVertexIn<T extends AnyAutoCustoms> = T & InferRecord<typeof builtinVertexIn>;
+declare const builtinVertexOut: {
+  readonly $clipDistances: BuiltinClipDistances;
+  readonly $position: BuiltinPosition;
+};
+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;
+};
+type AutoFragmentIn<T extends AnyAutoCustoms> = T & InferRecord<typeof builtinFragmentIn>;
+declare const builtinFragmentOut: {
+  readonly $fragDepth: BuiltinFragDepth;
+  readonly $sampleMask: 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 };

package/core/function/autoIO.js

@@ -0,0 +1,87 @@
+import { $internal, $resolve } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.js";
+import { vec4f } from "../../data/vector.js";
+import { AutoStruct } from "../../data/autoStruct.js";
+import { createFnCore } from "./fnCore.js";
+import { shaderStageSlot } from "../slot/internalSlots.js";
+import { builtin } from "../../builtin.js";
+
+//#region src/core/function/autoIO.ts
+const builtinVertexIn = {
+	$vertexIndex: builtin.vertexIndex,
+	$instanceIndex: builtin.instanceIndex
+};
+const builtinVertexOut = {
+	$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
+};
+const builtinFragmentOut = {
+	$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));
+	}
+};
+AutoFragmentFn.prototype[$internal] = true;
+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));
+	}
+};
+AutoVertexFn.prototype[$internal] = true;
+AutoVertexFn.prototype.resourceType = "auto-vertex-fn";
+
+//#endregion
+export { AutoFragmentFn, AutoVertexFn };

package/core/function/comptime.d.ts

@@ -0,0 +1,39 @@
+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
+type AnyFn = (...args: never[]) => unknown;
+type TgpuComptime<T extends AnyFn = AnyFn> = DualFn<T> & TgpuNamable & {
+  [$getNameForward]: unknown;
+  [$internal]: {
+    isComptime: true;
+  };
+};
+/**
+ * Creates a version of `func` that can called safely in a TypeGPU function to
+ * precompute and inject a value into the final shader code.
+ *
+ * Note how the function passed into `comptime` doesn't have to be marked with
+ * 'use gpu'. That's because the function doesn't execute on the GPU, it gets
+ * executed before the shader code gets sent to the GPU.
+ *
+ * @example
+ * ```ts
+ * const color = tgpu.comptime((int: number) => {
+ *   const r = (int >> 16) & 0xff;
+ *   const g = (int >> 8) & 0xff;
+ *   const b = int & 0xff;
+ *   return d.vec3f(r / 255, g / 255, b / 255);
+ * });
+ *
+ * const material = (diffuse: d.v3f): d.v3f => {
+ *   'use gpu';
+ *   const albedo = color(0xff00ff);
+ *   return albedo.mul(diffuse);
+ * };
+ * ```
+ */
+declare function comptime<T extends (...args: never[]) => unknown>(func: T): TgpuComptime<T>;
+//#endregion
+export { TgpuComptime, comptime };

package/core/function/comptime.js

@@ -0,0 +1,51 @@
+import { $getNameForward, $gpuCallable, $internal } from "../../shared/symbols.js";
+import { setName } from "../../shared/meta.js";
+import { WgslTypeError } from "../../errors.js";
+import { isKnownAtComptime } from "../../types.js";
+import { coerceToSnippet } from "../../tgsl/generationHelpers.js";
+
+//#region src/core/function/comptime.ts
+/**
+* Creates a version of `func` that can called safely in a TypeGPU function to
+* precompute and inject a value into the final shader code.
+*
+* Note how the function passed into `comptime` doesn't have to be marked with
+* 'use gpu'. That's because the function doesn't execute on the GPU, it gets
+* executed before the shader code gets sent to the GPU.
+*
+* @example
+* ```ts
+* const color = tgpu.comptime((int: number) => {
+*   const r = (int >> 16) & 0xff;
+*   const g = (int >> 8) & 0xff;
+*   const b = int & 0xff;
+*   return d.vec3f(r / 255, g / 255, b / 255);
+* });
+*
+* const material = (diffuse: d.v3f): d.v3f => {
+*   'use gpu';
+*   const albedo = color(0xff00ff);
+*   return albedo.mul(diffuse);
+* };
+* ```
+*/
+function comptime(func) {
+	const impl = ((...args) => {
+		return func(...args);
+	});
+	impl.toString = () => "comptime";
+	impl[$getNameForward] = func;
+	impl[$gpuCallable] = { call(_ctx, args) {
+		if (!args.every((s) => isKnownAtComptime(s))) throw new WgslTypeError(`Called comptime function with runtime-known values: ${args.filter((s) => !isKnownAtComptime(s)).map((s) => `'${s.value}'`).join(", ")}`);
+		return coerceToSnippet(func(...args.map((s) => s.value)));
+	} };
+	impl.$name = (label) => {
+		setName(func, label);
+		return impl;
+	};
+	Object.defineProperty(impl, $internal, { value: { isComptime: true } });
+	return impl;
+}
+
+//#endregion
+export { comptime };

package/core/function/createCallableSchema.js

@@ -0,0 +1,42 @@
+import { $gpuCallable } from "../../shared/symbols.js";
+import { setName } from "../../shared/meta.js";
+import { isPtr } from "../../data/wgslTypes.js";
+import { snip } from "../../data/snippet.js";
+import { NormalState, isKnownAtComptime } from "../../types.js";
+import { tryConvertSnippet } from "../../tgsl/conversion.js";
+
+//#region src/core/function/createCallableSchema.ts
+function callableSchema(options) {
+	const impl = ((...args) => {
+		return options.normalImpl(...args);
+	});
+	setName(impl, options.name);
+	impl.toString = () => options.name;
+	impl[$gpuCallable] = {
+		get strictSignature() {},
+		call(ctx, args) {
+			const { argTypes, returnType } = options.signature(...args.map((s) => {
+				if (isPtr(s.dataType) && s.dataType.implicit) return s.dataType.inner;
+				return s.dataType;
+			}));
+			const converted = args.map((s, idx) => {
+				const argType = argTypes[idx];
+				if (!argType) throw new Error("Function called with invalid arguments");
+				return tryConvertSnippet(ctx, s, argType, false);
+			});
+			if (converted.every((s) => isKnownAtComptime(s))) {
+				ctx.pushMode(new NormalState());
+				try {
+					return snip(options.normalImpl(...converted.map((s) => s.value)), returnType, "constant");
+				} finally {
+					ctx.popMode("normal");
+				}
+			}
+			return snip(options.codegenImpl(ctx, converted), returnType, "runtime");
+		}
+	};
+	return impl;
+}
+
+//#endregion
+export { callableSchema };

package/core/function/dualImpl.js

@@ -0,0 +1,54 @@
+import { $gpuCallable } from "../../shared/symbols.js";
+import { setName } from "../../shared/meta.js";
+import { isPtr } from "../../data/wgslTypes.js";
+import { snip } from "../../data/snippet.js";
+import { NormalState, isKnownAtComptime } from "../../types.js";
+import { tryConvertSnippet } from "../../tgsl/conversion.js";
+import { concretize } from "../../tgsl/generationHelpers.js";
+
+//#region src/core/function/dualImpl.ts
+var MissingCpuImplError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = this.constructor.name;
+	}
+};
+function dualImpl(options) {
+	const impl = ((...args) => {
+		if (typeof options.normalImpl === "string") throw new MissingCpuImplError(options.normalImpl);
+		return options.normalImpl(...args);
+	});
+	setName(impl, options.name);
+	impl.toString = () => options.name ?? "<unknown>";
+	impl[$gpuCallable] = {
+		get strictSignature() {
+			return typeof options.signature !== "function" ? options.signature : void 0;
+		},
+		call(ctx, args) {
+			const { argTypes, returnType } = typeof options.signature === "function" ? options.signature(...args.map((s) => {
+				if (isPtr(s.dataType) && s.dataType.implicit) return s.dataType.inner;
+				return s.dataType;
+			})) : options.signature;
+			const converted = args.map((s, idx) => {
+				const argType = argTypes[idx];
+				if (!argType) throw new Error("Function called with invalid arguments");
+				return tryConvertSnippet(ctx, s, argType, !options.ignoreImplicitCastWarning);
+			});
+			if (!options.noComptime && converted.every((s) => isKnownAtComptime(s)) && typeof options.normalImpl === "function") {
+				ctx.pushMode(new NormalState());
+				try {
+					return snip(options.normalImpl(...converted.map((s) => s.value)), returnType, "constant");
+				} catch (e) {
+					if (!(e instanceof MissingCpuImplError)) throw e;
+				} finally {
+					ctx.popMode("normal");
+				}
+			}
+			return snip(options.codegenImpl(ctx, converted), concretize(returnType), "runtime");
+		}
+	};
+	return impl;
+}
+
+//#endregion
+export { MissingCpuImplError, dualImpl };