typegpu 0.11.9 → 0.12.1

package/core/buffer/bufferBinding.d.ts

@@ -0,0 +1,71 @@
+import type { AnyWgslData, BaseData } from '../../data/wgslTypes.ts';
+import { type StorageFlag } from '../../extension.ts';
+import { type TgpuNamable } from '../../shared/meta.ts';
+import type { Infer, InferGPU, InferInput, InferPatch, InferPartial } from '../../shared/repr.ts';
+import type { TgpuSoul } from '../../shared/soul.ts';
+import { $getNameForward, $gpuValueOf, $internal, $repr, $soul } from '../../shared/symbols.ts';
+import { type BufferWriteOptions, type TgpuBuffer, type UniformFlag } from './buffer.ts';
+export interface TgpuBufferBindingSoul<TBuffer extends TgpuBuffer<BaseData> = TgpuBuffer<BaseData>> extends TgpuSoul<'uniform' | 'mutable' | 'readonly'> {
+    readonly buffer: TBuffer;
+}
+interface TgpuBufferBindingBase<TData extends BaseData> extends TgpuNamable {
+    readonly [$internal]: true;
+    readonly [$soul]: TgpuBufferBindingSoul<TgpuBuffer<TData>>;
+    write(data: InferInput<TData>, options?: BufferWriteOptions): void;
+    /** @deprecated Use {@link patch} instead. */
+    writePartial(data: InferPartial<TData>): void;
+    patch(data: InferPatch<TData>): void;
+    read(): Promise<Infer<TData>>;
+    readonly [$gpuValueOf]: InferGPU<TData>;
+    /** Type-token, not available at runtime */
+    readonly [$repr]: Infer<TData>;
+}
+export interface TgpuMutable<out TData extends BaseData> extends TgpuBufferBindingBase<TData> {
+    readonly resourceType: 'mutable';
+    readonly buffer: TgpuBuffer<TData> & StorageFlag;
+    $: InferGPU<TData>;
+    /** Type-token, not available at runtime */
+    readonly [$repr]: Infer<TData>;
+}
+export interface TgpuReadonly<out TData extends BaseData> extends TgpuBufferBindingBase<TData> {
+    readonly resourceType: 'readonly';
+    readonly buffer: TgpuBuffer<TData> & StorageFlag;
+    readonly $: InferGPU<TData>;
+    /** Type-token, not available at runtime */
+    readonly [$repr]: Infer<TData>;
+}
+export interface TgpuUniform<out TData extends BaseData> extends TgpuBufferBindingBase<TData> {
+    readonly resourceType: 'uniform';
+    readonly buffer: TgpuBuffer<TData> & UniformFlag;
+    readonly $: InferGPU<TData>;
+}
+export type TgpuBufferBinding<TData extends BaseData> = TgpuMutable<TData> | TgpuReadonly<TData> | TgpuUniform<TData>;
+export declare function isBufferBinding<TData extends BaseData>(value: unknown): value is TgpuBufferBinding<TData>;
+export declare function isUniformBinding<TData extends BaseData>(value: unknown): value is TgpuUniform<TData>;
+export declare function isMutableBinding<TData extends BaseData>(value: unknown): value is TgpuMutable<TData>;
+export declare function isReadonlyBinding<TData extends BaseData>(value: unknown): value is TgpuReadonly<TData>;
+/** @deprecated Use 'isBufferBinding' instead. */
+export declare const isBufferShorthand: typeof isBufferBinding;
+type BoundBuffer<TType, TData extends BaseData> = TgpuBuffer<TData> & (TType extends 'mutable' | 'readonly' ? StorageFlag : UniformFlag);
+export declare class TgpuBufferBindingImpl<TType extends 'mutable' | 'readonly' | 'uniform', TData extends BaseData> {
+    /** Type-token, not available at runtime */
+    readonly [$repr]: Infer<TData>;
+    readonly [$soul]: TgpuBufferBindingSoul<BoundBuffer<TType, TData>>;
+    readonly [$getNameForward]: object;
+    readonly resourceType: TType;
+    [$internal]: true;
+    $: InferGPU<TData>;
+    readonly [$gpuValueOf]: InferGPU<TData>;
+    constructor(usage: TType, buffer: BoundBuffer<TType, TData>);
+    get buffer(): BoundBuffer<TType, TData>;
+    $name(label: string): this;
+    write(data: InferInput<TData>, options?: BufferWriteOptions): void;
+    /** @deprecated Use {@link patch} instead. */
+    writePartial(data: InferPartial<TData>): void;
+    patch(data: InferPatch<TData>): void;
+    read(): Promise<Infer<TData>>;
+}
+export declare function mutable<TData extends AnyWgslData>(buffer: TgpuBuffer<TData> & StorageFlag): TgpuMutable<TData>;
+export declare function readonly<TData extends AnyWgslData>(buffer: TgpuBuffer<TData> & StorageFlag): TgpuReadonly<TData>;
+export declare function uniform<TData extends AnyWgslData>(buffer: TgpuBuffer<TData> & UniformFlag): TgpuUniform<TData>;
+export {};

