typegpu 0.10.1 → 0.11.0-rc.1

package/core/function/tgpuComputeFn.d.ts

@@ -0,0 +1,48 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $internal } from "../../shared/symbols.js";
+import { AnyComputeBuiltin } from "../../builtin.js";
+import { IORecord, InferIO } from "./fnTypes.js";
+import { Void } from "../../data/wgslTypes.js";
+
+//#region src/core/function/tgpuComputeFn.d.ts
+/**
+ * Describes a compute entry function signature (its arguments, return type and workgroup size)
+ */
+type TgpuComputeFnShellHeader<ComputeIn extends IORecord<AnyComputeBuiltin>> = {
+  readonly argTypes: ComputeIn[keyof ComputeIn][];
+  readonly returnType: Void;
+  readonly workgroupSize: number[];
+  readonly entryPoint: 'compute';
+};
+/**
+ * Describes a compute entry function signature (its arguments, return type and workgroup size).
+ * Allows creating tgpu compute functions by calling this shell
+ * and passing the implementation (as WGSL string or JS function) as the argument.
+ */
+type TgpuComputeFnShell<ComputeIn extends IORecord<AnyComputeBuiltin>> = TgpuComputeFnShellHeader<ComputeIn> &
+/**
+ * Creates a type-safe implementation of this signature
+ */
+((implementation: (input: InferIO<ComputeIn>) => undefined) => TgpuComputeFn<ComputeIn>) &
+/**
+ * @param implementation
+ *   Raw WGSL function implementation with header and body
+ *   without `fn` keyword and function name
+ *   e.g. `"(x: f32) -> f32 { return x; }"`;
+ */
+((implementation: string) => TgpuComputeFn<ComputeIn>) & ((strings: TemplateStringsArray, ...values: unknown[]) => TgpuComputeFn<ComputeIn>);
+interface TgpuComputeFn<ComputeIn extends IORecord<AnyComputeBuiltin> = any> extends TgpuNamable {
+  readonly [$internal]: true;
+  readonly shell: TgpuComputeFnShellHeader<ComputeIn>;
+  $uses(dependencyMap: Record<string, unknown>): this;
+}
+declare function computeFn(options: {
+  workgroupSize: number[];
+}): TgpuComputeFnShell<{}>;
+declare function computeFn<ComputeIn extends IORecord<AnyComputeBuiltin>>(options: {
+  in: ComputeIn;
+  workgroupSize: number[];
+}): TgpuComputeFnShell<ComputeIn>;
+declare function isTgpuComputeFn<ComputeIn extends IORecord<AnyComputeBuiltin>>(value: unknown): value is TgpuComputeFn<ComputeIn>;
+//#endregion
+export { TgpuComputeFn, TgpuComputeFnShell, computeFn, isTgpuComputeFn };

package/core/function/tgpuComputeFn.js

@@ -0,0 +1,55 @@
+import { $getNameForward, $internal, $resolve } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.js";
+import { Void } from "../../data/wgslTypes.js";
+import { separateBuiltins } from "./ioSchema.js";
+import { createFnCore } from "./fnCore.js";
+import { stripTemplate } from "./templateUtils.js";
+import { shaderStageSlot } from "../slot/internalSlots.js";
+//#region src/core/function/tgpuComputeFn.ts
+/**
+* Creates a shell of a typed entry function for the compute shader stage. Any function
+* that implements this shell can perform general-purpose computation.
+*
+* @param options.in
+*   Record with builtins used by the compute shader.
+* @param options.workgroupSize
+*   Size of blocks that the thread grid will be divided into (up to 3 dimensions).
+*/
+function computeFn(options) {
+	const shell = {
+		argTypes: Object.values(options.in ?? {}),
+		returnType: Void,
+		workgroupSize: options.workgroupSize,
+		entryPoint: "compute"
+	};
+	const entryInput = separateBuiltins(options.in ?? {});
+	const call = (arg, ...values) => createComputeFn(shell, options.workgroupSize, stripTemplate(arg, ...values), entryInput);
+	return Object.assign(call, shell);
+}
+function isTgpuComputeFn(value) {
+	return value?.shell?.entryPoint === "compute";
+}
+function createComputeFn(shell, workgroupSize, implementation, entryInput) {
+	const core = createFnCore(implementation, `@compute @workgroup_size(${workgroupSize.join(", ")}) `);
+	return {
+		shell,
+		$uses(newExternals) {
+			core.applyExternals(newExternals);
+			return this;
+		},
+		[$internal]: true,
+		[$getNameForward]: core,
+		$name(newLabel) {
+			setName(this, newLabel);
+			return this;
+		},
+		[$resolve](ctx) {
+			return ctx.withSlots([[shaderStageSlot, "compute"]], () => core.resolve(ctx, [], shell.returnType, entryInput));
+		},
+		toString() {
+			return `computeFn:${getName(core) ?? "<unnamed>"}`;
+		}
+	};
+}
+//#endregion
+export { computeFn, isTgpuComputeFn };

