planck-v2 2.0.0

package/src/common/Mat22.ts

@@ -0,0 +1,221 @@
+/*
+ * Planck.js
+ *
+ * Copyright (c) Erin Catto, Ali Shakiba
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { Vec2, Vec2Value } from "./Vec2";
+
+/** @internal */ const _ASSERT = typeof ASSERT === "undefined" ? false : ASSERT;
+
+/** A 2-by-2 matrix. Stored in column-major order. */
+export interface Mat22Value {
+  ex: Vec2Value;
+  ey: Vec2Value;
+}
+
+/**
+ * A 2-by-2 matrix. Stored in column-major order.
+ * 
+ * @deprecated Use Mat22Value and geo functions instead.
+ */
+export class Mat22 {
+  ex: Vec2;
+  ey: Vec2;
+
+  constructor(a: number, b: number, c: number, d: number);
+  constructor(a: { x: number; y: number }, b: { x: number; y: number });
+  constructor();
+  constructor(a?, b?, c?, d?) {
+    if (typeof a === "object" && a !== null) {
+      this.ex = Vec2.clone(a);
+      this.ey = Vec2.clone(b);
+    } else if (typeof a === "number") {
+      this.ex = Vec2.neo(a, c);
+      this.ey = Vec2.neo(b, d);
+    } else {
+      this.ex = Vec2.zero();
+      this.ey = Vec2.zero();
+    }
+  }
+
+  /** @hidden */
+  toString(): string {
+    return JSON.stringify(this);
+  }
+
+  static isValid(obj: any): boolean {
+    if (obj === null || typeof obj === "undefined") {
+      return false;
+    }
+    return Vec2.isValid(obj.ex) && Vec2.isValid(obj.ey);
+  }
+
+  static assert(o: any): void {
+    if (_ASSERT) console.assert(!Mat22.isValid(o), "Invalid Mat22!", o);
+  }
+
+  set(a: Mat22): void;
+  set(a: Vec2Value, b: Vec2Value): void;
+  set(a: number, b: number, c: number, d: number): void;
+  set(a, b?, c?, d?): void {
+    if (typeof a === "number" && typeof b === "number" && typeof c === "number" && typeof d === "number") {
+      this.ex.setNum(a, c);
+      this.ey.setNum(b, d);
+    } else if (typeof a === "object" && typeof b === "object") {
+      this.ex.setVec2(a);
+      this.ey.setVec2(b);
+    } else if (typeof a === "object") {
+      if (_ASSERT) Mat22.assert(a);
+      this.ex.setVec2(a.ex);
+      this.ey.setVec2(a.ey);
+    } else {
+      if (_ASSERT) console.assert(false);
+    }
+  }
+
+  setIdentity(): void {
+    this.ex.x = 1.0;
+    this.ey.x = 0.0;
+    this.ex.y = 0.0;
+    this.ey.y = 1.0;
+  }
+
+  setZero(): void {
+    this.ex.x = 0.0;
+    this.ey.x = 0.0;
+    this.ex.y = 0.0;
+    this.ey.y = 0.0;
+  }
+
+  getInverse(): Mat22 {
+    const a = this.ex.x;
+    const b = this.ey.x;
+    const c = this.ex.y;
+    const d = this.ey.y;
+    let det = a * d - b * c;
+    if (det !== 0.0) {
+      det = 1.0 / det;
+    }
+    const imx = new Mat22();
+    imx.ex.x = det * d;
+    imx.ey.x = -det * b;
+    imx.ex.y = -det * c;
+    imx.ey.y = det * a;
+    return imx;
+  }
+
+  /**
+   * Solve A * x = b, where b is a column vector. This is more efficient than
+   * computing the inverse in one-shot cases.
+   */
+  solve(v: Vec2Value): Vec2 {
+    if (_ASSERT) Vec2.assert(v);
+    const a = this.ex.x;
+    const b = this.ey.x;
+    const c = this.ex.y;
+    const d = this.ey.y;
+    let det = a * d - b * c;
+    if (det !== 0.0) {
+      det = 1.0 / det;
+    }
+    const w = Vec2.zero();
+    w.x = det * (d * v.x - b * v.y);
+    w.y = det * (a * v.y - c * v.x);
+    return w;
+  }
+
+  /**
+   * Multiply a matrix times a vector. If a rotation matrix is provided, then this
+   * transforms the vector from one frame to another.
+   */
+  static mul(mx: Mat22, my: Mat22): Mat22;
+  static mul(mx: Mat22, v: Vec2Value): Vec2;
+  static mul(mx, v) {
+    if (v && "x" in v && "y" in v) {
+      if (_ASSERT) Vec2.assert(v);
+      const x = mx.ex.x * v.x + mx.ey.x * v.y;
+      const y = mx.ex.y * v.x + mx.ey.y * v.y;
+      return Vec2.neo(x, y);
+    } else if (v && "ex" in v && "ey" in v) {
+      // Mat22
+      if (_ASSERT) Mat22.assert(v);
+      // return new Mat22(Vec2.mul(mx, v.ex), Vec2.mul(mx, v.ey));
+      const a = mx.ex.x * v.ex.x + mx.ey.x * v.ex.y;
+      const b = mx.ex.x * v.ey.x + mx.ey.x * v.ey.y;
+      const c = mx.ex.y * v.ex.x + mx.ey.y * v.ex.y;
+      const d = mx.ex.y * v.ey.x + mx.ey.y * v.ey.y;
+      return new Mat22(a, b, c, d);
+    }
+
+    if (_ASSERT) console.assert(false);
+  }
+
+  static mulVec2(mx: Mat22, v: Vec2Value): Vec2 {
+    if (_ASSERT) Vec2.assert(v);
+    const x = mx.ex.x * v.x + mx.ey.x * v.y;
+    const y = mx.ex.y * v.x + mx.ey.y * v.y;
+    return Vec2.neo(x, y);
+  }
+
+  static mulMat22(mx: Mat22, v: Mat22): Mat22 {
+    if (_ASSERT) Mat22.assert(v);
+    // return new Mat22(Vec2.mul(mx, v.ex), Vec2.mul(mx, v.ey));
+    const a = mx.ex.x * v.ex.x + mx.ey.x * v.ex.y;
+    const b = mx.ex.x * v.ey.x + mx.ey.x * v.ey.y;
+    const c = mx.ex.y * v.ex.x + mx.ey.y * v.ex.y;
+    const d = mx.ex.y * v.ey.x + mx.ey.y * v.ey.y;
+    return new Mat22(a, b, c, d);
+  }
+
+  /**
+   * Multiply a matrix transpose times a vector. If a rotation matrix is provided,
+   * then this transforms the vector from one frame to another (inverse
+   * transform).
+   */
+  static mulT(mx: Mat22, my: Mat22): Mat22;
+  static mulT(mx: Mat22, v: Vec2Value): Vec2;
+  static mulT(mx, v) {
+    if (v && "x" in v && "y" in v) {
+      // Vec2
+      if (_ASSERT) Vec2.assert(v);
+      return Vec2.neo(Vec2.dot(v, mx.ex), Vec2.dot(v, mx.ey));
+    } else if (v && "ex" in v && "ey" in v) {
+      // Mat22
+      if (_ASSERT) Mat22.assert(v);
+      const c1 = Vec2.neo(Vec2.dot(mx.ex, v.ex), Vec2.dot(mx.ey, v.ex));
+      const c2 = Vec2.neo(Vec2.dot(mx.ex, v.ey), Vec2.dot(mx.ey, v.ey));
+      return new Mat22(c1, c2);
+    }
+
+    if (_ASSERT) console.assert(false);
+  }
+
+  static mulTVec2(mx: Mat22, v: Vec2Value): Vec2 {
+    if (_ASSERT) Mat22.assert(mx);
+    if (_ASSERT) Vec2.assert(v);
+    return Vec2.neo(Vec2.dot(v, mx.ex), Vec2.dot(v, mx.ey));
+  }
+
+  static mulTMat22(mx: Mat22, v: Mat22): Mat22 {
+    if (_ASSERT) Mat22.assert(mx);
+    if (_ASSERT) Mat22.assert(v);
+    const c1 = Vec2.neo(Vec2.dot(mx.ex, v.ex), Vec2.dot(mx.ey, v.ex));
+    const c2 = Vec2.neo(Vec2.dot(mx.ex, v.ey), Vec2.dot(mx.ey, v.ey));
+    return new Mat22(c1, c2);
+  }
+
+  static abs(mx: Mat22): Mat22 {
+    if (_ASSERT) Mat22.assert(mx);
+    return new Mat22(Vec2.abs(mx.ex), Vec2.abs(mx.ey));
+  }
+
+  static add(mx1: Mat22, mx2: Mat22): Mat22 {
+    if (_ASSERT) Mat22.assert(mx1);
+    if (_ASSERT) Mat22.assert(mx2);
+    return new Mat22(Vec2.add(mx1.ex, mx2.ex), Vec2.add(mx1.ey, mx2.ey));
+  }
+}

