typegpu 0.12.5 → 0.12.7

package/std/subgroup.js

@@ -181,3 +181,37 @@ export const subgroupXor = dualImpl({
     codegenImpl: (_ctx, [e]) => stitch `subgroupXor(${e})`,
     sideEffects: false,
 });
+export const quadBroadcast = dualImpl({
+    name: 'quadBroadcast',
+    signature: (...args) => {
+        const id = unify([args[1]], [i32, u32]);
+        if (!id) {
+            throw new Error(`quadBroadcast's second argument has to be compatible with i32 or u32. Got: ${args[1].type}`);
+        }
+        return { argTypes: [args[0], id[0]], returnType: args[0] };
+    },
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e, id]) => stitch `quadBroadcast(${e}, ${id})`,
+    sideEffects: false,
+});
+export const quadSwapDiagonal = dualImpl({
+    name: 'quadSwapDiagonal',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `quadSwapDiagonal(${e})`,
+    sideEffects: false,
+});
+export const quadSwapX = dualImpl({
+    name: 'quadSwapX',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `quadSwapX(${e})`,
+    sideEffects: false,
+});
+export const quadSwapY = dualImpl({
+    name: 'quadSwapY',
+    signature: (arg) => ({ argTypes: [arg], returnType: arg }),
+    normalImpl: errorMessage,
+    codegenImpl: (_ctx, [e]) => stitch `quadSwapY(${e})`,
+    sideEffects: false,
+});

package/std/texture.d.ts

@@ -61,11 +61,19 @@ declare function textureStoreCpu<T extends textureStorage3d>(texture: T, coords:
 export declare const textureStore: import("../types.ts").DualFn<typeof textureStoreCpu>;
 declare function textureDimensionsCpu<T extends texture1d | textureStorage1d>(texture: T): number;
 declare function textureDimensionsCpu<T extends texture1d>(texture: T, level: number): number;
-declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray | textureStorage2d | textureStorage2dArray | textureExternal>(texture: T): v2u;
-declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray>(texture: T, level: number): v2u;
+declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray | textureMultisampled2d | textureDepth2d | textureDepth2dArray | textureDepthCube | textureDepthCubeArray | textureDepthMultisampled2d | textureStorage2d | textureStorage2dArray | textureExternal>(texture: T): v2u;
+declare function textureDimensionsCpu<T extends texture2d | texture2dArray | textureCube | textureCubeArray | textureDepth2d | textureDepth2dArray | textureDepthCube | textureDepthCubeArray>(texture: T, level: number): v2u;
 declare function textureDimensionsCpu<T extends texture3d | textureStorage3d>(texture: T): v3u;
 declare function textureDimensionsCpu<T extends texture3d>(texture: T, level: number): v3u;
 export declare const textureDimensions: import("../types.ts").DualFn<typeof textureDimensionsCpu>;
+type ArrayTexture = texture2dArray | textureCubeArray | textureDepth2dArray | textureDepthCubeArray | textureStorage2dArray;
+declare function textureNumLayersCpu<T extends ArrayTexture>(_texture: T): number;
+export declare const textureNumLayers: import("../types.ts").DualFn<typeof textureNumLayersCpu>;
+type MipmappedTexture = texture1d | texture2d | texture2dArray | texture3d | textureCube | textureCubeArray | textureDepth2d | textureDepth2dArray | textureDepthCube | textureDepthCubeArray;
+declare function textureNumLevelsCpu<T extends MipmappedTexture>(_texture: T): number;
+export declare const textureNumLevels: import("../types.ts").DualFn<typeof textureNumLevelsCpu>;
+declare function textureNumSamplesCpu<T extends textureMultisampled2d | textureDepthMultisampled2d>(_texture: T): number;
+export declare const textureNumSamples: import("../types.ts").DualFn<typeof textureNumSamplesCpu>;
 type Gather2dArgs<T extends texture2d = texture2d> = [
     component: number,
     texture: T,
@@ -121,6 +129,11 @@ type TextureGatherCpuFn = {
 };
 export declare const textureGatherCpu: TextureGatherCpuFn;
 export declare const textureGather: import("../types.ts").DualFn<TextureGatherCpuFn>;
+declare function textureGatherCompareCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number, offset?: v2i): v4f;
+declare function textureGatherCompareCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number, offset?: v2i): v4f;
+declare function textureGatherCompareCpu<T extends textureDepthCube>(texture: T, sampler: comparisonSampler, coords: v3f, depthRef: number): v4f;
+declare function textureGatherCompareCpu<T extends textureDepthCubeArray>(texture: T, sampler: comparisonSampler, coords: v3f, arrayIndex: number, depthRef: number): v4f;
+export declare const textureGatherCompare: import("../types.ts").DualFn<typeof textureGatherCompareCpu>;
 declare function textureSampleCompareCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number): number;
 declare function textureSampleCompareCpu<T extends textureDepth2d>(texture: T, sampler: comparisonSampler, coords: v2f, depthRef: number, offset: v2i): number;
 declare function textureSampleCompareCpu<T extends textureDepth2dArray>(texture: T, sampler: comparisonSampler, coords: v2f, arrayIndex: number, depthRef: number): number;

