typegpu 0.10.1 → 0.10.2

package/std/operators.d.ts

@@ -0,0 +1,48 @@
+import { DualFn } from "../types.js";
+import { AnyMatInstance, AnyNumericVecInstance, mBaseForVec, vBaseForMat } from "../data/wgslTypes.js";
+
+//#region src/std/operators.d.ts
+type NumVec = AnyNumericVecInstance;
+type Mat = AnyMatInstance;
+declare function cpuAdd(lhs: number, rhs: number): number;
+declare function cpuAdd<T extends NumVec>(lhs: number, rhs: T): T;
+declare function cpuAdd<T extends NumVec>(lhs: T, rhs: number): T;
+declare function cpuAdd<T extends NumVec | Mat>(lhs: T, rhs: T): T;
+declare function cpuAdd<Lhs extends number | NumVec | Mat, Rhs extends (Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : Lhs extends Mat ? Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
+declare const add: DualFn<typeof cpuAdd>;
+declare function cpuSub(lhs: number, rhs: number): number;
+declare function cpuSub<T extends NumVec>(lhs: number, rhs: T): T;
+declare function cpuSub<T extends NumVec>(lhs: T, rhs: number): T;
+declare function cpuSub<T extends NumVec | Mat>(lhs: T, rhs: T): T;
+declare function cpuSub<Lhs extends number | NumVec | Mat, Rhs extends (Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : Lhs extends Mat ? Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
+declare const sub: DualFn<typeof cpuSub>;
+declare function cpuMul(lhs: number, rhs: number): number;
+declare function cpuMul<MV extends NumVec | Mat>(lhs: number, rhs: MV): MV;
+declare function cpuMul<MV extends NumVec | Mat>(lhs: MV, rhs: number): MV;
+declare function cpuMul<V extends NumVec>(lhs: V, rhs: V): V;
+declare function cpuMul<M extends Mat, V extends vBaseForMat<M>>(lhs: V, rhs: M): V;
+declare function cpuMul<M extends Mat, V extends vBaseForMat<M>>(lhs: M, rhs: V): V;
+declare function cpuMul<M extends Mat>(lhs: M, rhs: M): M;
+declare function cpuMul<Lhs extends number | NumVec | Mat, Rhs extends (Lhs extends number ? number | NumVec | Mat : Lhs extends NumVec ? number | Lhs | mBaseForVec<Lhs> : Lhs extends Mat ? number | vBaseForMat<Lhs> | Lhs : never)>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
+declare const mul: DualFn<typeof cpuMul>;
+declare function cpuDiv(lhs: number, rhs: number): number;
+declare function cpuDiv<T extends NumVec>(lhs: T, rhs: T): T;
+declare function cpuDiv<T extends NumVec>(lhs: number, rhs: T): T;
+declare function cpuDiv<T extends NumVec>(lhs: T, rhs: number): T;
+declare const div: DualFn<typeof cpuDiv>;
+type ModOverload = {
+  (a: number, b: number): number;
+  <T extends NumVec>(a: T, b: T): T;
+  <T extends NumVec>(a: number, b: T): T;
+  <T extends NumVec>(a: T, b: number): T;
+};
+/**
+ * @privateRemarks
+ * Both JS and WGSL implementations use truncated definition of modulo
+ */
+declare const mod: DualFn<ModOverload>;
+declare function cpuNeg(value: number): number;
+declare function cpuNeg<T extends NumVec>(value: T): T;
+declare const neg: DualFn<typeof cpuNeg>;
+//#endregion
+export { add, div, mod, mul, neg, sub };

package/std/operators.js

@@ -0,0 +1,153 @@
+import { isFloat32VecInstance, isMat, isMatInstance, isVec, isVecInstance } from "../data/wgslTypes.js";
+import { SignatureNotSupportedError } from "../errors.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { unify } from "../tgsl/conversion.js";
+import { abstractFloat, f16, f32 } from "../data/numeric.js";
+import { vecTypeToConstructor } from "../data/vector.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+import { VectorOps } from "../data/vectorOps.js";
+
+//#region src/std/operators.ts
+const getPrimitive = (t) => "primitive" in t ? t.primitive : t;
+const makeBinarySignature = (opts) => (lhs, rhs) => {
+	const { restrict } = opts ?? {};
+	const fail = (msg) => {
+		if (restrict) throw new SignatureNotSupportedError([lhs, rhs], restrict);
+		throw new Error(`Cannot apply operator to ${lhs.type} and ${rhs.type}: ${msg}`);
+	};
+	if (opts?.noMat && (isMat(lhs) || isMat(rhs))) return fail("matrices not supported");
+	const lhsC = isVec(lhs) || isMat(lhs);
+	const rhsC = isVec(rhs) || isMat(rhs);
+	if (!lhsC && !rhsC) {
+		const unified = unify([lhs, rhs], restrict);
+		if (!unified) return fail("incompatible scalar types");
+		return {
+			argTypes: unified,
+			returnType: unified[0]
+		};
+	}
+	if (lhsC && rhsC) {
+		if (opts?.matVecProduct && isVec(lhs) !== isVec(rhs)) return {
+			argTypes: [lhs, rhs],
+			returnType: isVec(lhs) ? lhs : rhs
+		};
+		if (lhs.type !== rhs.type) return fail("operands must have the same type");
+		return {
+			argTypes: [lhs, rhs],
+			returnType: lhs
+		};
+	}
+	const [scalar, composite] = lhsC ? [rhs, lhs] : [lhs, rhs];
+	const unified = unify([scalar], [getPrimitive(composite)]);
+	if (!unified) return fail(`scalar not convertible to ${getPrimitive(composite).type}`);
+	return {
+		argTypes: lhsC ? [lhs, unified[0]] : [unified[0], rhs],
+		returnType: composite
+	};
+};
+const binaryArithmeticSignature = makeBinarySignature();
+const binaryMulSignature = makeBinarySignature({ matVecProduct: true });
+const binaryDivSignature = makeBinarySignature({
+	noMat: true,
+	restrict: [
+		f32,
+		f16,
+		abstractFloat
+	]
+});
+function cpuAdd(lhs, rhs) {
+	if (typeof lhs === "number" && typeof rhs === "number") return lhs + rhs;
+	if (typeof lhs === "number" && isVecInstance(rhs)) return VectorOps.addMixed[rhs.kind](rhs, lhs);
+	if (isVecInstance(lhs) && typeof rhs === "number") return VectorOps.addMixed[lhs.kind](lhs, rhs);
+	if (isVecInstance(lhs) && isVecInstance(rhs) || isMatInstance(lhs) && isMatInstance(rhs)) return VectorOps.add[lhs.kind](lhs, rhs);
+	throw new Error("Add/Sub called with invalid arguments.");
+}
+const add = dualImpl({
+	name: "add",
+	signature: binaryArithmeticSignature,
+	normalImpl: cpuAdd,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} + ${rhs})`
+});
+function cpuSub(lhs, rhs) {
+	return cpuAdd(lhs, cpuMul(-1, rhs));
+}
+const sub = dualImpl({
+	name: "sub",
+	signature: binaryArithmeticSignature,
+	normalImpl: cpuSub,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} - ${rhs})`
+});
+function cpuMul(lhs, rhs) {
+	if (typeof lhs === "number" && typeof rhs === "number") return lhs * rhs;
+	if (typeof lhs === "number" && (isVecInstance(rhs) || isMatInstance(rhs))) return VectorOps.mulSxV[rhs.kind](lhs, rhs);
+	if ((isVecInstance(lhs) || isMatInstance(lhs)) && typeof rhs === "number") return VectorOps.mulSxV[lhs.kind](rhs, lhs);
+	if (isVecInstance(lhs) && isVecInstance(rhs)) return VectorOps.mulVxV[lhs.kind](lhs, rhs);
+	if (isFloat32VecInstance(lhs) && isMatInstance(rhs)) return VectorOps.mulVxM[rhs.kind](lhs, rhs);
+	if (isMatInstance(lhs) && isFloat32VecInstance(rhs)) return VectorOps.mulMxV[lhs.kind](lhs, rhs);
+	if (isMatInstance(lhs) && isMatInstance(rhs)) return VectorOps.mulVxV[lhs.kind](lhs, rhs);
+	throw new Error("Mul called with invalid arguments.");
+}
+const mul = dualImpl({
+	name: "mul",
+	signature: binaryMulSignature,
+	normalImpl: cpuMul,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} * ${rhs})`
+});
+function cpuDiv(lhs, rhs) {
+	if (typeof lhs === "number" && typeof rhs === "number") return lhs / rhs;
+	if (typeof lhs === "number" && isVecInstance(rhs)) {
+		const schema = vecTypeToConstructor[rhs.kind];
+		return VectorOps.div[rhs.kind](schema(lhs), rhs);
+	}
+	if (isVecInstance(lhs) && typeof rhs === "number") {
+		const schema = vecTypeToConstructor[lhs.kind];
+		return VectorOps.div[lhs.kind](lhs, schema(rhs));
+	}
+	if (isVecInstance(lhs) && isVecInstance(rhs)) return VectorOps.div[lhs.kind](lhs, rhs);
+	throw new Error("Div called with invalid arguments.");
+}
+const div = dualImpl({
+	name: "div",
+	signature: binaryDivSignature,
+	normalImpl: cpuDiv,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} / ${rhs})`,
+	ignoreImplicitCastWarning: true
+});
+/**
+* @privateRemarks
+* Both JS and WGSL implementations use truncated definition of modulo
+*/
+const mod = dualImpl({
+	name: "mod",
+	signature: binaryDivSignature,
+	normalImpl: ((a, b) => {
+		if (typeof a === "number" && typeof b === "number") return a % b;
+		if (typeof a === "number" && isVecInstance(b)) {
+			const schema = vecTypeToConstructor[b.kind];
+			return VectorOps.mod[b.kind](schema(a), b);
+		}
+		if (isVecInstance(a) && typeof b === "number") {
+			const schema = vecTypeToConstructor[a.kind];
+			return VectorOps.mod[a.kind](a, schema(b));
+		}
+		if (isVecInstance(a) && isVecInstance(b)) return VectorOps.mod[a.kind](a, b);
+		throw new Error("Mod called with invalid arguments, expected types: number or vector.");
+	}),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} % ${rhs})`
+});
+function cpuNeg(value) {
+	if (typeof value === "number") return -value;
+	return VectorOps.neg[value.kind](value);
+}
+const neg = dualImpl({
+	name: "neg",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: cpuNeg,
+	codegenImpl: (_ctx, [arg]) => stitch`-(${arg})`
+});
+
+//#endregion
+export { add, div, mod, mul, neg, sub };

package/std/packing.d.ts

@@ -0,0 +1,26 @@
+import { DualFn } from "../types.js";
+import { v2f, v4f } from "../data/wgslTypes.js";
+
+//#region src/std/packing.d.ts
+/**
+ * @privateRemarks
+ * https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
+ */
+declare const unpack2x16float: DualFn<(e: number) => v2f>;
+/**
+ * @privateRemarks
+ * https://gpuweb.github.io/gpuweb/wgsl/#pack2x16float-builtin
+ */
+declare const pack2x16float: DualFn<(e: v2f) => number>;
+/**
+ * @privateRemarks
+ * https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
+ */
+declare const unpack4x8unorm: DualFn<(e: number) => v4f>;
+/**
+ * @privateRemarks
+ * https://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
+ */
+declare const pack4x8unorm: DualFn<(e: v4f) => number>;
+//#endregion
+export { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm };

package/std/packing.js

@@ -0,0 +1,86 @@
+import { stitch } from "../core/resolve/stitch.js";
+import { u32 } from "../data/numeric.js";
+import { vec2f, vec4f } from "../data/vector.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+import * as TB from "typed-binary";
+
+//#region src/std/packing.ts
+/**
+* @privateRemarks
+* https://gpuweb.github.io/gpuweb/wgsl/#unpack2x16float-builtin
+*/
+const unpack2x16float = dualImpl({
+	name: "unpack2x16float",
+	normalImpl: (e) => {
+		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
+		new TB.BufferWriter(buffer).writeUint32(e);
+		const reader = new TB.BufferReader(buffer);
+		return vec2f(reader.readFloat16(), reader.readFloat16());
+	},
+	signature: {
+		argTypes: [u32],
+		returnType: vec2f
+	},
+	codegenImpl: (_ctx, [e]) => stitch`unpack2x16float(${e})`
+});
+/**
+* @privateRemarks
+* https://gpuweb.github.io/gpuweb/wgsl/#pack2x16float-builtin
+*/
+const pack2x16float = dualImpl({
+	name: "pack2x16float",
+	normalImpl: (e) => {
+		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
+		const writer = new TB.BufferWriter(buffer);
+		writer.writeFloat16(e.x);
+		writer.writeFloat16(e.y);
+		return u32(new TB.BufferReader(buffer).readUint32());
+	},
+	signature: {
+		argTypes: [vec2f],
+		returnType: u32
+	},
+	codegenImpl: (_ctx, [e]) => stitch`pack2x16float(${e})`
+});
+/**
+* @privateRemarks
+* https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
+*/
+const unpack4x8unorm = dualImpl({
+	name: "unpack4x8unorm",
+	normalImpl: (e) => {
+		const buffer = /* @__PURE__ */ new ArrayBuffer(4);
+		new TB.BufferWriter(buffer).writeUint32(e);
+		const reader = new TB.BufferReader(buffer);
+		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})`
+});
+/**
+* @privateRemarks
+* https://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
+*/
+const pack4x8unorm = dualImpl({
+	name: "pack4x8unorm",
+	normalImpl: (e) => {
+		const buffer = /* @__PURE__ */ 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);
+		return u32(new TB.BufferReader(buffer).readUint32());
+	},
+	signature: {
+		argTypes: [vec4f],
+		returnType: u32
+	},
+	codegenImpl: (_ctx, [e]) => stitch`pack4x8unorm(${e})`
+});
+
+//#endregion
+export { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm };

package/std/subgroup.d.ts

@@ -0,0 +1,47 @@
+import { DualFn } from "../types.js";
+import { AnyIntegerVecInstance, AnyNumericVecInstance, v4u } from "../data/wgslTypes.js";
+
+//#region src/std/subgroup.d.ts
+interface IdentityNumOrVec {
+  (e: number): number;
+  <T extends AnyNumericVecInstance>(e: T): T;
+}
+interface IdentityIntNumOrVec {
+  (e: number): number;
+  <T extends AnyIntegerVecInstance>(e: T): T;
+}
+interface IdentityNumOrVecWithIdx {
+  (e: number, index: number): number;
+  <T extends AnyNumericVecInstance>(e: T, index: number): T;
+}
+interface IdentityNumOrVecWithDelta {
+  (e: number, delta: number): number;
+  <T extends AnyNumericVecInstance>(e: T, delta: number): T;
+}
+interface IdentityNumOrVecWithMask {
+  (e: number, mask: number): number;
+  <T extends AnyNumericVecInstance>(e: T, mask: number): T;
+}
+declare const subgroupAdd: DualFn<IdentityNumOrVec>;
+declare const subgroupExclusiveAdd: DualFn<IdentityNumOrVec>;
+declare const subgroupInclusiveAdd: DualFn<IdentityNumOrVec>;
+declare const subgroupAll: DualFn<(e: boolean) => boolean>;
+declare const subgroupAnd: DualFn<IdentityIntNumOrVec>;
+declare const subgroupAny: DualFn<(e: boolean) => boolean>;
+declare const subgroupBallot: DualFn<(e: boolean) => v4u>;
+declare const subgroupBroadcast: DualFn<IdentityNumOrVecWithIdx>;
+declare const subgroupBroadcastFirst: DualFn<IdentityNumOrVec>;
+declare const subgroupElect: DualFn<() => boolean>;
+declare const subgroupMax: DualFn<IdentityNumOrVec>;
+declare const subgroupMin: DualFn<IdentityNumOrVec>;
+declare const subgroupMul: DualFn<IdentityNumOrVec>;
+declare const subgroupExclusiveMul: DualFn<IdentityNumOrVec>;
+declare const subgroupInclusiveMul: DualFn<IdentityNumOrVec>;
+declare const subgroupOr: DualFn<IdentityIntNumOrVec>;
+declare const subgroupShuffle: DualFn<IdentityNumOrVecWithIdx>;
+declare const subgroupShuffleDown: DualFn<IdentityNumOrVecWithDelta>;
+declare const subgroupShuffleUp: DualFn<IdentityNumOrVecWithDelta>;
+declare const subgroupShuffleXor: DualFn<IdentityNumOrVecWithMask>;
+declare const subgroupXor: DualFn<IdentityIntNumOrVec>;
+//#endregion
+export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor };

package/std/subgroup.js

@@ -0,0 +1,220 @@
+import { stitch } from "../core/resolve/stitch.js";
+import { unify } from "../tgsl/conversion.js";
+import { bool, i32, u32 } from "../data/numeric.js";
+import { vec4u } from "../data/vector.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+
+//#region src/std/subgroup.ts
+const errorMessage = "Subgroup operations can only be used in the GPU context.";
+const subgroupAdd = dualImpl({
+	name: "subgroupAdd",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupAdd(${arg})`
+});
+const subgroupExclusiveAdd = dualImpl({
+	name: "subgroupExclusiveAdd",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupExclusiveAdd(${arg})`
+});
+const subgroupInclusiveAdd = dualImpl({
+	name: "subgroupInclusiveAdd",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupInclusiveAdd(${arg})`
+});
+const subgroupAll = dualImpl({
+	name: "subgroupAll",
+	signature: {
+		argTypes: [bool],
+		returnType: bool
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupAll(${e})`
+});
+const subgroupAnd = dualImpl({
+	name: "subgroupAnd",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupAnd(${e})`
+});
+const subgroupAny = dualImpl({
+	name: "subgroupAny",
+	signature: {
+		argTypes: [bool],
+		returnType: bool
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupAny(${e})`
+});
+const subgroupBallot = dualImpl({
+	name: "subgroupBallot",
+	signature: {
+		argTypes: [bool],
+		returnType: vec4u
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupBallot(${e})`
+});
+const subgroupBroadcast = dualImpl({
+	name: "subgroupBroadcast",
+	signature: (...args) => {
+		const id = unify([args[1]], [i32, u32]);
+		if (!id) throw new Error(`subgroupBroadcast'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, index]) => stitch`subgroupBroadcast(${e}, ${index})`
+});
+const subgroupBroadcastFirst = dualImpl({
+	name: "subgroupBroadcastFirst",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupBroadcastFirst(${e})`
+});
+const subgroupElect = dualImpl({
+	name: "subgroupElect",
+	signature: {
+		argTypes: [],
+		returnType: bool
+	},
+	normalImpl: errorMessage,
+	codegenImpl: () => stitch`subgroupElect()`
+});
+const subgroupMax = dualImpl({
+	name: "subgroupMax",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupMax(${arg})`
+});
+const subgroupMin = dualImpl({
+	name: "subgroupMin",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupMin(${arg})`
+});
+const subgroupMul = dualImpl({
+	name: "subgroupMul",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupMul(${arg})`
+});
+const subgroupExclusiveMul = dualImpl({
+	name: "subgroupExclusiveMul",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupExclusiveMul(${arg})`
+});
+const subgroupInclusiveMul = dualImpl({
+	name: "subgroupInclusiveMul",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [arg]) => stitch`subgroupInclusiveMul(${arg})`
+});
+const subgroupOr = dualImpl({
+	name: "subgroupOr",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupOr(${e})`
+});
+const subgroupShuffle = dualImpl({
+	name: "subgroupShuffle",
+	signature: (...args) => {
+		const id = unify([args[1]], [i32, u32]);
+		if (!id) throw new Error(`subgroupShuffle'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, index]) => stitch`subgroupShuffle(${e}, ${index})`
+});
+const subgroupShuffleDown = dualImpl({
+	name: "subgroupShuffleDown",
+	signature: (...args) => {
+		const delta = unify([args[1]], [u32]);
+		if (!delta) throw new Error(`subgroupShuffleDown's second argument has to be compatible with u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], delta[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, delta]) => stitch`subgroupShuffleDown(${e}, ${delta})`
+});
+const subgroupShuffleUp = dualImpl({
+	name: "subgroupShuffleUp",
+	signature: (...args) => {
+		const delta = unify([args[1]], [u32]);
+		if (!delta) throw new Error(`subgroupShuffleUp's second argument has to be compatible with u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], delta[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, delta]) => stitch`subgroupShuffleUp(${e}, ${delta})`
+});
+const subgroupShuffleXor = dualImpl({
+	name: "subgroupShuffleXor",
+	signature: (...args) => {
+		const mask = unify([args[1]], [u32]);
+		if (!mask) throw new Error(`subgroupShuffleXor's second argument has to be compatible with u32. Got: ${args[1].type}`);
+		return {
+			argTypes: [args[0], mask[0]],
+			returnType: args[0]
+		};
+	},
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e, mask]) => stitch`subgroupShuffleXor(${e}, ${mask})`
+});
+const subgroupXor = dualImpl({
+	name: "subgroupXor",
+	signature: (arg) => ({
+		argTypes: [arg],
+		returnType: arg
+	}),
+	normalImpl: errorMessage,
+	codegenImpl: (_ctx, [e]) => stitch`subgroupXor(${e})`
+});
+
+//#endregion
+export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor };