typegpu 0.12.6 → 0.12.8

package/core/pipeline/connectAttachmentToShader.js

@@ -1,29 +1,24 @@
-import { isBuiltin } from "../../data/attributes.js";
-import { isVoid, isWgslStruct } from "../../data/wgslTypes.js";
 function isColorAttachment(value) {
     return !!value?.view;
 }
-export function connectAttachmentToShader(fragmentOut, attachment) {
-    if (isVoid(fragmentOut) || isBuiltin(fragmentOut)) {
+export function connectAttachmentToShader(connectedTargets, attachment) {
+    if (!connectedTargets) {
         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.`);
+    return connectedTargets.map((target) => {
+        if (!target) {
+            return null;
+        }
+        if (target.key === undefined) {
+            if (!isColorAttachment(attachment)) {
+                throw new Error('Expected a single color attachment, not a record.');
             }
-            result.push(matching);
+            return attachment;
         }
-        return result;
-    }
-    if (!isColorAttachment(attachment)) {
-        throw new Error('Expected a single color attachment, not a record.');
-    }
-    return [attachment];
+        const matching = attachment[target.key];
+        if (!matching) {
+            throw new Error(`A color attachment by the name of '${target.key}' was not provided to the shader.`);
+        }
+        return matching;
+    });
 }

package/core/pipeline/connectTargetsToShader.d.ts

@@ -1,3 +1,7 @@
 import { type BaseData } from '../../data/wgslTypes.ts';
 import type { AnyFragmentTargets } from './renderPipeline.ts';
-export declare function connectTargetsToShader(fragmentOut: BaseData, targets: AnyFragmentTargets): (GPUColorTargetState | null)[];
+export interface ConnectedTarget {
+    key: string | undefined;
+    target: GPUColorTargetState;
+}
+export declare function connectTargetsToShader(fragmentOut: BaseData, targets: AnyFragmentTargets): (ConnectedTarget | null)[];

package/core/pipeline/connectTargetsToShader.js

@@ -1,31 +1,36 @@
 import { isBuiltin } from "../../data/attributes.js";
 import { isVoid, isWgslStruct } from "../../data/wgslTypes.js";
+import { invariant } from "../../errors.js";
+import { getCustomLocation } from "../../data/dataTypes.js";
 export function connectTargetsToShader(fragmentOut, targets) {
-    let presentationFormat;
     if (isVoid(fragmentOut) || isBuiltin(fragmentOut)) {
         return [];
     }
+    const result = [];
+    function putInResult(index, key, target) {
+        while (index > result.length) {
+            result.push(null);
+        }
+        result[index] = { key, target };
+    }
     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({
+        const varyings = Object.entries(fragmentOut.propTypes).filter(([, value]) => !isBuiltin(value));
+        for (const [key, outputValue] of varyings) {
+            const matchingTarget = targets?.[key];
+            const location = getCustomLocation(outputValue);
+            invariant(location !== undefined, `'withLocations' failed or was not called.`);
+            putInResult(location, key, {
                 ...matchingTarget,
-                format: matchingTarget?.format ??
-                    (presentationFormat ??= navigator.gpu.getPreferredCanvasFormat()),
+                format: matchingTarget?.format ?? navigator.gpu.getPreferredCanvasFormat(),
             });
         }
-        return result;
     }
-    const singleTarget = targets;
-    return [
-        {
+    else {
+        const singleTarget = targets;
+        putInResult(getCustomLocation(fragmentOut) ?? 0, undefined, {
             ...singleTarget,
-            format: singleTarget?.format ?? (presentationFormat ??= navigator.gpu.getPreferredCanvasFormat()),
-        },
-    ];
+            format: singleTarget?.format ?? navigator.gpu.getPreferredCanvasFormat(),
+        });
+    }
+    return result;
 }

package/core/pipeline/renderPipeline.d.ts

@@ -3,7 +3,7 @@ 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 AnyWgslData, 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';
@@ -18,6 +18,7 @@ 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';
@@ -34,7 +35,7 @@ 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;
@@ -221,7 +222,7 @@ 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 {
@@ -280,13 +281,15 @@ 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>>>;
     };
 }
 /**
- * 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
+ * Throws, when vertexOut and fragmentIn don't match in terms of custom locations.
+ *
+ * @privateRemarks
+ * Note that vertexOut is undefined in shellless functions.
  */
 export declare function matchUpVaryingLocations(vertexOut: TgpuVertexFn.Out | undefined, fragmentIn: TgpuFragmentFn.In | undefined, vertexFnName: string, fragmentFnName: string): Record<string, number>;
 export {};

package/core/pipeline/renderPipeline.js

@@ -42,7 +42,7 @@ 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, {
@@ -77,7 +77,7 @@ 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 ?? [])];
@@ -181,7 +181,7 @@ class TgpuRenderPipelineImpl {
     withStencilReference(reference) {
         return this.#withPriors({ stencilReference: reference });
     }
-    withIndexBuffer(buffer, indexFormatOrOffset, offsetElementsOrSizeBytes, sizeElementsOrUndefined) {
+    withIndexBuffer(buffer, indexFormatOrOffset, offsetBytesOrSizeElements, sizeBytesOrUndefined) {
         if (isGPUBuffer(buffer)) {
             if (typeof indexFormatOrOffset !== 'string') {
                 throw new Error('If a GPUBuffer is passed, indexFormat must be provided.');
@@ -190,8 +190,8 @@ class TgpuRenderPipelineImpl {
                 indexBuffer: {
                     buffer,
                     indexFormat: indexFormatOrOffset,
-                    offsetBytes: offsetElementsOrSizeBytes,
-                    sizeBytes: sizeElementsOrUndefined,
+                    offsetBytes: offsetBytesOrSizeElements,
+                    sizeBytes: sizeBytesOrUndefined,
                 },
             });
         }
@@ -207,8 +207,8 @@ class TgpuRenderPipelineImpl {
                 offsetBytes: indexFormatOrOffset !== undefined
                     ? indexFormatOrOffset * sizeOf(elementType)
                     : undefined,
-                sizeBytes: sizeElementsOrUndefined !== undefined
-                    ? sizeElementsOrUndefined * sizeOf(elementType)
+                sizeBytes: offsetBytesOrSizeElements !== undefined
+                    ? offsetBytesOrSizeElements * sizeOf(elementType)
                     : undefined,
             },
         });
@@ -224,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,
         };
@@ -345,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)
@@ -356,7 +354,7 @@ class RenderPipelineCore {
                     catchall,
                     logResources,
                     usedVertexLayouts: connectedAttribs.usedVertexLayouts,
-                    fragmentOut,
+                    connectedTargets,
                     usedImmediate: resolutionResult.usedImmediate,
                 };
                 this.#performanceTracker.measureCompile(device);
@@ -375,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),
@@ -383,7 +381,7 @@ class RenderPipelineCore {
             catchall,
             logResources,
             usedVertexLayouts: connectedAttribs.usedVertexLayouts,
-            fragmentOut,
+            connectedTargets,
             usedImmediate: resolutionResult.usedImmediate,
         };
         this.#performanceTracker.measureCompile(device);
@@ -444,7 +442,7 @@ class RenderPipelineCore {
         if (tgpuDescriptor.fragment) {
             descriptor.fragment = {
                 module,
-                targets: connectedTargets,
+                targets: connectedTargets.map((target) => (target ? target.target : null)),
             };
         }
         if (tgpuDescriptor.primitive) {
@@ -467,12 +465,14 @@ class RenderPipelineCore {
         if (tgpuDescriptor.multisample) {
             descriptor.multisample = tgpuDescriptor.multisample;
         }
-        return { resolutionResult, descriptor, connectedAttribs, fragmentOut };
+        return { resolutionResult, descriptor, connectedTargets, connectedAttribs };
     }
 }
 /**
- * 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
+ * Throws, when vertexOut and fragmentIn don't match in terms of custom locations.
+ *
+ * @privateRemarks
+ * Note that vertexOut is undefined in shellless functions.
  */
 export function matchUpVaryingLocations(vertexOut = {}, fragmentIn = {}, vertexFnName, fragmentFnName) {
     const locations = {};
@@ -497,13 +497,13 @@ export function matchUpVaryingLocations(vertexOut = {}, fragmentIn = {}, vertexF
             saveLocation(key, customLocation);
         }
         else if (locations[key] !== customLocation) {
-            logger.warn('locations-mismatched', `Mismatched location between vertexFn (${vertexFnName}) output (${locations[key]}) and fragmentFn (${fragmentFnName}) input (${customLocation}) for the key "${key}", using the location set on vertex output.`);
+            throw new Error(`Mismatched location between vertexFn (${vertexFnName}) output (${locations[key]}) and fragmentFn (${fragmentFnName}) input (${customLocation}) for the key "${key}".`);
         }
     }
     // automatically assign remaining locations to the rest
     let nextLocation = 0;
-    for (const key of Object.keys(vertexOut ?? {})) {
-        if (isBuiltin(vertexOut[key]) || locations[key] !== undefined) {
+    for (const [key, value] of [...Object.entries(vertexOut), ...Object.entries(fragmentIn)]) {
+        if (isBuiltin(value) || locations[key] !== undefined) {
             continue;
         }
         while (usedLocations.has(nextLocation)) {

package/core/pipeline/timeable.js

@@ -41,14 +41,27 @@ async function readTimestamps(querySet, registrations) {
     if (!querySet.available) {
         return;
     }
-    const result = await querySet.read();
+    let result;
+    try {
+        result = await querySet.read();
+    }
+    catch {
+        // The read was cancelled or failed (e.g. the device was destroyed or lost mid-read).
+        // Genuine validation errors are already reported through the device's error handling.
+        return;
+    }
     for (const { priors, callback } of registrations) {
         const start = result[priors.timestampWrites?.beginningOfPassWriteIndex ?? 0];
         const end = result[priors.timestampWrites?.endOfPassWriteIndex ?? 1];
         if (start === undefined || end === undefined) {
             throw new Error('QuerySet did not return valid timestamps.');
         }
-        await callback(start, end);
+        try {
+            await callback(start, end);
+        }
+        catch (err) {
+            console.error('An error was thrown from a performance callback (withPerformanceCallback). Errors thrown here cannot be caught by the caller, so handle them within the callback itself.', err);
+        }
     }
 }
 /** Returns false when the encoder is one we cannot defer work to, meaning the callback never fires */

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/configurableImpl.js

@@ -11,7 +11,6 @@ export class ConfigurableImpl {
         ]);
     }
     pipe(transform) {
-        const newCfg = transform(this);
-        return new ConfigurableImpl([...this.bindings, ...newCfg.bindings]);
+        return transform(this);
     }
 }

package/core/root/rootTypes.d.ts

@@ -430,9 +430,13 @@ export interface TgpuRoot extends Unwrapper, WithBinding {
      */
     get enabledWgslLanguageFeatures(): ReadonlySet<string>;
     /**
-     * Destroys all underlying resources (i.e. buffers...) created through this root object.
+     * 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/texture/externalTexture.d.ts

@@ -1,7 +1,7 @@
 import { $gpuValueOf, $internal, $resolve } from '../../shared/symbols.ts';
 import type { LayoutMembership } from '../../tgpuBindGroupLayout.ts';
 import { type WgslExternalTexture } from '../../data/texture.ts';
-import type { ResolutionCtx, SelfResolvable } from '../../types.ts';
+import { type ResolutionCtx, type SelfResolvable } from '../../types.ts';
 import { type ResolvedSnippet } from '../../data/snippet.ts';
 import type { Infer } from '../../shared/repr.ts';
 export interface TgpuExternalTexture {

package/core/texture/externalTexture.js

@@ -1,8 +1,9 @@
-import { $gpuValueOf, $internal, $ownSnippet, $resolve } from "../../shared/symbols.js";
+import { $comptimeValueOf, $gpuValueOf, $internal, $ownSnippet, $resolve, } from "../../shared/symbols.js";
 import { getName, setName } from "../../shared/meta.js";
 import { textureExternal } from "../../data/texture.js";
 import { valueProxyHandler } from "../valueProxyUtils.js";
 import { inCodegenMode } from "../../execMode.js";
+import { runtimeOnly } from "../../types.js";
 import { snip } from "../../data/snippet.js";
 export function isExternalTexture(value) {
     return value?.resourceType === 'external-texture';
@@ -33,6 +34,7 @@ export class TgpuExternalTextureImpl {
             get [$ownSnippet]() {
                 return snip(this, schema, 'handle', false);
             },
+            [$comptimeValueOf]: runtimeOnly,
             [$resolve]: (ctx) => ctx.resolve(this),
             toString: () => `textureExternal:${getName(this) ?? '<unnamed>'}.$`,
         }, valueProxyHandler);

package/core/texture/texture.d.ts

@@ -9,7 +9,7 @@ import type { TgpuDeviceOwningSoul, TgpuSoul } from '../../shared/soul.ts';
 import { $gpuValueOf, $internal, $repr, $resolve, $soul } from '../../shared/symbols.ts';
 import type { Default, TypedArray, UnionToIntersection } from '../../shared/utilityTypes.ts';
 import type { LayoutMembership } from '../../tgpuBindGroupLayout.ts';
-import type { ResolutionCtx, SelfResolvable } from '../../types.ts';
+import { type ResolutionCtx, type 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';

package/core/texture/texture.js

@@ -3,7 +3,8 @@ import { inCodegenMode } from "../../execMode.js";
 import { snip } from "../../data/snippet.js";
 import { getName, setName } from "../../shared/meta.js";
 import { getTextureFormatInfo, } from "./textureFormats.js";
-import { $gpuValueOf, $internal, $ownSnippet, $repr, $resolve, $soul, } from "../../shared/symbols.js";
+import { $gpuValueOf, $internal, $ownSnippet, $comptimeValueOf, $repr, $resolve, $soul, } from "../../shared/symbols.js";
+import { runtimeOnly } from "../../types.js";
 import { valueProxyHandler } from "../valueProxyUtils.js";
 import { clearTextureWithColor, generateTextureMipmaps, writeImages } from "./textureUtils.js";
 import { mipLevelSize, origin3d, resolveImageWrite, writeRegionSize, } from "./textureWrite.js";
@@ -313,6 +314,7 @@ class TgpuFixedTextureViewImpl {
             get [$ownSnippet]() {
                 return snip(this, schema, /* origin */ 'handle', false);
             },
+            [$comptimeValueOf]: runtimeOnly,
             [$resolve]: (ctx) => ctx.resolve(this),
             toString: () => `${this.toString()}.$`,
         }, valueProxyHandler);
@@ -375,6 +377,7 @@ export class TgpuLaidOutTextureViewImpl {
             get [$ownSnippet]() {
                 return snip(this, schema, /* origin */ 'handle', false);
             },
+            [$comptimeValueOf]: runtimeOnly,
             [$resolve]: (ctx) => ctx.resolve(this),
             toString: () => `${this.toString()}.$`,
         }, valueProxyHandler);
@@ -405,10 +408,14 @@ export class TgpuTextureRenderViewImpl {
         };
         this[$internal] = {
             unwrap: () => {
-                return baseTexture[$internal].materialize().createView({
-                    label: getName(this) ?? '<unnamed>',
-                    ...this.descriptor,
-                });
+                const soul = this[$soul];
+                if (!soul.raw) {
+                    soul.raw = soul.texture[$internal].materialize().createView({
+                        label: getName(this) ?? '<unnamed>',
+                        ...soul.descriptor,
+                    });
+                }
+                return soul.raw;
             },
             format: descriptor.format ?? baseTexture.props.format,
             aspect: descriptor.aspect,

package/core/unroll/tgpuUnroll.d.ts

@@ -1,15 +1,16 @@
-import { $internal, $resolve } from '../../shared/symbols.ts';
+import { $comptimeValueOf, $internal, $resolve } from '../../shared/symbols.ts';
+import { type ComptimeValue, type ResolutionCtx, type SelfResolvable, type WithComptimeValue } from '../../types.ts';
 import { type ResolvedSnippet, type Snippet } from '../../data/snippet.ts';
-import type { ResolutionCtx, SelfResolvable } from '../../types.ts';
 /**
  * The result of calling `tgpu.unroll(...)`. The code responsible for
  * generating shader code can check if the value of a snippet is
  * an instance of `UnrollableIterable`, and act accordingly.
  */
-export declare class UnrollableIterable implements SelfResolvable {
+export declare class UnrollableIterable implements SelfResolvable, WithComptimeValue {
     readonly [$internal] = true;
     readonly snippet: Snippet;
     constructor(snippet: Snippet);
+    [$comptimeValueOf](): ComptimeValue;
     [$resolve](ctx: ResolutionCtx): ResolvedSnippet;
 }
 /**

package/core/unroll/tgpuUnroll.js

@@ -1,5 +1,6 @@
-import { $gpuCallable, $internal, $resolve } from "../../shared/symbols.js";
+import { $comptimeValueOf, $gpuCallable, $internal, $resolve } from "../../shared/symbols.js";
 import { setName } from "../../shared/meta.js";
+import { asComptime, } from "../../types.js";
 import { withValue } from "../../data/snippet.js";
 /**
  * The result of calling `tgpu.unroll(...)`. The code responsible for
@@ -12,6 +13,11 @@ export class UnrollableIterable {
     constructor(snippet) {
         this.snippet = snippet;
     }
+    [$comptimeValueOf]() {
+        // Outside of for-of loops, `tgpu.unroll(...)` is transparent, just like in JS
+        const known = asComptime(this.snippet);
+        return known ? { comptime: true, value: known.value } : { comptime: false };
+    }
     [$resolve](ctx) {
         return ctx.resolveSnippet(this.snippet);
     }

package/core/valueProxyUtils.d.ts

@@ -1,3 +1,5 @@
-import { type SelfResolvable, type WithOwnSnippet } from '../types.ts';
-export declare const valueProxyHandler: ProxyHandler<SelfResolvable & WithOwnSnippet>;
+import { type SelfResolvable, type WithComptimeValue, type WithOwnSnippet } from '../types.ts';
+type ValueProxyTarget = SelfResolvable & WithOwnSnippet & WithComptimeValue;
+export declare const valueProxyHandler: ProxyHandler<ValueProxyTarget>;
 export declare function getGpuValueRecursively<T>(value: unknown): T;
+export {};