typegpu 0.10.0 → 0.10.2

package/core/pipeline/computePipeline.js

@@ -0,0 +1,226 @@
+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 { namespace } from "../resolve/namespace.js";
+import { isBindGroup } from "../../tgpuBindGroupLayout.js";
+import { resolve } from "../../resolutionCtx.js";
+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 { 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;
+		this[$internal] = {
+			get rawPipeline() {
+				return _core.unwrap().pipeline;
+			},
+			get priors() {
+				return _priors;
+			},
+			get root() {
+				return _core.root;
+			}
+		};
+		this[$getNameForward] = _core;
+	}
+	[$resolve](ctx) {
+		return ctx.resolve(this._core);
+	}
+	toString() {
+		return `computePipeline:${getName(this) ?? "<unnamed>"}`;
+	}
+	get rawPipeline() {
+		return this._core.unwrap().pipeline;
+	}
+	with(first, bindGroup) {
+		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,
+			externalEncoder: first,
+			externalPass: void 0
+		});
+		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]])
+		});
+	}
+	withPerformanceCallback(callback) {
+		const newPriors = createWithPerformanceCallback(this._priors, callback, this._core.root);
+		return new TgpuComputePipelineImpl(this._core, newPriors);
+	}
+	withTimestampWrites(options) {
+		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));
+	}
+	_applyComputeState(pass) {
+		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));
+	}
+	_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);
+			}
+			dispatch(this._priors.externalPass);
+			return;
+		}
+		if (this._priors.externalEncoder) {
+			const passDescriptor = {
+				label: getName(this._core) ?? "<unnamed>",
+				...setupTimestampWrites(this._priors, root)
+			};
+			const pass = this._priors.externalEncoder.beginComputePass(passDescriptor);
+			this._applyComputeState(pass);
+			dispatch(pass);
+			pass.end();
+			return;
+		}
+		const memo = this._core.unwrap();
+		const passDescriptor = {
+			label: getName(this._core) ?? "<unnamed>",
+			...setupTimestampWrites(this._priors, root)
+		};
+		const commandEncoder = root.device.createCommandEncoder();
+		const pass = commandEncoder.beginComputePass(passDescriptor);
+		this._applyComputeState(pass);
+		dispatch(pass);
+		pass.end();
+		root.device.queue.submit([commandEncoder.finish()]);
+		if (memo.logResources) logDataFromGPU(memo.logResources);
+		if (this._priors.performanceCallback) triggerPerformanceCallback({
+			root,
+			priors: this._priors
+		});
+	}
+	$name(label) {
+		setName(this, label);
+		return this;
+	}
+};
+var ComputePipelineCore = class {
+	[$internal] = true;
+	_memo;
+	#slotBindings;
+	#descriptor;
+	constructor(root, slotBindings, descriptor) {
+		this.root = root;
+		this.#slotBindings = slotBindings;
+		this.#descriptor = descriptor;
+	}
+	[$resolve](ctx) {
+		return ctx.withSlots(this.#slotBindings, () => {
+			ctx.resolve(this.#descriptor.compute);
+			return snip("", Void, "runtime");
+		});
+	}
+	toString() {
+		return "computePipelineCore";
+	}
+	unwrap() {
+		if (this._memo === void 0) {
+			const device = this.root.device;
+			const enableExtensions = wgslExtensions.filter((extension) => this.root.enabledFeatures.has(wgslExtensionToFeatureName[extension]));
+			let resolutionResult;
+			let resolveMeasure;
+			const ns = namespace({ names: this.root.nameRegistrySetting });
+			if (PERF?.enabled) {
+				const resolveStart = performance.mark("typegpu:resolution:start");
+				resolutionResult = resolve(this, {
+					namespace: ns,
+					enableExtensions,
+					shaderGenerator: this.root.shaderGenerator,
+					root: this.root
+				});
+				resolveMeasure = performance.measure("typegpu:resolution", { start: resolveStart.name });
+			} else resolutionResult = resolve(this, {
+				namespace: ns,
+				enableExtensions,
+				shaderGenerator: this.root.shaderGenerator,
+				root: this.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
+			});
+			this._memo = {
+				pipeline: device.createComputePipeline({
+					label: getName(this) ?? "<unnamed>",
+					layout: device.createPipelineLayout({
+						label: `${getName(this) ?? "<unnamed>"} - Pipeline Layout`,
+						bindGroupLayouts: usedBindGroupLayouts.map((l) => this.root.unwrap(l))
+					}),
+					compute: { module }
+				}),
+				usedBindGroupLayouts,
+				catchall,
+				logResources
+			};
+			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;
+	}
+};
+
+//#endregion
+export { INTERNAL_createComputePipeline };

package/core/pipeline/connectAttachmentToShader.js

@@ -0,0 +1,26 @@
+import { isWgslStruct } from "../../data/wgslTypes.js";
+import { isBuiltin } from "../../data/attributes.js";
+
+//#region src/core/pipeline/connectAttachmentToShader.ts
+function isColorAttachment(value) {
+	return !!value?.view;
+}
+function connectAttachmentToShader(fragmentOut, attachment) {
+	if (isBuiltin(fragmentOut)) return [];
+	if (isWgslStruct(fragmentOut)) {
+		const result = [];
+		for (const key of Object.keys(fragmentOut.propTypes)) {
+			const outputValue = fragmentOut.propTypes[key];
+			if (isBuiltin(outputValue)) continue;
+			const matching = attachment[key];
+			if (!matching) throw new Error(`A color attachment by the name of '${key}' was not provided to the shader.`);
+			result.push(matching);
+		}
+		return result;
+	}
+	if (!isColorAttachment(attachment)) throw new Error("Expected a single color attachment, not a record.");
+	return [attachment];
+}
+
+//#endregion
+export { connectAttachmentToShader };

package/core/pipeline/connectTargetsToShader.js

@@ -0,0 +1,29 @@
+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;
+	if (isVoid(fragmentOut) || isBuiltin(fragmentOut)) return [null];
+	if (isWgslStruct(fragmentOut)) {
+		const result = [];
+		for (const key of Object.keys(fragmentOut.propTypes)) {
+			const outputValue = fragmentOut.propTypes[key];
+			if (isBuiltin(outputValue)) continue;
+			const matchingTarget = targets[key];
+			result.push({
+				...matchingTarget,
+				format: matchingTarget?.format ?? (presentationFormat ??= navigator.gpu.getPreferredCanvasFormat())
+			});
+		}
+		return result;
+	}
+	const singleTarget = targets;
+	return [{
+		...singleTarget,
+		format: singleTarget?.format ?? (presentationFormat ??= navigator.gpu.getPreferredCanvasFormat())
+	}];
+}
+
+//#endregion
+export { connectTargetsToShader };

