glmaths 0.0.2 → 0.0.4

package/src/vec3.ts

@@ -12,22 +12,22 @@ import { Quat } from './quat'
  */
 export class Vec3 extends Float32Array {
 
-  static get zero() { return new Vec3(0, 0, 0) }
-  static get Zero() { return new Vec3(0, 0, 0) }
-  static get ZERO() { return new Vec3(0, 0, 0) }
-  static get one()  { return new Vec3(1, 1, 1) }
-  static get One()  { return new Vec3(1, 1, 1) }
-  static get ONE()  { return new Vec3(1, 1, 1) }
+  static get zero() { return vec3(0, 0, 0) }
+  static get Zero() { return vec3(0, 0, 0) }
+  static get ZERO() { return vec3(0, 0, 0) }
+  static get one()  { return vec3(1, 1, 1) }
+  static get One()  { return vec3(1, 1, 1) }
+  static get ONE()  { return vec3(1, 1, 1) }
 
-  static get unitX() { return new Vec3(1, 0, 0) }
-  static get UnitX() { return new Vec3(1, 0, 0) }
-  static get unitY() { return new Vec3(0, 1, 0) }
-  static get UnitY() { return new Vec3(0, 1, 0) }
-  static get unitZ() { return new Vec3(0, 0, 1) }
-  static get UnitZ() { return new Vec3(0, 0, 1) }
+  static get unitX() { return vec3(1, 0, 0) }
+  static get UnitX() { return vec3(1, 0, 0) }
+  static get unitY() { return vec3(0, 1, 0) }
+  static get UnitY() { return vec3(0, 1, 0) }
+  static get unitZ() { return vec3(0, 0, 1) }
+  static get UnitZ() { return vec3(0, 0, 1) }
 
   /**
-   * Creates a new Vec3
+   * Creates new vec3
    *
    * @param {Number} x X component, defaults to 0
    * @param {Number} y Y component, defaults to 0
@@ -53,10 +53,10 @@ export class Vec3 extends Float32Array {
    * Adds two vec3's
    *
    * @param {Number | Vec3} b the second operand
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  plus(b: number | Vec3, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  plus(b: number | Vec3, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     if (typeof b === 'number') {
       out[0] = this[0] + b
       out[1] = this[1] + b
@@ -73,10 +73,10 @@ export class Vec3 extends Float32Array {
    * Subtracts two vec3's
    *
    * @param {Number | Vec3} b the second operand
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  minus(b: number | Vec3, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  minus(b: number | Vec3, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     if (typeof b === 'number') {
       out[0] = this[0] - b
       out[1] = this[1] - b
@@ -93,10 +93,10 @@ export class Vec3 extends Float32Array {
    * Multiplies two vec3's
    *
    * @param {Number | Vec3} b the second operand
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  mult(b: number | Vec3, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  mult(b: number | Vec3, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     if (typeof b === 'number') {
       out[0] = this[0] * b
       out[1] = this[1] * b
@@ -113,10 +113,10 @@ export class Vec3 extends Float32Array {
    * Divides two vec3's
    *
    * @param {Number | Vec3} b the second operand
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  div(b: number | Vec3, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  div(b: number | Vec3, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     if (typeof b === 'number') {
       out[0] = this[0] / b
       out[1] = this[1] / b
@@ -128,7 +128,7 @@ export class Vec3 extends Float32Array {
     }
     return out
   }
-  invDiv(b: number | Vec3, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  invDiv(b: number | Vec3, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     if (typeof b === 'number') {
       out[0] = b / this[0]
       out[1] = b / this[1]
@@ -142,18 +142,18 @@ export class Vec3 extends Float32Array {
   }
 
   /**
-   * Negates the components of a vec3
+   * Negates the components of this vec3
    *
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  negate(out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  negate(out = glmaths.ALWAYS_COPY ? vec3() : this) {
     out[0] = -this[0]
     out[1] = -this[1]
     out[2] = -this[2]
     return out
   }
-  unaryPlus(out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  unaryPlus(out = glmaths.ALWAYS_COPY ? vec3() : this) {
     if (out != this) {
       out[0] = this[0]
       out[1] = this[1]
@@ -163,13 +163,13 @@ export class Vec3 extends Float32Array {
   }
 
   /**
-   * Normalizes a vec3
+   * Normalizes vec3
    *
    * @param {Vec3} v the vector to normalize
-   * @param {Vec3} out the receiving vector, defaults to a new Vec3
+   * @param {Vec3} out the receiving vector, defaults to new vec3
    * @returns {Vec3} out
    */
-  static normalize(v: Vec3, out = new Vec3()): Vec3 {
+  static normalize(v: Vec3, out = vec3()): Vec3 {
     const x = v[0], y = v[1], z = v[2]
     let len = x * x + y * y + z * z
     if (len > 0) len = 1.0 / Math.sqrt(len)
@@ -178,13 +178,14 @@ export class Vec3 extends Float32Array {
     out[2] = z * len
     return out
   }
+
   /**
-   * Normalizes a vec3
+   * Normalizes this vec3
    *
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  normalize(out = glmaths.ALWAYS_COPY ? new Vec3() : this): Vec3 {
+  normalize(out = glmaths.ALWAYS_COPY ? vec3() : this): Vec3 {
     const x = this[0], y = this[1], z = this[2]
     let len = x * x + y * y + z * z
     if (len > 0) len = 1.0 / Math.sqrt(len)
@@ -219,7 +220,7 @@ export class Vec3 extends Float32Array {
   }
 
   /**
-   * Calculates the squared length of a vec3
+   * Calculates the squared length of vec3
    *
    * @returns {Number} squared length of a vector
    */
@@ -229,7 +230,7 @@ export class Vec3 extends Float32Array {
   }
 
   /**
-   * Calculates the length of a vec3
+   * Calculates the length of vec3
    *
    * @returns {Number} length of a vector
    */
@@ -239,69 +240,69 @@ export class Vec3 extends Float32Array {
   }
 
   /**
-   * Returns a new vec3 with each component floored
+   * Returns vec3 with each component floored
    *
    * @param {Vec3} v the vector to floor
    * @returns {Vec3} a new floored vector
    */
-  static floor(v: Vec3, out = new Vec3()) {
+  static floor(v: Vec3, out = vec3()) {
     out[0] = Math.floor(v[0])
     out[1] = Math.floor(v[1])
     out[2] = Math.floor(v[2])
     return out
   }
   /**
-   * Returns a new vec3 with each component rounded
+   * Returns vec3 with each component rounded
    *
    * @param {Vec3} v the vector to round
    * @returns {Vec3} a new rounded vector
    */
-  static round(v: Vec3, out = new Vec3()) {
+  static round(v: Vec3, out = vec3()) {
     out[0] = Math.round(v[0])
     out[1] = Math.round(v[1])
     out[2] = Math.round(v[2])
     return out
   }
   /**
-   * Returns a new vec3 with each component ceiled
+   * Returns vec3 with each component ceiled
    *
    * @param {Vec3} v the vector to ceil
    * @returns {Vec3} a new ceiled vector
    */
-  static ceil (v: Vec3, out = new Vec3()) {
+  static ceil (v: Vec3, out = vec3()) {
     out[0] = Math.ceil(v[0])
     out[1] = Math.ceil(v[1])
     out[2] = Math.ceil(v[2])
     return out
   }
   /**
-   * Floors each component of a vec3
+   * Floors each component of vec3
    *
    * @returns {Vec3} this
    */
-  floor(out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  floor(out = glmaths.ALWAYS_COPY ? vec3() : this) {
     out[0] = Math.floor(this[0])
     out[1] = Math.floor(this[1])
     out[2] = Math.floor(this[2])
     return out
   }
   /**
-   * Rounds each component of a vec3
+   * Rounds each component of vec3
    *
    * @returns {Vec3} this
    */
-  round(out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  round(out = glmaths.ALWAYS_COPY ? vec3() : this) {
     out[0] = Math.round(this[0])
     out[1] = Math.round(this[1])
     out[2] = Math.round(this[2])
     return out
   }
   /**
-   * Ceils each component of a vec3
+   * Ceils each component of vec3
    *
    * @returns {Vec3} this
    */
-  ceil(out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  ceil(out = glmaths.ALWAYS_COPY ? vec3() : this) {
     out[0] = Math.ceil(this[0])
     out[1] = Math.ceil(this[1])
     out[2] = Math.ceil(this[2])
@@ -309,23 +310,23 @@ export class Vec3 extends Float32Array {
   }
 
   /**
-   * Returns the inverse of a vec3
+   * Returns the inverse of vec3
    *
    * @param {Vec3} v the source vector
    * @returns {Vec3} a new inverted vector
    */
-  static inverse(v: Vec3, out = new Vec3()) {
+  static inverse(v: Vec3, out = vec3()) {
     out[0] = 1.0 / v[0]
     out[1] = 1.0 / v[1]
     out[2] = 1.0 / v[2]
     return out
   }
   /**
-   * Inverts a vec3 component-wise
+   * Inverts vec3 component-wise
    *
    * @returns {Vec3} this
    */
-  inverse(out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  inverse(out = glmaths.ALWAYS_COPY ? vec3() : this) {
     out[0] = 1.0 / this[0]
     out[1] = 1.0 / this[1]
     out[2] = 1.0 / this[2]
@@ -333,12 +334,12 @@ export class Vec3 extends Float32Array {
   }
 
   /**
-   * Creates a new vec3 initialized with values from a vector
+   * Creates vec3 initialized with values from a vector
    *
-   * @returns {Vec3} a new Vec3
+   * @returns {Vec3} vec3
    */
   clone() {
-    return new Vec3(this[0], this[1], this[2])
+    return vec3(this[0], this[1], this[2])
   }
 
   /**
@@ -360,7 +361,7 @@ export class Vec3 extends Float32Array {
     const r = glmaths.RANDOM() * 2.0 * Math.PI
     const z = glmaths.RANDOM() * 2.0 - 1.0
     const zScale = Math.sqrt(1.0 - z * z) * scale
-    return new Vec3(
+    return vec3(
       Math.cos(r) * zScale,
       Math.sin(r) * zScale,
       z * scale
@@ -397,10 +398,10 @@ export class Vec3 extends Float32Array {
    *
    * @param {Vec3} a the first operand
    * @param {Vec3} b the second operand
-   * @param {Vec3} out the receiving vector, defaults to a new Vec3
+   * @param {Vec3} out the receiving vector, defaults to new vec3
    * @returns {Vec3} out
    */
-  static cross(a: Vec3, b: Vec3, out = new Vec3()): Vec3 {
+  static cross(a: Vec3, b: Vec3, out = vec3()): Vec3 {
     const ax = a[0], ay = a[1], az = a[2]
     const bx = b[0], by = b[1], bz = b[2]
     out[0] = ay * bz - az * by
@@ -445,10 +446,10 @@ export class Vec3 extends Float32Array {
    * @param {Vec3} a the first operand
    * @param {Vec3} b the second operand
    * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
-   * @param {Vec3} out the receiving vector, defaults to a new Vec3
+   * @param {Vec3} out the receiving vector, defaults to new vec3
    * @returns {Vec3} out
    */
-  static lerp(a: Vec3, b: Vec3, t: number, out = new Vec3()) {
+  static lerp(a: Vec3, b: Vec3, t: number, out = vec3()) {
     const ax = a[0], ay = a[1], az = a[2]
     out[0] = ax + (b[0] - ax) * t
     out[1] = ay + (b[1] - ay) * t
@@ -461,10 +462,10 @@ export class Vec3 extends Float32Array {
    * @param {Vec3} a the first operand
    * @param {Vec3} b the second operand
    * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
-   * @param {Vec3} out the receiving vector, defaults to a new Vec3
+   * @param {Vec3} out the receiving vector, defaults to new vec3
    * @returns {Vec3} out
    */
-  static slerp(a: Vec3, b: Vec3, t: number, out = new Vec3()) {
+  static slerp(a: Vec3, b: Vec3, t: number, out = vec3()) {
     const angle = Math.acos(Math.min(Math.max(Vec3.dot(a, b), -1), 1))
     const sinTotal = Math.sin(angle)
     const ratioA = Math.sin((1 - t) * angle) / sinTotal
@@ -482,7 +483,7 @@ export class Vec3 extends Float32Array {
    * @param {Vec3} b the second operand
    * @returns {Vec3} a new vector with the max components
    */
-  static max(a: Vec3, b: Vec3, out = new Vec3()) {
+  static max(a: Vec3, b: Vec3, out = vec3()) {
     out[0] = Math.max(a[0], b[0])
     out[1] = Math.max(a[1], b[1])
     out[2] = Math.max(a[2], b[2])
@@ -495,7 +496,7 @@ export class Vec3 extends Float32Array {
    * @param {Vec3} b the second operand
    * @returns {Vec3} a new vector with the min components
    */
-  static min(a: Vec3, b: Vec3, out = new Vec3()) {
+  static min(a: Vec3, b: Vec3, out = vec3()) {
     out[0] = Math.min(a[0], b[0])
     out[1] = Math.min(a[1], b[1])
     out[2] = Math.min(a[2], b[2])
@@ -511,7 +512,7 @@ export class Vec3 extends Float32Array {
    * @param {Vec3} out the receiving vector
    * @returns {Vec3} out
    */
-  static clamp(v: Vec3, min: Vec3 | number, max: Vec3 | number, out = new Vec3()) {
+  static clamp(v: Vec3, min: Vec3 | number, max: Vec3 | number, out = vec3()) {
     const minX = typeof min === 'number' ? min : min[0]
     const minY = typeof min === 'number' ? min : min[1]
     const minZ = typeof min === 'number' ? min : min[2]
@@ -533,7 +534,7 @@ export class Vec3 extends Float32Array {
    * @param {Vec3} out the receiving vector
    * @returns {Vec3} out
    */
-  static mix(a: Vec3, b: Vec3, t: Vec3 | number, out = new Vec3()) {
+  static mix(a: Vec3, b: Vec3, t: Vec3 | number, out = vec3()) {
     if (typeof t === 'number') {
       out[0] = a[0] + (b[0] - a[0]) * t
       out[1] = a[1] + (b[1] - a[1]) * t
@@ -555,7 +556,7 @@ export class Vec3 extends Float32Array {
    * @param {Vec3} out the receiving vector
    * @returns {Vec3} out
    */
-  static smoothstep(edge0: Vec3 | number, edge1: Vec3 | number, v: Vec3, out = new Vec3()) {
+  static smoothstep(edge0: Vec3 | number, edge1: Vec3 | number, v: Vec3, out = vec3()) {
     const e0x = typeof edge0 === 'number' ? edge0 : edge0[0]
     const e0y = typeof edge0 === 'number' ? edge0 : edge0[1]
     const e0z = typeof edge0 === 'number' ? edge0 : edge0[2]
@@ -572,14 +573,14 @@ export class Vec3 extends Float32Array {
   }
 
   /**
-   * Rotates a vec3 around the X axis
+   * Rotates vec3 around the X axis
    *
    * @param {Vec3} v the vector to rotate
    * @param {Number} rad the angle of rotation in radians
-   * @param {Vec3} origin the origin of the rotation, defaults to vec3(0)
+   * @param {Vec3} origin the origin of the rotation, defaults to vec3(0, 0, 0)
    * @returns {Vec3} a new rotated vector
    */
-  static rotateX(v: Vec3, rad: number, origin: Vec3 = Vec3.zero, out = new Vec3()): Vec3 {
+  static rotateX(v: Vec3, rad: number, origin: Vec3 = vec3.zero, out = vec3()): Vec3 {
     const p1 = v[1] - origin[1]
     const p2 = v[2] - origin[2]
     out[0] = v[0]
@@ -587,14 +588,15 @@ export class Vec3 extends Float32Array {
     out[2] = p1 * Math.sin(rad) + p2 * Math.cos(rad) + origin[2]
     return out
   }
+
   /**
-   * Rotates a vec3 around the X axis
+   * Rotates vec3 around the X axis
    *
    * @param {Number} rad the angle of rotation in radians
-   * @param {Vec3} origin the origin of the rotation, defaults to vec3(0)
+   * @param {Vec3} origin the origin of the rotation, defaults to vec3(0, 0, 0)
    * @returns {Vec3} a rotated vector
    */
-  rotateX(rad: number, origin: Vec3 = Vec3.zero, out = glmaths.ALWAYS_COPY ? new Vec3() : this): Vec3 {
+  rotateX(rad: number, origin: Vec3 = vec3.zero, out = glmaths.ALWAYS_COPY ? vec3() : this): Vec3 {
     const p1 = this[1] - origin[1]
     const p2 = this[2] - origin[2]
     out[0] = this[0]
@@ -602,15 +604,16 @@ export class Vec3 extends Float32Array {
     out[2] = p1 * Math.sin(rad) + p2 * Math.cos(rad) + origin[2]
     return out
   }
+
   /**
-   * Rotates a vec3 around the Y axis
+   * Rotates vec3 around the Y axis
    *
    * @param {Vec3} v the vector to rotate
    * @param {Number} rad the angle of rotation in radians
-   * @param {Vec3} origin the origin of the rotation, defaults to vec3(0)
+   * @param {Vec3} origin the origin of the rotation, defaults to vec3(0, 0, 0)
    * @returns {Vec3} a rotated vector
    */
-  static rotateY(v: Vec3, rad: number, origin: Vec3 = Vec3.zero, out = new Vec3()): Vec3 {
+  static rotateY(v: Vec3, rad: number, origin: Vec3 = vec3.zero, out = vec3()): Vec3 {
     const p0 = v[0] - origin[0]
     const p2 = v[2] - origin[2]
     out[0] = p2 * Math.sin(rad) + p0 * Math.cos(rad) + origin[0]
@@ -618,13 +621,14 @@ export class Vec3 extends Float32Array {
     out[2] = p2 * Math.cos(rad) - p0 * Math.sin(rad) + origin[2]
     return out
   }
+
   /**
-   * Rotates a vec3 around the Y axis
+   * Rotates vec3 around the Y axis
    *
    * @param {Number} rad the angle of rotation in radians
-   * @param {Vec3} origin the origin of the rotation, defaults to vec3(0)
+   * @param {Vec3} origin the origin of the rotation, defaults to vec3(0, 0, 0)
    */
-  rotateY(rad: number, origin: Vec3 = Vec3.zero, out = glmaths.ALWAYS_COPY ? new Vec3() : this) : Vec3 {
+  rotateY(rad: number, origin: Vec3 = vec3.zero, out = glmaths.ALWAYS_COPY ? vec3() : this) : Vec3 {
     const p0 = this[0] - origin[0]
     const p2 = this[2] - origin[2]
     out[0] = p2 * Math.sin(rad) + p0 * Math.cos(rad) + origin[0]
@@ -633,14 +637,14 @@ export class Vec3 extends Float32Array {
     return out
   }
   /**
-   * Rotates a vec3 around the Z axis
+   * Rotates vec3 around the Z axis
    *
    * @param {Vec3} v the vector to rotate
    * @param {Number} rad the angle of rotation in radians
    * @param {Vec3} origin the origin of the rotation, defaults to ZERO
    * @returns {Vec3} a new rotated vector
    */
-  static rotateZ(v: Vec3, rad: number, origin: Vec3 = Vec3.zero, out = new Vec3()) {
+  static rotateZ(v: Vec3, rad: number, origin: Vec3 = vec3.zero, out = vec3()) {
     const p0 = v[0] - origin[0]
     const p1 = v[1] - origin[1]
     out[0] = p0 * Math.cos(rad) - p1 * Math.sin(rad) + origin[0]
@@ -649,12 +653,12 @@ export class Vec3 extends Float32Array {
     return out
   }
   /**
-   * Rotates a vec3 around the Z axis
+   * Rotates vec3 around the Z axis
    *
    * @param {Number} rad the angle of rotation in radians
-   * @param {Vec3} origin the origin of the rotation, defaults to vec3(0)
+   * @param {Vec3} origin the origin of the rotation, defaults to vec3(0, 0, 0)
    */
-  rotateZ(rad: number, origin: Vec3 = Vec3.zero, out = glmaths.ALWAYS_COPY ? new Vec3() : this) : Vec3 {
+  rotateZ(rad: number, origin: Vec3 = vec3.zero, out = glmaths.ALWAYS_COPY ? vec3() : this) : Vec3 {
     const p0 = this[0] - origin[0]
     const p1 = this[1] - origin[1]
     out[0] = p0 * Math.cos(rad) - p1 * Math.sin(rad) + origin[0]
@@ -673,7 +677,7 @@ export class Vec3 extends Float32Array {
    * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
    * @returns {Vec3} a new vector
    */
-  static hermite(a: Vec3, b: Vec3, c: Vec3, d: Vec3, t: number, out = new Vec3()) {
+  static hermite(a: Vec3, b: Vec3, c: Vec3, d: Vec3, t: number, out = vec3()) {
     const factorTimes2 = t * t
     const factor1 = factorTimes2 * (2 * t - 3) + 1
     const factor2 = factorTimes2 * (t - 2) + t
@@ -684,6 +688,7 @@ export class Vec3 extends Float32Array {
     out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4
     return out
   }
+
   /**
    * Performs a bezier interpolation with two control points
    *
@@ -694,7 +699,7 @@ export class Vec3 extends Float32Array {
    * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
    * @returns {Vec3} a new vector
    */
-  static bezier(a: Vec3, b: Vec3, c: Vec3, d: Vec3, t: number, out = new Vec3()) {
+  static bezier(a: Vec3, b: Vec3, c: Vec3, d: Vec3, t: number, out = vec3()) {
     const inverseFactor = 1 - t
     const inverseFactorTimesTwo = inverseFactor * inverseFactor
     const factorTimes2 = t * t
@@ -714,38 +719,40 @@ export class Vec3 extends Float32Array {
    * @param {Vec3} a the first operand
    * @param {Vec3} b the second operand
    * @param {Number} scale the amount to scale b by before adding
-   * @param {Vec3} out the receiving vector, defaults to a new Vec3
+   * @param {Vec3} out the receiving vector, defaults to new vec3
    * @returns {Vec3} out
    */
-  static scaleAndAdd(a: Vec3, b: Vec3, scale: number, out = new Vec3()) {
+  static scaleAndAdd(a: Vec3, b: Vec3, scale: number, out = vec3()) {
     out[0] = a[0] + b[0] * scale
     out[1] = a[1] + b[1] * scale
     out[2] = a[2] + b[2] * scale
     return out
   }
+
   /**
    * Reflects a vector off a surface with the given normal
    *
    * @param {Vec3} I the incident vector
    * @param {Vec3} N the surface normal
-   * @param {Vec3} out the receiving vector, defaults to a new Vec3
+   * @param {Vec3} out the receiving vector, defaults to new vec3
    * @returns {Vec3} out
    */
-  static reflect(I: Vec3, N: Vec3, out = new Vec3()) {
+  static reflect(I: Vec3, N: Vec3, out = vec3()) {
     const d = Vec3.dot(N, I) * 2
     out[0] = I[0] - d * N[0]; out[1] = I[1] - d * N[1]; out[2] = I[2] - d * N[2]
     return out
   }
+
   /**
    * Refracts a vector through a surface with the given normal and index of refraction ratio (Snell's law)
    *
    * @param {Vec3} I the incident vector
    * @param {Vec3} N the surface normal
    * @param {Number} eta the ratio of indices of refraction
-   * @param {Vec3} out the receiving vector, defaults to a new Vec3
+   * @param {Vec3} out the receiving vector, defaults to new vec3
    * @returns {Vec3} out
    */
-  static refract(I: Vec3, N: Vec3, eta: number, out = new Vec3()) {
+  static refract(I: Vec3, N: Vec3, eta: number, out = vec3()) {
     const d = Vec3.dot(N, I)
     const k = 1.0 - eta * eta * (1.0 - d * d)
     if (k < 0.0) { out[0] = out[1] = out[2] = 0; return out }
@@ -755,31 +762,33 @@ export class Vec3 extends Float32Array {
     out[2] = eta * I[2] - f * N[2]
     return out
   }
+
   /**
    * Returns a vector pointing in the same direction as another, based on the dot product with a reference
    *
    * @param {Vec3} N the vector to orient
    * @param {Vec3} I the incident vector
    * @param {Vec3} Nref the reference vector
-   * @param {Vec3} out the receiving vector, defaults to a new Vec3
+   * @param {Vec3} out the receiving vector, defaults to new vec3
    * @returns {Vec3} out
    */
-  static faceforward(N: Vec3, I: Vec3, Nref: Vec3, out = new Vec3()) {
+  static faceforward(N: Vec3, I: Vec3, Nref: Vec3, out = vec3()) {
     const d = Vec3.dot(Nref, I)
     const sign = d < 0 ? 1 : -1
     out[0] = N[0] * sign; out[1] = N[1] * sign; out[2] = N[2] * sign
     return out
   }
+
   /**
    * Computes the normalized normal of a triangle defined by three points
    *
    * @param {Vec3} p1 the first vertex
    * @param {Vec3} p2 the second vertex
    * @param {Vec3} p3 the third vertex
-   * @param {Vec3} out the receiving vector, defaults to a new Vec3
+   * @param {Vec3} out the receiving vector, defaults to new vec3
    * @returns {Vec3} out
    */
-  static triangleNormal(p1: Vec3, p2: Vec3, p3: Vec3, out = new Vec3()) {
+  static triangleNormal(p1: Vec3, p2: Vec3, p3: Vec3, out = vec3()) {
     const e1x = p2[0]-p1[0], e1y = p2[1]-p1[1], e1z = p2[2]-p1[2]
     const e2x = p3[0]-p1[0], e2y = p3[1]-p1[1], e2z = p3[2]-p1[2]
     out[0] = e1y*e2z - e1z*e2y; out[1] = e1z*e2x - e1x*e2z; out[2] = e1x*e2y - e1y*e2x
@@ -787,19 +796,21 @@ export class Vec3 extends Float32Array {
     if (len > 0) { len = 1/Math.sqrt(len); out[0]*=len; out[1]*=len; out[2]*=len }
     return out
   }
+
   /**
    * Projects vector a onto vector b
    *
    * @param {Vec3} a the vector to project
    * @param {Vec3} b the vector to project onto
-   * @param {Vec3} out the receiving vector, defaults to a new Vec3
+   * @param {Vec3} out the receiving vector, defaults to new vec3
    * @returns {Vec3} out
    */
-  static project(a: Vec3, b: Vec3, out = new Vec3()) {
+  static project(a: Vec3, b: Vec3, out = vec3()) {
     const d = Vec3.dot(a, b) / Vec3.dot(b, b)
     out[0] = b[0] * d; out[1] = b[1] * d; out[2] = b[2] * d
     return out
   }
+
   /**
    * Returns the signed angle between two vec3's, using a reference axis to determine sign
    *
@@ -819,36 +830,38 @@ export class Vec3 extends Float32Array {
    *
    * @param {Vec3} b the second operand
    * @param {Number} scale the amount to scale b by before adding
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  scaleAndAdd(b: Vec3, scale: number, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  scaleAndAdd(b: Vec3, scale: number, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     out[0] = this[0] + b[0] * scale
     out[1] = this[1] + b[1] * scale
     out[2] = this[2] + b[2] * scale
     return out
   }
+
   /**
-   * Returns a vec3 with each component set to its absolute value
+   * Returns vec3 with each component set to its absolute value
    *
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  abs(out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  abs(out = glmaths.ALWAYS_COPY ? vec3() : this) {
     out[0] = Math.abs(this[0])
     out[1] = Math.abs(this[1])
     out[2] = Math.abs(this[2])
     return out
   }
+  
   /**
    * Clamps each component of this vector between min and max.
    *
    * @param {Vec3 | number} min the lower bound (per-component or scalar)
    * @param {Vec3 | number} max the upper bound (per-component or scalar)
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  clamp(min: Vec3 | number, max: Vec3 | number, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  clamp(min: Vec3 | number, max: Vec3 | number, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     const minX = typeof min === 'number' ? min : min[0]
     const minY = typeof min === 'number' ? min : min[1]
     const minZ = typeof min === 'number' ? min : min[2]
@@ -860,15 +873,16 @@ export class Vec3 extends Float32Array {
     out[2] = Math.min(Math.max(this[2], minZ), maxZ)
     return out
   }
+
   /**
    * Performs a linear interpolation between this vector and b.
    *
    * @param {Vec3} b the second operand
    * @param {Vec3 | number} t interpolation amount (per-component or scalar)
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  mix(b: Vec3, t: Vec3 | number, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  mix(b: Vec3, t: Vec3 | number, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     if (typeof t === 'number') {
       out[0] = this[0] + (b[0] - this[0]) * t
       out[1] = this[1] + (b[1] - this[1]) * t
@@ -880,14 +894,15 @@ export class Vec3 extends Float32Array {
     }
     return out
   }
+
   /**
    * Generates a step function by comparing this vector to edge.
    *
    * @param {Vec3 | number} edge the edge value (per-component or scalar)
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  step(edge: Vec3 | number, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  step(edge: Vec3 | number, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     if (typeof edge === 'number') {
       out[0] = this[0] < edge ? 0 : 1
       out[1] = this[1] < edge ? 0 : 1
@@ -899,15 +914,16 @@ export class Vec3 extends Float32Array {
     }
     return out
   }
+
   /**
    * Performs Hermite interpolation between two values (smoothstep).
    *
    * @param {Vec3 | number} edge0 the lower edge (per-component or scalar)
    * @param {Vec3 | number} edge1 the upper edge (per-component or scalar)
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  smoothstep(edge0: Vec3 | number, edge1: Vec3 | number, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  smoothstep(edge0: Vec3 | number, edge1: Vec3 | number, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     const e0x = typeof edge0 === 'number' ? edge0 : edge0[0]
     const e0y = typeof edge0 === 'number' ? edge0 : edge0[1]
     const e0z = typeof edge0 === 'number' ? edge0 : edge0[2]
@@ -922,50 +938,54 @@ export class Vec3 extends Float32Array {
     out[2] = t2 * t2 * (3 - 2 * t2)
     return out
   }
+
   /**
    * Returns the fractional part of each component.
    *
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  fract(out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  fract(out = glmaths.ALWAYS_COPY ? vec3() : this) {
     out[0] = this[0] - Math.floor(this[0])
     out[1] = this[1] - Math.floor(this[1])
     out[2] = this[2] - Math.floor(this[2])
     return out
   }
+
   /**
    * Returns the sign of each component (-1, 0, or 1).
    *
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  sign(out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  sign(out = glmaths.ALWAYS_COPY ? vec3() : this) {
     out[0] = this[0] > 0 ? 1 : this[0] < 0 ? -1 : 0
     out[1] = this[1] > 0 ? 1 : this[1] < 0 ? -1 : 0
     out[2] = this[2] > 0 ? 1 : this[2] < 0 ? -1 : 0
     return out
   }
+
   /**
    * Clamps each component to [0, 1].
    *
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  saturate(out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  saturate(out = glmaths.ALWAYS_COPY ? vec3() : this) {
     out[0] = Math.min(Math.max(this[0], 0), 1)
     out[1] = Math.min(Math.max(this[1], 0), 1)
     out[2] = Math.min(Math.max(this[2], 0), 1)
     return out
   }
+
   /**
    * Transforms this vec3 with a Mat3
    *
    * @param {Mat3} m the 3x3 matrix to transform with
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  transformMat3(m: Mat3, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  transformMat3(m: Mat3, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     const x = this[0], y = this[1], z = this[2]
     out[0] = x * m[0] + y * m[3] + z * m[6]
     out[1] = x * m[1] + y * m[4] + z * m[7]
@@ -977,10 +997,10 @@ export class Vec3 extends Float32Array {
    * Transforms this vec3 with a Mat4 (as a point, w=1)
    *
    * @param {Mat4} m the 4x4 matrix to transform with
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  transformMat4(m: Mat4, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  transformMat4(m: Mat4, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     const x = this[0], y = this[1], z = this[2]
     let w = m[3] * x + m[7] * y + m[11] * z + m[15]
     w = w || 1.0
@@ -994,10 +1014,10 @@ export class Vec3 extends Float32Array {
    * Transforms this vec3 with a quaternion
    *
    * @param {Quat} q the quaternion to transform with
-   * @param {Vec3} out the receiving vector, defaults to this
+   * @param {Vec3} out the receiving vector, defaults to new vec3()
    * @returns {Vec3} out
    */
-  transformQuat(q: Quat, out = glmaths.ALWAYS_COPY ? new Vec3() : this) {
+  transformQuat(q: Quat, out = glmaths.ALWAYS_COPY ? vec3() : this) {
     const qx = q[0], qy = q[1], qz = q[2], qw = q[3]
     const x = this[0], y = this[1], z = this[2]
     let uvx = qy * z - qz * y, uvy = qz * x - qx * z, uvz = qx * y - qy * x
@@ -1028,6 +1048,7 @@ export interface Vec3 {
   str: () => string
   transformMat3x3: (m: Mat3, out?: Vec3) => Vec3
   transformMat4x4: (m: Mat4, out?: Vec3) => Vec3
+  normalized: (out?: Vec3) => Vec3
 
   // Auto-generated
   x0: Vec2; x1: Vec2; xx: Vec2; xy: Vec2; y0: Vec2; y1: Vec2; yx: Vec2; yy: Vec2; x00: Vec3; x01: Vec3; x0x: Vec3; x0y: Vec3; x0z: Vec3; x10: Vec3; x11: Vec3; x1x: Vec3; x1y: Vec3; x1z: Vec3; xx0: Vec3; xx1: Vec3; xxx: Vec3; xxy: Vec3; xxz: Vec3; xy0: Vec3; xy1: Vec3; xyx: Vec3; xyy: Vec3; xyz: Vec3; xz0: Vec3; xz1: Vec3; xzx: Vec3; xzy: Vec3; xzz: Vec3; y00: Vec3; y01: Vec3; y0x: Vec3; y0y: Vec3; y0z: Vec3; y10: Vec3; y11: Vec3; y1x: Vec3; y1y: Vec3; y1z: Vec3; yx0: Vec3; yx1: Vec3; yxx: Vec3; yxy: Vec3; yxz: Vec3; yy0: Vec3; yy1: Vec3; yyx: Vec3; yyy: Vec3; yyz: Vec3; yz0: Vec3; yz1: Vec3; yzx: Vec3; yzy: Vec3; yzz: Vec3; z00: Vec3; z01: Vec3; z0x: Vec3; z0y: Vec3; z0z: Vec3; z10: Vec3; z11: Vec3; z1x: Vec3; z1y: Vec3; z1z: Vec3; zx0: Vec3; zx1: Vec3; zxx: Vec3; zxy: Vec3; zxz: Vec3; zy0: Vec3; zy1: Vec3; zyx: Vec3; zyy: Vec3; zyz: Vec3; zz0: Vec3; zz1: Vec3; zzx: Vec3; zzy: Vec3; zzz: Vec3; x000: Vec4; x001: Vec4; x00x: Vec4; x00y: Vec4; x00z: Vec4; x00w: Vec4; x010: Vec4; x011: Vec4; x01x: Vec4; x01y: Vec4; x01z: Vec4; x01w: Vec4; x0x0: Vec4; x0x1: Vec4; x0xx: Vec4; x0xy: Vec4; x0xz: Vec4; x0xw: Vec4; x0y0: Vec4; x0y1: Vec4; x0yx: Vec4; x0yy: Vec4; x0yz: Vec4; x0yw: Vec4; x0z0: Vec4; x0z1: Vec4; x0zx: Vec4; x0zy: Vec4; x0zz: Vec4; x0zw: Vec4; x0w0: Vec4; x0w1: Vec4; x0wx: Vec4; x0wy: Vec4; x0wz: Vec4; x0ww: Vec4; x100: Vec4; x101: Vec4; x10x: Vec4; x10y: Vec4; x10z: Vec4; x10w: Vec4; x110: Vec4; x111: Vec4; x11x: Vec4; x11y: Vec4; x11z: Vec4; x11w: Vec4; x1x0: Vec4; x1x1: Vec4; x1xx: Vec4; x1xy: Vec4; x1xz: Vec4; x1xw: Vec4; x1y0: Vec4; x1y1: Vec4; x1yx: Vec4; x1yy: Vec4; x1yz: Vec4; x1yw: Vec4; x1z0: Vec4; x1z1: Vec4; x1zx: Vec4; x1zy: Vec4; x1zz: Vec4; x1zw: Vec4; x1w0: Vec4; x1w1: Vec4; x1wx: Vec4; x1wy: Vec4; x1wz: Vec4; x1ww: Vec4; xx00: Vec4; xx01: Vec4; xx0x: Vec4; xx0y: Vec4; xx0z: Vec4; xx0w: Vec4; xx10: Vec4; xx11: Vec4; xx1x: Vec4; xx1y: Vec4; xx1z: Vec4; xx1w: Vec4; xxx0: Vec4; xxx1: Vec4; xxxx: Vec4; xxxy: Vec4; xxxz: Vec4; xxxw: Vec4; xxy0: Vec4; xxy1: Vec4; xxyx: Vec4; xxyy: Vec4; xxyz: Vec4; xxyw: Vec4; xxz0: Vec4; xxz1: Vec4; xxzx: Vec4; xxzy: Vec4; xxzz: Vec4; xxzw: Vec4; xxw0: Vec4; xxw1: Vec4; xxwx: Vec4; xxwy: Vec4; xxwz: Vec4; xxww: Vec4; xy00: Vec4; xy01: Vec4; xy0x: Vec4; xy0y: Vec4; xy0z: Vec4; xy0w: Vec4; xy10: Vec4; xy11: Vec4; xy1x: Vec4; xy1y: Vec4; xy1z: Vec4; xy1w: Vec4; xyx0: Vec4; xyx1: Vec4; xyxx: Vec4; xyxy: Vec4; xyxz: Vec4; xyxw: Vec4; xyy0: Vec4; xyy1: Vec4; xyyx: Vec4; xyyy: Vec4; xyyz: Vec4; xyyw: Vec4; xyz0: Vec4; xyz1: Vec4; xyzx: Vec4; xyzy: Vec4; xyzz: Vec4; xyzw: Vec4; xyw0: Vec4; xyw1: Vec4; xywx: Vec4; xywy: Vec4; xywz: Vec4; xyww: Vec4; xz00: Vec4; xz01: Vec4; xz0x: Vec4; xz0y: Vec4; xz0z: Vec4; xz0w: Vec4; xz10: Vec4; xz11: Vec4; xz1x: Vec4; xz1y: Vec4; xz1z: Vec4; xz1w: Vec4; xzx0: Vec4; xzx1: Vec4; xzxx: Vec4; xzxy: Vec4; xzxz: Vec4; xzxw: Vec4; xzy0: Vec4; xzy1: Vec4; xzyx: Vec4; xzyy: Vec4; xzyz: Vec4; xzyw: Vec4; xzz0: Vec4; xzz1: Vec4; xzzx: Vec4; xzzy: Vec4; xzzz: Vec4; xzzw: Vec4; xzw0: Vec4; xzw1: Vec4; xzwx: Vec4; xzwy: Vec4; xzwz: Vec4; xzww: Vec4; xw00: Vec4; xw01: Vec4; xw0x: Vec4; xw0y: Vec4; xw0z: Vec4; xw0w: Vec4; xw10: Vec4; xw11: Vec4; xw1x: Vec4; xw1y: Vec4; xw1z: Vec4; xw1w: Vec4; xwx0: Vec4; xwx1: Vec4; xwxx: Vec4; xwxy: Vec4; xwxz: Vec4; xwxw: Vec4; xwy0: Vec4; xwy1: Vec4; xwyx: Vec4; xwyy: Vec4; xwyz: Vec4; xwyw: Vec4; xwz0: Vec4; xwz1: Vec4; xwzx: Vec4; xwzy: Vec4; xwzz: Vec4; xwzw: Vec4; xww0: Vec4; xww1: Vec4; xwwx: Vec4; xwwy: Vec4; xwwz: Vec4; xwww: Vec4; y000: Vec4; y001: Vec4; y00x: Vec4; y00y: Vec4; y00z: Vec4; y00w: Vec4; y010: Vec4; y011: Vec4; y01x: Vec4; y01y: Vec4; y01z: Vec4; y01w: Vec4; y0x0: Vec4; y0x1: Vec4; y0xx: Vec4; y0xy: Vec4; y0xz: Vec4; y0xw: Vec4; y0y0: Vec4; y0y1: Vec4; y0yx: Vec4; y0yy: Vec4; y0yz: Vec4; y0yw: Vec4; y0z0: Vec4; y0z1: Vec4; y0zx: Vec4; y0zy: Vec4; y0zz: Vec4; y0zw: Vec4; y0w0: Vec4; y0w1: Vec4; y0wx: Vec4; y0wy: Vec4; y0wz: Vec4; y0ww: Vec4; y100: Vec4; y101: Vec4; y10x: Vec4; y10y: Vec4; y10z: Vec4; y10w: Vec4; y110: Vec4; y111: Vec4; y11x: Vec4; y11y: Vec4; y11z: Vec4; y11w: Vec4; y1x0: Vec4; y1x1: Vec4; y1xx: Vec4; y1xy: Vec4; y1xz: Vec4; y1xw: Vec4; y1y0: Vec4; y1y1: Vec4; y1yx: Vec4; y1yy: Vec4; y1yz: Vec4; y1yw: Vec4; y1z0: Vec4; y1z1: Vec4; y1zx: Vec4; y1zy: Vec4; y1zz: Vec4; y1zw: Vec4; y1w0: Vec4; y1w1: Vec4; y1wx: Vec4; y1wy: Vec4; y1wz: Vec4; y1ww: Vec4; yx00: Vec4; yx01: Vec4; yx0x: Vec4; yx0y: Vec4; yx0z: Vec4; yx0w: Vec4; yx10: Vec4; yx11: Vec4; yx1x: Vec4; yx1y: Vec4; yx1z: Vec4; yx1w: Vec4; yxx0: Vec4; yxx1: Vec4; yxxx: Vec4; yxxy: Vec4; yxxz: Vec4; yxxw: Vec4; yxy0: Vec4; yxy1: Vec4; yxyx: Vec4; yxyy: Vec4; yxyz: Vec4; yxyw: Vec4; yxz0: Vec4; yxz1: Vec4; yxzx: Vec4; yxzy: Vec4; yxzz: Vec4; yxzw: Vec4; yxw0: Vec4; yxw1: Vec4; yxwx: Vec4; yxwy: Vec4; yxwz: Vec4; yxww: Vec4; yy00: Vec4; yy01: Vec4; yy0x: Vec4; yy0y: Vec4; yy0z: Vec4; yy0w: Vec4; yy10: Vec4; yy11: Vec4; yy1x: Vec4; yy1y: Vec4; yy1z: Vec4; yy1w: Vec4; yyx0: Vec4; yyx1: Vec4; yyxx: Vec4; yyxy: Vec4; yyxz: Vec4; yyxw: Vec4; yyy0: Vec4; yyy1: Vec4; yyyx: Vec4; yyyy: Vec4; yyyz: Vec4; yyyw: Vec4; yyz0: Vec4; yyz1: Vec4; yyzx: Vec4; yyzy: Vec4; yyzz: Vec4; yyzw: Vec4; yyw0: Vec4; yyw1: Vec4; yywx: Vec4; yywy: Vec4; yywz: Vec4; yyww: Vec4; yz00: Vec4; yz01: Vec4; yz0x: Vec4; yz0y: Vec4; yz0z: Vec4; yz0w: Vec4; yz10: Vec4; yz11: Vec4; yz1x: Vec4; yz1y: Vec4; yz1z: Vec4; yz1w: Vec4; yzx0: Vec4; yzx1: Vec4; yzxx: Vec4; yzxy: Vec4; yzxz: Vec4; yzxw: Vec4; yzy0: Vec4; yzy1: Vec4; yzyx: Vec4; yzyy: Vec4; yzyz: Vec4; yzyw: Vec4; yzz0: Vec4; yzz1: Vec4; yzzx: Vec4; yzzy: Vec4; yzzz: Vec4; yzzw: Vec4; yzw0: Vec4; yzw1: Vec4; yzwx: Vec4; yzwy: Vec4; yzwz: Vec4; yzww: Vec4; yw00: Vec4; yw01: Vec4; yw0x: Vec4; yw0y: Vec4; yw0z: Vec4; yw0w: Vec4; yw10: Vec4; yw11: Vec4; yw1x: Vec4; yw1y: Vec4; yw1z: Vec4; yw1w: Vec4; ywx0: Vec4; ywx1: Vec4; ywxx: Vec4; ywxy: Vec4; ywxz: Vec4; ywxw: Vec4; ywy0: Vec4; ywy1: Vec4; ywyx: Vec4; ywyy: Vec4; ywyz: Vec4; ywyw: Vec4; ywz0: Vec4; ywz1: Vec4; ywzx: Vec4; ywzy: Vec4; ywzz: Vec4; ywzw: Vec4; yww0: Vec4; yww1: Vec4; ywwx: Vec4; ywwy: Vec4; ywwz: Vec4; ywww: Vec4; z000: Vec4; z001: Vec4; z00x: Vec4; z00y: Vec4; z00z: Vec4; z00w: Vec4; z010: Vec4; z011: Vec4; z01x: Vec4; z01y: Vec4; z01z: Vec4; z01w: Vec4; z0x0: Vec4; z0x1: Vec4; z0xx: Vec4; z0xy: Vec4; z0xz: Vec4; z0xw: Vec4; z0y0: Vec4; z0y1: Vec4; z0yx: Vec4; z0yy: Vec4; z0yz: Vec4; z0yw: Vec4; z0z0: Vec4; z0z1: Vec4; z0zx: Vec4; z0zy: Vec4; z0zz: Vec4; z0zw: Vec4; z0w0: Vec4; z0w1: Vec4; z0wx: Vec4; z0wy: Vec4; z0wz: Vec4; z0ww: Vec4; z100: Vec4; z101: Vec4; z10x: Vec4; z10y: Vec4; z10z: Vec4; z10w: Vec4; z110: Vec4; z111: Vec4; z11x: Vec4; z11y: Vec4; z11z: Vec4; z11w: Vec4; z1x0: Vec4; z1x1: Vec4; z1xx: Vec4; z1xy: Vec4; z1xz: Vec4; z1xw: Vec4; z1y0: Vec4; z1y1: Vec4; z1yx: Vec4; z1yy: Vec4; z1yz: Vec4; z1yw: Vec4; z1z0: Vec4; z1z1: Vec4; z1zx: Vec4; z1zy: Vec4; z1zz: Vec4; z1zw: Vec4; z1w0: Vec4; z1w1: Vec4; z1wx: Vec4; z1wy: Vec4; z1wz: Vec4; z1ww: Vec4; zx00: Vec4; zx01: Vec4; zx0x: Vec4; zx0y: Vec4; zx0z: Vec4; zx0w: Vec4; zx10: Vec4; zx11: Vec4; zx1x: Vec4; zx1y: Vec4; zx1z: Vec4; zx1w: Vec4; zxx0: Vec4; zxx1: Vec4; zxxx: Vec4; zxxy: Vec4; zxxz: Vec4; zxxw: Vec4; zxy0: Vec4; zxy1: Vec4; zxyx: Vec4; zxyy: Vec4; zxyz: Vec4; zxyw: Vec4; zxz0: Vec4; zxz1: Vec4; zxzx: Vec4; zxzy: Vec4; zxzz: Vec4; zxzw: Vec4; zxw0: Vec4; zxw1: Vec4; zxwx: Vec4; zxwy: Vec4; zxwz: Vec4; zxww: Vec4; zy00: Vec4; zy01: Vec4; zy0x: Vec4; zy0y: Vec4; zy0z: Vec4; zy0w: Vec4; zy10: Vec4; zy11: Vec4; zy1x: Vec4; zy1y: Vec4; zy1z: Vec4; zy1w: Vec4; zyx0: Vec4; zyx1: Vec4; zyxx: Vec4; zyxy: Vec4; zyxz: Vec4; zyxw: Vec4; zyy0: Vec4; zyy1: Vec4; zyyx: Vec4; zyyy: Vec4; zyyz: Vec4; zyyw: Vec4; zyz0: Vec4; zyz1: Vec4; zyzx: Vec4; zyzy: Vec4; zyzz: Vec4; zyzw: Vec4; zyw0: Vec4; zyw1: Vec4; zywx: Vec4; zywy: Vec4; zywz: Vec4; zyww: Vec4; zz00: Vec4; zz01: Vec4; zz0x: Vec4; zz0y: Vec4; zz0z: Vec4; zz0w: Vec4; zz10: Vec4; zz11: Vec4; zz1x: Vec4; zz1y: Vec4; zz1z: Vec4; zz1w: Vec4; zzx0: Vec4; zzx1: Vec4; zzxx: Vec4; zzxy: Vec4; zzxz: Vec4; zzxw: Vec4; zzy0: Vec4; zzy1: Vec4; zzyx: Vec4; zzyy: Vec4; zzyz: Vec4; zzyw: Vec4; zzz0: Vec4; zzz1: Vec4; zzzx: Vec4; zzzy: Vec4; zzzz: Vec4; zzzw: Vec4; zzw0: Vec4; zzw1: Vec4; zzwx: Vec4; zzwy: Vec4; zzwz: Vec4; zzww: Vec4; zw00: Vec4; zw01: Vec4; zw0x: Vec4; zw0y: Vec4; zw0z: Vec4; zw0w: Vec4; zw10: Vec4; zw11: Vec4; zw1x: Vec4; zw1y: Vec4; zw1z: Vec4; zw1w: Vec4; zwx0: Vec4; zwx1: Vec4; zwxx: Vec4; zwxy: Vec4; zwxz: Vec4; zwxw: Vec4; zwy0: Vec4; zwy1: Vec4; zwyx: Vec4; zwyy: Vec4; zwyz: Vec4; zwyw: Vec4; zwz0: Vec4; zwz1: Vec4; zwzx: Vec4; zwzy: Vec4; zwzz: Vec4; zwzw: Vec4; zww0: Vec4; zww1: Vec4; zwwx: Vec4; zwwy: Vec4; zwwz: Vec4; zwww: Vec4; w000: Vec4; w001: Vec4; w00x: Vec4; w00y: Vec4; w00z: Vec4; w00w: Vec4; w010: Vec4; w011: Vec4; w01x: Vec4; w01y: Vec4; w01z: Vec4; w01w: Vec4; w0x0: Vec4; w0x1: Vec4; w0xx: Vec4; w0xy: Vec4; w0xz: Vec4; w0xw: Vec4; w0y0: Vec4; w0y1: Vec4; w0yx: Vec4; w0yy: Vec4; w0yz: Vec4; w0yw: Vec4; w0z0: Vec4; w0z1: Vec4; w0zx: Vec4; w0zy: Vec4; w0zz: Vec4; w0zw: Vec4; w0w0: Vec4; w0w1: Vec4; w0wx: Vec4; w0wy: Vec4; w0wz: Vec4; w0ww: Vec4; w100: Vec4; w101: Vec4; w10x: Vec4; w10y: Vec4; w10z: Vec4; w10w: Vec4; w110: Vec4; w111: Vec4; w11x: Vec4; w11y: Vec4; w11z: Vec4; w11w: Vec4; w1x0: Vec4; w1x1: Vec4; w1xx: Vec4; w1xy: Vec4; w1xz: Vec4; w1xw: Vec4; w1y0: Vec4; w1y1: Vec4; w1yx: Vec4; w1yy: Vec4; w1yz: Vec4; w1yw: Vec4; w1z0: Vec4; w1z1: Vec4; w1zx: Vec4; w1zy: Vec4; w1zz: Vec4; w1zw: Vec4; w1w0: Vec4; w1w1: Vec4; w1wx: Vec4; w1wy: Vec4; w1wz: Vec4; w1ww: Vec4; wx00: Vec4; wx01: Vec4; wx0x: Vec4; wx0y: Vec4; wx0z: Vec4; wx0w: Vec4; wx10: Vec4; wx11: Vec4; wx1x: Vec4; wx1y: Vec4; wx1z: Vec4; wx1w: Vec4; wxx0: Vec4; wxx1: Vec4; wxxx: Vec4; wxxy: Vec4; wxxz: Vec4; wxxw: Vec4; wxy0: Vec4; wxy1: Vec4; wxyx: Vec4; wxyy: Vec4; wxyz: Vec4; wxyw: Vec4; wxz0: Vec4; wxz1: Vec4; wxzx: Vec4; wxzy: Vec4; wxzz: Vec4; wxzw: Vec4; wxw0: Vec4; wxw1: Vec4; wxwx: Vec4; wxwy: Vec4; wxwz: Vec4; wxww: Vec4; wy00: Vec4; wy01: Vec4; wy0x: Vec4; wy0y: Vec4; wy0z: Vec4; wy0w: Vec4; wy10: Vec4; wy11: Vec4; wy1x: Vec4; wy1y: Vec4; wy1z: Vec4; wy1w: Vec4; wyx0: Vec4; wyx1: Vec4; wyxx: Vec4; wyxy: Vec4; wyxz: Vec4; wyxw: Vec4; wyy0: Vec4; wyy1: Vec4; wyyx: Vec4; wyyy: Vec4; wyyz: Vec4; wyyw: Vec4; wyz0: Vec4; wyz1: Vec4; wyzx: Vec4; wyzy: Vec4; wyzz: Vec4; wyzw: Vec4; wyw0: Vec4; wyw1: Vec4; wywx: Vec4; wywy: Vec4; wywz: Vec4; wyww: Vec4; wz00: Vec4; wz01: Vec4; wz0x: Vec4; wz0y: Vec4; wz0z: Vec4; wz0w: Vec4; wz10: Vec4; wz11: Vec4; wz1x: Vec4; wz1y: Vec4; wz1z: Vec4; wz1w: Vec4; wzx0: Vec4; wzx1: Vec4; wzxx: Vec4; wzxy: Vec4; wzxz: Vec4; wzxw: Vec4; wzy0: Vec4; wzy1: Vec4; wzyx: Vec4; wzyy: Vec4; wzyz: Vec4; wzyw: Vec4; wzz0: Vec4; wzz1: Vec4; wzzx: Vec4; wzzy: Vec4; wzzz: Vec4; wzzw: Vec4; wzw0: Vec4; wzw1: Vec4; wzwx: Vec4; wzwy: Vec4; wzwz: Vec4; wzww: Vec4; ww00: Vec4; ww01: Vec4; ww0x: Vec4; ww0y: Vec4; ww0z: Vec4; ww0w: Vec4; ww10: Vec4; ww11: Vec4; ww1x: Vec4; ww1y: Vec4; ww1z: Vec4; ww1w: Vec4; wwx0: Vec4; wwx1: Vec4; wwxx: Vec4; wwxy: Vec4; wwxz: Vec4; wwxw: Vec4; wwy0: Vec4; wwy1: Vec4; wwyx: Vec4; wwyy: Vec4; wwyz: Vec4; wwyw: Vec4; wwz0: Vec4; wwz1: Vec4; wwzx: Vec4; wwzy: Vec4; wwzz: Vec4; wwzw: Vec4; www0: Vec4; www1: Vec4; wwwx: Vec4; wwwy: Vec4; wwwz: Vec4; wwww: Vec4;
@@ -1052,6 +1073,7 @@ Vec3.prototype.neg = Vec3.prototype.negate
 Vec3.prototype.unaryMinus = Vec3.prototype.negate
 Vec3.prototype.sqrLen = Vec3.prototype.squaredLength
 Vec3.prototype.str = Vec3.prototype.toString
+Vec3.prototype.normalized = Vec3.prototype.normalize
 Vec3.prototype.transformMat3x3 = Vec3.prototype.transformMat3
 Vec3.prototype.transformMat4x4 = Vec3.prototype.transformMat4