@jbroll/jscad-modeling 2.12.7

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

@@ -0,0 +1,29 @@
+const test = require('ava')
+
+const { TAU } = require('../constants')
+
+const { isOnlyTransformScale, create, fromTranslation, fromTaitBryanRotation, fromScaling, invert, multiply } = require('./index')
+
+test('mat4: isOnlyTransformScale() should return true for right angles', (t) => {
+  let someRotation = fromTaitBryanRotation(create(), TAU / 2, 0, 0)
+  t.true(isOnlyTransformScale(someRotation))
+  t.true(isOnlyTransformScale(invert(create(), someRotation)))
+
+  someRotation = fromTaitBryanRotation(create(), 0, 0, 0)
+  t.true(isOnlyTransformScale(someRotation))
+})
+
+test('mat4: isOnlyTransformScale() should return correct values', (t) => {
+  const identity = create() // identity matrix
+  t.true(isOnlyTransformScale(identity))
+
+  const someTranslation = fromTranslation(create(), [5, 5, 5])
+  t.true(isOnlyTransformScale(someTranslation))
+
+  const someScaling = fromScaling(create(), [5, 5, 5])
+  t.true(isOnlyTransformScale(someScaling))
+  t.true(isOnlyTransformScale(invert(create(), someScaling)))
+
+  const combined = multiply(create(), someTranslation, someScaling)
+  t.true(isOnlyTransformScale(combined))
+})

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

@@ -0,0 +1,6 @@
+import Mat4 from './type'
+import Vec2 from '../vec2/type'
+
+export default leftMultiplyVec2
+
+declare function leftMultiplyVec2(vector: Vec2, matrix: Mat4): Vec2

package/src/maths/mat4/leftMultiplyVec2.js

@@ -0,0 +1,28 @@
+const fromValues = require('../vec2/fromValues')
+
+/*
+ * Multiply the input matrix by a Vector2 (interpreted as 2 column, 1 row)
+ * (result = v*M)
+ * Fourth element is set to 1
+ * @param {vec2} vector the input vector
+ * @param {mat4} matrix the input matrix
+ * @returns {vec2} output
+ */
+const leftMultiplyVec2 = (vector, matrix) => {
+  const [v0, v1] = vector
+  const v2 = 0
+  const v3 = 1
+  let x = v0 * matrix[0] + v1 * matrix[4] + v2 * matrix[8] + v3 * matrix[12]
+  let y = v0 * matrix[1] + v1 * matrix[5] + v2 * matrix[9] + v3 * matrix[13]
+  const w = v0 * matrix[3] + v1 * matrix[7] + v2 * matrix[11] + v3 * matrix[15]
+
+  // scale such that fourth element becomes 1:
+  if (w !== 1) {
+    const invw = 1.0 / w
+    x *= invw
+    y *= invw
+  }
+  return fromValues(x, y)
+}
+
+module.exports = leftMultiplyVec2

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

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

package/src/maths/mat4/leftMultiplyVec3.js

@@ -0,0 +1,29 @@
+const fromValues = require('../vec3/fromValues')
+
+/*
+ * Multiply the input matrix by a Vector3 (interpreted as 3 column, 1 row)
+ * (result = v*M)
+ * Fourth element is set to 1
+ * @param {vec3} vector the input vector
+ * @param {mat4} matrix the input matrix
+ * @returns {vec3} output
+ */
+const leftMultiplyVec3 = (vector, matrix) => {
+  const [v0, v1, v2] = vector
+  const v3 = 1
+  let x = v0 * matrix[0] + v1 * matrix[4] + v2 * matrix[8] + v3 * matrix[12]
+  let y = v0 * matrix[1] + v1 * matrix[5] + v2 * matrix[9] + v3 * matrix[13]
+  let z = v0 * matrix[2] + v1 * matrix[6] + v2 * matrix[10] + v3 * matrix[14]
+  const w = v0 * matrix[3] + v1 * matrix[7] + v2 * matrix[11] + v3 * matrix[15]
+
+  // scale such that fourth element becomes 1:
+  if (w !== 1) {
+    const invw = 1.0 / w
+    x *= invw
+    y *= invw
+    z *= invw
+  }
+  return fromValues(x, y, z)
+}
+
+module.exports = leftMultiplyVec3

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

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

package/src/maths/mat4/mirror.js