package/core/buffer/bufferBinding.js

@@ -0,0 +1,154 @@
+import { schemaCallWrapper } from "../../data/schemaCallWrapper.js";
+import { snip } from "../../data/snippet.js";
+import { IllegalBufferAccessError } from "../../errors.js";
+import { isInsideTgpuFn } from "../../execMode.js";
+import {} from "../../extension.js";
+import { getName, setName } from "../../shared/meta.js";
+import { $getNameForward, $gpuValueOf, $internal, $repr, $soul } from "../../shared/symbols.js";
+import { isUsableAsStorage, isUsableAsUniform } from "../../types.js";
+import { makeDereferenceable } from "../../tgsl/makeDereferenceable.js";
+import { makeResolvable } from "../../tgsl/makeResolvable.js";
+import {} from "./buffer.js";
+export function isBufferBinding(value) {
+    return value instanceof TgpuBufferBindingImpl;
+}
+export function isUniformBinding(value) {
+    return isBufferBinding(value) && value.resourceType === 'uniform';
+}
+export function isMutableBinding(value) {
+    return isBufferBinding(value) && value.resourceType === 'mutable';
+}
+export function isReadonlyBinding(value) {
+    return isBufferBinding(value) && value.resourceType === 'readonly';
+}
+// TODO(#2666) - remove this
+/** @deprecated Use 'isBufferBinding' instead. */
+export const isBufferShorthand = isBufferBinding;
+export class TgpuBufferBindingImpl {
+    [$soul];
+    [$getNameForward];
+    resourceType;
+    static {
+        TgpuBufferBindingImpl.prototype[$internal] = true;
+        makeDereferenceable(makeResolvable(TgpuBufferBindingImpl.prototype, {
+            asString() {
+                return `${this.resourceType}BufferBinding:${getName(this) ?? '<unnamed>'}`;
+            },
+            resolve(ctx) {
+                const dataType = this.buffer.dataType;
+                const id = ctx.makeUniqueIdentifier(getName(this), 'global');
+                const { group, binding } = ctx.allocateFixedEntry(this.resourceType === 'uniform'
+                    ? { uniform: dataType }
+                    : { storage: dataType, access: this.resourceType }, this.buffer);
+                return ctx.gen.declareGlobalVar({
+                    group,
+                    binding,
+                    scope: this.resourceType,
+                    id,
+                    dataType,
+                    init: undefined,
+                });
+            },
+        }), {
+            codegenMode: {
+                getBaseSnippet(trackingProxy) {
+                    return snip(trackingProxy, this.buffer.dataType, 
+                    /* origin */ this.resourceType, 
+                    /* possibleSideEffects */ false);
+                },
+            },
+            simulateMode: {
+                get(state) {
+                    if (!state.buffers.has(this.buffer)) {
+                        // Not initialized yet
+                        state.buffers.set(this.buffer, schemaCallWrapper(this.buffer.dataType, this.buffer.initial));
+                    }
+                    return state.buffers.get(this.buffer);
+                },
+                set(state, value) {
+                    state.buffers.set(this.buffer, value);
+                },
+            },
+            normalMode: {
+                get() {
+                    throw new IllegalBufferAccessError(isInsideTgpuFn()
+                        ? `Cannot access ${String(this.buffer)}. TypeGPU functions that depends on GPU resources need to be part of a compute dispatch, draw call or simulation`
+                        : '.$ is inaccessible during normal JS execution. Try `.read()`');
+                },
+                set() {
+                    throw new IllegalBufferAccessError(isInsideTgpuFn()
+                        ? `Cannot access ${String(this.buffer)}. TypeGPU functions that depends on GPU resources need to be part of a compute dispatch, draw call or simulation`
+                        : '.$ is inaccessible during normal JS execution. Try `.write()`');
+                },
+            },
+        });
+    }
+    constructor(usage, buffer) {
+        this.resourceType = usage;
+        this[$getNameForward] = buffer;
+        this[$soul] = {
+            type: usage,
+            buffer,
+            label: undefined,
+        };
+    }
+    get buffer() {
+        return this[$soul].buffer;
+    }
+    $name(label) {
+        setName(this, label);
+        return this;
+    }
+    write(data, options) {
+        this.buffer.write(data, options);
+    }
+    /** @deprecated Use {@link patch} instead. */
+    writePartial(data) {
+        this.buffer.writePartial(data);
+    }
+    patch(data) {
+        this.buffer.patch(data);
+    }
+    read() {
+        return this.buffer.read();
+    }
+}
+// --------------
+// Constructors
+// --------------
+const mutableUsageMap = new WeakMap();
+export function mutable(buffer) {
+    if (!isUsableAsStorage(buffer)) {
+        throw new Error(`Cannot call as('mutable') on ${buffer}, as it is not allowed to be used as storage. To allow it, call .$usage('storage') when creating the buffer.`);
+    }
+    let usage = mutableUsageMap.get(buffer);
+    if (!usage) {
+        usage = new TgpuBufferBindingImpl('mutable', buffer);
+        mutableUsageMap.set(buffer, usage);
+    }
+    return usage;
+}
+const readonlyUsageMap = new WeakMap();
+export function readonly(buffer) {
+    if (!isUsableAsStorage(buffer)) {
+        throw new Error(`Cannot call as('readonly') on ${buffer}, as it is not allowed to be used as storage. To allow it, call .$usage('storage') when creating the buffer.`);
+    }
+    let usage = readonlyUsageMap.get(buffer);
+    if (!usage) {
+        usage = new TgpuBufferBindingImpl('readonly', buffer);
+        readonlyUsageMap.set(buffer, usage);
+    }
+    return usage;
+}
+const uniformUsageMap = new WeakMap();
+export function uniform(buffer) {
+    if (!isUsableAsUniform(buffer)) {
+        throw new Error(`Cannot call as('uniform') on ${buffer}, as it is not allowed to be used as a uniform. To allow it, call .$usage('uniform') when creating the buffer.`);
+    }
+    let usage = uniformUsageMap.get(buffer);
+    if (!usage) {
+        usage = new TgpuBufferBindingImpl('uniform', buffer);
+        uniformUsageMap.set(buffer, usage);
+    }
+    return usage;
+}