package/core/function/tgpuFn.d.ts

@@ -0,0 +1,52 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $internal, $providing } from "../../shared/symbols.js";
+import { Prettify } from "../../shared/utilityTypes.js";
+import { AnyFn, Implementation, InferArgs, InferImplSchema, InheritArgNames } from "./fnTypes.js";
+import { Providing } from "../slot/slotTypes.js";
+import { Withable } from "../root/rootTypes.js";
+import { DualFn } from "../../types.js";
+import { BaseData, Void } from "../../data/wgslTypes.js";
+import { InferGPU } from "../../shared/repr.js";
+
+//#region src/core/function/tgpuFn.d.ts
+/**
+ * Describes a function signature (its arguments and return type)
+ */
+type TgpuFnShellHeader<Args extends BaseData[], Return extends BaseData> = {
+  readonly [$internal]: true;
+  readonly argTypes: Args;
+  readonly returnType: Return;
+};
+/**
+ * Describes a function signature (its arguments and return type).
+ * Allows creating tgpu functions by calling this shell
+ * and passing the implementation (as WGSL string or JS function) as the argument.
+ */
+type TgpuFnShell<Args extends BaseData[], Return extends BaseData> = TgpuFnShellHeader<Args, Return> & (<T extends (...args: InferArgs<Args>) => InferGPU<Return>>(implementation: T) => TgpuFn<Prettify<InheritArgNames<(...args: Args) => Return, T>>['result']>) & ((implementation: string) => TgpuFn<(...args: Args) => Return>) & ((strings: TemplateStringsArray, ...values: unknown[]) => TgpuFn<(...args: Args) => Return>);
+interface TgpuFnBase<ImplSchema extends AnyFn> extends TgpuNamable, Withable<TgpuFn<ImplSchema>> {
+  [$internal]: {
+    implementation: Implementation<ImplSchema>;
+  };
+  readonly resourceType: 'function';
+  readonly shell: TgpuFnShellHeader<Parameters<ImplSchema>, Extract<ReturnType<ImplSchema>, BaseData>>;
+  readonly [$providing]?: Providing | undefined;
+  $uses(dependencyMap: Record<string, unknown>): this;
+}
+type TgpuFn<ImplSchema extends AnyFn = (...args: any[]) => any> = DualFn<InferImplSchema<ImplSchema>> & TgpuFnBase<ImplSchema>;
+/**
+ * A function wrapper that allows providing slot and accessor overrides for shellless functions
+ */
+interface TgpuGenericFn<T extends AnyFn> extends TgpuNamable, Withable<TgpuGenericFn<T>> {
+  readonly [$internal]: {
+    inner: T;
+  };
+  readonly [$providing]?: Providing | undefined;
+  readonly resourceType: 'generic-function';
+  (...args: Parameters<T>): ReturnType<T>;
+}
+declare function fn<Args extends BaseData[] | []>(argTypes: Args, returnType?: undefined): TgpuFnShell<Args, Void>;
+declare function fn<Args extends BaseData[] | [], Return extends BaseData>(argTypes: Args, returnType: Return): TgpuFnShell<Args, Return>;
+declare function fn<T extends AnyFn>(inner: T): TgpuGenericFn<T>;
+declare function isTgpuFn<Args extends BaseData[] | [], Return extends BaseData>(value: unknown): value is TgpuFn<(...args: Args) => Return>;
+//#endregion
+export { TgpuFn, TgpuFnShell, TgpuGenericFn, fn, isTgpuFn };

package/core/function/tgpuFn.js

