typegpu 0.12.5 → 0.12.7

package/core/pipeline/renderPipeline.d.ts

@@ -3,8 +3,9 @@ import type { IndexFlag, IndirectFlag, TgpuBuffer, VertexFlag } from '../buffer/
 import type { TgpuQuerySet } from '../querySet/querySet.ts';
 import { type Disarray, type UndecorateRecord } from '../../data/dataTypes.ts';
 import { type ResolvedSnippet } from '../../data/snippet.ts';
-import { type AnyVecInstance, type BaseData, type U16, type U32, type v4f, Void, type WgslArray, type WgslStruct } from '../../data/wgslTypes.ts';
+import { type AnyVecInstance, type AnyWgslData, type BaseData, type U16, type U32, type v4f, Void, type WgslArray } from '../../data/wgslTypes.ts';
 import type { TgpuNamable } from '../../shared/meta.ts';
+import type { InferInput } from '../../shared/repr.ts';
 import type { TgpuDeviceOwningSoul } from '../../shared/soul.ts';
 import { $getNameForward, $internal, $resolve, $soul } from '../../shared/symbols.ts';
 import type { AnyVertexAttribs } from '../../shared/vertexFormat.ts';
@@ -17,8 +18,10 @@ import type { TgpuVertexFn } from '../function/tgpuVertexFn.ts';
 import type { ExperimentalTgpuRoot } from '../root/rootTypes.ts';
 import type { TgpuSlot } from '../slot/slotTypes.ts';
 import { type TgpuVertexLayout } from '../vertexLayout/vertexLayout.ts';
+import { type ConnectedTarget } from './connectTargetsToShader.ts';
 import { type TgpuCommandEncoder } from '../commandEncoder/commandEncoder.ts';
 import type { ColorAttachment, DepthStencilAttachment } from '../commandEncoder/attachments.ts';
+import { type ImmediateSnapshot, type TgpuImmediateVar } from '../immediate/immediateVar.ts';
 import { type TgpuRenderCommands } from '../commandEncoder/renderPass.ts';
 import { type Timeable, type TimestampWritesPriors } from './timeable.ts';
 import { type PrimitiveOffsetInfo } from '../../data/offsetUtils.ts';
