@aethervtt/shard-core 0.0.1

package/dist/math/aabb.js

@@ -0,0 +1,78 @@
+const create = () => empty(new Float32Array(6));
+function empty(out) {
+  out[0] = out[1] = out[2] = Infinity;
+  out[3] = out[4] = out[5] = -Infinity;
+  return out;
+}
+function set(out, min, max) {
+  out[0] = min[0];
+  out[1] = min[1];
+  out[2] = min[2];
+  out[3] = max[0];
+  out[4] = max[1];
+  out[5] = max[2];
+  return out;
+}
+function fromPoints(out, positions, stride = 3) {
+  empty(out);
+  for (let i = 0; i + 2 < positions.length; i += stride) {
+    const x = positions[i];
+    const y = positions[i + 1];
+    const z = positions[i + 2];
+    if (x < out[0]) out[0] = x;
+    if (y < out[1]) out[1] = y;
+    if (z < out[2]) out[2] = z;
+    if (x > out[3]) out[3] = x;
+    if (y > out[4]) out[4] = y;
+    if (z > out[5]) out[5] = z;
+  }
+  return out;
+}
+function transformAffineAt(out, box, m, mo) {
+  const minX = box[0];
+  const minY = box[1];
+  const minZ = box[2];
+  const maxX = box[3];
+  const maxY = box[4];
+  const maxZ = box[5];
+  for (let r = 0; r < 3; r++) {
+    let lo = m[mo + r * 4 + 3];
+    let hi = lo;
+    const ex = m[mo + r * 4];
+    const ey = m[mo + r * 4 + 1];
+    const ez = m[mo + r * 4 + 2];
+    const ax = ex * minX;
+    const bx = ex * maxX;
+    const ay = ey * minY;
+    const by = ey * maxY;
+    const az = ez * minZ;
+    const bz = ez * maxZ;
+    lo += Math.min(ax, bx) + Math.min(ay, by) + Math.min(az, bz);
+    hi += Math.max(ax, bx) + Math.max(ay, by) + Math.max(az, bz);
+    out[r] = lo;
+    out[r + 3] = hi;
+  }
+  return out;
+}
+function center(out, box) {
+  out[0] = (box[0] + box[3]) / 2;
+  out[1] = (box[1] + box[4]) / 2;
+  out[2] = (box[2] + box[5]) / 2;
+  return out;
+}
+function intersects(a, b) {
+  return a[0] <= b[3] && a[3] >= b[0] && a[1] <= b[4] && a[4] >= b[1] && a[2] <= b[5] && a[5] >= b[2];
+}
+function containsPoint(box, p) {
+  return p[0] >= box[0] && p[0] <= box[3] && p[1] >= box[1] && p[1] <= box[4] && p[2] >= box[2] && p[2] <= box[5];
+}
+export {
+  center,
+  containsPoint,
+  create,
+  empty,
+  fromPoints,
+  intersects,
+  set,
+  transformAffineAt
+};

package/dist/math/affine.d.ts

@@ -0,0 +1,28 @@
+import type { Readable, Writable } from './types.js';
+/**
+ * Affine transforms stored as the top three rows of a 4x4 matrix, row by row (12 floats):
+ * `[m00 m01 m02 tx, m10 m11 m12 ty, m20 m21 m22 tz]`. The implied fourth row is `0 0 0 1`.
+ * In WGSL this is `array<vec4f, 3>`, and a point transforms with three dot products.
+ *
+ * `*At` variants read and write at offsets, for strided ECS columns.
+ */
+export declare const create: () => Float32Array;
+export declare function identityAt<T extends Writable>(out: T, o: number): T;
+export declare const identity: <T extends Writable>(out: T) => T;
+export declare function copyAt<T extends Writable>(out: T, o: number, a: Readable, ao: number): T;
+/** Translation · rotation · scale, from values at offsets (t: vec3, q: quat, s: vec3). */
+export declare function fromTRSAt<T extends Writable>(out: T, o: number, t: Readable, to: number, q: Readable, qo: number, s: Readable, so: number): T;
+export declare const fromTRS: <T extends Writable>(out: T, t: Readable, q: Readable, s: Readable) => T;
+/** out = a · b, at offsets. `out` may alias `b` but not `a`. */
+export declare function multiplyAt<T extends Writable>(out: T, o: number, a: Readable, ao: number, b: Readable, bo: number): T;
+export declare const multiply: <T extends Writable>(out: T, a: Readable, b: Readable) => T;
+/** Inverse of an affine transform. Returns null for singular transforms. */
+export declare function invert<T extends Writable>(out: T, a: Readable): T | null;
+export declare function transformPointAt<T extends Writable>(out: T, a: Readable, ao: number, p: Readable): T;
+export declare const transformPoint: <T extends Writable>(out: T, a: Readable, p: Readable) => T;
+export declare function getTranslationAt<T extends Writable>(out: T, a: Readable, ao: number): T;
+/** Expands to a column-major mat4. */
+export declare function toMat4At<T extends Writable>(out: T, a: Readable, ao: number): T;
+export declare const toMat4: <T extends Writable>(out: T, a: Readable) => T;
+/** Takes the top three rows of a column-major mat4 (drops any projective part). */
+export declare function fromMat4<T extends Writable>(out: T, m: Readable): T;

