@vertexvis/geometry 1.0.2-canary.0 → 1.0.2-canary.10

package/dist/bundle.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var tslib = require('tslib');
 
 /**
@@ -176,21 +174,21 @@ function fromJson$5(json) {
 
 var point = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  add: add$1,
   create: create$d,
-  polar: polar,
   distance: distance$2,
-  subtract: subtract$1,
-  add: add$1,
+  fromJson: fromJson$5,
   isEqual: isEqual$3,
   lerp: lerp$1,
-  negate: negate$1,
-  scale: scale$5,
-  scaleProportional: scaleProportional,
   magnitude: magnitude$2,
-  normalizeVector: normalizeVector,
+  negate: negate$1,
   normalDirectionVector: normalDirectionVector,
+  normalizeVector: normalizeVector,
   orthogonalVector: orthogonalVector,
-  fromJson: fromJson$5
+  polar: polar,
+  scale: scale$5,
+  scaleProportional: scaleProportional,
+  subtract: subtract$1
 });
 
 /**
@@ -261,10 +259,10 @@ function fromValues(
 m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44) {
     /* eslint-disable prettier/prettier */
     return [
-        m11, m21, m31, m41,
-        m12, m22, m32, m42,
-        m13, m23, m33, m43,
-        m14, m24, m34, m44,
+        m11, m12, m13, m14,
+        m21, m22, m23, m24,
+        m31, m32, m33, m34,
+        m41, m42, m43, m44,
     ];
     /* eslint-enable prettier/prettier */
 }
@@ -334,9 +332,9 @@ function makeRotation(rotation) {
     var wx = w * x2, wy = w * y2, wz = w * z2;
     /* eslint-disable prettier/prettier */
     return [
-        1 - (yy + zz), xy + wz, xz - wy, 0,
-        xy - wz, 1 - (xx + zz), yz + wx, 0,
-        xz + wy, yz - wx, 1 - (xx + yy), 0,
+        1 - (yy + zz), xy - wz, xz + wy, 0,
+        xy + wz, 1 - (xx + zz), yz - wx, 0,
+        xz - wy, yz + wx, 1 - (xx + yy), 0,
         0, 0, 0, 1
     ];
     /* eslint-enable prettier/prettier */
@@ -366,33 +364,33 @@ function makeScale(scale) {
     /* eslint-enable prettier/prettier */
 }
 /**
- * Creates a matrix that has translation, rotation and scale applied to it.
+ * Creates a matrix that has translation, rotation, and scale applied to it.
  *
  * @param translation The translation applied to the matrix.
  * @param rotation The rotation applied to the matrix.
  * @param scale The scale applied to the matrix.
- * @returns A transformed matrix.
+ * @returns A transformed matrix in column-major form.
  */
 function makeTRS(translation, rotation, scale) {
     var t = makeTranslation(translation);
-    var r = makeRotation(rotation);
+    var r = transpose(makeRotation(rotation));
     var s = makeScale(scale);
-    return multiply$2(multiply$2(t, r), s);
+    return multiply$2(s, multiply$2(r, t));
 }
 /**
  * Returns a matrix that has the basis components (upper left 3x3 matrix) set to
  * the following x, y, and z axis.
  *
  * ```
- * x.x  y.x  z.x  0
- * x.y  y.y  z.y  0
- * x.z  y.z  z.z  0
+ * x.x  x.y  x.z  0
+ * y.x  y.y  y.z  0
+ * z.x  z.y  z.z  0
  * 0    0    0    0
  * ```
  *
- * @param x The x axis to set.
- * @param y The y axis to set.
- * @param z The z axis to set.
+ * @param x The x-axis to set.
+ * @param y The y-axis to set.
+ * @param z The z-axis to set.
  * @returns A matrix with its basis components populated.
  */
 function makeBasis(x, y, z) {
@@ -405,30 +403,6 @@ function makeBasis(x, y, z) {
     ];
     /* eslint-enable prettier/prettier */
 }
-/**
- * Creates a rotation matrix that is rotated around a given axis by the given
- * angle.
- *
- * @param axis The axis of rotation.
- * @param radians The angle of rotation.
- * @returns A rotation matrix.
- */
-function makeRotationAxis(axis, radians) {
-    var c = Math.cos(radians);
-    var s = Math.sin(radians);
-    var t = 1 - c;
-    var x = axis.x, y = axis.y, z = axis.z;
-    var tx = t * x;
-    var ty = t * y;
-    /* eslint-disable prettier/prettier */
-    return [
-        tx * x + c, tx * y + s * z, tx * z - s * y, 0,
-        tx * y - s * z, ty * y + c, ty * z + s * x, 0,
-        tx * z + s * y, ty * z - s * x, t * z * z + c, 0,
-        0, 0, 0, 1
-    ];
-    /* eslint-enable prettier/prettier */
-}
 /**
  * Creates a matrix used for [perspective
  * projections](https://en.wikipedia.org/wiki/3D_projection#Perspective_projection).
@@ -610,24 +584,24 @@ function invert(matrix) {
     if (!det) {
         return makeZero();
     }
-    det = 1.0 / det;
+    var oneOverDet = 1 / det;
     return [
-        (a11 * b11 - a12 * b10 + a13 * b09) * det,
-        (a02 * b10 - a01 * b11 - a03 * b09) * det,
-        (a31 * b05 - a32 * b04 + a33 * b03) * det,
-        (a22 * b04 - a21 * b05 - a23 * b03) * det,
-        (a12 * b08 - a10 * b11 - a13 * b07) * det,
-        (a00 * b11 - a02 * b08 + a03 * b07) * det,
-        (a32 * b02 - a30 * b05 - a33 * b01) * det,
-        (a20 * b05 - a22 * b02 + a23 * b01) * det,
-        (a10 * b10 - a11 * b08 + a13 * b06) * det,
-        (a01 * b08 - a00 * b10 - a03 * b06) * det,
-        (a30 * b04 - a31 * b02 + a33 * b00) * det,
-        (a21 * b02 - a20 * b04 - a23 * b00) * det,
-        (a11 * b07 - a10 * b09 - a12 * b06) * det,
-        (a00 * b09 - a01 * b07 + a02 * b06) * det,
-        (a31 * b01 - a30 * b03 - a32 * b00) * det,
-        (a20 * b03 - a21 * b01 + a22 * b00) * det,
+        (a11 * b11 - a12 * b10 + a13 * b09) * oneOverDet,
+        (a02 * b10 - a01 * b11 - a03 * b09) * oneOverDet,
+        (a31 * b05 - a32 * b04 + a33 * b03) * oneOverDet,
+        (a22 * b04 - a21 * b05 - a23 * b03) * oneOverDet,
+        (a12 * b08 - a10 * b11 - a13 * b07) * oneOverDet,
+        (a00 * b11 - a02 * b08 + a03 * b07) * oneOverDet,
+        (a32 * b02 - a30 * b05 - a33 * b01) * oneOverDet,
+        (a20 * b05 - a22 * b02 + a23 * b01) * oneOverDet,
+        (a10 * b10 - a11 * b08 + a13 * b06) * oneOverDet,
+        (a01 * b08 - a00 * b10 - a03 * b06) * oneOverDet,
+        (a30 * b04 - a31 * b02 + a33 * b00) * oneOverDet,
+        (a21 * b02 - a20 * b04 - a23 * b00) * oneOverDet,
+        (a11 * b07 - a10 * b09 - a12 * b06) * oneOverDet,
+        (a00 * b09 - a01 * b07 + a02 * b06) * oneOverDet,
+        (a31 * b01 - a30 * b03 - a32 * b00) * oneOverDet,
+        (a20 * b03 - a21 * b01 + a22 * b00) * oneOverDet,
     ];
 }
 /**
@@ -662,49 +636,37 @@ function lookAt(m, position, target, up) {
     var res = tslib.__spreadArray([], m, true);
     /* eslint-disable prettier/prettier */
     res[0] = x.x;
-    res[4] = y.x;
-    res[8] = z.x;
     res[1] = x.y;
-    res[5] = y.y;
-    res[9] = z.y;
     res[2] = x.z;
+    res[4] = y.x;
+    res[5] = y.y;
     res[6] = y.z;
+    res[8] = z.x;
+    res[9] = z.y;
     res[10] = z.z;
     /* eslint-enable prettier/prettier */
     return res;
 }
 /**
- * Returns a post-multiplied matrix.
+ * Returns a post-multiplied matrix equal to ab.
  */
 function multiply$2(a, b) {
-    var ae = a;
-    var be = b;
-    var a11 = ae[0], a12 = ae[4], a13 = ae[8], a14 = ae[12];
-    var a21 = ae[1], a22 = ae[5], a23 = ae[9], a24 = ae[13];
-    var a31 = ae[2], a32 = ae[6], a33 = ae[10], a34 = ae[14];
-    var a41 = ae[3], a42 = ae[7], a43 = ae[11], a44 = ae[15];
-    var b11 = be[0], b12 = be[4], b13 = be[8], b14 = be[12];
-    var b21 = be[1], b22 = be[5], b23 = be[9], b24 = be[13];
-    var b31 = be[2], b32 = be[6], b33 = be[10], b34 = be[14];
-    var b41 = be[3], b42 = be[7], b43 = be[11], b44 = be[15];
-    var mat = makeIdentity();
-    mat[0] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
-    mat[4] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
-    mat[8] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
-    mat[12] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
-    mat[1] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
-    mat[5] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
-    mat[9] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
-    mat[13] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
-    mat[2] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
-    mat[6] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
-    mat[10] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
-    mat[14] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
-    mat[3] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
-    mat[7] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
-    mat[11] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
-    mat[15] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
-    return mat;
+    var result = makeIdentity();
+    // Consider each row i in the final matrix
+    for (var i = 0; i < 4; i++) {
+        // Consider each column j in the final matrix
+        for (var j = 0; j < 4; j++) {
+            // Calculate the value at row i and column j
+            var value = 0;
+            for (var k = 0; k < 4; k++) {
+                // Calculate (ik + kj) and add it to the value
+                value += a[i * 4 + k] * b[k * 4 + j];
+            }
+            var positionInResultingMatrix = 4 * i + j;
+            result[positionInResultingMatrix] = value;
+        }
+    }
+    return result;
 }
 /**
  * Returns the [transpose](https://en.wikipedia.org/wiki/Transpose) of the given
@@ -721,32 +683,37 @@ function transpose(matrix) {
     /* eslint-enable prettier/prettier */
 }
 /**
- * Multiplies the columns of a matrix by the given vector.
+ * Multiplies the columns of a row-major matrix by the given vector.
  */
 function scale$4(matrix, scale) {
     var x = scale.x, y = scale.y, z = scale.z;
     var m = tslib.__spreadArray([], matrix, true);
     /* eslint-disable prettier/prettier */
     m[0] *= x;
-    m[4] *= y;
-    m[8] *= z;
     m[1] *= x;
-    m[5] *= y;
-    m[9] *= z;
     m[2] *= x;
-    m[6] *= y;
-    m[10] *= z;
     m[3] *= x;
+    m[4] *= y;
+    m[5] *= y;
+    m[6] *= y;
     m[7] *= y;
+    m[8] *= z;
+    m[9] *= z;
+    m[10] *= z;
     m[11] *= z;
     /* eslint-enable prettier/prettier */
     return m;
 }
