typegpu 0.10.1 → 0.11.0-rc.1

package/std/operators.d.ts

@@ -0,0 +1,56 @@
+import { DualFn } from "../types.js";
+import { AnyIntegerVecInstance, AnyMatInstance, AnyNumericVecInstance, mBaseForVec, vBaseForMat, vecIToVecU } 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;
+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;
+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;
+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;
+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;
+declare function cpuNeg(value: number): number;
+declare function cpuNeg<T extends NumVec>(value: T): T;
+declare const neg: DualFn;
+declare function cpuBitShiftLeft(lhs: number, rhs: number): number;
+declare function cpuBitShiftLeft<T extends AnyIntegerVecInstance>(lhs: T, rhs: number): T;
+declare function cpuBitShiftLeft<T extends AnyIntegerVecInstance>(lhs: T, rhs: vecIToVecU<T>): T;
+declare const bitShiftLeft: DualFn;
+declare function cpuBitShiftRight(lhs: number, rhs: number): number;
+declare function cpuBitShiftRight<T extends AnyIntegerVecInstance>(lhs: T, rhs: number): T;
+declare function cpuBitShiftRight<T extends AnyIntegerVecInstance>(lhs: T, rhs: vecIToVecU<T>): T;
+declare const bitShiftRight: DualFn;
+//#endregion
+export { add, bitShiftLeft, bitShiftRight, div, mod, mul, neg, sub };

package/std/operators.js

@@ -0,0 +1,227 @@
+import { isFloat32VecInstance, isInteger32VecInstance, isMat, isMatInstance, isUint32VecInstance, 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, i32, u32 } from "../data/numeric.js";
+import { vec2i, vec2u, vec3i, vec3u, vec4i, vec4u, 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})`
+});
+const anyConcreteInteger = [
+	i32,
+	u32,
+	vec2i,
+	vec3i,
+	vec4i,
+	vec2u,
+	vec3u,
+	vec4u
+];
+const intVecToUnsignedVec = {
+	vec2i: vec2u,
+	vec2u,
+	vec3i: vec3u,
+	vec3u,
+	vec4i: vec4u,
+	vec4u
+};
+const bitShiftSignature = (lhs, rhs) => {
+	const lhsUnified = unify([lhs], anyConcreteInteger)?.[0];
+	if (!lhsUnified) throw new SignatureNotSupportedError([lhs], anyConcreteInteger);
+	let rhsType;
+	if (isVec(lhsUnified)) {
+		const cc = lhsUnified.componentCount;
+		const vecU = cc === 2 ? vec2u : cc === 3 ? vec3u : vec4u;
+		const rhsUnified = unify([rhs], [u32, vecU])?.[0];
+		if (!rhsUnified) throw new SignatureNotSupportedError([rhs], [u32, vecU]);
+		rhsType = rhsUnified;
+	} else rhsType = u32;
+	return {
+		argTypes: [lhsUnified, rhsType],
+		returnType: lhsUnified
+	};
+};
+function cpuBitShiftLeft(lhs, rhs) {
+	if (typeof lhs === "number" && typeof rhs === "number") return lhs << rhs;
+	if (isInteger32VecInstance(lhs) && isUint32VecInstance(rhs) && lhs.length == rhs.length) return VectorOps.bitShiftLeft[lhs.kind](lhs, rhs);
+	if (isInteger32VecInstance(lhs) && typeof rhs === "number") {
+		const rhsVec = intVecToUnsignedVec[lhs.kind](rhs);
+		return VectorOps.bitShiftLeft[lhs.kind](lhs, rhsVec);
+	}
+	throw new Error("bitShiftLeft called with invalid arguments, expected types: number or integer vector (rhs must be the same arity as lhs).");
+}
+const bitShiftLeft = dualImpl({
+	name: "bitShiftLeft",
+	signature: bitShiftSignature,
+	normalImpl: cpuBitShiftLeft,
+	codegenImpl: (_ctx, [lhs, rhs]) => {
+		if (isVec(lhs.dataType) && !isVec(rhs.dataType)) {
+			const cc = lhs.dataType.componentCount;
+			return stitch`(${lhs} << ${cc === 2 ? "vec2u" : cc === 3 ? "vec3u" : "vec4u"}(${rhs}))`;
+		}
+		return stitch`(${lhs} << ${rhs})`;
+	}
+});
+function cpuBitShiftRight(lhs, rhs) {
+	if (typeof lhs === "number" && typeof rhs === "number") return lhs >> rhs;
+	if (isInteger32VecInstance(lhs) && isUint32VecInstance(rhs) && lhs.length == rhs.length) return VectorOps.bitShiftRight[lhs.kind](lhs, rhs);
+	if (isInteger32VecInstance(lhs) && typeof rhs === "number") {
+		const rhsVec = intVecToUnsignedVec[lhs.kind](rhs);
+		return VectorOps.bitShiftRight[lhs.kind](lhs, rhsVec);
+	}
+	throw new Error("bitShiftRight called with invalid arguments, expected types: number or integer vector (rhs must be the same arity as lhs).");
+}
+const bitShiftRight = dualImpl({
+	name: "bitShiftRight",
+	signature: bitShiftSignature,
+	normalImpl: cpuBitShiftRight,
+	codegenImpl: (_ctx, [lhs, rhs]) => {
+		if (isVec(lhs.dataType) && !isVec(rhs.dataType)) {
+			const cc = lhs.dataType.componentCount;
+			return stitch`(${lhs} >> ${cc === 2 ? "vec2u" : cc === 3 ? "vec3u" : "vec4u"}(${rhs}))`;
+		}
+		return stitch`(${lhs} >> ${rhs})`;
+	}
+});
+//#endregion
+export { add, bitShiftLeft, bitShiftRight, 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;
+/**
+ * @privateRemarks
+ * https://gpuweb.github.io/gpuweb/wgsl/#pack2x16float-builtin
+ */
+declare const pack2x16float: DualFn;
+/**
+ * @privateRemarks
+ * https://gpuweb.github.io/gpuweb/wgsl/#unpack4x8unorm-builtin
+ */
+declare const unpack4x8unorm: DualFn;
+/**
+ * @privateRemarks
+ * https://gpuweb.github.io/gpuweb/wgsl/#pack4x8unorm-builtin
+ */
+declare const pack4x8unorm: DualFn;
+//#endregion
+export { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm };

package/std/packing.js

@@ -0,0 +1,84 @@
+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/range.d.ts

@@ -0,0 +1,24 @@
+import { TgpuComptime } from "../core/function/comptime.js";
+//#region src/std/range.d.ts
+interface TgpuRange extends Array<number> {
+  start: number;
+  end: number;
+  step: number;
+}
+/**
+ * Returns an array of values between `start` (inclusive) and `end` (exclusive) with the given `step`.
+ *
+ * If only one argument is provided, it is interpreted as `end`, with `start=0` and `step=1`.
+ *
+ * ```ts
+ * let result = d.f32(1);
+ * for (const i of std.range(5)) {
+ *   result *= i + 1;
+ * }
+ * ```
+ *
+ * Can also be combined with `tgpu.unroll` to unroll a specific number of iterations.
+ */
+declare const range: TgpuComptime;
+//#endregion
+export { range };

package/std/range.js

@@ -0,0 +1,38 @@
+import { comptime } from "../core/function/comptime.js";
+//#region src/std/range.ts
+/**
+* Returns an array of values between `start` (inclusive) and `end` (exclusive) with the given `step`.
+*
+* If only one argument is provided, it is interpreted as `end`, with `start=0` and `step=1`.
+*
+* ```ts
+* let result = d.f32(1);
+* for (const i of std.range(5)) {
+*   result *= i + 1;
+* }
+* ```
+*
+* Can also be combined with `tgpu.unroll` to unroll a specific number of iterations.
+*/
+const range = comptime((start, end, step = 1) => {
+	if (end === void 0) {
+		end = start;
+		start = 0;
+	}
+	if (!Number.isInteger(start)) throw new Error(`'start' must be an integer, got ${start}`);
+	if (!Number.isInteger(end)) throw new Error(`'end' must be an integer, got ${end}`);
+	if (!Number.isInteger(step) || step === 0) throw new Error(`'step' must be a non-zero integer, got ${step}`);
+	const result = [];
+	result.start = start;
+	result.end = end;
+	result.step = step;
+	if (Math.sign(step) !== Math.sign(end - start)) return result;
+	if (step > 0) for (let i = start; i < end; i += step) result.push(i);
+	if (step < 0) for (let i = start; i > end; i += step) result.push(i);
+	return result;
+});
+function isTgpuRange(value) {
+	return Array.isArray(value) && "start" in value && "end" in value && "step" in value;
+}
+//#endregion
+export { isTgpuRange, range };

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;
+declare const subgroupExclusiveAdd: DualFn;
+declare const subgroupInclusiveAdd: DualFn;
+declare const subgroupAll: DualFn;
+declare const subgroupAnd: DualFn;
+declare const subgroupAny: DualFn;
+declare const subgroupBallot: DualFn;
+declare const subgroupBroadcast: DualFn;
+declare const subgroupBroadcastFirst: DualFn;
+declare const subgroupElect: DualFn;
+declare const subgroupMax: DualFn;
+declare const subgroupMin: DualFn;
+declare const subgroupMul: DualFn;
+declare const subgroupExclusiveMul: DualFn;
+declare const subgroupInclusiveMul: DualFn;
+declare const subgroupOr: DualFn;
+declare const subgroupShuffle: DualFn;
+declare const subgroupShuffleDown: DualFn;
+declare const subgroupShuffleUp: DualFn;
+declare const subgroupShuffleXor: DualFn;
+declare const subgroupXor: DualFn;
+//#endregion
+export { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor };