typegpu 0.11.9 → 0.12.1

package/core/commandEncoder/attachments.js

@@ -0,0 +1,29 @@
+import { $internal } from "../../shared/symbols.js";
+import { isQuerySet } from "../querySet/querySet.js";
+import { isGPUCanvasContext } from "../pipeline/typeGuards.js";
+import { isTexture, isTextureView, } from "../texture/texture.js";
+export function unwrapAttachmentView(root, view) {
+    if (isTexture(view)) {
+        return root.unwrap(view).createView();
+    }
+    if (isTextureView(view)) {
+        return root.unwrap(view);
+    }
+    if (isGPUCanvasContext(view)) {
+        return view.getCurrentTexture().createView();
+    }
+    return view;
+}
+export function unwrapTimestampWrites(root, timestampWrites) {
+    const { querySet, beginningOfPassWriteIndex, endOfPassWriteIndex } = timestampWrites;
+    const result = {
+        querySet: isQuerySet(querySet) ? root.unwrap(querySet) : querySet,
+    };
+    if (beginningOfPassWriteIndex !== undefined) {
+        result.beginningOfPassWriteIndex = beginningOfPassWriteIndex;
+    }
+    if (endOfPassWriteIndex !== undefined) {
+        result.endOfPassWriteIndex = endOfPassWriteIndex;
+    }
+    return result;
+}

package/core/commandEncoder/commandEncoder.d.ts

@@ -0,0 +1,53 @@
+import { $internal } from '../../shared/symbols.ts';
+import type { ExperimentalTgpuRoot } from '../root/rootTypes.ts';
+import { type TgpuComputePass, type TgpuComputePassDescriptor } from './computePass.ts';
+import { type TgpuRenderPass, type TgpuRenderPassDescriptor } from './renderPass.ts';
+export interface CommandEncoderInternals {
+    readonly rawEncoder: GPUCommandEncoder;
+    readonly root: ExperimentalTgpuRoot;
+    /** A caller-owned raw encoder, so submission is out of our hands and no work can be deferred */
+    readonly adopted: boolean;
+    /** Commands recorded just before the encoder is finished, keyed for deduplication */
+    readonly beforeFinish: Map<object, (rawEncoder: GPUCommandEncoder) => void>;
+    /** Callbacks run once the recorded commands have been submitted, keyed for deduplication */
+    readonly afterSubmit: Map<object, () => void>;
+}
+/**
+ * The TypeGPU equivalent of {@link GPUCommandEncoder}, for batching multiple
+ * passes (and draws within them) into a single submission.
+ *
+ * @example
+ * ```ts
+ * const encoder = root['~unstable'].createCommandEncoder();
+ * const pass = encoder.beginRenderPass({
+ *   colorAttachments: [{ view: msaaTexture, resolveTarget: context }],
+ * });
+ * scenePipeline.with(pass).draw(vertexCount);
+ * skyPipeline.with(pass).draw(3);
+ * pass.end();
+ * encoder.submit();
+ * ```
+ *
+ * For anything not covered by the typed surface (e.g. texture copies), grab
+ * the raw encoder via `root.unwrap(encoder)`.
+ */
+export interface TgpuCommandEncoder {
+    readonly [$internal]: CommandEncoderInternals;
+    readonly resourceType: 'command-encoder';
+    /**
+     * Begins recording a render pass. Attachment views accept TypeGPU textures,
+     * texture views and canvas contexts, next to raw {@link GPUTextureView}s.
+     */
+    beginRenderPass(descriptor: TgpuRenderPassDescriptor): TgpuRenderPass;
+    /** Begins recording a compute pass */
+    beginComputePass(descriptor?: TgpuComputePassDescriptor): TgpuComputePass;
+    /** Finishes the recording and submits the resulting command buffer to the device queue */
+    submit(): void;
+    /**
+     * Escape hatch: finishes the recording without submitting, for manual
+     * multi-encoder batching via `device.queue.submit([...])`.
+     */
+    finish(descriptor?: GPUCommandBufferDescriptor): GPUCommandBuffer;
+}
+export declare function INTERNAL_createCommandEncoder(root: ExperimentalTgpuRoot, descriptor?: GPUCommandEncoderDescriptor): TgpuCommandEncoder;
+export declare function INTERNAL_adoptCommandEncoder(root: ExperimentalTgpuRoot, rawEncoder: GPUCommandEncoder): TgpuCommandEncoder;

package/core/commandEncoder/commandEncoder.js

@@ -0,0 +1,56 @@
+import { $internal } from "../../shared/symbols.js";
+import { logger } from "../../tgpuLogger.js";
+import { INTERNAL_beginComputePass, } from "./computePass.js";
+import { INTERNAL_beginRenderPass, } from "./renderPass.js";
+export function INTERNAL_createCommandEncoder(root, descriptor) {
+    return new TgpuCommandEncoderImpl(root, root.device.createCommandEncoder(descriptor), false);
+}
+export function INTERNAL_adoptCommandEncoder(root, rawEncoder) {
+    return new TgpuCommandEncoderImpl(root, rawEncoder, true);
+}
+// --------------
+// Implementation
+// --------------
+class TgpuCommandEncoderImpl {
+    [$internal];
+    resourceType = 'command-encoder';
+    constructor(root, rawEncoder, adopted) {
+        this[$internal] = {
+            rawEncoder,
+            root,
+            adopted,
+            beforeFinish: new Map(),
+            afterSubmit: new Map(),
+        };
+    }
+    beginRenderPass(descriptor) {
+        return INTERNAL_beginRenderPass(this, descriptor);
+    }
+    beginComputePass(descriptor) {
+        return INTERNAL_beginComputePass(this, descriptor);
+    }
+    #recordPendingCommands() {
+        const { rawEncoder, beforeFinish } = this[$internal];
+        for (const record of beforeFinish.values()) {
+            record(rawEncoder);
+        }
+        beforeFinish.clear();
+    }
+    submit() {
+        const { rawEncoder, root, afterSubmit } = this[$internal];
+        this.#recordPendingCommands();
+        root.device.queue.submit([rawEncoder.finish()]);
+        for (const hook of afterSubmit.values()) {
+            hook();
+        }
+        afterSubmit.clear();
+    }
+    finish(descriptor) {
+        const { rawEncoder, root, afterSubmit } = this[$internal];
+        this.#recordPendingCommands();
+        if (afterSubmit.size > 0) {
+            logger.warnOnce('suspicious', root, 'finishWithPendingWork', 'Shader console.log output and performance callbacks do not fire for command buffers produced by encoder.finish(). Use encoder.submit() instead.');
+        }
+        return rawEncoder.finish(descriptor);
+    }
+}

package/core/commandEncoder/computePass.d.ts

