@adobe/ecs 0.0.0-stage → 0.1.0

package/src/interface/math/vec2/u32/bitwise-xor.ts

@@ -0,0 +1,7 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const bitwiseXor = intrinsic({ wgsl: "^", form: "infix", parameters: ["vec2u", "vec2u"], result: "vec2u" }, ([x1, y1]: Vec2_U32, [x2, y2]: Vec2_U32): Vec2_U32 => [
+    (x1 ^ x2) >>> 0,
+    (y1 ^ y2) >>> 0,
+]);

package/src/interface/math/vec2/u32/clamp.ts

@@ -0,0 +1,6 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+import { max } from "./max.js";
+import { min } from "./min.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const clamp = intrinsic({ wgsl: "clamp", parameters: ["vec2u", "vec2u", "vec2u"], result: "vec2u" }, (v: Vec2_U32, minVec: Vec2_U32, maxVec: Vec2_U32): Vec2_U32 => min(max(v, minVec), maxVec));

package/src/interface/math/vec2/u32/count-leading-zeros.ts

@@ -0,0 +1,8 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+import { U32 } from "../../u32/index.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const countLeadingZeros = intrinsic({ wgsl: "countLeadingZeros", parameters: ["vec2u"], result: "vec2u" }, ([x, y]: Vec2_U32): Vec2_U32 => [
+    U32.countLeadingZeros(x),
+    U32.countLeadingZeros(y),
+]);

package/src/interface/math/vec2/u32/count-one-bits.ts

@@ -0,0 +1,8 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+import { U32 } from "../../u32/index.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const countOneBits = intrinsic({ wgsl: "countOneBits", parameters: ["vec2u"], result: "vec2u" }, ([x, y]: Vec2_U32): Vec2_U32 => [
+    U32.countOneBits(x),
+    U32.countOneBits(y),
+]);

package/src/interface/math/vec2/u32/count-trailing-zeros.ts

@@ -0,0 +1,8 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+import { U32 } from "../../u32/index.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const countTrailingZeros = intrinsic({ wgsl: "countTrailingZeros", parameters: ["vec2u"], result: "vec2u" }, ([x, y]: Vec2_U32): Vec2_U32 => [
+    U32.countTrailingZeros(x),
+    U32.countTrailingZeros(y),
+]);

package/src/interface/math/vec2/u32/equals.ts

@@ -0,0 +1,3 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+
+export const equals = ([x1, y1]: Vec2_U32, [x2, y2]: Vec2_U32): boolean => x1 === x2 && y1 === y2;

package/src/interface/math/vec2/u32/max.ts

@@ -0,0 +1,7 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const max = intrinsic({ wgsl: "max", parameters: ["vec2u", "vec2u"], result: "vec2u" }, ([x1, y1]: Vec2_U32, [x2, y2]: Vec2_U32): Vec2_U32 => [
+    Math.max(x1, x2) >>> 0,
+    Math.max(y1, y2) >>> 0,
+]);

package/src/interface/math/vec2/u32/min.ts

@@ -0,0 +1,7 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const min = intrinsic({ wgsl: "min", parameters: ["vec2u", "vec2u"], result: "vec2u" }, ([x1, y1]: Vec2_U32, [x2, y2]: Vec2_U32): Vec2_U32 => [
+    Math.min(x1, x2) >>> 0,
+    Math.min(y1, y2) >>> 0,
+]);

package/src/interface/math/vec2/u32/negate.ts

@@ -0,0 +1,3 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+
+export const negate = ([x, y]: Vec2_U32): Vec2_U32 => [(-x) >>> 0, (-y) >>> 0];

package/src/interface/math/vec2/u32/public.ts

@@ -0,0 +1,20 @@
+export * from "./add.js";
+export * from "./bitwise-and.js";
+export * from "./bitwise-not.js";
+export * from "./bitwise-or.js";
+export * from "./bitwise-xor.js";
+export * from "./clamp.js";
+export * from "./count-leading-zeros.js";
+export * from "./count-one-bits.js";
+export * from "./count-trailing-zeros.js";
+export * from "./equals.js";
+export * from "./max.js";
+export * from "./min.js";
+export * from "./negate.js";
+export * from "./reverse-bits.js";
+export * from "./scale.js";
+export * from "./shift-left.js";
+export * from "./shift-right.js";
+export * from "./subtract.js";
+export * from "./zero.js";
+export * from "./schema.js";

package/src/interface/math/vec2/u32/reverse-bits.ts

@@ -0,0 +1,8 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+import { U32 } from "../../u32/index.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const reverseBits = intrinsic({ wgsl: "reverseBits", parameters: ["vec2u"], result: "vec2u" }, ([x, y]: Vec2_U32): Vec2_U32 => [
+    U32.reverseBits(x),
+    U32.reverseBits(y),
+]);

package/src/interface/math/vec2/u32/scale.ts

@@ -0,0 +1,5 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+import { intrinsic } from "../../intrinsic.js";
+import type { U32 } from "../../u32/index.js";
+
+export const scale = intrinsic({ wgsl: "*", form: "infix", parameters: ["vec2u", "u32"], result: "vec2u" }, ([x, y]: Vec2_U32, s: U32): Vec2_U32 => [Math.imul(x, s) >>> 0, Math.imul(y, s) >>> 0]);

package/src/interface/math/vec2/u32/schema.ts

@@ -0,0 +1,4 @@
+import type { Schema } from "../../../schema/schema.js";
+import { schema as item } from "../../u32/schema.js";
+
+export const schema = { type: "array", items: item, minItems: 2, maxItems: 2 } as const satisfies Schema;

package/src/interface/math/vec2/u32/shift-left.ts

@@ -0,0 +1,3 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+
+export const shiftLeft = ([x, y]: Vec2_U32, s: number): Vec2_U32 => [(x << s) >>> 0, (y << s) >>> 0];

package/src/interface/math/vec2/u32/shift-right.ts

@@ -0,0 +1,7 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+import { U32 } from "../../u32/index.js";
+
+export const shiftRight = ([x, y]: Vec2_U32, s: number): Vec2_U32 => [
+    U32.shiftRight(x, s),
+    U32.shiftRight(y, s),
+];

package/src/interface/math/vec2/u32/subtract.ts

@@ -0,0 +1,7 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const subtract = intrinsic({ wgsl: "-", form: "infix", parameters: ["vec2u", "vec2u"], result: "vec2u" }, ([x1, y1]: Vec2_U32, [x2, y2]: Vec2_U32): Vec2_U32 => [
+    (x1 - x2) >>> 0,
+    (y1 - y2) >>> 0,
+]);

package/src/interface/math/vec2/u32/u32.ts

@@ -0,0 +1,4 @@
+/** Vectors of integers in [0, 2^32). Functions wrap as WGSL's u32 does; for other values their results are indeterminate. */
+export type U32 = readonly [number, number];
+
+export * as U32 from "./public.js";

package/src/interface/math/vec2/u32/zero.ts

@@ -0,0 +1,3 @@
+import type { U32 as Vec2_U32 } from "./u32.js";
+
+export const zero: Vec2_U32 = [0, 0];

package/src/interface/math/vec3/f32/abs.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const abs = intrinsic({ wgsl: "abs", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.abs(x), Math.abs(y), Math.abs(z)]);

package/src/interface/math/vec3/f32/acos.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const acos = intrinsic({ wgsl: "acos", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.acos(x), Math.acos(y), Math.acos(z)]);

package/src/interface/math/vec3/f32/acosh.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const acosh = intrinsic({ wgsl: "acosh", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.acosh(x), Math.acosh(y), Math.acosh(z)]);

package/src/interface/math/vec3/f32/add.ts

@@ -0,0 +1,8 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const add = intrinsic({ wgsl: "+", form: "infix", parameters: ["vec3f", "vec3f"], result: "vec3f" }, ([x1, y1, z1]: F32, [x2, y2, z2]: F32): F32 => [
+    x1 + x2,
+    y1 + y2,
+    z1 + z2
+]);

package/src/interface/math/vec3/f32/asin.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const asin = intrinsic({ wgsl: "asin", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.asin(x), Math.asin(y), Math.asin(z)]);

