@perplexdotgg/bounce 1.0.0 → 1.0.1

package/src/math/quat.ts

@@ -1,193 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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);
-}