@jbroll/jscad-modeling 2.12.7

package/src/maths/plane/fromNormalAndPoint.js

@@ -0,0 +1,32 @@
+const vec3 = require('../vec3')
+
+/**
+ * Represents a plane in 3D coordinate space as determined by a normal (perpendicular to the plane)
+ * and distance from 0,0,0.
+ *
+ * The contents of the array are a normal [0,1,2] and a distance [3].
+ * @see https://en.wikipedia.org/wiki/Hesse_normal_form
+ * @typedef {Array} plane
+ */
+
+/**
+ * Create a new plane from the given normal and point values.
+ *
+ * @param {plane} out - receiving plane
+ * @param {vec3} normal - directional vector
+ * @param {vec3} point - origin of plane
+ * @returns {plane} out
+ * @alias module:modeling/maths/plane.fromNormalAndPoint
+ */
+const fromNormalAndPoint = (out, normal, point) => {
+  const u = vec3.normalize(vec3.create(), normal)
+  const w = vec3.dot(point, u)
+
+  out[0] = u[0]
+  out[1] = u[1]
+  out[2] = u[2]
+  out[3] = w
+  return out
+}
+
+module.exports = fromNormalAndPoint

package/src/maths/plane/fromNormalAndPoint.test.js

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

package/src/maths/plane/fromPoints.d.ts

@@ -0,0 +1,6 @@
+import Plane from './type'
+import Vec3 from '../vec3/type'
+
+export default fromPoints
+
+declare function fromPoints(out: Plane, ...vertices: Array<Vec3>): Plane

package/src/maths/plane/fromPoints.js

@@ -0,0 +1,47 @@
+const vec3 = require('../vec3')
+
+/**
+ * Create a plane from the given points.
+ *
+ * @param {plane} out - receiving plane
+ * @param {Array} vertices - points on the plane
+ * @returns {plane} out
+ * @alias module:modeling/maths/plane.fromPoints
+ */
+const fromPoints = (out, ...vertices) => {
+  const len = vertices.length
+
+  // Calculate normal vector for a single vertex
+  // Inline to avoid allocations
+  const ba = vec3.create()
+  const ca = vec3.create()
+  const vertexNormal = (index) => {
+    const a = vertices[index]
+    const b = vertices[(index + 1) % len]
+    const c = vertices[(index + 2) % len]
+    vec3.subtract(ba, b, a) // ba = b - a
+    vec3.subtract(ca, c, a) // ca = c - a
+    vec3.cross(ba, ba, ca) // ba = ba x ca
+    vec3.normalize(ba, ba)
+    return ba
+  }
+
+  out[0] = 0
+  out[1] = 0
+  out[2] = 0
+  if (len === 3) {
+    // optimization for triangles, which are always coplanar
+    vec3.copy(out, vertexNormal(0))
+  } else {
+    // sum of vertex normals
+    vertices.forEach((v, i) => {
+      vec3.add(out, out, vertexNormal(i))
+    })
+    // renormalize normal vector
+    vec3.normalize(out, out)
+  }
+  out[3] = vec3.dot(out, vertices[0])
+  return out
+}
+
+module.exports = fromPoints

package/src/maths/plane/fromPoints.test.js

@@ -0,0 +1,20 @@
+const test = require('ava')
+const { fromPoints, create } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('plane: fromPoints() should return a new plane with correct values', (t) => {
+  const obs1 = fromPoints(create(), [0, 0, 0], [1, 0, 0], [1, 1, 0])
+  t.true(compareVectors(obs1, [0, 0, 1, 0]))
+
+  const obs2 = fromPoints(obs1, [0, 6, 0], [0, 2, 2], [0, 6, 6])
+  t.true(compareVectors(obs2, [-1, 0, 0, 0]))
+
+  // planes created from the same points results in an invalid plane
+  const obs3 = fromPoints(obs1, [0, 6, 0], [0, 6, 0], [0, 6, 0])
+  t.true(compareVectors(obs3, [0 / 0, 0 / 0, 0 / 0, 0 / 0]))
+
+  // polygon with co-linear vertices
+  const obs4 = fromPoints(obs1, [0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0])
+  t.true(compareVectors(obs4, [0, 0, 1, 0]))
+})

package/src/maths/plane/fromPointsRandom.d.ts

