typegpu 0.12.5 → 0.12.7

package/std/boolean.js

@@ -9,6 +9,7 @@ import { isBool, isVecBool, isVecInstance, } from "../data/wgslTypes.js";
 import { SignatureNotSupportedError, WgslTypeError } from "../errors.js";
 import { unify } from "../tgsl/conversion.js";
 import { cpuCopy } from "./copy.js";
+import { coerceToSnippet } from "../tgsl/generationHelpers.js";
 function correspondingBooleanVectorSchema(dataType) {
     if (dataType.type.includes('2')) {
         return vec2b;
@@ -30,7 +31,7 @@ export const allEq = dualImpl({
     name: 'allEq',
     signature: (...argTypes) => ({ argTypes, returnType: bool }),
     normalImpl: (lhs, rhs) => cpuAll(cpuEq(lhs, rhs)),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `all(${lhs} == ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => stitch `all(${ctx.gen.emitBinaryOp(lhs, '==', rhs)})`,
     sideEffects: false,
 });
 const cpuEq = (lhs, rhs) => {
@@ -54,7 +55,7 @@ export const eq = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: cpuEq,
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} == ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '==', rhs),
     sideEffects: false,
 });
 /**
@@ -72,7 +73,7 @@ export const ne = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: (lhs, rhs) => cpuNot(cpuEq(lhs, rhs)),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} != ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '!=', rhs),
     sideEffects: false,
 });
 const cpuLt = (lhs, rhs) => {
@@ -95,7 +96,7 @@ export const lt = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: cpuLt,
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} < ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '<', rhs),
     sideEffects: false,
 });
 /**
@@ -113,7 +114,7 @@ export const le = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: (lhs, rhs) => cpuOr(cpuLt(lhs, rhs), cpuEq(lhs, rhs)),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} <= ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '<=', rhs),
     sideEffects: false,
 });
 /**
@@ -131,7 +132,7 @@ export const gt = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: (lhs, rhs) => cpuAnd(cpuNot(cpuLt(lhs, rhs)), cpuNot(cpuEq(lhs, rhs))),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} > ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '>', rhs),
     sideEffects: false,
 });
 /**
@@ -149,7 +150,7 @@ export const ge = dualImpl({
         returnType: correspondingBooleanVectorSchema(argTypes[0]),
     }),
     normalImpl: (lhs, rhs) => cpuNot(cpuLt(lhs, rhs)),
-    codegenImpl: (_ctx, [lhs, rhs]) => stitch `(${lhs} >= ${rhs})`,
+    codegenImpl: (ctx, [lhs, rhs]) => ctx.gen.emitBinaryOp(lhs, '>=', rhs),
     sideEffects: false,
 });
 function cpuNot(value) {
@@ -274,9 +275,7 @@ export const isCloseTo = dualImpl({
             return stitch `(abs(f32(${lhs}) - f32(${rhs})) <= ${precision})`;
         }
         if (!isSnippetNumeric(lhs) && !isSnippetNumeric(rhs)) {
-            // https://www.w3.org/TR/WGSL/#vector-multi-component:~:text=Binary%20arithmetic%20expressions%20with%20mixed%20scalar%20and%20vector%20operands
-            // (a-a)+prec creates a vector of a.length elements, all equal to prec
-            return stitch `all(abs(${lhs} - ${rhs}) <= (${lhs} - ${lhs}) + ${precision})`;
+            return stitch `all(abs(${lhs} - ${rhs}) <= ${_ctx.gen.typeInstantiation(lhs.dataType, [coerceToSnippet(precision)])})`;
         }
         return 'false';
     },

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

@@ -160,10 +160,15 @@ function cpuNeg(value) {
 }
 export const neg = dualImpl({
     name: 'neg',
-    signature: (arg) => ({
-        argTypes: [arg],
-        returnType: arg,
-    }),
+    signature: (arg) => {
+        if (getPrimitive(arg) === u32) {
+            throw new WgslTypeError(`Unsupported signature. Unary operator - cannot be applied to argument of kind '${arg.type}'.`);
+        }
+        return {
+            argTypes: [arg],
+            returnType: arg,
+        };
+    },
     normalImpl: cpuNeg,
     codegenImpl: (_ctx, [arg]) => stitch `-(${arg})`,
     sideEffects: false,

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>;

package/std/packing.js

@@ -2,8 +2,25 @@ import * as TB from 'typed-binary';
 import { dualImpl } from "../core/function/dualImpl.js";
 import { stitch } from "../core/resolve/stitch.js";
 import { u32 } from "../data/numeric.js";
-import { vec2f, vec4f } from "../data/vector.js";
+import { clampScalar } from "../data/numberOps.js";
+import { vec2f, vec4f, vec4i, vec4u } from "../data/vector.js";
 import { readFloat16, writeFloat16 } from "../data/float16Conversion.js";
+const littleEndian = { endianness: 'little' };
+const packedBuffer = new ArrayBuffer(4);
+const packedWriter = new TB.BufferWriter(packedBuffer, littleEndian);
+const packedReader = new TB.BufferReader(packedBuffer, littleEndian);
+function readPacked(value) {
+    packedWriter.seekTo(0);
+    packedWriter.writeUint32(value);
+    packedReader.seekTo(0);
+    return packedReader;
+}
+function writePacked(write) {
+    packedWriter.seekTo(0);
+    write(packedWriter);
+    packedReader.seekTo(0);
+    return u32(packedReader.readUint32());
+}
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
@@ -11,10 +28,7 @@ import { readFloat16, writeFloat16 } from "../data/float16Conversion.js";
 export const unpack2x16float = dualImpl({
     name: 'unpack2x16float',
     normalImpl: (e) => {
-        const buffer = new ArrayBuffer(4);
-        const writer = new TB.BufferWriter(buffer);
-        writer.writeUint32(e);
-        const reader = new TB.BufferReader(buffer);
+        const reader = readPacked(e);
         return vec2f(readFloat16(reader), readFloat16(reader));
     },
     signature: { argTypes: [u32], returnType: vec2f },
@@ -27,18 +41,50 @@ export const unpack2x16float = dualImpl({
  */
 export const pack2x16float = dualImpl({
     name: 'pack2x16float',
-    normalImpl: (e) => {
-        const buffer = new ArrayBuffer(4);
-        const writer = new TB.BufferWriter(buffer);
+    normalImpl: (e) => writePacked((writer) => {
         writeFloat16(writer, e.x);
         writeFloat16(writer, e.y);
-        const reader = new TB.BufferReader(buffer);
-        return u32(reader.readUint32());
-    },
+    }),
     signature: { argTypes: [vec2f], returnType: u32 },
     codegenImpl: (_ctx, [e]) => stitch `pack2x16float(${e})`,
     sideEffects: false,
 });
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack2x16snorm-builtin
+ */
+export const pack2x16snorm = dualImpl({
+    name: 'pack2x16snorm',
+    normalImpl: (e) => {
+        const x = Math.floor(0.5 + 32767 * clampScalar(e.x, -1, 1));
+        const y = Math.floor(0.5 + 32767 * clampScalar(e.y, -1, 1));
+        return writePacked((writer) => {
+            writer.writeInt16(x);
+            writer.writeInt16(y);
+        });
+    },
+    signature: { argTypes: [vec2f], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack2x16snorm(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack2x16unorm-builtin
+ */
+export const pack2x16unorm = dualImpl({
+    name: 'pack2x16unorm',
+    normalImpl: (e) => {
+        const x = Math.floor(0.5 + 65535 * clampScalar(e.x, 0, 1));
+        const y = Math.floor(0.5 + 65535 * clampScalar(e.y, 0, 1));
+        return writePacked((writer) => {
+            writer.writeUint16(x);
+            writer.writeUint16(y);
+        });
+    },
+    signature: { argTypes: [vec2f], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack2x16unorm(${e})`,
+    sideEffects: false,
+});
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
@@ -46,33 +92,176 @@ export const pack2x16float = dualImpl({
 export const unpack4x8unorm = dualImpl({
     name: 'unpack4x8unorm',
     normalImpl: (e) => {
-        const buffer = new ArrayBuffer(4);
-        const writer = new TB.BufferWriter(buffer);
-        writer.writeUint32(e);
-        const reader = new TB.BufferReader(buffer);
+        const reader = readPacked(e);
         return vec4f(reader.readUint8() / 255, reader.readUint8() / 255, reader.readUint8() / 255, reader.readUint8() / 255);
     },
     signature: { argTypes: [u32], returnType: vec4f },
     codegenImpl: (_ctx, [e]) => stitch `unpack4x8unorm(${e})`,
     sideEffects: false,
 });
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack4x8snorm-builtin
+ */
+export const unpack4x8snorm = dualImpl({
+    name: 'unpack4x8snorm',
+    normalImpl: (e) => {
+        const reader = readPacked(e);
+        return vec4f(Math.max(reader.readInt8() / 127, -1), Math.max(reader.readInt8() / 127, -1), Math.max(reader.readInt8() / 127, -1), Math.max(reader.readInt8() / 127, -1));
+    },
+    signature: { argTypes: [u32], returnType: vec4f },
+    codegenImpl: (_ctx, [e]) => stitch `unpack4x8snorm(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack4xi8-builtin
+ */
+export const unpack4xI8 = dualImpl({
+    name: 'unpack4xI8',
+    normalImpl: (e) => {
+        const reader = readPacked(e);
+        return vec4i(reader.readInt8(), reader.readInt8(), reader.readInt8(), reader.readInt8());
+    },
+    signature: { argTypes: [u32], returnType: vec4i },
+    codegenImpl: (_ctx, [e]) => stitch `unpack4xI8(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack4xu8-builtin
+ */
+export const unpack4xU8 = dualImpl({
+    name: 'unpack4xU8',
+    normalImpl: (e) => {
+        const reader = readPacked(e);
+        return vec4u(reader.readUint8(), reader.readUint8(), reader.readUint8(), reader.readUint8());
+    },
+    signature: { argTypes: [u32], returnType: vec4u },
+    codegenImpl: (_ctx, [e]) => stitch `unpack4xU8(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack2x16snorm-builtin
+ */
+export const unpack2x16snorm = dualImpl({
+    name: 'unpack2x16snorm',
+    normalImpl: (e) => {
+        const reader = readPacked(e);
+        return vec2f(Math.max(reader.readInt16() / 32767, -1), Math.max(reader.readInt16() / 32767, -1));
+    },
+    signature: { argTypes: [u32], returnType: vec2f },
+    codegenImpl: (_ctx, [e]) => stitch `unpack2x16snorm(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#unpack2x16unorm-builtin
+ */
+export const unpack2x16unorm = dualImpl({
+    name: 'unpack2x16unorm',
+    normalImpl: (e) => {
+        const reader = readPacked(e);
+        return vec2f(reader.readUint16() / 65535, reader.readUint16() / 65535);
+    },
+    signature: { argTypes: [u32], returnType: vec2f },
+    codegenImpl: (_ctx, [e]) => stitch `unpack2x16unorm(${e})`,
+    sideEffects: false,
+});
 /**
  * @privateRemarks
  * https://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
  */
 export const pack4x8unorm = dualImpl({
     name: 'pack4x8unorm',
-    normalImpl: (e) => {
-        const buffer = new ArrayBuffer(4);
-        const writer = new TB.BufferWriter(buffer);
-        writer.writeUint8(e.x * 255);
-        writer.writeUint8(e.y * 255);
-        writer.writeUint8(e.z * 255);
-        writer.writeUint8(e.w * 255);
-        const reader = new TB.BufferReader(buffer);
-        return u32(reader.readUint32());
-    },
+    normalImpl: (e) => writePacked((writer) => {
+        writer.writeUint8(Math.floor(0.5 + 255 * clampScalar(e.x, 0, 1)));
+        writer.writeUint8(Math.floor(0.5 + 255 * clampScalar(e.y, 0, 1)));
+        writer.writeUint8(Math.floor(0.5 + 255 * clampScalar(e.z, 0, 1)));
+        writer.writeUint8(Math.floor(0.5 + 255 * clampScalar(e.w, 0, 1)));
+    }),
     signature: { argTypes: [vec4f], returnType: u32 },
     codegenImpl: (_ctx, [e]) => stitch `pack4x8unorm(${e})`,
     sideEffects: false,
 });
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4x8snorm-builtin
+ */
+export const pack4x8snorm = dualImpl({
+    name: 'pack4x8snorm',
+    normalImpl: (e) => writePacked((writer) => {
+        writer.writeInt8(Math.floor(0.5 + 127 * clampScalar(e.x, -1, 1)));
+        writer.writeInt8(Math.floor(0.5 + 127 * clampScalar(e.y, -1, 1)));
+        writer.writeInt8(Math.floor(0.5 + 127 * clampScalar(e.z, -1, 1)));
+        writer.writeInt8(Math.floor(0.5 + 127 * clampScalar(e.w, -1, 1)));
+    }),
+    signature: { argTypes: [vec4f], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack4x8snorm(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xi8-builtin
+ */
+export const pack4xI8 = dualImpl({
+    name: 'pack4xI8',
+    normalImpl: (e) => writePacked((writer) => {
+        writer.writeInt8(e.x);
+        writer.writeInt8(e.y);
+        writer.writeInt8(e.z);
+        writer.writeInt8(e.w);
+    }),
+    signature: { argTypes: [vec4i], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack4xI8(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xu8-builtin
+ */
+export const pack4xU8 = dualImpl({
+    name: 'pack4xU8',
+    normalImpl: (e) => writePacked((writer) => {
+        writer.writeUint8(e.x);
+        writer.writeUint8(e.y);
+        writer.writeUint8(e.z);
+        writer.writeUint8(e.w);
+    }),
+    signature: { argTypes: [vec4u], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack4xU8(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xi8clamp-builtin
+ */
+export const pack4xI8Clamp = dualImpl({
+    name: 'pack4xI8Clamp',
+    normalImpl: (e) => writePacked((writer) => {
+        writer.writeInt8(clampScalar(e.x, -128, 127));
+        writer.writeInt8(clampScalar(e.y, -128, 127));
+        writer.writeInt8(clampScalar(e.z, -128, 127));
+        writer.writeInt8(clampScalar(e.w, -128, 127));
+    }),
+    signature: { argTypes: [vec4i], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack4xI8Clamp(${e})`,
+    sideEffects: false,
+});
+/**
+ * @privateRemarks
+ * https://www.w3.org/TR/WGSL/#pack4xu8clamp-builtin
+ */
+export const pack4xU8Clamp = dualImpl({
+    name: 'pack4xU8Clamp',
+    normalImpl: (e) => writePacked((writer) => {
+        writer.writeUint8(clampScalar(e.x, 0, 255));
+        writer.writeUint8(clampScalar(e.y, 0, 255));
+        writer.writeUint8(clampScalar(e.z, 0, 255));
+        writer.writeUint8(clampScalar(e.w, 0, 255));
+    }),
+    signature: { argTypes: [vec4u], returnType: u32 },
+    codegenImpl: (_ctx, [e]) => stitch `pack4xU8Clamp(${e})`,
+    sideEffects: false,
+});

package/std/subgroup.d.ts

@@ -40,4 +40,8 @@ export declare const subgroupShuffleDown: import("../types.ts").DualFn<IdentityN
 export declare const subgroupShuffleUp: import("../types.ts").DualFn<IdentityNumOrVecWithDelta>;
 export declare const subgroupShuffleXor: import("../types.ts").DualFn<IdentityNumOrVecWithMask>;
 export declare const subgroupXor: import("../types.ts").DualFn<IdentityIntNumOrVec>;
+export declare const quadBroadcast: import("../types.ts").DualFn<IdentityNumOrVecWithIdx>;
+export declare const quadSwapDiagonal: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const quadSwapX: import("../types.ts").DualFn<IdentityNumOrVec>;
+export declare const quadSwapY: import("../types.ts").DualFn<IdentityNumOrVec>;
 export {};