package/src/interface/math/vec3/f32/asinh.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const asinh = intrinsic({ wgsl: "asinh", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.asinh(x), Math.asinh(y), Math.asinh(z)]);

package/src/interface/math/vec3/f32/atan.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const atan = intrinsic({ wgsl: "atan", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.atan(x), Math.atan(y), Math.atan(z)]);

package/src/interface/math/vec3/f32/atanh.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const atanh = intrinsic({ wgsl: "atanh", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.atanh(x), Math.atanh(y), Math.atanh(z)]);

package/src/interface/math/vec3/f32/ceil.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const ceil = intrinsic({ wgsl: "ceil", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.ceil(x), Math.ceil(y), Math.ceil(z)]);

package/src/interface/math/vec3/f32/clamp.ts

@@ -0,0 +1,6 @@
+import type { F32 } from "./f32.js";
+import { max } from "./max.js";
+import { min } from "./min.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const clamp = intrinsic({ wgsl: "clamp", parameters: ["vec3f", "vec3f", "vec3f"], result: "vec3f" }, (v: F32, minVec: F32, maxVec: F32): F32 => min(max(v, minVec), maxVec));

package/src/interface/math/vec3/f32/cos.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const cos = intrinsic({ wgsl: "cos", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.cos(x), Math.cos(y), Math.cos(z)]);

package/src/interface/math/vec3/f32/cosh.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const cosh = intrinsic({ wgsl: "cosh", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.cosh(x), Math.cosh(y), Math.cosh(z)]);

package/src/interface/math/vec3/f32/cross.ts

@@ -0,0 +1,8 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const cross = intrinsic({ wgsl: "cross", parameters: ["vec3f", "vec3f"], result: "vec3f" }, ([x1, y1, z1]: F32, [x2, y2, z2]: F32): F32 => [
+    y1 * z2 - z1 * y2,
+    z1 * x2 - x1 * z2,
+    x1 * y2 - y1 * x2
+]);

package/src/interface/math/vec3/f32/distance-squared.ts

@@ -0,0 +1,8 @@
+import type { F32 } from "./f32.js";
+
+export const distanceSquared = (a: F32, b: F32): number => {
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const dz = b[2] - a[2];
+    return dx * dx + dy * dy + dz * dz;
+};

package/src/interface/math/vec3/f32/distance.ts

@@ -0,0 +1,6 @@
+import type { F32 } from "./f32.js";
+import { length } from "./length.js";
+import { subtract } from "./subtract.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const distance = intrinsic({ wgsl: "distance", parameters: ["vec3f", "vec3f"], result: "f32" }, (a: F32, b: F32): number => length(subtract(b, a)));

package/src/interface/math/vec3/f32/dot.ts

@@ -0,0 +1,5 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const dot = intrinsic({ wgsl: "dot", parameters: ["vec3f", "vec3f"], result: "f32" }, ([x1, y1, z1]: F32, [x2, y2, z2]: F32): number =>
+    x1 * x2 + y1 * y2 + z1 * z2);

package/src/interface/math/vec3/f32/equals.ts

@@ -0,0 +1,3 @@
+import type { F32 } from "./f32.js";
+
+export const equals = (a: F32, b: F32): boolean => a[0] === b[0] && a[1] === b[1] && a[2] === b[2];

package/src/interface/math/vec3/f32/exp.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const exp = intrinsic({ wgsl: "exp", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.exp(x), Math.exp(y), Math.exp(z)]);

package/src/interface/math/vec3/f32/exp2.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const exp2 = intrinsic({ wgsl: "exp2", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.pow(2, x), Math.pow(2, y), Math.pow(2, z)]);

package/src/interface/math/vec3/f32/f32.ts

@@ -0,0 +1,3 @@
+export type F32 = readonly [number, number, number];
+
+export * as F32 from "./public.js";

package/src/interface/math/vec3/f32/faceforward.ts