-function position(matrix, other) {
-    var m = tslib.__spreadArray([], matrix, true);
-    m[12] = other[12];
-    m[13] = other[13];
-    m[14] = other[14];
+/**
+ * Sets the position of the matrix given as the first parameter
+ * to the position of the matrix given as the second parameter.
+ * Both matrices should have row-major format.
+ */
+function position(originalMatrix, matrixWithDesiredPosition) {
+    var m = tslib.__spreadArray([], originalMatrix, true);
+    m[12] = matrixWithDesiredPosition[12];
+    m[13] = matrixWithDesiredPosition[13];
+    m[14] = matrixWithDesiredPosition[14];
     return m;
 }
 /**
@@ -758,8 +725,18 @@ function isIdentity(matrix) {
 }
 /**
  * Returns an object representation of a `Matrix4`.
+ * @param m A Matrix4 item written in column-major form.
+ *
+ * @deprecated Use {@link toObjectColumnMajor} or {@link toObjectRowMajor} instead.
  */
 function toObject(m) {
+    return toObjectColumnMajor(m);
+}
+/**
+ * Returns an object representation of a `Matrix4`.
+ * @param m A Matrix4 item written in column-major form.
+ */
+function toObjectColumnMajor(m) {
     /* eslint-disable prettier/prettier */
     return {
         m11: m[0], m12: m[4], m13: m[8], m14: m[12],
@@ -769,6 +746,20 @@ function toObject(m) {
     };
     /* eslint-enable prettier/prettier */
 }
+/**
+ * Returns an object representation of a `Matrix4`.
+ * @param m A Matrix4 item written in row-major form.
+ */
+function toObjectRowMajor(m) {
+    /* eslint-disable prettier/prettier */
+    return {
+        m11: m[0], m12: m[1], m13: m[2], m14: m[3],
+        m21: m[4], m22: m[5], m23: m[6], m24: m[7],
+        m31: m[8], m32: m[9], m33: m[10], m34: m[11],
+        m41: m[12], m42: m[13], m43: m[14], m44: m[15],
+    };
+    /* eslint-enable prettier/prettier */
+}
 /**
  * A type guard to check if `obj` is of type `Matrix4`.
  */
@@ -778,30 +769,31 @@ function isType$2(obj) {
 
 var matrix4 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  fromValues: fromValues,
   fromObject: fromObject,
+  fromValues: fromValues,
+  invert: invert,
+  isIdentity: isIdentity,
+  isType: isType$2,
+  lookAt: lookAt,
+  makeBasis: makeBasis,
+  makeFrustum: makeFrustum,
   makeIdentity: makeIdentity,
-  makeZero: makeZero,
-  makeTranslation: makeTranslation,
+  makeLookAt: makeLookAt,
+  makeLookAtView: makeLookAtView,
+  makeOrthographic: makeOrthographic,
+  makePerspective: makePerspective,
   makeRotation: makeRotation,
   makeScale: makeScale,
   makeTRS: makeTRS,
-  makeBasis: makeBasis,
-  makeRotationAxis: makeRotationAxis,
-  makeFrustum: makeFrustum,
-  makePerspective: makePerspective,
-  makeOrthographic: makeOrthographic,
-  makeLookAtView: makeLookAtView,
-  makeLookAt: makeLookAt,
-  invert: invert,
-  lookAt: lookAt,
+  makeTranslation: makeTranslation,
+  makeZero: makeZero,
   multiply: multiply$2,
-  transpose: transpose,
-  scale: scale$4,
   position: position,
-  isIdentity: isIdentity,
+  scale: scale$4,
   toObject: toObject,
-  isType: isType$2
+  toObjectColumnMajor: toObjectColumnMajor,
+  toObjectRowMajor: toObjectRowMajor,
+  transpose: transpose
 });
 
 /**
@@ -851,9 +843,12 @@ function fromDegrees(value) {
  * @param matrix A pure rotation matrix, unscaled.
  * @param order The order that the rotations are applied.
  */
-function fromRotationMatrix(matrix, order) {
+function fromRotationMatrix(matrix, order, matrixIsColumnMajor) {
     if (order === void 0) { order = 'xyz'; }
-    var m = toObject(matrix);
+    if (matrixIsColumnMajor === void 0) { matrixIsColumnMajor = true; }
+    var m = matrixIsColumnMajor
+        ? toObjectColumnMajor(matrix)
+        : toObjectRowMajor(matrix);
     var x = 0, y = 0, z = 0;
     if (order === 'xyz') {
         y = Math.asin(clamp(m.m13, -1, 1));
@@ -959,8 +954,8 @@ var euler = /*#__PURE__*/Object.freeze({
   __proto__: null,
   create: create$c,
   fromDegrees: fromDegrees,
-  fromRotationMatrix: fromRotationMatrix,
   fromJson: fromJson$4,
+  fromRotationMatrix: fromRotationMatrix,
   isType: isType$1
 });
 
@@ -1032,55 +1027,47 @@ function fromAxisAngle(axis, radians) {
  * (unscaled).
  */
 function fromMatrixRotation(matrix) {
-    var m = toObject(matrix);
+    // Determine the scalars for each vector
     var scale = fromMatrixScale(matrix);
-    var is1 = 1 / scale.x;
-    var is2 = 1 / scale.y;
-    var is3 = 1 / scale.z;
-    var sm11 = m.m11 * is1;
-    var sm12 = m.m21 * is2;
-    var sm13 = m.m31 * is3;
-    var sm21 = m.m12 * is1;
-    var sm22 = m.m22 * is2;
-    var sm23 = m.m32 * is3;
-    var sm31 = m.m13 * is1;
-    var sm32 = m.m23 * is2;
-    var sm33 = m.m33 * is3;
-    var trace = sm11 + sm22 + sm33;
+    var oneOverScaleVector = create$a(1 / scale.x, 1 / scale.y, 1 / scale.z);
+    // Scale the matrix
+    var scaledMatrix = scale$4(matrix, oneOverScaleVector);
+    var sM = toObjectRowMajor(scaledMatrix);
+    var trace = sM.m11 + sM.m22 + sM.m33;
     if (trace > 0) {
-        var s = Math.sqrt(trace + 1.0) * 2;
+        var s = Math.sqrt(trace + 1) * 2;
         return {
-            x: (sm23 - sm32) / s,
-            y: (sm31 - sm13) / s,
-            z: (sm12 - sm21) / s,
+            x: (sM.m23 - sM.m32) / s,
+            y: (sM.m31 - sM.m13) / s,
+            z: (sM.m12 - sM.m21) / s,
             w: 0.25 * s,
         };
     }
-    else if (sm11 > sm22 && sm11 > sm33) {
-        var s = Math.sqrt(1.0 + sm11 - sm22 - sm33) * 2;
+    else if (sM.m11 > sM.m22 && sM.m11 > sM.m33) {
+        var s = Math.sqrt(1 + sM.m11 - sM.m22 - sM.m33) * 2;
         return {
             x: 0.25 * s,
-            y: (sm12 + sm21) / s,
-            z: (sm31 + sm13) / s,
-            w: (sm23 - sm32) / s,
+            y: (sM.m12 + sM.m21) / s,
+            z: (sM.m31 + sM.m13) / s,
+            w: (sM.m23 - sM.m32) / s,
         };
     }
-    else if (sm22 > sm33) {
-        var s = Math.sqrt(1.0 + sm22 - sm11 - sm33) * 2;
+    else if (sM.m22 > sM.m33) {
+        var s = Math.sqrt(1 + sM.m22 - sM.m11 - sM.m33) * 2;
         return {
-            x: (sm12 + sm21) / s,
+            x: (sM.m12 + sM.m21) / s,
             y: 0.25 * s,
-            z: (sm23 + sm32) / s,
-            w: (sm31 - sm13) / s,
+            z: (sM.m23 + sM.m32) / s,
+            w: (sM.m31 - sM.m13) / s,
         };
     }
     else {
-        var s = Math.sqrt(1.0 + sm33 - sm11 - sm22) * 2;
+        var s = Math.sqrt(1 + sM.m33 - sM.m11 - sM.m22) * 2;
         return {
-            x: (sm31 + sm13) / s,
-            y: (sm23 + sm32) / s,
+            x: (sM.m31 + sM.m13) / s,
+            y: (sM.m23 + sM.m32) / s,
             z: 0.25 * s,
-            w: (sm12 - sm21) / s,
+            w: (sM.m12 - sM.m21) / s,
         };
     }
 }
@@ -1161,15 +1148,15 @@ function isType(obj) {
 var quaternion = /*#__PURE__*/Object.freeze({
   __proto__: null,
   create: create$b,
-  fromJson: fromJson$3,
-  normalize: normalize$1,
-  magnitude: magnitude$1,
-  scale: scale$3,
   fromAxisAngle: fromAxisAngle,
-  fromMatrixRotation: fromMatrixRotation,
   fromEuler: fromEuler,
+  fromJson: fromJson$3,
+  fromMatrixRotation: fromMatrixRotation,
+  isType: isType,
+  magnitude: magnitude$1,
   multiply: multiply$1,
-  isType: isType
+  normalize: normalize$1,
+  scale: scale$3
 });
 
 function create$a() {
@@ -1212,19 +1199,19 @@ function isValid$1(_a) {
  * Returns a vector representing the scale elements of `matrix`.
  */
 function fromMatrixScale(matrix) {
-    var m = toObject(matrix);
+    var m = toObjectRowMajor(matrix);
     return {
-        x: Math.hypot(m.m11, m.m21, m.m31),
-        y: Math.hypot(m.m12, m.m22, m.m32),
-        z: Math.hypot(m.m13, m.m23, m.m33),
+        x: Math.hypot(m.m11, m.m12, m.m13),
+        y: Math.hypot(m.m21, m.m22, m.m23),
+        z: Math.hypot(m.m31, m.m32, m.m33),
     };
 }
 /**
  * Returns a vector representing the position elements of `matrix`.
  */
 function fromMatrixPosition(matrix) {
-    var m = toObject(matrix);
-    return { x: m.m14, y: m.m24, z: m.m34 };
+    var m = toObjectRowMajor(matrix);
+    return { x: m.m41, y: m.m42, z: m.m43 };
 }
 /**
  * Parses a JSON string representation of a Vector3 and returns an object.
@@ -1422,7 +1409,7 @@ function eulerTo(a, b) {
         return dotAB > 1 - 1e-6 ? create$c() : create$c({ x: Math.PI });
     }
     var normalizedQ = normalize$1(create$b(tslib.__assign({ w: 1 + dotAB }, cross(normalizedA, normalizedB))));
-    return fromRotationMatrix(makeRotation(normalizedQ));
+    return fromRotationMatrix(makeRotation(normalizedQ), 'xyz', false);
 }
 /**
  * Performs a projection of a `vector` onto `onNormal`.
@@ -1474,9 +1461,21 @@ function rotateAboutAxis(angle, point, axisDirection, axisPosition) {
     }
 }
 /**
- * Returns a vector that is multiplied with a matrix.
+ * Returns a vector that is multiplied with a matrix in column-major form.
+ * @param vector A Vector3 item.
+ * @param m A Matrix4 item written in column-major form.
+ *
+ * @deprecated Use {@link multiplyByTransformMatrixColumnMajor} or {@link multiplyByTransformMatrixRowMajor} instead.
  */
 function transformMatrix$1(vector, m) {
+    return multiplyByTransformMatrixColumnMajor(vector, m);
+}
+/**
+ * Returns a vector that is multiplied with a matrix in column-major form.
+ * @param vector A Vector3 item.
+ * @param m A Matrix4 item written in column-major form.
+ */
+function multiplyByTransformMatrixColumnMajor(vector, m) {
     var x = vector.x, y = vector.y, z = vector.z;
     var w = 1 / (m[3] * x + m[7] * y + m[11] * z + m[15]);
     return {
@@ -1485,6 +1484,20 @@ function transformMatrix$1(vector, m) {
         z: (m[2] * x + m[6] * y + m[10] * z + m[14]) * w,
     };
 }
+/**
+ * Returns a vector that is multiplied with a matrix in row-major form.
+ * @param vector A Vector3 item.
+ * @param m A Matrix4 item written in row-major form.
+ */
+function multiplyByTransformMatrixRowMajor(vector, m) {
+    var x = vector.x, y = vector.y, z = vector.z;
+    var w = 1 / (m[12] * x + m[13] * y + m[14] * z + m[15]);
+    return {
+        x: (m[0] * x + m[1] * y + m[2] * z + m[3]) * w,
+        y: (m[4] * x + m[5] * y + m[6] * z + m[7]) * w,
+        z: (m[8] * x + m[9] * y + m[10] * z + m[11]) * w,
+    };
+}
 /**
  * Euclidean distance between two vectors
  */
@@ -1548,47 +1561,49 @@ function lerp(a, b, t) {
  * @returns A point in world space coordinates.
  */
 function transformNdcToWorldSpace(ndc, worldMatrix, projectionMatrixInverse) {
-    return transformMatrix$1(transformMatrix$1(ndc, projectionMatrixInverse), worldMatrix);
+    return multiplyByTransformMatrixColumnMajor(multiplyByTransformMatrixColumnMajor(ndc, projectionMatrixInverse), worldMatrix);
 }
 
 var vector3 = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  add: add,
+  angleTo: angleTo,
+  back: back,
   create: create$a,
-  isValid: isValid$1,
-  fromMatrixScale: fromMatrixScale,
-  fromMatrixPosition: fromMatrixPosition,
-  fromJson: fromJson$2,
-  fromArray: fromArray,
-  toArray: toArray,
-  right: right,
-  up: up,
+  cross: cross,
+  distance: distance$1,
+  distanceSquared: distanceSquared$1,
+  dot: dot$1,
+  down: down,
+  eulerTo: eulerTo,
   forward: forward,
+  fromArray: fromArray,
+  fromJson: fromJson$2,
+  fromMatrixPosition: fromMatrixPosition,
+  fromMatrixScale: fromMatrixScale,
+  isEqual: isEqual$2,
+  isValid: isValid$1,
   left: left,
-  down: down,
-  back: back,
-  origin: origin,
-  normalize: normalize,
+  lerp: lerp,
   magnitude: magnitude,
   magnitudeSquared: magnitudeSquared,
-  cross: cross,
-  add: add,
-  subtract: subtract,
+  max: max,
+  min: min,
   multiply: multiply,
-  scale: scale$2,
-  dot: dot$1,
-  angleTo: angleTo,
-  eulerTo: eulerTo,
+  multiplyByTransformMatrixColumnMajor: multiplyByTransformMatrixColumnMajor,
+  multiplyByTransformMatrixRowMajor: multiplyByTransformMatrixRowMajor,
+  negate: negate,
+  normalize: normalize,
+  origin: origin,
   project: project,
+  right: right,
   rotateAboutAxis: rotateAboutAxis,
+  scale: scale$2,
+  subtract: subtract,
+  toArray: toArray,
   transformMatrix: transformMatrix$1,
-  distance: distance$1,
-  distanceSquared: distanceSquared$1,
-  isEqual: isEqual$2,
-  max: max,
-  min: min,
-  negate: negate,
-  lerp: lerp,
-  transformNdcToWorldSpace: transformNdcToWorldSpace
+  transformNdcToWorldSpace: transformNdcToWorldSpace,
+  up: up
 });
 
 /**
@@ -1653,14 +1668,14 @@ function isValid(boundingBox) {
 
 var boundingBox = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$9,
-  fromVectors: fromVectors,
   center: center$3,
+  create: create$9,
   diagonal: diagonal,
   epsilon: epsilon,
-  union: union,
+  fromVectors: fromVectors,
+  isValid: isValid,
   lengths: lengths,
-  isValid: isValid
+  union: union
 });
 
 /**
@@ -1874,26 +1889,26 @@ function fromJson$1(json) {
 
 var rectangle = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  area: area$1,
+  bottomRight: bottomRight,
+  center: center$2,
+  containFit: containFit$1,
+  containsPoints: containsPoints,
   create: create$7,
+  cropFit: cropFit$1,
   fromDimensions: fromDimensions,
+  fromJson: fromJson$1,
   fromPointAndDimensions: fromPointAndDimensions,
   fromPoints: fromPoints,
-  containFit: containFit$1,
-  cropFit: cropFit$1,
-  scaleFit: scaleFit$1,
-  scale: scale$1,
   isEqual: isEqual$1,
-  offset: offset,
-  area: area$1,
-  center: center$2,
-  topLeft: topLeft,
-  bottomRight: bottomRight,
-  isPortrait: isPortrait,
   isLandscape: isLandscape,
+  isPortrait: isPortrait,
   isSquare: isSquare,
+  offset: offset,
   pad: pad,
-  containsPoints: containsPoints,
-  fromJson: fromJson$1
+  scale: scale$1,
+  scaleFit: scaleFit$1,
+  topLeft: topLeft
 });
 
 /**
@@ -2037,22 +2052,22 @@ function toRectangle(dimensions, position) {
 
 var dimensions = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  area: area,
+  aspectRatio: aspectRatio,
+  center: center$1,
+  containFit: containFit,
   create: create$6,
-  square: square,
+  cropFit: cropFit,
+  fitToRatio: fitToRatio,
+  floor: floor,
   isEqual: isEqual,
-  scale: scale,
   proportionalScale: proportionalScale,
-  trim: trim,
-  containFit: containFit,
-  cropFit: cropFit,
-  scaleFit: scaleFit,
   round: round,
-  floor: floor,
-  center: center$1,
-  aspectRatio: aspectRatio,
-  area: area,
-  fitToRatio: fitToRatio,
-  toRectangle: toRectangle
+  scale: scale,
+  scaleFit: scaleFit,
+  square: square,
+  toRectangle: toRectangle,
+  trim: trim
 });
 
 /**
@@ -2084,8 +2099,8 @@ function center(line) {
  * @returns A transformed line.
  */
 function transformMatrix(line, matrix) {
-    var start = transformMatrix$1(line.start, matrix);
-    var end = transformMatrix$1(line.end, matrix);
+    var start = multiplyByTransformMatrixColumnMajor(line.start, matrix);
+    var end = multiplyByTransformMatrixColumnMajor(line.end, matrix);
     return { start: start, end: end };
 }
 /**
@@ -2110,12 +2125,12 @@ function direction(line) {
 
 var line3 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$5,
   center: center,
-  transformMatrix: transformMatrix,
+  create: create$5,
+  direction: direction,
   distance: distance,
   distanceSquared: distanceSquared,
-  direction: direction
+  transformMatrix: transformMatrix
 });
 
 /**
@@ -2184,11 +2199,11 @@ var matrix = /*#__PURE__*/Object.freeze({
   __proto__: null,
   create: create$4,
   identity: identity,
-  translation: translation,
-  rotation: rotation,
   rotate: rotate,
+  rotation: rotation,
+  transformPoint: transformPoint,
   translate: translate,
-  transformPoint: transformPoint
+  translation: translation
 });
 
 function create$3() {
@@ -2313,8 +2328,8 @@ function projectPoint(plane, point) {
 var plane = /*#__PURE__*/Object.freeze({
   __proto__: null,
   create: create$2,
-  fromNormalAndCoplanarPoint: fromNormalAndCoplanarPoint,
   distanceToPoint: distanceToPoint,
+  fromNormalAndCoplanarPoint: fromNormalAndCoplanarPoint,
   intersectLine: intersectLine,
   projectPoint: projectPoint
 });
@@ -2381,8 +2396,8 @@ function intersectPlane(ray, plane) {
 
 var ray = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  create: create$1,
   at: at,
+  create: create$1,
   distanceToPlane: distanceToPlane,
   intersectPlane: intersectPlane
 });