typegpu 0.10.1 → 0.11.0-rc.1

package/std/atomic.js

@@ -0,0 +1,111 @@
+import { Void, isAtomic } from "../data/wgslTypes.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { safeStringify } from "../shared/stringify.js";
+import { i32, u32 } from "../data/numeric.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+//#region src/std/atomic.ts
+const workgroupBarrier = dualImpl({
+	name: "workgroupBarrier",
+	normalImpl: "workgroupBarrier is a no-op outside of CODEGEN mode.",
+	signature: {
+		argTypes: [],
+		returnType: Void
+	},
+	codegenImpl: () => "workgroupBarrier()"
+});
+const storageBarrier = dualImpl({
+	name: "storageBarrier",
+	normalImpl: "storageBarrier is a no-op outside of CODEGEN mode.",
+	signature: {
+		argTypes: [],
+		returnType: Void
+	},
+	codegenImpl: () => "storageBarrier()"
+});
+const textureBarrier = dualImpl({
+	name: "textureBarrier",
+	normalImpl: "textureBarrier is a no-op outside of CODEGEN mode.",
+	signature: {
+		argTypes: [],
+		returnType: Void
+	},
+	codegenImpl: () => "textureBarrier()"
+});
+const atomicNormalError = "Atomic operations are not supported outside of CODEGEN mode.";
+const atomicLoad = dualImpl({
+	name: "atomicLoad",
+	normalImpl: atomicNormalError,
+	signature: (a) => {
+		if (!isAtomic(a)) throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
+		return {
+			argTypes: [a],
+			returnType: a.inner
+		};
+	},
+	codegenImpl: (_ctx, [a]) => stitch`atomicLoad(&${a})`
+});
+const atomicActionSignature = (a) => {
+	if (!isAtomic(a)) throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
+	return {
+		argTypes: [a, a.inner.type === "u32" ? u32 : i32],
+		returnType: Void
+	};
+};
+const atomicOpSignature = (a) => {
+	if (!isAtomic(a)) throw new Error(`Invalid atomic type: ${safeStringify(a)}`);
+	const paramType = a.inner.type === "u32" ? u32 : i32;
+	return {
+		argTypes: [a, paramType],
+		returnType: paramType
+	};
+};
+const atomicStore = dualImpl({
+	name: "atomicStore",
+	normalImpl: atomicNormalError,
+	signature: atomicActionSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicStore(&${a}, ${value})`
+});
+const atomicAdd = dualImpl({
+	name: "atomicAdd",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicAdd(&${a}, ${value})`
+});
+const atomicSub = dualImpl({
+	name: "atomicSub",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicSub(&${a}, ${value})`
+});
+const atomicMax = dualImpl({
+	name: "atomicMax",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicMax(&${a}, ${value})`
+});
+const atomicMin = dualImpl({
+	name: "atomicMin",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicMin(&${a}, ${value})`
+});
+const atomicAnd = dualImpl({
+	name: "atomicAnd",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicAnd(&${a}, ${value})`
+});
+const atomicOr = dualImpl({
+	name: "atomicOr",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicOr(&${a}, ${value})`
+});
+const atomicXor = dualImpl({
+	name: "atomicXor",
+	normalImpl: atomicNormalError,
+	signature: atomicOpSignature,
+	codegenImpl: (_ctx, [a, value]) => stitch`atomicXor(&${a}, ${value})`
+});
+//#endregion
+export { atomicAdd, atomicAnd, atomicLoad, atomicMax, atomicMin, atomicOr, atomicStore, atomicSub, atomicXor, storageBarrier, textureBarrier, workgroupBarrier };

package/std/bitcast.d.ts

@@ -0,0 +1,10 @@
+import { DualFn } from "../types.js";
+import { v2f, v2i, v2u, v3f, v3i, v3u, v4f, v4i, v4u } from "../data/wgslTypes.js";
+
+//#region src/std/bitcast.d.ts
+type BitcastU32toF32Overload = ((value: number) => number) & ((value: v2u) => v2f) & ((value: v3u) => v3f) & ((value: v4u) => v4f);
+declare const bitcastU32toF32: DualFn;
+type BitcastU32toI32Overload = ((value: number) => number) & ((value: v2u) => v2i) & ((value: v3u) => v3i) & ((value: v4u) => v4i);
+declare const bitcastU32toI32: DualFn;
+//#endregion
+export { bitcastU32toF32, bitcastU32toI32 };

package/std/bitcast.js

@@ -0,0 +1,41 @@
+import { isVec } from "../data/wgslTypes.js";
+import { stitch } from "../core/resolve/stitch.js";
+import { unify } from "../tgsl/conversion.js";
+import { f32, i32, u32 } from "../data/numeric.js";
+import { vec2f, vec2i, vec3f, vec3i, vec4f, vec4i } from "../data/vector.js";
+import { dualImpl } from "../core/function/dualImpl.js";
+import { bitcastU32toF32Impl, bitcastU32toI32Impl } from "../data/numberOps.js";
+import { VectorOps } from "../data/vectorOps.js";
+//#region src/std/bitcast.ts
+const bitcastU32toF32 = dualImpl({
+	name: "bitcastU32toF32",
+	normalImpl: ((value) => {
+		if (typeof value === "number") return bitcastU32toF32Impl(value);
+		return VectorOps.bitcastU32toF32[value.kind](value);
+	}),
+	codegenImpl: (_ctx, [n]) => stitch`bitcast<f32>(${n})`,
+	signature: (...arg) => {
+		const uargs = unify(arg, [u32]) ?? arg;
+		return {
+			argTypes: uargs,
+			returnType: isVec(uargs[0]) ? uargs[0].type === "vec2u" ? vec2f : uargs[0].type === "vec3u" ? vec3f : vec4f : f32
+		};
+	}
+});
+const bitcastU32toI32 = dualImpl({
+	name: "bitcastU32toI32",
+	normalImpl: ((value) => {
+		if (typeof value === "number") return bitcastU32toI32Impl(value);
+		return VectorOps.bitcastU32toI32[value.kind](value);
+	}),
+	codegenImpl: (_ctx, [n]) => stitch`bitcast<i32>(${n})`,
+	signature: (...arg) => {
+		const uargs = unify(arg, [u32]) ?? arg;
+		return {
+			argTypes: uargs,
+			returnType: isVec(uargs[0]) ? uargs[0].type === "vec2u" ? vec2i : uargs[0].type === "vec3u" ? vec3i : vec4i : i32
+		};
+	}
+});
+//#endregion
+export { bitcastU32toF32, bitcastU32toI32 };

package/std/boolean.d.ts

@@ -0,0 +1,141 @@
+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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+type VecInstanceToBooleanVecInstance<T extends AnyVecInstance> = T extends AnyVec2Instance ? v2b : T extends AnyVec3Instance ? v3b : v4b;
+declare function cpuNot(value: boolean): boolean;
+declare function cpuNot(value: number): boolean;
+declare function cpuNot<T extends AnyVecInstance>(value: T): VecInstanceToBooleanVecInstance<T>;
+declare function cpuNot(value: unknown): boolean;
+/**
+ * Returns the logical negation of the given value.
+ * For scalars (bool, number), returns `!value`.
+ * For boolean vectors, returns **component-wise** `!value`.
+ * For numeric vectors, returns a boolean vector with component-wise truthiness negation.
+ * For all other types, returns the truthiness negation (in WGSL, this applies only if the value is known at compile-time).
+ * @example
+ * not(true) // returns false
+ * not(-1) // returns false
+ * not(0) // returns true
+ * not(vec3b(true, true, false)) // returns vec3b(false, false, true)
+ * not(vec3f(1.0, 0.0, -1.0)) // returns vec3b(false, true, false)
+ * not({a: 1882}) // returns false
+ * not(NaN) // returns false **as in WGSL**
+ */
+declare const not: DualFn;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+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;
+//#endregion
+export { all, allEq, and, any, eq, ge, gt, isCloseTo, le, lt, ne, not, or, select };

package/std/boolean.js

@@ -0,0 +1,299 @@
+import { isBool, isNumericSchema, isVec, isVecBool, 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})`
+});
+function cpuNot(value) {
+	if (typeof value === "number" && isNaN(value)) return false;
+	if (isVecInstance(value)) {
+		if (value.length === 2) return vec2b(cpuNot(value.x), cpuNot(value.y));
+		if (value.length === 3) return vec3b(cpuNot(value.x), cpuNot(value.y), cpuNot(value.z));
+		if (value.length === 4) return vec4b(cpuNot(value.x), cpuNot(value.y), cpuNot(value.z), cpuNot(value.w));
+	}
+	return !value;
+}
+/**
+* Returns the logical negation of the given value.
+* For scalars (bool, number), returns `!value`.
+* For boolean vectors, returns **component-wise** `!value`.
+* For numeric vectors, returns a boolean vector with component-wise truthiness negation.
+* For all other types, returns the truthiness negation (in WGSL, this applies only if the value is known at compile-time).
+* @example
+* not(true) // returns false
+* not(-1) // returns false
+* not(0) // returns true
+* not(vec3b(true, true, false)) // returns vec3b(false, false, true)
+* not(vec3f(1.0, 0.0, -1.0)) // returns vec3b(false, true, false)
+* not({a: 1882}) // returns false
+* not(NaN) // returns false **as in WGSL**
+*/
+const not = dualImpl({
+	name: "not",
+	signature: (arg) => {
+		const returnType = isVec(arg) ? correspondingBooleanVectorSchema(arg) : bool;
+		return {
+			argTypes: [arg],
+			returnType
+		};
+	},
+	normalImpl: cpuNot,
+	codegenImpl: (_ctx, [arg]) => {
+		const { dataType } = arg;
+		if (isBool(dataType)) return stitch`!${arg}`;
+		if (isNumericSchema(dataType)) return stitch`!bool(${arg})`;
+		if (isVecBool(dataType)) return stitch`!(${arg})`;
+		if (isVec(dataType)) return stitch`!(${`vec${dataType.componentCount}<bool>`}(${arg}))`;
+		return "false";
+	}
+});
+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;
+declare const dpdxCoarse: DualFn;
+declare const dpdxFine: DualFn;
+declare const dpdy: DualFn;
+declare const dpdyCoarse: DualFn;
+declare const dpdyFine: DualFn;
+declare const fwidth: DualFn;
+declare const fwidthCoarse: DualFn;
+declare const fwidthFine: DualFn;
+//#endregion
+export { dpdx, dpdxCoarse, dpdxFine, dpdy, dpdyCoarse, dpdyFine, fwidth, fwidthCoarse, fwidthFine };