@@ -0,0 +1,58 @@
+import type { PrimitiveOffsetInfo } from '../../data/offsetUtils.ts';
+import type { AnyWgslData } from '../../data/wgslTypes.ts';
+import { $internal } from '../../shared/symbols.ts';
+import type { TgpuBindGroup, TgpuBindGroupLayout, TgpuLayoutEntry } from '../../tgpuBindGroupLayout.ts';
+import type { IndirectFlag, TgpuBuffer } from '../buffer/buffer.ts';
+import { ComputeDrawState } from '../pipeline/drawState.ts';
+import type { TgpuComputePipeline } from '../pipeline/computePipeline.ts';
+import type { ExperimentalTgpuRoot } from '../root/rootTypes.ts';
+import { type TgpuPassTimestampWrites } from './attachments.ts';
+import type { TgpuCommandEncoder } from './commandEncoder.ts';
+/**
+ * The TypeGPU equivalent of {@link GPUComputePassDescriptor}.
+ * Query sets accept TypeGPU query sets next to raw {@link GPUQuerySet}s.
+ */
+export interface TgpuComputePassDescriptor {
+    label?: string | undefined;
+    timestampWrites?: TgpuPassTimestampWrites | undefined;
+}
+export interface ComputePassInternals {
+    readonly rawPass: GPUComputePassEncoder;
+    readonly state: ComputeDrawState;
+    /** Undefined for raw pass encoders the caller owns */
+    readonly owner: TgpuCommandEncoder | undefined;
+    appliedVersion: number | undefined;
+}
+/**
+ * A compute pass recording into a {@link TgpuCommandEncoder}.
+ *
+ * Dispatch either by binding TypeGPU pipelines to it
+ * (`pipeline.with(pass).dispatchWorkgroups(...)`), or proxy-style via
+ * `pass.setPipeline(pipeline)` followed by `pass.dispatchWorkgroups(...)`.
+ *
+ * Call `end()` when done recording.
+ */
+export interface TgpuComputePass {
+    readonly [$internal]: ComputePassInternals;
+    readonly resourceType: 'compute-pass';
+    /** Sets the current {@link TgpuComputePipeline} for subsequent dispatches */
+    setPipeline(pipeline: TgpuComputePipeline): void;
+    /** Associates a bind group with the layout it was created from */
+    setBindGroup(bindGroup: TgpuBindGroup): void;
+    /** Associates a bind group with the given layout */
+    setBindGroup<Entries extends Record<string, TgpuLayoutEntry | null>>(bindGroupLayout: TgpuBindGroupLayout<Entries>, bindGroup: TgpuBindGroup<Entries> | GPUBindGroup): void;
+    dispatchWorkgroups(x: number, y?: number, z?: number): void;
+    /**
+     * Dispatches compute workgroups using parameters read from a buffer.
+     * The buffer must contain 3 consecutive u32 values (x, y, z workgroup counts).
+     * To get the correct offset within complex data structures, use `d.memoryLayoutOf(...)`.
+     *
+     * @param indirectBuffer - Buffer marked with 'indirect' usage containing dispatch parameters or raw GPUBuffer
+     * @param start - PrimitiveOffsetInfo pointing to the first dispatch parameter. If not provided, starts at offset 0. To obtain safe offsets, use `d.memoryLayoutOf(...)`.
+     */
+    dispatchWorkgroupsIndirect<T extends AnyWgslData>(indirectBuffer: (TgpuBuffer<T> & IndirectFlag) | GPUBuffer, start?: PrimitiveOffsetInfo | number): void;
+    /** Completes the recording of this compute pass */
+    end(): void;
+}
+export declare function INTERNAL_beginComputePass(encoder: TgpuCommandEncoder, descriptor?: TgpuComputePassDescriptor): TgpuComputePass;
+export declare function INTERNAL_adoptComputePass(root: ExperimentalTgpuRoot, rawPass: GPUComputePassEncoder): TgpuComputePass;

package/core/commandEncoder/computePass.js

@@ -0,0 +1,63 @@
+import { $internal } from "../../shared/symbols.js";
+import { isGPUBuffer } from "../../types.js";
+import { DISPATCH_INDIRECT_SIZE, resolveIndirectOffset } from "../pipeline/pipelineUtils.js";
+import { ComputeDrawState, emitComputeDispatch, recordBindGroup, stampComputePipeline, } from "../pipeline/drawState.js";
+import { unwrapTimestampWrites } from "./attachments.js";
+// --------------
+// Implementation
+// --------------
+export function INTERNAL_beginComputePass(encoder, descriptor) {
+    const { rawEncoder, root } = encoder[$internal];
+    const rawDescriptor = {};
+    if (descriptor?.label !== undefined) {
+        rawDescriptor.label = descriptor.label;
+    }
+    if (descriptor?.timestampWrites !== undefined) {
+        rawDescriptor.timestampWrites = unwrapTimestampWrites(root, descriptor.timestampWrites);
+    }
+    return new TgpuComputePassImpl(root, rawEncoder.beginComputePass(rawDescriptor), encoder);
+}
+export function INTERNAL_adoptComputePass(root, rawPass) {
+    const adopted = new TgpuComputePassImpl(root, rawPass, undefined);
+    adopted[$internal].state.rawAccessed = true;
+    return adopted;
+}
+class TgpuComputePassImpl {
+    [$internal];
+    resourceType = 'compute-pass';
+    #root;
+    constructor(root, rawPass, owner) {
+        this.#root = root;
+        this[$internal] = {
+            rawPass,
+            state: new ComputeDrawState(),
+            owner,
+            appliedVersion: undefined,
+        };
+    }
+    #emit(emit) {
+        const internals = this[$internal];
+        const pipeline = internals.state.currentPipeline;
+        if (!pipeline) {
+            throw new Error('Cannot dispatch without a call to pass.setPipeline');
+        }
+        emitComputeDispatch(this.#root, internals, pipeline, emit);
+    }
+    setPipeline(pipeline) {
+        stampComputePipeline(this[$internal].state, pipeline);
+    }
+    setBindGroup(first, bindGroup) {
+        recordBindGroup(this[$internal].state, first, bindGroup);
+    }
+    dispatchWorkgroups(x, y, z) {
+        this.#emit((rawPass) => rawPass.dispatchWorkgroups(x, y, z));
+    }
+    dispatchWorkgroupsIndirect(indirectBuffer, start) {
+        const rawBuffer = isGPUBuffer(indirectBuffer) ? indirectBuffer : indirectBuffer.buffer;
+        const offset = resolveIndirectOffset(indirectBuffer, start, DISPATCH_INDIRECT_SIZE, 'dispatchWorkgroupsIndirect');
+        this.#emit((rawPass) => rawPass.dispatchWorkgroupsIndirect(rawBuffer, offset));
+    }
+    end() {
+        this[$internal].rawPass.end();
+    }
+}

package/core/commandEncoder/renderPass.d.ts