package/dist/math/affine.js

@@ -0,0 +1,159 @@
+const create = () => identity(new Float32Array(12));
+function identityAt(out, o) {
+  for (let i = 0; i < 12; i++) out[o + i] = 0;
+  out[o] = 1;
+  out[o + 5] = 1;
+  out[o + 10] = 1;
+  return out;
+}
+const identity = (out) => identityAt(out, 0);
+function copyAt(out, o, a, ao) {
+  for (let i = 0; i < 12; i++) out[o + i] = a[ao + i];
+  return out;
+}
+function fromTRSAt(out, o, t, to, q, qo, s, so) {
+  const x = q[qo];
+  const y = q[qo + 1];
+  const z = q[qo + 2];
+  const w = q[qo + 3];
+  const sx = s[so];
+  const sy = s[so + 1];
+  const sz = s[so + 2];
+  const xx = x * x;
+  const yy = y * y;
+  const zz = z * z;
+  const xy = x * y;
+  const xz = x * z;
+  const yz = y * z;
+  const wx = w * x;
+  const wy = w * y;
+  const wz = w * z;
+  out[o] = (1 - 2 * (yy + zz)) * sx;
+  out[o + 1] = 2 * (xy - wz) * sy;
+  out[o + 2] = 2 * (xz + wy) * sz;
+  out[o + 3] = t[to];
+  out[o + 4] = 2 * (xy + wz) * sx;
+  out[o + 5] = (1 - 2 * (xx + zz)) * sy;
+  out[o + 6] = 2 * (yz - wx) * sz;
+  out[o + 7] = t[to + 1];
+  out[o + 8] = 2 * (xz - wy) * sx;
+  out[o + 9] = 2 * (yz + wx) * sy;
+  out[o + 10] = (1 - 2 * (xx + yy)) * sz;
+  out[o + 11] = t[to + 2];
+  return out;
+}
+const fromTRS = (out, t, q, s) => fromTRSAt(out, 0, t, 0, q, 0, s, 0);
+function multiplyAt(out, o, a, ao, b, bo) {
+  const b00 = b[bo];
+  const b01 = b[bo + 1];
+  const b02 = b[bo + 2];
+  const b03 = b[bo + 3];
+  const b10 = b[bo + 4];
+  const b11 = b[bo + 5];
+  const b12 = b[bo + 6];
+  const b13 = b[bo + 7];
+  const b20 = b[bo + 8];
+  const b21 = b[bo + 9];
+  const b22 = b[bo + 10];
+  const b23 = b[bo + 11];
+  for (let r = 0; r < 3; r++) {
+    const a0 = a[ao + r * 4];
+    const a1 = a[ao + r * 4 + 1];
+    const a2 = a[ao + r * 4 + 2];
+    const a3 = a[ao + r * 4 + 3];
+    out[o + r * 4] = a0 * b00 + a1 * b10 + a2 * b20;
+    out[o + r * 4 + 1] = a0 * b01 + a1 * b11 + a2 * b21;
+    out[o + r * 4 + 2] = a0 * b02 + a1 * b12 + a2 * b22;
+    out[o + r * 4 + 3] = a0 * b03 + a1 * b13 + a2 * b23 + a3;
+  }
+  return out;
+}
+const multiply = (out, a, b) => multiplyAt(out, 0, a, 0, b, 0);
+function invert(out, a) {
+  const a00 = a[0];
+  const a01 = a[1];
+  const a02 = a[2];
+  const a10 = a[4];
+  const a11 = a[5];
+  const a12 = a[6];
+  const a20 = a[8];
+  const a21 = a[9];
+  const a22 = a[10];
+  const tx = a[3];
+  const ty = a[7];
+  const tz = a[11];
+  const c00 = a11 * a22 - a12 * a21;
+  const c01 = a02 * a21 - a01 * a22;
+  const c02 = a01 * a12 - a02 * a11;
+  const det = a00 * c00 + a10 * c01 + a20 * c02;
+  if (!det) return null;
+  const inv = 1 / det;
+  const i00 = c00 * inv;
+  const i01 = c01 * inv;
+  const i02 = c02 * inv;
+  const i10 = (a12 * a20 - a10 * a22) * inv;
+  const i11 = (a00 * a22 - a02 * a20) * inv;
+  const i12 = (a02 * a10 - a00 * a12) * inv;
+  const i20 = (a10 * a21 - a11 * a20) * inv;
+  const i21 = (a01 * a20 - a00 * a21) * inv;
+  const i22 = (a00 * a11 - a01 * a10) * inv;
+  out[0] = i00;
+  out[1] = i01;
+  out[2] = i02;
+  out[3] = -(i00 * tx + i01 * ty + i02 * tz);
+  out[4] = i10;
+  out[5] = i11;
+  out[6] = i12;
+  out[7] = -(i10 * tx + i11 * ty + i12 * tz);
+  out[8] = i20;
+  out[9] = i21;
+  out[10] = i22;
+  out[11] = -(i20 * tx + i21 * ty + i22 * tz);
+  return out;
+}
+function transformPointAt(out, a, ao, p) {
+  const x = p[0];
+  const y = p[1];
+  const z = p[2];
+  out[0] = a[ao] * x + a[ao + 1] * y + a[ao + 2] * z + a[ao + 3];
+  out[1] = a[ao + 4] * x + a[ao + 5] * y + a[ao + 6] * z + a[ao + 7];
+  out[2] = a[ao + 8] * x + a[ao + 9] * y + a[ao + 10] * z + a[ao + 11];
+  return out;
+}
+const transformPoint = (out, a, p) => transformPointAt(out, a, 0, p);
+function getTranslationAt(out, a, ao) {
+  out[0] = a[ao + 3];
+  out[1] = a[ao + 7];
+  out[2] = a[ao + 11];
+  return out;
+}
+function toMat4At(out, a, ao) {
+  for (let r = 0; r < 3; r++) for (let c = 0; c < 4; c++) out[c * 4 + r] = a[ao + r * 4 + c];
+  out[3] = 0;
+  out[7] = 0;
+  out[11] = 0;
+  out[15] = 1;
+  return out;
+}
+const toMat4 = (out, a) => toMat4At(out, a, 0);
+function fromMat4(out, m) {
+  for (let r = 0; r < 3; r++) for (let c = 0; c < 4; c++) out[r * 4 + c] = m[c * 4 + r];
+  return out;
+}
+export {
+  copyAt,
+  create,
+  fromMat4,
+  fromTRS,
+  fromTRSAt,
+  getTranslationAt,
+  identity,
+  identityAt,
+  invert,
+  multiply,
+  multiplyAt,
+  toMat4,
+  toMat4At,
+  transformPoint,
+  transformPointAt
+};

