@perplexdotgg/bounce 1.0.0

package/src/math/quat.ts

@@ -0,0 +1,193 @@
+import { createClass, NumberType, PropertyDefinitionMap } from "monomorph";
+import { Vec3 } from "./vec3";
+import { Mat3, mat3Keys } from "./mat3";
+import { Mat4 } from "./mat4";
+
+export const quatKeys = ["x", "y", "z", "w"] as const;
+
+const quatProps = {
+  x: NumberType(0.0),
+  y: NumberType(0.0),
+  z: NumberType(0.0),
+  w: NumberType(1.0),
+} as const satisfies PropertyDefinitionMap;
+
+export class Quat extends createClass<Quat, typeof quatProps>(quatProps) {
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
+  }
+
+  normalize() {
+    const length = this.length();
+    if (length > 0) {
+      this.x /= length;
+      this.y /= length;
+      this.z /= length;
+      this.w /= length;
+    }
+
+    return this;
+  }
+
+  identity() {
+    this.x = 0;
+    this.y = 0;
+    this.z = 0;
+    this.w = 1;
+
+    return this;
+  }
+
+  conjugateQuat(a: Quat): Quat {
+    this.x = -a.x;
+    this.y = -a.y;
+    this.z = -a.z;
+    this.w = a.w;
+    return this;
+  }
+
+  multiplyQuats(a: Quat, b: Quat): Quat {
+    const ax = a.x;
+    const ay = a.y;
+    const az = a.z;
+    const aw = a.w;
+    const bx = b.x;
+    const by = b.y;
+    const bz = b.z;
+    const bw = b.w;
+
+    this.x = ax * bw + aw * bx + ay * bz - az * by;
+    this.y = ay * bw + aw * by + az * bx - ax * bz;
+    this.z = az * bw + aw * bz + ax * by - ay * bx;
+    this.w = aw * bw - ax * bx - ay * by - az * bz;
+    return this;
+  }
+
+  normalizeQuat(a: Quat): Quat {
+    const x = a.x;
+    const y = a.y;
+    const z = a.z;
+    const w = a.w;
+    let len = x * x + y * y + z * z + w * w;
+    if (len > 0) {
+      len = 1 / Math.sqrt(len);
+    }
+    this.x = x * len;
+    this.y = y * len;
+    this.z = z * len;
+    this.w = w * len;
+    return this;
+  }
+
+  setAxisAngle(axis: Vec3, angle: number): Quat {
+    angle = angle * 0.5;
+    let s = Math.sin(angle);
+    this.x = s * axis.x;
+    this.y = s * axis.y;
+    this.z = s * axis.z;
+    this.w = Math.cos(angle);
+    return this;
+  }
+
+  dot(b: Quat) {
+    return this.x * b.x + this.y * b.y + this.z * b.z + this.w * b.w;
+  }
+
+  notEquals(other: Quat, tolerance: number = 1e-6) {
+    return (
+      Math.abs(this.x - other.x) >= tolerance ||
+      Math.abs(this.y - other.y) >= tolerance ||
+      Math.abs(this.z - other.z) >= tolerance ||
+      Math.abs(this.w - other.w) >= tolerance
+    );
+  }
+
+  equals(other: Quat, tolerance: number = 1e-6) {
+    return (
+      Math.abs(this.x - other.x) < tolerance &&
+      Math.abs(this.y - other.y) < tolerance &&
+      Math.abs(this.z - other.z) < tolerance &&
+      Math.abs(this.w - other.w) < tolerance
+    );
+  }
+
+  intoEuler(out: Vec3) {
+    // if rotation angle is small, can use an approximation
+    // TODO: handle large angles
+    if (this.w < 0) {
+      out.x = -this.x * 2;
+      out.y = -this.y * 2;
+      out.z = -this.z * 2;
+    } else {
+      out.x = this.x * 2;
+      out.y = this.y * 2;
+      out.z = this.z * 2;
+    }
+
+    return this;
+  }
+
+  fromMat3(m: Mat3) {
+    // TODO: this will not work with structs due to array indexing
+
+    // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes
+    // article "Quaternion Calculus and Fast Animation".
+    let fTrace = m.e0 + m.e4 + m.e8;
+    let fRoot;
+
+    if (fTrace > 0.0) {
+      // |w| > 1/2, may as well choose w > 1/2
+      fRoot = Math.sqrt(fTrace + 1.0); // 2w
+      this.w = 0.5 * fRoot;
+      fRoot = 0.5 / fRoot; // 1/(4w)
+      this.x = (m.e5 - m.e7) * fRoot;
+      this.y = (m.e6 - m.e2) * fRoot;
+      this.z = (m.e1 - m.e3) * fRoot;
+    } else {
+      // |w| <= 1/2
+      let i = 0;
+      if (m.e4 > m.e0) i = 1;
+      if (m.e8 > m[mat3Keys[i * 3 + i]]) i = 2;
+      let j = (i + 1) % 3;
+      let k = (i + 2) % 3;
+
+      fRoot = Math.sqrt(m[mat3Keys[i * 3 + i]] - m[mat3Keys[j * 3 + j]] - m[mat3Keys[k * 3 + k]] + 1.0);
+      this[quatKeys[i]] = 0.5 * fRoot;
+      fRoot = 0.5 / fRoot;
+      this.w = (m[mat3Keys[j * 3 + k]] - m[mat3Keys[k * 3 + j]]) * fRoot;
+      this[quatKeys[j]] = (m[mat3Keys[j * 3 + i]] + m[mat3Keys[i * 3 + j]]) * fRoot;
+      this[quatKeys[k]] = (m[mat3Keys[k * 3 + i]] + m[mat3Keys[i * 3 + k]]) * fRoot;
+    }
+
+    return this;
+  }
+
+  fromMat4(m: Mat4) {
+    tempMat3.fromMat4(m);
+    this.fromMat3(tempMat3);
+    return this;
+  }
+
+  computeRotationAngle(axis: Vec3) {
+    if (this.w === 0.0) {
+      return Math.PI;
+    } else {
+      vector.x = this.x;
+      vector.y = this.y;
+      vector.z = this.z;
+      return 2 * Math.atan(vector.dot(axis) / this.w);
+    }
+  }
+
+  toObject() {
+    return {
+      x: this.x,
+      y: this.y,
+      z: this.z,
+      w: this.w,
+    };
+  }
+}
+
+const vector = /*@__PURE__*/ Vec3.create();
+const tempMat3 = /*@__PURE__*/ Mat3.create();

