@perplexdotgg/bounce 1.0.0

package/src/math/vec3.ts

@@ -0,0 +1,589 @@
+import { createClass, NumberType, PropertyDefinitionMap } from "monomorph";
+import { Mat3 } from "./mat3";
+import { Mat4 } from "./mat4";
+import { Quat } from "./quat";
+
+const componentIndexToKeyMap = ["x", "y", "z"] as const;
+
+export function squaredDistance(a: Vec3, b: Vec3) {
+  let x = b.x - a.x;
+  let y = b.y - a.y;
+  let z = b.z - a.z;
+  return x * x + y * y + z * z;
+}
+
+const vec3Props = {
+  x: NumberType(0),
+  y: NumberType(0),
+  z: NumberType(0),
+} as const satisfies PropertyDefinitionMap;
+
+export class Vec3 extends createClass<Vec3, typeof vec3Props>(vec3Props) {
+  toObject() {
+    return {
+      x: this.x,
+      y: this.y,
+      z: this.z,
+    };
+  }
+
+  addVector(a: Vec3) {
+    this.x += a.x;
+    this.y += a.y;
+    this.z += a.z;
+    return this;
+  }
+
+  addVectors(a: Vec3, b: Vec3) {
+    this.x = a.x + b.x;
+    this.y = a.y + b.y;
+    this.z = a.z + b.z;
+    return this;
+  }
+
+  subtractVector(other: Vec3) {
+    this.x -= other.x;
+    this.y -= other.y;
+    this.z -= other.z;
+    return this;
+  }
+
+  subtractVectors(a: Vec3, b: Vec3) {
+    this.x = a.x - b.x;
+    this.y = a.y - b.y;
+    this.z = a.z - b.z;
+    return this;
+  }
+
+  scale(scale: number) {
+    this.x *= scale;
+    this.y *= scale;
+    this.z *= scale;
+    return this;
+  }
+
+  scaleVector(other: Vec3, scale: number) {
+    this.x = other.x * scale;
+    this.y = other.y * scale;
+    this.z = other.z * scale;
+    return this;
+  }
+
+  addScaled(other: Vec3, scale: number) {
+    this.x += other.x * scale;
+    this.y += other.y * scale;
+    this.z += other.z * scale;
+    return this;
+  }
+
+  addScaledToVector(a: Vec3, b: Vec3, scale: number) {
+    this.x = a.x + b.x * scale;
+    this.y = a.y + b.y * scale;
+    this.z = a.z + b.z * scale;
+    return this;
+  }
+
+  negate() {
+    this.x = -this.x;
+    this.y = -this.y;
+    this.z = -this.z;
+    return this;
+  }
+
+  negateVector(a: Vec3) {
+    this.x = -a.x;
+    this.y = -a.y;
+    this.z = -a.z;
+    return this;
+  }
+
+  normalize() {
+    const x = this.x;
+    const y = this.y;
+    const z = this.z;
+
+    let length = x * x + y * y + z * z;
+    if (length > 0) {
+      length = 1 / Math.sqrt(length);
+    }
+
+    this.x = this.x * length;
+    this.y = this.y * length;
+    this.z = this.z * length;
+
+    return this;
+  }
+
+  normalizeVector(a: Vec3) {
+    const x = a.x;
+    const y = a.y;
+    const z = a.z;
+
+    let length = x * x + y * y + z * z;
+    if (length > 0) {
+      length = 1 / Math.sqrt(length);
+    }
+
+    this.x = x * length;
+    this.y = y * length;
+    this.z = z * length;
+
+    return this;
+  }
+
+  crossVector(other: Vec3) {
+    const ax = this.x;
+    const ay = this.y;
+    const az = this.z;
+
+    const bx = other.x;
+    const by = other.y;
+    const bz = other.z;
+
+    this.x = ay * bz - az * by;
+    this.y = az * bx - ax * bz;
+    this.z = ax * by - ay * bx;
+    return this;
+  }
+
+  crossVectors(a: Vec3, b: Vec3) {
+    const ax = a.x;
+    const ay = a.y;
+    const az = a.z;
+
+    const bx = b.x;
+    const by = b.y;
+    const bz = b.z;
+
+    this.x = ay * bz - az * by;
+    this.y = az * bx - ax * bz;
+    this.z = ax * by - ay * bx;
+    return this;
+  }
+
+  zero() {
+    this.x = 0;
+    this.y = 0;
+    this.z = 0;
+    return this;
+  }
+
+  length() {
+    const x = this.x;
+    const y = this.y;
+    const z = this.z;
+    return Math.sqrt(x * x + y * y + z * z);
+  }
+
+  squaredLength() {
+    const x = this.x;
+    const y = this.y;
+    const z = this.z;
+    return x * x + y * y + z * z;
+  }
+
+  dot(other: Vec3) {
+    return this.x * other.x + this.y * other.y + this.z * other.z;
+  }
+
+  transformFromMat3(matrix: Mat3) {
+    const x = this.x;
+    const y = this.y;
+    const z = this.z;
+
+    this.x = x * matrix.e0 + y * matrix.e3 + z * matrix.e6;
+    this.y = x * matrix.e1 + y * matrix.e4 + z * matrix.e7;
+    this.z = x * matrix.e2 + y * matrix.e5 + z * matrix.e8;
+
+    return this;
+  }
+
+  transformVectorFromMat3(vector: Vec3, matrix: Mat3) {
+    const x = vector.x;
+    const y = vector.y;
+    const z = vector.z;
+
+    this.x = x * matrix.e0 + y * matrix.e3 + z * matrix.e6;
+    this.y = x * matrix.e1 + y * matrix.e4 + z * matrix.e7;
+    this.z = x * matrix.e2 + y * matrix.e5 + z * matrix.e8;
+
+    return this;
+  }
+
+  transformFromMat4(matrix: Mat4) {
+    const x = this.x;
+    const y = this.y;
+    const z = this.z;
+
+    let w = matrix.e3 * x + matrix.e7 * y + matrix.e11 * z + matrix.e15;
+    w = w || 1.0;
+
+    this.x = (matrix.e0 * x + matrix.e4 * y + matrix.e8 * z + matrix.e12) / w;
+    this.y = (matrix.e1 * x + matrix.e5 * y + matrix.e9 * z + matrix.e13) / w;
+    this.z = (matrix.e2 * x + matrix.e6 * y + matrix.e10 * z + matrix.e14) / w;
+
+    return this;
+  }
+
+  transformVectorFromMat4(vector: Vec3, matrix: Mat4) {
+    const x = vector.x;
+    const y = vector.y;
+    const z = vector.z;
+
+    let w = matrix.e3 * x + matrix.e7 * y + matrix.e11 * z + matrix.e15;
+    w = w || 1.0;
+
+    this.x = (matrix.e0 * x + matrix.e4 * y + matrix.e8 * z + matrix.e12) / w;
+    this.y = (matrix.e1 * x + matrix.e5 * y + matrix.e9 * z + matrix.e13) / w;
+    this.z = (matrix.e2 * x + matrix.e6 * y + matrix.e10 * z + matrix.e14) / w;
+
+    return this;
+  }
+
+  isNearZero(squaredTolerance: number = 1e-6) {
+    return this.squaredLength() <= squaredTolerance;
+  }
+
+  // TODO: refactor this to match new function and naming style, a bit tricky to do until everything is working
+  normalizedOr(out: Vec3, safeFallback: Vec3) {
+    if (this.isNearZero()) {
+      out.copy(safeFallback);
+    } else {
+      out.normalizeVector(this);
+    }
+  }
+
+  swap(other: Vec3) {
+    temp.x = this.x;
+    temp.y = this.y;
+    temp.z = this.z;
+
+    this.x = other.x;
+    this.y = other.y;
+    this.z = other.z;
+
+    other.x = temp.x;
+    other.y = temp.y;
+    other.z = temp.z;
+  }
+
+  transformByMat4(matrix: Mat4) {
+    const x = this.x;
+    const y = this.y;
+    const z = this.z;
+
+    let w = matrix.e3 * x + matrix.e7 * y + matrix.e11 * z + matrix.e15;
+    w = w || 1.0;
+
+    this.x = (matrix.e0 * x + matrix.e4 * y + matrix.e8 * z + matrix.e12) / w;
+    this.y = (matrix.e1 * x + matrix.e5 * y + matrix.e9 * z + matrix.e13) / w;
+    this.z = (matrix.e2 * x + matrix.e6 * y + matrix.e10 * z + matrix.e14) / w;
+
+    return this;
+  }
+
+  transformByQuat(quaternion: Quat) {
+    const qx = quaternion.x;
+    const qy = quaternion.y;
+    const qz = quaternion.z;
+    const qw = quaternion.w;
+
+    const x = this.x;
+    const y = this.y;
+    const z = this.z;
+
+    const uvx = qy * z - qz * y;
+    const uvy = qz * x - qx * z;
+    const uvz = qx * y - qy * x;
+
+    const uuvx = qy * uvz - qz * uvy;
+    const uuvy = qz * uvx - qx * uvz;
+    const uuvz = qx * uvy - qy * uvx;
+
+    let w2 = qw * 2;
+
+    this.x = x + w2 * uvx + 2 * uuvx;
+    this.y = y + w2 * uvy + 2 * uuvy;
+    this.z = z + w2 * uvz + 2 * uuvz;
+
+    return this;
+  }
+
+  transformVectorByQuat(a: Vec3, quaternion: Quat) {
+    const qx = quaternion.x;
+    const qy = quaternion.y;
+    const qz = quaternion.z;
+    const qw = quaternion.w;
+
+    const x = a.x;
+    const y = a.y;
+    const z = a.z;
+
+    const uvx = qy * z - qz * y;
+    const uvy = qz * x - qx * z;
+    const uvz = qx * y - qy * x;
+
+    const uuvx = qy * uvz - qz * uvy;
+    const uuvy = qz * uvx - qx * uvz;
+    const uuvz = qx * uvy - qy * uvx;
+
+    let w2 = qw * 2;
+
+    this.x = x + w2 * uvx + 2 * uuvx;
+    this.y = y + w2 * uvy + 2 * uuvy;
+    this.z = z + w2 * uvz + 2 * uuvz;
+
+    return this;
+  }
+
+  distance(other: Vec3) {
+    const x = other.x - this.x;
+    const y = other.y - this.y;
+    const z = other.z - this.z;
+    return Math.sqrt(x * x + y * y + z * z);
+  }
+
+  applyQuatThenAddToVector(a: Vec3, r: Quat, b: Vec3) {
+    rb.transformVectorByQuat(b, r);
+    this.addVectors(a, rb);
+    return this;
+  }
+
+  replicate(value: number) {
+    this.x = value;
+    this.y = value;
+    this.z = value;
+  }
+
+  getComponentAtIndex(index: number) {
+    return this[componentIndexToKeyMap[index]];
+  }
+
+  setComponentAtIndex(index: number, value: number) {
+    this[componentIndexToKeyMap[index]] = value;
+    return this;
+  }
+
+  isNormalized(tolerance: number = 1e-3) {
+    return Math.abs(this.length() - 1) < tolerance;
+  }
+
+  computeNormalizedPerpendicular(vector: Vec3) {
+    if (Math.abs(vector.x) > Math.abs(vector.y)) {
+      const len = Math.sqrt(vector.x * vector.x + vector.z * vector.z);
+      this.x = vector.z / len;
+      this.y = 0;
+      this.z = -vector.x / len;
+    } else {
+      const len = Math.sqrt(vector.y * vector.y + vector.z * vector.z);
+      this.x = 0;
+      this.y = vector.z / len;
+      this.z = -vector.y / len;
+    }
+  }
+
+  isClose(other: Vec3, tolerance: number = 1e-6) {
+    return squaredDistance(this, other) <= tolerance;
+  }
+
+  isCloseToZero(tolerance: number = 1e-6) {
+    return this.squaredLength() <= tolerance;
+  }
+
+  averageOfVectors(a: Vec3, b: Vec3) {
+    this.x = (a.x + b.x) * 0.5;
+    this.y = (a.y + b.y) * 0.5;
+    this.z = (a.z + b.z) * 0.5;
+  }
+
+  absNorm() {
+    return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z);
+  }
+
+  isUnitVector(tolerance: number = 1e-3) {
+    return Math.abs(this.length() - 1) < tolerance;
+  }
+
+  addScalar(s: number) {
+    this.x = this.x + s;
+    this.y = this.y + s;
+    this.z = this.z + s;
+    return this;
+  }
+
+  addScalarToVector(a: Vec3, s: number) {
+    this.x = a.x + s;
+    this.y = a.y + s;
+    this.z = a.z + s;
+    return this;
+  }
+
+  squaredDistance(b: Vec3) {
+    const x = b.x - this.x;
+    const y = b.y - this.y;
+    const z = b.z - this.z;
+    return x * x + y * y + z * z;
+  }
+
+  notEquals(other: Vec3, 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
+    );
+  }
+
+  equals(other: Vec3, 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
+    );
+  }
+
+  minVector(a: Vec3) {
+    this.x = Math.min(this.x, a.x);
+    this.y = Math.min(this.y, a.y);
+    this.z = Math.min(this.z, a.z);
+    return this;
+  }
+
+  minVectors(a: Vec3, b: Vec3) {
+    this.x = Math.min(a.x, b.x);
+    this.y = Math.min(a.y, b.y);
+    this.z = Math.min(a.z, b.z);
+    return this;
+  }
+
+  maxVector(a: Vec3) {
+    this.x = Math.max(this.x, a.x);
+    this.y = Math.max(this.y, a.y);
+    this.z = Math.max(this.z, a.z);
+    return this;
+  }
+
+  maxVectors(a: Vec3, b: Vec3) {
+    this.x = Math.max(a.x, b.x);
+    this.y = Math.max(a.y, b.y);
+    this.z = Math.max(a.z, b.z);
+    return this;
+  }
+
+  computeMaxAxis() {
+    const absX = Math.abs(this.x);
+    const absY = Math.abs(this.y);
+    const absZ = Math.abs(this.z);
+    if (absX >= absY && absX >= absZ) {
+      return 0;
+    }
+    if (absY >= absX && absY >= absZ) {
+      return 1;
+    }
+    return 2;
+  }
+
+  computeMaxComponent() {
+    const absX = Math.abs(this.x);
+    const absY = Math.abs(this.y);
+    const absZ = Math.abs(this.z);
+    if (absX >= absY && absX >= absZ) {
+      return "x";
+    }
+    if (absY >= absX && absY >= absZ) {
+      return "y";
+    }
+    return "z";
+  }
+
+  abs() {
+    this.x = Math.abs(this.x);
+    this.y = Math.abs(this.y);
+    this.z = Math.abs(this.z);
+    return this;
+  }
+
+  absVector(a: Vec3) {
+    this.x = Math.abs(a.x);
+    this.y = Math.abs(a.y);
+    this.z = Math.abs(a.z);
+    return this;
+  }
+
+  computeLowestComponentIndex(): number {
+    return this.x < this.y ? (this.z < this.x ? 2 : 0) : this.z < this.y ? 2 : 1;
+  }
+
+  projectOnPlane(normal: Vec3) {
+    const dot = this.dot(normal);
+    this.x -= normal.x * dot;
+    this.y -= normal.y * dot;
+  }
+
+  projectOnVector(vector: Vec3): void {
+    const projectionAmount = this.dot(vector) / vector.dot(vector);
+    this.x = vector.x * projectionAmount;
+    this.y = vector.y * projectionAmount;
+    this.z = vector.z * projectionAmount;
+  }
+
+  isExactlyZero() {
+    return this.x === 0 && this.y === 0 && this.z === 0;
+  }
+
+  addScaledVector(vector: Vec3, scalar: number) {
+    this.x += vector.x * scalar;
+    this.y += vector.y * scalar;
+    this.z += vector.z * scalar;
+    return this;
+  }
+
+  subScaledVector(vector: Vec3, scalar: number) {
+    this.x -= vector.x * scalar;
+    this.y -= vector.y * scalar;
+    this.z -= vector.z * scalar;
+    return this;
+  }
+
+  addRotatedVector(vector: Vec3, rotation: Mat3) {
+    rotatedVector.transformVectorFromMat3(vector, rotation);
+    this.x += rotatedVector.x;
+    this.y += rotatedVector.y;
+    this.z += rotatedVector.z;
+    return this;
+  }
+
+  subRotatedVector(vector: Vec3, rotation: Mat3) {
+    rotatedVector.transformVectorFromMat3(vector, rotation);
+    this.x -= rotatedVector.x;
+    this.y -= rotatedVector.y;
+    this.z -= rotatedVector.z;
+    return this;
+  }
+
+  exactEquals(b: Vec3) {
+    return this.x === b.x && this.y === b.y && this.z === b.z;
+  }
+
+  multiplyVectors(a: Vec3, b: Vec3) {
+    this.x = a.x * b.x;
+    this.y = a.y * b.y;
+    this.z = a.z * b.z;
+    return this;
+  }
+
+  rotateVectorByMat4(vector: Vec3, matrix: Mat4) {
+    rotationMatrix.fromMat4(matrix);
+    this.transformVectorFromMat3(vector, rotationMatrix);
+  }
+
+  distanceXZ(other: Vec3) {
+    const dx = other.x - this.x;
+    const dz = other.z - this.z;
+    return Math.sqrt(dx * dx + dz * dz);
+  }
+}
+
+const rb = /*@__PURE__*/ Vec3.create();
+const temp = /*@__PURE__*/ Vec3.create();
+const rotatedVector = /*@__PURE__*/ Vec3.create();
+const rotationMatrix = /*@__PURE__*/ Mat3.create();

package/src/math/vec4.ts

@@ -0,0 +1,10 @@
+import { createClass, NumberType, PropertyDefinitionMap } from "monomorph";
+
+const vec4Props = {
+  x: NumberType(0),
+  y: NumberType(0),
+  z: NumberType(0),
+  w: NumberType(0),
+} as const satisfies PropertyDefinitionMap;
+
+export class Vec4 extends createClass<Vec4, typeof vec4Props>(vec4Props) {}