@@ -0,0 +1,6 @@
+import Plane from './type'
+import Vec3 from '../vec3/type'
+
+export default fromPointsRandom
+
+declare function fromPointsRandom(out: Plane, a: Vec3, b: Vec3, c: Vec3): Plane

package/src/maths/plane/fromPointsRandom.js

@@ -0,0 +1,42 @@
+const { EPS } = require('../constants')
+
+const vec3 = require('../vec3')
+
+/**
+ * Create a new plane from the given points like fromPoints,
+ * but allow the vectors to be on one point or one line.
+ * In such a case, a random plane through the given points is constructed.
+ *
+ * @param {plane} out - receiving plane
+ * @param {vec3} a - 3D point
+ * @param {vec3} b - 3D point
+ * @param {vec3} c - 3D point
+ * @returns {plane} out
+ * @alias module:modeling/maths/plane.fromPointsRandom
+ */
+const fromPointsRandom = (out, a, b, c) => {
+  let ba = vec3.subtract(vec3.create(), b, a)
+  let ca = vec3.subtract(vec3.create(), c, a)
+  if (vec3.length(ba) < EPS) {
+    ba = vec3.orthogonal(ba, ca)
+  }
+  if (vec3.length(ca) < EPS) {
+    ca = vec3.orthogonal(ca, ba)
+  }
+  let normal = vec3.cross(vec3.create(), ba, ca)
+  if (vec3.length(normal) < EPS) {
+    // this would mean that ba == ca.negated()
+    ca = vec3.orthogonal(ca, ba)
+    normal = vec3.cross(normal, ba, ca)
+  }
+  normal = vec3.normalize(normal, normal)
+  const w = vec3.dot(normal, a)
+
+  out[0] = normal[0]
+  out[1] = normal[1]
+  out[2] = normal[2]
+  out[3] = w
+  return out
+}
+
+module.exports = fromPointsRandom

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

@@ -0,0 +1,5 @@
+import Plane from './type'
+
+export default fromValues
+
+declare function fromValues(x: number, y: number, z: number, w: number): Plane

package/src/maths/plane/index.d.ts

@@ -0,0 +1,17 @@
+export { default as clone } from './clone'
+export { default as copy } from './copy'
+export { default as create } from './create'
+export { default as equals } from './equals'
+export { default as flip } from './flip'
+export { default as fromNormalAndPoint } from './fromNormalAndPoint'
+export { default as fromValues } from './fromValues'
+export { default as fromNoisyPoints } from './fromNoisyPoints'
+export { default as fromPoints } from './fromPoints'
+export { default as fromPointsRandom } from './fromPointsRandom'
+export { default as signedDistanceToPoint } from './signedDistanceToPoint'
+export { default as projectionOfPoint } from './projectionOfPoint'
+export { default as toString } from './toString'
+export { default as transform } from './transform'
+
+export { default as Plane } from './type'
+export as namespace plane

package/src/maths/plane/index.js

@@ -0,0 +1,46 @@
+/**
+ * Represents a plane in 3D coordinate space as determined by a normal (perpendicular to the plane)
+ * and distance from 0,0,0.
+ * @see {@link plane} for data structure information.
+ * @module modeling/maths/plane
+ */
+module.exports = {
+  /**
+   * @see [vec4.clone()]{@link module:modeling/maths/vec4.clone}
+   * @function clone
+   */
+  clone: require('../vec4/clone'),
+  /**
+   * @see [vec4.copy()]{@link module:modeling/maths/vec4.copy}
+   * @function copy
+   */
+  copy: require('../vec4/copy'),
+  /**
+   * @see [vec4.create()]{@link module:modeling/maths/vec4.create}
+   * @function create
+   */
+  create: require('../vec4/create'),
+  /**
+   * @see [vec4.equals()]{@link module:modeling/maths/vec4.equals}
+   * @function equals
+   */
+  equals: require('../vec4/equals'),
+  flip: require('./flip'),
+  fromNormalAndPoint: require('./fromNormalAndPoint'),
+  /**
+   * @see [vec4.fromValues()]{@link module:modeling/maths/vec4.fromValues}
+   * @function fromValues
+   */
+  fromValues: require('../vec4/fromValues'),
+  fromNoisyPoints: require('./fromNoisyPoints'),
+  fromPoints: require('./fromPoints'),
+  fromPointsRandom: require('./fromPointsRandom'),
+  projectionOfPoint: require('./projectionOfPoint'),
+  signedDistanceToPoint: require('./signedDistanceToPoint'),
+  /**
+   * @see [vec4.toString()]{@link module:modeling/maths/vec4.toString}
+   * @function toString
+   */
+  toString: require('../vec4/toString'),
+  transform: require('./transform')
+}