@@ -0,0 +1,121 @@
+import type { Disarray } from '../../data/dataTypes.ts';
+import type { PrimitiveOffsetInfo } from '../../data/offsetUtils.ts';
+import type { BaseData, WgslArray } from '../../data/wgslTypes.ts';
+import { $internal } from '../../shared/symbols.ts';
+import type { TgpuBindGroup, TgpuBindGroupLayout, TgpuLayoutEntry } from '../../tgpuBindGroupLayout.ts';
+import type { IndexFlag, IndirectFlag, TgpuBuffer, VertexFlag } from '../buffer/buffer.ts';
+import { RenderDrawState } from '../pipeline/drawState.ts';
+import type { TgpuRenderPipeline } from '../pipeline/renderPipeline.ts';
+import { type TgpuQuerySet } from '../querySet/querySet.ts';
+import type { ExperimentalTgpuRoot } from '../root/rootTypes.ts';
+import type { TgpuCommandEncoder } from './commandEncoder.ts';
+import type { TgpuVertexLayout } from '../vertexLayout/vertexLayout.ts';
+import { type ColorAttachment, type DepthStencilAttachment, type TgpuPassTimestampWrites } from './attachments.ts';
+/**
+ * The TypeGPU equivalent of {@link GPURenderPassDescriptor}. Attachment views accept
+ * TypeGPU textures, texture views and canvas contexts (next to raw {@link GPUTextureView}s),
+ * and query sets accept {@link TgpuQuerySet}.
+ *
+ * Load/store operations default to `loadOp: 'clear'`, `storeOp: 'store'`
+ * (and `depthClearValue: 1` for depth attachments). For depth/stencil attachments,
+ * defaults are derived from the view's format and aspect. A raw {@link GPUTextureView}
+ * with no explicit operations is assumed to be depth-only; provide explicit
+ * operations for raw stencil or depth-stencil views.
+ */
+export interface TgpuRenderPassDescriptor {
+    label?: string | undefined;
+    colorAttachments?: ColorAttachment | readonly (ColorAttachment | null)[] | undefined;
+    depthStencilAttachment?: DepthStencilAttachment | undefined;
+    occlusionQuerySet?: TgpuQuerySet<'occlusion'> | GPUQuerySet | undefined;
+    timestampWrites?: TgpuPassTimestampWrites | undefined;
+    maxDrawCount?: number | undefined;
+}
+export interface RenderPassInternals<TRaw extends GPURenderPassEncoder | GPURenderBundleEncoder = GPURenderPassEncoder | GPURenderBundleEncoder> {
+    readonly rawPass: TRaw;
+    readonly state: RenderDrawState;
+    /** Undefined for bundle encoders and for raw pass encoders the caller owns */
+    readonly owner: TgpuCommandEncoder | undefined;
+    appliedVersion: number | undefined;
+}
+/**
+ * The draw-recording surface shared by render passes and render bundle encoders,
+ * mirroring {@link GPURenderCommandsMixin}.
+ *
+ * Draw either by binding TypeGPU pipelines to it (`pipeline.with(pass).draw(...)`),
+ * or proxy-style via `pass.setPipeline(pipeline)` followed by `pass.draw(...)`.
+ * Pipeline resolution is lazy: shaders compile on the first draw.
+ */
+export interface TgpuRenderCommands {
+    readonly [$internal]: RenderPassInternals;
+    readonly resourceType: 'render-pass' | 'render-bundle-encoder';
+    /** Sets the current {@link TgpuRenderPipeline} for subsequent draw calls */
+    setPipeline(pipeline: TgpuRenderPipeline): void;
+    /** Associates a bind group with the layout it was created from */
+    setBindGroup(bindGroup: TgpuBindGroup): void;
+    /** Associates a bind group with the given layout */
+    setBindGroup<Entries extends Record<string, TgpuLayoutEntry | null>>(bindGroupLayout: TgpuBindGroupLayout<Entries>, bindGroup: TgpuBindGroup<Entries> | GPUBindGroup): void;
+    /** Binds a vertex buffer to the given vertex layout */
+    setVertexBuffer<TData extends WgslArray | Disarray>(vertexLayout: TgpuVertexLayout<TData>, buffer: (TgpuBuffer<TData> & VertexFlag) | GPUBuffer, offset?: number, size?: number): void;
+    /** Sets the current index buffer */
+    setIndexBuffer<TData extends WgslArray | Disarray>(buffer: (TgpuBuffer<TData> & IndexFlag) | GPUBuffer, indexFormat: GPUIndexFormat, offset?: number, size?: number): void;
+    draw(vertexCount: number, instanceCount?: number, firstVertex?: number, firstInstance?: number): void;
+    drawIndexed(indexCount: number, instanceCount?: number, firstIndex?: number, baseVertex?: number, firstInstance?: number): 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;
+}
+/**
+ * Records draw commands into a render bundle, mirroring {@link GPURenderBundleEncoder}.
+ *
+ * Call `finish()` to obtain a {@link GPURenderBundle}, replayable in a render
+ * pass via {@link TgpuRenderPass.executeBundles}.
+ */
+export interface TgpuRenderBundleEncoder extends TgpuRenderCommands {
+    readonly [$internal]: RenderPassInternals<GPURenderBundleEncoder>;
+    readonly resourceType: 'render-bundle-encoder';
+    /** Completes the recording and returns the resulting {@link GPURenderBundle} */
+    finish(descriptor?: GPURenderBundleDescriptor): GPURenderBundle;
+}
+/**
+ * A render pass recording into a {@link TgpuCommandEncoder}. On top of the
+ * draw commands, it exposes the state that WebGPU scopes to a render pass.
+ *
+ * Call `end()` when done recording.
+ */
+export interface TgpuRenderPass extends TgpuRenderCommands {
+    readonly [$internal]: RenderPassInternals<GPURenderPassEncoder>;
+    readonly resourceType: 'render-pass';
+    setViewport(x: number, y: number, width: number, height: number, minDepth: number, maxDepth: number): void;
+    setScissorRect(x: number, y: number, width: number, height: number): void;
+    setBlendConstant(color: readonly [number, number, number, number] | GPUColor): void;
+    setStencilReference(reference: GPUStencilValue): void;
+    beginOcclusionQuery(queryIndex: GPUSize32): void;
+    endOcclusionQuery(): void;
+    /**
+     * Executes previously recorded {@link GPURenderBundle}s as part of this pass.
+     * As per the WebGPU spec, this resets the raw pass's pipeline, bind group
+     * and vertex/index buffer state. The state tracked by this typed pass is
+     * re-applied on the next draw.
+     */
+    executeBundles(bundles: Iterable<GPURenderBundle>): void;
+    /** Completes the recording of this render pass */
+    end(): void;
+}
+export declare function INTERNAL_beginRenderPass(encoder: TgpuCommandEncoder, descriptor: TgpuRenderPassDescriptor): TgpuRenderPass;
+export declare function INTERNAL_createRenderBundleEncoder(root: ExperimentalTgpuRoot, descriptor: GPURenderBundleEncoderDescriptor): TgpuRenderBundleEncoder;
+export declare function INTERNAL_adoptRenderCommands(root: ExperimentalTgpuRoot, rawPass: GPURenderPassEncoder | GPURenderBundleEncoder): TgpuRenderCommands;

