typegpu 0.10.0 → 0.10.2

package/std/boolean.d.ts

@@ -0,0 +1,127 @@
+import { DualFn } from "../types.js";
+import { AnyBooleanVecInstance, AnyFloatVecInstance, AnyNumericVecInstance, AnyVec2Instance, AnyVec3Instance, AnyVecInstance, v2b, v3b, v4b } from "../data/wgslTypes.js";
+
+//#region src/std/boolean.d.ts
+/**
+ * Checks whether `lhs == rhs` on all components.
+ * Equivalent to `all(eq(lhs, rhs))`.
+ * @example
+ * allEq(vec2f(0.0, 1.0), vec2f(0.0, 2.0)) // returns false
+ * allEq(vec3u(0, 1, 2), vec3u(0, 1, 2)) // returns true
+ */
+declare const allEq: DualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => boolean)>;
+/**
+ * Checks **component-wise** whether `lhs == rhs`.
+ * This function does **not** return `bool`, for that use-case, wrap the result in `all`, or use `allEq`.
+ * @example
+ * eq(vec2f(0.0, 1.0), vec2f(0.0, 2.0)) // returns vec2b(true, false)
+ * eq(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(false, true, false)
+ * all(eq(vec4i(4, 3, 2, 1), vec4i(4, 3, 2, 1))) // returns true
+ * allEq(vec4i(4, 3, 2, 1), vec4i(4, 3, 2, 1)) // returns true
+ */
+declare const eq: DualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+/**
+ * Checks **component-wise** whether `lhs != rhs`.
+ * This function does **not** return `bool`, for that use-case, wrap the result in `any`.
+ * @example
+ * ne(vec2f(0.0, 1.0), vec2f(0.0, 2.0)) // returns vec2b(false, true)
+ * ne(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(true, false, true)
+ * any(ne(vec4i(4, 3, 2, 1), vec4i(4, 2, 2, 1))) // returns true
+ */
+declare const ne: DualFn<(<T extends AnyVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+/**
+ * Checks **component-wise** whether `lhs < rhs`.
+ * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
+ * @example
+ * lt(vec2f(0.0, 0.0), vec2f(0.0, 1.0)) // returns vec2b(false, true)
+ * lt(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(true, false, false)
+ * all(lt(vec4i(1, 2, 3, 4), vec4i(2, 3, 4, 5))) // returns true
+ */
+declare const lt: DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+/**
+ * Checks **component-wise** whether `lhs <= rhs`.
+ * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
+ * @example
+ * le(vec2f(0.0, 0.0), vec2f(0.0, 1.0)) // returns vec2b(true, true)
+ * le(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(true, true, false)
+ * all(le(vec4i(1, 2, 3, 4), vec4i(2, 3, 3, 5))) // returns true
+ */
+declare const le: DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+/**
+ * Checks **component-wise** whether `lhs > rhs`.
+ * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
+ * @example
+ * gt(vec2f(0.0, 0.0), vec2f(0.0, 1.0)) // returns vec2b(false, false)
+ * gt(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(false, false, true)
+ * all(gt(vec4i(2, 3, 4, 5), vec4i(1, 2, 3, 4))) // returns true
+ */
+declare const gt: DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+/**
+ * Checks **component-wise** whether `lhs >= rhs`.
+ * This function does **not** return `bool`, for that use-case, wrap the result in `all`.
+ * @example
+ * ge(vec2f(0.0, 0.0), vec2f(0.0, 1.0)) // returns vec2b(true, false)
+ * ge(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(false, true, true)
+ * all(ge(vec4i(2, 2, 4, 5), vec4i(1, 2, 3, 4))) // returns true
+ */
+declare const ge: DualFn<(<T extends AnyNumericVecInstance>(lhs: T, rhs: T) => T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)>;
+/**
+ * Returns **component-wise** `!value`.
+ * @example
+ * not(vec2b(false, true)) // returns vec2b(true, false)
+ * not(vec3b(true, true, false)) // returns vec3b(false, false, true)
+ */
+declare const not: DualFn<(<T extends AnyBooleanVecInstance>(value: T) => T)>;
+/**
+ * Returns **component-wise** logical `or` result.
+ * @example
+ * or(vec2b(false, true), vec2b(false, false)) // returns vec2b(false, true)
+ * or(vec3b(true, true, false), vec3b(false, true, false)) // returns vec3b(true, true, false)
+ */
+declare const or: DualFn<(<T extends AnyBooleanVecInstance>(lhs: T, rhs: T) => T)>;
+/**
+ * Returns **component-wise** logical `and` result.
+ * @example
+ * and(vec2b(false, true), vec2b(true, true)) // returns vec2b(false, true)
+ * and(vec3b(true, true, false), vec3b(false, true, false)) // returns vec3b(false, true, false)
+ */
+declare const and: DualFn<(<T extends AnyBooleanVecInstance>(lhs: T, rhs: T) => T)>;
+/**
+ * Returns `true` if each component of `value` is true.
+ * @example
+ * all(vec2b(false, true)) // returns false
+ * all(vec3b(true, true, true)) // returns true
+ */
+declare const all: DualFn<(value: AnyBooleanVecInstance) => boolean>;
+/**
+ * Returns `true` if any component of `value` is true.
+ * @example
+ * any(vec2b(false, true)) // returns true
+ * any(vec3b(false, false, false)) // returns false
+ */
+declare const any: DualFn<(value: AnyBooleanVecInstance) => boolean>;
+/**
+ * Checks whether the given elements differ by at most the `precision` value.
+ * Checks all elements of `lhs` and `rhs` if arguments are vectors.
+ * @example
+ * isCloseTo(0, 0.1) // returns false
+ * isCloseTo(vec3f(0, 0, 0), vec3f(0.002, -0.009, 0)) // returns true
+ *
+ * @param {number} precision argument that specifies the maximum allowed difference, 0.01 by default.
+ */
+declare const isCloseTo: DualFn<(<T extends AnyFloatVecInstance | number>(lhs: T, rhs: T, precision?: number) => boolean)>;
+declare function cpuSelect(f: boolean, t: boolean, cond: boolean): boolean;
+declare function cpuSelect(f: number, t: number, cond: boolean): number;
+declare function cpuSelect<T extends AnyVecInstance>(f: T, t: T, cond: boolean | (T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b)): T;
+/**
+ * Returns `t` if `cond` is `true`, and `f` otherwise.
+ * Component-wise if `cond` is a vector.
+ * @example
+ * select(1, 2, false) // returns 1
+ * select(1, 2, true) // returns 2
+ * select(vec2i(1, 2), vec2i(3, 4), true) // returns vec2i(3, 4)
+ * select(vec2i(1, 2), vec2i(3, 4), vec2b(false, true)) // returns vec2i(1, 4)
+ */
+declare const select: DualFn<typeof cpuSelect>;
+//#endregion
+export { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select };

package/std/boolean.js

@@ -0,0 +1,274 @@
+import { isVecInstance } from "../data/wgslTypes.js";
+import { isSnippetNumeric, snip } from "../data/snippet.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { unify } from "../tgsl/conversion.js";
+import { bool, f32 } from "../data/numeric.js";
+import { vec2b, vec3b, vec4b } from "../data/vector.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+import { VectorOps } from "../data/vectorOps.js";
+import { sub } from "./operators.js";
+
+//#region src/std/boolean.ts
+function correspondingBooleanVectorSchema(dataType) {
+	if (dataType.type.includes("2")) return vec2b;
+	if (dataType.type.includes("3")) return vec3b;
+	return vec4b;
+}
+/**
+* Checks whether `lhs == rhs` on all components.
+* Equivalent to `all(eq(lhs, rhs))`.
+* @example
+* allEq(vec2f(0.0, 1.0), vec2f(0.0, 2.0)) // returns false
+* allEq(vec3u(0, 1, 2), vec3u(0, 1, 2)) // returns true
+*/
+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})`
+});
+const cpuEq = (lhs, rhs) => VectorOps.eq[lhs.kind](lhs, rhs);
+/**
+* Checks **component-wise** whether `lhs == rhs`.
+* This function does **not** return `bool`, for that use-case, wrap the result in `all`, or use `allEq`.
+* @example
+* eq(vec2f(0.0, 1.0), vec2f(0.0, 2.0)) // returns vec2b(true, false)
+* eq(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(false, true, false)
+* all(eq(vec4i(4, 3, 2, 1), vec4i(4, 3, 2, 1))) // returns true
+* allEq(vec4i(4, 3, 2, 1), vec4i(4, 3, 2, 1)) // returns true
+*/
+const eq = dualImpl({
+	name: "eq",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: correspondingBooleanVectorSchema(argTypes[0])
+	}),
+	normalImpl: cpuEq,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} == ${rhs})`
+});
+/**
+* Checks **component-wise** whether `lhs != rhs`.
+* This function does **not** return `bool`, for that use-case, wrap the result in `any`.
+* @example
+* ne(vec2f(0.0, 1.0), vec2f(0.0, 2.0)) // returns vec2b(false, true)
+* ne(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(true, false, true)
+* any(ne(vec4i(4, 3, 2, 1), vec4i(4, 2, 2, 1))) // returns true
+*/
+const ne = dualImpl({
+	name: "ne",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: correspondingBooleanVectorSchema(argTypes[0])
+	}),
+	normalImpl: (lhs, rhs) => cpuNot(cpuEq(lhs, rhs)),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} != ${rhs})`
+});
+const cpuLt = (lhs, rhs) => VectorOps.lt[lhs.kind](lhs, rhs);
+/**
+* Checks **component-wise** whether `lhs < rhs`.
+* This function does **not** return `bool`, for that use-case, wrap the result in `all`.
+* @example
+* lt(vec2f(0.0, 0.0), vec2f(0.0, 1.0)) // returns vec2b(false, true)
+* lt(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(true, false, false)
+* all(lt(vec4i(1, 2, 3, 4), vec4i(2, 3, 4, 5))) // returns true
+*/
+const lt = dualImpl({
+	name: "lt",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: correspondingBooleanVectorSchema(argTypes[0])
+	}),
+	normalImpl: cpuLt,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} < ${rhs})`
+});
+/**
+* Checks **component-wise** whether `lhs <= rhs`.
+* This function does **not** return `bool`, for that use-case, wrap the result in `all`.
+* @example
+* le(vec2f(0.0, 0.0), vec2f(0.0, 1.0)) // returns vec2b(true, true)
+* le(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(true, true, false)
+* all(le(vec4i(1, 2, 3, 4), vec4i(2, 3, 3, 5))) // returns true
+*/
+const le = dualImpl({
+	name: "le",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: correspondingBooleanVectorSchema(argTypes[0])
+	}),
+	normalImpl: (lhs, rhs) => cpuOr(cpuLt(lhs, rhs), cpuEq(lhs, rhs)),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} <= ${rhs})`
+});
+/**
+* Checks **component-wise** whether `lhs > rhs`.
+* This function does **not** return `bool`, for that use-case, wrap the result in `all`.
+* @example
+* gt(vec2f(0.0, 0.0), vec2f(0.0, 1.0)) // returns vec2b(false, false)
+* gt(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(false, false, true)
+* all(gt(vec4i(2, 3, 4, 5), vec4i(1, 2, 3, 4))) // returns true
+*/
+const gt = dualImpl({
+	name: "gt",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: correspondingBooleanVectorSchema(argTypes[0])
+	}),
+	normalImpl: (lhs, rhs) => cpuAnd(cpuNot(cpuLt(lhs, rhs)), cpuNot(cpuEq(lhs, rhs))),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} > ${rhs})`
+});
+/**
+* Checks **component-wise** whether `lhs >= rhs`.
+* This function does **not** return `bool`, for that use-case, wrap the result in `all`.
+* @example
+* ge(vec2f(0.0, 0.0), vec2f(0.0, 1.0)) // returns vec2b(true, false)
+* ge(vec3u(0, 1, 2), vec3u(2, 1, 0)) // returns vec3b(false, true, true)
+* all(ge(vec4i(2, 2, 4, 5), vec4i(1, 2, 3, 4))) // returns true
+*/
+const ge = dualImpl({
+	name: "ge",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: correspondingBooleanVectorSchema(argTypes[0])
+	}),
+	normalImpl: (lhs, rhs) => cpuNot(cpuLt(lhs, rhs)),
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} >= ${rhs})`
+});
+const cpuNot = (value) => VectorOps.neg[value.kind](value);
+/**
+* Returns **component-wise** `!value`.
+* @example
+* not(vec2b(false, true)) // returns vec2b(true, false)
+* not(vec3b(true, true, false)) // returns vec3b(false, false, true)
+*/
+const not = dualImpl({
+	name: "not",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: argTypes[0]
+	}),
+	normalImpl: cpuNot,
+	codegenImpl: (_ctx, [arg]) => stitch`!(${arg})`
+});
+const cpuOr = (lhs, rhs) => VectorOps.or[lhs.kind](lhs, rhs);
+/**
+* Returns **component-wise** logical `or` result.
+* @example
+* or(vec2b(false, true), vec2b(false, false)) // returns vec2b(false, true)
+* or(vec3b(true, true, false), vec3b(false, true, false)) // returns vec3b(true, true, false)
+*/
+const or = dualImpl({
+	name: "or",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: argTypes[0]
+	}),
+	normalImpl: cpuOr,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} | ${rhs})`
+});
+const cpuAnd = (lhs, rhs) => cpuNot(cpuOr(cpuNot(lhs), cpuNot(rhs)));
+/**
+* Returns **component-wise** logical `and` result.
+* @example
+* and(vec2b(false, true), vec2b(true, true)) // returns vec2b(false, true)
+* and(vec3b(true, true, false), vec3b(false, true, false)) // returns vec3b(false, true, false)
+*/
+const and = dualImpl({
+	name: "and",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: argTypes[0]
+	}),
+	normalImpl: cpuAnd,
+	codegenImpl: (_ctx, [lhs, rhs]) => stitch`(${lhs} & ${rhs})`
+});
+const cpuAll = (value) => VectorOps.all[value.kind](value);
+/**
+* Returns `true` if each component of `value` is true.
+* @example
+* all(vec2b(false, true)) // returns false
+* all(vec3b(true, true, true)) // returns true
+*/
+const all = dualImpl({
+	name: "all",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: bool
+	}),
+	normalImpl: cpuAll,
+	codegenImpl: (_ctx, [value]) => stitch`all(${value})`
+});
+/**
+* Returns `true` if any component of `value` is true.
+* @example
+* any(vec2b(false, true)) // returns true
+* any(vec3b(false, false, false)) // returns false
+*/
+const any = dualImpl({
+	name: "any",
+	signature: (...argTypes) => ({
+		argTypes,
+		returnType: bool
+	}),
+	normalImpl: (value) => !cpuAll(cpuNot(value)),
+	codegenImpl: (_ctx, [arg]) => stitch`any(${arg})`
+});
+/**
+* Checks whether the given elements differ by at most the `precision` value.
+* Checks all elements of `lhs` and `rhs` if arguments are vectors.
+* @example
+* isCloseTo(0, 0.1) // returns false
+* isCloseTo(vec3f(0, 0, 0), vec3f(0.002, -0.009, 0)) // returns true
+*
+* @param {number} precision argument that specifies the maximum allowed difference, 0.01 by default.
+*/
+const isCloseTo = dualImpl({
+	name: "isCloseTo",
+	signature: (...args) => ({
+		argTypes: args,
+		returnType: bool
+	}),
+	normalImpl: (lhs, rhs, precision = .01) => {
+		if (typeof lhs === "number" && typeof rhs === "number") return Math.abs(lhs - rhs) < precision;
+		if (isVecInstance(lhs) && isVecInstance(rhs)) return VectorOps.isCloseToZero[lhs.kind](sub(lhs, rhs), precision);
+		return false;
+	},
+	codegenImpl: (_ctx, [lhs, rhs, precision = snip(.01, f32, "constant")]) => {
+		if (isSnippetNumeric(lhs) && isSnippetNumeric(rhs)) return stitch`(abs(f32(${lhs}) - f32(${rhs})) <= ${precision})`;
+		if (!isSnippetNumeric(lhs) && !isSnippetNumeric(rhs)) return stitch`all(abs(${lhs} - ${rhs}) <= (${lhs} - ${lhs}) + ${precision})`;
+		return "false";
+	}
+});
+function cpuSelect(f, t, cond) {
+	if (typeof cond === "boolean") return cond ? t : f;
+	return VectorOps.select[f.kind](f, t, cond);
+}
+/**
+* Returns `t` if `cond` is `true`, and `f` otherwise.
+* Component-wise if `cond` is a vector.
+* @example
+* select(1, 2, false) // returns 1
+* select(1, 2, true) // returns 2
+* select(vec2i(1, 2), vec2i(3, 4), true) // returns vec2i(3, 4)
+* select(vec2i(1, 2), vec2i(3, 4), vec2b(false, true)) // returns vec2i(1, 4)
+*/
+const select = dualImpl({
+	name: "select",
+	signature: (f, t, cond) => {
+		const [uf, ut] = unify([f, t]) ?? [f, t];
+		return {
+			argTypes: [
+				uf,
+				ut,
+				cond
+			],
+			returnType: uf
+		};
+	},
+	normalImpl: cpuSelect,
+	codegenImpl: (_ctx, [f, t, cond]) => stitch`select(${f}, ${t}, ${cond})`
+});
+
+//#endregion
+export { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select };

package/std/derivative.d.ts

@@ -0,0 +1,16 @@
+import { DualFn } from "../types.js";
+import { AnyFloat32VecInstance } from "../data/wgslTypes.js";
+
+//#region src/std/derivative.d.ts
+type DerivativeSignature = ((value: number) => number) & (<T extends AnyFloat32VecInstance>(value: T) => T);
+declare const dpdx: DualFn<DerivativeSignature>;
+declare const dpdxCoarse: DualFn<DerivativeSignature>;
+declare const dpdxFine: DualFn<DerivativeSignature>;
+declare const dpdy: DualFn<DerivativeSignature>;
+declare const dpdyCoarse: DualFn<DerivativeSignature>;
+declare const dpdyFine: DualFn<DerivativeSignature>;
+declare const fwidth: DualFn<DerivativeSignature>;
+declare const fwidthCoarse: DualFn<DerivativeSignature>;
+declare const fwidthFine: DualFn<DerivativeSignature>;
+//#endregion
+export { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthCoarse, fwidthFine };

package/std/derivative.js

@@ -0,0 +1,89 @@
+import { stitch } from "../core/resolve/stitch.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+
+//#region src/std/derivative.ts
+const derivativeNormalError = "Derivative builtins are not allowed on the CPU";
+const dpdx = dualImpl({
+	name: "dpdx",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdx(${value})`
+});
+const dpdxCoarse = dualImpl({
+	name: "dpdxCoarse",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdxCoarse(${value})`
+});
+const dpdxFine = dualImpl({
+	name: "dpdxFine",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdxFine(${value})`
+});
+const dpdy = dualImpl({
+	name: "dpdy",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdy(${value})`
+});
+const dpdyCoarse = dualImpl({
+	name: "dpdyCoarse",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdyCoarse(${value})`
+});
+const dpdyFine = dualImpl({
+	name: "dpdyFine",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`dpdyFine(${value})`
+});
+const fwidth = dualImpl({
+	name: "fwidth",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`fwidth(${value})`
+});
+const fwidthCoarse = dualImpl({
+	name: "fwidthCoarse",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`fwidthCoarse(${value})`
+});
+const fwidthFine = dualImpl({
+	name: "fwidthFine",
+	normalImpl: derivativeNormalError,
+	signature: (value) => ({
+		argTypes: [value],
+		returnType: value
+	}),
+	codegenImpl: (_ctx, [value]) => stitch`fwidthFine(${value})`
+});
+
+//#endregion
+export { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthCoarse, fwidthFine };

package/std/discard.d.ts

@@ -0,0 +1,6 @@
+import { DualFn } from "../types.js";
+
+//#region src/std/discard.d.ts
+declare const discard: DualFn<() => never>;
+//#endregion
+export { discard };

package/std/discard.js

@@ -0,0 +1,16 @@
+import { Void } from "../data/wgslTypes.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+
+//#region src/std/discard.ts
+const discard = dualImpl({
+	name: "discard",
+	normalImpl: "`discard` relies on GPU resources and cannot be executed outside of a draw call",
+	signature: {
+		argTypes: [],
+		returnType: Void
+	},
+	codegenImpl: () => "discard;"
+});
+
+//#endregion
+export { discard };

package/std/extensions.d.ts

@@ -0,0 +1,8 @@
+import { WgslExtension } from "../wgslExtensions.js";
+import { TgpuComptime } from "../core/function/comptime.js";
+import "../indexNamedExports.js";
+
+//#region src/std/extensions.d.ts
+declare const extensionEnabled: TgpuComptime<(extensionName: WgslExtension) => boolean>;
+//#endregion
+export { extensionEnabled };

package/std/extensions.js

@@ -0,0 +1,14 @@
+import { getResolutionCtx } from "../execMode.js";
+import { comptime } from "../core/function/comptime.js";
+import { wgslExtensions } from "../wgslExtensions.js";
+
+//#region src/std/extensions.ts
+const extensionEnabled = comptime((extensionName) => {
+	const resolutionCtx = getResolutionCtx();
+	if (!resolutionCtx) throw new Error("Functions using `extensionEnabled` cannot be called directly. Either generate WGSL from them, or use tgpu['~unstable'].simulate(...)");
+	if (typeof extensionName !== "string" || !wgslExtensions.includes(extensionName)) throw new Error(`extensionEnabled has to be called with a string literal representing a valid WGSL extension name. Got: '${extensionName}'`);
+	return (resolutionCtx.enableExtensions ?? []).includes(extensionName);
+});
+
+//#endregion
+export { extensionEnabled };

package/std/index.d.ts

@@ -1,9 +1,21 @@
-import { $ as dpdyFine, $t as countOneBits, A as subgroupShuffleUp, An as quantizeToF16, At as rotateY4, B as textureSampleCompareLevel, Bn as smoothstep, Bt as abs, C as subgroupInclusiveMul, Cn as log2, Ct as le, D as subgroupOr, Dn as modf, Dt as or, E as subgroupMul, En as mix, Et as not, F as textureLoad, Fn as round, Ft as div, G as unpack2x16float, Gn as transpose, Gt as atan, H as textureStore, Hn as step, Ht as acosh, I as textureSample, In as saturate, It as mod, J as dpdx, Jt as ceil, K as unpack4x8unorm, Kn as trunc, Kt as atan2, L as textureSampleBaseClampToEdge, Ln as sign, Lt as mul, M as subgroupXor, Mn as reflect, Mt as scale4, N as textureDimensions, Nn as refract, Nt as translate4, O as subgroupShuffle, On as normalize, Ot as select, P as textureGather, Pn as reverseBits, Pt as add, Q as dpdyCoarse, Qt as countLeadingZeros, R as textureSampleBias, Rn as sin, Rt as neg, S as subgroupInclusiveAdd, Sn as log, St as isCloseTo, T as subgroupMin, Tn as min, Tt as ne, U as pack2x16float, Un as tan, Ut as asin, V as textureSampleLevel, Vn as sqrt, Vt as acos, W as pack4x8unorm, Wn as tanh, Wt as asinh, X as dpdxFine, Xt as cos, Y as dpdxCoarse, Yt as clamp, Z as dpdy, Zt as cosh, _ as subgroupBroadcast, _n as frexp, _t as and, an as dot, at as atomicLoad, b as subgroupExclusiveAdd, bn as ldexp, bt as ge, cn as exp, cr as rotationY4, ct as atomicOr, d as extensionEnabled, dn as faceForward, dr as translation4, dt as atomicXor, en as countTrailingZeros, er as identity2, et as fwidth, f as subgroupAdd, fn as firstLeadingBit, ft as storageBarrier, g as subgroupBallot, gn as fract, gt as allEq, h as subgroupAny, hn as fma, ht as all, in as distance, it as atomicAnd, j as subgroupShuffleXor, jn as radians, jt as rotateZ4, k as subgroupShuffleDown, kn as pow, kt as rotateX4, l as bitcastU32toF32, ln as exp2, lr as rotationZ4, lt as atomicStore, m as subgroupAnd, mn as floor, mt as workgroupBarrier, nn as degrees, nr as identity4, nt as fwidthFine, on as dot4I8Packed, ot as atomicMax, p as subgroupAll, pn as firstTrailingBit, pt as textureBarrier, q as arrayLength, qn as discard, qt as atanh, rn as determinant, rt as atomicAdd, sn as dot4U8Packed, sr as rotationX4, st as atomicMin, tn as cross, tr as identity3, tt as fwidthCoarse, u as bitcastU32toI32, un as extractBits, ur as scaling4, ut as atomicSub, v as subgroupBroadcastFirst, vn as insertBits, vt as any, w as subgroupMax, wn as max, wt as lt, x as subgroupExclusiveMul, xn as length, xt as gt, y as subgroupElect, yn as inverseSqrt, yt as eq, z as textureSampleCompare, zn as sinh, zt as sub } from "../indexNamedExports-Cdy7USiY.js";
+import { identity2, identity3, identity4, rotationX4, rotationY4, rotationZ4, scaling4, translation4 } from "../data/matrix.js";
+import { discard } from "./discard.js";
+import { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc } from "./numeric.js";
+import { add, div, mod, mul, neg, sub } from "./operators.js";
+import { rotateX4, rotateY4, rotateZ4, scale4, translate4 } from "./matrix.js";
+import { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select } from "./boolean.js";
+import { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier } from "./atomic.js";
+import { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthCoarse, fwidthFine } from "./derivative.js";
+import { arrayLength } from "./array.js";
+import { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm } from "./packing.js";
+import { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore } from "./texture.js";
+import { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor } from "./subgroup.js";
+import { extensionEnabled } from "./extensions.js";
+import { bitcastU32toF32, bitcastU32toI32 } from "./bitcast.js";
 
 //#region src/std/index.d.ts
 declare namespace index_d_exports {
   export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
 }
 //#endregion
-export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, index_d_exports as t, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
-//# sourceMappingURL=index.d.ts.map
+export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, index_d_exports, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };

package/std/index.js

@@ -1,6 +1,18 @@
-import { t as __exportAll } from "../chunk-BYypO7fO.js";
-import { C as translation4, S as scaling4, a as neg, b as rotationY4, f as identity2, i as mul, m as identity4, n as div, o as sub, p as identity3, r as mod, t as add, x as rotationZ4, y as rotationX4 } from "../operators-HTxa_0k9.js";
-import { $ as workgroupBarrier, $t as extractBits, A as textureSampleCompareLevel, An as sqrt, At as acos, B as fwidthCoarse, Bt as cosh, C as textureDimensions, Cn as reverseBits, Ct as pack4x8unorm, D as textureSampleBaseClampToEdge, Dn as sin, Dt as bitcastU32toI32, E as textureSample, En as sign, Et as bitcastU32toF32, F as dpdxFine, Fn as trunc, Ft as atan2, G as atomicMax, Gt as degrees, H as atomicAdd, Ht as countOneBits, I as dpdy, It as atanh, J as atomicStore, Jt as dot, K as atomicMin, Kt as determinant, L as dpdyCoarse, Lt as ceil, M as textureStore, Mn as tan, Mt as asin, N as dpdx, Nn as tanh, Nt as asinh, O as textureSampleBias, On as sinh, Ot as arrayLength, P as dpdxCoarse, Pn as transpose, Pt as atan, Q as textureBarrier, Qt as exp2, R as dpdyFine, Rt as clamp, S as subgroupXor, Sn as refract, St as pack2x16float, T as textureLoad, Tn as saturate, Tt as unpack4x8unorm, U as atomicAnd, Ut as countTrailingZeros, V as fwidthFine, Vt as countLeadingZeros, W as atomicLoad, Wt as cross, X as atomicXor, Xt as dot4U8Packed, Y as atomicSub, Yt as dot4I8Packed, Z as storageBarrier, Zt as exp, _ as subgroupOr, _n as normalize, _t as not, a as subgroupAny, an as fract, at as discard, b as subgroupShuffleUp, bn as radians, c as subgroupBroadcastFirst, cn as inverseSqrt, ct as and, d as subgroupExclusiveMul, dn as log, dt as ge, en as faceForward, et as rotateX4, f as subgroupInclusiveAdd, fn as log2, ft as gt, g as subgroupMul, gn as modf, gt as ne, h as subgroupMin, hn as mix, ht as lt, i as subgroupAnd, in as fma, it as translate4, j as textureSampleLevel, jn as step, jt as acosh, k as textureSampleCompare, kn as smoothstep, kt as abs, l as subgroupElect, ln as ldexp, lt as any, m as subgroupMax, mn as min, mt as le, n as subgroupAdd, nn as firstTrailingBit, nt as rotateZ4, o as subgroupBallot, on as frexp, ot as all, p as subgroupInclusiveMul, pn as max, pt as isCloseTo, q as atomicOr, qt as distance, r as subgroupAll, rn as floor, rt as scale4, s as subgroupBroadcast, sn as insertBits, st as allEq, t as extensionEnabled, tn as firstLeadingBit, tt as rotateY4, u as subgroupExclusiveAdd, un as length, ut as eq, v as subgroupShuffle, vn as pow, vt as or, w as textureGather, wn as round, wt as unpack2x16float, x as subgroupShuffleXor, xn as reflect, y as subgroupShuffleDown, yn as quantizeToF16, yt as select, z as fwidth, zt as cos } from "../extensions-0SFbU9FH.js";
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { identity2, identity3, identity4, rotationX4, rotationY4, rotationZ4, scaling4, translation4 } from "../data/matrix.js";
+import { add, div, mod, mul, neg, sub } from "./operators.js";
+import { abs, acos, acosh, asin, asinh, atan, atan2, atanh, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, distance, dot, dot4I8Packed, dot4U8Packed, exp, exp2, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, insertBits, inverseSqrt, ldexp, length, log, log2, max, min, mix, modf, normalize, pow, quantizeToF16, radians, reflect, refract, reverseBits, round, saturate, sign, sin, sinh, smoothstep, sqrt, step, tan, tanh, transpose, trunc } from "./numeric.js";
+import { arrayLength } from "./array.js";
+import { bitcastU32toF32, bitcastU32toI32 } from "./bitcast.js";
+import { pack2x16float, pack4x8unorm, unpack2x16float, unpack4x8unorm } from "./packing.js";
+import { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select } from "./boolean.js";
+import { discard } from "./discard.js";
+import { rotateX4, rotateY4, rotateZ4, scale4, translate4 } from "./matrix.js";
+import { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier } from "./atomic.js";
+import { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthCoarse, fwidthFine } from "./derivative.js";
+import { textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore } from "./texture.js";
+import { subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor } from "./subgroup.js";
+import { extensionEnabled } from "./extensions.js";
 
 //#region src/std/index.ts
 var std_exports = /* @__PURE__ */ __exportAll({
@@ -162,5 +174,4 @@ var std_exports = /* @__PURE__ */ __exportAll({
 });
 
 //#endregion
-export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, std_exports as t, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };
-//# sourceMappingURL=index.js.map
+export { abs, acos, acosh, add, all, allEq, and, any, arrayLength, asin, asinh, atan, atan2, atanh, atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, bitcastU32toF32, bitcastU32toI32, ceil, clamp, cos, cosh, countLeadingZeros, countOneBits, countTrailingZeros, cross, degrees, determinant, discard, distance, div, dot, dot4I8Packed, dot4U8Packed, dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, eq, exp, exp2, extensionEnabled, extractBits, faceForward, firstLeadingBit, firstTrailingBit, floor, fma, fract, frexp, fwidth, fwidthCoarse, fwidthFine, ge, gt, identity2, identity3, identity4, insertBits, inverseSqrt, isCloseTo, ldexp, le, length, log, log2, lt, max, min, mix, mod, modf, mul, ne, neg, normalize, not, or, pack2x16float, pack4x8unorm, pow, quantizeToF16, radians, reflect, refract, reverseBits, rotateX4, rotateY4, rotateZ4, rotationX4, rotationY4, rotationZ4, round, saturate, scale4, scaling4, select, sign, sin, sinh, smoothstep, sqrt, std_exports, step, storageBarrier, sub, subgroupAdd, subgroupAll, subgroupAnd, subgroupAny, subgroupBallot, subgroupBroadcast, subgroupBroadcastFirst, subgroupElect, subgroupExclusiveAdd, subgroupExclusiveMul, subgroupInclusiveAdd, subgroupInclusiveMul, subgroupMax, subgroupMin, subgroupMul, subgroupOr, subgroupShuffle, subgroupShuffleDown, subgroupShuffleUp, subgroupShuffleXor, subgroupXor, tan, tanh, textureBarrier, textureDimensions, textureGather, textureLoad, textureSample, textureSampleBaseClampToEdge, textureSampleBias, textureSampleCompare, textureSampleCompareLevel, textureSampleLevel, textureStore, translate4, translation4, transpose, trunc, unpack2x16float, unpack4x8unorm, workgroupBarrier };