typegpu 0.10.1 → 0.11.0-rc.1

package/core/buffer/bufferShorthand.d.ts

@@ -0,0 +1,48 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $gpuValueOf, $internal } from "../../shared/symbols.js";
+import { StorageFlag } from "../../extension.js";
+import { BufferWriteOptions, TgpuBuffer, UniformFlag } from "./buffer.js";
+import { BaseData } from "../../data/wgslTypes.js";
+import { Infer, InferGPU, InferInput, InferPartial, InferPatch } from "../../shared/repr.js";
+
+//#region src/core/buffer/bufferShorthand.d.ts
+interface TgpuBufferShorthandBase<TData extends BaseData> extends TgpuNamable {
+  readonly [$internal]: true;
+  write(data: InferInput<TData>, options?: BufferWriteOptions): void;
+  /** @deprecated Use {@link patch} instead. */
+  writePartial(data: InferPartial<TData>): void;
+  patch(data: InferPatch<TData>): void;
+  read(): Promise<Infer<TData>>;
+  readonly [$gpuValueOf]: InferGPU<TData>;
+}
+interface TgpuMutable<out TData extends BaseData> extends TgpuBufferShorthandBase<TData> {
+  readonly resourceType: 'mutable';
+  readonly buffer: TgpuBuffer<TData> & StorageFlag;
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  value: InferGPU<TData>;
+  $: InferGPU<TData>;
+}
+interface TgpuReadonly<out TData extends BaseData> extends TgpuBufferShorthandBase<TData> {
+  readonly resourceType: 'readonly';
+  readonly buffer: TgpuBuffer<TData> & StorageFlag;
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: InferGPU<TData>;
+  readonly $: InferGPU<TData>;
+}
+interface TgpuUniform<out TData extends BaseData> extends TgpuBufferShorthandBase<TData> {
+  readonly resourceType: 'uniform';
+  readonly buffer: TgpuBuffer<TData> & UniformFlag;
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: InferGPU<TData>;
+  readonly $: InferGPU<TData>;
+}
+type TgpuBufferShorthand<TData extends BaseData> = TgpuMutable<TData> | TgpuReadonly<TData> | TgpuUniform<TData>;
+declare function isBufferShorthand<TData extends BaseData>(value: unknown): value is TgpuBufferShorthand<TData>;
+//#endregion
+export { TgpuBufferShorthand, TgpuMutable, TgpuReadonly, TgpuUniform, isBufferShorthand };

package/core/buffer/bufferShorthand.js

