@galfus/engine 0.0.0-stage → 0.31.1-alpha

package/src/math/quat.ts

@@ -0,0 +1,438 @@
+/**
+ * Quaternion operations.
+ * Stored as a 4-element Float32Array: [x, y, z, w]
+ */
+
+import { EPSILON, equalsApprox } from './common';
+import type { ReadonlyMat4 } from './mat4';
+import type { ReadonlyVec3 } from './vec3';
+
+export type Quat = Float32Array & {
+  0: number;
+  1: number;
+  2: number;
+  3: number;
+};
+
+export type ReadonlyQuat = ArrayLike<number> & {
+  0: number;
+  1: number;
+  2: number;
+  3: number;
+};
+
+export function create(): Quat {
+  const out = new Float32Array(4) as unknown as Quat;
+  out[3] = 1;
+  return out;
+}
+
+export function identity(out: Quat): Quat {
+  out[0] = 0;
+  out[1] = 0;
+  out[2] = 0;
+  out[3] = 1;
+  return out;
+}
+
+export function fromValues(x: number, y: number, z: number, w: number): Quat {
+  const out = new Float32Array(4) as unknown as Quat;
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  out[3] = w;
+  return out;
+}
+
+export function copy(out: Quat, a: ReadonlyQuat): Quat {
+  out[0] = a[0];
+  out[1] = a[1];
+  out[2] = a[2];
+  out[3] = a[3];
+  return out;
+}
+
+export function set(out: Quat, x: number, y: number, z: number, w: number): Quat {
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+  out[3] = w;
+  return out;
+}
+
+export function setAxisAngle(out: Quat, axis: ReadonlyVec3, rad: number): Quat {
+  const half = rad * 0.5;
+  const s = Math.sin(half);
+  out[0] = s * axis[0];
+  out[1] = s * axis[1];
+  out[2] = s * axis[2];
+  out[3] = Math.cos(half);
+  return out;
+}
+
+export function multiply(out: Quat, a: ReadonlyQuat, b: ReadonlyQuat): Quat {
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  const bx = b[0];
+  const by = b[1];
+  const bz = b[2];
+  const bw = b[3];
+
+  out[0] = ax * bw + aw * bx + ay * bz - az * by;
+  out[1] = ay * bw + aw * by + az * bx - ax * bz;
+  out[2] = az * bw + aw * bz + ax * by - ay * bx;
+  out[3] = aw * bw - ax * bx - ay * by - az * bz;
+  return out;
+}
+
+export function rotateX(out: Quat, a: ReadonlyQuat, rad: number): Quat {
+  const half = rad * 0.5;
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  const bx = Math.sin(half);
+  const bw = Math.cos(half);
+
+  out[0] = ax * bw + aw * bx;
+  out[1] = ay * bw + az * bx;
+  out[2] = az * bw - ay * bx;
+  out[3] = aw * bw - ax * bx;
+  return out;
+}
+
+export function rotateY(out: Quat, a: ReadonlyQuat, rad: number): Quat {
+  const half = rad * 0.5;
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  const by = Math.sin(half);
+  const bw = Math.cos(half);
+
+  out[0] = ax * bw - az * by;
+  out[1] = ay * bw + aw * by;
+  out[2] = az * bw + ax * by;
+  out[3] = aw * bw - ay * by;
+  return out;
+}
+
+export function rotateZ(out: Quat, a: ReadonlyQuat, rad: number): Quat {
+  const half = rad * 0.5;
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  const bz = Math.sin(half);
+  const bw = Math.cos(half);
+
+  out[0] = ax * bw + ay * bz;
+  out[1] = ay * bw - ax * bz;
+  out[2] = az * bw + aw * bz;
+  out[3] = aw * bw - az * bz;
+  return out;
+}
+
+export function invert(out: Quat, a: ReadonlyQuat): Quat {
+  const a0 = a[0];
+  const a1 = a[1];
+  const a2 = a[2];
+  const a3 = a[3];
+  const dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;
+  const invDot = dot ? 1.0 / dot : 0;
+
+  out[0] = -a0 * invDot;
+  out[1] = -a1 * invDot;
+  out[2] = -a2 * invDot;
+  out[3] = a3 * invDot;
+  return out;
+}
+
+export function conjugate(out: Quat, a: ReadonlyQuat): Quat {
+  out[0] = -a[0];
+  out[1] = -a[1];
+  out[2] = -a[2];
+  out[3] = a[3];
+  return out;
+}
+
+export function normalize(out: Quat, a: ReadonlyQuat): Quat {
+  const x = a[0];
+  const y = a[1];
+  const z = a[2];
+  const w = a[3];
+  let len = Math.hypot(x, y, z, w);
+  if (len === 0) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 1;
+  } else {
+    len = 1 / len;
+    out[0] = x * len;
+    out[1] = y * len;
+    out[2] = z * len;
+    out[3] = w * len;
+  }
+  return out;
+}
+
+export function slerp(out: Quat, a: ReadonlyQuat, b: ReadonlyQuat, t: number): Quat {
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  let aw = a[3];
+  let bx = b[0];
+  let by = b[1];
+  let bz = b[2];
+  let bw = b[3];
+
+  let cosom = ax * bx + ay * by + az * bz + aw * bw;
+  if (cosom < 0.0) {
+    cosom = -cosom;
+    bx = -bx;
+    by = -by;
+    bz = -bz;
+    bw = -bw;
+  }
+
+  let scale0: number;
+  let scale1: number;
+
+  if (1.0 - cosom > EPSILON) {
+    const omega = Math.acos(cosom);
+    const sinom = Math.sin(omega);
+    scale0 = Math.sin((1.0 - t) * omega) / sinom;
+    scale1 = Math.sin(t * omega) / sinom;
+  } else {
+    scale0 = 1.0 - t;
+    scale1 = t;
+  }
+
+  out[0] = scale0 * ax + scale1 * bx;
+  out[1] = scale0 * ay + scale1 * by;
+  out[2] = scale0 * az + scale1 * bz;
+  out[3] = scale0 * aw + scale1 * bw;
+  return out;
+}
+
+/**
+ * Normalized linear interpolation (nlerp) between two quaternions along the shortest path.
+ */
+export function lerp(out: Quat, a: ReadonlyQuat, b: ReadonlyQuat, t: number): Quat {
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  const aw = a[3];
+  let bx = b[0];
+  let by = b[1];
+  let bz = b[2];
+  let bw = b[3];
+
+  if (ax * bx + ay * by + az * bz + aw * bw < 0) {
+    bx = -bx;
+    by = -by;
+    bz = -bz;
+    bw = -bw;
+  }
+
+  const x = ax + t * (bx - ax);
+  const y = ay + t * (by - ay);
+  const z = az + t * (bz - az);
+  const w = aw + t * (bw - aw);
+
+  let len = Math.hypot(x, y, z, w);
+  if (len === 0) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 1;
+  } else {
+    len = 1 / len;
+    out[0] = x * len;
+    out[1] = y * len;
+    out[2] = z * len;
+    out[3] = w * len;
+  }
+  return out;
+}
+
+export function clamp(
+  out: Quat,
+  a: ReadonlyQuat,
+  min: ReadonlyQuat | number,
+  max: ReadonlyQuat | number
+): Quat {
+  const minX = typeof min === 'number' ? min : min[0];
+  const minY = typeof min === 'number' ? min : min[1];
+  const minZ = typeof min === 'number' ? min : min[2];
+  const minW = typeof min === 'number' ? min : min[3];
+  const maxX = typeof max === 'number' ? max : max[0];
+  const maxY = typeof max === 'number' ? max : max[1];
+  const maxZ = typeof max === 'number' ? max : max[2];
+  const maxW = typeof max === 'number' ? max : max[3];
+  out[0] = Math.min(Math.max(a[0], minX), maxX);
+  out[1] = Math.min(Math.max(a[1], minY), maxY);
+  out[2] = Math.min(Math.max(a[2], minZ), maxZ);
+  out[3] = Math.min(Math.max(a[3], minW), maxW);
+  return out;
+}
+
+export function fromEuler(out: Quat, x: number, y: number, z: number): Quat {
+  const halfToRad = 0.5 * (Math.PI / 180.0);
+  const xRad = x * halfToRad;
+  const yRad = y * halfToRad;
+  const zRad = z * halfToRad;
+
+  const sx = Math.sin(xRad);
+  const cx = Math.cos(xRad);
+  const sy = Math.sin(yRad);
+  const cy = Math.cos(yRad);
+  const sz = Math.sin(zRad);
+  const cz = Math.cos(zRad);
+
+  out[0] = sx * cy * cz - cx * sy * sz;
+  out[1] = cx * sy * cz + sx * cy * sz;
+  out[2] = cx * cy * sz - sx * sy * cz;
+  out[3] = cx * cy * cz + sx * sy * sz;
+  return out;
+}
+
+/**
+ * Computes a rotation quaternion that orients an entity at `eye` towards `target`.
+ *
+ * @param out Output quaternion receiving the computed rotation.
+ * @param eye Observer / entity origin position.
+ * @param target Destination target point to look at.
+ * @param up Upward reference direction (defaults to [0, 1, 0]).
+ * @returns `out`
+ */
+export function fromLookAt(
+  out: Quat,
+  eye: ReadonlyVec3,
+  target: ReadonlyVec3,
+  up: ReadonlyVec3 = [0.0, 1.0, 0.0]
+): Quat {
+  let fx = target[0] - eye[0];
+  let fy = target[1] - eye[1];
+  let fz = target[2] - eye[2];
+  const rlen = 1.0 / (Math.hypot(fx, fy, fz) || 1.0);
+  fx *= rlen;
+  fy *= rlen;
+  fz *= rlen;
+
+  let rx = up[1] * fz - up[2] * fy;
+  let ry = up[2] * fx - up[0] * fz;
+  let rz = up[0] * fy - up[1] * fx;
+  const rlenR = 1.0 / (Math.hypot(rx, ry, rz) || 1.0);
+  rx *= rlenR;
+  ry *= rlenR;
+  rz *= rlenR;
+
+  const ux = fy * rz - fz * ry;
+  const uy = fz * rx - fx * rz;
+  const uz = fx * ry - fy * rx;
+
+  const m00 = rx;
+  const m01 = ry;
+  const m02 = rz;
+  const m10 = ux;
+  const m11 = uy;
+  const m12 = uz;
+  const m20 = -fx;
+  const m21 = -fy;
+  const m22 = -fz;
+
+  const trace = m00 + m11 + m22;
+  if (trace > 0) {
+    const s = 0.5 / Math.sqrt(trace + 1.0);
+    out[0] = (m12 - m21) * s;
+    out[1] = (m20 - m02) * s;
+    out[2] = (m01 - m10) * s;
+    out[3] = 0.25 / s;
+  } else if (m00 > m11 && m00 > m22) {
+    const s = 2.0 * Math.sqrt(1.0 + m00 - m11 - m22);
+    out[0] = 0.25 * s;
+    out[1] = (m10 + m01) / s;
+    out[2] = (m20 + m02) / s;
+    out[3] = (m12 - m21) / s;
+  } else if (m11 > m22) {
+    const s = 2.0 * Math.sqrt(1.0 + m11 - m00 - m22);
+    out[0] = (m10 + m01) / s;
+    out[1] = 0.25 * s;
+    out[2] = (m21 + m12) / s;
+    out[3] = (m20 - m02) / s;
+  } else {
+    const s = 2.0 * Math.sqrt(1.0 + m22 - m00 - m11);
+    out[0] = (m20 + m02) / s;
+    out[1] = (m21 + m12) / s;
+    out[2] = 0.25 * s;
+    out[3] = (m01 - m10) / s;
+  }
+  return out;
+}
+
+export function fromMat4(out: Quat, m: ReadonlyMat4): Quat {
+  let m00 = m[0]!;
+  let m01 = m[1]!;
+  let m02 = m[2]!;
+  let m10 = m[4]!;
+  let m11 = m[5]!;
+  let m12 = m[6]!;
+  let m20 = m[8]!;
+  let m21 = m[9]!;
+  let m22 = m[10]!;
+
+  const sx = 1.0 / (Math.hypot(m00, m01, m02) || 1.0);
+  const sy = 1.0 / (Math.hypot(m10, m11, m12) || 1.0);
+  const sz = 1.0 / (Math.hypot(m20, m21, m22) || 1.0);
+
+  m00 *= sx;
+  m01 *= sx;
+  m02 *= sx;
+  m10 *= sy;
+  m11 *= sy;
+  m12 *= sy;
+  m20 *= sz;
+  m21 *= sz;
+  m22 *= sz;
+
+  const trace = m00 + m11 + m22;
+  if (trace > 0) {
+    const s = 0.5 / Math.sqrt(trace + 1.0);
+    out[0] = (m12 - m21) * s;
+    out[1] = (m20 - m02) * s;
+    out[2] = (m01 - m10) * s;
+    out[3] = 0.25 / s;
+  } else if (m00 > m11 && m00 > m22) {
+    const s = 2.0 * Math.sqrt(1.0 + m00 - m11 - m22);
+    out[0] = 0.25 * s;
+    out[1] = (m10 + m01) / s;
+    out[2] = (m20 + m02) / s;
+    out[3] = (m12 - m21) / s;
+  } else if (m11 > m22) {
+    const s = 2.0 * Math.sqrt(1.0 + m11 - m00 - m22);
+    out[0] = (m10 + m01) / s;
+    out[1] = 0.25 * s;
+    out[2] = (m21 + m12) / s;
+    out[3] = (m20 - m02) / s;
+  } else {
+    const s = 2.0 * Math.sqrt(1.0 + m22 - m00 - m11);
+    out[0] = (m20 + m02) / s;
+    out[1] = (m21 + m12) / s;
+    out[2] = 0.25 * s;
+    out[3] = (m01 - m10) / s;
+  }
+  return out;
+}
+
+export function equals(a: ReadonlyQuat, b: ReadonlyQuat, epsilon: number = EPSILON): boolean {
+  return (
+    equalsApprox(a[0], b[0], epsilon) &&
+    equalsApprox(a[1], b[1], epsilon) &&
+    equalsApprox(a[2], b[2], epsilon) &&
+    equalsApprox(a[3], b[3], epsilon)
+  );
+}