package/src/maths/plane/projectionOfPoint.d.ts

@@ -0,0 +1,6 @@
+import Plane from './type'
+import Vec3 from '../vec3/type'
+
+export default projectionOfPoint
+
+declare function projectionOfPoint(plane: Plane, point: Vec3): Vec3

package/src/maths/plane/projectionOfPoint.js

@@ -0,0 +1,19 @@
+const vec3 = require('../vec3')
+
+/**
+ * Project the given point on to the given plane.
+ *
+ * @param {plane} plane - plane of reference
+ * @param {vec3} point - point of reference
+ * @return {vec3} projected point on plane
+ * @alias module:modeling/maths/plane.projectionOfPoint
+ */
+const projectionOfPoint = (plane, point) => {
+  const a = point[0] * plane[0] + point[1] * plane[1] + point[2] * plane[2] - plane[3]
+  const x = point[0] - a * plane[0]
+  const y = point[1] - a * plane[1]
+  const z = point[2] - a * plane[2]
+  return vec3.fromValues(x, y, z)
+}
+
+module.exports = projectionOfPoint

package/src/maths/plane/projectionOfPoint.test.js

@@ -0,0 +1,43 @@
+const test = require('ava')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+const { projectionOfPoint, create, fromNormalAndPoint } = require('./index')
+
+test('plane: projectionOfPoint() should return correct values', (t) => {
+  const temp = create()
+
+  const plane1 = fromNormalAndPoint(temp, [0, 0, 0], [0, 0, 0])
+  const point1 = projectionOfPoint(plane1, [0, 0, 0])
+  t.deepEqual(point1, [0, 0, 0])
+
+  // axis aligned planes
+  const plane2 = fromNormalAndPoint(temp, [0, 0, 1], [0, 0, 0])
+  const point2 = projectionOfPoint(plane2, [1, 1, 1])
+  t.deepEqual(point2, [1, 1, 0])
+
+  const plane3 = fromNormalAndPoint(temp, [1, 0, 0], [0, 0, 0])
+  const point3 = projectionOfPoint(plane3, [1, 1, 1])
+  t.deepEqual(point3, [0, 1, 1])
+
+  const plane4 = fromNormalAndPoint(temp, [0, 1, 0], [0, 0, 0])
+  const point4 = projectionOfPoint(plane4, [1, 1, 1])
+  t.deepEqual(point4, [1, 0, 1])
+
+  // diagonal planes
+  const plane5 = fromNormalAndPoint(temp, [1, 1, 1], [0, 0, 0])
+  const point5 = projectionOfPoint(plane5, [0, 0, 0])
+  t.deepEqual(point5, [0, 0, 0])
+
+  const plane6 = fromNormalAndPoint(temp, [1, 1, 1], [0, 0, 0])
+  const point6 = projectionOfPoint(plane6, [3, 3, 3])
+  t.true(compareVectors(point6, [0, 0, 0]))
+
+  const plane7 = fromNormalAndPoint(temp, [1, 1, 1], [0, 0, 0])
+  const point7 = projectionOfPoint(plane7, [-3, -3, -3])
+  t.true(compareVectors(point7, [0, 0, 0]))
+
+  const plane8 = fromNormalAndPoint(temp, [1, 1, 1], [0, 0, 0])
+  const point8 = projectionOfPoint(plane8, [0, 0, 0])
+  t.true(compareVectors(point8, [0, 0, 0]))
+})

package/src/maths/plane/signedDistanceToPoint.d.ts

@@ -0,0 +1,6 @@
+import Plane from './type'
+import Vec3 from '../vec3/type'
+
+export default signedDistanceToPoint
+
+declare function signedDistanceToPoint(plane: Plane, vec: Vec3): number

package/src/maths/plane/signedDistanceToPoint.js