package/std/texture.js

@@ -129,6 +129,36 @@ export const textureDimensions = dualImpl({
     },
     sideEffects: false,
 });
+function textureNumLayersCpu(_texture) {
+    throw new MissingCpuImplError('`textureNumLayers` relies on GPU resources and cannot be executed outside of a draw call');
+}
+export const textureNumLayers = dualImpl({
+    name: 'textureNumLayers',
+    normalImpl: textureNumLayersCpu,
+    codegenImpl: (_ctx, [texture]) => stitch `textureNumLayers(${texture})`,
+    signature: (texture) => ({ argTypes: [texture], returnType: u32 }),
+    sideEffects: false,
+});
+function textureNumLevelsCpu(_texture) {
+    throw new MissingCpuImplError('`textureNumLevels` relies on GPU resources and cannot be executed outside of a draw call');
+}
+export const textureNumLevels = dualImpl({
+    name: 'textureNumLevels',
+    normalImpl: textureNumLevelsCpu,
+    codegenImpl: (_ctx, [texture]) => stitch `textureNumLevels(${texture})`,
+    signature: (texture) => ({ argTypes: [texture], returnType: u32 }),
+    sideEffects: false,
+});
+function textureNumSamplesCpu(_texture) {
+    throw new MissingCpuImplError('`textureNumSamples` relies on GPU resources and cannot be executed outside of a draw call');
+}
+export const textureNumSamples = dualImpl({
+    name: 'textureNumSamples',
+    normalImpl: textureNumSamplesCpu,
+    codegenImpl: (_ctx, [texture]) => stitch `textureNumSamples(${texture})`,
+    signature: (texture) => ({ argTypes: [texture], returnType: u32 }),
+    sideEffects: false,
+});
 export const textureGatherCpu = (..._args) => {
     throw new Error('Texture gather relies on GPU resources and cannot be executed outside of a draw call');
 };
@@ -162,6 +192,24 @@ export const textureGather = dualImpl({
     },
     sideEffects: false,
 });
+function textureGatherCompareCpu(_texture, _sampler, _coords, _depthRefOrArrayIndex, _depthRefOrOffset, _maybeOffset) {
+    throw new MissingCpuImplError('`textureGatherCompare` relies on GPU resources and cannot be executed outside of a draw call');
+}
+export const textureGatherCompare = dualImpl({
+    name: 'textureGatherCompare',
+    normalImpl: textureGatherCompareCpu,
+    codegenImpl: (_ctx, args) => stitch `textureGatherCompare(${args})`,
+    signature: (...args) => {
+        const texture = args[0];
+        const isArrayTexture = texture.type === 'texture_depth_2d_array' || texture.type === 'texture_depth_cube_array';
+        const [tex, sampler, coords, _arrayIndex, ...rest] = args;
+        return {
+            argTypes: isArrayTexture ? [tex, sampler, coords, [u32, i32], ...rest] : args,
+            returnType: vec4f,
+        };
+    },
+    sideEffects: false,
+});
 function textureSampleCompareCpu(_texture, _sampler, _coords, _depthRefOrArrayIndex, _depthRefOrOffset, _maybeOffset) {
     throw new MissingCpuImplError('Texture comparison sampling relies on GPU resources and cannot be executed outside of a draw call');
 }

