typegpu 0.10.2 → 0.11.0-rc.1

package/core/function/tgpuVertexFn.js

@@ -1,10 +1,9 @@
 import { $getNameForward, $internal, $resolve } from "../../shared/symbols.js";
-import { getName, isNamable, setName } from "../../shared/meta.js";
-import { createIoSchema } from "./ioSchema.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
@@ -33,7 +32,7 @@ function isTgpuVertexFn(value) {
 }
 function createVertexFn(shell, implementation) {
 	const core = createFnCore(implementation, "@vertex ");
-	const inputType = shell.argTypes[0];
+	const entryInput = separateAllAsPositional(shell.in ?? {});
 	return {
 		shell,
 		$uses(newExternals) {
@@ -44,22 +43,17 @@ function createVertexFn(shell, implementation) {
 		[$getNameForward]: core,
 		$name(newLabel) {
 			setName(this, newLabel);
-			if (isNamable(inputType)) inputType.$name(`${newLabel}_Input`);
 			return this;
 		},
 		[$resolve](ctx) {
 			const outputWithLocation = createIoSchema(shell.out, ctx.varyingLocations).$name(`${getName(this) ?? ""}_Output`);
-			if (typeof implementation === "string") {
-				if (inputType) core.applyExternals({ In: inputType });
-				core.applyExternals({ Out: outputWithLocation });
-			}
-			return ctx.withSlots([[shaderStageSlot, "vertex"]], () => core.resolve(ctx, shell.argTypes, outputWithLocation));
+			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 };
+export { isTgpuVertexFn, vertexFn };

package/core/pipeline/applyPipelineState.js

@@ -2,7 +2,6 @@ import { MissingBindGroupsError, MissingVertexBuffersError } from "../../errors.
 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);
@@ -32,6 +31,5 @@ function applyVertexBuffers(encoder, root, usedVertexLayouts, resolveVertexBuffe
 	});
 	if (missingVertexLayouts.size > 0) throw new MissingVertexBuffersError(missingVertexLayouts);
 }
-
 //#endregion
-export { applyBindGroups, applyVertexBuffers };
+export { applyBindGroups, applyVertexBuffers };

package/core/pipeline/computePipeline.d.ts

@@ -1,12 +1,8 @@
 import { TgpuNamable } from "../../shared/meta.js";
 import { $internal } from "../../shared/symbols.js";
 import { AnyComputeBuiltin } from "../../builtin.js";
-import "../querySet/querySet.js";
-import "../../data/snippet.js";
-import "../../tgsl/consoleLog/types.js";
 import { IORecord } from "../function/fnTypes.js";
 import { TgpuComputeFn } from "../function/tgpuComputeFn.js";
-import "../slot/slotTypes.js";
 import { PrimitiveOffsetInfo } from "../../data/offsetUtils.js";
 import { Timeable, TimestampWritesPriors } from "./timeable.js";
 import { TgpuBindGroup, TgpuBindGroupLayout, TgpuLayoutEntry } from "../../tgpuBindGroupLayout.js";
@@ -39,10 +35,10 @@ interface TgpuComputePipeline extends TgpuNamable, SelfResolvable, Timeable {
    * 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
+   * @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, start?: PrimitiveOffsetInfo | number): void;
+  dispatchWorkgroupsIndirect<T extends AnyWgslData>(indirectBuffer: (TgpuBuffer<T> & IndirectFlag) | GPUBuffer, start?: PrimitiveOffsetInfo | number): void;
 }
 declare namespace TgpuComputePipeline {
   type Descriptor<Input extends IORecord<AnyComputeBuiltin> = IORecord<AnyComputeBuiltin>> = {

package/core/pipeline/computePipeline.js

@@ -2,7 +2,7 @@ import { $getNameForward, $internal, $resolve } from "../../shared/symbols.js";
 import { PERF, getName, setName } from "../../shared/meta.js";
 import { Void } from "../../data/wgslTypes.js";
 import { snip } from "../../data/snippet.js";
-import { sizeOf } from "../../data/sizeOf.js";
+import { isGPUBuffer } from "../../types.js";
 import { namespace } from "../resolve/namespace.js";
 import { isBindGroup } from "../../tgpuBindGroupLayout.js";
 import { resolve } from "../../resolutionCtx.js";
@@ -10,125 +10,121 @@ import { isGPUCommandEncoder, isGPUComputePassEncoder } from "./typeGuards.js";
 import { applyBindGroups } from "./applyPipelineState.js";
 import { logDataFromGPU } from "../../tgsl/consoleLog/deserializers.js";
 import { wgslExtensionToFeatureName, wgslExtensions } from "../../wgslExtensions.js";
-import { memoryLayoutOf } from "../../data/offsetUtils.js";
+import { resolveIndirectOffset } from "./pipelineUtils.js";
 import { createWithPerformanceCallback, createWithTimestampWrites, setupTimestampWrites, triggerPerformanceCallback } from "./timeable.js";
-
 //#region src/core/pipeline/computePipeline.ts
 function INTERNAL_createComputePipeline(branch, slotBindings, descriptor) {
 	return new TgpuComputePipelineImpl(new ComputePipelineCore(branch, slotBindings, descriptor), {});
 }
-function validateIndirectBufferSize(bufferSize, offset, requiredBytes, operation) {
-	if (offset + requiredBytes > bufferSize) throw new Error(`Buffer too small for ${operation}. Required: ${requiredBytes} bytes at offset ${offset}, but buffer is only ${bufferSize} bytes.`);
-	if (offset % 4 !== 0) throw new Error(`Indirect buffer offset must be a multiple of 4. Got: ${offset}`);
-}
 const _lastAppliedCompute = /* @__PURE__ */ new WeakMap();
 var TgpuComputePipelineImpl = class TgpuComputePipelineImpl {
 	[$internal];
 	resourceType = "compute-pipeline";
 	[$getNameForward];
-	constructor(_core, _priors) {
-		this._core = _core;
-		this._priors = _priors;
+	#core;
+	#priors;
+	constructor(core, priors) {
+		this.#core = core;
+		this.#priors = priors;
 		this[$internal] = {
 			get rawPipeline() {
-				return _core.unwrap().pipeline;
+				return core.unwrap().pipeline;
 			},
 			get priors() {
-				return _priors;
+				return priors;
 			},
 			get root() {
-				return _core.root;
+				return core.root;
 			}
 		};
-		this[$getNameForward] = _core;
+		this[$getNameForward] = core;
 	}
 	[$resolve](ctx) {
-		return ctx.resolve(this._core);
+		return ctx.resolve(this.#core);
 	}
 	toString() {
 		return `computePipeline:${getName(this) ?? "<unnamed>"}`;
 	}
 	get rawPipeline() {
-		return this._core.unwrap().pipeline;
+		return this.#core.unwrap().pipeline;
 	}
 	with(first, bindGroup) {
-		if (isGPUComputePassEncoder(first)) return new TgpuComputePipelineImpl(this._core, {
-			...this._priors,
+		if (isGPUComputePassEncoder(first)) return new TgpuComputePipelineImpl(this.#core, {
+			...this.#priors,
 			externalPass: first,
 			externalEncoder: void 0
 		});
-		if (isGPUCommandEncoder(first)) return new TgpuComputePipelineImpl(this._core, {
-			...this._priors,
+		if (isGPUCommandEncoder(first)) return new TgpuComputePipelineImpl(this.#core, {
+			...this.#priors,
 			externalEncoder: first,
 			externalPass: void 0
 		});
-		if (isBindGroup(first)) return new TgpuComputePipelineImpl(this._core, {
-			...this._priors,
-			bindGroupLayoutMap: new Map([...this._priors.bindGroupLayoutMap ?? [], [first.layout, first]])
+		if (isBindGroup(first)) return new TgpuComputePipelineImpl(this.#core, {
+			...this.#priors,
+			bindGroupLayoutMap: new Map([...this.#priors.bindGroupLayoutMap ?? [], [first.layout, first]])
 		});
-		return new TgpuComputePipelineImpl(this._core, {
-			...this._priors,
-			bindGroupLayoutMap: new Map([...this._priors.bindGroupLayoutMap ?? [], [first, bindGroup]])
+		return new TgpuComputePipelineImpl(this.#core, {
+			...this.#priors,
+			bindGroupLayoutMap: new Map([...this.#priors.bindGroupLayoutMap ?? [], [first, bindGroup]])
 		});
 	}
 	withPerformanceCallback(callback) {
-		const newPriors = createWithPerformanceCallback(this._priors, callback, this._core.root);
-		return new TgpuComputePipelineImpl(this._core, newPriors);
+		if (this.#priors.timestampWrites) return new TgpuComputePipelineImpl(this.#core, {
+			...this.#priors,
+			performanceCallback: callback
+		});
+		const querySet = this.#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(this.#priors, callback, querySet);
+		return new TgpuComputePipelineImpl(this.#core, newPriors);
 	}
 	withTimestampWrites(options) {
-		const newPriors = createWithTimestampWrites(this._priors, options, this._core.root);
-		return new TgpuComputePipelineImpl(this._core, newPriors);
+		const newPriors = createWithTimestampWrites(this.#priors, options, this.#core.root);
+		return new TgpuComputePipelineImpl(this.#core, newPriors);
 	}
 	dispatchWorkgroups(x, y, z) {
 		this._executeComputePass((pass) => pass.dispatchWorkgroups(x, y, z));
 	}
 	dispatchWorkgroupsIndirect(indirectBuffer, start) {
 		const DISPATCH_SIZE = 12;
-		let offsetInfo = start ?? memoryLayoutOf(indirectBuffer.dataType);
-		if (typeof offsetInfo === "number") if (offsetInfo === 0) offsetInfo = memoryLayoutOf(indirectBuffer.dataType);
-		else {
-			console.warn(`dispatchWorkgroupsIndirect: Provided start offset ${offsetInfo} as a raw number. Use d.memoryLayoutOf(...) to include contiguous padding info for safer validation.`);
-			offsetInfo = {
-				offset: offsetInfo,
-				contiguous: DISPATCH_SIZE
-			};
-		}
-		const { offset, contiguous } = offsetInfo;
-		validateIndirectBufferSize(sizeOf(indirectBuffer.dataType), offset, DISPATCH_SIZE, "dispatchWorkgroupsIndirect");
-		if (contiguous < DISPATCH_SIZE) console.warn(`dispatchWorkgroupsIndirect: Starting at offset ${offset}, only ${contiguous} contiguous bytes are available before padding. Dispatch requires ${DISPATCH_SIZE} bytes (3 x u32). Reading across padding may result in undefined behavior.`);
-		this._executeComputePass((pass) => pass.dispatchWorkgroupsIndirect(indirectBuffer.buffer, offset));
+		const rawBuffer = isGPUBuffer(indirectBuffer) ? indirectBuffer : indirectBuffer.buffer;
+		const offset = resolveIndirectOffset(indirectBuffer, start, DISPATCH_SIZE, "dispatchWorkgroupsIndirect");
+		this._executeComputePass((pass) => pass.dispatchWorkgroupsIndirect(rawBuffer, offset));
 	}
 	_applyComputeState(pass) {
-		const memo = this._core.unwrap();
-		const { root } = this._core;
+		const memo = this.#core.unwrap();
+		const { root } = this.#core;
 		pass.setPipeline(memo.pipeline);
-		applyBindGroups(pass, root, memo.usedBindGroupLayouts, memo.catchall, (layout) => this._priors.bindGroupLayoutMap?.get(layout));
+		applyBindGroups(pass, root, memo.usedBindGroupLayouts, memo.catchall, (layout) => this.#priors.bindGroupLayoutMap?.get(layout));
 	}
 	_executeComputePass(dispatch) {
-		const { root } = this._core;
-		if (this._priors.externalPass) {
-			if (_lastAppliedCompute.get(this._priors.externalPass) !== this) {
-				this._applyComputeState(this._priors.externalPass);
-				_lastAppliedCompute.set(this._priors.externalPass, this);
+		const { root } = this.#core;
+		if (this.#priors.externalPass) {
+			if (_lastAppliedCompute.get(this.#priors.externalPass) !== this) {
+				this._applyComputeState(this.#priors.externalPass);
+				_lastAppliedCompute.set(this.#priors.externalPass, this);
 			}
-			dispatch(this._priors.externalPass);
+			dispatch(this.#priors.externalPass);
 			return;
 		}
-		if (this._priors.externalEncoder) {
+		if (this.#priors.externalEncoder) {
 			const passDescriptor = {
-				label: getName(this._core) ?? "<unnamed>",
-				...setupTimestampWrites(this._priors, root)
+				label: getName(this.#core) ?? "<unnamed>",
+				...setupTimestampWrites(this.#priors, root)
 			};
-			const pass = this._priors.externalEncoder.beginComputePass(passDescriptor);
+			const pass = this.#priors.externalEncoder.beginComputePass(passDescriptor);
 			this._applyComputeState(pass);
 			dispatch(pass);
 			pass.end();
 			return;
 		}
-		const memo = this._core.unwrap();
+		const memo = this.#core.unwrap();
 		const passDescriptor = {
-			label: getName(this._core) ?? "<unnamed>",
-			...setupTimestampWrites(this._priors, root)
+			label: getName(this.#core) ?? "<unnamed>",
+			...setupTimestampWrites(this.#priors, root)
 		};
 		const commandEncoder = root.device.createCommandEncoder();
 		const pass = commandEncoder.beginComputePass(passDescriptor);
@@ -137,9 +133,9 @@ var TgpuComputePipelineImpl = class TgpuComputePipelineImpl {
 		pass.end();
 		root.device.queue.submit([commandEncoder.finish()]);
 		if (memo.logResources) logDataFromGPU(memo.logResources);
-		if (this._priors.performanceCallback) triggerPerformanceCallback({
+		if (this.#priors.performanceCallback) triggerPerformanceCallback({
 			root,
-			priors: this._priors
+			priors: this.#priors
 		});
 	}
 	$name(label) {
@@ -149,9 +145,11 @@ var TgpuComputePipelineImpl = class TgpuComputePipelineImpl {
 };
 var ComputePipelineCore = class {
 	[$internal] = true;
+	root;
 	_memo;
 	#slotBindings;
 	#descriptor;
+	#performanceCallbackQuerySet;
 	constructor(root, slotBindings, descriptor) {
 		this.root = root;
 		this.#slotBindings = slotBindings;
@@ -166,6 +164,10 @@ var ComputePipelineCore = class {
 	toString() {
 		return "computePipelineCore";
 	}
+	get performanceCallbackQuerySet() {
+		if (!this.root.enabledFeatures.has("timestamp-query")) return;
+		return this.#performanceCallbackQuerySet ??= this.root.createQuerySet("timestamp", 2);
+	}
 	unwrap() {
 		if (this._memo === void 0) {
 			const device = this.root.device;
@@ -221,6 +223,5 @@ var ComputePipelineCore = class {
 		return this._memo;
 	}
 };
-
 //#endregion
-export { INTERNAL_createComputePipeline };
+export { INTERNAL_createComputePipeline };

package/core/pipeline/connectAttachmentToShader.js

@@ -1,6 +1,5 @@
 import { isWgslStruct } from "../../data/wgslTypes.js";
 import { isBuiltin } from "../../data/attributes.js";
-
 //#region src/core/pipeline/connectAttachmentToShader.ts
 function isColorAttachment(value) {
 	return !!value?.view;
@@ -21,6 +20,5 @@ function connectAttachmentToShader(fragmentOut, attachment) {
 	if (!isColorAttachment(attachment)) throw new Error("Expected a single color attachment, not a record.");
 	return [attachment];
 }
-
 //#endregion
-export { connectAttachmentToShader };
+export { connectAttachmentToShader };

package/core/pipeline/connectTargetsToShader.js

@@ -1,6 +1,5 @@
 import { isVoid, isWgslStruct } from "../../data/wgslTypes.js";
 import { isBuiltin } from "../../data/attributes.js";
-
 //#region src/core/pipeline/connectTargetsToShader.ts
 function connectTargetsToShader(fragmentOut, targets) {
 	let presentationFormat;
@@ -24,6 +23,5 @@ function connectTargetsToShader(fragmentOut, targets) {
 		format: singleTarget?.format ?? (presentationFormat ??= navigator.gpu.getPreferredCanvasFormat())
 	}];
 }
-
 //#endregion
-export { connectTargetsToShader };
+export { connectTargetsToShader };

package/core/pipeline/limitsOverflow.js

@@ -8,6 +8,5 @@ function warnIfOverflow(layouts, limits) {
 2. Increasing the limit when requesting a device or creating a root.`);
 	if (storage > limits.maxStorageBuffersPerShaderStage) console.warn(`Total number of storage buffers (${storage}) exceeds maxStorageBuffersPerShaderStage (${limits.maxStorageBuffersPerShaderStage}).`);
 }
-
 //#endregion
-export { warnIfOverflow };
+export { warnIfOverflow };

package/core/pipeline/pipelineUtils.js

@@ -0,0 +1,29 @@
+import { isGPUBuffer } from "../../types.js";
+import { sizeOf } from "../../data/sizeOf.js";
+import { memoryLayoutOf } from "../../data/offsetUtils.js";
+//#region src/core/pipeline/pipelineUtils.ts
+const IndirectOperationToRequiredData = {
+	dispatchWorkgroupsIndirect: "3 x u32",
+	drawIndirect: "4 x u32",
+	drawIndexedIndirect: "3 x u32, i32, u32"
+};
+function validateIndirectBufferSize(bufferSize, offset, requiredBytes, operation) {
+	if (offset + requiredBytes > bufferSize) throw new Error(`Buffer too small for ${operation}. Required: ${requiredBytes} bytes at offset ${offset}, but buffer is only ${bufferSize} bytes.`);
+	if (offset % 4 !== 0) throw new Error(`Indirect buffer offset must be a multiple of 4. Got: ${offset}`);
+}
+function resolveIndirectOffset(indirectBuffer, start, requiredSize, operation) {
+	if (isGPUBuffer(indirectBuffer)) {
+		const offset = typeof start === "number" ? start : start?.offset ?? 0;
+		validateIndirectBufferSize(indirectBuffer.size, offset, requiredSize, operation);
+		return offset;
+	}
+	const { offset, contiguous } = start ? typeof start === "number" ? {
+		offset: start,
+		contiguous: requiredSize
+	} : start : memoryLayoutOf(indirectBuffer.dataType);
+	validateIndirectBufferSize(sizeOf(indirectBuffer.dataType), offset, requiredSize, operation);
+	if (contiguous < requiredSize) console.warn(`${operation}: Starting at offset ${offset}, only ${contiguous} contiguous bytes are available before padding. '${operation}' requires ${requiredSize} bytes (${IndirectOperationToRequiredData[operation]}). Reading across padding may result in undefined behavior.`);
+	return offset;
+}
+//#endregion
+export { resolveIndirectOffset };

package/core/pipeline/renderPipeline.d.ts

@@ -1,10 +1,11 @@
 import { TgpuNamable } from "../../shared/meta.js";
 import { $internal, $resolve } from "../../shared/symbols.js";
 import { AnyBuiltin, OmitBuiltins } from "../../builtin.js";
-import "../querySet/querySet.js";
+import { TgpuQuerySet } from "../querySet/querySet.js";
 import { ResolvedSnippet } from "../../data/snippet.js";
 import { LogResources } from "../../tgsl/consoleLog/types.js";
 import { TgpuSlot } from "../slot/slotTypes.js";
+import { PrimitiveOffsetInfo } from "../../data/offsetUtils.js";
 import { Timeable, TimestampWritesPriors } from "./timeable.js";
 import { AnyVertexAttribs } from "../../shared/vertexFormat.js";
 import { AnyAutoCustoms, AutoFragmentIn, AutoFragmentOut, AutoVertexIn, AutoVertexOut } from "../function/autoIO.js";
@@ -14,7 +15,7 @@ import { RenderFlag } from "../texture/usageExtension.js";
 import { TgpuVertexLayout } from "../vertexLayout/vertexLayout.js";
 import { TgpuBindGroup, TgpuBindGroupLayout, TgpuLayoutEntry } from "../../tgpuBindGroupLayout.js";
 import { ExperimentalTgpuRoot } from "../root/rootTypes.js";
-import { IndexFlag, TgpuBuffer, VertexFlag } from "../buffer/buffer.js";
+import { IndexFlag, IndirectFlag, TgpuBuffer, VertexFlag } from "../buffer/buffer.js";
 import { ResolutionCtx, SelfResolvable } from "../../types.js";
 import { AnyVecInstance, BaseData, U16, U32, Void, WgslArray, v4f } from "../../data/wgslTypes.js";
 import { WgslTexture, WgslTextureDepth2d, WgslTextureDepthMultisampled2d } from "../../data/texture.js";
@@ -77,8 +78,24 @@ interface TgpuRenderPipeline<in Targets = never> extends TgpuNamable, SelfResolv
   withIndexBuffer(buffer: TgpuBuffer<BaseData> & IndexFlag, offsetElements?: number, sizeElements?: number): this & HasIndexBuffer;
   withIndexBuffer(buffer: GPUBuffer, indexFormat: GPUIndexFormat, offsetBytes?: number, sizeBytes?: number): this & HasIndexBuffer;
   draw(vertexCount: number, instanceCount?: number, firstVertex?: number, firstInstance?: number): void;
-  drawIndirect(indirectBuffer: TgpuBuffer<BaseData> | GPUBuffer, indirectOffset?: GPUSize64): void;
-  drawIndexedIndirect(indirectBuffer: TgpuBuffer<BaseData> | GPUBuffer, indirectOffset?: GPUSize64): void;
+  /**
+   * Draws primitives using parameters read from a buffer.
+   * The buffer must contain 4 consecutive u32 values (vertexCount, instanceCount, firstVertex, firstInstance).
+   * To get the correct offset within complex data structures, use `d.memoryLayoutOf(...)`.
+   *
+   * @param indirectBuffer - Buffer marked with 'indirect' usage containing draw parameters or raw GPUBuffer
+   * @param indirectOffset - PrimitiveOffsetInfo pointing to the first draw parameter. If not provided, starts at offset 0. To obtain safe offsets, use `d.memoryLayoutOf(...)`.
+   */
+  drawIndirect(indirectBuffer: (TgpuBuffer<BaseData> & IndirectFlag) | GPUBuffer, indirectOffset?: PrimitiveOffsetInfo | number): void;
+  /**
+   * Draws indexed primitives using parameters read from a buffer.
+   * The buffer must contain 5 consecutive 32-bit integer values (indexCount u32, instanceCount u32, firstIndex u32, baseVertex i32, firstInstance u32).
+   * To get the correct offset within complex data structures, use `d.memoryLayoutOf(...)`.
+   *
+   * @param indirectBuffer - Buffer marked with 'indirect' usage containing draw parameters or raw GPUBuffer
+   * @param indirectOffset - PrimitiveOffsetInfo pointing to the first draw parameter. If not provided, starts at offset 0. To obtain safe offsets, use `d.memoryLayoutOf(...)`.
+   */
+  drawIndexedIndirect(indirectBuffer: (TgpuBuffer<BaseData> & IndirectFlag) | GPUBuffer, indirectOffset?: PrimitiveOffsetInfo | number): void;
 }
 declare namespace TgpuRenderPipeline {
   interface DescriptorBase {
@@ -250,12 +267,13 @@ type Memo = {
 };
 declare class RenderPipelineCore implements SelfResolvable {
   #private;
-  readonly options: RenderPipelineCoreOptions;
   readonly [$internal] = true;
+  readonly options: RenderPipelineCoreOptions;
   private _memo;
   constructor(options: RenderPipelineCoreOptions);
   [$resolve](ctx: ResolutionCtx): ResolvedSnippet;
   toString(): string;
+  get performanceCallbackQuerySet(): TgpuQuerySet<"timestamp"> | undefined;
   unwrap(): Memo;
 }
 /**

package/core/pipeline/renderPipeline.js

@@ -8,21 +8,23 @@ 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 { connectAttributesToShader } from "../vertexLayout/connectAttributesToShader.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), {});
 }
@@ -78,7 +80,16 @@ var TgpuRenderPipelineImpl = class TgpuRenderPipelineImpl {
 	}
 	withPerformanceCallback(callback) {
 		const internals = this[$internal];
-		const newPriors = createWithPerformanceCallback(internals.priors, callback, internals.core.options.root);
+		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) {
@@ -254,22 +265,23 @@ var TgpuRenderPipelineImpl = class TgpuRenderPipelineImpl {
 			priors: internals.priors
 		});
 	}
-	drawIndirect(indirectBuffer, indirectOffset = 0) {
+	drawIndirect(indirectBuffer, indirectOffset) {
 		const internals = this[$internal];
 		const { root } = internals.core.options;
-		const rawBuffer = isGPUBuffer(indirectBuffer) ? indirectBuffer : root.unwrap(indirectBuffer);
+		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, indirectOffset);
+			internals.priors.externalRenderEncoder.drawIndirect(rawBuffer, offset);
 			return;
 		}
 		if (internals.priors.externalEncoder) {
 			const pass = this._createRenderPass(internals.priors.externalEncoder);
 			this._applyRenderState(pass);
-			pass.drawIndirect(rawBuffer, indirectOffset);
+			pass.drawIndirect(rawBuffer, offset);
 			pass.end();
 			return;
 		}
@@ -277,7 +289,7 @@ var TgpuRenderPipelineImpl = class TgpuRenderPipelineImpl {
 		const commandEncoder = root.device.createCommandEncoder();
 		const pass = this._createRenderPass(commandEncoder);
 		this._applyRenderState(pass);
-		pass.drawIndirect(rawBuffer, indirectOffset);
+		pass.drawIndirect(rawBuffer, offset);
 		pass.end();
 		root.device.queue.submit([commandEncoder.finish()]);
 		if (logResources) logDataFromGPU(logResources);
@@ -286,24 +298,25 @@ var TgpuRenderPipelineImpl = class TgpuRenderPipelineImpl {
 			priors: internals.priors
 		});
 	}
-	drawIndexedIndirect(indirectBuffer, indirectOffset = 0) {
+	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, indirectOffset);
+			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, indirectOffset);
+			pass.drawIndexedIndirect(rawBuffer, offset);
 			pass.end();
 			return;
 		}
@@ -312,7 +325,7 @@ var TgpuRenderPipelineImpl = class TgpuRenderPipelineImpl {
 		const pass = this._createRenderPass(commandEncoder);
 		this._applyRenderState(pass);
 		this._setIndexBuffer(pass);
-		pass.drawIndexedIndirect(rawBuffer, indirectOffset);
+		pass.drawIndexedIndirect(rawBuffer, offset);
 		pass.end();
 		root.device.queue.submit([commandEncoder.finish()]);
 		if (logResources) logDataFromGPU(logResources);
@@ -324,9 +337,11 @@ var TgpuRenderPipelineImpl = class TgpuRenderPipelineImpl {
 };
 var RenderPipelineCore = class {
 	[$internal] = true;
+	options;
 	_memo;
 	#latestAutoVertexIn;
 	#latestAutoFragmentOut;
+	#performanceCallbackQuerySet;
 	constructor(options) {
 		this.options = options;
 	}
@@ -354,6 +369,10 @@ var RenderPipelineCore = class {
 	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;
@@ -466,6 +485,5 @@ function matchUpVaryingLocations(vertexOut = {}, fragmentIn = {}, vertexFnName,
 function isGPUCanvasContext(value) {
 	return typeof value?.getCurrentTexture === "function";
 }
-
 //#endregion
-export { INTERNAL_createRenderPipeline };
+export { INTERNAL_createRenderPipeline };

package/core/pipeline/timeable.d.ts

@@ -1,6 +1,4 @@
 import { TgpuQuerySet } from "../querySet/querySet.js";
-import "../root/rootTypes.js";
-
 //#region src/core/pipeline/timeable.d.ts
 interface Timeable {
   withPerformanceCallback(callback: (start: bigint, end: bigint) => void | Promise<void>): this;
@@ -17,7 +15,6 @@ type TimestampWritesPriors = {
     endOfPassWriteIndex?: number;
   };
   readonly performanceCallback?: (start: bigint, end: bigint) => void | Promise<void>;
-  readonly hasAutoQuerySet?: boolean;
 };
 //#endregion
 export { Timeable, TimestampWritesPriors };