@@ -0,0 +1,13 @@
+const vec3 = require('../vec3')
+
+/**
+ * Calculate the distance to the given point.
+ *
+ * @param {plane} plane - plane of reference
+ * @param {vec3} point - point of reference
+ * @return {Number} signed distance to point
+ * @alias module:modeling/maths/plane.signedDistanceToPoint
+ */
+const signedDistanceToPoint = (plane, point) => vec3.dot(plane, point) - plane[3]
+
+module.exports = signedDistanceToPoint

package/src/maths/plane/signedDistanceToPoint.test.js

@@ -0,0 +1,20 @@
+const test = require('ava')
+const { signedDistanceToPoint, fromValues } = require('./index')
+
+test('plane: signedDistanceToPoint() should return correct values', (t) => {
+  const plane1 = fromValues(0, 0, 0, 0)
+  const distance1 = signedDistanceToPoint(plane1, [0, 0, 0])
+  t.true(distance1 === 0.0)
+
+  const plane2 = fromValues(1, 1, 1, 1)
+  const distance2 = signedDistanceToPoint(plane2, [-1, -1, -1])
+  t.true(distance2 === (-3.0 - 1))
+
+  const plane3 = fromValues(5, 5, 5, 5)
+  const distance3 = signedDistanceToPoint(plane3, [5, 5, 5])
+  t.true(distance3 === (75.0 - 5))
+
+  const plane4 = fromValues(5, 5, 5, 5)
+  const distance4 = signedDistanceToPoint(plane4, [-2, 3, -4])
+  t.true(distance4 === (-15.0 - 5))
+})

package/src/maths/plane/toString.d.ts

@@ -0,0 +1,5 @@
+import Plane from './type'
+
+export default toString
+
+declare function toString(plane: Plane): string

package/src/maths/plane/transform.d.ts

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

package/src/maths/plane/transform.js

@@ -0,0 +1,40 @@
+const mat4 = require('../mat4')
+const vec3 = require('../vec3')
+
+const fromPoints = require('./fromPoints')
+const flip = require('./flip')
+
+/**
+ * Transform the given plane using the given matrix
+ *
+ * @param {plane} out - receiving plane
+ * @param {plane} plane - plane to transform
+ * @param {mat4} matrix - matrix to transform with
+ * @return {plane} out
+ * @alias module:modeling/maths/plane.transform
+ */
+const transform = (out, plane, matrix) => {
+  const ismirror = mat4.isMirroring(matrix)
+  // get two vectors in the plane:
+  const r = vec3.orthogonal(vec3.create(), plane)
+  const u = vec3.cross(r, plane, r)
+  const v = vec3.cross(vec3.create(), plane, u)
+  // get 3 points in the plane:
+  let point1 = vec3.fromScalar(vec3.create(), plane[3])
+  vec3.multiply(point1, point1, plane)
+  let point2 = vec3.add(vec3.create(), point1, u)
+  let point3 = vec3.add(vec3.create(), point1, v)
+  // transform the points:
+  point1 = vec3.transform(point1, point1, matrix)
+  point2 = vec3.transform(point2, point2, matrix)
+  point3 = vec3.transform(point3, point3, matrix)
+  // and create a new plane from the transformed points:
+  fromPoints(out, point1, point2, point3)
+  if (ismirror) {
+    // the transform is mirroring so flip the plane
+    flip(out, out)
+  }
+  return out
+}
+
+module.exports = transform

package/src/maths/plane/transform.test.js