@@ -0,0 +1,168 @@
+import { $getNameForward, $internal, $providing, $resolve, isMarkedInternal } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.js";
+import { Void } from "../../data/wgslTypes.js";
+import { ExecutionError } from "../../errors.js";
+import { isAccessor, isMutableAccessor } from "../slot/slotTypes.js";
+import { provideInsideTgpuFn } from "../../execMode.js";
+import { stitch } from "../resolve/stitch.js";
+import { schemaCallWrapper } from "../../data/schemaCallWrapper.js";
+import { dualImpl } from "./dualImpl.js";
+import { comptime } from "./comptime.js";
+import { addArgTypesToExternals, addReturnTypeToExternals } from "../resolve/externals.js";
+import { createFnCore } from "./fnCore.js";
+import { stripTemplate } from "./templateUtils.js";
+//#region src/core/function/tgpuFn.ts
+function fn(argTypesOrCallback, returnType) {
+	if (typeof argTypesOrCallback === "function") return createGenericFn(argTypesOrCallback, []);
+	const argTypes = argTypesOrCallback;
+	const shell = {
+		[$internal]: true,
+		argTypes,
+		returnType: returnType ?? Void
+	};
+	const call = (arg, ...values) => createFn(shell, stripTemplate(arg, ...values));
+	return Object.assign(call, shell);
+}
+function isTgpuFn(value) {
+	return isMarkedInternal(value) && value?.resourceType === "function";
+}
+function isGenericFn(value) {
+	return isMarkedInternal(value) && value?.resourceType === "generic-function";
+}
+function stringifyPair([slot, value]) {
+	return `${getName(slot) ?? "<unnamed>"}=${value}`;
+}
+function createFn(shell, _implementation) {
+	let pairs = [];
+	let implementation;
+	if (isGenericFn(_implementation)) {
+		pairs = _implementation[$providing]?.pairs ?? [];
+		implementation = _implementation[$internal].inner;
+	} else implementation = _implementation;
+	const core = createFnCore(implementation, "");
+	const fnBase = {
+		shell,
+		resourceType: "function",
+		[$internal]: { implementation },
+		$uses(newExternals) {
+			core.applyExternals(newExternals);
+			return this;
+		},
+		[$getNameForward]: core,
+		$name(label) {
+			setName(this, label);
+			return this;
+		},
+		with: comptime((slot, value) => {
+			return createBoundFunction(fn, [[isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot, value]]);
+		}),
+		[$resolve](ctx) {
+			if (typeof implementation === "string") {
+				addArgTypesToExternals(implementation, shell.argTypes, core.applyExternals);
+				addReturnTypeToExternals(implementation, shell.returnType, core.applyExternals);
+			}
+			return core.resolve(ctx, shell.argTypes, shell.returnType);
+		}
+	};
+	const call = dualImpl({
+		name: void 0,
+		noComptime: true,
+		signature: {
+			argTypes: shell.argTypes,
+			returnType: shell.returnType
+		},
+		normalImpl: (...args) => provideInsideTgpuFn(() => {
+			try {
+				if (typeof implementation === "string") throw new Error("Cannot execute on the CPU functions constructed with raw WGSL");
+				const castAndCopiedArgs = args.map((arg, index) => schemaCallWrapper(shell.argTypes[index], arg));
+				const result = implementation(...castAndCopiedArgs);
+				return schemaCallWrapper(shell.returnType, result);
+			} catch (err) {
+				if (err instanceof ExecutionError) throw err.appendToTrace(fn);
+				throw new ExecutionError(err, [fn]);
+			}
+		}),
+		codegenImpl: (ctx, args) => ctx.withResetIndentLevel(() => stitch`${ctx.resolve(fn).value}(${args})`)
+	});
+	const fn = Object.assign(call, fnBase);
+	Object.defineProperty(fn, "toString", { value() {
+		return `fn:${getName(core) ?? "<unnamed>"}`;
+	} });
+	if (pairs.length > 0) return createBoundFunction(fn, pairs);
+	return fn;
+}
+function createBoundFunction(innerFn, pairs) {
+	const fnBase = {
+		resourceType: "function",
+		shell: innerFn.shell,
+		[$internal]: { implementation: innerFn[$internal].implementation },
+		[$providing]: {
+			inner: innerFn,
+			pairs
+		},
+		$uses(newExternals) {
+			innerFn.$uses(newExternals);
+			return this;
+		},
+		$name(label) {
+			setName(this, label);
+			return this;
+		},
+		with: comptime((slot, value) => {
+			const s = isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot;
+			return createBoundFunction(innerFn, [...pairs, [s, value]]);
+		})
+	};
+	const call = dualImpl({
+		name: void 0,
+		noComptime: true,
+		signature: {
+			argTypes: innerFn.shell.argTypes,
+			returnType: innerFn.shell.returnType
+		},
+		normalImpl: innerFn,
+		codegenImpl: (ctx, args) => ctx.withResetIndentLevel(() => stitch`${ctx.resolve(fn).value}(${args})`)
+	});
+	const fn = Object.assign(call, fnBase);
+	Object.defineProperty(fn, "toString", { value() {
+		return `fn:${getName(this) ?? "<unnamed>"}[${pairs.map(stringifyPair).join(", ")}]`;
+	} });
+	const innerName = getName(innerFn);
+	if (innerName) setName(fn, innerName);
+	return fn;
+}
+function createGenericFn(inner, pairs) {
+	const fnBase = {
+		[$internal]: { inner },
+		resourceType: "generic-function",
+		[$providing]: pairs.length > 0 ? {
+			inner,
+			pairs
+		} : void 0,
+		$name(label) {
+			setName(this, label);
+			if (!getName(inner)) setName(inner, label);
+			return this;
+		},
+		[$resolve](ctx) {
+			return ctx.resolve(inner);
+		},
+		with(slot, value) {
+			const s = isAccessor(slot) || isMutableAccessor(slot) ? slot.slot : slot;
+			return createGenericFn(inner, [...pairs, [s, value]]);
+		}
+	};
+	const call = (...args) => {
+		return inner(...args);
+	};
+	const genericFn = Object.assign(call, fnBase);
+	if (getName(inner)) setName(genericFn, getName(inner));
+	Object.defineProperty(genericFn, "toString", { value() {
+		const fnLabel = getName(genericFn) ?? "<unnamed>";
+		if (pairs.length > 0) return `fn*:${fnLabel}[${pairs.map(stringifyPair).join(", ")}]`;
+		return `fn*:${fnLabel}`;
+	} });
+	return genericFn;
+}
+//#endregion
+export { fn, isGenericFn, isTgpuFn };

