glmaths 0.0.2 → 0.0.4

package/src/quat2.ts

@@ -11,9 +11,9 @@ import { Mat4 } from './mat4'
  */
 export class Quat2 extends Float32Array {
 
-  static get identity() { return new Quat2(0, 0, 0, 1, 0, 0, 0, 0) }
-  static get Identity() { return new Quat2(0, 0, 0, 1, 0, 0, 0, 0) }
-  static get IDENTITY() { return new Quat2(0, 0, 0, 1, 0, 0, 0, 0) }
+  static get identity() { return quat2(0, 0, 0, 1, 0, 0, 0, 0) }
+  static get Identity() { return quat2(0, 0, 0, 1, 0, 0, 0, 0) }
+  static get IDENTITY() { return quat2(0, 0, 0, 1, 0, 0, 0, 0) }
 
   /**
    * Creates a new dual quaternion
@@ -100,7 +100,7 @@ export class Quat2 extends Float32Array {
    * @param {Quat2} out the receiving dual quaternion, defaults to quat2()
    * @returns {Quat2} out
    */
-  static fromRotationTranslation(q: Quat, t: Vec3, out = new Quat2()): Quat2 {
+  static fromRotationTranslation(q: Quat, t: Vec3, out = quat2()): Quat2 {
     const ax = t[0] * 0.5, ay = t[1] * 0.5, az = t[2] * 0.5
     const bx = q[0], by = q[1], bz = q[2], bw = q[3]
     out[0] = bx; out[1] = by; out[2] = bz; out[3] = bw
@@ -118,7 +118,7 @@ export class Quat2 extends Float32Array {
    * @param {Quat2} out the receiving dual quaternion, defaults to quat2()
    * @returns {Quat2} out
    */
-  static fromTranslation(t: Vec3, out = new Quat2()): Quat2 {
+  static fromTranslation(t: Vec3, out = quat2()): Quat2 {
     out[0] = 0; out[1] = 0; out[2] = 0; out[3] = 1
     out[4] = t[0] * 0.5; out[5] = t[1] * 0.5; out[6] = t[2] * 0.5; out[7] = 0
     return out
@@ -131,7 +131,7 @@ export class Quat2 extends Float32Array {
    * @param {Quat2} out the receiving dual quaternion, defaults to quat2()
    * @returns {Quat2} out
    */
-  static fromRotation(q: Quat, out = new Quat2()): Quat2 {
+  static fromRotation(q: Quat, out = quat2()): Quat2 {
     out[0] = q[0]; out[1] = q[1]; out[2] = q[2]; out[3] = q[3]
     out[4] = 0; out[5] = 0; out[6] = 0; out[7] = 0
     return out
@@ -144,7 +144,7 @@ export class Quat2 extends Float32Array {
    * @param {Quat2} out the receiving dual quaternion, defaults to quat2()
    * @returns {Quat2} out
    */
-  static fromMat4(m: Mat4, out = new Quat2()): Quat2 {
+  static fromMat4(m: Mat4, out = quat2()): Quat2 {
     const r = m.getRotation()
     const t = m.getTranslation()
     return Quat2.fromRotationTranslation(r, t, out)
@@ -156,18 +156,18 @@ export class Quat2 extends Float32Array {
    * @returns {Quat2} a new dual quaternion
    */
   clone() {
-    return new Quat2(this[0], this[1], this[2], this[3], this[4], this[5], this[6], this[7])
+    return quat2(this[0], this[1], this[2], this[3], this[4], this[5], this[6], this[7])
   }
 
   /**
    * Multiply two dual quaternions
    *
    * @param {Quat2} b the second operand
-   * @param {Quat2} out the receiving dual quaternion, defaults to this
+   * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
    * @returns {Quat2} out
    */
   // @ts-ignore
-  multiply = (b: Quat2, out = glmaths.ALWAYS_COPY ? new Quat2() : this): Quat2 => {
+  multiply = (b: Quat2, out = glmaths.ALWAYS_COPY ? quat2() : this): Quat2 => {
     const ax0 = this[0], ay0 = this[1], az0 = this[2], aw0 = this[3]
     const bx1 = b[4], by1 = b[5], bz1 = b[6], bw1 = b[7]
     const ax1 = this[4], ay1 = this[5], az1 = this[6], aw1 = this[7]
@@ -193,10 +193,10 @@ export class Quat2 extends Float32Array {
    * Translate by a Vec3
    *
    * @param {Vec3} v the translation vector
-   * @param {Quat2} out the receiving dual quaternion, defaults to this
+   * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
    * @returns {Quat2} out
    */
-  translate(v: Vec3, out = glmaths.ALWAYS_COPY ? new Quat2() : this): Quat2 {
+  translate(v: Vec3, out = glmaths.ALWAYS_COPY ? quat2() : this): Quat2 {
     const ax1 = this[0], ay1 = this[1], az1 = this[2], aw1 = this[3]
     const bx1 = v[0] * 0.5, by1 = v[1] * 0.5, bz1 = v[2] * 0.5
     const ax2 = this[4], ay2 = this[5], az2 = this[6], aw2 = this[7]
@@ -211,10 +211,10 @@ export class Quat2 extends Float32Array {
   /**
    * Calculates the conjugate of a dual quaternion
    *
-   * @param {Quat2} out the receiving dual quaternion, defaults to this
+   * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
    * @returns {Quat2} out
    */
-  conjugate(out = glmaths.ALWAYS_COPY ? new Quat2() : this): Quat2 {
+  conjugate(out = glmaths.ALWAYS_COPY ? quat2() : this): Quat2 {
     out[0] = -this[0]; out[1] = -this[1]; out[2] = -this[2]; out[3] = this[3]
     out[4] = -this[4]; out[5] = -this[5]; out[6] = -this[6]; out[7] = this[7]
     return out
@@ -223,10 +223,10 @@ export class Quat2 extends Float32Array {
   /**
    * Calculates the inverse of a dual quaternion
    *
-   * @param {Quat2} out the receiving dual quaternion, defaults to this
+   * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
    * @returns {Quat2} out
    */
-  invert(out = glmaths.ALWAYS_COPY ? new Quat2() : this): Quat2 {
+  invert(out = glmaths.ALWAYS_COPY ? quat2() : this): Quat2 {
     const sqlen = this.squaredLength()
     out[0] = -this[0] / sqlen; out[1] = -this[1] / sqlen
     out[2] = -this[2] / sqlen; out[3] = this[3] / sqlen
@@ -257,16 +257,17 @@ export class Quat2 extends Float32Array {
   /**
    * Normalize the dual quaternion
    *
-   * @param {Quat2} out the receiving dual quaternion, defaults to this
+   * @param {Quat2} q the quaternion to normalize
+   * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
    * @returns {Quat2} out
    */
-  normalize(out = glmaths.ALWAYS_COPY ? new Quat2() : this): Quat2 {
-    let magnitude = this.squaredLength()
+  static normalize(q: Quat2, out = quat2()) {
+    let magnitude = q.squaredLength()
     if (magnitude > 0) {
       magnitude = Math.sqrt(magnitude)
-      const a0 = this[0] / magnitude, a1 = this[1] / magnitude
-      const a2 = this[2] / magnitude, a3 = this[3] / magnitude
-      const b0 = this[4], b1 = this[5], b2 = this[6], b3 = this[7]
+      const a0 = q[0] / magnitude, a1 = q[1] / magnitude
+      const a2 = q[2] / magnitude, a3 = q[3] / magnitude
+      const b0 = q[4], b1 = q[5], b2 = q[6], b3 = q[7]
       const a_dot_b = a0 * b0 + a1 * b1 + a2 * b2 + a3 * b3
       out[0] = a0; out[1] = a1; out[2] = a2; out[3] = a3
       out[4] = (b0 - a0 * a_dot_b) / magnitude
@@ -277,6 +278,16 @@ export class Quat2 extends Float32Array {
     return out
   }
 
+  /**
+   * Normalize the dual quaternion
+   *
+   * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
+   * @returns {Quat2} out
+   */
+  normalize(out = glmaths.ALWAYS_COPY ? quat2() : this): Quat2 {
+    return Quat2.normalize(this, out)
+  }
+
   /**
    * Dot product of the real parts of two dual quaternions
    *
@@ -297,7 +308,7 @@ export class Quat2 extends Float32Array {
    * @param {Quat2} out the receiving dual quaternion, defaults to quat2()
    * @returns {Quat2} out
    */
-  static lerp(a: Quat2, b: Quat2, t: number, out = new Quat2()): Quat2 {
+  static lerp(a: Quat2, b: Quat2, t: number, out = quat2()): Quat2 {
     const mt = 1 - t
     if (Quat2.dot(a, b) < 0) t = -t
     out[0] = a[0] * mt + b[0] * t
@@ -315,10 +326,10 @@ export class Quat2 extends Float32Array {
    * Adds two dual quaternions
    *
    * @param {Quat2} b the second operand
-   * @param {Quat2} out the receiving dual quaternion, defaults to this
+   * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
    * @returns {Quat2} out
    */
-  plus(b: Quat2, out = glmaths.ALWAYS_COPY ? new Quat2() : this): Quat2 {
+  plus(b: Quat2, out = glmaths.ALWAYS_COPY ? quat2() : this): Quat2 {
     out[0] = this[0] + b[0]; out[1] = this[1] + b[1]
     out[2] = this[2] + b[2]; out[3] = this[3] + b[3]
     out[4] = this[4] + b[4]; out[5] = this[5] + b[5]
@@ -330,10 +341,10 @@ export class Quat2 extends Float32Array {
    * Scales a dual quaternion by a scalar
    *
    * @param {Number} s the scalar to scale by
-   * @param {Quat2} out the receiving dual quaternion, defaults to this
+   * @param {Quat2} out the receiving dual quaternion, defaults to new quat2()
    * @returns {Quat2} out
    */
-  scale(s: number, out = glmaths.ALWAYS_COPY ? new Quat2() : this): Quat2 {
+  scale(s: number, out = glmaths.ALWAYS_COPY ? quat2() : this): Quat2 {
     out[0] = this[0] * s; out[1] = this[1] * s
     out[2] = this[2] * s; out[3] = this[3] * s
     out[4] = this[4] * s; out[5] = this[5] * s
@@ -399,14 +410,17 @@ export interface Quat2 {
   sqrLen: () => number
   str: () => string
   add: (b: Quat2, out?: Quat2) => Quat2
+  normalized: (out?: Quat2) => Quat2
 }
 
 // @aliases
 Quat2.prototype.sqrLen = Quat2.prototype.squaredLength
+Quat2.prototype.normalized = Quat2.prototype.normalize
 Quat2.prototype.str = Quat2.prototype.toString
 Quat2.prototype.add = Quat2.prototype.plus
 
-export const quat2 = Object.assign(
-  (x1 = 0, y1 = 0, z1 = 0, w1 = 1, x2 = 0, y2 = 0, z2 = 0, w2 = 0) => new Quat2(x1, y1, z1, w1, x2, y2, z2, w2),
-  Quat2
-)
+const createQuat2 = 
+  (x1 = 0, y1 = 0, z1 = 0, w1 = 1, x2 = 0, y2 = 0, z2 = 0, w2 = 0) =>
+    new Quat2(x1, y1, z1, w1, x2, y2, z2, w2)
+Object.setPrototypeOf(createQuat2, Quat2)
+export const quat2 = createQuat2 as typeof createQuat2 & typeof Quat2