@jscad/modeling 2.9.4 → 2.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.9.4",
+  "version": "2.10.0",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "homepage": "https://openjscad.xyz/",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
@@ -61,5 +61,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "662965f40a1ce628aa97f30b814586e72a3acb36"
+  "gitHead": "13572067545460affd53b64b3ab834a39af8c7e5"
 }

package/src/colors/colorize.d.ts

@@ -5,9 +5,10 @@ import { RGB, RGBA } from './types'
 
 export default colorize
 
-declare function colorize<T extends Geometry>(color: RGB | RGBA, object: T): T
-declare function colorize<T>(color: RGB | RGBA, object: T): T & Colored
+// Single Geom3 returns Colored Geom3
+declare function colorize<T extends Geometry>(color: RGB | RGBA, object: T): T & Colored
 
-declare function colorize<T extends Geometry>(color: RGB | RGBA, ...objects: RecursiveArray<T>): Array<T>
-declare function colorize<T>(color: RGB | RGBA, ...objects: RecursiveArray<T>): Array<T & Colored>
-declare function colorize(color: RGB | RGBA, ...objects: RecursiveArray<any>): Array<any & Colored>
+// List of Geom3 returns list of Colored Geom3
+declare function colorize<T extends Geometry>(color: RGB | RGBA, ...objects: RecursiveArray<T>): Array<T & Colored>
+// List of mixed geometries returns list of colored geometries
+declare function colorize(color: RGB | RGBA, ...objects: RecursiveArray<Geometry>): Array<Geometry & Colored>

package/src/geometries/geom2/type.d.ts

@@ -1,10 +1,11 @@
 import Vec2 from '../../maths/vec2/type'
 import Mat4 from '../../maths/mat4/type'
-import { Colored } from '../types'
+import { Color } from '../types'
 
 export default Geom2
 