@@ -0,0 +1,7 @@
+import type { F32 } from "./f32.js";
+import { dot } from "./dot.js";
+import { negate } from "./negate.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const faceforward = intrinsic({ wgsl: "faceForward", parameters: ["vec3f", "vec3f", "vec3f"], result: "vec3f" }, (n: F32, i: F32, nref: F32): F32 =>
+    dot(nref, i) < 0 ? n : negate(n));

package/src/interface/math/vec3/f32/floor.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const floor = intrinsic({ wgsl: "floor", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.floor(x), Math.floor(y), Math.floor(z)]);

package/src/interface/math/vec3/f32/fract.ts

@@ -0,0 +1,8 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const fract = intrinsic({ wgsl: "fract", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [
+    x - Math.floor(x),
+    y - Math.floor(y),
+    z - Math.floor(z)
+]);

package/src/interface/math/vec3/f32/length-squared.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { dot } from "./dot.js";
+
+export const lengthSquared = (v: F32): number => dot(v, v);

package/src/interface/math/vec3/f32/length.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const length = intrinsic({ wgsl: "length", parameters: ["vec3f"], result: "f32" }, ([x, y, z]: F32): number => Math.sqrt(x * x + y * y + z * z));

package/src/interface/math/vec3/f32/log.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const log = intrinsic({ wgsl: "log", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.log(x), Math.log(y), Math.log(z)]);

package/src/interface/math/vec3/f32/log2.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const log2 = intrinsic({ wgsl: "log2", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.log2(x), Math.log2(y), Math.log2(z)]);

package/src/interface/math/vec3/f32/max.ts

@@ -0,0 +1,8 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const max = intrinsic({ wgsl: "max", parameters: ["vec3f", "vec3f"], result: "vec3f" }, ([x1, y1, z1]: F32, [x2, y2, z2]: F32): F32 => [
+    Math.max(x1, x2),
+    Math.max(y1, y2),
+    Math.max(z1, z2)
+]);

package/src/interface/math/vec3/f32/min.ts

@@ -0,0 +1,8 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const min = intrinsic({ wgsl: "min", parameters: ["vec3f", "vec3f"], result: "vec3f" }, ([x1, y1, z1]: F32, [x2, y2, z2]: F32): F32 => [
+    Math.min(x1, x2),
+    Math.min(y1, y2),
+    Math.min(z1, z2)
+]);

package/src/interface/math/vec3/f32/mix.ts

@@ -0,0 +1,8 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const mix = intrinsic({ wgsl: "mix", parameters: ["vec3f", "vec3f", "f32"], result: "vec3f" }, ([x1, y1, z1]: F32, [x2, y2, z2]: F32, t: number): F32 => [
+    x1 * (1 - t) + x2 * t,
+    y1 * (1 - t) + y2 * t,
+    z1 * (1 - t) + z2 * t
+]);

package/src/interface/math/vec3/f32/mod.ts

@@ -0,0 +1,7 @@
+import type { F32 } from "./f32.js";
+
+export const mod = ([x, y, z]: F32, m: number): F32 => [
+    x - m * Math.floor(x / m),
+    y - m * Math.floor(y / m),
+    z - m * Math.floor(z / m),
+];

package/src/interface/math/vec3/f32/modf.ts

@@ -0,0 +1,7 @@
+import type { F32 } from "./f32.js";
+import { fract } from "./fract.js";
+
+export const modf = ([x, y, z]: F32): { fract: F32; whole: F32 } => ({
+    whole: [Math.trunc(x), Math.trunc(y), Math.trunc(z)],
+    fract: [x - Math.trunc(x), y - Math.trunc(y), z - Math.trunc(z)]
+});

package/src/interface/math/vec3/f32/multiply.ts

@@ -0,0 +1,11 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+/**
+ * Performs a component-wise multiplication of two vectors.
+ */
+export const multiply = intrinsic({ wgsl: "*", form: "infix", parameters: ["vec3f", "vec3f"], result: "vec3f" }, ([x1, y1, z1]: F32, [x2, y2, z2]: F32): F32 => [
+    x1 * x2,
+    y1 * y2,
+    z1 * z2
+]);

package/src/interface/math/vec3/f32/negate.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const negate = intrinsic({ wgsl: "-", form: "prefix", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [-x, -y, -z]);

package/src/interface/math/vec3/f32/normalize.ts

@@ -0,0 +1,6 @@
+import type { F32 } from "./f32.js";
+import { length } from "./length.js";
+import { scale } from "./scale.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const normalize = intrinsic({ wgsl: "normalize", parameters: ["vec3f"], result: "vec3f" }, (v: F32): F32 => scale(v, 1 / length(v)));

package/src/interface/math/vec3/f32/one.ts

@@ -0,0 +1,3 @@
+import type { F32 } from "./f32.js";
+
+export const one: F32 = [1, 1, 1];

package/src/interface/math/vec3/f32/pow.ts

@@ -0,0 +1,9 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+/** Each lane of the first vector to the power of the second's; as WGSL's `pow`, indeterminate for a negative base, or a zero base with an exponent at most zero. */
+export const pow = intrinsic({ wgsl: "pow", parameters: ["vec3f", "vec3f"], result: "vec3f" }, ([x1, y1, z1]: F32, [x2, y2, z2]: F32): F32 => [
+    Math.pow(x1, x2),
+    Math.pow(y1, y2),
+    Math.pow(z1, z2)
+]);

package/src/interface/math/vec3/f32/public.ts

@@ -0,0 +1,53 @@
+export * from "./abs.js";
+export * from "./acos.js";
+export * from "./acosh.js";
+export * from "./add.js";
+export * from "./asin.js";
+export * from "./asinh.js";
+export * from "./atan.js";
+export * from "./atanh.js";
+export * from "./ceil.js";
+export * from "./clamp.js";
+export * from "./cos.js";
+export * from "./cosh.js";
+export * from "./cross.js";
+export * from "./distance-squared.js";
+export * from "./distance.js";
+export * from "./dot.js";
+export * from "./equals.js";
+export * from "./exp.js";
+export * from "./exp2.js";
+export * from "./faceforward.js";
+export * from "./floor.js";
+export * from "./fract.js";
+export * from "./length-squared.js";
+export * from "./length.js";
+export * from "./log.js";
+export * from "./log2.js";
+export * from "./max.js";
+export * from "./min.js";
+export * from "./mix.js";
+export * from "./mod.js";
+export * from "./modf.js";
+export * from "./multiply.js";
+export * from "./negate.js";
+export * from "./normalize.js";
+export * from "./one.js";
+export * from "./pow.js";
+export * from "./random.js";
+export * from "./reflect.js";
+export * from "./refract.js";
+export * from "./round.js";
+export * from "./scale.js";
+export * from "./sign.js";
+export * from "./sin.js";
+export * from "./sinh.js";
+export * from "./smoothstep.js";
+export * from "./sqrt.js";
+export * from "./step.js";
+export * from "./subtract.js";
+export * from "./tan.js";
+export * from "./tanh.js";
+export * from "./trunc.js";
+export * from "./zero.js";
+export * from "./schema.js";

package/src/interface/math/vec3/f32/random.ts

@@ -0,0 +1,5 @@
+import type { F32 } from "./f32.js";
+
+export const random = (): F32 => {
+    return [Math.random(), Math.random(), Math.random()];
+};

package/src/interface/math/vec3/f32/reflect.ts

@@ -0,0 +1,10 @@
+import type { F32 } from "./f32.js";
+import { dot } from "./dot.js";
+import { scale } from "./scale.js";
+import { subtract } from "./subtract.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const reflect = intrinsic({ wgsl: "reflect", parameters: ["vec3f", "vec3f"], result: "vec3f" }, (i: F32, n: F32): F32 => {
+    const dot2 = dot(n, i) * 2;
+    return subtract(i, scale(n, dot2));
+});