package/core/function/tgpuFragmentFn.d.ts

@@ -0,0 +1,72 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $internal } from "../../shared/symbols.js";
+import { Prettify } from "../../shared/utilityTypes.js";
+import { AnyFragmentInputBuiltin, AnyFragmentOutputBuiltin, OmitBuiltins } from "../../builtin.js";
+import { BaseIOData, IOLayout, IORecord, InferIO } from "./fnTypes.js";
+import { AnyAutoCustoms, AutoFragmentIn, AutoFragmentOut } from "./autoIO.js";
+import { InstanceToSchema } from "../../data/instanceToSchema.js";
+import { IOLayoutToSchema } from "./ioSchema.js";
+import { BaseData, Decorated, Interpolate, Location, Vec4f, Vec4i, Vec4u, WgslStruct } from "../../data/wgslTypes.js";
+import { UndecorateRecord } from "../../data/dataTypes.js";
+
+//#region src/core/function/tgpuFragmentFn.d.ts
+type FragmentInConstrained = IORecord<BaseIOData | Decorated<BaseIOData, (Location | Interpolate)[]> | AnyFragmentInputBuiltin>;
+type VertexOutToVarying<T> = OmitBuiltins<{ [K in keyof T]: InstanceToSchema<T[K]> }>;
+type FragmentColorValue = Vec4f | Vec4i | Vec4u;
+type FragmentOutConstrained = IOLayout<FragmentColorValue | Decorated<FragmentColorValue, (Location | Interpolate)[]> | AnyFragmentOutputBuiltin>;
+/**
+ * Describes a fragment entry function signature (its arguments, return type and targets)
+ */
+type TgpuFragmentFnShellHeader<FragmentIn extends TgpuFragmentFn.In = TgpuFragmentFn.In, FragmentOut extends TgpuFragmentFn.Out = TgpuFragmentFn.Out> = {
+  readonly in: FragmentIn | undefined;
+  readonly out: FragmentOut;
+  readonly returnType: IOLayoutToSchema<FragmentOut>;
+  readonly entryPoint: 'fragment';
+};
+type CleanIO<T> = T extends Record<string, BaseData> ? Prettify<UndecorateRecord<OmitBuiltins<T>>> : Prettify<UndecorateRecord<OmitBuiltins<{
+  a: T;
+}>>> extends {
+  a: infer Result;
+} ? Result : Record<string, never>;
+/**
+ * Describes a fragment entry function signature (its arguments, return type and targets).
+ * Allows creating tgpu fragment functions by calling this shell
+ * and passing the implementation (as WGSL string or JS function) as the argument.
+ */
+interface TgpuFragmentFnShell<out TIn extends TgpuFragmentFn.In = TgpuFragmentFn.In, out TOut extends TgpuFragmentFn.Out = TgpuFragmentFn.Out> extends TgpuFragmentFnShellHeader<TIn, TOut> {
+  /**
+   * Creates a type-safe implementation of this signature
+   */
+  (implementation: (input: InferIO<TIn>, out: TOut extends IORecord ? WgslStruct<TOut> : TOut) => InferIO<TOut>): TgpuFragmentFn<CleanIO<TIn>, CleanIO<TOut>>;
+  /**
+   * @param implementation
+   *   Raw WGSL function implementation with header and body
+   *   without `fn` keyword and function name
+   *   e.g. `"(x: f32) -> f32 { return x; }"`;
+   */
+  (implementation: string): TgpuFragmentFn<CleanIO<TIn>, CleanIO<TOut>>;
+  (strings: TemplateStringsArray, ...values: unknown[]): TgpuFragmentFn<CleanIO<TIn>, CleanIO<TOut>>;
+}
+interface TgpuFragmentFn<in Varying extends TgpuFragmentFn.In = Record<string, never>, out Output extends TgpuFragmentFn.Out = TgpuFragmentFn.Out> extends TgpuNamable {
+  readonly [$internal]: true;
+  readonly shell: TgpuFragmentFnShellHeader<Varying, Output>;
+  readonly outputType: IOLayoutToSchema<Output>;
+  $uses(dependencyMap: Record<string, unknown>): this;
+}
+declare namespace TgpuFragmentFn {
+  type In = Record<string, BaseData>;
+  type Out = Record<string, BaseData> | BaseData;
+  type AutoIn<T extends AnyAutoCustoms> = AutoFragmentIn<T>;
+  type AutoOut<T extends AnyAutoCustoms = AnyAutoCustoms> = AutoFragmentOut<T>;
+  type AutoInEmpty = AutoFragmentIn<Record<string, never>>;
+}
+declare function fragmentFn<FragmentOut extends FragmentOutConstrained>(options: {
+  out: FragmentOut;
+}): TgpuFragmentFnShell<{}, FragmentOut>;
+declare function fragmentFn<FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained>(options: {
+  in: FragmentIn;
+  out: FragmentOut;
+}): TgpuFragmentFnShell<FragmentIn, FragmentOut>;
+declare function isTgpuFragmentFn<FragmentIn extends FragmentInConstrained, FragmentOut extends FragmentOutConstrained>(value: unknown): value is TgpuFragmentFn<FragmentIn, FragmentOut>;
+//#endregion
+export { FragmentInConstrained, FragmentOutConstrained, TgpuFragmentFn, TgpuFragmentFnShell, VertexOutToVarying, fragmentFn, isTgpuFragmentFn };

package/core/function/tgpuFragmentFn.js

@@ -0,0 +1,63 @@
+import { $getNameForward, $internal, $resolve } from "../../shared/symbols.js";
+import { getName, isNamable, setName } from "../../shared/meta.js";
+import { createIoSchema, separateBuiltins } from "./ioSchema.js";
+import { addReturnTypeToExternals } from "../resolve/externals.js";
+import { createFnCore } from "./fnCore.js";
+import { stripTemplate } from "./templateUtils.js";
+import { shaderStageSlot } from "../slot/internalSlots.js";
+//#region src/core/function/tgpuFragmentFn.ts
+/**
+* Creates a shell of a typed entry function for the fragment shader stage. Any function
+* that implements this shell can run for each fragment (pixel), allowing the inner code
+* to process information received from the vertex shader stage and builtins to determine
+* the final color of the pixel (many pixels in case of multiple targets).
+*
+* @param options.in
+*  Values computed in the vertex stage and builtins to be made available to functions that implement this shell.
+* @param options.out
+*  A `vec4f`, signaling this function outputs a color for one target, or a record containing colors for multiple targets.
+*/
+function fragmentFn(options) {
+	const shell = {
+		in: options.in,
+		out: options.out,
+		returnType: createIoSchema(options.out),
+		entryPoint: "fragment"
+	};
+	const call = (arg, ...values) => createFragmentFn(shell, stripTemplate(arg, ...values));
+	return Object.assign(call, shell);
+}
+function isTgpuFragmentFn(value) {
+	return value?.shell?.entryPoint === "fragment";
+}
+function createFragmentFn(shell, implementation) {
+	const core = createFnCore(implementation, "@fragment ");
+	const outputType = shell.returnType;
+	if (typeof implementation === "string") addReturnTypeToExternals(implementation, outputType, (externals) => core.applyExternals(externals));
+	return {
+		shell,
+		outputType,
+		$uses(newExternals) {
+			core.applyExternals(newExternals);
+			return this;
+		},
+		[$internal]: true,
+		[$getNameForward]: core,
+		$name(newLabel) {
+			setName(this, newLabel);
+			if (isNamable(outputType)) outputType.$name(`${newLabel}_Output`);
+			return this;
+		},
+		[$resolve](ctx) {
+			const entryInput = separateBuiltins(shell.in ?? {}, ctx.varyingLocations ?? {});
+			if (entryInput.dataSchema && isNamable(entryInput.dataSchema)) entryInput.dataSchema.$name(`${getName(this) ?? ""}_Input`);
+			core.applyExternals({ Out: outputType });
+			return ctx.withSlots([[shaderStageSlot, "fragment"]], () => core.resolve(ctx, [], shell.returnType, entryInput));
+		},
+		toString() {
+			return `fragmentFn:${getName(core) ?? "<unnamed>"}`;
+		}
+	};
+}
+//#endregion
+export { fragmentFn, isTgpuFragmentFn };