package/dist/math/affine64.d.ts

@@ -0,0 +1,11 @@
+import type { Readable, Writable } from './types.js';
+/**
+ * The `affine` functions on `Float64Array`, for the few places that need positions beyond f32
+ * precision (large-world grids, spec 0040). Same layout: the top three rows of a 4x4, row by row.
+ */
+export { copyAt, fromMat4, fromTRS, fromTRSAt, getTranslationAt, identity, identityAt, invert, multiply, multiplyAt, toMat4, toMat4At, transformPoint, transformPointAt, } from './affine.js';
+export declare const create: () => Float64Array;
+/** out = a · translation(x, y, z). `out` may alias `a`. */
+export declare function translateAt<T extends Writable>(out: T, o: number, a: Readable, ao: number, x: number, y: number, z: number): T;
+/** Rotates and scales a direction (no translation). */
+export declare function transformVectorAt<T extends Writable>(out: T, a: Readable, ao: number, v: Readable): T;

package/dist/math/affine64.js

@@ -0,0 +1,58 @@
+import { identity } from "./affine.js";
+import {
+  copyAt,
+  fromMat4,
+  fromTRS,
+  fromTRSAt,
+  getTranslationAt,
+  identity as identity2,
+  identityAt,
+  invert,
+  multiply,
+  multiplyAt,
+  toMat4,
+  toMat4At,
+  transformPoint,
+  transformPointAt
+} from "./affine.js";
+const create = () => identity(new Float64Array(12));
+function translateAt(out, o, a, ao, x, y, z) {
+  for (let r = 0; r < 3; r++) {
+    const a0 = a[ao + r * 4];
+    const a1 = a[ao + r * 4 + 1];
+    const a2 = a[ao + r * 4 + 2];
+    out[o + r * 4] = a0;
+    out[o + r * 4 + 1] = a1;
+    out[o + r * 4 + 2] = a2;
+    out[o + r * 4 + 3] = a0 * x + a1 * y + a2 * z + a[ao + r * 4 + 3];
+  }
+  return out;
+}
+function transformVectorAt(out, a, ao, v) {
+  const x = v[0];
+  const y = v[1];
+  const z = v[2];
+  out[0] = a[ao] * x + a[ao + 1] * y + a[ao + 2] * z;
+  out[1] = a[ao + 4] * x + a[ao + 5] * y + a[ao + 6] * z;
+  out[2] = a[ao + 8] * x + a[ao + 9] * y + a[ao + 10] * z;
+  return out;
+}
+export {
+  copyAt,
+  create,
+  fromMat4,
+  fromTRS,
+  fromTRSAt,
+  getTranslationAt,
+  identity2 as identity,
+  identityAt,
+  invert,
+  multiply,
+  multiplyAt,
+  toMat4,
+  toMat4At,
+  transformPoint,
+  transformPointAt,
+  transformVectorAt,
+  translateAt
+};