package/src/math/vec2.ts

@@ -0,0 +1,161 @@
+/**
+ * 2D vector operations.
+ */
+
+import { EPSILON, equalsApprox } from './common';
+import type { ReadonlyMat2d } from './mat2d';
+
+export type Vec2 = Float32Array & {
+  0: number;
+  1: number;
+};
+
+export type ReadonlyVec2 = ArrayLike<number> & {
+  0: number;
+  1: number;
+};
+
+export type WritableVec2 = Vec2 | [number, number];
+
+export function create(): Vec2 {
+  return new Float32Array(2) as unknown as Vec2;
+}
+
+export function fromValues(x: number, y: number): Vec2 {
+  const out = new Float32Array(2) as unknown as Vec2;
+  out[0] = x;
+  out[1] = y;
+  return out;
+}
+
+export function copy(out: Vec2, a: ReadonlyVec2): Vec2 {
+  out[0] = a[0];
+  out[1] = a[1];
+  return out;
+}
+
+export function set<T extends WritableVec2>(out: T, x: number, y: number): T {
+  out[0] = x;
+  out[1] = y;
+  return out;
+}
+
+export function add<T extends WritableVec2>(out: T, a: ReadonlyVec2, b: ReadonlyVec2): T {
+  out[0] = a[0] + b[0];
+  out[1] = a[1] + b[1];
+  return out;
+}
+
+export function subtract<T extends WritableVec2>(out: T, a: ReadonlyVec2, b: ReadonlyVec2): T {
+  out[0] = a[0] - b[0];
+  out[1] = a[1] - b[1];
+  return out;
+}
+
+export function multiply(out: Vec2, a: ReadonlyVec2, b: ReadonlyVec2): Vec2 {
+  out[0] = a[0] * b[0];
+  out[1] = a[1] * b[1];
+  return out;
+}
+
+export function scale<T extends WritableVec2>(out: T, a: ReadonlyVec2, b: number): T {
+  out[0] = a[0] * b;
+  out[1] = a[1] * b;
+  return out;
+}
+
+export function distance(a: ReadonlyVec2, b: ReadonlyVec2): number {
+  const x = b[0] - a[0];
+  const y = b[1] - a[1];
+  return Math.hypot(x, y);
+}
+
+export function length(a: ReadonlyVec2): number {
+  return Math.hypot(a[0], a[1]);
+}
+
+export function normalize<T extends WritableVec2>(out: T, a: ReadonlyVec2): T {
+  const x = a[0];
+  const y = a[1];
+  const len = Math.hypot(x, y);
+  out[0] = len === 0 ? 0 : x / len;
+  out[1] = len === 0 ? 0 : y / len;
+  return out;
+}
+
+export function dot(a: ReadonlyVec2, b: ReadonlyVec2): number {
+  return a[0] * b[0] + a[1] * b[1];
+}
+
+export function cross(a: ReadonlyVec2, b: ReadonlyVec2): number {
+  return a[0] * b[1] - a[1] * b[0];
+}
+
+export function lerp(out: Vec2, a: ReadonlyVec2, b: ReadonlyVec2, t: number): Vec2 {
+  const ax = a[0];
+  const ay = a[1];
+  out[0] = ax + t * (b[0] - ax);
+  out[1] = ay + t * (b[1] - ay);
+  return out;
+}
+
+export function clamp(
+  out: Vec2,
+  a: ReadonlyVec2,
+  min: ReadonlyVec2 | number,
+  max: ReadonlyVec2 | number
+): Vec2 {
+  const minX = typeof min === 'number' ? min : min[0];
+  const minY = typeof min === 'number' ? min : min[1];
+  const maxX = typeof max === 'number' ? max : max[0];
+  const maxY = typeof max === 'number' ? max : max[1];
+  out[0] = Math.min(Math.max(a[0], minX), maxX);
+  out[1] = Math.min(Math.max(a[1], minY), maxY);
+  return out;
+}
+
+export function transformMat2d<T extends WritableVec2>(
+  out: T,
+  a: ReadonlyVec2,
+  m: ReadonlyMat2d
+): T {
+  const x = a[0];
+  const y = a[1];
+  out[0] = m[0] * x + m[2] * y + m[4];
+  out[1] = m[1] * x + m[3] * y + m[5];
+  return out;
+}
+
+/** Transforms a direction by the linear part of an affine matrix. */
+export function transformDirectionMat2d<T extends WritableVec2>(
+  out: T,
+  a: ReadonlyVec2,
+  m: ReadonlyMat2d
+): T {
+  const x = a[0],
+    y = a[1];
+  out[0] = m[0] * x + m[2] * y;
+  out[1] = m[1] * x + m[3] * y;
+  return out;
+}
+
+/** Transforms a normal using the transpose of an already inverted affine matrix. */
+export function transformNormalMat2d<T extends WritableVec2>(
+  out: T,
+  a: ReadonlyVec2,
+  inverse: ReadonlyMat2d
+): T {
+  const x = a[0],
+    y = a[1];
+  out[0] = inverse[0] * x + inverse[1] * y;
+  out[1] = inverse[2] * x + inverse[3] * y;
+  return out;
+}
+
+export function exactEquals(a: ReadonlyVec2, b: ReadonlyVec2): boolean {
+  return a[0] === b[0] && a[1] === b[1];
+}
+
+export function equals(a: ReadonlyVec2, b: ReadonlyVec2, epsilon: number = EPSILON): boolean {
+  return equalsApprox(a[0], b[0], epsilon) && equalsApprox(a[1], b[1], epsilon);
+}