typegpu 0.10.1 → 0.11.0-rc.1

package/core/pipeline/renderPipeline.js

@@ -0,0 +1,489 @@
+import { $getNameForward, $internal, $resolve } from "../../shared/symbols.js";
+import { PERF, getName, setName } from "../../shared/meta.js";
+import { Void, isWgslData } from "../../data/wgslTypes.js";
+import { getCustomLocation } from "../../data/dataTypes.js";
+import { snip } from "../../data/snippet.js";
+import { isGPUBuffer } from "../../types.js";
+import { formatToWGSLType } from "../../data/vertexFormatData.js";
+import { sizeOf } from "../../data/sizeOf.js";
+import { isBuiltin } from "../../data/attributes.js";
+import { namespace } from "../resolve/namespace.js";
+import { isTexture, isTextureView } from "../texture/texture.js";
+import { isBindGroup, isBindGroupLayout } from "../../tgpuBindGroupLayout.js";
+import { connectAttributesToShader } from "../vertexLayout/connectAttributesToShader.js";
+import { resolve } from "../../resolutionCtx.js";
+import { isGPUCommandEncoder, isGPURenderBundleEncoder, isGPURenderPassEncoder } from "./typeGuards.js";
+import { applyBindGroups, applyVertexBuffers } from "./applyPipelineState.js";
+import { logDataFromGPU } from "../../tgsl/consoleLog/deserializers.js";
+import { wgslExtensionToFeatureName, wgslExtensions } from "../../wgslExtensions.js";
+import { resolveIndirectOffset } from "./pipelineUtils.js";
+import { createWithPerformanceCallback, createWithTimestampWrites, setupTimestampWrites, triggerPerformanceCallback } from "./timeable.js";
+import { AutoFragmentFn, AutoVertexFn } from "../function/autoIO.js";
+import { isVertexLayout } from "../vertexLayout/vertexLayout.js";
+import { connectAttachmentToShader } from "./connectAttachmentToShader.js";
+import { connectTargetsToShader } from "./connectTargetsToShader.js";
+//#region src/core/pipeline/renderPipeline.ts
+const DRAW_INDIRECT_SIZE = 16;
+const DRAW_INDEXED_INDIRECT_SIZE = 20;
+function INTERNAL_createRenderPipeline(options) {
+	return new TgpuRenderPipelineImpl(new RenderPipelineCore(options), {});
+}
+const _lastAppliedRender = /* @__PURE__ */ new WeakMap();
+var TgpuRenderPipelineImpl = class TgpuRenderPipelineImpl {
+	[$internal];
+	resourceType = "render-pipeline";
+	[$getNameForward];
+	hasIndexBuffer = false;
+	constructor(core, priors) {
+		this[$internal] = {
+			core,
+			priors,
+			root: core.options.root
+		};
+		this[$getNameForward] = core;
+	}
+	[$resolve](ctx) {
+		return ctx.resolve(this[$internal].core);
+	}
+	toString() {
+		return `renderPipeline:${getName(this) ?? "<unnamed>"}`;
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+	with(first, resource) {
+		const internals = this[$internal];
+		if (isGPURenderPassEncoder(first) || isGPURenderBundleEncoder(first)) return new TgpuRenderPipelineImpl(internals.core, {
+			...internals.priors,
+			externalRenderEncoder: first,
+			externalEncoder: void 0
+		});
+		if (isGPUCommandEncoder(first)) return new TgpuRenderPipelineImpl(internals.core, {
+			...internals.priors,
+			externalEncoder: first,
+			externalRenderEncoder: void 0
+		});
+		if (isBindGroup(first)) return new TgpuRenderPipelineImpl(internals.core, {
+			...internals.priors,
+			bindGroupLayoutMap: new Map([...internals.priors.bindGroupLayoutMap ?? [], [first.layout, first]])
+		});
+		if (isBindGroupLayout(first)) return new TgpuRenderPipelineImpl(internals.core, {
+			...internals.priors,
+			bindGroupLayoutMap: new Map([...internals.priors.bindGroupLayoutMap ?? [], [first, resource]])
+		});
+		if (isVertexLayout(first)) return new TgpuRenderPipelineImpl(internals.core, {
+			...internals.priors,
+			vertexLayoutMap: new Map([...internals.priors.vertexLayoutMap ?? [], [first, resource]])
+		});
+		throw new Error("Unsupported value passed into .with()");
+	}
+	withPerformanceCallback(callback) {
+		const internals = this[$internal];
+		if (internals.priors.timestampWrites) return new TgpuRenderPipelineImpl(internals.core, {
+			...internals.priors,
+			performanceCallback: callback
+		});
+		const querySet = internals.core.performanceCallbackQuerySet;
+		if (!querySet) {
+			console.warn("Performance callback cannot be used because the timestamp-query feature is not enabled on the root.");
+			return this;
+		}
+		const newPriors = createWithPerformanceCallback(internals.priors, callback, querySet);
+		return new TgpuRenderPipelineImpl(internals.core, newPriors);
+	}
+	withTimestampWrites(options) {
+		const internals = this[$internal];
+		const newPriors = createWithTimestampWrites(internals.priors, options, internals.core.options.root);
+		return new TgpuRenderPipelineImpl(internals.core, newPriors);
+	}
+	withColorAttachment(attachment) {
+		const internals = this[$internal];
+		return new TgpuRenderPipelineImpl(internals.core, {
+			...internals.priors,
+			colorAttachment: attachment
+		});
+	}
+	withDepthStencilAttachment(attachment) {
+		const internals = this[$internal];
+		return new TgpuRenderPipelineImpl(internals.core, {
+			...internals.priors,
+			depthStencilAttachment: attachment
+		});
+	}
+	withStencilReference(reference) {
+		const internals = this[$internal];
+		return new TgpuRenderPipelineImpl(internals.core, {
+			...internals.priors,
+			stencilReference: reference
+		});
+	}
+	withIndexBuffer(buffer, indexFormatOrOffset, offsetElementsOrSizeBytes, sizeElementsOrUndefined) {
+		const internals = this[$internal];
+		if (isGPUBuffer(buffer)) {
+			if (typeof indexFormatOrOffset !== "string") throw new Error("If a GPUBuffer is passed, indexFormat must be provided.");
+			return new TgpuRenderPipelineImpl(internals.core, {
+				...internals.priors,
+				indexBuffer: {
+					buffer,
+					indexFormat: indexFormatOrOffset,
+					offsetBytes: offsetElementsOrSizeBytes,
+					sizeBytes: sizeElementsOrUndefined
+				}
+			});
+		}
+		const dataTypeToIndexFormat = {
+			u32: "uint32",
+			u16: "uint16"
+		};
+		const elementType = buffer.dataType.elementType;
+		return new TgpuRenderPipelineImpl(internals.core, {
+			...internals.priors,
+			indexBuffer: {
+				buffer,
+				indexFormat: dataTypeToIndexFormat[elementType.type],
+				offsetBytes: indexFormatOrOffset !== void 0 ? indexFormatOrOffset * sizeOf(elementType) : void 0,
+				sizeBytes: sizeElementsOrUndefined !== void 0 ? sizeElementsOrUndefined * sizeOf(elementType) : void 0
+			}
+		});
+	}
+	_createRenderPass(encoder) {
+		const internals = this[$internal];
+		const { root, descriptor } = internals.core.options;
+		const memo = internals.core.unwrap();
+		const colorAttachments = descriptor.fragment ? connectAttachmentToShader(descriptor.fragment?.shell?.returnType ?? memo.fragmentOut, internals.priors.colorAttachment ?? {}).map((_attachment) => {
+			const attachment = {
+				loadOp: "clear",
+				storeOp: "store",
+				..._attachment
+			};
+			if (isTexture(attachment.view)) attachment.view = root.unwrap(attachment.view).createView();
+			else if (isTextureView(attachment.view)) attachment.view = root.unwrap(attachment.view);
+			else if (isGPUCanvasContext(attachment.view)) attachment.view = attachment.view.getCurrentTexture().createView();
+			if (isTexture(attachment.resolveTarget)) attachment.resolveTarget = root.unwrap(attachment.resolveTarget).createView();
+			else if (isTextureView(attachment.resolveTarget)) attachment.resolveTarget = root.unwrap(attachment.resolveTarget);
+			else if (isGPUCanvasContext(attachment.resolveTarget)) attachment.resolveTarget = attachment.resolveTarget.getCurrentTexture().createView();
+			return attachment;
+		}) : [];
+		const renderPassDescriptor = {
+			label: getName(internals.core) ?? "<unnamed>",
+			colorAttachments,
+			...setupTimestampWrites(internals.priors, root)
+		};
+		const depthStencil = internals.priors.depthStencilAttachment;
+		if (depthStencil !== void 0) {
+			const view = isTexture(depthStencil.view) ? root.unwrap(depthStencil.view).createView() : isTextureView(depthStencil.view) ? root.unwrap(depthStencil.view) : depthStencil.view;
+			renderPassDescriptor.depthStencilAttachment = {
+				...depthStencil,
+				view
+			};
+		}
+		return encoder.beginRenderPass(renderPassDescriptor);
+	}
+	_applyRenderState(encoder) {
+		const internals = this[$internal];
+		const memo = internals.core.unwrap();
+		const { root } = internals.core.options;
+		encoder.setPipeline(memo.pipeline);
+		applyBindGroups(encoder, root, memo.usedBindGroupLayouts, memo.catchall, (layout) => internals.priors.bindGroupLayoutMap?.get(layout));
+		applyVertexBuffers(encoder, root, memo.usedVertexLayouts, (layout) => {
+			const buffer = internals.priors.vertexLayoutMap?.get(layout);
+			return buffer ? { buffer } : void 0;
+		});
+		if (internals.priors.stencilReference !== void 0 && "setStencilReference" in encoder) encoder.setStencilReference(internals.priors.stencilReference);
+	}
+	_setIndexBuffer(encoder) {
+		const internals = this[$internal];
+		const { root } = internals.core.options;
+		if (!internals.priors.indexBuffer) throw new Error("No index buffer set for this render pipeline.");
+		const { buffer, indexFormat, offsetBytes, sizeBytes } = internals.priors.indexBuffer;
+		if (isGPUBuffer(buffer)) encoder.setIndexBuffer(buffer, indexFormat, offsetBytes, sizeBytes);
+		else encoder.setIndexBuffer(root.unwrap(buffer), indexFormat, offsetBytes, sizeBytes);
+	}
+	draw(vertexCount, instanceCount, firstVertex, firstInstance) {
+		const internals = this[$internal];
+		const { root } = internals.core.options;
+		if (internals.priors.externalRenderEncoder) {
+			if (_lastAppliedRender.get(internals.priors.externalRenderEncoder) !== this) {
+				this._applyRenderState(internals.priors.externalRenderEncoder);
+				_lastAppliedRender.set(internals.priors.externalRenderEncoder, this);
+			}
+			internals.priors.externalRenderEncoder.draw(vertexCount, instanceCount, firstVertex, firstInstance);
+			return;
+		}
+		if (internals.priors.externalEncoder) {
+			const pass = this._createRenderPass(internals.priors.externalEncoder);
+			this._applyRenderState(pass);
+			pass.draw(vertexCount, instanceCount, firstVertex, firstInstance);
+			pass.end();
+			return;
+		}
+		const { logResources } = internals.core.unwrap();
+		const commandEncoder = root.device.createCommandEncoder();
+		const pass = this._createRenderPass(commandEncoder);
+		this._applyRenderState(pass);
+		pass.draw(vertexCount, instanceCount, firstVertex, firstInstance);
+		pass.end();
+		root.device.queue.submit([commandEncoder.finish()]);
+		if (logResources) logDataFromGPU(logResources);
+		if (internals.priors.performanceCallback) triggerPerformanceCallback({
+			root,
+			priors: internals.priors
+		});
+	}
+	drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance) {
+		const internals = this[$internal];
+		const { root } = internals.core.options;
+		if (internals.priors.externalRenderEncoder) {
+			if (_lastAppliedRender.get(internals.priors.externalRenderEncoder) !== this) {
+				this._applyRenderState(internals.priors.externalRenderEncoder);
+				this._setIndexBuffer(internals.priors.externalRenderEncoder);
+				_lastAppliedRender.set(internals.priors.externalRenderEncoder, this);
+			}
+			internals.priors.externalRenderEncoder.drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
+			return;
+		}
+		if (internals.priors.externalEncoder) {
+			const pass = this._createRenderPass(internals.priors.externalEncoder);
+			this._applyRenderState(pass);
+			this._setIndexBuffer(pass);
+			pass.drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
+			pass.end();
+			return;
+		}
+		const { logResources } = internals.core.unwrap();
+		const commandEncoder = root.device.createCommandEncoder();
+		const pass = this._createRenderPass(commandEncoder);
+		this._applyRenderState(pass);
+		this._setIndexBuffer(pass);
+		pass.drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance);
+		pass.end();
+		root.device.queue.submit([commandEncoder.finish()]);
+		if (logResources) logDataFromGPU(logResources);
+		if (internals.priors.performanceCallback) triggerPerformanceCallback({
+			root,
+			priors: internals.priors
+		});
+	}
+	drawIndirect(indirectBuffer, indirectOffset) {
+		const internals = this[$internal];
+		const { root } = internals.core.options;
+		const rawBuffer = isGPUBuffer(indirectBuffer) ? indirectBuffer : indirectBuffer.buffer;
+		const offset = resolveIndirectOffset(indirectBuffer, indirectOffset, DRAW_INDIRECT_SIZE, "drawIndirect");
+		if (internals.priors.externalRenderEncoder) {
+			if (_lastAppliedRender.get(internals.priors.externalRenderEncoder) !== this) {
+				this._applyRenderState(internals.priors.externalRenderEncoder);
+				_lastAppliedRender.set(internals.priors.externalRenderEncoder, this);
+			}
+			internals.priors.externalRenderEncoder.drawIndirect(rawBuffer, offset);
+			return;
+		}
+		if (internals.priors.externalEncoder) {
+			const pass = this._createRenderPass(internals.priors.externalEncoder);
+			this._applyRenderState(pass);
+			pass.drawIndirect(rawBuffer, offset);
+			pass.end();
+			return;
+		}
+		const { logResources } = internals.core.unwrap();
+		const commandEncoder = root.device.createCommandEncoder();
+		const pass = this._createRenderPass(commandEncoder);
+		this._applyRenderState(pass);
+		pass.drawIndirect(rawBuffer, offset);
+		pass.end();
+		root.device.queue.submit([commandEncoder.finish()]);
+		if (logResources) logDataFromGPU(logResources);
+		if (internals.priors.performanceCallback) triggerPerformanceCallback({
+			root,
+			priors: internals.priors
+		});
+	}
+	drawIndexedIndirect(indirectBuffer, indirectOffset) {
+		const internals = this[$internal];
+		const { root } = internals.core.options;
+		const rawBuffer = isGPUBuffer(indirectBuffer) ? indirectBuffer : root.unwrap(indirectBuffer);
+		const offset = resolveIndirectOffset(indirectBuffer, indirectOffset, DRAW_INDEXED_INDIRECT_SIZE, "drawIndexedIndirect");
+		if (internals.priors.externalRenderEncoder) {
+			if (_lastAppliedRender.get(internals.priors.externalRenderEncoder) !== this) {
+				this._applyRenderState(internals.priors.externalRenderEncoder);
+				this._setIndexBuffer(internals.priors.externalRenderEncoder);
+				_lastAppliedRender.set(internals.priors.externalRenderEncoder, this);
+			}
+			internals.priors.externalRenderEncoder.drawIndexedIndirect(rawBuffer, offset);
+			return;
+		}
+		if (internals.priors.externalEncoder) {
+			const pass = this._createRenderPass(internals.priors.externalEncoder);
+			this._applyRenderState(pass);
+			this._setIndexBuffer(pass);
+			pass.drawIndexedIndirect(rawBuffer, offset);
+			pass.end();
+			return;
+		}
+		const { logResources } = internals.core.unwrap();
+		const commandEncoder = root.device.createCommandEncoder();
+		const pass = this._createRenderPass(commandEncoder);
+		this._applyRenderState(pass);
+		this._setIndexBuffer(pass);
+		pass.drawIndexedIndirect(rawBuffer, offset);
+		pass.end();
+		root.device.queue.submit([commandEncoder.finish()]);
+		if (logResources) logDataFromGPU(logResources);
+		if (internals.priors.performanceCallback) triggerPerformanceCallback({
+			root,
+			priors: internals.priors
+		});
+	}
+};
+var RenderPipelineCore = class {
+	[$internal] = true;
+	options;
+	_memo;
+	#latestAutoVertexIn;
+	#latestAutoFragmentOut;
+	#performanceCallbackQuerySet;
+	constructor(options) {
+		this.options = options;
+	}
+	[$resolve](ctx) {
+		const { slotBindings } = this.options;
+		const { vertex, fragment, attribs = {} } = this.options.descriptor;
+		this.#latestAutoVertexIn = void 0;
+		this.#latestAutoFragmentOut = void 0;
+		const locations = matchUpVaryingLocations(vertex?.shell?.out, fragment?.shell?.in, getName(vertex) ?? "<unnamed>", getName(fragment) ?? "<unnamed>");
+		return ctx.withVaryingLocations(locations, () => ctx.withSlots(slotBindings, () => {
+			let vertexOut;
+			if (typeof vertex === "function") {
+				const autoFn = new AutoVertexFn(vertex, Object.fromEntries(Object.entries(attribs).map(([key, value]) => [key, formatToWGSLType[value.format]])), locations);
+				ctx.resolve(autoFn);
+				this.#latestAutoVertexIn = autoFn.autoIn.completeStruct.propTypes;
+				vertexOut = autoFn.autoOut.completeStruct;
+			} else vertexOut = ctx.resolve(vertex).dataType;
+			if (fragment) if (typeof fragment === "function") {
+				const varyings = Object.fromEntries(Object.entries(vertexOut.propTypes).filter(([, dataType]) => !isBuiltin(dataType)));
+				this.#latestAutoFragmentOut = ctx.resolve(new AutoFragmentFn(fragment, varyings, locations)).dataType;
+			} else ctx.resolve(fragment);
+			return snip("", Void, "runtime");
+		}));
+	}
+	toString() {
+		return "renderPipelineCore";
+	}
+	get performanceCallbackQuerySet() {
+		if (!this.options.root.enabledFeatures.has("timestamp-query")) return;
+		return this.#performanceCallbackQuerySet ??= this.options.root.createQuerySet("timestamp", 2);
+	}
+	unwrap() {
+		if (this._memo !== void 0) return this._memo;
+		const { root, descriptor: tgpuDescriptor } = this.options;
+		const device = root.device;
+		const enableExtensions = wgslExtensions.filter((extension) => root.enabledFeatures.has(wgslExtensionToFeatureName[extension]));
+		let resolutionResult;
+		let resolveMeasure;
+		const ns = namespace({ names: root.nameRegistrySetting });
+		if (PERF?.enabled) {
+			const resolveStart = performance.mark("typegpu:resolution:start");
+			resolutionResult = resolve(this, {
+				namespace: ns,
+				enableExtensions,
+				shaderGenerator: root.shaderGenerator,
+				root
+			});
+			resolveMeasure = performance.measure("typegpu:resolution", { start: resolveStart.name });
+		} else resolutionResult = resolve(this, {
+			namespace: ns,
+			enableExtensions,
+			shaderGenerator: root.shaderGenerator,
+			root
+		});
+		const { code, usedBindGroupLayouts, catchall, logResources } = resolutionResult;
+		if (catchall !== void 0) usedBindGroupLayouts[catchall[0]]?.$name(`${getName(this) ?? "<unnamed>"} - Automatic Bind Group & Layout`);
+		const module = device.createShaderModule({
+			label: `${getName(this) ?? "<unnamed>"} - Shader`,
+			code
+		});
+		const { vertex, fragment, attribs = {}, targets } = this.options.descriptor;
+		const connectedAttribs = connectAttributesToShader(vertex?.shell?.in ?? this.#latestAutoVertexIn ?? {}, attribs);
+		const fragmentOut = fragment?.shell?.returnType ?? this.#latestAutoFragmentOut;
+		const connectedTargets = fragmentOut ? connectTargetsToShader(fragmentOut, targets) : [null];
+		const descriptor = {
+			layout: device.createPipelineLayout({
+				label: `${getName(this) ?? "<unnamed>"} - Pipeline Layout`,
+				bindGroupLayouts: usedBindGroupLayouts.map((l) => root.unwrap(l))
+			}),
+			vertex: {
+				module,
+				buffers: connectedAttribs.bufferDefinitions
+			}
+		};
+		const label = getName(this);
+		if (label !== void 0) descriptor.label = label;
+		if (tgpuDescriptor.fragment) descriptor.fragment = {
+			module,
+			targets: connectedTargets
+		};
+		if (tgpuDescriptor.primitive) if (isWgslData(tgpuDescriptor.primitive.stripIndexFormat)) descriptor.primitive = {
+			...tgpuDescriptor.primitive,
+			stripIndexFormat: {
+				u32: "uint32",
+				u16: "uint16"
+			}[tgpuDescriptor.primitive.stripIndexFormat.type]
+		};
+		else descriptor.primitive = tgpuDescriptor.primitive;
+		if (tgpuDescriptor.depthStencil) descriptor.depthStencil = tgpuDescriptor.depthStencil;
+		if (tgpuDescriptor.multisample) descriptor.multisample = tgpuDescriptor.multisample;
+		this._memo = {
+			pipeline: device.createRenderPipeline(descriptor),
+			usedBindGroupLayouts,
+			catchall,
+			logResources,
+			usedVertexLayouts: connectedAttribs.usedVertexLayouts,
+			fragmentOut: this.#latestAutoFragmentOut
+		};
+		if (PERF?.enabled) (async () => {
+			const start = performance.mark("typegpu:compile-start");
+			await device.queue.onSubmittedWorkDone();
+			const compileMeasure = performance.measure("typegpu:compiled", { start: start.name });
+			PERF?.record("resolution", {
+				resolveDuration: resolveMeasure?.duration,
+				compileDuration: compileMeasure.duration,
+				wgslSize: code.length
+			});
+		})();
+		return this._memo;
+	}
+};
+/**
+* Assumes vertexOut and fragmentIn are matching when it comes to the keys, that is fragmentIn's keyset is a subset of vertexOut's
+* Logs a warning, when they don't match in terms of custom locations
+*/
+function matchUpVaryingLocations(vertexOut = {}, fragmentIn = {}, vertexFnName, fragmentFnName) {
+	const locations = {};
+	const usedLocations = /* @__PURE__ */ new Set();
+	function saveLocation(key, location) {
+		locations[key] = location;
+		usedLocations.add(location);
+	}
+	for (const [key, value] of Object.entries(vertexOut)) {
+		const customLocation = getCustomLocation(value);
+		if (customLocation !== void 0) saveLocation(key, customLocation);
+	}
+	for (const [key, value] of Object.entries(fragmentIn)) {
+		const customLocation = getCustomLocation(value);
+		if (customLocation === void 0) continue;
+		if (locations[key] === void 0) saveLocation(key, customLocation);
+		else if (locations[key] !== customLocation) console.warn(`Mismatched location between vertexFn (${vertexFnName}) output (${locations[key]}) and fragmentFn (${fragmentFnName}) input (${customLocation}) for the key "${key}", using the location set on vertex output.`);
+	}
+	let nextLocation = 0;
+	for (const key of Object.keys(vertexOut ?? {})) {
+		if (isBuiltin(vertexOut[key]) || locations[key] !== void 0) continue;
+		while (usedLocations.has(nextLocation)) nextLocation++;
+		saveLocation(key, nextLocation);
+	}
+	return locations;
+}
+function isGPUCanvasContext(value) {
+	return typeof value?.getCurrentTexture === "function";
+}
+//#endregion
+export { INTERNAL_createRenderPipeline };

package/core/pipeline/timeable.d.ts

@@ -0,0 +1,20 @@
+import { TgpuQuerySet } from "../querySet/querySet.js";
+//#region src/core/pipeline/timeable.d.ts
+interface Timeable {
+  withPerformanceCallback(callback: (start: bigint, end: bigint) => void | Promise<void>): this;
+  withTimestampWrites(options: {
+    querySet: TgpuQuerySet<'timestamp'> | GPUQuerySet;
+    beginningOfPassWriteIndex?: number;
+    endOfPassWriteIndex?: number;
+  }): this;
+}
+type TimestampWritesPriors = {
+  readonly timestampWrites?: {
+    querySet: TgpuQuerySet<'timestamp'> | GPUQuerySet;
+    beginningOfPassWriteIndex?: number;
+    endOfPassWriteIndex?: number;
+  };
+  readonly performanceCallback?: (start: bigint, end: bigint) => void | Promise<void>;
+};
+//#endregion
+export { Timeable, TimestampWritesPriors };

package/core/pipeline/timeable.js

@@ -0,0 +1,55 @@
+import { $internal } from "../../shared/symbols.js";
+import { isQuerySet } from "../querySet/querySet.js";
+//#region src/core/pipeline/timeable.ts
+function createWithPerformanceCallback(currentPriors, callback, querySet) {
+	if (!currentPriors.timestampWrites) return {
+		...currentPriors,
+		performanceCallback: callback,
+		timestampWrites: {
+			querySet,
+			beginningOfPassWriteIndex: 0,
+			endOfPassWriteIndex: 1
+		}
+	};
+	return {
+		...currentPriors,
+		performanceCallback: callback
+	};
+}
+function createWithTimestampWrites(currentPriors, options, root) {
+	if (!root.enabledFeatures.has("timestamp-query")) throw new Error("Timestamp writes require the \"timestamp-query\" feature to be enabled on GPU device.");
+	const timestampWrites = { querySet: options.querySet };
+	if (options.beginningOfPassWriteIndex !== void 0) timestampWrites.beginningOfPassWriteIndex = options.beginningOfPassWriteIndex;
+	if (options.endOfPassWriteIndex !== void 0) timestampWrites.endOfPassWriteIndex = options.endOfPassWriteIndex;
+	return {
+		...currentPriors,
+		timestampWrites
+	};
+}
+function setupTimestampWrites(priors, root) {
+	if (!priors.timestampWrites) return {};
+	const { querySet, beginningOfPassWriteIndex, endOfPassWriteIndex } = priors.timestampWrites;
+	const timestampWrites = { querySet: isQuerySet(querySet) ? root.unwrap(querySet) : querySet };
+	if (beginningOfPassWriteIndex !== void 0) timestampWrites.beginningOfPassWriteIndex = beginningOfPassWriteIndex;
+	if (endOfPassWriteIndex !== void 0) timestampWrites.endOfPassWriteIndex = endOfPassWriteIndex;
+	return { timestampWrites };
+}
+function triggerPerformanceCallback({ root, priors }) {
+	const querySet = priors.timestampWrites?.querySet;
+	const callback = priors.performanceCallback;
+	if (!querySet) throw new Error("Cannot dispatch workgroups with performance callback without a query set.");
+	if (!isQuerySet(querySet)) throw new Error("Performance callback with raw GPUQuerySet is not supported. Use TgpuQuerySet instead.");
+	const commandEncoder = root.device.createCommandEncoder();
+	commandEncoder.resolveQuerySet(root.unwrap(querySet), 0, querySet.count, querySet[$internal].resolveBuffer, 0);
+	root.device.queue.submit([commandEncoder.finish()]);
+	root.device.queue.onSubmittedWorkDone().then(async () => {
+		if (!querySet.available) return;
+		const result = await querySet.read();
+		const start = result[priors.timestampWrites?.beginningOfPassWriteIndex ?? 0];
+		const end = result[priors.timestampWrites?.endOfPassWriteIndex ?? 1];
+		if (start === void 0 || end === void 0) throw new Error("QuerySet did not return valid timestamps.");
+		await callback(start, end);
+	});
+}
+//#endregion
+export { createWithPerformanceCallback, createWithTimestampWrites, setupTimestampWrites, triggerPerformanceCallback };

package/core/pipeline/typeGuards.js

@@ -0,0 +1,27 @@
+import { $internal } from "../../shared/symbols.js";
+//#region src/core/pipeline/typeGuards.ts
+function isComputePipeline(value) {
+	const maybe = value;
+	return maybe?.resourceType === "compute-pipeline" && !!maybe[$internal];
+}
+function isRenderPipeline(value) {
+	const maybe = value;
+	return maybe?.resourceType === "render-pipeline" && !!maybe[$internal];
+}
+function isPipeline(value) {
+	return isRenderPipeline(value) || isComputePipeline(value);
+}
+function isGPUCommandEncoder(value) {
+	return !!value && typeof value === "object" && "beginRenderPass" in value && "beginComputePass" in value;
+}
+function isGPUComputePassEncoder(value) {
+	return !!value && typeof value === "object" && "dispatchWorkgroups" in value && !("beginRenderPass" in value);
+}
+function isGPURenderPassEncoder(value) {
+	return !!value && typeof value === "object" && "executeBundles" in value && "draw" in value;
+}
+function isGPURenderBundleEncoder(value) {
+	return !!value && typeof value === "object" && "draw" in value && "finish" in value && !("executeBundles" in value) && !("beginRenderPass" in value) && !("dispatchWorkgroups" in value);
+}
+//#endregion
+export { isComputePipeline, isGPUCommandEncoder, isGPUComputePassEncoder, isGPURenderBundleEncoder, isGPURenderPassEncoder, isPipeline, isRenderPipeline };

package/core/querySet/querySet.d.ts

@@ -0,0 +1,20 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $internal } from "../../shared/symbols.js";
+//#region src/core/querySet/querySet.d.ts
+interface TgpuQuerySet<T extends GPUQueryType> extends TgpuNamable {
+  readonly resourceType: 'query-set';
+  readonly type: T;
+  readonly count: number;
+  readonly querySet: GPUQuerySet;
+  readonly destroyed: boolean;
+  readonly available: boolean;
+  readonly [$internal]: {
+    readonly readBuffer: GPUBuffer;
+    readonly resolveBuffer: GPUBuffer;
+  };
+  resolve(): void;
+  read(): Promise<bigint[]>;
+  destroy(): void;
+}
+//#endregion
+export { TgpuQuerySet };