package/core/pipeline/limitsOverflow.js

@@ -0,0 +1,13 @@
+//#region src/core/pipeline/limitsOverflow.ts
+function warnIfOverflow(layouts, limits) {
+	const entries = Object.values(layouts).flatMap((layout) => Object.values(layout.entries)).filter((entry) => entry !== null);
+	const uniform = entries.filter((entry) => "uniform" in entry).length;
+	const storage = entries.filter((entry) => "storage" in entry).length;
+	if (uniform > limits.maxUniformBuffersPerShaderStage) console.warn(`Total number of uniform buffers (${uniform}) exceeds maxUniformBuffersPerShaderStage (${limits.maxUniformBuffersPerShaderStage}). Consider:
+1. Grouping some of the uniforms into one using 'd.struct',
+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 };

package/core/pipeline/renderPipeline.d.ts

@@ -0,0 +1,266 @@
+import { TgpuNamable } from "../../shared/meta.js";
+import { $internal, $resolve } from "../../shared/symbols.js";
+import { AnyBuiltin, OmitBuiltins } from "../../builtin.js";
+import "../querySet/querySet.js";
+import { ResolvedSnippet } from "../../data/snippet.js";
+import { LogResources } from "../../tgsl/consoleLog/types.js";
+import { TgpuSlot } from "../slot/slotTypes.js";
+import { Timeable, TimestampWritesPriors } from "./timeable.js";
+import { AnyVertexAttribs } from "../../shared/vertexFormat.js";
+import { AnyAutoCustoms, AutoFragmentIn, AutoFragmentOut, AutoVertexIn, AutoVertexOut } from "../function/autoIO.js";
+import { TgpuFragmentFn } from "../function/tgpuFragmentFn.js";
+import { TgpuVertexFn } from "../function/tgpuVertexFn.js";
+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 { 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";
+import { TextureInternals, TgpuTextureRenderView, TgpuTextureView } from "../texture/texture.js";
+import { Disarray, UndecorateRecord } from "../../data/dataTypes.js";
+
+//#region src/core/pipeline/renderPipeline.d.ts
+interface RenderPipelineInternals {
+  readonly core: RenderPipelineCore;
+  readonly priors: TgpuRenderPipelinePriors & TimestampWritesPriors;
+  readonly root: ExperimentalTgpuRoot;
+}
+type TgpuPrimitiveState = GPUPrimitiveState | (Omit<GPUPrimitiveState, 'stripIndexFormat'> & {
+  stripIndexFormat?: U32 | U16;
+}) | undefined;
+type TgpuColorTargetState = (Omit<GPUColorTargetState, 'format'> & {
+  /**
+   * The {@link GPUTextureFormat} of this color target. The pipeline will only be compatible with
+   * {@link GPURenderPassEncoder}s which use a {@link GPUTextureView} of this format in the
+   * corresponding color attachment.
+   *
+   * @default navigator.gpu.getPreferredCanvasFormat()
+   */
+  format?: GPUTextureFormat | undefined;
+}) | undefined;
+interface HasIndexBuffer {
+  readonly hasIndexBuffer: true;
+  drawIndexed(indexCount: number, instanceCount?: number, firstIndex?: number, baseVertex?: number, firstInstance?: number): void;
+}
+interface TgpuRenderPipeline<in Targets = never> extends TgpuNamable, SelfResolvable, Timeable {
+  readonly [$internal]: RenderPipelineInternals;
+  readonly resourceType: 'render-pipeline';
+  readonly hasIndexBuffer: boolean;
+  with<TData extends WgslArray | Disarray>(vertexLayout: TgpuVertexLayout<TData>, buffer: (TgpuBuffer<TData> & VertexFlag) | GPUBuffer): this;
+  /**
+   * @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: GPURenderPassEncoder): this;
+  with(bundleEncoder: GPURenderBundleEncoder): this;
+  /**
+   * Attaches texture views to the pipeline's targets (outputs).
+   *
+   * @example
+   * // Draw 3 vertices onto the context's canvas
+   * pipeline
+   *   .withColorAttachment({ view: context })
+   *   .draw(3)
+   *
+   * @param attachment The object should match the shape
+   * returned by the fragment shader, with values matching the {@link ColorAttachment} type.
+   */
+  withColorAttachment(attachment: FragmentOutToColorAttachment<Targets>): this;
+  withDepthStencilAttachment(attachment: DepthStencilAttachment): this;
+  withStencilReference(reference: GPUStencilValue): this;
+  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;
+}
+declare namespace TgpuRenderPipeline {
+  interface DescriptorBase {
+    /**
+     * Describes the primitive-related properties of the pipeline.
+     */
+    primitive?: TgpuPrimitiveState | undefined;
+    /**
+     * Describes the optional depth-stencil properties, including the testing, operations, and bias.
+     */
+    depthStencil?: GPUDepthStencilState | undefined;
+    /**
+     * Describes the multi-sampling properties of the pipeline.
+     */
+    multisample?: GPUMultisampleState | undefined;
+  }
+  interface Descriptor extends DescriptorBase {
+    vertex: TgpuVertexFn | ((input: AutoVertexIn<Record<string, never>>) => AutoVertexOut<AnyAutoCustoms>);
+    fragment?: TgpuFragmentFn | ((input: AutoFragmentIn<Record<string, never>>) => AutoFragmentOut<undefined | v4f | AnyAutoCustoms>) | undefined;
+    attribs?: AnyVertexAttribs | undefined;
+    targets?: AnyFragmentTargets | undefined;
+  }
+}
+type FragmentOutToTargets<T> = T extends undefined | AnyBuiltin | Void | Record<string, never> ? Record<string, never> | undefined : T extends {
+  readonly [$internal]: unknown;
+} | number | boolean | AnyVecInstance ? TgpuColorTargetState : T extends Record<string, unknown> ? { [Key in keyof OmitBuiltins<T>]?: TgpuColorTargetState } | undefined : TgpuColorTargetState | Record<string, TgpuColorTargetState>;
+type FragmentOutToColorAttachment<T> = T extends {
+  readonly [$internal]: unknown;
+} ? ColorAttachment : T extends Record<string, unknown> ? { [Key in keyof UndecorateRecord<T>]: ColorAttachment } : Record<string, never>;
+type AnyFragmentTargets = TgpuColorTargetState | Record<string, TgpuColorTargetState>;
+interface ColorTextureConstraint {
+  readonly [$internal]: TextureInternals;
+  readonly resourceType: 'texture';
+  readonly props: {
+    format: GPUTextureFormat;
+  };
+}
+interface ColorAttachment {
+  /**
+   * A {@link GPUTextureView} describing the texture subresource that will be output to for this
+   * color attachment.
+   */
+  view: (ColorTextureConstraint & RenderFlag) | GPUTextureView | TgpuTextureView<WgslTexture> | TgpuTextureRenderView | GPUCanvasContext;
+  /**
+   * Indicates the depth slice index of {@link GPUTextureViewDimension#"3d"} {@link GPURenderPassColorAttachment#view}
+   * that will be output to for this color attachment.
+   */
+  depthSlice?: GPUIntegerCoordinate;
+  /**
+   * A {@link GPUTextureView} describing the texture subresource that will receive the resolved
+   * output for this color attachment if {@link GPURenderPassColorAttachment#view} is
+   * multisampled.
+   */
+  resolveTarget?: (ColorTextureConstraint & RenderFlag) | GPUTextureView | TgpuTextureView<WgslTexture> | TgpuTextureRenderView | GPUCanvasContext;
+  /**
+   * Indicates the value to clear {@link GPURenderPassColorAttachment#view} to prior to executing the
+   * render pass. If not map/exist|provided, defaults to `{r: 0, g: 0, b: 0, a: 0}`. Ignored
+   * if {@link GPURenderPassColorAttachment#loadOp} is not {@link GPULoadOp#"clear"}.
+   * The components of {@link GPURenderPassColorAttachment#clearValue} are all double values.
+   * They are converted to a texel value of texture format matching the render attachment.
+   * If conversion fails, a validation error is generated.
+   */
+  clearValue?: GPUColor;
+  /**
+   * Indicates the load operation to perform on {@link GPURenderPassColorAttachment#view} prior to
+   * executing the render pass.
+   * Note: It is recommended to prefer clearing; see {@link GPULoadOp#"clear"} for details.
+   *
+   * @default 'clear'
+   */
+  loadOp?: GPULoadOp | undefined;
+  /**
+   * The store operation to perform on {@link GPURenderPassColorAttachment#view}
+   * after executing the render pass.
+   *
+   * @default 'store'
+   */
+  storeOp?: GPUStoreOp | undefined;
+}
+type DepthStencilFormat = 'stencil8' | 'depth16unorm' | 'depth24plus' | 'depth24plus-stencil8' | 'depth32float' | 'depth32float-stencil8';
+interface DepthStencilTextureConstraint {
+  readonly [$internal]: TextureInternals;
+  readonly resourceType: 'texture';
+  readonly props: {
+    format: DepthStencilFormat;
+  };
+}
+interface DepthStencilAttachment {
+  /**
+   * A {@link GPUTextureView} | ({@link TgpuTexture} & {@link RenderFlag}) describing the texture subresource that will be output to
+   * and read from for this depth/stencil attachment.
+   */
+  view: (DepthStencilTextureConstraint & RenderFlag) | TgpuTextureView<WgslTextureDepth2d | WgslTextureDepthMultisampled2d> | TgpuTextureRenderView | GPUTextureView;
+  /**
+   * Indicates the value to clear {@link GPURenderPassDepthStencilAttachment#view}'s depth component
+   * to prior to executing the render pass. Ignored if {@link GPURenderPassDepthStencilAttachment#depthLoadOp}
+   * is not {@link GPULoadOp#"clear"}. Must be between 0.0 and 1.0, inclusive (unless unrestricted depth is enabled).
+   */
+  depthClearValue?: number;
+  /**
+   * Indicates the load operation to perform on {@link GPURenderPassDepthStencilAttachment#view}'s
+   * depth component prior to executing the render pass.
+   * Note: It is recommended to prefer clearing; see {@link GPULoadOp#"clear"} for details.
+   */
+  depthLoadOp?: GPULoadOp;
+  /**
+   * The store operation to perform on {@link GPURenderPassDepthStencilAttachment#view}'s
+   * depth component after executing the render pass.
+   */
+  depthStoreOp?: GPUStoreOp;
+  /**
+   * Indicates that the depth component of {@link GPURenderPassDepthStencilAttachment#view}
+   * is read only.
+   */
+  depthReadOnly?: boolean;
+  /**
+   * Indicates the value to clear {@link GPURenderPassDepthStencilAttachment#view}'s stencil component
+   * to prior to executing the render pass. Ignored if {@link GPURenderPassDepthStencilAttachment#stencilLoadOp}
+   * is not {@link GPULoadOp#"clear"}.
+   * The value will be converted to the type of the stencil aspect of `view` by taking the same
+   * number of LSBs as the number of bits in the stencil aspect of one texel block|texel of `view`.
+   */
+  stencilClearValue?: GPUStencilValue;
+  /**
+   * Indicates the load operation to perform on {@link GPURenderPassDepthStencilAttachment#view}'s
+   * stencil component prior to executing the render pass.
+   * Note: It is recommended to prefer clearing; see {@link GPULoadOp#"clear"} for details.
+   */
+  stencilLoadOp?: GPULoadOp;
+  /**
+   * The store operation to perform on {@link GPURenderPassDepthStencilAttachment#view}'s
+   * stencil component after executing the render pass.
+   */
+  stencilStoreOp?: GPUStoreOp;
+  /**
+   * Indicates that the stencil component of {@link GPURenderPassDepthStencilAttachment#view}
+   * is read only.
+   */
+  stencilReadOnly?: boolean;
+}
+type AnyFragmentColorAttachment = ColorAttachment | Record<string, ColorAttachment>;
+type RenderPipelineCoreOptions = {
+  root: ExperimentalTgpuRoot;
+  slotBindings: [TgpuSlot<unknown>, unknown][];
+  descriptor: TgpuRenderPipeline.Descriptor;
+};
+type TgpuRenderPipelinePriors = {
+  readonly vertexLayoutMap?: Map<TgpuVertexLayout, (TgpuBuffer<BaseData> & VertexFlag) | GPUBuffer> | undefined;
+  readonly bindGroupLayoutMap?: Map<TgpuBindGroupLayout, TgpuBindGroup | GPUBindGroup> | undefined;
+  readonly colorAttachment?: AnyFragmentColorAttachment | undefined;
+  readonly depthStencilAttachment?: DepthStencilAttachment | undefined;
+  readonly stencilReference?: GPUStencilValue | undefined;
+  readonly indexBuffer?: {
+    buffer: (TgpuBuffer<BaseData> & IndexFlag) | GPUBuffer;
+    indexFormat: GPUIndexFormat;
+    offsetBytes?: number | undefined;
+    sizeBytes?: number | undefined;
+  } | undefined;
+  readonly externalEncoder?: GPUCommandEncoder | undefined;
+  readonly externalRenderEncoder?: GPURenderPassEncoder | GPURenderBundleEncoder | undefined;
+} & TimestampWritesPriors;
+type Memo = {
+  pipeline: GPURenderPipeline;
+  usedBindGroupLayouts: TgpuBindGroupLayout[];
+  catchall: [number, TgpuBindGroup] | undefined;
+  logResources: LogResources | undefined;
+  usedVertexLayouts: TgpuVertexLayout[];
+  fragmentOut: BaseData;
+};
+declare class RenderPipelineCore implements SelfResolvable {
+  #private;
+  readonly options: RenderPipelineCoreOptions;
+  readonly [$internal] = true;
+  private _memo;
+  constructor(options: RenderPipelineCoreOptions);
+  [$resolve](ctx: ResolutionCtx): ResolvedSnippet;
+  toString(): string;
+  unwrap(): 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
+ */
+//#endregion
+export { ColorAttachment, FragmentOutToTargets, TgpuPrimitiveState, TgpuRenderPipeline };