@@ -0,0 +1,34 @@
+/*
+ * m the mat4 by the dimensions in the given vec3
+ * create an affine matrix for mirroring into an arbitrary plane:
+ *
+ * @param {mat4} out - the receiving matrix
+ * @param {vec3} vector - the vec3 to mirror the matrix by
+ * @param {mat4} matrix - the matrix to mirror
+ * @returns {mat4} out
+ */
+const mirror = (out, vector, matrix) => {
+  const x = vector[0]
+  const y = vector[1]
+  const z = vector[2]
+
+  out[0] = matrix[0] * x
+  out[1] = matrix[1] * x
+  out[2] = matrix[2] * x
+  out[3] = matrix[3] * x
+  out[4] = matrix[4] * y
+  out[5] = matrix[5] * y
+  out[6] = matrix[6] * y
+  out[7] = matrix[7] * y
+  out[8] = matrix[8] * z
+  out[9] = matrix[9] * z
+  out[10] = matrix[10] * z
+  out[11] = matrix[11] * z
+  out[12] = matrix[12]
+  out[13] = matrix[13]
+  out[14] = matrix[14]
+  out[15] = matrix[15]
+  return out
+}
+
+module.exports = mirror

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

@@ -0,0 +1,6 @@
+import Mat4 from './type'
+import Plane from '../plane/type'
+
+export default mirrorByPlane
+
+declare function mirrorByPlane(out: Mat4, plane: Plane): Mat4

package/src/maths/mat4/mirrorByPlane.js

@@ -0,0 +1,32 @@
+/**
+ * Create a matrix for mirroring about the given plane.
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {vec4} plane - plane of which to mirror the matrix
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.mirrorByPlane
+ */
+const mirrorByPlane = (out, plane) => {
+  const [nx, ny, nz, w] = plane
+
+  out[0] = (1.0 - 2.0 * nx * nx)
+  out[1] = (-2.0 * ny * nx)
+  out[2] = (-2.0 * nz * nx)
+  out[3] = 0
+  out[4] = (-2.0 * nx * ny)
+  out[5] = (1.0 - 2.0 * ny * ny)
+  out[6] = (-2.0 * nz * ny)
+  out[7] = 0
+  out[8] = (-2.0 * nx * nz)
+  out[9] = (-2.0 * ny * nz)
+  out[10] = (1.0 - 2.0 * nz * nz)
+  out[11] = 0
+  out[12] = (2.0 * nx * w)
+  out[13] = (2.0 * ny * w)
+  out[14] = (2.0 * nz * w)
+  out[15] = 1
+
+  return out
+}
+
+module.exports = mirrorByPlane

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