package/dist/math/frustum.d.ts

@@ -0,0 +1,11 @@
+import type { Readable, Writable } from './types.js';
+/**
+ * Six planes as 24 floats `(nx, ny, nz, d)`, inside where `n · p + d >= 0`. Order: left, right,
+ * bottom, top, near, far. Works for standard and reversed-Z projections; a degenerate plane (the
+ * infinite far plane) always passes.
+ */
+export declare const create: () => Float32Array;
+export declare function fromViewProjection<T extends Writable>(out: T, m: Readable): T;
+/** True if the box is at least partly inside (conservative: may keep boxes near corners). */
+export declare function intersectsAabbAt(f: Readable, box: Readable, bo: number): boolean;
+export declare const intersectsAabb: (f: Readable, box: Readable) => boolean;

package/dist/math/frustum.js

@@ -0,0 +1,59 @@
+const create = () => new Float32Array(24);
+function fromViewProjection(out, m) {
+  for (let p = 0; p < 6; p++) {
+    const axis = p >> 1;
+    const sign = p & 1 ? -1 : 1;
+    let a;
+    let b;
+    let c;
+    let d;
+    if (axis < 2) {
+      a = m[3] + sign * m[axis];
+      b = m[7] + sign * m[4 + axis];
+      c = m[11] + sign * m[8 + axis];
+      d = m[15] + sign * m[12 + axis];
+    } else if (sign > 0) {
+      a = m[2];
+      b = m[6];
+      c = m[10];
+      d = m[14];
+    } else {
+      a = m[3] - m[2];
+      b = m[7] - m[6];
+      c = m[11] - m[10];
+      d = m[15] - m[14];
+    }
+    const len = Math.sqrt(a * a + b * b + c * c);
+    if (len < 1e-12) {
+      out[p * 4] = 0;
+      out[p * 4 + 1] = 0;
+      out[p * 4 + 2] = 0;
+      out[p * 4 + 3] = 1;
+    } else {
+      out[p * 4] = a / len;
+      out[p * 4 + 1] = b / len;
+      out[p * 4 + 2] = c / len;
+      out[p * 4 + 3] = d / len;
+    }
+  }
+  return out;
+}
+function intersectsAabbAt(f, box, bo) {
+  for (let p = 0; p < 24; p += 4) {
+    const nx = f[p];
+    const ny = f[p + 1];
+    const nz = f[p + 2];
+    const x = nx >= 0 ? box[bo + 3] : box[bo];
+    const y = ny >= 0 ? box[bo + 4] : box[bo + 1];
+    const z = nz >= 0 ? box[bo + 5] : box[bo + 2];
+    if (nx * x + ny * y + nz * z + f[p + 3] < 0) return false;
+  }
+  return true;
+}
+const intersectsAabb = (f, box) => intersectsAabbAt(f, box, 0);
+export {
+  create,
+  fromViewProjection,
+  intersectsAabb,
+  intersectsAabbAt
+};

package/dist/math/hash.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A child seed from a seed and a label: how `Rng.fork`, noise sources, and generators derive seeds.
+ * Numeric labels hash as four bytes, so the noise kernel and WGSL compute the same value.
+ */
+export declare function hashSeed(seed: number, label: string | number): number;
+/** lowbias32 (Chris Wellons): a well-mixed 32-bit finalizer. */
+export declare function mix32(h: number): number;
+/** Primes the noise kernel multiplies lattice coordinates by before mixing. */
+export declare const LATTICE_PRIMES: readonly [501125321, 1136930381, 1720413743, 1066037191];
+/**
+ * The noise kernel's lattice hash of an integer cell under a seed, as an unsigned 32-bit number:
+ * the same value a noise source hashes for that cell. Generators use it for per-cell decisions.
+ */
+export declare function hash32(seed: number, x: number, y?: number, z?: number, w?: number): number;

package/dist/math/hash.js

@@ -0,0 +1,38 @@
+function fnv(h, unit) {
+  return Math.imul(h ^ unit, 16777619);
+}
+function hashLabel(label) {
+  let h = 2166136261;
+  if (typeof label === "string") {
+    for (let i = 0; i < label.length; i++) h = fnv(h, label.charCodeAt(i));
+  } else {
+    h = fnv(h, label & 255);
+    h = fnv(h, label >>> 8 & 255);
+    h = fnv(h, label >>> 16 & 255);
+    h = fnv(h, label >>> 24);
+  }
+  return h;
+}
+function hashSeed(seed, label) {
+  const h = hashLabel(label);
+  return (Math.imul((seed ^ h) >>> 0, 2654435761) ^ fnv(h, 35)) >>> 0;
+}
+function mix32(h) {
+  h ^= h >>> 16;
+  h = Math.imul(h, 2146121005);
+  h ^= h >>> 15;
+  h = Math.imul(h, 2221713035);
+  return (h ^ h >>> 16) >>> 0;
+}
+const LATTICE_PRIMES = [501125321, 1136930381, 1720413743, 1066037191];
+function hash32(seed, x, y = 0, z = 0, w = 0) {
+  return mix32(
+    seed ^ Math.imul(x, LATTICE_PRIMES[0]) ^ Math.imul(y, LATTICE_PRIMES[1]) ^ Math.imul(z, LATTICE_PRIMES[2]) ^ Math.imul(w, LATTICE_PRIMES[3])
+  );
+}
+export {
+  LATTICE_PRIMES,
+  hash32,
+  hashSeed,
+  mix32
+};

package/dist/math/index.d.ts

@@ -0,0 +1,14 @@
+export * as aabb from './aabb.js';
+export * as affine from './affine.js';
+export * as affine64 from './affine64.js';
+export * as frustum from './frustum.js';
+export { hash32, hashSeed, LATTICE_PRIMES, mix32 } from './hash.js';
+export * as mat3 from './mat3.js';
+export * as mat4 from './mat4.js';
+export * as quat from './quat.js';
+export * as ray from './ray.js';
+export { Rng } from './rng.js';
+export { EPSILON, type Readable, type Writable } from './types.js';
+export * as vec2 from './vec2.js';
+export * as vec3 from './vec3.js';
+export * as vec4 from './vec4.js';

package/dist/math/index.js

@@ -0,0 +1,33 @@
+import * as aabb from "./aabb.js";
+import * as affine from "./affine.js";
+import * as affine64 from "./affine64.js";
+import * as frustum from "./frustum.js";
+import { hash32, hashSeed, LATTICE_PRIMES, mix32 } from "./hash.js";
+import * as mat3 from "./mat3.js";
+import * as mat4 from "./mat4.js";
+import * as quat from "./quat.js";
+import * as ray from "./ray.js";
+import { Rng } from "./rng.js";
+import { EPSILON } from "./types.js";
+import * as vec2 from "./vec2.js";
+import * as vec3 from "./vec3.js";
+import * as vec4 from "./vec4.js";
+export {
+  EPSILON,
+  LATTICE_PRIMES,
+  Rng,
+  aabb,
+  affine,
+  affine64,
+  frustum,
+  hash32,
+  hashSeed,
+  mat3,
+  mat4,
+  mix32,
+  quat,
+  ray,
+  vec2,
+  vec3,
+  vec4
+};

package/dist/math/mat3.d.ts

@@ -0,0 +1,6 @@
+import type { Readable, Writable } from './types.js';
+/** Column-major 3x3: element (row r, column c) at index c * 3 + r. */
+export declare const create: () => Float32Array;
+export declare function identity<T extends Writable>(out: T): T;
+/** Inverse transpose of an affine transform's 3x3 part: transforms normals correctly under scale. */
+export declare function normalFromAffineAt<T extends Writable>(out: T, a: Readable, ao: number): T | null;

package/dist/math/mat3.js

@@ -0,0 +1,37 @@
+const create = () => identity(new Float32Array(9));
+function identity(out) {
+  for (let i = 0; i < 9; i++) out[i] = i % 4 === 0 ? 1 : 0;
+  return out;
+}
+function normalFromAffineAt(out, a, ao) {
+  const a00 = a[ao];
+  const a01 = a[ao + 1];
+  const a02 = a[ao + 2];
+  const a10 = a[ao + 4];
+  const a11 = a[ao + 5];
+  const a12 = a[ao + 6];
+  const a20 = a[ao + 8];
+  const a21 = a[ao + 9];
+  const a22 = a[ao + 10];
+  const c00 = a11 * a22 - a12 * a21;
+  const c01 = a12 * a20 - a10 * a22;
+  const c02 = a10 * a21 - a11 * a20;
+  const det = a00 * c00 + a01 * c01 + a02 * c02;
+  if (!det) return null;
+  const inv = 1 / det;
+  out[0] = c00 * inv;
+  out[1] = (a02 * a21 - a01 * a22) * inv;
+  out[2] = (a01 * a12 - a02 * a11) * inv;
+  out[3] = c01 * inv;
+  out[4] = (a00 * a22 - a02 * a20) * inv;
+  out[5] = (a02 * a10 - a00 * a12) * inv;
+  out[6] = c02 * inv;
+  out[7] = (a01 * a20 - a00 * a21) * inv;
+  out[8] = (a00 * a11 - a01 * a10) * inv;
+  return out;
+}
+export {
+  create,
+  identity,
+  normalFromAffineAt
+};

package/dist/math/mat4.d.ts

@@ -0,0 +1,23 @@
+import type { Readable, Writable } from './types.js';
+/** Column-major 4x4: element (row r, column c) is at index c * 4 + r. */
+export declare const create: () => Float32Array;
+export declare function identity<T extends Writable>(out: T): T;
+export declare function copy<T extends Writable>(out: T, a: Readable): T;
+/** out = a · b */
+export declare function multiply<T extends Writable>(out: T, a: Readable, b: Readable): T;
+export declare function transpose<T extends Writable>(out: T, a: Readable): T;
+/** General inverse. Returns null (and leaves `out` untouched) for singular matrices. */
+export declare function invert<T extends Writable>(out: T, a: Readable): T | null;
+/** Translation · rotation · scale. */
+export declare function fromTRS<T extends Writable>(out: T, t: Readable, q: Readable, s: Readable): T;
+export declare function getTranslation<T extends Writable>(out: T, m: Readable): T;
+/** Perspective projection with WebGPU 0..1 depth (near → 0, far → 1). */
+export declare function perspective<T extends Writable>(out: T, fovY: number, aspect: number, near: number, far: number): T;
+/** Reversed-Z perspective with an infinite far plane: near → 1, infinity → 0. */
+export declare function perspectiveReversedZ<T extends Writable>(out: T, fovY: number, aspect: number, near: number): T;
+/** Orthographic projection with WebGPU 0..1 depth (near → 0, far → 1). */
+export declare function orthographic<T extends Writable>(out: T, left: number, right: number, bottom: number, top: number, near: number, far: number): T;
+/** Reversed-Z orthographic: near → 1, far → 0. */
+export declare function orthographicReversedZ<T extends Writable>(out: T, left: number, right: number, bottom: number, top: number, near: number, far: number): T;
+/** View matrix for a camera at `eye` looking at `target`. */
+export declare function lookAt<T extends Writable>(out: T, eye: Readable, target: Readable, up: Readable): T;