package/tgpuUnstable.d.ts

@@ -1,4 +1,5 @@
 export { declare } from './core/declare/tgpuDeclare.ts';
+export { immediateVar } from './core/immediate/immediateVar.ts';
 export { rawCodeSnippet } from './core/rawCodeSnippet/tgpuRawCodeSnippet.ts';
 export { namespace } from './core/resolve/namespace.ts';
 export { simulate } from './core/simulate/tgpuSimulate.ts';

package/tgpuUnstable.js

@@ -1,5 +1,6 @@
 // NOTE: This is a barrel file, internal files should not import things from this file
 export { declare } from "./core/declare/tgpuDeclare.js";
+export { immediateVar } from "./core/immediate/immediateVar.js";
 export { rawCodeSnippet } from "./core/rawCodeSnippet/tgpuRawCodeSnippet.js";
 export { namespace } from "./core/resolve/namespace.js";
 export { simulate } from "./core/simulate/tgpuSimulate.js";

package/tgsl/accessIndex.js

@@ -12,33 +12,31 @@ const indexableTypeToResult = {
     mat3x3f: vec3f,
     mat4x4f: vec4f,
 };
+function deriveIndexAccessOrigin(targetOrigin, indexOrigin) {
+    if (targetOrigin === 'constant-immutable-def') {
+        // Constant refs stay const unless the index forces runtime materialization
+        return indexOrigin === 'constant' || indexOrigin === 'constant-immutable-def'
+            ? 'constant-immutable-def'
+            : 'runtime-immutable-def';
+    }
+    if (targetOrigin === 'constant') {
+        // Ephemeral constants indexed with constants stay constant, otherwise they become runtime-known
+        return indexOrigin === 'constant' || indexOrigin === 'constant-immutable-def'
+            ? 'constant'
+            : 'runtime';
+    }
+    // Fallthrough
+    return targetOrigin;
+}
 export function accessIndex(target, indexArg) {
     const index = typeof indexArg === 'number' ? coerceToSnippet(indexArg) : indexArg;
     // array
     if (isWgslArray(target.dataType) || isDisarray(target.dataType)) {
         const elementType = target.dataType.elementType;
-        let origin;
-        if (target.origin === 'constant-immutable-def') {
-            // Constant refs stay const unless the element/index forces runtime materialization
-            origin =
-                index.origin === 'constant' || index.origin === 'constant-immutable-def'
-                    ? 'constant-immutable-def'
-                    : 'runtime-immutable-def';
-        }
-        else if (target.origin === 'constant') {
-            // Ephemeral constants indexed with constants stay constant, otherwise they become runtime-known
-            origin =
-                index.origin === 'constant' || index.origin === 'constant-immutable-def'
-                    ? 'constant'
-                    : 'runtime';
-        }
-        else {
-            // Fallthrough
-            origin = target.origin;
-        }
         if (target.value instanceof ArrayExpression && isKnownAtComptime(index)) {
             return target.value.elements[index.value];
         }
+        const origin = deriveIndexAccessOrigin(target.origin, index.origin);
         return snip(isKnownAtComptime(target) && isKnownAtComptime(index)
             ? // oxlint-disable-next-line typescript/no-explicit-any -- it's fine, it's there
                 target.value[index.value]
@@ -50,8 +48,7 @@ export function accessIndex(target, indexArg) {
         return snip(isKnownAtComptime(target) && isKnownAtComptime(index)
             ? // oxlint-disable-next-line typescript/no-explicit-any -- it's fine, it's there
                 target.value[index.value]
-            : stitch `${target}[${index}]`, target.dataType.primitive, 
-        /* origin */ target.origin, target.possibleSideEffects || index.possibleSideEffects);
+            : stitch `${target}[${index}]`, target.dataType.primitive, deriveIndexAccessOrigin(target.origin, index.origin), target.possibleSideEffects || index.possibleSideEffects);
     }
     if (isPtr(target.dataType)) {
         // Sometimes values that are typed as pointers aren't instances of `d.ref`, so we
@@ -61,8 +58,7 @@ export function accessIndex(target, indexArg) {
     // matrix.columns
     if (target.value instanceof MatrixColumnsAccess) {
         const propType = indexableTypeToResult[target.value.matrix.dataType.type];
-        return snip(stitch `${target.value.matrix}[${index}]`, propType, 
-        /* origin */ target.origin, target.possibleSideEffects || index.possibleSideEffects);
+        return snip(stitch `${target.value.matrix}[${index}]`, propType, deriveIndexAccessOrigin(target.origin, index.origin), target.possibleSideEffects || index.possibleSideEffects);
     }
     // matrix
     if (target.dataType.type in indexableTypeToResult) {

package/tgsl/conversion.d.ts

@@ -16,6 +16,7 @@ export type ConversionResult = {
 export declare function getBestConversion(types: BaseData[], targetTypes?: BaseData[]): ConversionResult | undefined;
 /**
  * Unifies input types to a common type.
+ * Ties between equally good `restrictTo` candidates go to the one listed first.
  */
 export declare function unify<T extends (BaseData | UnknownData)[] | []>(inTypes: T, restrictTo?: BaseData[]): {
     [K in keyof T]: BaseData;
@@ -23,6 +24,7 @@ export declare function unify<T extends (BaseData | UnknownData)[] | []>(inTypes
 /**
  * Unifies input types to a common type.
  * Unlike `unify`, it does not allow implicit conversions.
+ * Ties between equally good `restrictTo` candidates go to the one listed first.
  */
 export declare function unifyStrict<T extends (BaseData | UnknownData)[] | []>(inTypes: T, restrictTo?: BaseData[]): {
     [K in keyof T]: BaseData;

package/tgsl/conversion.js

@@ -131,6 +131,7 @@ function findBestType(types, uniqueTypes, allowImplicit) {
                 destType = conversion.targetType;
             }
         }
+        // Ties keep the earlier candidate, so callers order their target types by preference.
         if (sum < (bestResult?.sum ?? Number.POSITIVE_INFINITY)) {
             bestResult = { type: destType, details, sum };
         }
@@ -209,6 +210,7 @@ function applyActionToSnippet(ctx, snippet, action, targetType) {
 }
 /**
  * Unifies input types to a common type.
+ * Ties between equally good `restrictTo` candidates go to the one listed first.
  */
 export function unify(inTypes, restrictTo) {
     if (inTypes.some((type) => type === UnknownData)) {
@@ -223,6 +225,7 @@ export function unify(inTypes, restrictTo) {
 /**
  * Unifies input types to a common type.
  * Unlike `unify`, it does not allow implicit conversions.
+ * Ties between equally good `restrictTo` candidates go to the one listed first.
  */
 export function unifyStrict(inTypes, restrictTo) {
     if (inTypes.some((type) => type === UnknownData)) {

package/tgsl/forOfUtils.js

@@ -1,5 +1,5 @@
 import { UnknownData } from "../data/dataTypes.js";
-import { isAlias, snip } from "../data/snippet.js";
+import { isAddressableOrigin, isStoredInMemory, snip } from "../data/snippet.js";
 import { stitch } from "../core/resolve/stitch.js";
 import * as wgsl from "../data/wgslTypes.js";
 import { i32, u32 } from "../data/numeric.js";
@@ -31,10 +31,7 @@ export function getElementType(elementSnippet, iterableSnippet) {
         throw new WgslTypeError(stitch `The elements in iterable ${iterableSnippet} are of unknown type`);
     }
     if (wgsl.isNaturallyEphemeral(elementSnippet.dataType) ||
-        elementSnippet.origin === 'runtime' ||
-        elementSnippet.origin === 'constant' ||
-        elementSnippet.origin === 'constant-immutable-def' ||
-        elementSnippet.origin === 'runtime-immutable-def') {
+        !isAddressableOrigin(elementSnippet.origin)) {
         return elementType;
     }
     if (!wgsl.isPtr(elementType)) {
@@ -56,7 +53,10 @@ export function getRangeSnippets(ctx, iterableSnippet, unroll = false) {
             comparison: step < 0 ? '>' : '<',
         };
     }
-    if (!unroll && !isAlias(iterableSnippet)) {
+    if (iterableSnippet.possibleSideEffects) {
+        throw new Error('`for ... of ...` loops do not support iterables with possible side effects. Store the iterable in a variable first.');
+    }
+    if (!unroll && !isStoredInMemory(iterableSnippet)) {
         throw new Error(`\`for ... of ...\` loops only support std.range or iterables stored in variables.
 -----
 You can wrap iterable with \`tgpu.unroll(...)\`. If iterable is known at comptime, the loop will be unrolled.

package/tgsl/generationHelpers.js

@@ -1,7 +1,7 @@
 import { UnknownData } from "../data/dataTypes.js";
 import { abstractFloat, abstractInt, bool, f32, i32 } from "../data/numeric.js";
 import { isRef } from "../data/ref.js";
-import { isAlias, isSnippet, snip, withDataType } from "../data/snippet.js";
+import { isStoredInMemory, isSnippet, snip, withDataType } from "../data/snippet.js";
 import { isMatInstance, isNaturallyEphemeral, isVecInstance, WORKAROUND_getSchema, } from "../data/wgslTypes.js";
 import { getOwnSnippet } from "../types.js";
 import { WgslTypeError } from "../errors.js";
@@ -81,7 +81,7 @@ export class ArrayExpression {
     [$resolve](ctx) {
         for (const elem of this.elements) {
             // We check if there are no references among the elements
-            if (isAlias(elem) && !isNaturallyEphemeral(elem.dataType)) {
+            if (isStoredInMemory(elem) && !isNaturallyEphemeral(elem.dataType)) {
                 const snippetStr = ctx.resolveSnippet(elem).value;
                 const snippetType = ctx.resolve(concretize(elem.dataType)).value;
                 throw new WgslTypeError(`'${snippetStr}' reference cannot be used in an array constructor.\n-----\nTry '${snippetType}(${snippetStr})' or 'arrayOf(${snippetType}, count)([...])' to copy the value instead.\n-----`);

package/tgsl/shaderGenerator.d.ts

@@ -17,7 +17,7 @@ export interface ConstantDefinitionOptions {
     readonly init: Snippet;
 }
 export interface VariableDefinitionOptions {
-    readonly scope: VariableScope | BindableBufferUsage | 'handle';
+    readonly scope: VariableScope | BindableBufferUsage | 'handle' | 'immediate';
     readonly id: string;
     readonly dataType: BaseData;
     readonly init: Snippet | undefined;

package/tgsl/wgslGenerator.d.ts

@@ -19,6 +19,7 @@ export declare class WgslGenerator implements ShaderGenerator {
      */
     protected _emitVarDecl(keyword: 'var' | 'let' | 'const' | `#VAR_${number}#`, name: string, _dataType: wgsl.BaseData, rhsStr: string): string;
     protected _identifier(id: string): Snippet;
+    protected _emitSwitchStatement(discriminantExpr: Snippet, groupedCaseExprs: [tests: Snippet[], consequent: ResolvedStatement[]][]): string;
     protected _callShellless(callee: AnyFn, args: readonly Snippet[]): ResolvedSnippet | undefined;
     /**
      * A wrapper for `generateExpression` that updates `ctx.expectedType`
@@ -51,6 +52,10 @@ export declare class WgslGenerator implements ShaderGenerator {
      */
     protected _aliasConstStatement(rawId: string, eqNode: tinyest.Expression, eq: Snippet): ResolvedStatement;
     protected _statement(statement: tinyest.Statement): ResolvedStatement;
+    /**
+     * Resolves the key of an object property. Handles both computed and non-computed keys.
+     */
+    protected _resolveObjectPropertyKey(property: tinyest.ObjectProperty): string;
     /**
      * Attempts a member access lookup to mark a variable as modified.
      * @example