-declare interface Geom2 extends Colored {
+declare interface Geom2 {
   sides: Array<[Vec2, Vec2]>
   transforms: Mat4
+  color?: Color
 }

package/src/geometries/geom3/type.d.ts

@@ -1,10 +1,11 @@
 import Poly3 from '../poly3/type'
 import Mat4 from '../../maths/mat4/type'
-import { Colored } from '../types'
+import { Color } from '../types'
 
 export default Geom3
 
-declare interface Geom3 extends Colored {
+declare interface Geom3 {
   polygons: Array<Poly3>
   transforms: Mat4
+  color?: Color
 }

package/src/geometries/path2/appendArc.js

@@ -1,3 +1,4 @@
+const { TAU } = require('../../maths/constants')
 const vec2 = require('../../maths/vec2')
 
 const fromPoints = require('./fromPoints')
@@ -12,7 +13,7 @@ const toPoints = require('./toPoints')
  * @param {vec2} [options.radius=[0,0]] - radius of arc (X and Y)
  * @param {Number} [options.xaxisrotation=0] - rotation (RADIANS) of the X axis of the arc with respect to the X axis of the coordinate system
  * @param {Boolean} [options.clockwise=false] - draw an arc clockwise with respect to the center point
- * @param {Boolean} [options.large=false] - draw an arc longer than PI radians
+ * @param {Boolean} [options.large=false] - draw an arc longer than TAU / 2 radians
  * @param {Number} [options.segments=16] - number of segments per full rotation
  * @param {path2} geometry - the path of which to append the arc
  * @returns {path2} a new path with the appended points
@@ -111,15 +112,15 @@ const appendArc = (options, geometry) => {
     const theta1 = vec2.angleRadians(vector1)
     const theta2 = vec2.angleRadians(vector2)
     let deltatheta = theta2 - theta1
-    deltatheta = deltatheta % (2 * Math.PI)
+    deltatheta = deltatheta % TAU
     if ((!sweepFlag) && (deltatheta > 0)) {
-      deltatheta -= 2 * Math.PI
+      deltatheta -= TAU
     } else if ((sweepFlag) && (deltatheta < 0)) {
-      deltatheta += 2 * Math.PI
+      deltatheta += TAU
     }
 
     // Ok, we have the center point and angle range (from theta1, deltatheta radians) so we can create the ellipse
-    let numsteps = Math.ceil(Math.abs(deltatheta) / (2 * Math.PI) * segments) + 1
+    let numsteps = Math.ceil(Math.abs(deltatheta) / TAU * segments) + 1
     if (numsteps < 1) numsteps = 1
     for (let step = 1; step < numsteps; step++) {
       const theta = theta1 + step / numsteps * deltatheta

package/src/geometries/path2/appendArc.test.js

@@ -1,5 +1,7 @@
 const test = require('ava')
 
+const { TAU } = require('../../maths/constants')
+
 const { appendArc, fromPoints, toPoints } = require('./index')
 
 const { comparePoints } = require('../../../test/helpers/')
@@ -48,7 +50,7 @@ test('appendArc: appending to a path produces a new path', (t) => {
   t.is(pts.length, 16)
 
   // test xaxisrotation
-  obs = appendArc({ endpoint: [12, -22], radius: [15, -20], xaxisrotation: Math.PI / 2 }, p2)
+  obs = appendArc({ endpoint: [12, -22], radius: [15, -20], xaxisrotation: TAU / 4 }, p2)
   pts = toPoints(obs)
   exp = [
     [27, -22],

package/src/geometries/path2/appendBezier.js

@@ -1,3 +1,4 @@
+const { TAU } = require('../../maths/constants')
 const vec2 = require('../../maths/vec2')
 const vec3 = require('../../maths/vec2')
 
@@ -117,7 +118,7 @@ const appendBezier = (options, geometry) => {
 
   // subdivide each segment until the angle at each vertex becomes small enough:
   let subdivideBase = 1
-  const maxangle = Math.PI * 2 / segments
+  const maxangle = TAU / segments
   const maxsinangle = Math.sin(maxangle)
   while (subdivideBase < newpoints.length - 1) {
     const dir1 = vec2.subtract(v0, newpoints[subdivideBase], newpoints[subdivideBase - 1])

package/src/geometries/path2/appendPoints.js

@@ -1,5 +1,5 @@
-const fromPoints = require('./fromPoints')
-const toPoints = require('./toPoints')
+const concat = require('./concat')
+const create = require('./create')
 
 /**
  * Append the given list of points to the end of the given geometry.
@@ -10,15 +10,6 @@ const toPoints = require('./toPoints')
  * @example
  * let newpath = appendPoints([[3, 4], [4, 5]], oldpath)
  */
-const appendPoints = (points, geometry) => {
-  if (geometry.isClosed) {
-    throw new Error('cannot append points to a closed path')
-  }
-
-  let newpoints = toPoints(geometry)
-  newpoints = newpoints.concat(points)
-
-  return fromPoints({}, newpoints)
-}
+const appendPoints = (points, geometry) => concat(geometry, create(points))
 
 module.exports = appendPoints

package/src/geometries/path2/appendPoints.test.js

@@ -17,3 +17,19 @@ test('appendPoints: appending to a path produces a new path with expected points
   t.not(p1, obs)
   t.is(pts.length, 4)
 })
+
+test('appendPoints: appending empty points to a path produces a new path with expected points', (t) => {
+  const p1 = fromPoints({}, [[1, 1], [2, 2]])
+  const obs = appendPoints([], p1)
+  const pts = toPoints(obs)
+  t.not(p1, obs)
+  t.is(pts.length, 2)
+})
+
+test('appendPoints: appending same points to a path produces a new path with expected points', (t) => {
+  const p1 = fromPoints({}, [[1, 1], [2, 2]])
+  const obs = appendPoints([[2, 2], [3, 3]], p1)
+  const pts = toPoints(obs)
+  t.not(p1, obs)
+  t.is(pts.length, 3)
+})

package/src/geometries/path2/concat.js

@@ -1,8 +1,11 @@
 const fromPoints = require('./fromPoints')
 const toPoints = require('./toPoints')
+
 const { equals } = require('../../maths/vec2')
+
 /**
  * Concatenate the given paths.
+ *
  * If both contain the same point at the junction, merge it into one.
  * A concatenation of zero paths is an empty, open path.
  * A concatenation of one closed path to a series of open paths produces a closed path.
@@ -17,16 +20,14 @@ const { equals } = require('../../maths/vec2')
 const concat = (...paths) => {
   // Only the last path can be closed, producing a closed path.
   let isClosed = false
-  for (const path of paths) {
-    if (isClosed) {
-      throw new Error('Cannot concatenate to a closed path')
-    }
-    isClosed = path.isClosed
-  }
   let newpoints = []
-  paths.forEach((path) => {
-    const tmp = toPoints(path)
+  paths.forEach((path, i) => {
+    const tmp = toPoints(path).slice()
     if (newpoints.length > 0 && tmp.length > 0 && equals(tmp[0], newpoints[newpoints.length - 1])) tmp.shift()
+    if (tmp.length > 0 && isClosed) {
+      throw new Error(`Cannot concatenate to a closed path; check the ${i}th path`)
+    }
+    isClosed = path.isClosed
     newpoints = newpoints.concat(tmp)
   })
   return fromPoints({ closed: isClosed }, newpoints)

package/src/geometries/path2/concat.test.js

@@ -10,10 +10,16 @@ test('concat: empty paths produces an empty open path', (t) => {
   t.true(equals(concat(fromPoints({}, []), fromPoints({}, [])), fromPoints({ closed: false }, [])))
 })
 
-test('concat: Two open paths produces a open path', (t) => {
-  t.true(equals(concat(fromPoints({ closed: false }, [[0, 0]]),
-    fromPoints({ closed: false }, [[1, 1]])),
-  fromPoints({ closed: false }, [[0, 0], [1, 1]])))
+test('concat: many open paths produces a open path', (t) => {
+  const p1 = fromPoints({ closed: false }, [[0, 0]])
+  const p2 = fromPoints({ closed: false }, [[1, 1]])
+  const p3 = fromPoints({ closed: false }, [[1, 1], [3, 3]])
+
+  const result = concat(p1, p2, p3)
+  t.true(equals(result, fromPoints({}, [[0, 0], [1, 1], [3, 3]])))
+  t.is(p1.points.length, 1)
+  t.is(p2.points.length, 1)
+  t.is(p3.points.length, 2)
 })
 
 test('concat: An open path and a closed path produces a closed path', (t) => {
@@ -23,7 +29,7 @@ test('concat: An open path and a closed path produces a closed path', (t) => {
 })
 
 test('concat: A closed path and an open path throws an error', (t) => {
-  t.throws(() => concat(fromPoints({ closed: true }, [[0, 0]]),
-    fromPoints({ closed: false }, [[1, 1]])),
-  { message: 'Cannot concatenate to a closed path' })
+  const p1 = fromPoints({ closed: true }, [[0, 0]])
+  const p2 = fromPoints({ closed: false }, [[1, 1]])
+  t.throws(() => concat(p1, p2), { message: 'Cannot concatenate to a closed path; check the 1th path' })
 })

package/src/geometries/path2/transform.js

@@ -10,7 +10,7 @@ const mat4 = require('../../maths/mat4')
  * @alias module:modeling/geometries/path2.transform
  *
  * @example
- * let newpath = transform(fromZRotation(Math.PI / 4), path)
+ * let newpath = transform(fromZRotation(TAU / 8), path)
  */
 const transform = (matrix, geometry) => {
   const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)

package/src/geometries/path2/type.d.ts

@@ -1,11 +1,12 @@
 import Vec2 from '../../maths/vec2/type'
 import Mat4 from '../../maths/mat4/type'
-import { Colored } from '../types'
+import { Color } from '../types'
 
 export default Path2
 
-declare interface Path2 extends Colored {
+declare interface Path2 {
   points: Array<Vec2>
   isClosed: boolean
   transforms: Mat4
+  color?: Color
 }

package/src/geometries/poly3/measureBoundingSphere.d.ts

@@ -1,6 +1,6 @@
 import Poly3 from './type'
-import Vec3 from '../../maths/vec3/type'
+import Vec4 from '../../maths/vec4/type'
 
 export default measureBoundingSphere
 
-declare function measureBoundingSphere(polygon: Poly3): [Vec3, Vec3]
+declare function measureBoundingSphere(polygon: Poly3): Vec4

package/src/geometries/poly3/measureBoundingSphere.js

@@ -1,19 +1,57 @@
 const vec3 = require('../../maths/vec3')
-const measureBoundingBox = require('./measureBoundingBox')
+const vec4 = require('../../maths/vec4')
+
+const cache = new WeakMap()
 
 /**
  * Measure the bounding sphere of the given polygon.
  * @param {poly3} polygon - the polygon to measure
- * @returns {Array} the computed bounding sphere; center point (3D) and radius
+ * @returns {vec4} the computed bounding sphere; center point (3D) and radius
  * @alias module:modeling/geometries/poly3.measureBoundingSphere
  */
 const measureBoundingSphere = (polygon) => {
-  const box = measureBoundingBox(polygon)
-  const center = box[0]
-  vec3.add(center, box[0], box[1])
-  vec3.scale(center, center, 0.5)
-  const radius = vec3.distance(center, box[1])
-  return [center, radius]
+  let boundingSphere = cache.get(polygon)
+  if (boundingSphere) return boundingSphere
+
+  const vertices = polygon.vertices
+  const out = vec4.create()
+
+  if (vertices.length === 0) {
+    out[0] = 0
+    out[1] = 0
+    out[2] = 0
+    out[3] = 0
+    return out
+  }
+
+  // keep a list of min/max vertices by axis
+  let minx = vertices[0]
+  let miny = minx
+  let minz = minx
+  let maxx = minx
+  let maxy = minx
+  let maxz = minx
+
+  vertices.forEach((v) => {
+    if (minx[0] > v[0]) minx = v
+    if (miny[1] > v[1]) miny = v
+    if (minz[2] > v[2]) minz = v
+    if (maxx[0] < v[0]) maxx = v
+    if (maxy[1] < v[1]) maxy = v
+    if (maxz[2] < v[2]) maxz = v
+  })
+
+  out[0] = (minx[0] + maxx[0]) * 0.5 // center of sphere
+  out[1] = (miny[1] + maxy[1]) * 0.5
+  out[2] = (minz[2] + maxz[2]) * 0.5
+  const x = out[0] - maxx[0]
+  const y = out[1] - maxy[1]
+  const z = out[2] - maxz[2]
+  out[3] = Math.sqrt(x * x + y * y + z * z) // radius of sphere
+
+  cache.set(polygon, out)
+
+  return out
 }
 
 module.exports = measureBoundingSphere

package/src/geometries/poly3/measureBoundingSphere.test.js

@@ -3,28 +3,23 @@ const { measureBoundingSphere, create, fromPoints, transform } = require('./inde
 
 const mat4 = require('../../maths/mat4')
 
-const { compareVectors, nearlyEqual } = require('../../../test/helpers/index')
-
 test('poly3: measureBoundingSphere() should return correct values', (t) => {
   let ply1 = create()
-  let exp1 = [[0, 0, 0], 0]
+  let exp1 = [0, 0, 0, 0]
   let ret1 = measureBoundingSphere(ply1)
-  t.true(compareVectors(ret1[0], exp1[0]))
-  nearlyEqual(t, ret1[1], exp1[1], Number.EPSILON)
+  t.deepEqual(ret1, exp1)
 
   // simple triangle
   let ply2 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10]])
-  let exp2 = [[0, 5, 5], 7.0710678118654755]
+  let exp2 = [0, 5, 5, 7.0710678118654755]
   let ret2 = measureBoundingSphere(ply2)
-  t.true(compareVectors(ret2[0], exp2[0]))
-  nearlyEqual(t, ret2[1], exp2[1], Number.EPSILON)
+  t.deepEqual(ret2, exp2)
 
   // simple square
   let ply3 = fromPoints([[0, 0, 0], [0, 10, 0], [0, 10, 10], [0, 0, 10]])
-  let exp3 = [[0, 5, 5], 7.0710678118654755]
+  let exp3 = [0, 5, 5, 7.0710678118654755]
   let ret3 = measureBoundingSphere(ply3)
-  t.true(compareVectors(ret3[0], exp3[0]))
-  nearlyEqual(t, ret3[1], exp3[1], Number.EPSILON)
+  t.deepEqual(ret3, exp3)
 
   // V-shape
   const points = [
@@ -40,10 +35,9 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
     [0, 3, 3]
   ]
   let ply4 = fromPoints(points)
-  let exp4 = [[0, 4.5, 3], 4.6097722286464435]
+  let exp4 = [0, 4.5, 3, 4.6097722286464435]
   let ret4 = measureBoundingSphere(ply4)
-  t.true(compareVectors(ret4[0], exp4[0]))
-  nearlyEqual(t, ret4[1], exp4[1], Number.EPSILON)
+  t.deepEqual(ret4, exp4)
 
   // rotated to various angles
   const rotation = mat4.fromZRotation(mat4.create(), (45 * 0.017453292519943295))
@@ -55,16 +49,12 @@ test('poly3: measureBoundingSphere() should return correct values', (t) => {
   ret2 = measureBoundingSphere(ply2)
   ret3 = measureBoundingSphere(ply3)
   ret4 = measureBoundingSphere(ply4)
-  exp1 = [[0, 0, 0], 0]
-  t.true(compareVectors(ret1[0], exp1[0]))
-  nearlyEqual(t, ret1[1], exp1[1], Number.EPSILON)
-  exp2 = [[-3.5355339059327373, 3.5355339059327378, 5], 7.0710678118654755]
-  t.true(compareVectors(ret2[0], exp2[0]))
-  nearlyEqual(t, ret2[1], exp2[1], Number.EPSILON)
-  exp3 = [[-3.5355339059327373, 3.5355339059327378, 5], 7.0710678118654755]
-  t.true(compareVectors(ret3[0], exp3[0]))
-  nearlyEqual(t, ret3[1], exp3[1], Number.EPSILON)
-  exp4 = [[-3.181980515339464, 3.1819805153394642, 3], 4.6097722286464435]
-  t.true(compareVectors(ret4[0], exp4[0]))
-  nearlyEqual(t, ret4[1], exp4[1], Number.EPSILON)
+  exp1 = [0, 0, 0, 0]
+  t.deepEqual(ret1, exp1)
+  exp2 = [-3.5355339059327373, 3.5355339059327378, 5, 7.0710678118654755]
+  t.deepEqual(ret2, exp2)
+  exp3 = [-3.5355339059327373, 3.5355339059327378, 5, 7.0710678118654755]
+  t.deepEqual(ret3, exp3)
+  exp4 = [-3.181980515339464, 3.1819805153394642, 3, 4.6097722286464435]
+  t.deepEqual(ret4, exp4)
 })

package/src/geometries/poly3/type.d.ts

@@ -1,8 +1,9 @@
 import Vec3 from '../../maths/vec3/type'
-import { Colored } from '../types'
+import { Color } from '../types'
 
 export default Poly3
 
-declare interface Poly3 extends Colored {
+declare interface Poly3 {
   vertices: Array<Vec3>
+  color?: Color
 }

package/src/geometries/types.d.ts

@@ -8,8 +8,10 @@ import { RGB, RGBA } from '../colors'
 // see https://github.com/jscad/OpenJSCAD.org/pull/726#issuecomment-724575265
 export type Geometry = Geom2 | Geom3 | Poly3 | Path2
 
-export type Colored = {
-  color?: RGB | RGBA
+export type Color = RGB | RGBA
+
+export interface Colored {
+  color: Color
 }
 
 export { default as Geom2 } from './geom2/type'

package/src/index.d.ts

@@ -11,6 +11,7 @@ export * as booleans from './operations/booleans'
 export * as expansions from './operations/expansions'
 export * as extrusions from './operations/extrusions'
 export * as hulls from './operations/hulls'
+export * as modifiers from './operations/modifiers'
 export * as transforms from './operations/transforms'
 
 export as namespace modeling

package/src/maths/constants.js

@@ -24,8 +24,18 @@ const NEPS = 1e-13
 // for comparing coplanar polygons, as provided by the sphere primitive at high
 // segmentation. NEPS is for 64 bit Number values.
 
+/**
+ * The TAU property represents the ratio of the circumference of a circle to its radius.
+ * Approximately 6.28318530717958647692
+ * @default
+ * @example
+ * const { TAU } = require('@jscad/modeling').maths.constants
+ */
+const TAU = Math.PI * 2
+
 module.exports = {
   EPS,
   NEPS,
+  TAU,
   spatialResolution
 }

package/src/maths/mat4/fromRotation.js

@@ -1,6 +1,8 @@
-const identity = require('./identity')
+const { EPS } = require('../constants')
+
+const { sin, cos } = require('../utils/trigonometry')
 
-const { EPSILON } = require('./constants')
+const identity = require('./identity')
 
 /**
  * Creates a matrix from a given angle around a given axis
@@ -15,24 +17,24 @@ const { EPSILON } = require('./constants')
  * @returns {mat4} out
  * @alias module:modeling/maths/mat4.fromRotation
  * @example
- * let matrix = fromRotation(create(), Math.PI / 2, [0, 0, 3])
+ * let matrix = fromRotation(create(), TAU / 4, [0, 0, 3])
  */
 const fromRotation = (out, rad, axis) => {
   let [x, y, z] = axis
-  let len = Math.hypot(x, y, z)
+  const lengthSquared = x * x + y * y + z * z
 
-  if (Math.abs(len) < EPSILON) {
+  if (Math.abs(lengthSquared) < EPS) {
     // axis is 0,0,0 or almost
     return identity(out)
   }
 
-  len = 1 / len
+  const len = 1 / Math.sqrt(lengthSquared)
   x *= len
   y *= len
   z *= len
 
-  const s = Math.sin(rad)
-  const c = Math.cos(rad)
+  const s = sin(rad)
+  const c = cos(rad)
   const t = 1 - c
 
   // Perform rotation-specific matrix multiplication

package/src/maths/mat4/fromTaitBryanRotation.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Creates a matrix from the given Tait–Bryan angles.
  *
@@ -11,16 +13,16 @@
  * @returns {mat4} out
  * @alias module:modeling/maths/mat4.fromTaitBryanRotation
  * @example
- * let matrix = fromTaitBryanRotation(create(), Math.PI / 2, 0, Math.PI)
+ * let matrix = fromTaitBryanRotation(create(), TAU / 4, 0, TAU / 2)
  */
 const fromTaitBryanRotation = (out, yaw, pitch, roll) => {
   // precompute sines and cosines of Euler angles
-  const sy = Math.sin(yaw)
-  const cy = Math.cos(yaw)
-  const sp = Math.sin(pitch)
-  const cp = Math.cos(pitch)
-  const sr = Math.sin(roll)
-  const cr = Math.cos(roll)
+  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

package/src/maths/mat4/fromXRotation.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Creates a matrix from the given angle around the X axis.
  * This is equivalent to (but much faster than):
@@ -10,11 +12,11 @@
  * @returns {mat4} out
  * @alias module:modeling/maths/mat4.fromXRotation
  * @example
- * let matrix = fromXRotation(create(), Math.PI / 2)
+ * let matrix = fromXRotation(create(), TAU / 4)
  */
 const fromXRotation = (out, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
 
   // Perform axis-specific matrix multiplication
   out[0] = 1

package/src/maths/mat4/fromYRotation.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Creates a matrix from the given angle around the Y axis.
  * This is equivalent to (but much faster than):
@@ -10,11 +12,11 @@
  * @returns {mat4} out
  * @alias module:modeling/maths/mat4.fromYRotation
  * @example
- * let matrix = fromYRotation(create(), Math.PI / 2)
+ * let matrix = fromYRotation(create(), TAU / 4)
  */
 const fromYRotation = (out, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
 
   // Perform axis-specific matrix multiplication
   out[0] = c

package/src/maths/mat4/fromZRotation.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Creates a matrix from the given angle around the Z axis.
  * This is equivalent to (but much faster than):
@@ -10,11 +12,11 @@
  * @returns {mat4} out
  * @alias module:modeling/maths/mat4.fromZRotation
  * @example
- * let matrix = fromZRotation(create(), Math.PI / 2)
+ * let matrix = fromZRotation(create(), TAU / 4)
  */
 const fromZRotation = (out, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
 
   // Perform axis-specific matrix multiplication
   out[0] = c

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

@@ -1,8 +1,11 @@
 const test = require('ava')
+
+const { TAU } = require('../constants')
+const vec3 = require('../vec3/index')
+
 const { create, invert, fromTranslation, fromXRotation } = require('./index')
 
 const { compareVectors } = require('../../../test/helpers/index')
-const vec3 = require('../vec3/index')
 
 test('mat4: invert() translate ', (t) => {
   const matrix = fromTranslation(create(), [10, 10, 0])
@@ -17,7 +20,7 @@ test('mat4: invert() translate ', (t) => {
 })
 
 test('mat4: invert() rotate ', (t) => {
-  const matrix = fromXRotation(create(), Math.PI / 2)
+  const matrix = fromXRotation(create(), TAU / 4)
   const matrixInv = invert(create(), matrix)
 
   const vec1 = [10, 10, 10]

package/src/maths/mat4/isOnlyTransformScale.js

@@ -1,7 +1,7 @@
 
 /**
  * Determine whether the given matrix is only translate and/or scale.
- * This code returns true for PI rotation as it can be interpreted as scale.
+ * This code returns true for TAU / 2 rotation as it can be interpreted as scale.
  *
  * @param {mat4} matrix - the matrix
  * @returns {Boolean} true if matrix is for translate and/or scale