package/core/function/tgpuVertexFn.d.ts

@@ -0,0 +1,59 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $internal } from "../../shared/symbols.js";
+import { Prettify } from "../../shared/utilityTypes.js";
+import { AnyVertexInputBuiltin, AnyVertexOutputBuiltin, OmitBuiltins } from "../../builtin.js";
+import { BaseIOData, IORecord, InferIO } from "./fnTypes.js";
+import { AnyAutoCustoms, AutoVertexOut, _AutoVertexIn } from "./autoIO.js";
+import { IOLayoutToSchema } from "./ioSchema.js";
+import { BaseData, Decorated, Interpolate, Location } from "../../data/wgslTypes.js";
+import { UndecorateRecord } from "../../data/dataTypes.js";
+
+//#region src/core/function/tgpuVertexFn.d.ts
+type VertexInConstrained = IORecord<BaseIOData | Decorated<BaseIOData, Location[]> | AnyVertexInputBuiltin>;
+type VertexOutConstrained = IORecord<BaseIOData | Decorated<BaseIOData, (Location | Interpolate)[]> | AnyVertexOutputBuiltin>;
+/**
+ * Describes a vertex entry function signature (its arguments, return type and attributes)
+ */
+type TgpuVertexFnShellHeader<VertexIn extends TgpuVertexFn.In, VertexOut extends TgpuVertexFn.Out> = {
+  readonly in: VertexIn | undefined;
+  readonly out: VertexOut;
+  readonly argTypes: [IOLayoutToSchema<VertexIn>] | [];
+  readonly entryPoint: 'vertex';
+};
+type CleanIO<T> = T extends Record<string, BaseData> ? Prettify<UndecorateRecord<OmitBuiltins<T>>> : Prettify<UndecorateRecord<OmitBuiltins<{
+  a: T;
+}>>> extends {
+  a: infer Result;
+} ? Result : never;
+/**
+ * Describes a vertex entry function signature (its arguments, return type and attributes).
+ * Allows creating tgpu vertex functions by calling this shell
+ * and passing the implementation (as WGSL string or JS function) as the argument.
+ */
+interface TgpuVertexFnShell<out TIn extends TgpuVertexFn.In, out TOut extends TgpuVertexFn.Out> extends TgpuVertexFnShellHeader<TIn, TOut> {
+  (implementation: (input: InferIO<TIn>, out: IOLayoutToSchema<TOut>) => InferIO<TOut>): TgpuVertexFn<CleanIO<TIn>, CleanIO<TOut>>;
+  (implementation: string): TgpuVertexFn<CleanIO<TIn>, CleanIO<TOut>>;
+  (strings: TemplateStringsArray, ...values: unknown[]): TgpuVertexFn<CleanIO<TIn>, CleanIO<TOut>>;
+}
+interface TgpuVertexFn<in VertexIn extends TgpuVertexFn.In = Record<string, never>, out VertexOut extends TgpuVertexFn.Out = TgpuVertexFn.Out> extends TgpuNamable {
+  readonly [$internal]: true;
+  readonly shell: TgpuVertexFnShellHeader<VertexIn, VertexOut>;
+  $uses(dependencyMap: Record<string, unknown>): this;
+}
+declare namespace TgpuVertexFn {
+  type In = BaseData | Record<string, BaseData>;
+  type Out = Record<string, BaseData>;
+  type AutoIn<T> = _AutoVertexIn<T>;
+  type AutoOut<T extends AnyAutoCustoms = AnyAutoCustoms> = AutoVertexOut<T>;
+  type AutoInEmpty = _AutoVertexIn<Record<string, never>>;
+}
+declare function vertexFn<VertexOut extends VertexOutConstrained>(options: {
+  out: VertexOut;
+}): TgpuVertexFnShell<{}, VertexOut>;
+declare function vertexFn<VertexIn extends VertexInConstrained, VertexOut extends VertexOutConstrained>(options: {
+  in: VertexIn;
+  out: VertexOut;
+}): TgpuVertexFnShell<VertexIn, VertexOut>;
+declare function isTgpuVertexFn<VertexIn extends VertexInConstrained, VertexOut extends VertexOutConstrained>(value: unknown): value is TgpuVertexFn<VertexIn, VertexOut>;
+//#endregion
+export { TgpuVertexFn, TgpuVertexFnShell, isTgpuVertexFn, vertexFn };