@@ -0,0 +1,28 @@
+const test = require('ava')
+
+const plane = require('../plane')
+
+const { mirrorByPlane, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers')
+
+test('mat4: mirrorByPlane() called with out parameter should return a new mat4 with correct values', (t) => {
+  const planeX = plane.fromPoints(plane.create(), [0, 0, 0], [0, 1, 1], [0, 1, 0])
+  const planeY = plane.fromPoints(plane.create(), [0, 0, 0], [1, 0, 0], [1, 0, 1])
+  const planeZ = plane.fromPoints(plane.create(), [0, 0, 0], [1, 0, 0], [1, 1, 0])
+
+  const out1 = create()
+  const ret1 = mirrorByPlane(out1, planeX)
+  t.true(compareVectors(out1, [-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+  t.true(compareVectors(ret1, [-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  const out2 = create()
+  const ret2 = mirrorByPlane(out2, planeY)
+  t.true(compareVectors(out2, [1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+  t.true(compareVectors(ret2, [1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  const out3 = create()
+  const ret3 = mirrorByPlane(out3, planeZ)
+  t.true(compareVectors(out3, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]))
+  t.true(compareVectors(ret3, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1]))
+})

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

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

package/src/maths/mat4/multiply.js

@@ -0,0 +1,67 @@
+/**
+ * Multiplies the two matrices.
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {mat4} a - first operand
+ * @param {mat4} b - second operand
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.multiply
+ */
+const multiply = (out, a, b) => {
+  const a00 = a[0]
+  const a01 = a[1]
+  const a02 = a[2]
+  const a03 = a[3]
+  const a10 = a[4]
+  const a11 = a[5]
+  const a12 = a[6]
+  const a13 = a[7]
+  const a20 = a[8]
+  const a21 = a[9]
+  const a22 = a[10]
+  const a23 = a[11]
+  const a30 = a[12]
+  const a31 = a[13]
+  const a32 = a[14]
+  const a33 = a[15]
+
+  // Cache only the current line of the second matrix
+  let b0 = b[0]
+  let b1 = b[1]
+  let b2 = b[2]
+  let b3 = b[3]
+  out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30
+  out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31
+  out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32
+  out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33
+
+  b0 = b[4]
+  b1 = b[5]
+  b2 = b[6]
+  b3 = b[7]
+  out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30
+  out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31
+  out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32
+  out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33
+
+  b0 = b[8]
+  b1 = b[9]
+  b2 = b[10]
+  b3 = b[11]
+  out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30
+  out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31
+  out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32
+  out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33
+
+  b0 = b[12]
+  b1 = b[13]
+  b2 = b[14]
+  b3 = b[15]
+  out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30
+  out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31
+  out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32
+  out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33
+  return out
+}
+
+module.exports = multiply

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

@@ -0,0 +1,28 @@
+const test = require('ava')
+const { multiply } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: multiply() called with out parameter should return a new mat4 with correct values', (t) => {
+  const obs1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  const ret1 = multiply(obs1,
+    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])
+  t.true(compareVectors(obs1, [90, 100, 110, 120, 202, 228, 254, 280, 314, 356, 398, 440, 426, 484, 542, 600]))
+  t.true(compareVectors(ret1, [90, 100, 110, 120, 202, 228, 254, 280, 314, 356, 398, 440, 426, 484, 542, 600]))
+  t.is(obs1, ret1)
+
+  const obs2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  const ret2 = multiply(obs2,
+    [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16],
+    [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16])
+  t.true(compareVectors(obs2, [90, 100, 110, 120, 202, 228, 254, 280, 314, 356, 398, 440, 426, 484, 542, 600]))
+  t.true(compareVectors(ret2, [90, 100, 110, 120, 202, 228, 254, 280, 314, 356, 398, 440, 426, 484, 542, 600]))
+
+  const obs3 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  const ret3 = multiply(obs3,
+    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+    [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16])
+  t.true(compareVectors(obs3, [-90, -100, -110, -120, -202, -228, -254, -280, -314, -356, -398, -440, -426, -484, -542, -600]))
+  t.true(compareVectors(ret3, [-90, -100, -110, -120, -202, -228, -254, -280, -314, -356, -398, -440, -426, -484, -542, -600]))
+})

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

@@ -0,0 +1,6 @@
+import Mat4 from './type'
+import Vec2 from '../vec2/type'
+
+export default rightMultiplyVec2
+
+declare function rightMultiplyVec2(vector: Vec2, matrix: Mat4): Vec2

package/src/maths/mat4/rightMultiplyVec2.js

@@ -0,0 +1,29 @@
+const fromValues = require('../vec2/fromValues')
+
+/**
+ * Multiply a 2D vector by a matrix (interpreted as 2 row, 1 column).
+ *
+ * Calculation: result = v*M, where the fourth element is set to 1.
+ * @param {vec2} vector - input vector
+ * @param {mat4} matrix - input matrix
+ * @returns {vec2} a new vector
+ * @alias module:modeling/maths/mat4.rightMultiplyVec2
+ */
+const rightMultiplyVec2 = (vector, matrix) => {
+  const [v0, v1] = vector
+  const v2 = 0
+  const v3 = 1
+  let x = v0 * matrix[0] + v1 * matrix[1] + v2 * matrix[2] + v3 * matrix[3]
+  let y = v0 * matrix[4] + v1 * matrix[5] + v2 * matrix[6] + v3 * matrix[7]
+  const w = v0 * matrix[12] + v1 * matrix[13] + v2 * matrix[14] + v3 * matrix[15]
+
+  // scale such that fourth element becomes 1:
+  if (w !== 1) {
+    const invw = 1.0 / w
+    x *= invw
+    y *= invw
+  }
+  return fromValues(x, y)
+}
+
+module.exports = rightMultiplyVec2

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

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

package/src/maths/mat4/rightMultiplyVec3.js

@@ -0,0 +1,30 @@
+const fromValues = require('../vec3/fromValues')
+
+/**
+ * Multiply a 3D vector by a matrix (interpreted as 3 row, 1 column)
+ *
+ * Calculation: result = v*M, where the fourth element is set to 1.
+ * @param {vec3} vector - input vector
+ * @param {mat4} matrix - input matrix
+ * @returns {vec3} a new vector
+ * @alias module:modeling/maths/mat4.rightMultiplyVec3
+ */
+const rightMultiplyVec3 = (vector, matrix) => {
+  const [v0, v1, v2] = vector
+  const v3 = 1
+  let x = v0 * matrix[0] + v1 * matrix[1] + v2 * matrix[2] + v3 * matrix[3]
+  let y = v0 * matrix[4] + v1 * matrix[5] + v2 * matrix[6] + v3 * matrix[7]
+  let z = v0 * matrix[8] + v1 * matrix[9] + v2 * matrix[10] + v3 * matrix[11]
+  const w = v0 * matrix[12] + v1 * matrix[13] + v2 * matrix[14] + v3 * matrix[15]
+
+  // scale such that fourth element becomes 1:
+  if (w !== 1) {
+    const invw = 1.0 / w
+    x *= invw
+    y *= invw
+    z *= invw
+  }
+  return fromValues(x, y, z)
+}
+
+module.exports = rightMultiplyVec3

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

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

package/src/maths/mat4/rotate.js

@@ -0,0 +1,82 @@
+const { EPS } = require('../constants')
+
+const { sin, cos } = require('../utils/trigonometry')
+
+const copy = require('./copy')
+
+/**
+ * Rotates a matrix by the given angle about the given axis.
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {mat4} matrix - matrix to rotate
+ * @param {Number} radians - angle to rotate the matrix by
+ * @param {vec3} axis - axis to rotate around
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.rotate
+ */
+const rotate = (out, matrix, radians, 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 copy(out, matrix)
+  }
+
+  const len = 1 / Math.sqrt(lengthSquared)
+  x *= len
+  y *= len
+  z *= len
+
+  const s = sin(radians)
+  const c = cos(radians)
+  const t = 1 - c
+
+  const a00 = matrix[0]
+  const a01 = matrix[1]
+  const a02 = matrix[2]
+  const a03 = matrix[3]
+  const a10 = matrix[4]
+  const a11 = matrix[5]
+  const a12 = matrix[6]
+  const a13 = matrix[7]
+  const a20 = matrix[8]
+  const a21 = matrix[9]
+  const a22 = matrix[10]
+  const a23 = matrix[11]
+
+  // Construct the elements of the rotation matrix
+  const b00 = x * x * t + c
+  const b01 = y * x * t + z * s
+  const b02 = z * x * t - y * s
+  const b10 = x * y * t - z * s
+  const b11 = y * y * t + c
+  const b12 = z * y * t + x * s
+  const b20 = x * z * t + y * s
+  const b21 = y * z * t - x * s
+  const b22 = z * z * t + c
+
+  // Perform rotation-specific matrix multiplication
+  out[0] = a00 * b00 + a10 * b01 + a20 * b02
+  out[1] = a01 * b00 + a11 * b01 + a21 * b02
+  out[2] = a02 * b00 + a12 * b01 + a22 * b02
+  out[3] = a03 * b00 + a13 * b01 + a23 * b02
+  out[4] = a00 * b10 + a10 * b11 + a20 * b12
+  out[5] = a01 * b10 + a11 * b11 + a21 * b12
+  out[6] = a02 * b10 + a12 * b11 + a22 * b12
+  out[7] = a03 * b10 + a13 * b11 + a23 * b12
+  out[8] = a00 * b20 + a10 * b21 + a20 * b22
+  out[9] = a01 * b20 + a11 * b21 + a21 * b22
+  out[10] = a02 * b20 + a12 * b21 + a22 * b22
+  out[11] = a03 * b20 + a13 * b21 + a23 * b22
+
+  if (matrix !== out) { // If the source and destination differ, copy the unchanged last row
+    out[12] = matrix[12]
+    out[13] = matrix[13]
+    out[14] = matrix[14]
+    out[15] = matrix[15]
+  }
+  return out
+}
+
+module.exports = rotate

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

@@ -0,0 +1,27 @@
+const test = require('ava')
+const { rotate, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: rotate() called with out parameter should return a new mat4 with correct values', (t) => {
+  const rotation = 90 * 0.017453292519943295
+
+  const idn = create()
+
+  // invalid condition when axis is 0,0,0
+  const out1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  const ret1 = rotate(out1, idn, rotation, [0, 0, 0])
+  t.is(out1, ret1)
+  t.true(compareVectors(out1, [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+
+  const out2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  const ret2 = rotate(out2, idn, rotation, [0, 0, 1])
+  t.true(compareVectors(out2, [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+  t.true(compareVectors(ret2, [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+  t.is(out2, ret2)
+
+  const out3 = create()
+  const ret3 = rotate(out3, out3, -rotation, [0, 0, 1])
+  t.true(compareVectors(out3, [0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+  t.true(compareVectors(ret3, [0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]))
+})

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

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default rotateX
+
+declare function rotateX(out: Mat4, matrix: Mat4, radians: number): Mat4

package/src/maths/mat4/rotateX.js

@@ -0,0 +1,47 @@
+const { sin, cos } = require('../utils/trigonometry')
+
+/**
+ * Rotates a matrix by the given angle around the X axis.
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {mat4} matrix - matrix to rotate
+ * @param {Number} radians - angle to rotate the matrix by
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.rotateX
+ */
+const rotateX = (out, matrix, radians) => {
+  const s = sin(radians)
+  const c = cos(radians)
+  const a10 = matrix[4]
+  const a11 = matrix[5]
+  const a12 = matrix[6]
+  const a13 = matrix[7]
+  const a20 = matrix[8]
+  const a21 = matrix[9]
+  const a22 = matrix[10]
+  const a23 = matrix[11]
+
+  if (matrix !== out) { // If the source and destination differ, copy the unchanged rows
+    out[0] = matrix[0]
+    out[1] = matrix[1]
+    out[2] = matrix[2]
+    out[3] = matrix[3]
+    out[12] = matrix[12]
+    out[13] = matrix[13]
+    out[14] = matrix[14]
+    out[15] = matrix[15]
+  }
+
+  // Perform axis-specific matrix multiplication
+  out[4] = a10 * c + a20 * s
+  out[5] = a11 * c + a21 * s
+  out[6] = a12 * c + a22 * s
+  out[7] = a13 * c + a23 * s
+  out[8] = a20 * c - a10 * s
+  out[9] = a21 * c - a11 * s
+  out[10] = a22 * c - a12 * s
+  out[11] = a23 * c - a13 * s
+  return out
+}
+
+module.exports = rotateX

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

@@ -0,0 +1,21 @@
+const test = require('ava')
+const { rotateX, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: rotateX() called with out parameter should return a new mat4 with correct values', (t) => {
+  const rotation = 90 * 0.017453292519943295
+
+  const idn = create()
+
+  const out2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  const ret2 = rotateX(out2, idn, rotation)
+  t.true(compareVectors(out2, [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]))
+  t.true(compareVectors(ret2, [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1]))
+  t.is(out2, ret2)
+
+  const out3 = create()
+  const ret3 = rotateX(out3, out3, -rotation)
+  t.true(compareVectors(out3, [1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]))
+  t.true(compareVectors(ret3, [1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]))
+})

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

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default rotateY
+
+declare function rotateY(out: Mat4, matrix: Mat4, radians: number): Mat4

package/src/maths/mat4/rotateY.js

@@ -0,0 +1,47 @@
+const { sin, cos } = require('../utils/trigonometry')
+
+/**
+ * Rotates a matrix by the given angle around the Y axis.
+ *
+ * @param {mat4} out - receiving matrix
+ * @param {mat4} matrix - matrix to rotate
+ * @param {Number} radians - angle to rotate the matrix by
+ * @returns {mat4} out
+ * @alias module:modeling/maths/mat4.rotateY
+ */
+const rotateY = (out, matrix, radians) => {
+  const s = sin(radians)
+  const c = cos(radians)
+  const a00 = matrix[0]
+  const a01 = matrix[1]
+  const a02 = matrix[2]
+  const a03 = matrix[3]
+  const a20 = matrix[8]
+  const a21 = matrix[9]
+  const a22 = matrix[10]
+  const a23 = matrix[11]
+
+  if (matrix !== out) { // If the source and destination differ, copy the unchanged rows
+    out[4] = matrix[4]
+    out[5] = matrix[5]
+    out[6] = matrix[6]
+    out[7] = matrix[7]
+    out[12] = matrix[12]
+    out[13] = matrix[13]
+    out[14] = matrix[14]
+    out[15] = matrix[15]
+  }
+
+  // Perform axis-specific matrix multiplication
+  out[0] = a00 * c - a20 * s
+  out[1] = a01 * c - a21 * s
+  out[2] = a02 * c - a22 * s
+  out[3] = a03 * c - a23 * s
+  out[8] = a00 * s + a20 * c
+  out[9] = a01 * s + a21 * c
+  out[10] = a02 * s + a22 * c
+  out[11] = a03 * s + a23 * c
+  return out
+}
+
+module.exports = rotateY

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

@@ -0,0 +1,21 @@
+const test = require('ava')
+const { rotateY, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('mat4: rotateY() called with out parameter should return a new mat4 with correct values', (t) => {
+  const rotation = 90 * 0.017453292519943295
+
+  const idn = create()
+
+  const out2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+  const ret2 = rotateY(out2, idn, rotation)
+  t.true(compareVectors(out2, [0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]))
+  t.true(compareVectors(ret2, [0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]))
+  t.is(out2, ret2)
+
+  const out3 = create()
+  const ret3 = rotateY(out3, out3, -rotation)
+  t.true(compareVectors(out3, [0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1]))
+  t.true(compareVectors(ret3, [0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 1]))
+})

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

@@ -0,0 +1,5 @@
+import Mat4 from './type'
+
+export default rotateZ
+
+declare function rotateZ(out: Mat4, matrix: Mat4, radians: number): Mat4