package/core/commandEncoder/renderPass.js

@@ -0,0 +1,196 @@
+import { $internal } from "../../shared/symbols.js";
+import { isGPUBuffer } from "../../types.js";
+import { DRAW_INDEXED_INDIRECT_SIZE, DRAW_INDIRECT_SIZE, resolveIndirectOffset, } from "../pipeline/pipelineUtils.js";
+import { isTexture, isTextureView } from "../texture/texture.js";
+import { emitRenderDraw, recordBindGroup, RenderDrawState, stampRenderPipeline, } from "../pipeline/drawState.js";
+import { isQuerySet } from "../querySet/querySet.js";
+import { unwrapAttachmentView, unwrapTimestampWrites, } from "./attachments.js";
+// --------------
+// Implementation
+// --------------
+function attachmentAspects(view) {
+    let format;
+    let aspect = 'all';
+    if (isTexture(view)) {
+        format = view.props.format;
+    }
+    else if (isTextureView(view)) {
+        format = view[$internal].format;
+        aspect = view[$internal].aspect ?? 'all';
+    }
+    if (format === undefined) {
+        return undefined;
+    }
+    return {
+        hasDepth: format.includes('depth') && aspect !== 'stencil-only',
+        hasStencil: format.includes('stencil') && aspect !== 'depth-only',
+    };
+}
+function withDepthStencilDefaults(attachment, view) {
+    const rawAttachment = { ...attachment, view };
+    const aspects = attachmentAspects(attachment.view);
+    if (aspects === undefined) {
+        const hasExplicitOps = attachment.depthLoadOp !== undefined ||
+            attachment.depthStoreOp !== undefined ||
+            attachment.stencilLoadOp !== undefined ||
+            attachment.stencilStoreOp !== undefined;
+        if (hasExplicitOps) {
+            return rawAttachment;
+        }
+    }
+    const { hasDepth, hasStencil } = aspects ?? { hasDepth: true, hasStencil: false };
+    if (hasDepth && !attachment.depthReadOnly) {
+        rawAttachment.depthLoadOp ??= 'clear';
+        rawAttachment.depthStoreOp ??= 'store';
+        rawAttachment.depthClearValue ??= 1;
+    }
+    if (hasStencil && !attachment.stencilReadOnly) {
+        rawAttachment.stencilLoadOp ??= 'clear';
+        rawAttachment.stencilStoreOp ??= 'store';
+    }
+    return rawAttachment;
+}
+export function INTERNAL_beginRenderPass(encoder, descriptor) {
+    const { rawEncoder, root } = encoder[$internal];
+    const colorAttachments = descriptor.colorAttachments === undefined
+        ? []
+        : Array.isArray(descriptor.colorAttachments)
+            ? descriptor.colorAttachments
+            : [descriptor.colorAttachments];
+    const rawDescriptor = {
+        colorAttachments: colorAttachments.map((attachment) => {
+            if (attachment === null) {
+                return null;
+            }
+            const rawAttachment = {
+                ...attachment,
+                loadOp: attachment.loadOp ?? 'clear',
+                storeOp: attachment.storeOp ?? 'store',
+                view: unwrapAttachmentView(root, attachment.view),
+            };
+            if (attachment.resolveTarget !== undefined) {
+                rawAttachment.resolveTarget = unwrapAttachmentView(root, attachment.resolveTarget);
+            }
+            return rawAttachment;
+        }),
+    };
+    if (descriptor.label !== undefined) {
+        rawDescriptor.label = descriptor.label;
+    }
+    if (descriptor.depthStencilAttachment !== undefined) {
+        rawDescriptor.depthStencilAttachment = withDepthStencilDefaults(descriptor.depthStencilAttachment, unwrapAttachmentView(root, descriptor.depthStencilAttachment.view));
+    }
+    if (descriptor.occlusionQuerySet !== undefined) {
+        rawDescriptor.occlusionQuerySet = isQuerySet(descriptor.occlusionQuerySet)
+            ? root.unwrap(descriptor.occlusionQuerySet)
+            : descriptor.occlusionQuerySet;
+    }
+    if (descriptor.timestampWrites !== undefined) {
+        rawDescriptor.timestampWrites = unwrapTimestampWrites(root, descriptor.timestampWrites);
+    }
+    if (descriptor.maxDrawCount !== undefined) {
+        rawDescriptor.maxDrawCount = descriptor.maxDrawCount;
+    }
+    return new TgpuRenderPassImpl(root, rawEncoder.beginRenderPass(rawDescriptor), encoder);
+}
+export function INTERNAL_createRenderBundleEncoder(root, descriptor) {
+    return new TgpuRenderBundleEncoderImpl(root, root.device.createRenderBundleEncoder(descriptor), undefined);
+}
+export function INTERNAL_adoptRenderCommands(root, rawPass) {
+    const adopted = typeof rawPass.executeBundles === 'function'
+        ? new TgpuRenderPassImpl(root, rawPass, undefined)
+        : new TgpuRenderCommandsImpl(root, rawPass, undefined);
+    adopted[$internal].state.rawAccessed = true;
+    return adopted;
+}
+class TgpuRenderCommandsImpl {
+    [$internal];
+    resourceType = 'render-bundle-encoder';
+    #root;
+    constructor(root, rawPass, owner) {
+        this.#root = root;
+        this[$internal] = {
+            rawPass,
+            state: new RenderDrawState(),
+            owner,
+            appliedVersion: undefined,
+        };
+    }
+    #emit(usesIndexBuffer, emit) {
+        const internals = this[$internal];
+        const pipeline = internals.state.currentPipeline;
+        if (!pipeline) {
+            throw new Error('Cannot draw without a call to pass.setPipeline');
+        }
+        emitRenderDraw(this.#root, internals, pipeline, usesIndexBuffer, emit);
+    }
+    setPipeline(pipeline) {
+        stampRenderPipeline(this[$internal].state, pipeline);
+    }
+    setBindGroup(first, bindGroup) {
+        recordBindGroup(this[$internal].state, first, bindGroup);
+    }
+    setVertexBuffer(vertexLayout, buffer, offset, size) {
+        const { state } = this[$internal];
+        state.vertexBuffers.set(vertexLayout, { buffer, offset, size });
+        state.version++;
+    }
+    setIndexBuffer(buffer, indexFormat, offset, size) {
+        const { state } = this[$internal];
+        state.indexBuffer = { buffer, indexFormat, offsetBytes: offset, sizeBytes: size };
+        state.version++;
+    }
+    draw(vertexCount, instanceCount, firstVertex, firstInstance) {
+        this.#emit(false, (rawPass) => rawPass.draw(vertexCount, instanceCount, firstVertex, firstInstance));
+    }
+    drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance) {
+        this.#emit(true, (rawPass) => rawPass.drawIndexed(indexCount, instanceCount, firstIndex, baseVertex, firstInstance));
+    }
+    drawIndirect(indirectBuffer, indirectOffset) {
+        const rawBuffer = isGPUBuffer(indirectBuffer) ? indirectBuffer : indirectBuffer.buffer;
+        const offset = resolveIndirectOffset(indirectBuffer, indirectOffset, DRAW_INDIRECT_SIZE, 'drawIndirect');
+        this.#emit(false, (rawPass) => rawPass.drawIndirect(rawBuffer, offset));
+    }
+    drawIndexedIndirect(indirectBuffer, indirectOffset) {
+        const rawBuffer = isGPUBuffer(indirectBuffer) ? indirectBuffer : indirectBuffer.buffer;
+        const offset = resolveIndirectOffset(indirectBuffer, indirectOffset, DRAW_INDEXED_INDIRECT_SIZE, 'drawIndexedIndirect');
+        this.#emit(true, (rawPass) => rawPass.drawIndexedIndirect(rawBuffer, offset));
+    }
+}
+class TgpuRenderBundleEncoderImpl extends TgpuRenderCommandsImpl {
+    resourceType = 'render-bundle-encoder';
+    finish(descriptor) {
+        return this[$internal].rawPass.finish(descriptor);
+    }
+}
+class TgpuRenderPassImpl extends TgpuRenderCommandsImpl {
+    resourceType = 'render-pass';
+    setViewport(x, y, width, height, minDepth, maxDepth) {
+        this[$internal].rawPass.setViewport(x, y, width, height, minDepth, maxDepth);
+    }
+    setScissorRect(x, y, width, height) {
+        this[$internal].rawPass.setScissorRect(x, y, width, height);
+    }
+    setBlendConstant(color) {
+        this[$internal].rawPass.setBlendConstant(color);
+    }
+    setStencilReference(reference) {
+        const { state } = this[$internal];
+        state.stencilReference = reference;
+        state.version++;
+    }
+    beginOcclusionQuery(queryIndex) {
+        this[$internal].rawPass.beginOcclusionQuery(queryIndex);
+    }
+    endOcclusionQuery() {
+        this[$internal].rawPass.endOcclusionQuery();
+    }
+    executeBundles(bundles) {
+        const internals = this[$internal];
+        internals.rawPass.executeBundles(bundles);
+        internals.appliedVersion = undefined;
+    }
+    end() {
+        this[$internal].rawPass.end();
+    }
+}

