@jbroll/jscad-modeling 2.12.7

package/src/maths/mat4/copy.js

@@ -0,0 +1,29 @@
+/**
+ * Creates a copy of the given matrix.
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {mat4} matrix - matrix to copy
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.copy
+ */
+const copy = (out, matrix) => {
+  out[0] = matrix[0]
+  out[1] = matrix[1]
+  out[2] = matrix[2]
+  out[3] = matrix[3]
+  out[4] = matrix[4]
+  out[5] = matrix[5]
+  out[6] = matrix[6]
+  out[7] = matrix[7]
+  out[8] = matrix[8]
+  out[9] = matrix[9]
+  out[10] = matrix[10]
+  out[11] = matrix[11]
+  out[12] = matrix[12]
+  out[13] = matrix[13]
+  out[14] = matrix[14]
+  out[15] = matrix[15]
+  return out
+}
+
+module.exports = copy

package/src/maths/mat4/copy.test.js

@@ -0,0 +1,30 @@
+const test = require('ava')
+const { create, copy, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: copy() with two params should update a mat4 with same values', (t) => {
+  const org1 = create()
+  const mat1 = fromValues(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+  const ret1 = copy(org1, mat1)
+  t.true(compareVectors(org1, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+  t.true(compareVectors(ret1, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))
+  t.is(ret1, org1)
+  t.not(mat1, org1)
+
+  const org2 = create()
+  const mat2 = fromValues(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
+  const ret2 = copy(org2, mat2)
+  t.true(compareVectors(org2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]))
+  t.true(compareVectors(ret2, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]))
+  t.is(ret2, org2)
+  t.not(mat2, org2)
+
+  const org3 = create()
+  const mat3 = fromValues(-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16)
+  const ret3 = copy(org3, mat3)
+  t.true(compareVectors(org3, [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16]))
+  t.true(compareVectors(ret3, [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16]))
+  t.is(ret3, org3)
+  t.not(mat3, org3)
+})

package/src/maths/mat4/create.d.ts

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default create
+
+declare function create(): Mat4

package/src/maths/mat4/create.js

@@ -0,0 +1,20 @@
+/**
+ * Represents a 4x4 matrix which is column-major (when typed out it looks row-major).
+ * See fromValues().
+ * @typedef {Array} mat4
+ */
+
+/**
+ * Creates a new identity matrix.
+ *
+ * @returns {mat4} a new matrix
+ * @alias module:modeling/maths/mat4.create
+ */
+const create = () => [
+  1, 0, 0, 0,
+  0, 1, 0, 0,
+  0, 0, 1, 0,
+  0, 0, 0, 1
+]
+
+module.exports = create

package/src/maths/mat4/create.test.js

@@ -0,0 +1,10 @@
+const test = require('ava')
+
+const { create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: create() should return a mat4 with initial values', (t) => {
+  const obs = create() // identity matrix
+  t.true(compareVectors(obs, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+})

package/src/maths/mat4/equals.d.ts

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default equals
+
+declare function equals(a: Mat4, b: Mat4): boolean

package/src/maths/mat4/equals.js

@@ -0,0 +1,16 @@
+/**
+ * Returns whether or not the matrices have exactly the same elements in the same position.
+ *
+ * @param {mat4} a - first matrix
+ * @param {mat4} b - second matrix
+ * @returns {Boolean} true if the matrices are equal
+ * @alias module:modeling/maths/mat4.equals
+ */
+const equals = (a, b) => (
+  a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] &&
+  a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] &&
+  a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] &&
+  a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15]
+)
+
+module.exports = equals

package/src/maths/mat4/equals.test.js