package/src/common/Mat33.ts

@@ -0,0 +1,224 @@
+/*
+ * Planck.js
+ *
+ * Copyright (c) Erin Catto, Ali Shakiba
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { Vec2, Vec2Value } from "./Vec2";
+import { Vec3, Vec3Value } from "./Vec3";
+
+/** @internal */ const _ASSERT = typeof ASSERT === "undefined" ? false : ASSERT;
+
+/** A 3-by-3 matrix. Stored in column-major order. */
+export interface Mat33Value {
+  ex: Vec3Value;
+  ey: Vec3Value;
+  ez: Vec3Value;
+}
+
+/**
+ * A 3-by-3 matrix. Stored in column-major order.
+ * 
+ * @deprecated Use Mat33Value and geo functions instead.
+ */
+export class Mat33 {
+  ex: Vec3;
+  ey: Vec3;
+  ez: Vec3;
+
+  constructor(a: Vec3Value, b: Vec3Value, c: Vec3Value);
+  constructor();
+  constructor(a?: Vec3Value, b?: Vec3Value, c?: Vec3Value) {
+    if (typeof a === "object" && a !== null) {
+      this.ex = Vec3.clone(a);
+      this.ey = Vec3.clone(b);
+      this.ez = Vec3.clone(c);
+    } else {
+      this.ex = Vec3.zero();
+      this.ey = Vec3.zero();
+      this.ez = Vec3.zero();
+    }
+  }
+
+  /** @hidden */
+  toString(): string {
+    return JSON.stringify(this);
+  }
+
+  static isValid(obj: any): boolean {
+    if (obj === null || typeof obj === "undefined") {
+      return false;
+    }
+    return Vec3.isValid(obj.ex) && Vec3.isValid(obj.ey) && Vec3.isValid(obj.ez);
+  }
+
+  static assert(o: any): void {
+    if (_ASSERT) console.assert(!Mat33.isValid(o), "Invalid Mat33!", o);
+  }
+
+  /**
+   * Set this matrix to all zeros.
+   */
+  setZero(): Mat33 {
+    this.ex.setZero();
+    this.ey.setZero();
+    this.ez.setZero();
+    return this;
+  }
+
+  /**
+   * Solve A * x = b, where b is a column vector. This is more efficient than
+   * computing the inverse in one-shot cases.
+   */
+  solve33(v: Vec3Value): Vec3 {
+    // let det = matrix.dotVec3(this.ex, matrix.newCrossVec3(this.ey, this.ez));
+    let cross_x = this.ey.y * this.ez.z - this.ey.z * this.ez.y;
+    let cross_y = this.ey.z * this.ez.x - this.ey.x * this.ez.z;
+    let cross_z = this.ey.x * this.ez.y - this.ey.y * this.ez.x;
+    let det = this.ex.x * cross_x + this.ex.y * cross_y + this.ex.z * cross_z;
+    if (det !== 0.0) {
+      det = 1.0 / det;
+    }
+    const r = new Vec3();
+    // r.x = det * matrix.dotVec3(v, matrix.newCrossVec3(this.ey, this.ez));
+    cross_x = this.ey.y * this.ez.z - this.ey.z * this.ez.y;
+    cross_y = this.ey.z * this.ez.x - this.ey.x * this.ez.z;
+    cross_z = this.ey.x * this.ez.y - this.ey.y * this.ez.x;
+    r.x = det * (v.x * cross_x + v.y * cross_y + v.z * cross_z);
+
+    // r.y = det * matrix.dotVec3(this.ex, matrix.newCrossVec3(v, this.ez));
+    cross_x = v.y * this.ez.z - v.z * this.ez.y;
+    cross_y = v.z * this.ez.x - v.x * this.ez.z;
+    cross_z = v.x * this.ez.y - v.y * this.ez.x;
+    r.y = det * (this.ex.x * cross_x + this.ex.y * cross_y + this.ex.z * cross_z);
+
+    // r.z = det * matrix.dotVec3(this.ex, matrix.newCrossVec3(this.ey, v));
+    cross_x = this.ey.y * v.z - this.ey.z * v.y;
+    cross_y = this.ey.z * v.x - this.ey.x * v.z;
+    cross_z = this.ey.x * v.y - this.ey.y * v.x;
+    r.z = det * (this.ex.x * cross_x + this.ex.y * cross_y + this.ex.z * cross_z);
+    return r;
+  }
+
+  /**
+   * Solve A * x = b, where b is a column vector. This is more efficient than
+   * computing the inverse in one-shot cases. Solve only the upper 2-by-2 matrix
+   * equation.
+   */
+  solve22(v: Vec2Value): Vec2 {
+    const a11 = this.ex.x;
+    const a12 = this.ey.x;
+    const a21 = this.ex.y;
+    const a22 = this.ey.y;
+    let det = a11 * a22 - a12 * a21;
+    if (det !== 0.0) {
+      det = 1.0 / det;
+    }
+    const r = Vec2.zero();
+    r.x = det * (a22 * v.x - a12 * v.y);
+    r.y = det * (a11 * v.y - a21 * v.x);
+    return r;
+  }
+
+  /**
+   * Get the inverse of this matrix as a 2-by-2. Returns the zero matrix if
+   * singular.
+   */
+  getInverse22(M: Mat33): void {
+    const a = this.ex.x;
+    const b = this.ey.x;
+    const c = this.ex.y;
+    const d = this.ey.y;
+    let det = a * d - b * c;
+    if (det !== 0.0) {
+      det = 1.0 / det;
+    }
+    M.ex.x = det * d;
+    M.ey.x = -det * b;
+    M.ex.z = 0.0;
+    M.ex.y = -det * c;
+    M.ey.y = det * a;
+    M.ey.z = 0.0;
+    M.ez.x = 0.0;
+    M.ez.y = 0.0;
+    M.ez.z = 0.0;
+  }
+
+  /**
+   * Get the symmetric inverse of this matrix as a 3-by-3. Returns the zero matrix
+   * if singular.
+   */
+  getSymInverse33(M: Mat33): void {
+    let det = Vec3.dot(this.ex, Vec3.cross(this.ey, this.ez));
+    if (det !== 0.0) {
+      det = 1.0 / det;
+    }
+    const a11 = this.ex.x;
+    const a12 = this.ey.x;
+    const a13 = this.ez.x;
+    const a22 = this.ey.y;
+    const a23 = this.ez.y;
+    const a33 = this.ez.z;
+
+    M.ex.x = det * (a22 * a33 - a23 * a23);
+    M.ex.y = det * (a13 * a23 - a12 * a33);
+    M.ex.z = det * (a12 * a23 - a13 * a22);
+
+    M.ey.x = M.ex.y;
+    M.ey.y = det * (a11 * a33 - a13 * a13);
+    M.ey.z = det * (a13 * a12 - a11 * a23);
+
+    M.ez.x = M.ex.z;
+    M.ez.y = M.ey.z;
+    M.ez.z = det * (a11 * a22 - a12 * a12);
+  }
+
+  /**
+   * Multiply a matrix times a vector.
+   */
+  static mul(a: Mat33, b: Vec2Value): Vec2;
+  static mul(a: Mat33, b: Vec3Value): Vec3;
+  static mul(a, b) {
+    if (_ASSERT) Mat33.assert(a);
+    if (b && "z" in b && "y" in b && "x" in b) {
+      if (_ASSERT) Vec3.assert(b);
+      const x = a.ex.x * b.x + a.ey.x * b.y + a.ez.x * b.z;
+      const y = a.ex.y * b.x + a.ey.y * b.y + a.ez.y * b.z;
+      const z = a.ex.z * b.x + a.ey.z * b.y + a.ez.z * b.z;
+      return new Vec3(x, y, z);
+    } else if (b && "y" in b && "x" in b) {
+      if (_ASSERT) Vec2.assert(b);
+      const x = a.ex.x * b.x + a.ey.x * b.y;
+      const y = a.ex.y * b.x + a.ey.y * b.y;
+      return Vec2.neo(x, y);
+    }
+
+    if (_ASSERT) console.assert(false);
+  }
+
+  static mulVec3(a: Mat33, b: Vec3Value): Vec3 {
+    if (_ASSERT) Mat33.assert(a);
+    if (_ASSERT) Vec3.assert(b);
+    const x = a.ex.x * b.x + a.ey.x * b.y + a.ez.x * b.z;
+    const y = a.ex.y * b.x + a.ey.y * b.y + a.ez.y * b.z;
+    const z = a.ex.z * b.x + a.ey.z * b.y + a.ez.z * b.z;
+    return new Vec3(x, y, z);
+  }
+
+  static mulVec2(a: Mat33, b: Vec2Value): Vec2 {
+    if (_ASSERT) Mat33.assert(a);
+    if (_ASSERT) Vec2.assert(b);
+    const x = a.ex.x * b.x + a.ey.x * b.y;
+    const y = a.ex.y * b.x + a.ey.y * b.y;
+    return Vec2.neo(x, y);
+  }
+
+  static add(a: Mat33, b: Mat33): Mat33 {
+    if (_ASSERT) Mat33.assert(a);
+    if (_ASSERT) Mat33.assert(b);
+    return new Mat33(Vec3.add(a.ex, b.ex), Vec3.add(a.ey, b.ey), Vec3.add(a.ez, b.ez));
+  }
+}