@@ -0,0 +1,72 @@
+const test = require('ava')
+const { transform, create, fromValues } = require('./index')
+
+const { compareVectors } = require('../../../test/helpers/index')
+
+test('plane: transform() called with three parameters should return a plane with correct values', (t) => {
+  const identityMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const out = create()
+  const obs1 = transform(out, fromValues(0, 0, 1, 0), identityMatrix)
+  t.true(compareVectors(obs1, [0 / 0, 0 / 0, 0 / 0, 0 / 0]))
+  t.is(out, obs1)
+
+  const plane2 = fromValues(0, 0, -1, 0)
+  const obs2 = transform(out, plane2, identityMatrix)
+  t.true(compareVectors(obs2, [0, 0, -1, 0]))
+
+  const x = 1
+  const y = 5
+  const z = 7
+  const translationMatrix = [
+    1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    x, y, z, 1
+  ]
+
+  const plane3 = fromValues(0, 0, 1, 0)
+  const obs3 = transform(out, plane3, translationMatrix)
+  t.true(compareVectors(obs3, [0, 0, 1, 7]))
+
+  const w = 1
+  const h = 3
+  const d = 5
+  const scaleMatrix = [
+    w, 0, 0, 0,
+    0, h, 0, 0,
+    0, 0, d, 0,
+    0, 0, 0, 1
+  ]
+
+  const plane4 = fromValues(0, -1, 0, 0)
+  const obs4 = transform(out, plane4, scaleMatrix)
+  t.true(compareVectors(obs4, [0, -1, 0, 0]))
+
+  const r = (90 * 0.017453292519943295)
+  const rotateZMatrix = [
+    Math.cos(r), -Math.sin(r), 0, 0,
+    Math.sin(r), Math.cos(r), 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+
+  const plane5 = fromValues(-1, 0, 0, 0)
+  const obs5 = transform(plane5, plane5, rotateZMatrix)
+  t.true(compareVectors(obs5, [-0, 1, 0, 0]))
+
+  const mirrorMatrix = [
+    -1, 0, 0, 0,
+    0, 1, 0, 0,
+    0, 0, 1, 0,
+    0, 0, 0, 1
+  ]
+  const plane6 = fromValues(1, 0, 0, 0)
+  const obs6 = transform(plane6, plane6, mirrorMatrix)
+  t.true(compareVectors(obs6, [-1, 0, 0, 0]))
+})

package/src/maths/plane/type.d.ts

@@ -0,0 +1,3 @@
+export default Plane
+
+declare type Plane = [number, number, number, number]

package/src/maths/rotation.test.js

@@ -0,0 +1,131 @@
+const test = require('ava')
+
+const { compareVectors } = require('../../test/helpers/index')
+
+const { constants, mat4, vec2, vec3 } = require('./index')
+
+// ALL POSITIVE ROTATIONS ARE CLOCKWISE
+// see https://webglfundamentals.org/webgl/lessons/webgl-3d-orthographic.html
+// IN A LEFT-HANDED COORDINATE SYSTEM
+
+// JSCAD IS RIGHT-HANDED COORDINATE SYSTEM
+// WHERE POSITIVE ROTATIONS ARE COUNTER-CLOCKWISE
+
+// identity matrices for comparisons
+
+const rad90 = constants.TAU / 4
+
+// +90 degree rotation about X
+const cwX90Matrix = [
+  1, 0, 0, 0,
+  0, Math.cos(rad90), Math.sin(rad90), 0,
+  0, -Math.sin(rad90), Math.cos(rad90), 0,
+  0, 0, 0, 1
+]
+// +90 degree rotation about Y
+const cwY90Matrix = [
+  Math.cos(rad90), 0, -Math.sin(rad90), 0,
+  0, 1, 0, 0,
+  Math.sin(rad90), 0, Math.cos(rad90), 0,
+  0, 0, 0, 1
+]
+// +90 degree rotation about Z
+const cwZ90Matrix = [
+  Math.cos(rad90), Math.sin(rad90), 0, 0,
+  -Math.sin(rad90), Math.cos(rad90), 0, 0,
+  0, 0, 1, 0,
+  0, 0, 0, 1
+]
+
+test('rotation: mat4 rotation functions should produce expected results', (t) => {
+  const idn = mat4.create()
+  let obs
+
+  // test matrices for rotating about X axis
+  obs = mat4.fromXRotation(mat4.create(), rad90)
+  t.true(compareVectors(obs, cwX90Matrix))
+
+  obs = mat4.fromRotation(mat4.create(), rad90, [1, 0, 0])
+  t.true(compareVectors(obs, cwX90Matrix))
+
+  obs = mat4.rotateX(obs, idn, rad90)
+  t.true(compareVectors(obs, cwX90Matrix))
+
+  // test matrices for rotating about Y axis
+  obs = mat4.fromYRotation(mat4.create(), rad90)
+  t.true(compareVectors(obs, cwY90Matrix))
+
+  obs = mat4.fromRotation(mat4.create(), rad90, [0, 1, 0])
+  t.true(compareVectors(obs, cwY90Matrix))
+
+  obs = mat4.rotateY(obs, idn, rad90)
+  t.true(compareVectors(obs, cwY90Matrix))
+
+  // test matrices for rotating about Z axis
+  obs = mat4.fromZRotation(mat4.create(), rad90)
+  t.true(compareVectors(obs, cwZ90Matrix))
+
+  obs = mat4.fromRotation(mat4.create(), rad90, [0, 0, 1])
+  t.true(compareVectors(obs, cwZ90Matrix))
+
+  obs = mat4.rotateZ(obs, idn, rad90)
+  t.true(compareVectors(obs, cwZ90Matrix))
+})
+
+test('rotation: vec2 rotation functions should produce expected results', (t) => {
+  const onX = vec2.fromValues(3, 0)
+  const onY = vec2.fromValues(0, 3)
+  const matZ = mat4.fromZRotation(mat4.create(), rad90)
+
+  // transform
+  const t1 = vec2.transform(vec2.create(), onX, matZ)
+  t.true(compareVectors(t1, [0, 3]))
+
+  const t2 = vec2.transform(vec2.create(), onY, matZ)
+  t.true(compareVectors(t2, [-3, 0]))
+
+  // rotate
+  const r1 = vec2.rotate(vec2.create(), onX, vec2.create(), rad90)
+  t.true(compareVectors(r1, [0, 3]))
+
+  const r2 = vec2.rotate(vec2.create(), onY, vec2.create(), rad90)
+  t.true(compareVectors(r2, [-3, 0]))
+
+  // verify
+  t.true(compareVectors(t1, r1))
+  t.true(compareVectors(t2, r2))
+})
+
+test('rotation: vec3 rotation functions should produce expected results', (t) => {
+  const onX = vec3.fromValues(3, 0, 0)
+  const onY = vec3.fromValues(0, 3, 0)
+  const onZ = vec3.fromValues(0, 0, 3)
+  const matX = mat4.fromXRotation(mat4.create(), rad90)
+  const matY = mat4.fromYRotation(mat4.create(), rad90)
+  const matZ = mat4.fromZRotation(mat4.create(), rad90)
+
+  // transform
+  const t1 = vec3.transform(vec3.create(), onX, matZ)
+  t.true(compareVectors(t1, [0, 3, 0]))
+
+  const t2 = vec3.transform(vec3.create(), onY, matX)
+  t.true(compareVectors(t2, [0, 0, 3]))
+
+  const t3 = vec3.transform(vec3.create(), onZ, matY)
+  t.true(compareVectors(t3, [3, 0, 0]))
+
+  // rotate
+  const r1 = vec3.rotateZ(vec3.create(), onX, [0, 0, 0], rad90)
+  t.true(compareVectors(r1, [0, 3, 0]))
+
+  const r2 = vec3.rotateX(vec3.create(), onY, [0, 0, 0], rad90)
+  t.true(compareVectors(r2, [0, 0, 3]))
+
+  const r3 = vec3.rotateY(vec3.create(), onZ, [0, 0, 0], rad90)
+  t.true(compareVectors(r3, [3, 0, 0]))
+
+  // verify
+  t.true(compareVectors(t1, r1))
+  t.true(compareVectors(t2, r2))
+  t.true(compareVectors(t3, r3))
+})

package/src/maths/types.d.ts

@@ -0,0 +1,8 @@
+export { default as Line2 } from './line2/type'
+export { default as Line3 } from './line3/type'
+export { default as Mat4 } from './mat4/type'
+export { default as Plane } from './plane/type'
+export { default as Vec1 } from './vec1/type'
+export { default as Vec2 } from './vec2/type'
+export { default as Vec3 } from './vec3/type'
+export { default as Vec4 } from './vec4/type'

package/src/maths/utils/aboutEqualNormals.d.ts

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

package/src/maths/utils/aboutEqualNormals.js

@@ -0,0 +1,12 @@
+const { NEPS } = require('../constants')
+
+/**
+ * Compare two normals (unit vectors) for near equality.
+ * @param {vec3} a - normal a
+ * @param {vec3} b - normal b
+ * @returns {Boolean} true if a and b are nearly equal
+ * @alias module:modeling/maths/utils.aboutEqualNormals
+ */
+const aboutEqualNormals = (a, b) => (Math.abs(a[0] - b[0]) <= NEPS && Math.abs(a[1] - b[1]) <= NEPS && Math.abs(a[2] - b[2]) <= NEPS)
+
+module.exports = aboutEqualNormals

package/src/maths/utils/area.d.ts

@@ -0,0 +1,5 @@
+import Vec2 from '../vec2/type'
+
+export default area
+
+declare function area(points: Array<Vec2>): number