@@ -32,8 +35,10 @@ export interface RenderPipelineInternals {
 export interface TgpuRenderPipelineSoul extends TgpuDeviceOwningSoul<'render-pipeline', GPURenderPipeline> {
     usedBindGroupLayouts?: TgpuBindGroupLayout[] | undefined;
     usedVertexLayouts?: TgpuVertexLayout[] | undefined;
-    fragmentOut?: BaseData | undefined;
+    connectedTargets?: (ConnectedTarget | null)[] | undefined;
     bindGroups?: [TgpuBindGroupLayout, TgpuBindGroup | GPUBindGroup][] | undefined;
+    usedImmediate?: TgpuImmediateVar | undefined;
+    immediates?: [TgpuImmediateVar, ImmediateSnapshot][] | undefined;
     vertexBuffers?: [TgpuVertexLayout, (TgpuBuffer<BaseData> & VertexFlag) | GPUBuffer][] | undefined;
     indexBuffer?: {
         buffer: (TgpuBuffer<BaseData> & IndexFlag) | GPUBuffer;
@@ -76,6 +81,16 @@ export interface TgpuRenderPipeline<in Targets = never> extends TgpuNamable, Sel
     with<Entries extends Record<string, TgpuLayoutEntry | null>>(bindGroupLayout: TgpuBindGroupLayout<Entries>, bindGroup: TgpuBindGroup<Entries>): this;
     with(bindGroupLayout: TgpuBindGroupLayout, bindGroup: GPUBindGroup): this;
     with(bindGroup: TgpuBindGroup): this;
+    /**
+     * Provides a value for the given immediate variable, applied on draw like
+     * the rest of the pipeline-held state and overridden by `pass.setImmediates`.
+     * The value is captured (copied) at call time; mutating it afterwards has
+     * no effect.
+     *
+     * Passing an `ArrayBuffer` or typed array skips serialization entirely; the bytes
+     * are copied verbatim and the caller guarantees they match the schema's layout.
+     */
+    with<T extends AnyWgslData>(immediate: TgpuImmediateVar<T>, value: InferInput<T> | ArrayBuffer | ArrayBufferView): this;
     /**
      * Directs subsequent draw calls into the given render pass or render bundle
      * encoder, letting multiple pipelines share one pass (and one submission).
@@ -199,6 +214,7 @@ type TgpuRenderPipelinePriors = {
     readonly pass?: TgpuRenderCommands | undefined;
     /** An encoder the pipeline records its own passes into, but does not submit */
     readonly encoder?: TgpuCommandEncoder | undefined;
+    readonly immediatesMap?: Map<TgpuImmediateVar, ImmediateSnapshot> | undefined;
 } & TimestampWritesPriors;
 type Memo = {
     pipeline: GPURenderPipeline;
@@ -206,7 +222,8 @@ type Memo = {
     catchall: [number, TgpuBindGroup] | undefined;
     logResources: LogResources | undefined;
     usedVertexLayouts: TgpuVertexLayout[];
-    fragmentOut: BaseData | undefined;
+    connectedTargets: (ConnectedTarget | null)[] | undefined;
+    usedImmediate: TgpuImmediateVar | undefined;
 };
 declare class TgpuRenderPipelineImpl implements TgpuRenderPipeline {
     #private;
@@ -223,6 +240,7 @@ declare class TgpuRenderPipelineImpl implements TgpuRenderPipeline {
     with(bindGroupLayout: TgpuBindGroupLayout, bindGroup: GPUBindGroup): this;
     with(bindGroup: TgpuBindGroup): this;
     with<TData extends WgslArray | Disarray>(vertexLayout: TgpuVertexLayout<TData>, buffer: GPUBuffer): this;
+    with<T extends AnyWgslData>(immediate: TgpuImmediateVar<T>, value: InferInput<T> | ArrayBuffer | ArrayBufferView): this;
     with(pass: TgpuRenderCommands): this;
     with(encoder: TgpuCommandEncoder): this;
     with(encoder: GPUCommandEncoder): this;
@@ -263,8 +281,8 @@ declare class RenderPipelineCore implements SelfResolvable {
     resolveAndCreateShaderModule(): {
         resolutionResult: import("../../resolutionCtx.ts").ResolutionResult;
         descriptor: GPURenderPipelineDescriptor;
+        connectedTargets: (ConnectedTarget | null)[];
         connectedAttribs: import("../vertexLayout/connectAttributesToShader.ts").ConnectAttributesToShaderResult;
-        fragmentOut: WgslStruct<import("../function/ioSchema.ts").WithLocations<Record<string, BaseData>>>;
     };
 }
 /**

package/core/pipeline/renderPipeline.js

@@ -18,6 +18,7 @@ import { isVertexLayout } from "../vertexLayout/vertexLayout.js";
 import { connectAttachmentToShader } from "./connectAttachmentToShader.js";
 import { connectTargetsToShader } from "./connectTargetsToShader.js";
 import { INTERNAL_adoptCommandEncoder, INTERNAL_createCommandEncoder, } from "../commandEncoder/commandEncoder.js";
+import { createImmediateSnapshot, isImmediateVar, validateImmediateUsage, } from "../immediate/immediateVar.js";
 import { INTERNAL_adoptRenderCommands, } from "../commandEncoder/renderPass.js";
 import { emitRenderDraw, finalizeOwnEncoder, requireIndexBuffer } from "./drawState.js";
 import { isGPUCommandEncoder, isGPURenderBundleEncoder, isGPURenderPassEncoder, isTgpuCommandEncoder, isTgpuRenderCommands, } from "./typeGuards.js";
@@ -41,10 +42,12 @@ export function INTERNAL_restoreRenderPipeline(soul, ctx) {
         catchall: undefined,
         logResources: undefined,
         usedVertexLayouts: soul.usedVertexLayouts ?? [],
-        fragmentOut: soul.fragmentOut,
+        connectedTargets: soul.connectedTargets,
+        usedImmediate: soul.usedImmediate,
     });
     const pipeline = new TgpuRenderPipelineImpl(core, {
         bindGroupLayoutMap: new Map(soul.bindGroups),
+        immediatesMap: new Map(soul.immediates),
         vertexLayoutMap: new Map(soul.vertexBuffers),
         indexBuffer: soul.indexBuffer,
         stencilReference: soul.stencilReference,
@@ -74,8 +77,10 @@ class TgpuRenderPipelineImpl {
                     soul.raw = memo.pipeline;
                     soul.usedBindGroupLayouts = memo.usedBindGroupLayouts;
                     soul.usedVertexLayouts = memo.usedVertexLayouts;
-                    soul.fragmentOut = memo.fragmentOut;
+                    soul.connectedTargets = memo.connectedTargets;
                     soul.bindGroups = collectBindGroupPairs(memo.usedBindGroupLayouts, memo.catchall, priors.bindGroupLayoutMap);
+                    soul.usedImmediate = memo.usedImmediate;
+                    soul.immediates = [...(priors.immediatesMap ?? [])];
                     soul.vertexBuffers = collectVertexBufferPairs(memo.usedVertexLayouts, priors.vertexLayoutMap);
                     soul.indexBuffer = priors.indexBuffer;
                     soul.stencilReference = priors.stencilReference;
@@ -141,6 +146,11 @@ class TgpuRenderPipelineImpl {
                 ]),
             });
         }
+        if (isImmediateVar(first)) {
+            return this.#withPriors({
+                immediatesMap: new Map(internals.priors.immediatesMap).set(first, createImmediateSnapshot(first, resource)),
+            });
+        }
         throw new Error('Unsupported value passed into .with()');
     }
     pipe(transform) {
@@ -214,12 +224,10 @@ class TgpuRenderPipelineImpl {
     }
     #ownPassDescriptor() {
         const { core, priors } = this[$internal];
-        const { fragmentOut } = core.unwrap();
+        const { connectedTargets } = core.unwrap();
         return {
             label: getName(core) ?? '<unnamed>',
-            colorAttachments: fragmentOut
-                ? connectAttachmentToShader(fragmentOut, priors.colorAttachment ?? {})
-                : [],
+            colorAttachments: connectAttachmentToShader(connectedTargets, priors.colorAttachment ?? {}),
             depthStencilAttachment: priors.depthStencilAttachment,
             timestampWrites: priors.timestampWrites,
         };
@@ -335,7 +343,7 @@ class RenderPipelineCore {
         if (this.#initAsyncPromise === undefined) {
             // the pipeline did not start resolution & compilation
             const device = this.options.root.device;
-            const { resolutionResult, descriptor, connectedAttribs, fragmentOut } = this.resolveAndCreateShaderModule();
+            const { resolutionResult, descriptor, connectedTargets, connectedAttribs } = this.resolveAndCreateShaderModule();
             const { usedBindGroupLayouts, catchall, logResources } = resolutionResult;
             this.#initAsyncPromise = device
                 .createRenderPipelineAsync(descriptor)
@@ -346,7 +354,8 @@ class RenderPipelineCore {
                     catchall,
                     logResources,
                     usedVertexLayouts: connectedAttribs.usedVertexLayouts,
-                    fragmentOut,
+                    connectedTargets,
+                    usedImmediate: resolutionResult.usedImmediate,
                 };
                 this.#performanceTracker.measureCompile(device);
             })
@@ -364,7 +373,7 @@ class RenderPipelineCore {
             throw new Error("'pipeline.initAsync()' was called and is not yet resolved.");
         }
         const device = this.options.root.device;
-        const { resolutionResult, descriptor, connectedAttribs, fragmentOut } = this.resolveAndCreateShaderModule();
+        const { resolutionResult, descriptor, connectedTargets, connectedAttribs } = this.resolveAndCreateShaderModule();
         const { usedBindGroupLayouts, catchall, logResources } = resolutionResult;
         this.#memo = {
             pipeline: device.createRenderPipeline(descriptor),
@@ -372,7 +381,8 @@ class RenderPipelineCore {
             catchall,
             logResources,
             usedVertexLayouts: connectedAttribs.usedVertexLayouts,
-            fragmentOut,
+            connectedTargets,
+            usedImmediate: resolutionResult.usedImmediate,
         };
         this.#performanceTracker.measureCompile(device);
     }
@@ -396,11 +406,12 @@ class RenderPipelineCore {
             shaderGenerator: root.shaderGeneratorClass ? new root.shaderGeneratorClass() : undefined,
             root,
         }));
-        const { code, usedBindGroupLayouts, catchall } = resolutionResult;
+        const { code, usedBindGroupLayouts, catchall, usedImmediate } = resolutionResult;
         if (catchall !== undefined) {
             usedBindGroupLayouts[catchall[0]]?.$name(`${getName(this) ?? '<unnamed>'} - Automatic Bind Group & Layout`);
         }
         warnIfOverflow(usedBindGroupLayouts, device.limits);
+        const immediateSize = usedImmediate ? validateImmediateUsage(usedImmediate, root) : 0;
         const module = device.createShaderModule({
             label: `${getName(this) ?? '<unnamed>'} - Shader`,
             code,
@@ -417,6 +428,7 @@ class RenderPipelineCore {
             layout: device.createPipelineLayout({
                 label: `${getName(this) ?? '<unnamed>'} - Pipeline Layout`,
                 bindGroupLayouts: usedBindGroupLayouts.map((l) => root.unwrap(l)),
+                immediateSize,
             }),
             vertex: {
                 module,
@@ -430,7 +442,7 @@ class RenderPipelineCore {
         if (tgpuDescriptor.fragment) {
             descriptor.fragment = {
                 module,
-                targets: connectedTargets,
+                targets: connectedTargets.map((target) => (target ? target.target : null)),
             };
         }
         if (tgpuDescriptor.primitive) {
@@ -453,7 +465,7 @@ class RenderPipelineCore {
         if (tgpuDescriptor.multisample) {
             descriptor.multisample = tgpuDescriptor.multisample;
         }
-        return { resolutionResult, descriptor, connectedAttribs, fragmentOut };
+        return { resolutionResult, descriptor, connectedTargets, connectedAttribs };
     }
 }
 /**

package/core/resolve/namespace.js

@@ -1,4 +1,4 @@
-import { bannedTokens, builtins } from "../../nameUtils.js";
+import { bannedTokens, builtins, templateEnumerants } from "../../nameUtils.js";
 import { $internal } from "../../shared/symbols.js";
 import { ShelllessRepository } from "../../tgsl/shellless.js";
 class NamespaceImpl {
@@ -6,7 +6,7 @@ class NamespaceImpl {
     constructor(strategy) {
         this[$internal] = {
             strategy,
-            takenGlobalIdentifiers: new Set([...bannedTokens, ...builtins]),
+            takenGlobalIdentifiers: new Set([...bannedTokens, ...builtins, ...templateEnumerants]),
             shelllessRepo: new ShelllessRepository(),
             memoizedResolves: new WeakMap(),
             memoizedLazy: new WeakMap(),

package/core/root/init.js

@@ -214,6 +214,9 @@ class TgpuRootImpl extends WithBindingImpl {
     get minify() {
         return this[$soul].minify;
     }
+    get enabledWgslLanguageFeatures() {
+        return navigator.gpu?.wgslLanguageFeatures ?? new Set();
+    }
     createBuffer(typeSchema, initialOrBuffer) {
         return INTERNAL_createBuffer(this, typeSchema, initialOrBuffer);
     }

package/core/root/rootTypes.d.ts

@@ -419,9 +419,24 @@ export interface TgpuRoot extends Unwrapper, WithBinding {
      */
     get enabledFeatures(): ReadonlySet<GPUFeatureName>;
     /**
-     * Destroys all underlying resources (i.e. buffers...) created through this root object.
+     * Retrieves a read-only list of WGSL language extensions supported in the
+     * current environment (`navigator.gpu.wgslLanguageFeatures`).
+     * Returns an empty set when WebGPU is unavailable.
+     *
+     * @example
+     * ```ts
+     * const canUseImmediates = root.enabledWgslLanguageFeatures.has('immediate_address_space');
+     * ```
+     */
+    get enabledWgslLanguageFeatures(): ReadonlySet<string>;
+    /**
+     * Releases internal resource caches (e.g. utility texture pipelines),
+     * letting the GC reclaim them.
+     *
+     * Buffers, textures and other resources created through the root are NOT destroyed.
+     *
      * If the object is created via `tgpu.init` instead of `tgpu.initFromDevice`,
-     * then the inner GPU device is destroyed as well.
+     * destroys the underlying WebGPU device as well.
      */
     destroy(): void;
     '~unstable': Pick<ExperimentalTgpuRoot, 'createCommandEncoder' | 'createComparisonSampler' | 'createGuardedComputePipeline' | 'createRenderBundleEncoder' | 'createSampler' | 'createTexture' | 'nameRegistrySetting' | 'shaderGeneratorClass' | 'pipe' | 'with'>;

package/core/slot/accessor.d.ts

@@ -1,5 +1,5 @@
 import { type AnyData } from '../../data/dataTypes.ts';
-import type { BaseData } from '../../data/wgslTypes.ts';
+import { type BaseData } from '../../data/wgslTypes.ts';
 import type { InferGPU } from '../../shared/repr.ts';
 import { $getNameForward, $gpuValueOf, $internal, $resolve, $soul } from '../../shared/symbols.ts';
 import type { UnwrapRuntimeConstructor } from '../../tgpuBindGroupLayout.ts';

package/core/slot/accessor.js

@@ -1,6 +1,10 @@
-import { isData } from "../../data/dataTypes.js";
+import { isData, undecorate } from "../../data/dataTypes.js";
 import { schemaCallWrapper } from "../../data/schemaCallWrapper.js";
 import { isSnippet, snip } from "../../data/snippet.js";
+import { deepEqual } from "../../data/deepEqual.js";
+import { arrayOf } from "../../data/array.js";
+import { UnknownData } from "../../data/dataTypes.js";
+import { isAbstract, isWgslArray } from "../../data/wgslTypes.js";
 import { getResolutionCtx } from "../../execMode.js";
 import { makeDereferenceable } from "../../tgsl/makeDereferenceable.js";
 import { makeResolvable } from "../../tgsl/makeResolvable.js";
@@ -19,10 +23,65 @@ export function mutableAccessor(schemaOrConstructor, defaultValue) {
 // --------------
 // Implementation
 // --------------
+/**
+ * Accessors typed with a runtime-sized array schema (e.g. `d.arrayOf(d.f32)`) accept
+ * any array of that element type. If the provided JS value has a concrete length, we
+ * use a statically-sized schema so that the generated code can take advantage of it.
+ */
+function concretizeSchema(accessorSchema, value) {
+    if (isWgslArray(accessorSchema) && accessorSchema.elementCount === 0 && Array.isArray(value)) {
+        if (value.length === 0) {
+            throw new Error(`Cannot use empty array as an accessor value. Empty arrays aren't representable in shader code.`);
+        }
+        return arrayOf(accessorSchema.elementType, value.length);
+    }
+    return accessorSchema;
+}
+/**
+ * Origins of values that can be assigned to (or are handles, like storage textures).
+ * Accessors can only refer to module-scope resources, so function-scope origins
+ * ('function', 'local-def') are never provided to them.
+ */
+const mutableOrigins = new Set(['mutable', 'workgroup', 'private', 'handle']);
+/**
+ * Whether a value of type `providedType` can be used in place of `accessorSchema` without
+ * any conversion. Runtime-sized array schemas accept arrays of any length with a matching element type.
+ */
+function matchesSchema(accessorSchema, providedType) {
+    if (providedType === UnknownData) {
+        return false;
+    }
+    const expected = undecorate(accessorSchema);
+    const provided = undecorate(providedType);
+    if (isWgslArray(expected) && expected.elementCount === 0 && isWgslArray(provided)) {
+        return deepEqual(expected.elementType, provided.elementType);
+    }
+    return deepEqual(expected, provided);
+}
+/**
+ * Values with a concrete WGSL type (buffers, variables, GPU functions, ...) are used as-is,
+ * so they have to match the accessor's schema exactly. Mutable accessors are also assigned to,
+ * so the provided value has to be mutable.
+ */
+function validateAccessorSnippet(accessor, snippet) {
+    const isMutable = accessor.resourceType === 'mutable-accessor';
+    const description = `${isMutable ? 'mutable accessor' : 'accessor'} '${getName(accessor) ?? '<unnamed>'}'`;
+    if (isMutable && !mutableOrigins.has(snippet.origin)) {
+        throw new Error(`Values provided to ${description} must be mutable (e.g. mutable buffers, private or workgroup variables), got a value with origin '${snippet.origin}'. Use tgpu.accessor for read-only access.`);
+    }
+    if (!matchesSchema(accessor.schema, snippet.dataType)) {
+        throw new Error(`Value of type '${String(snippet.dataType)}' does not match the schema of ${description}: '${String(accessor.schema)}'.`);
+    }
+}
 /**
  * @returns A snippet representing the accessor.
  */
 function createAccessorSnippet(accessor) {
+    const snippet = createUnvalidatedAccessorSnippet(accessor);
+    validateAccessorSnippet(accessor, snippet);
+    return snippet;
+}
+function createUnvalidatedAccessorSnippet(accessor) {
     // oxlint-disable-next-line typescript/no-non-null-assertion -- it's there
     const ctx = getResolutionCtx();
     let value = getGpuValueRecursively(ctx.unwrap(accessor.slot));
@@ -35,23 +94,31 @@ function createAccessorSnippet(accessor) {
         if (isSnippet(value)) {
             value = value.value;
         }
+        value = getGpuValueRecursively(value);
     }
     const ownSnippet = getOwnSnippet(value);
     if (ownSnippet) {
         return ownSnippet;
     }
     if (isGPUCallable(value)) {
-        return value[$gpuCallable].call(ctx, []);
+        const result = value[$gpuCallable].call(ctx, []);
+        if (result.dataType !== UnknownData && !isAbstract(result.dataType)) {
+            return result;
+        }
+        // The result is a plain JS value (e.g. an array literal or a number returned from
+        // `tgpu.comptime`), so we treat it the same way as a directly provided JS value.
+        value = result.value;
     }
     if (isTgpuFn(value) || hasTinyestMetadata(value)) {
         const fn = ctx.resolve(value);
-        return ctx.withResetIndentLevel(() => snip(`${fn.value}()`, accessor.schema, /* origin */ 'runtime', fn.possibleSideEffects));
+        return ctx.withResetIndentLevel(() => snip(`${fn.value}()`, fn.dataType, /* origin */ 'runtime', fn.possibleSideEffects));
     }
     ctx.pushMode(new NormalState());
     try {
+        const schema = concretizeSchema(accessor.schema, value);
         // Doing a deep copy each time so that we don't have to deal with refs
-        const cloned = schemaCallWrapper(accessor.schema, value);
-        return snip(cloned, accessor.schema, 'constant', /* possibleSideEffects */ false);
+        const cloned = schemaCallWrapper(schema, value);
+        return snip(cloned, schema, 'constant', /* possibleSideEffects */ false);
     }
     finally {
         ctx.popMode('normal');

package/core/slot/slotTypes.d.ts

@@ -7,6 +7,7 @@ import { $gpuValueOf, $internal, $providing, $soul } from '../../shared/symbols.
 import type { UnwrapRuntimeConstructor } from '../../tgpuBindGroupLayout.ts';
 import type { TgpuBufferBinding } from '../buffer/bufferBinding.ts';
 import type { TgpuConst } from '../constant/tgpuConstant.ts';
+import type { TgpuImmediateVar } from '../immediate/immediateVar.ts';
 import type { Withable } from '../root/rootTypes.ts';
 import type { TgpuTextureView } from '../texture/texture.ts';
 import type { TgpuVar, VariableScope } from '../variable/tgpuVariable.ts';
@@ -51,7 +52,7 @@ export interface TgpuAccessor<T extends BaseData = BaseData> extends TgpuNamable
     readonly $: InferGPU<T>;
     toString(): string;
 }
-type DataAccessorIn<T extends BaseData> = (() => DataAccessorIn<T>) | TgpuBufferBinding<T> | TgpuVar<VariableScope, T> | TgpuConst<T> | Infer<T>;
+type DataAccessorIn<T extends BaseData> = (() => DataAccessorIn<T>) | TgpuBufferBinding<T> | TgpuVar<VariableScope, T> | TgpuConst<T> | TgpuImmediateVar<T> | Infer<T>;
 type TextureAccessorIn<T extends WgslTexture | WgslStorageTexture> = (() => TextureAccessorIn<T>) | Infer<T> | TgpuTextureView<T>;
 export declare namespace TgpuAccessor {
     type In<T extends BaseData | ((count: number) => BaseData)> = UnwrapRuntimeConstructor<T> extends WgslTexture | WgslStorageTexture ? TextureAccessorIn<UnwrapRuntimeConstructor<T>> : DataAccessorIn<UnwrapRuntimeConstructor<T>>;

package/core/texture/texture.d.ts

@@ -13,6 +13,7 @@ import type { ResolutionCtx, SelfResolvable } from '../../types.ts';
 import type { ExperimentalTgpuRoot } from '../root/rootTypes.ts';
 import type { TextureProps } from './textureProps.ts';
 import type { AllowedUsages, LiteralToExtensionMap, RenderFlag, SampledFlag } from './usageExtension.ts';
+import { type TextureBlobWriteOptions, type TextureCopyOptions, type TextureRawWriteOptions, type TextureWriteOptions } from './textureWrite.ts';
 export type TextureInternals = {
     root: ExperimentalTgpuRoot;
     materialize(): GPUTexture;
@@ -38,17 +39,7 @@ type TextureViewInternals = {
     readonly aspect?: GPUTextureAspect | undefined;
 };
 export type TexelData = Vec4u | Vec4i | Vec4f;
-export type ExternalImageSource = HTMLCanvasElement | HTMLImageElement | HTMLVideoElement | ImageBitmap | ImageData | OffscreenCanvas | VideoFrame;
-export type TextureWriteFit = 'stretch';
-export type TextureWriteOptions = {
-    /**
-     * How to handle a source whose dimensions do not match the texture.
-     *
-     * By default, mismatched writes throw. Use `'stretch'` to resample the
-     * source to the texture's dimensions.
-     */
-    fit?: TextureWriteFit;
-};
+export type { TextureBlobWriteOptions, TextureChannel, TextureCopyOptions, TextureRawWriteOptions, TextureWriteFit, TextureWriteOptions, } from './textureWrite.ts';
 type TgpuTextureViewDescriptor = {
     /**
      * Which {@link GPUTextureAspect | aspect(s)} of the texture are accessible to the texture view.
@@ -106,6 +97,12 @@ type CopyCompatibleTexture<T extends TextureProps> = TgpuTexture<{
     format: T['format'];
     sampleCount?: T['sampleCount'];
 }>;
+type FormatCompatibleTexture<T extends TextureProps> = TgpuTexture<{
+    size: readonly number[];
+    format: T['format'];
+    dimension?: TextureProps['dimension'];
+    sampleCount?: T['sampleCount'];
+}>;
 export interface TgpuTexture<TProps extends TextureProps = any> extends TgpuNamable {
     readonly [$internal]: TextureInternals;
     readonly [$soul]: TgpuTextureSoul<TProps>;
@@ -123,11 +120,21 @@ export interface TgpuTexture<TProps extends TextureProps = any> extends TgpuNama
         sampleType?: T['sampleType'] extends F32 ? 'float' | 'unfilterable-float' : never;
     }): TgpuTextureView<T>;
     createView<T extends WgslStorageTexture>(schema: ValidateTextureViewSchema<this, T>, viewDescriptor?: TgpuTextureViewDescriptor): TgpuTextureView<T>;
+    /** Clears the texture to zeros */
     clear(mipLevel?: number | 'all'): void;
+    /** Clears the texture to `color`. Requires the `'render'` usage flag */
+    clear(color: readonly [number, number, number, number], mipLevel?: number | 'all'): void;
     generateMipmaps(baseMipLevel?: number, mipLevels?: number): void;
-    write(source: ExternalImageSource | ExternalImageSource[], options?: TextureWriteOptions): void;
-    write(source: ArrayBuffer | TypedArray | DataView, mipLevel?: number): void;
+    /** Writes image sources to the texture, one per array layer. Requires the `'render'` usage flag */
+    write(source: GPUCopyExternalImageSource | GPUCopyExternalImageSource[], options?: TextureWriteOptions): void;
+    /** Writes raw texel data to the texture */
+    write(source: ArrayBuffer | TypedArray | DataView, options?: number | TextureRawWriteOptions): void;
+    /** Decodes an image blob and writes it to the texture. Requires the `'render'` usage flag */
+    writeAsync(source: Blob, options?: TextureBlobWriteOptions): Promise<void>;
+    /** Copies the contents of a texture with a matching size and format */
     copyFrom<T extends CopyCompatibleTexture<TProps>>(source: T): void;
+    /** Copies a region between textures of the same format */
+    copyFrom<T extends FormatCompatibleTexture<TProps>>(source: T, options: TextureCopyOptions): void;
     destroy(): void;
 }
 export interface TgpuTextureView<TSchema extends WgslStorageTexture | WgslTexture = WgslStorageTexture | WgslTexture> extends TgpuNamable {
@@ -170,4 +177,3 @@ export declare class TgpuTextureRenderViewImpl implements TgpuTextureRenderView
     constructor(baseTexture: TgpuTexture, descriptor?: TgpuTextureViewDescriptor);
     get descriptor(): TgpuTextureViewDescriptor;
 }
-export {};