@vertexvis/geometry 1.0.2-canary.7 → 1.0.2-canary.9

package/dist/cdn/bundle.js

@@ -257,10 +257,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 */
 }
@@ -330,9 +330,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 */
@@ -362,33 +362,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) {
@@ -401,30 +401,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).
@@ -606,24 +582,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,
     ];
 }
 /**
@@ -658,49 +634,37 @@ function lookAt(m, position, target, up) {
     var res = __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
@@ -717,32 +681,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 = __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 = __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 = __spreadArray([], originalMatrix, true);
+    m[12] = matrixWithDesiredPosition[12];
+    m[13] = matrixWithDesiredPosition[13];
+    m[14] = matrixWithDesiredPosition[14];
     return m;
 }
 /**
@@ -754,8 +723,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],
@@ -765,6 +744,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`.
  */
@@ -788,7 +781,6 @@ var matrix4 = /*#__PURE__*/Object.freeze({
   makeOrthographic: makeOrthographic,
   makePerspective: makePerspective,
   makeRotation: makeRotation,
-  makeRotationAxis: makeRotationAxis,
   makeScale: makeScale,
   makeTRS: makeTRS,
   makeTranslation: makeTranslation,
@@ -797,6 +789,8 @@ var matrix4 = /*#__PURE__*/Object.freeze({
   position: position,
   scale: scale$4,
   toObject: toObject,
+  toObjectColumnMajor: toObjectColumnMajor,
+  toObjectRowMajor: toObjectRowMajor,
   transpose: transpose
 });
 
@@ -847,9 +841,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));
@@ -1028,55 +1025,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,
         };
     }
 }
@@ -1208,19 +1197,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.
@@ -1418,7 +1407,7 @@ function eulerTo(a, b) {
         return dotAB > 1 - 1e-6 ? create$c() : create$c({ x: Math.PI });
     }
     var normalizedQ = normalize$1(create$b(__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`.
@@ -1470,9 +1459,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 {
@@ -1481,6 +1482,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
  */
@@ -1544,7 +1559,7 @@ 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({
@@ -1573,6 +1588,8 @@ var vector3 = /*#__PURE__*/Object.freeze({
   max: max,
   min: min,
   multiply: multiply,
+  multiplyByTransformMatrixColumnMajor: multiplyByTransformMatrixColumnMajor,
+  multiplyByTransformMatrixRowMajor: multiplyByTransformMatrixRowMajor,
   negate: negate,
   normalize: normalize,
   origin: origin,
@@ -2080,8 +2097,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 };
 }
 /**