package/src/math/scalar.ts

@@ -0,0 +1,81 @@
+export function clamp(value: number, min: number, max: number) {
+  return Math.min(Math.max(min, value), max);
+}
+
+export function isClose(a: number, b: number, epsilon: number = 1e-10) {
+  return Math.abs(a - b) < epsilon;
+}
+
+export function squared(value: number) {
+  return value * value;
+}
+
+export function degreesToRadians(degrees: number) {
+  return degrees * (Math.PI / 180);
+}
+
+export function average(a: number, b: number) {
+  return (a + b) * 0.5;
+}
+
+export function equals(a: number, b: number, tolerance: number = 1e-6) {
+  return Math.abs(a - b) < tolerance;
+}
+
+export function isPowerOf2(value: number): boolean {
+  return Math.log2(value) % 1 === 0;
+}
+
+export const negativeOnePi = -1 * Math.PI;
+export const negativeTwoPi = -2 * Math.PI;
+export const positiveOnePi = +1 * Math.PI;
+export const positiveTwoPi = +2 * Math.PI;
+
+/**
+ * Normalize an angle to be in the interval [-π, +π].
+ * - slow for large angles
+ * - fast for small angles
+ * - guaranteed to return an angle in the interval [-π, +π]
+ * - raises an exception for NaN or -/+ Infinity
+ */
+export function normalizeBetweenMinusPiAndPi(angle: number): number {
+  if (Number.isFinite(angle) === false) {
+    throw new Error(`expected finite angle, got ${angle} instead`);
+  }
+
+  let result = angle;
+
+  // case: angle is less than -π
+  if (angle < negativeOnePi) {
+    while (result <= negativeOnePi) {
+      result += positiveTwoPi;
+    }
+  }
+  // case: angle is greater than +π
+  else if (angle > positiveOnePi) {
+    while (result >= positiveOnePi) {
+      result += negativeTwoPi;
+    }
+  }
+
+  return result;
+}
+
+export function computeClosestPowersOfTwo(n: number): { previous: number; next: number } {
+  if (n < 1) {
+    throw new Error("n must be positive");
+  }
+
+  // If n is already a power of two
+  if ((n & (n - 1)) === 0) {
+    return { previous: n, next: n };
+  }
+
+  // Previous power of two (most significant bit)
+  const previous = 1 << Math.floor(Math.log2(n));
+
+  // Next power of two
+  const next = 1 << Math.ceil(Math.log2(n));
+
+  return { previous, next };
+}

package/src/math/tensor.ts

@@ -0,0 +1,17 @@
+import { Mat3 } from "./mat3";
+import { Quat } from "./quat";
+
+const normalizedOrientation = /*@__PURE__*/ Quat.create();
+const localToWorldRotation = /*@__PURE__*/ Mat3.create();
+const worldToLocalRotation = /*@__PURE__*/ Mat3.create();
+
+export function transformTensor(out: Mat3, tensor: Mat3, orientation: Quat) {
+  // create rotation transformation matrices
+  normalizedOrientation.normalizeQuat(orientation);
+  localToWorldRotation.fromQuat(normalizedOrientation);
+  worldToLocalRotation.invertMat3(localToWorldRotation);
+
+  // transform tensor
+  out.multiplyMat3s(localToWorldRotation, tensor);
+  out.multiplyMat3s(out, worldToLocalRotation);
+}