package/core/buffer/bufferUsage.d.ts

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

package/core/buffer/bufferUsage.js

@@ -1,171 +1 @@
-import { $getNameForward, $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symbols.js";
-import { getName, setName } from "../../shared/meta.js";
-import { snip } from "../../data/snippet.js";
-import { IllegalBufferAccessError } from "../../errors.js";
-import { getExecMode, inCodegenMode, isInsideTgpuFn } from "../../execMode.js";
-import { schemaCallWrapper } from "../../data/schemaCallWrapper.js";
-import { assertExhaustive } from "../../shared/utilityTypes.js";
-import { valueProxyHandler } from "../valueProxyUtils.js";
-import { isUsableAsStorage } from "../../extension.js";
-
-//#region src/core/buffer/bufferUsage.ts
-function isUsableAsUniform(buffer) {
-	return !!buffer.usableAsUniform;
-}
-var TgpuFixedBufferImpl = class {
-	resourceType = "buffer-usage";
-	usage;
-	buffer;
-	[$internal];
-	[$getNameForward];
-	constructor(usage, buffer) {
-		this.usage = usage;
-		this.buffer = buffer;
-		this[$internal] = { dataType: buffer.dataType };
-		this[$getNameForward] = buffer;
-	}
-	$name(label) {
-		setName(this, label);
-		return this;
-	}
-	[$resolve](ctx) {
-		const dataType = this.buffer.dataType;
-		const id = ctx.makeUniqueIdentifier(getName(this), "global");
-		const { group, binding } = ctx.allocateFixedEntry(this.usage === "uniform" ? { uniform: dataType } : {
-			storage: dataType,
-			access: this.usage
-		}, this.buffer);
-		return ctx.gen.declareGlobalVar({
-			group,
-			binding,
-			scope: this.usage,
-			id,
-			dataType,
-			init: void 0
-		});
-	}
-	toString() {
-		return `${this.usage}:${getName(this) ?? "<unnamed>"}`;
-	}
-	get [$gpuValueOf]() {
-		const dataType = this.buffer.dataType;
-		const usage = this.usage;
-		return new Proxy({
-			[$internal]: true,
-			get [$ownSnippet]() {
-				return snip(this, dataType, usage);
-			},
-			[$resolve]: (ctx) => ctx.resolve(this),
-			toString: () => `${this.usage}:${getName(this) ?? "<unnamed>"}.$`
-		}, valueProxyHandler);
-	}
-	get $() {
-		const mode = getExecMode();
-		const insideTgpuFn = isInsideTgpuFn();
-		if (mode.type === "normal") throw new IllegalBufferAccessError(insideTgpuFn ? `Cannot access ${String(this.buffer)}. TypeGPU functions that depends on GPU resources need to be part of a compute dispatch, draw call or simulation` : ".$ is inaccessible during normal JS execution. Try `.read()`");
-		if (mode.type === "codegen") return this[$gpuValueOf];
-		if (mode.type === "simulate") {
-			if (!mode.buffers.has(this.buffer)) mode.buffers.set(this.buffer, schemaCallWrapper(this.buffer.dataType, this.buffer.initial));
-			return mode.buffers.get(this.buffer);
-		}
-		return assertExhaustive(mode, "bufferUsage.ts#TgpuFixedBufferImpl/$");
-	}
-	get value() {
-		return this.$;
-	}
-	set $(value) {
-		const mode = getExecMode();
-		const insideTgpuFn = isInsideTgpuFn();
-		if (mode.type === "normal") throw new IllegalBufferAccessError(insideTgpuFn ? `Cannot access ${String(this.buffer)}. TypeGPU functions that depends on GPU resources need to be part of a compute dispatch, draw call or simulation` : ".$ is inaccessible during normal JS execution. Try `.write()`");
-		if (mode.type === "codegen") throw new Error("Unreachable bufferUsage.ts#TgpuFixedBufferImpl/$");
-		if (mode.type === "simulate") {
-			mode.buffers.set(this.buffer, value);
-			return;
-		}
-		assertExhaustive(mode, "bufferUsage.ts#TgpuFixedBufferImpl/$");
-	}
-	set value(value) {
-		this.$ = value;
-	}
-};
-var TgpuLaidOutBufferImpl = class {
-	[$internal];
-	resourceType = "buffer-usage";
-	usage;
-	dataType;
-	#membership;
-	constructor(usage, dataType, membership) {
-		this[$internal] = { dataType };
-		this.usage = usage;
-		this.dataType = dataType;
-		this.#membership = membership;
-		setName(this, membership.key);
-	}
-	[$resolve](ctx) {
-		const id = ctx.makeUniqueIdentifier(getName(this), "global");
-		const group = ctx.allocateLayoutEntry(this.#membership.layout);
-		return ctx.gen.declareGlobalVar({
-			group,
-			binding: this.#membership.idx,
-			scope: this.usage,
-			id,
-			dataType: this.dataType,
-			init: void 0
-		});
-	}
-	toString() {
-		return `${this.usage}:${getName(this) ?? "<unnamed>"}`;
-	}
-	get [$gpuValueOf]() {
-		const schema = this.dataType;
-		const usage = this.usage;
-		return new Proxy({
-			[$internal]: true,
-			get [$ownSnippet]() {
-				return snip(this, schema, usage);
-			},
-			[$resolve]: (ctx) => ctx.resolve(this),
-			toString: () => `${this.usage}:${getName(this) ?? "<unnamed>"}.$`
-		}, valueProxyHandler);
-	}
-	get $() {
-		if (inCodegenMode()) return this[$gpuValueOf];
-		throw new Error("Direct access to buffer values is possible only as part of a compute dispatch or draw call. Try .read() or .write() instead");
-	}
-	get value() {
-		return this.$;
-	}
-};
-const mutableUsageMap = /* @__PURE__ */ new WeakMap();
-function mutable(buffer) {
-	if (!isUsableAsStorage(buffer)) throw new Error(`Cannot call as('mutable') on ${buffer}, as it is not allowed to be used as storage. To allow it, call .$usage('storage') when creating the buffer.`);
-	let usage = mutableUsageMap.get(buffer);
-	if (!usage) {
-		usage = new TgpuFixedBufferImpl("mutable", buffer);
-		mutableUsageMap.set(buffer, usage);
-	}
-	return usage;
-}
-const readonlyUsageMap = /* @__PURE__ */ new WeakMap();
-function readonly(buffer) {
-	if (!isUsableAsStorage(buffer)) throw new Error(`Cannot call as('readonly') on ${buffer}, as it is not allowed to be used as storage. To allow it, call .$usage('storage') when creating the buffer.`);
-	let usage = readonlyUsageMap.get(buffer);
-	if (!usage) {
-		usage = new TgpuFixedBufferImpl("readonly", buffer);
-		readonlyUsageMap.set(buffer, usage);
-	}
-	return usage;
-}
-const uniformUsageMap = /* @__PURE__ */ new WeakMap();
-function uniform(buffer) {
-	if (!isUsableAsUniform(buffer)) throw new Error(`Cannot call as('uniform') on ${buffer}, as it is not allowed to be used as a uniform. To allow it, call .$usage('uniform') when creating the buffer.`);
-	let usage = uniformUsageMap.get(buffer);
-	if (!usage) {
-		usage = new TgpuFixedBufferImpl("uniform", buffer);
-		uniformUsageMap.set(buffer, usage);
-	}
-	return usage;
-}
-
-//#endregion
-export { TgpuLaidOutBufferImpl, isUsableAsUniform, mutable, readonly, uniform };
+import {} from "../../data/wgslTypes.js";

package/core/buffer/laidOutBuffer.d.ts

@@ -0,0 +1,25 @@
+import { type BaseData } from '../../data/wgslTypes.ts';
+import type { Infer, InferGPU } from '../../shared/repr.ts';
+import { $gpuValueOf, $internal, $repr, $resolve } from '../../shared/symbols.ts';
+import type { LayoutMembership } from '../../tgpuBindGroupLayout.ts';
+import type { BindableBufferUsage, SelfResolvable } from '../../types.ts';
+/**
+ * A class representing a buffer accessed via a BindGroupLayout.
+ * Compared to a regular buffer, it's missing read/write methods,
+ * but it holds a membership.
+ */
+export declare class TgpuLaidOutBufferImpl<TData extends BaseData, TUsage extends BindableBufferUsage> implements SelfResolvable {
+    #private;
+    /** Type-token, not available at runtime */
+    readonly [$repr]: Infer<TData>;
+    readonly [$internal]: {
+        readonly dataType: TData;
+    };
+    readonly usage: TUsage;
+    readonly dataType: TData;
+    [$resolve]: SelfResolvable[typeof $resolve];
+    resourceType: 'laid-out-buffer';
+    $: InferGPU<TData>;
+    readonly [$gpuValueOf]: InferGPU<TData>;
+    constructor(usage: TUsage, dataType: TData, membership: LayoutMembership);
+}

package/core/buffer/laidOutBuffer.js

@@ -0,0 +1,55 @@
+import { snip } from "../../data/snippet.js";
+import {} from "../../data/wgslTypes.js";
+import { makeDereferenceable } from "../../tgsl/makeDereferenceable.js";
+import { makeResolvable } from "../../tgsl/makeResolvable.js";
+import { getName, setName } from "../../shared/meta.js";
+import { $gpuValueOf, $internal, $repr, $resolve } from "../../shared/symbols.js";
+/**
+ * A class representing a buffer accessed via a BindGroupLayout.
+ * Compared to a regular buffer, it's missing read/write methods,
+ * but it holds a membership.
+ */
+export class TgpuLaidOutBufferImpl {
+    [$internal];
+    usage;
+    dataType;
+    #membership;
+    static {
+        TgpuLaidOutBufferImpl.prototype.resourceType = 'laid-out-buffer';
+        makeDereferenceable(makeResolvable(TgpuLaidOutBufferImpl.prototype, {
+            asString() {
+                return `${this.usage}:${getName(this) ?? '<unnamed>'}`;
+            },
+            resolve(ctx) {
+                const id = ctx.makeUniqueIdentifier(getName(this), 'global');
+                const group = ctx.allocateLayoutEntry(this.#membership.layout);
+                return ctx.gen.declareGlobalVar({
+                    group,
+                    binding: this.#membership.idx,
+                    scope: this.usage,
+                    id,
+                    dataType: this.dataType,
+                    init: undefined,
+                });
+            },
+        }), {
+            codegenMode: {
+                getBaseSnippet(trackingProxy) {
+                    return snip(trackingProxy, this.dataType, this.usage, /* possibleSideEffects */ false);
+                },
+            },
+            normalMode: {
+                get() {
+                    throw new Error('Direct access to buffer values is possible only as part of a compute dispatch or draw call. Try .read() or .write() instead');
+                },
+            },
+        });
+    }
+    constructor(usage, dataType, membership) {
+        this[$internal] = { dataType };
+        this.usage = usage;
+        this.dataType = dataType;
+        this.#membership = membership;
+        setName(this, membership.key);
+    }
+}

package/core/commandEncoder/attachments.d.ts

@@ -0,0 +1,125 @@
+import type { WgslTexture, WgslTextureDepth2d, WgslTextureDepthMultisampled2d } from '../../data/texture.ts';
+import { $internal } from '../../shared/symbols.ts';
+import { type TgpuQuerySet } from '../querySet/querySet.ts';
+import type { ExperimentalTgpuRoot } from '../root/rootTypes.ts';
+import { type TextureInternals, type TgpuTextureRenderView, type TgpuTextureView } from '../texture/texture.ts';
+import type { RenderFlag } from '../texture/usageExtension.ts';
+interface ColorTextureConstraint {
+    readonly [$internal]: TextureInternals;
+    readonly resourceType: 'texture';
+    readonly props: {
+        format: GPUTextureFormat;
+    };
+}
+export 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 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?: readonly [number, number, number, number] | 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;
+}
+export type DepthStencilFormat = 'stencil8' | 'depth16unorm' | 'depth24plus' | 'depth24plus-stencil8' | 'depth32float' | 'depth32float-stencil8';
+interface DepthStencilTextureConstraint {
+    readonly [$internal]: TextureInternals;
+    readonly resourceType: 'texture';
+    readonly props: {
+        format: DepthStencilFormat;
+    };
+}
+export interface DepthStencilAttachment {
+    /**
+     * 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 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;
+}
+export type AnyAttachmentView = ColorAttachment['view'] | NonNullable<ColorAttachment['resolveTarget']> | DepthStencilAttachment['view'];
+export declare function unwrapAttachmentView(root: ExperimentalTgpuRoot, view: AnyAttachmentView): GPUTextureView;
+export interface TgpuPassTimestampWrites {
+    querySet: TgpuQuerySet<'timestamp'> | GPUQuerySet;
+    beginningOfPassWriteIndex?: number | undefined;
+    endOfPassWriteIndex?: number | undefined;
+}
+export declare function unwrapTimestampWrites(root: ExperimentalTgpuRoot, timestampWrites: TgpuPassTimestampWrites): GPURenderPassTimestampWrites;
+export {};