package/core/function/tgpuVertexFn.js

@@ -0,0 +1,59 @@
+import { $getNameForward, $internal, $resolve } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.js";
+import { createIoSchema, separateAllAsPositional } from "./ioSchema.js";
+import { createFnCore } from "./fnCore.js";
+import { stripTemplate } from "./templateUtils.js";
+import { shaderStageSlot } from "../slot/internalSlots.js";
+//#region src/core/function/tgpuVertexFn.ts
+/**
+* Creates a shell of a typed entry function for the vertex shader stage. Any function
+* that implements this shell can run for each vertex, allowing the inner code to process
+* attributes and determine the final position of the vertex.
+*
+* @param options.in
+*   Vertex attributes and builtins to be made available to functions that implement this shell.
+* @param options.out
+*   A record containing the final position of the vertex, and any information
+*   passed onto the fragment shader stage.
+*/
+function vertexFn(options) {
+	if (Object.keys(options.out).length === 0) throw new Error(`A vertexFn output cannot be empty since it must include the 'position' builtin.`);
+	const shell = {
+		in: options.in,
+		out: options.out,
+		argTypes: options.in && Object.keys(options.in).length !== 0 ? [createIoSchema(options.in)] : [],
+		entryPoint: "vertex"
+	};
+	const call = (arg, ...values) => createVertexFn(shell, stripTemplate(arg, ...values));
+	return Object.assign(call, shell);
+}
+function isTgpuVertexFn(value) {
+	return value?.shell?.entryPoint === "vertex";
+}
+function createVertexFn(shell, implementation) {
+	const core = createFnCore(implementation, "@vertex ");
+	const entryInput = separateAllAsPositional(shell.in ?? {});
+	return {
+		shell,
+		$uses(newExternals) {
+			core.applyExternals(newExternals);
+			return this;
+		},
+		[$internal]: true,
+		[$getNameForward]: core,
+		$name(newLabel) {
+			setName(this, newLabel);
+			return this;
+		},
+		[$resolve](ctx) {
+			const outputWithLocation = createIoSchema(shell.out, ctx.varyingLocations).$name(`${getName(this) ?? ""}_Output`);
+			if (typeof implementation === "string") core.applyExternals({ Out: outputWithLocation });
+			return ctx.withSlots([[shaderStageSlot, "vertex"]], () => core.resolve(ctx, [], outputWithLocation, entryInput));
+		},
+		toString() {
+			return `vertexFn:${getName(core) ?? "<unnamed>"}`;
+		}
+	};
+}
+//#endregion
+export { isTgpuVertexFn, vertexFn };

package/core/pipeline/applyPipelineState.js

@@ -0,0 +1,35 @@
+import { MissingBindGroupsError, MissingVertexBuffersError } from "../../errors.js";
+import { isBuffer } from "../buffer/buffer.js";
+import { isBindGroup } from "../../tgpuBindGroupLayout.js";
+import { warnIfOverflow } from "./limitsOverflow.js";
+//#region src/core/pipeline/applyPipelineState.ts
+function applyBindGroups(encoder, root, usedBindGroupLayouts, catchall, resolveBindGroup) {
+	const missingBindGroups = new Set(usedBindGroupLayouts);
+	warnIfOverflow(usedBindGroupLayouts, root.device.limits);
+	usedBindGroupLayouts.forEach((layout, idx) => {
+		if (catchall && idx === catchall[0]) {
+			encoder.setBindGroup(idx, root.unwrap(catchall[1]));
+			missingBindGroups.delete(layout);
+		} else {
+			const bindGroup = resolveBindGroup(layout);
+			if (bindGroup !== void 0) {
+				missingBindGroups.delete(layout);
+				if (isBindGroup(bindGroup)) encoder.setBindGroup(idx, root.unwrap(bindGroup));
+				else encoder.setBindGroup(idx, bindGroup);
+			}
+		}
+	});
+	if (missingBindGroups.size > 0) throw new MissingBindGroupsError(missingBindGroups);
+}
+function applyVertexBuffers(encoder, root, usedVertexLayouts, resolveVertexBuffer) {
+	const missingVertexLayouts = /* @__PURE__ */ new Set();
+	usedVertexLayouts.forEach((vertexLayout, idx) => {
+		const entry = resolveVertexBuffer(vertexLayout);
+		if (!entry || !entry.buffer) missingVertexLayouts.add(vertexLayout);
+		else if (isBuffer(entry.buffer)) encoder.setVertexBuffer(idx, root.unwrap(entry.buffer), entry.offset, entry.size);
+		else encoder.setVertexBuffer(idx, entry.buffer, entry.offset, entry.size);
+	});
+	if (missingVertexLayouts.size > 0) throw new MissingVertexBuffersError(missingVertexLayouts);
+}
+//#endregion
+export { applyBindGroups, applyVertexBuffers };