@@ -0,0 +1,53 @@
+import { $getNameForward, $gpuValueOf, $internal, $resolve } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.js";
+//#region src/core/buffer/bufferShorthand.ts
+function isBufferShorthand(value) {
+	return value instanceof TgpuBufferShorthandImpl;
+}
+var TgpuBufferShorthandImpl = class {
+	[$internal] = true;
+	[$getNameForward];
+	resourceType;
+	buffer;
+	#usage;
+	constructor(resourceType, buffer) {
+		this.resourceType = resourceType;
+		this.buffer = buffer;
+		this[$getNameForward] = buffer;
+		this.#usage = this.buffer.as(this.resourceType);
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+	write(data, options) {
+		this.buffer.write(data, options);
+	}
+	/** @deprecated Use {@link patch} instead. */
+	writePartial(data) {
+		this.buffer.writePartial(data);
+	}
+	patch(data) {
+		this.buffer.patch(data);
+	}
+	read() {
+		return this.buffer.read();
+	}
+	get [$gpuValueOf]() {
+		return this.#usage.$;
+	}
+	get $() {
+		return this.#usage.$;
+	}
+	get value() {
+		return this.$;
+	}
+	toString() {
+		return `${this.resourceType}BufferShorthand:${getName(this) ?? "<unnamed>"}`;
+	}
+	[$resolve](ctx) {
+		return ctx.resolve(this.#usage);
+	}
+};
+//#endregion
+export { TgpuBufferShorthandImpl, isBufferShorthand };

package/core/buffer/bufferUsage.d.ts

@@ -0,0 +1,43 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $gpuValueOf, $internal, $repr } from "../../shared/symbols.js";
+import { TgpuBuffer, UniformFlag } from "./buffer.js";
+import { BindableBufferUsage } from "../../types.js";
+import { BaseData } from "../../data/wgslTypes.js";
+import { Infer, InferGPU } from "../../shared/repr.js";
+
+//#region src/core/buffer/bufferUsage.d.ts
+interface TgpuBufferUsage<TData extends BaseData = BaseData, TUsage extends BindableBufferUsage = BindableBufferUsage> {
+  readonly resourceType: 'buffer-usage';
+  readonly usage: TUsage;
+  readonly [$repr]: Infer<TData>;
+  readonly [$gpuValueOf]: InferGPU<TData>;
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  value: InferGPU<TData>;
+  $: InferGPU<TData>;
+  readonly [$internal]: {
+    readonly dataType: TData;
+  };
+}
+interface TgpuBufferUniform<TData extends BaseData> extends TgpuBufferUsage<TData, 'uniform'> {
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: InferGPU<TData>;
+  readonly $: InferGPU<TData>;
+}
+interface TgpuBufferReadonly<TData extends BaseData> extends TgpuBufferUsage<TData, 'readonly'> {
+  /**
+   * @deprecated Use `.$` instead, works the same way.
+   */
+  readonly value: InferGPU<TData>;
+  readonly $: InferGPU<TData>;
+}
+interface TgpuFixedBufferUsage<TData extends BaseData> extends TgpuNamable {
+  readonly buffer: TgpuBuffer<TData>;
+}
+interface TgpuBufferMutable<TData extends BaseData> extends TgpuBufferUsage<TData, 'mutable'> {}
+declare function isUsableAsUniform<T extends TgpuBuffer<BaseData>>(buffer: T): buffer is T & UniformFlag;
+//#endregion
+export { TgpuBufferMutable, TgpuBufferReadonly, TgpuBufferUniform, TgpuBufferUsage, TgpuFixedBufferUsage, isUsableAsUniform };

package/core/buffer/bufferUsage.js

@@ -0,0 +1,165 @@
+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";
+	usage;
+	buffer;
+	[$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";
+	usage;
+	dataType;
+	#membership;
+	constructor(usage, dataType, membership) {
+		this[$internal] = { dataType };
+		this.usage = usage;
+		this.dataType = 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,29 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $gpuValueOf, $internal } from "../../shared/symbols.js";
+import { AnyWgslData, BaseData, WgslArray } 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>;
+declare function constant<TElement extends AnyWgslData>(dataType: (elementCount: number) => WgslArray<TElement>, value: InferGPU<WgslArray<TElement>>): TgpuConst<WgslArray<TElement>>;
+//#endregion
+export { TgpuConst, constant };

package/core/constant/tgpuConstant.js

@@ -0,0 +1,68 @@
+import { $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symbols.js";
+import { getName, setName } from "../../shared/meta.js";
+import { isNaturallyEphemeral } from "../../data/wgslTypes.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);
+}
+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;
+	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.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,39 @@
+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 = [];
+	#declaration;
+	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,38 @@
+import { Assume, RemoveIndexSignature } from "../../shared/utilityTypes.js";
+import { BuiltinClipDistances, BuiltinFragDepth, BuiltinFrontFacing, BuiltinInstanceIndex, BuiltinPosition, BuiltinPrimitiveIndex, BuiltinSampleIndex, BuiltinSampleMask, BuiltinSubgroupInvocationId, BuiltinSubgroupSize, BuiltinVertexIndex, OmitBuiltins } from "../../builtin.js";
+import { BaseIOData } from "./fnTypes.js";
+import { TgpuVertexAttrib } from "../../shared/vertexFormat.js";
+import { FormatToWGSLType } from "../../data/vertexFormatData.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> = 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>> }>;
+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> = RemoveIndexSignature<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, _AutoVertexIn };

package/core/function/autoIO.js

@@ -0,0 +1,85 @@
+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 };