typegpu 0.12.5 → 0.12.6

package/std/atomic.js

@@ -1,6 +1,9 @@
 import { dualImpl } from "../core/function/dualImpl.js";
 import { stitch } from "../core/resolve/stitch.js";
-import { i32, u32 } from "../data/numeric.js";
+import { unptr } from "../data/dataTypes.js";
+import { bool, i32, u32 } from "../data/numeric.js";
+import { derefSnippet } from "../data/ref.js";
+import { abstruct } from "../data/struct.js";
 import { isAtomic, Void, } from "../data/wgslTypes.js";
 import { safeStringify } from "../shared/stringify.js";
 export const workgroupBarrier = dualImpl({
@@ -24,33 +27,40 @@ export const textureBarrier = dualImpl({
     codegenImpl: () => 'textureBarrier()',
     sideEffects: true,
 });
-const atomicNormalError = 'Atomic operations are not supported outside of CODEGEN mode.';
-export const atomicLoad = dualImpl({
-    name: 'atomicLoad',
-    normalImpl: atomicNormalError,
-    signature: (a) => {
-        if (!isAtomic(a)) {
-            throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
-        }
-        return { argTypes: [a], returnType: a.inner };
+export const workgroupUniformLoad = dualImpl({
+    name: 'workgroupUniformLoad',
+    normalImpl: 'workgroupUniformLoad is not supported outside of CODEGEN mode.',
+    signature: (value) => {
+        const inner = unptr(value);
+        return {
+            argTypes: [value],
+            returnType: isAtomic(inner) ? inner.inner : inner,
+        };
     },
-    codegenImpl: (_ctx, [a]) => stitch `atomicLoad(&${a})`,
+    codegenImpl: (_ctx, [value]) => stitch `workgroupUniformLoad(&${derefSnippet(value)})`,
     sideEffects: true,
 });
-const atomicActionSignature = (a) => {
-    if (!isAtomic(a)) {
+const atomicNormalError = 'Atomic operations are not supported outside of CODEGEN mode.';
+const unwrapAtomic = (a) => {
+    const inner = unptr(a);
+    if (!isAtomic(inner)) {
         throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
     }
-    return {
-        argTypes: [a, a.inner.type === 'u32' ? u32 : i32],
-        returnType: Void,
-    };
+    return inner;
 };
+export const atomicLoad = dualImpl({
+    name: 'atomicLoad',
+    normalImpl: atomicNormalError,
+    signature: (a) => ({ argTypes: [a], returnType: unwrapAtomic(a).inner }),
+    codegenImpl: (_ctx, [a]) => stitch `atomicLoad(&${derefSnippet(a)})`,
+    sideEffects: true,
+});
+const atomicActionSignature = (a) => ({
+    argTypes: [a, unwrapAtomic(a).inner.type === 'u32' ? u32 : i32],
+    returnType: Void,
+});
 const atomicOpSignature = (a) => {
-    if (!isAtomic(a)) {
-        throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
-    }
-    const paramType = a.inner.type === 'u32' ? u32 : i32;
+    const paramType = unwrapAtomic(a).inner.type === 'u32' ? u32 : i32;
     return {
         argTypes: [a, paramType],
         returnType: paramType,
@@ -60,55 +70,79 @@ export const atomicStore = dualImpl({
     name: 'atomicStore',
     normalImpl: atomicNormalError,
     signature: atomicActionSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicStore(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicStore(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicAdd = dualImpl({
     name: 'atomicAdd',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicAdd(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicAdd(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicSub = dualImpl({
     name: 'atomicSub',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicSub(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicSub(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicMax = dualImpl({
     name: 'atomicMax',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicMax(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicMax(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicMin = dualImpl({
     name: 'atomicMin',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicMin(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicMin(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicAnd = dualImpl({
     name: 'atomicAnd',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicAnd(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicAnd(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicOr = dualImpl({
     name: 'atomicOr',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicOr(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicOr(&${derefSnippet(a)}, ${value})`,
     sideEffects: true,
 });
 export const atomicXor = dualImpl({
     name: 'atomicXor',
     normalImpl: atomicNormalError,
     signature: atomicOpSignature,
-    codegenImpl: (_ctx, [a, value]) => stitch `atomicXor(&${a}, ${value})`,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicXor(&${derefSnippet(a)}, ${value})`,
+    sideEffects: true,
+});
+export const atomicExchange = dualImpl({
+    name: 'atomicExchange',
+    normalImpl: atomicNormalError,
+    signature: atomicOpSignature,
+    codegenImpl: (_ctx, [a, value]) => stitch `atomicExchange(&${derefSnippet(a)}, ${value})`,
+    sideEffects: true,
+});
+const AtomicCompareExchangeResults = {
+    i32: abstruct({ old_value: i32, exchanged: bool }),
+    u32: abstruct({ old_value: u32, exchanged: bool }),
+};
+export const atomicCompareExchangeWeak = dualImpl({
+    name: 'atomicCompareExchangeWeak',
+    normalImpl: atomicNormalError,
+    signature: (a) => {
+        const inner = unwrapAtomic(a).inner.type === 'u32' ? u32 : i32;
+        return {
+            argTypes: [a, inner, inner],
+            returnType: AtomicCompareExchangeResults[inner.type],
+        };
+    },
+    codegenImpl: (_ctx, [a, compare, value]) => stitch `atomicCompareExchangeWeak(&${derefSnippet(a)}, ${compare}, ${value})`,
     sideEffects: true,
 });

package/std/derivative.js

@@ -1,66 +1,71 @@
 import { dualImpl } from "../core/function/dualImpl.js";
 import { stitch } from "../core/resolve/stitch.js";
+import { f32 } from "../data/numeric.js";
+import { vec2f, vec3f, vec4f } from "../data/vector.js";
+import { unifyRestrictedSignature } from "./numeric.js";
 const derivativeNormalError = 'Derivative builtins are not allowed on the CPU';
+// WGSL derivative builtins only accept f32 and vecN<f32>
+const derivativeSignature = unifyRestrictedSignature([f32, vec2f, vec3f, vec4f]);
 export const dpdx = dualImpl({
     name: 'dpdx',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (ctx, [value]) => ctx.gen.emitCall('dpdx', [], [value]),
     sideEffects: false,
 });
 export const dpdxCoarse = dualImpl({
     name: 'dpdxCoarse',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (_ctx, [value]) => stitch `dpdxCoarse(${value})`,
     sideEffects: false,
 });
 export const dpdxFine = dualImpl({
     name: 'dpdxFine',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (_ctx, [value]) => stitch `dpdxFine(${value})`,
     sideEffects: false,
 });
 export const dpdy = dualImpl({
     name: 'dpdy',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (ctx, [value]) => ctx.gen.emitCall('dpdy', [], [value]),
     sideEffects: false,
 });
 export const dpdyCoarse = dualImpl({
     name: 'dpdyCoarse',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (_ctx, [value]) => stitch `dpdyCoarse(${value})`,
     sideEffects: false,
 });
 export const dpdyFine = dualImpl({
     name: 'dpdyFine',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (_ctx, [value]) => stitch `dpdyFine(${value})`,
     sideEffects: false,
 });
 export const fwidth = dualImpl({
     name: 'fwidth',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (ctx, [value]) => ctx.gen.emitCall('fwidth', [], [value]),
     sideEffects: false,
 });
 export const fwidthCoarse = dualImpl({
     name: 'fwidthCoarse',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (_ctx, [value]) => stitch `fwidthCoarse(${value})`,
     sideEffects: false,
 });
 export const fwidthFine = dualImpl({
     name: 'fwidthFine',
     normalImpl: derivativeNormalError,
-    signature: (value) => ({ argTypes: [value], returnType: value }),
+    signature: derivativeSignature,
     codegenImpl: (_ctx, [value]) => stitch `fwidthFine(${value})`,
     sideEffects: false,
 });

package/std/index.d.ts

@@ -8,12 +8,12 @@ export { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub } from './ope
 export { rotateX4, rotateY4, rotateZ4, scale4, translate4 } from './matrix.ts';
 export { identity2, identity3, identity4, rotationX4, rotationY4, rotationZ4, scaling4, translation4, } from '../data/matrix.ts';
 export { allEq, eq, ne, lt, le, gt, ge, not, or, and, all, any, isCloseTo, select, } from './boolean.ts';
-export { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, workgroupBarrier, storageBarrier, textureBarrier, } from './atomic.ts';
+export { atomicAdd, atomicAnd, atomicCompareExchangeWeak, atomicExchange, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, workgroupBarrier, storageBarrier, textureBarrier, workgroupUniformLoad, } from './atomic.ts';
 export { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthCoarse, fwidthFine, } from './derivative.ts';
 export { arrayLength } from './array.ts';
-export { pack4x8unorm, pack2x16float, unpack4x8unorm, unpack2x16float, } from './packing.ts';
-export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, } from './texture.ts';
-export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, } from './subgroup.ts';
+export { pack2x16float, pack2x16snorm, pack2x16unorm, pack4x8snorm, pack4x8unorm, pack4xI8, pack4xI8Clamp, pack4xU8, pack4xU8Clamp, unpack2x16float, unpack2x16snorm, unpack2x16unorm, unpack4x8snorm, unpack4x8unorm, unpack4xI8, unpack4xU8, } from './packing.ts';
+export { textureDimensions, textureGather, textureGatherCompare, textureLoad, textureNumLayers, textureNumLevels, textureNumSamples, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, } from './texture.ts';
+export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, quadBroadcast, quadSwapDiagonal, quadSwapX, quadSwapY, } from './subgroup.ts';
 export { extensionEnabled } from './extensions.ts';
 export { bitcastU32toF32, bitcastU32toI32, bitcastF32toU32, bitcast } from './bitcast.ts';
 export { range } from './range.ts';

package/std/index.js

@@ -17,15 +17,15 @@ not, or, and,
 all, any, 
 // other
 isCloseTo, select, } from "./boolean.js";
-export { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, 
+export { atomicAdd, atomicAnd, atomicCompareExchangeWeak, atomicExchange, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, 
 // synchronization
-workgroupBarrier, storageBarrier, textureBarrier, } from "./atomic.js";
+workgroupBarrier, storageBarrier, textureBarrier, workgroupUniformLoad, } from "./atomic.js";
 export { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthCoarse, fwidthFine, } from "./derivative.js";
 export { arrayLength } from "./array.js";
 // oxfmt-ignore
-export { pack4x8unorm, pack2x16float, unpack4x8unorm, unpack2x16float, } from "./packing.js";
-export { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, } from "./texture.js";
-export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, } from "./subgroup.js";
+export { pack2x16float, pack2x16snorm, pack2x16unorm, pack4x8snorm, pack4x8unorm, pack4xI8, pack4xI8Clamp, pack4xU8, pack4xU8Clamp, unpack2x16float, unpack2x16snorm, unpack2x16unorm, unpack4x8snorm, unpack4x8unorm, unpack4xI8, unpack4xU8, } from "./packing.js";
+export { textureDimensions, textureGather, textureGatherCompare, textureLoad, textureNumLayers, textureNumLevels, textureNumSamples, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleGrad, textureSampleLevel, textureStore, } from "./texture.js";
+export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, quadBroadcast, quadSwapDiagonal, quadSwapX, quadSwapY, } from "./subgroup.js";
 export { extensionEnabled } from "./extensions.js";
 export { bitcastU32toF32, bitcastU32toI32, bitcastF32toU32, bitcast } from "./bitcast.js";
 export { range } from "./range.js";

package/std/numeric.d.ts

@@ -1,6 +1,10 @@
-import { type AnyFloat32VecInstance, type AnyFloatVecInstance, type AnyIntegerVecInstance, type AnyMatInstance, type AnyNumericVecInstance, type AnySignedVecInstance, type v2f, type v2h, type v2i, type v3f, type v3h, type v3i, type v4f, type v4h, type v4i, type Vec2f } from '../data/wgslTypes.ts';
+import { type AnyFloat32VecInstance, type AnyFloatVecInstance, type AnyIntegerVecInstance, type AnyMatInstance, type AnyNumericVecInstance, type AnySignedVecInstance, type BaseData, type v2f, type v2h, type v2i, type v3f, type v3h, type v3i, type v4f, type v4h, type v4i, type Vec2f } from '../data/wgslTypes.ts';
 import type { Infer } from '../shared/repr.ts';
 type NumVec = AnyNumericVecInstance;
+export declare const unifyRestrictedSignature: (restrict: BaseData[]) => (...args: BaseData[]) => {
+    argTypes: BaseData[];
+    returnType: BaseData;
+};
 declare function cpuAbs(value: number): number;
 declare function cpuAbs<T extends NumVec | number>(value: T): T;
 export declare const abs: import("../types.ts").DualFn<typeof cpuAbs>;

package/std/numeric.js

@@ -26,7 +26,7 @@ const variadicUnifySignature = (...args) => {
         returnType: uargs[0],
     };
 };
-const unifyRestrictedSignature = (restrict) => (...args) => {
+export const unifyRestrictedSignature = (restrict) => (...args) => {
     const uargs = unify(args, restrict);
     if (!uargs) {
         throw new SignatureNotSupportedError(args, restrict);
@@ -946,9 +946,9 @@ function cpuIntdiv(lhs, rhs) {
 export const intdiv = dualImpl({
     name: 'intdiv',
     signature: (lhs, rhs) => {
-        const unified = unify([lhs, rhs], [u32, i32]);
+        const unified = unify([lhs, rhs], [i32, u32]);
         if (!unified) {
-            throw new SignatureNotSupportedError([lhs, rhs], [u32, i32, abstractInt]);
+            throw new SignatureNotSupportedError([lhs, rhs], [i32, u32, abstractInt]);
         }
         return { argTypes: unified, returnType: unified[0] };
     },

package/std/packing.d.ts

@@ -1,4 +1,4 @@
-import type { v2f, v4f } from '../data/wgslTypes.ts';
+import type { v2f, v4f, v4i, v4u } from '../data/wgslTypes.ts';
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
@@ -9,13 +9,73 @@ export declare const unpack2x16float: import("../types.ts").DualFn<(e: number) =
  * https://gpuweb.github.io/gpuweb/wgsl/#pack2x16float-builtin
  */
 export declare const pack2x16float: import("../types.ts").DualFn<(e: v2f) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack2x16snorm-builtin
+ */
+export declare const pack2x16snorm: import("../types.ts").DualFn<(e: v2f) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack2x16unorm-builtin
+ */
+export declare const pack2x16unorm: import("../types.ts").DualFn<(e: v2f) => number>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
  */
 export declare const unpack4x8unorm: import("../types.ts").DualFn<(e: number) => v4f>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack4x8snorm-builtin
+ */
+export declare const unpack4x8snorm: import("../types.ts").DualFn<(e: number) => v4f>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack4xi8-builtin
+ */
+export declare const unpack4xI8: import("../types.ts").DualFn<(e: number) => v4i>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack4xu8-builtin
+ */
+export declare const unpack4xU8: import("../types.ts").DualFn<(e: number) => v4u>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack2x16snorm-builtin
+ */
+export declare const unpack2x16snorm: import("../types.ts").DualFn<(e: number) => v2f>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack2x16unorm-builtin
+ */
+export declare const unpack2x16unorm: import("../types.ts").DualFn<(e: number) => v2f>;
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
  */
 export declare const pack4x8unorm: import("../types.ts").DualFn<(e: v4f) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4x8snorm-builtin
+ */
+export declare const pack4x8snorm: import("../types.ts").DualFn<(e: v4f) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xi8-builtin
+ */
+export declare const pack4xI8: import("../types.ts").DualFn<(e: v4i) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xu8-builtin
+ */
+export declare const pack4xU8: import("../types.ts").DualFn<(e: v4u) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xi8clamp-builtin
+ */
+export declare const pack4xI8Clamp: import("../types.ts").DualFn<(e: v4i) => number>;
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xu8clamp-builtin
+ */
+export declare const pack4xU8Clamp: import("../types.ts").DualFn<(e: v4u) => number>;