package/src/interface/math/vec3/f32/refract.ts

@@ -0,0 +1,15 @@
+import type { F32 } from "./f32.js";
+import { dot } from "./dot.js";
+import { scale } from "./scale.js";
+import { subtract } from "./subtract.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const refract = intrinsic({ wgsl: "refract", parameters: ["vec3f", "vec3f", "f32"], result: "vec3f" }, (i: F32, n: F32, eta: number): F32 => {
+    const dotProduct = dot(n, i);
+    const k = 1.0 - eta * eta * (1.0 - dotProduct * dotProduct);
+    if (k < 0.0) {
+        return [0, 0, 0];
+    }
+    const scaleFactor = eta * dotProduct + Math.sqrt(k);
+    return subtract(scale(i, eta), scale(n, scaleFactor));
+});

package/src/interface/math/vec3/f32/round.ts

@@ -0,0 +1,9 @@
+import type { F32 } from "./f32.js";
+import { roundHalfEven } from "../../f32/round-half-even.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const round = intrinsic({ wgsl: "round", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [
+    roundHalfEven(x),
+    roundHalfEven(y),
+    roundHalfEven(z),
+]);

package/src/interface/math/vec3/f32/scale.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const scale = intrinsic({ wgsl: "*", form: "infix", parameters: ["vec3f", "f32"], result: "vec3f" }, ([x, y, z]: F32, s: number): F32 => [x * s, y * s, z * s]);