package/core/constant/tgpuConstant.d.ts

@@ -1,30 +1,30 @@
-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;
-  };
+import { type AnyData } from '../../data/dataTypes.ts';
+import { type AnyWgslData, type BaseData, type WgslArray } from '../../data/wgslTypes.ts';
+import type { TgpuNamable } from '../../shared/meta.ts';
+import type { InferGPU } from '../../shared/repr.ts';
+import type { TgpuSoul } from '../../shared/soul.ts';
+import { $gpuValueOf, $internal, $soul } from '../../shared/symbols.ts';
+export 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;
+export interface TgpuConstSoul<TDataType extends BaseData = BaseData> extends TgpuSoul<'const'> {
+    readonly dataType: TDataType;
+    readonly value: DeepReadonly<InferGPU<TDataType>>;
+}
+export interface TgpuConst<TDataType extends BaseData = BaseData> extends TgpuNamable {
+    readonly resourceType: 'const';
+    readonly [$gpuValueOf]: DeepReadonly<InferGPU<TDataType>>;
+    readonly $: DeepReadonly<InferGPU<TDataType>>;
+    readonly [$soul]: TgpuConstSoul<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 };
+export declare function constant<TDataType extends AnyData>(dataType: TDataType, value: InferGPU<TDataType>): TgpuConst<TDataType>;
+export declare function constant<TElement extends AnyWgslData>(dataType: (elementCount: number) => WgslArray<TElement>, value: InferGPU<WgslArray<TElement>>): TgpuConst<WgslArray<TElement>>;