package/src/common/Math.ts

@@ -0,0 +1,96 @@
+/*
+ * Planck.js
+ *
+ * Copyright (c) Erin Catto, Ali Shakiba
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/** @internal */ const math_random = Math.random;
+
+export const EPSILON = 1e-9;
+
+/** @internal @deprecated */
+export const isFinite = Number.isFinite;
+
+/**
+ * @deprecated
+ * Next Largest Power of 2 Given a binary integer value x, the next largest
+ * power of 2 can be computed by a SWAR algorithm that recursively "folds" the
+ * upper bits into the lower bits. This process yields a bit vector with the
+ * same most significant 1 as x, but all 1's below it. Adding 1 to that value
+ * yields the next largest power of 2. For a 32-bit value:
+ */
+export function nextPowerOfTwo(x: number): number {
+  x |= x >> 1;
+  x |= x >> 2;
+  x |= x >> 4;
+  x |= x >> 8;
+  x |= x >> 16;
+  return x + 1;
+}
+
+/** @deprecated */
+export function isPowerOfTwo(x: number): boolean {
+  return x > 0 && (x & (x - 1)) === 0;
+}
+
+/** @deprecated */
+export function mod(num: number, min?: number, max?: number): number {
+  if (typeof min === "undefined") {
+    max = 1;
+    min = 0;
+  } else if (typeof max === "undefined") {
+    max = min;
+    min = 0;
+  }
+  if (max > min) {
+    num = (num - min) % (max - min);
+    return num + (num < 0 ? max : min);
+  } else {
+    num = (num - max) % (min - max);
+    return num + (num <= 0 ? min : max);
+  }
+}
+
+/**
+ * @deprecated
+ * Returns a min if num is less than min, and max if more than max, otherwise returns num.
+ */
+export function clamp(num: number, min: number, max: number): number {
+  if (num < min) {
+    return min;
+  } else if (num > max) {
+    return max;
+  } else {
+    return num;
+  }
+}
+
+/**
+ * @deprecated
+ * Returns a random number between min and max when two arguments are provided.
+ * If one arg is provided between 0 to max.
+ * If one arg is passed between 0 to 1.
+ */
+export function random(min?: number, max?: number): number {
+  if (typeof min === "undefined") {
+    max = 1;
+    min = 0;
+  } else if (typeof max === "undefined") {
+    max = min;
+    min = 0;
+  }
+  return min === max ? min : math_random() * (max - min) + min;
+}
+
+/** @ignore */
+export const math = Object.create(Math);
+math.EPSILON = EPSILON;
+math.isFinite = isFinite;
+math.nextPowerOfTwo = nextPowerOfTwo;
+math.isPowerOfTwo = isPowerOfTwo;
+math.mod = mod;
+math.clamp = clamp;
+math.random = random;