package/src/interface/math/vec3/f32/schema.ts

@@ -0,0 +1,4 @@
+import type { Schema } from "../../../schema/schema.js";
+import { schema as item } from "../../f32/schema.js";
+
+export const schema = { type: "array", items: item, minItems: 3, maxItems: 3 } as const satisfies Schema;

package/src/interface/math/vec3/f32/sign.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const sign = intrinsic({ wgsl: "sign", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.sign(x), Math.sign(y), Math.sign(z)]);

package/src/interface/math/vec3/f32/sin.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const sin = intrinsic({ wgsl: "sin", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.sin(x), Math.sin(y), Math.sin(z)]);

package/src/interface/math/vec3/f32/sinh.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const sinh = intrinsic({ wgsl: "sinh", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.sinh(x), Math.sinh(y), Math.sinh(z)]);

package/src/interface/math/vec3/f32/smoothstep.ts

@@ -0,0 +1,13 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const smoothstep = intrinsic({ wgsl: "smoothstep", parameters: ["vec3f", "vec3f", "vec3f"], result: "vec3f" }, ([e0x, e0y, e0z]: F32, [e1x, e1y, e1z]: F32, [x, y, z]: F32): F32 => {
+    const tx = Math.max(0, Math.min(1, (x - e0x) / (e1x - e0x)));
+    const ty = Math.max(0, Math.min(1, (y - e0y) / (e1y - e0y)));
+    const tz = Math.max(0, Math.min(1, (z - e0z) / (e1z - e0z)));
+    return [
+        tx * tx * (3 - 2 * tx),
+        ty * ty * (3 - 2 * ty),
+        tz * tz * (3 - 2 * tz)
+    ];
+});

package/src/interface/math/vec3/f32/sqrt.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const sqrt = intrinsic({ wgsl: "sqrt", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.sqrt(x), Math.sqrt(y), Math.sqrt(z)]);

package/src/interface/math/vec3/f32/step.ts

@@ -0,0 +1,8 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const step = intrinsic({ wgsl: "step", parameters: ["vec3f", "vec3f"], result: "vec3f" }, ([edge1, edge2, edge3]: F32, [x, y, z]: F32): F32 => [
+    x < edge1 ? 0 : 1,
+    y < edge2 ? 0 : 1,
+    z < edge3 ? 0 : 1
+]);

package/src/interface/math/vec3/f32/subtract.ts

@@ -0,0 +1,8 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const subtract = intrinsic({ wgsl: "-", form: "infix", parameters: ["vec3f", "vec3f"], result: "vec3f" }, ([x1, y1, z1]: F32, [x2, y2, z2]: F32): F32 => [
+    x1 - x2,
+    y1 - y2,
+    z1 - z2
+]);

package/src/interface/math/vec3/f32/tan.ts

@@ -0,0 +1,4 @@
+import type { F32 } from "./f32.js";
+import { intrinsic } from "../../intrinsic.js";
+
+export const tan = intrinsic({ wgsl: "tan", parameters: ["vec3f"], result: "vec3f" }, ([x, y, z]: F32): F32 => [Math.tan(x), Math.tan(y), Math.tan(z)]);