@@ -0,0 +1,56 @@
+const test = require('ava')
+const equals = require('./equals')
+
+test('vec3: equals() should return correct booleans', (t) => {
+  const veca = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  const vecb = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  t.true(equals(veca, vecb))
+
+  const vecb0 = [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  t.false(equals(veca, vecb0))
+
+  const vecb1 = [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  t.false(equals(veca, vecb1))
+
+  const vecb2 = [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  t.false(equals(veca, vecb2))
+
+  const vecb3 = [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  t.false(equals(veca, vecb3))
+
+  const vecb4 = [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  t.false(equals(veca, vecb4))
+
+  const vecb5 = [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  t.false(equals(veca, vecb5))
+
+  const vecb6 = [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  t.false(equals(veca, vecb6))
+
+  const vecb7 = [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
+  t.false(equals(veca, vecb7))
+
+  const vecb8 = [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
+  t.false(equals(veca, vecb8))
+
+  const vecb9 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
+  t.false(equals(veca, vecb9))
+
+  const vecb10 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
+  t.false(equals(veca, vecb10))
+
+  const vecb11 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
+  t.false(equals(veca, vecb11))
+
+  const vecb12 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
+  t.false(equals(veca, vecb12))
+
+  const vecb13 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]
+  t.false(equals(veca, vecb13))
+
+  const vecb14 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
+  t.false(equals(veca, vecb14))
+
+  const vecb15 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
+  t.false(equals(veca, vecb15))
+})

package/src/maths/mat4/fromRotation.d.ts

@@ -0,0 +1,6 @@
+import Mat4 from './type'
+import Vec3 from '../vec3/type'
+
+export default fromRotation
+
+declare function fromRotation(out: Mat4, rad: number, axis: Vec3): Mat4

package/src/maths/mat4/fromRotation.js

@@ -0,0 +1,60 @@
+const { EPS } = require('../constants')
+
+const { sin, cos } = require('../utils/trigonometry')
+
+const identity = require('./identity')
+
+/**
+ * Creates a matrix from a given angle around a given axis
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest)
+ *     mat4.rotate(dest, dest, rad, axis)
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {Number} rad - angle to rotate the matrix by
+ * @param {vec3} axis - axis of which to rotate around
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.fromRotation
+ * @example
+ * let matrix = fromRotation(create(), TAU / 4, [0, 0, 3])
+ */
+const fromRotation = (out, rad, axis) => {
+  let [x, y, z] = axis
+  const lengthSquared = x * x + y * y + z * z
+
+  if (Math.abs(lengthSquared) < EPS) {
+    // axis is 0,0,0 or almost
+    return identity(out)
+  }
+
+  const len = 1 / Math.sqrt(lengthSquared)
+  x *= len
+  y *= len
+  z *= len
+
+  const s = sin(rad)
+  const c = cos(rad)
+  const t = 1 - c
+
+  // Perform rotation-specific matrix multiplication
+  out[0] = x * x * t + c
+  out[1] = y * x * t + z * s
+  out[2] = z * x * t - y * s
+  out[3] = 0
+  out[4] = x * y * t - z * s
+  out[5] = y * y * t + c
+  out[6] = z * y * t + x * s
+  out[7] = 0
+  out[8] = x * z * t + y * s
+  out[9] = y * z * t - x * s
+  out[10] = z * z * t + c
+  out[11] = 0
+  out[12] = 0
+  out[13] = 0
+  out[14] = 0
+  out[15] = 1
+  return out
+}
+
+module.exports = fromRotation

package/src/maths/mat4/fromRotation.test.js

@@ -0,0 +1,18 @@
+const test = require('ava')
+const { fromRotation, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: fromRotation() should return a mat4 with correct values', (t) => {
+  const rotation = 90 * 0.017453292519943295
+
+  // invalid condition when axis is 0,0,0
+  const obs1 = fromRotation(create(), rotation, [0, 0, 0])
+  t.true(compareVectors(obs1, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  const obs2 = fromRotation(create(), rotation, [0, 0, 1])
+  t.true(compareVectors(obs2, [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  const obs3 = fromRotation(obs2, -rotation, [0, 0, 1])
+  t.true(compareVectors(obs3, [0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+})

package/src/maths/mat4/fromScaling.d.ts

@@ -0,0 +1,6 @@
+import Mat4 from './type'
+import Vec3 from '../vec3/type'
+
+export default fromScaling
+
+declare function fromScaling(out: Mat4, vector: Vec3): Mat4

package/src/maths/mat4/fromScaling.js

@@ -0,0 +1,35 @@
+/**
+ * Creates a matrix from a vector scaling.
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest)
+ *     mat4.scale(dest, dest, vec)
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {vec3} vector - X, Y, Z factors by which to scale
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.fromScaling
+ * @example
+ * let matrix = fromScaling([1, 2, 0.5])
+ */
+const fromScaling = (out, vector) => {
+  out[0] = vector[0]
+  out[1] = 0
+  out[2] = 0
+  out[3] = 0
+  out[4] = 0
+  out[5] = vector[1]
+  out[6] = 0
+  out[7] = 0
+  out[8] = 0
+  out[9] = 0
+  out[10] = vector[2]
+  out[11] = 0
+  out[12] = 0
+  out[13] = 0
+  out[14] = 0
+  out[15] = 1
+  return out
+}
+
+module.exports = fromScaling

package/src/maths/mat4/fromScaling.test.js

@@ -0,0 +1,12 @@
+const test = require('ava')
+const { fromScaling, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: fromScaling() should return a new mat4 with correct values', (t) => {
+  const obs1 = fromScaling(create(), [2, 4, 6])
+  t.true(compareVectors(obs1, [2, 0, 0, 0, 0, 4, 0, 0, 0, 0, 6, 0, 0, 0, 0, 1]))
+
+  const obs2 = fromScaling(obs1, [-2, -4, -6])
+  t.true(compareVectors(obs2, [-2, 0, 0, 0, 0, -4, 0, 0, 0, 0, -6, 0, 0, 0, 0, 1]))
+})

package/src/maths/mat4/fromTaitBryanRotation.d.ts

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default fromTaitBryanRotation
+
+declare function fromTaitBryanRotation(out: Mat4, yaw: number, pitch: number, roll: number): Mat4

package/src/maths/mat4/fromTaitBryanRotation.js

@@ -0,0 +1,55 @@
+const { sin, cos } = require('../utils/trigonometry')
+
+/**
+ * Creates a matrix from the given Tait–Bryan angles.
+ *
+ * Tait-Bryan Euler angle convention using active, intrinsic rotations around the axes in the order z-y-x.
+ * @see https://en.wikipedia.org/wiki/Euler_angles
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {Number} yaw - Z rotation in radians
+ * @param {Number} pitch - Y rotation in radians
+ * @param {Number} roll - X rotation in radians
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.fromTaitBryanRotation
+ * @example
+ * let matrix = fromTaitBryanRotation(create(), TAU / 4, 0, TAU / 2)
+ */
+const fromTaitBryanRotation = (out, yaw, pitch, roll) => {
+  // precompute sines and cosines of Euler angles
+  const sy = sin(yaw)
+  const cy = cos(yaw)
+  const sp = sin(pitch)
+  const cp = cos(pitch)
+  const sr = sin(roll)
+  const cr = cos(roll)
+
+  // create and populate rotation matrix
+  // left-hand-rule rotation
+  // const els = [
+  //  cp*cy, sr*sp*cy - cr*sy, sr*sy + cr*sp*cy, 0,
+  //  cp*sy, cr*cy + sr*sp*sy, cr*sp*sy - sr*cy, 0,
+  //  -sp, sr*cp, cr*cp, 0,
+  //  0, 0, 0, 1
+  // ]
+  // right-hand-rule rotation
+  out[0] = cp * cy
+  out[1] = cp * sy
+  out[2] = -sp
+  out[3] = 0
+  out[4] = sr * sp * cy - cr * sy
+  out[5] = cr * cy + sr * sp * sy
+  out[6] = sr * cp
+  out[7] = 0
+  out[8] = sr * sy + cr * sp * cy
+  out[9] = cr * sp * sy - sr * cy
+  out[10] = cr * cp
+  out[11] = 0
+  out[12] = 0
+  out[13] = 0
+  out[14] = 0
+  out[15] = 1
+  return out
+}
+
+module.exports = fromTaitBryanRotation

package/src/maths/mat4/fromTaitBryanRotation.test.js

@@ -0,0 +1,24 @@
+const test = require('ava')
+
+const { fromTaitBryanRotation, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: fromTaitBryanRotation() should return a new mat4 with correct values', (t) => {
+  const rotation = 90 * 0.017453292519943295
+
+  // rotation using YAW / Z
+  const obs1 = fromTaitBryanRotation(create(), rotation, 0, 0)
+  t.true(compareVectors(obs1, [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  // rotation using PITCH / Y
+  const obs2 = fromTaitBryanRotation(create(), 0, rotation, 0)
+  t.true(compareVectors(obs2, [0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]))
+
+  // rotation using ROLL / X
+  const obs3 = fromTaitBryanRotation(create(), 0, 0, rotation)
+  t.true(compareVectors(obs3, [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]))
+
+  const obs4 = fromTaitBryanRotation(obs3, -rotation, -rotation, -rotation)
+  t.true(compareVectors(obs4, [0, 0, 1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]))
+})

package/src/maths/mat4/fromTranslation.d.ts

@@ -0,0 +1,6 @@
+import Mat4 from './type'
+import Vec3 from '../vec3/type'
+
+export default fromTranslation
+
+declare function fromTranslation(out: Mat4, vector: Vec3): Mat4

package/src/maths/mat4/fromTranslation.js

@@ -0,0 +1,35 @@
+/**
+ * Creates a matrix from a vector translation.
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest)
+ *     mat4.translate(dest, dest, vec)
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {vec3} vector - offset (vector) of translation
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.fromTranslation
+ * @example
+ * let matrix = fromTranslation(create(), [1, 2, 3])
+ */
+const fromTranslation = (out, vector) => {
+  out[0] = 1
+  out[1] = 0
+  out[2] = 0
+  out[3] = 0
+  out[4] = 0
+  out[5] = 1
+  out[6] = 0
+  out[7] = 0
+  out[8] = 0
+  out[9] = 0
+  out[10] = 1
+  out[11] = 0
+  out[12] = vector[0]
+  out[13] = vector[1]
+  out[14] = vector[2]
+  out[15] = 1
+  return out
+}
+
+module.exports = fromTranslation

package/src/maths/mat4/fromTranslation.test.js

@@ -0,0 +1,12 @@
+const test = require('ava')
+const { fromTranslation, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: fromTranslation() should return a new mat4 with correct values', (t) => {
+  const obs1 = fromTranslation(create(), [2, 4, 6])
+  t.true(compareVectors(obs1, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 2, 4, 6, 1]))
+
+  const obs2 = fromTranslation(obs1, [-2, -4, -6])
+  t.true(compareVectors(obs2, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, -2, -4, -6, 1]))
+})

package/src/maths/mat4/fromValues.d.ts

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default fromValues
+
+declare function fromValues(m00: number, m01: number, m02: number, m03: number, m10: number, m11: number, m12: number, m13: number, m20: number, m21: number, m22: number, m23: number, m30: number, m31: number, m32: number, m33: number): Mat4

package/src/maths/mat4/fromValues.js

@@ -0,0 +1,53 @@
+const create = require('./create')
+
+/**
+ * Create a matrix with the given values.
+ *
+ * @param {Number} m00 Component in column 0, row 0 position (index 0)
+ * @param {Number} m01 Component in column 0, row 1 position (index 1)
+ * @param {Number} m02 Component in column 0, row 2 position (index 2)
+ * @param {Number} m03 Component in column 0, row 3 position (index 3)
+ * @param {Number} m10 Component in column 1, row 0 position (index 4)
+ * @param {Number} m11 Component in column 1, row 1 position (index 5)
+ * @param {Number} m12 Component in column 1, row 2 position (index 6)
+ * @param {Number} m13 Component in column 1, row 3 position (index 7)
+ * @param {Number} m20 Component in column 2, row 0 position (index 8)
+ * @param {Number} m21 Component in column 2, row 1 position (index 9)
+ * @param {Number} m22 Component in column 2, row 2 position (index 10)
+ * @param {Number} m23 Component in column 2, row 3 position (index 11)
+ * @param {Number} m30 Component in column 3, row 0 position (index 12)
+ * @param {Number} m31 Component in column 3, row 1 position (index 13)
+ * @param {Number} m32 Component in column 3, row 2 position (index 14)
+ * @param {Number} m33 Component in column 3, row 3 position (index 15)
+ * @returns {mat4} a new matrix
+ * @alias module:modeling/maths/mat4.fromValues
+ * @example
+ * let matrix = fromValues(
+ *   1, 0, 0, 1,
+ *   0, 1, 0, 0,
+ *   0, 0, 1, 0,
+ *   0, 0, 0, 1
+ * )
+ */
+const fromValues = (m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) => {
+  const out = create()
+  out[0] = m00
+  out[1] = m01
+  out[2] = m02
+  out[3] = m03
+  out[4] = m10
+  out[5] = m11
+  out[6] = m12
+  out[7] = m13
+  out[8] = m20
+  out[9] = m21
+  out[10] = m22
+  out[11] = m23
+  out[12] = m30
+  out[13] = m31
+  out[14] = m32
+  out[15] = m33
+  return out
+}
+
+module.exports = fromValues

package/src/maths/mat4/fromValues.test.js

@@ -0,0 +1,12 @@
+const test = require('ava')
+const { fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: fromValues() should return a new mat4 with correct values', (t) => {
+  const obs1 = fromValues(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+  t.true(compareVectors(obs1, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]))
+
+  const obs2 = fromValues(0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15)
+  t.true(compareVectors(obs2, [0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15]))
+})

package/src/maths/mat4/fromVectorRotation.d.ts

@@ -0,0 +1,6 @@
+import Mat4 from './type'
+import Vec3 from '../vec3/type'
+
+export default fromVectorRotation
+
+declare function fromVectorRotation(out: Mat4, source: Vec3, target: Vec3): Mat4

package/src/maths/mat4/fromVectorRotation.js

@@ -0,0 +1,49 @@
+const vec3 = require('../vec3')
+
+const fromRotation = require('./fromRotation')
+
+/**
+ * Create a matrix that rotates the given source to the given target vector.
+ *
+ * Each vector must be a directional vector with a length greater than zero.
+ * @see https://gist.github.com/kevinmoran/b45980723e53edeb8a5a43c49f134724
+ * @param {mat4} out - receiving matrix
+ * @param {vec3} source - source vector
+ * @param {vec3} target - target vector
+ * @returns {mat4} a new matrix
+ * @alias module:modeling/maths/mat4.fromVectorRotation
+ * @example
+ * let matrix = fromVectorRotation(mat4.create(), [1, 2, 2], [-3, 3, 12])
+ */
+const fromVectorRotation = (out, source, target) => {
+  const sourceNormal = vec3.normalize(vec3.create(), source)
+  const targetNormal = vec3.normalize(vec3.create(), target)
+
+  const axis = vec3.cross(vec3.create(), targetNormal, sourceNormal)
+  const cosA = vec3.dot(targetNormal, sourceNormal)
+  if (cosA === -1.0) return fromRotation(out, Math.PI, vec3.orthogonal(axis, sourceNormal))
+
+  const k = 1 / (1 + cosA)
+  out[0] = (axis[0] * axis[0] * k) + cosA
+  out[1] = (axis[1] * axis[0] * k) - axis[2]
+  out[2] = (axis[2] * axis[0] * k) + axis[1]
+  out[3] = 0
+
+  out[4] = (axis[0] * axis[1] * k) + axis[2]
+  out[5] = (axis[1] * axis[1] * k) + cosA
+  out[6] = (axis[2] * axis[1] * k) - axis[0]
+  out[7] = 0
+
+  out[8] = (axis[0] * axis[2] * k) - axis[1]
+  out[9] = (axis[1] * axis[2] * k) + axis[0]
+  out[10] = (axis[2] * axis[2] * k) + cosA
+  out[11] = 0
+
+  out[12] = 0
+  out[13] = 0
+  out[14] = 0
+  out[15] = 1
+  return out
+}
+
+module.exports = fromVectorRotation