package/core/pipeline/computePipeline.d.ts

@@ -0,0 +1,54 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $internal } from "../../shared/symbols.js";
+import { AnyComputeBuiltin } from "../../builtin.js";
+import { IORecord } from "../function/fnTypes.js";
+import { TgpuComputeFn } from "../function/tgpuComputeFn.js";
+import { PrimitiveOffsetInfo } from "../../data/offsetUtils.js";
+import { Timeable, TimestampWritesPriors } from "./timeable.js";
+import { TgpuBindGroup, TgpuBindGroupLayout, TgpuLayoutEntry } from "../../tgpuBindGroupLayout.js";
+import { ExperimentalTgpuRoot } from "../root/rootTypes.js";
+import { IndirectFlag, TgpuBuffer } from "../buffer/buffer.js";
+import { SelfResolvable } from "../../types.js";
+import { AnyWgslData } from "../../data/wgslTypes.js";
+
+//#region src/core/pipeline/computePipeline.d.ts
+interface ComputePipelineInternals {
+  readonly rawPipeline: GPUComputePipeline;
+  readonly priors: TgpuComputePipelinePriors & TimestampWritesPriors;
+  readonly root: ExperimentalTgpuRoot;
+}
+interface TgpuComputePipeline extends TgpuNamable, SelfResolvable, Timeable {
+  readonly [$internal]: ComputePipelineInternals;
+  readonly resourceType: 'compute-pipeline';
+  /**
+   * @deprecated This overload is outdated.
+   * Call `pipeline.with(bindGroup)` instead.
+   */
+  with<Entries extends Record<string, TgpuLayoutEntry | null>>(bindGroupLayout: TgpuBindGroupLayout<Entries>, bindGroup: TgpuBindGroup<Entries>): this;
+  with(bindGroupLayout: TgpuBindGroupLayout, bindGroup: GPUBindGroup): this;
+  with(bindGroup: TgpuBindGroup): this;
+  with(encoder: GPUCommandEncoder): this;
+  with(pass: GPUComputePassEncoder): this;
+  dispatchWorkgroups(x: number, y?: number, z?: number): void;
+  /**
+   * Dispatches compute workgroups using parameters read from a buffer.
+   * The buffer must contain 3 consecutive u32 values (x, y, z workgroup counts).
+   * To get the correct offset within complex data structures, use `d.memoryLayoutOf(...)`.
+   *
+   * @param indirectBuffer - Buffer marked with 'indirect' usage containing dispatch parameters or raw GPUBuffer
+   * @param start - PrimitiveOffsetInfo pointing to the first dispatch parameter. If not provided, starts at offset 0. To obtain safe offsets, use `d.memoryLayoutOf(...)`.
+   */
+  dispatchWorkgroupsIndirect<T extends AnyWgslData>(indirectBuffer: (TgpuBuffer<T> & IndirectFlag) | GPUBuffer, start?: PrimitiveOffsetInfo | number): void;
+}
+declare namespace TgpuComputePipeline {
+  type Descriptor<Input extends IORecord<AnyComputeBuiltin> = IORecord<AnyComputeBuiltin>> = {
+    compute: TgpuComputeFn<Input>;
+  };
+}
+type TgpuComputePipelinePriors = {
+  readonly bindGroupLayoutMap?: Map<TgpuBindGroupLayout, TgpuBindGroup | GPUBindGroup>;
+  readonly externalEncoder?: GPUCommandEncoder | undefined;
+  readonly externalPass?: GPUComputePassEncoder | undefined;
+} & TimestampWritesPriors;
+//#endregion
+export { TgpuComputePipeline };