@jscad/modeling 2.9.6 → 2.10.0

package/src/operations/transforms/rotate.test.js

@@ -1,5 +1,7 @@
 const test = require('ava')
 
+const { TAU } = require('../../maths/constants')
+
 const { geom2, geom3, path2 } = require('../../geometries')
 
 const { rotate, rotateX, rotateY, rotateZ } = require('./index')
@@ -10,7 +12,7 @@ test('rotate: rotating of a path2 produces expected changes to points', (t) => {
   const geometry = path2.fromPoints({}, [[1, 0], [0, 1], [-1, 0]])
 
   // rotate about Z
-  let rotated = rotate([0, 0, Math.PI / 2], geometry)
+  let rotated = rotate([0, 0, TAU / 4], geometry)
   let obs = path2.toPoints(rotated)
   const exp = [
     new Float32Array([0, 1]),
@@ -19,7 +21,7 @@ test('rotate: rotating of a path2 produces expected changes to points', (t) => {
   ]
   t.true(comparePoints(obs, exp))
 
-  rotated = rotateZ(Math.PI / 2, geometry)
+  rotated = rotateZ(TAU / 4, geometry)
   obs = path2.toPoints(rotated)
   t.notThrows(() => path2.validate(rotated))
   t.true(comparePoints(obs, exp))
@@ -29,7 +31,7 @@ test('rotate: rotating of a geom2 produces expected changes to points', (t) => {
   const geometry = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
 
   // rotate about Z
-  let rotated = rotate([0, 0, -Math.PI / 2], geometry)
+  let rotated = rotate([0, 0, -TAU / 4], geometry)
   let obs = geom2.toPoints(rotated)
   const exp = [
     new Float32Array([0, 0]),
@@ -39,7 +41,7 @@ test('rotate: rotating of a geom2 produces expected changes to points', (t) => {
   t.notThrows(() => geom2.validate(rotated))
   t.true(comparePoints(obs, exp))
 
-  rotated = rotateZ(-Math.PI / 2, geometry)
+  rotated = rotateZ(-TAU / 4, geometry)
   obs = geom2.toPoints(rotated)
   t.notThrows(() => geom2.validate(rotated))
   t.true(comparePoints(obs, exp))
@@ -57,7 +59,7 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   const geometry = geom3.fromPoints(points)
 
   // rotate about X
-  let rotated = rotate([Math.PI / 2], geometry)
+  let rotated = rotate([TAU / 4], geometry)
   let obs = geom3.toPoints(rotated)
   let exp = [
     [[-2, 12, -7.000000000000001], [-2, -18, -6.999999999999999],
@@ -76,13 +78,13 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
-  rotated = rotateX(Math.PI / 2, geometry)
+  rotated = rotateX(TAU / 4, geometry)
   obs = geom3.toPoints(rotated)
   t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // rotate about Y
-  rotated = rotate([0, -Math.PI / 2], geometry)
+  rotated = rotate([0, -TAU / 4], geometry)
   obs = geom3.toPoints(rotated)
   exp = [
     [[12, -7, -2.000000000000001], [-18, -7, -1.999999999999999],
@@ -101,12 +103,12 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
-  rotated = rotateY(-Math.PI / 2, geometry)
+  rotated = rotateY(-TAU / 4, geometry)
   obs = geom3.toPoints(rotated)
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // rotate about Z
-  rotated = rotate([0, 0, Math.PI], geometry)
+  rotated = rotate([0, 0, TAU / 2], geometry)
   obs = geom3.toPoints(rotated)
   exp = [
     [[2.000000000000001, 7, -12], [2.000000000000001, 7, 18],
@@ -125,7 +127,7 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
   t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
-  rotated = rotateZ(Math.PI, geometry)
+  rotated = rotateZ(TAU / 2, geometry)
   obs = geom3.toPoints(rotated)
   t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -136,7 +138,7 @@ test('rotate: rotating of multiple objects produces expected changes', (t) => {
   const geometry1 = path2.fromPoints({}, [[-5, 5], [5, 5], [-5, -5], [10, -5]])
   const geometry2 = geom2.fromPoints([[-5, -5], [0, 5], [10, -5]])
 
-  const rotated = rotate([0, 0, Math.PI / 2], junk, geometry1, geometry2)
+  const rotated = rotate([0, 0, TAU / 4], junk, geometry1, geometry2)
 
   t.is(rotated[0], junk)
 

package/src/operations/transforms/transform.js

@@ -12,7 +12,7 @@ const path2 = require('../../geometries/path2')
  * @alias module:modeling/transforms.transform
  *
  * @example
- * const newsphere = transform(mat4.rotateX(Math.PI/4), sphere())
+ * const newsphere = transform(mat4.rotateX(TAU / 8), sphere())
  */
 const transform = (matrix, ...objects) => {
   // TODO how to check that the matrix is REAL?

package/src/primitives/arc.js

@@ -1,4 +1,4 @@
-const { EPS } = require('../maths/constants')
+const { EPS, TAU } = require('../maths/constants')
 
 const vec2 = require('../maths/vec2')
 
@@ -12,7 +12,7 @@ const { isGT, isGTE, isNumberArray } = require('./commonChecks')
  * @param {Array} [options.center=[0,0]] - center of arc
  * @param {Number} [options.radius=1] - radius of arc
  * @param {Number} [options.startAngle=0] - starting angle of the arc, in radians
- * @param {Number} [options.endAngle=Math.PI*2] - ending angle of the arc, in radians
+ * @param {Number} [options.endAngle=TAU] - ending angle of the arc, in radians
  * @param {Number} [options.segments=32] - number of segments to create per full rotation
  * @param {Boolean} [options.makeTangent=false] - adds line segments at both ends of the arc to ensure that the gradients at the edges are tangent
  * @returns {path2} new 2D path
@@ -23,7 +23,7 @@ const arc = (options) => {
     center: [0, 0],
     radius: 1,
     startAngle: 0,
-    endAngle: (Math.PI * 2),
+    endAngle: TAU,
     makeTangent: false,
     segments: 32
   }
@@ -35,15 +35,15 @@ const arc = (options) => {
   if (!isGTE(endAngle, 0)) throw new Error('endAngle must be positive')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
 
-  startAngle = startAngle % (Math.PI * 2)
-  endAngle = endAngle % (Math.PI * 2)
+  startAngle = startAngle % TAU
+  endAngle = endAngle % TAU
 
-  let rotation = (Math.PI * 2)
+  let rotation = TAU
   if (startAngle < endAngle) {
     rotation = endAngle - startAngle
   }
   if (startAngle > endAngle) {
-    rotation = endAngle + ((Math.PI * 2) - startAngle)
+    rotation = endAngle + (TAU - startAngle)
   }
 
   const minangle = Math.acos(((radius * radius) + (radius * radius) - (EPS * EPS)) / (2 * radius * radius))
@@ -59,7 +59,7 @@ const arc = (options) => {
     pointArray.push(point)
   } else {
     // note: add one additional step to acheive full rotation
-    const numsteps = Math.max(1, Math.floor(segments * (rotation / (Math.PI * 2)))) + 1
+    const numsteps = Math.max(1, Math.floor(segments * (rotation / TAU))) + 1
     let edgestepsize = numsteps * 0.5 / rotation // step size for half a degree
     if (edgestepsize > 0.25) edgestepsize = 0.25
 

package/src/primitives/arc.test.js

@@ -1,11 +1,12 @@
 const test = require('ava')
 
-const { arc } = require('./index')
-
+const { TAU } = require('../maths/constants')
 const path2 = require('../geometries/path2')
 
 const comparePoints = require('../../test/helpers/comparePoints')
 
+const { arc } = require('./index')
+
 test('arc (defaults)', (t) => {
   const geometry = arc()
   const obs = path2.toPoints(geometry)
@@ -86,7 +87,7 @@ test('arc (options)', (t) => {
     [0.9350162426854147, -0.35460488704253595],
     [1, -2.4492935982947064e-16]
   ]
-  geometry = arc({ startAngle: Math.PI / 2, segments: 16 })
+  geometry = arc({ startAngle: TAU / 4, segments: 16 })
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
@@ -102,7 +103,7 @@ test('arc (options)', (t) => {
     [0.30901699437494745, 0.9510565162951535],
     [6.123233995736766e-17, 1]
   ]
-  geometry = arc({ endAngle: Math.PI / 2, segments: 16 })
+  geometry = arc({ endAngle: TAU / 4, segments: 16 })
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
@@ -167,7 +168,7 @@ test('arc (rotations)', (t) => {
     [-0.9510565162951535, 0.3090169943749475],
     [-1, 1.2246467991473532e-16]
   ]
-  let geometry = arc({ startAngle: Math.PI / 2, endAngle: Math.PI, segments: 16 })
+  let geometry = arc({ startAngle: TAU / 4, endAngle: TAU / 2, segments: 16 })
   let obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
@@ -186,7 +187,7 @@ test('arc (rotations)', (t) => {
     [0.9396926207859084, -0.3420201433256686],
     [1, -2.4492935982947064e-16]
   ]
-  geometry = arc({ startAngle: Math.PI, endAngle: Math.PI * 2, segments: 16 })
+  geometry = arc({ startAngle: TAU / 2, endAngle: TAU, segments: 16 })
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
@@ -205,7 +206,7 @@ test('arc (rotations)', (t) => {
     [0.34202014332566866, 0.9396926207859084],
     [3.061616997868383e-16, 1]
   ]
-  geometry = arc({ startAngle: Math.PI * 2 * 0.75, endAngle: Math.PI / 2, segments: 16 })
+  geometry = arc({ startAngle: TAU * 0.75, endAngle: TAU / 4, segments: 16 })
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))
@@ -213,7 +214,7 @@ test('arc (rotations)', (t) => {
   t.true(comparePoints(obs, exp))
 
   exp = [[-1.8369701987210297e-16, -1]]
-  geometry = arc({ startAngle: Math.PI * 2 * 0.75, endAngle: 270.000000005 * 0.017453292519943295, segments: 16 })
+  geometry = arc({ startAngle: TAU * 0.75, endAngle: 270.000000005 * 0.017453292519943295, segments: 16 })
   obs = path2.toPoints(geometry)
 
   t.notThrows(() => path2.validate(geometry))

package/src/primitives/circle.js

@@ -1,3 +1,5 @@
+const { TAU } = require('../maths/constants')
+
 const ellipse = require('./ellipse')
 
 const { isGT } = require('./commonChecks')
@@ -9,7 +11,7 @@ const { isGT } = require('./commonChecks')
  * @param {Array} [options.center=[0,0]] - center of circle
  * @param {Number} [options.radius=1] - radius of circle
  * @param {Number} [options.startAngle=0] - start angle of circle, in radians
- * @param {Number} [options.endAngle=(Math.PI * 2)] - end angle of circle, in radians
+ * @param {Number} [options.endAngle=TAU] - end angle of circle, in radians
  * @param {Number} [options.segments=32] - number of segments to create per full rotation
  * @returns {geom2} new 2D geometry
  * @alias module:modeling/primitives.circle
@@ -21,7 +23,7 @@ const circle = (options) => {
     center: [0, 0],
     radius: 1,
     startAngle: 0,
-    endAngle: (Math.PI * 2),
+    endAngle: TAU,
     segments: 32
   }
   let { center, radius, startAngle, endAngle, segments } = Object.assign({}, defaults, options)

package/src/primitives/circle.test.js

@@ -1,11 +1,12 @@
 const test = require('ava')
 
-const { circle } = require('./index')
-
+const { TAU } = require('../maths/constants')
 const geom2 = require('../geometries/geom2')
 
 const comparePoints = require('../../test/helpers/comparePoints')
 
+const { circle } = require('./index')
+
 test('circle (defaults)', (t) => {
   const geometry = circle()
   const pts = geom2.toPoints(geometry)
@@ -84,7 +85,7 @@ test('circle (options)', (t) => {
   t.true(comparePoints(pts, exp))
 
   // test startAngle
-  geometry = circle({ radius: 3.5, startAngle: Math.PI / 2, segments: 16 })
+  geometry = circle({ radius: 3.5, startAngle: TAU / 4, segments: 16 })
   pts = geom2.toPoints(geometry)
   exp = [
     [0, 3.5],
@@ -108,7 +109,7 @@ test('circle (options)', (t) => {
   t.true(comparePoints(pts, exp))
 
   // test endAngle
-  geometry = circle({ radius: 3.5, endAngle: Math.PI / 2, segments: 16 })
+  geometry = circle({ radius: 3.5, endAngle: TAU / 4, segments: 16 })
   pts = geom2.toPoints(geometry)
   exp = [
     [3.5, 0],
@@ -124,7 +125,7 @@ test('circle (options)', (t) => {
   t.true(comparePoints(pts, exp))
 
   // test full rotation with non-zero startAngle
-  geometry = circle({ startAngle: 1, endAngle: 1 + 2 * Math.PI })
+  geometry = circle({ startAngle: 1, endAngle: 1 + TAU })
   pts = geom2.toPoints(geometry)
 
   t.notThrows(() => geom2.validate(geometry))

package/src/primitives/cylinderElliptic.js

@@ -1,4 +1,4 @@
-const { EPS } = require('../maths/constants')
+const { EPS, TAU } = require('../maths/constants')
 
 const vec3 = require('../maths/vec3')
 
@@ -17,7 +17,7 @@ const { isGT, isGTE, isNumberArray } = require('./commonChecks')
  * @param {Array} [options.startRadius=[1,1]] - radius of rounded start, must be two dimensional array
  * @param {Number} [options.startAngle=0] - start angle of cylinder, in radians
  * @param {Array} [options.endRadius=[1,1]] - radius of rounded end, must be two dimensional array
- * @param {Number} [options.endAngle=(Math.PI * 2)] - end angle of cylinder, in radians
+ * @param {Number} [options.endAngle=TAU] - end angle of cylinder, in radians
  * @param {Number} [options.segments=32] - number of segments to create per full rotation
  * @returns {geom3} new geometry
  * @alias module:modeling/primitives.cylinderElliptic
@@ -32,7 +32,7 @@ const cylinderElliptic = (options) => {
     startRadius: [1, 1],
     startAngle: 0,
     endRadius: [1, 1],
-    endAngle: (Math.PI * 2),
+    endAngle: TAU,
     segments: 32
   }
   let { center, height, startRadius, startAngle, endRadius, endAngle, segments } = Object.assign({}, defaults, options)
@@ -48,15 +48,15 @@ const cylinderElliptic = (options) => {
   if (!isGTE(endAngle, 0)) throw new Error('endAngle must be positive')
   if (!isGTE(segments, 4)) throw new Error('segments must be four or more')
 
-  startAngle = startAngle % (Math.PI * 2)
-  endAngle = endAngle % (Math.PI * 2)
+  startAngle = startAngle % TAU
+  endAngle = endAngle % TAU
 
-  let rotation = (Math.PI * 2)
+  let rotation = TAU
   if (startAngle < endAngle) {
     rotation = endAngle - startAngle
   }
   if (startAngle > endAngle) {
-    rotation = endAngle + ((Math.PI * 2) - startAngle)
+    rotation = endAngle + (TAU - startAngle)
   }
 
   const minradius = Math.min(startRadius[0], startRadius[1], endRadius[0], endRadius[1])
@@ -64,7 +64,7 @@ const cylinderElliptic = (options) => {
                             (2 * minradius * minradius))
   if (rotation < minangle) throw new Error('startAngle and endAngle do not define a significant rotation')
 
-  const slices = Math.floor(segments * (rotation / (Math.PI * 2)))
+  const slices = Math.floor(segments * (rotation / TAU))
 
   const start = vec3.fromValues(0, 0, -(height / 2))
   const end = vec3.fromValues(0, 0, height / 2)
@@ -97,8 +97,8 @@ const cylinderElliptic = (options) => {
   for (let i = 0; i < slices; i++) {
     const t0 = i / slices
     let t1 = (i + 1) / slices
-    // fix rounding error when rotating 2 * PI radians
-    if (rotation === 2 * Math.PI && i === slices - 1) t1 = 0
+    // fix rounding error when rotating TAU radians
+    if (rotation === TAU && i === slices - 1) t1 = 0
 
     if (endRadius[0] === startRadius[0] && endRadius[1] === startRadius[1]) {
       polygons.push(fromPoints(start, point(0, t1, endRadius), point(0, t0, endRadius)))
@@ -119,7 +119,7 @@ const cylinderElliptic = (options) => {
       }
     }
   }
-  if (rotation < (Math.PI * 2)) {
+  if (rotation < TAU) {
     polygons.push(fromPoints(start, point(0, 0, startRadius), end))
     polygons.push(fromPoints(point(0, 0, startRadius), point(1, 0, endRadius), end))
     polygons.push(fromPoints(start, end, point(0, 1, startRadius)))

package/src/primitives/cylinderElliptic.test.js

@@ -1,5 +1,6 @@
 const test = require('ava')
 
+const { TAU } = require('../maths/constants')
 const geom3 = require('../geometries/geom3')
 
 const { cylinderElliptic } = require('./index')
@@ -132,14 +133,14 @@ test('cylinderElliptic (options)', (t) => {
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // test startAngle and endAngle
-  obs = cylinderElliptic({ startRadius: [1, 2], endRadius: [2, 1], startAngle: Math.PI / 2, endAngle: Math.PI * 2 * 0.75, segments: 12 })
+  obs = cylinderElliptic({ startRadius: [1, 2], endRadius: [2, 1], startAngle: TAU / 4, endAngle: TAU * 0.75, segments: 12 })
   pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 28)
 
   // test startAngle and endAngle
-  obs = cylinderElliptic({ startAngle: 1, endAngle: 1 + 2 * Math.PI })
+  obs = cylinderElliptic({ startAngle: 1, endAngle: 1 + TAU })
   pts = geom3.toPoints(obs)
 
   t.notThrows(() => geom3.validate(obs))

package/src/primitives/ellipse.js

@@ -1,4 +1,4 @@
-const { EPS } = require('../maths/constants')
+const { EPS, TAU } = require('../maths/constants')
 
 const vec2 = require('../maths/vec2')
 
@@ -15,7 +15,7 @@ const { isGTE, isNumberArray } = require('./commonChecks')
  * @param {Array} [options.center=[0,0]] - center of ellipse
  * @param {Array} [options.radius=[1,1]] - radius of ellipse, along X and Y
  * @param {Number} [options.startAngle=0] - start angle of ellipse, in radians
- * @param {Number} [options.endAngle=(Math.PI * 2)] - end angle of ellipse, in radians
+ * @param {Number} [options.endAngle=TAU] - end angle of ellipse, in radians
  * @param {Number} [options.segments=32] - number of segments to create per full rotation
  * @returns {geom2} new 2D geometry
  * @alias module:modeling/primitives.ellipse
@@ -27,7 +27,7 @@ const ellipse = (options) => {
     center: [0, 0],
     radius: [1, 1],
     startAngle: 0,
-    endAngle: (Math.PI * 2),
+    endAngle: TAU,
     segments: 32
   }
   let { center, radius, startAngle, endAngle, segments } = Object.assign({}, defaults, options)
@@ -39,15 +39,15 @@ const ellipse = (options) => {
   if (!isGTE(endAngle, 0)) throw new Error('endAngle must be positive')
   if (!isGTE(segments, 3)) throw new Error('segments must be three or more')
 
-  startAngle = startAngle % (Math.PI * 2)
-  endAngle = endAngle % (Math.PI * 2)
+  startAngle = startAngle % TAU
+  endAngle = endAngle % TAU
 
-  let rotation = (Math.PI * 2)
+  let rotation = TAU
   if (startAngle < endAngle) {
     rotation = endAngle - startAngle
   }
   if (startAngle > endAngle) {
-    rotation = endAngle + ((Math.PI * 2) - startAngle)
+    rotation = endAngle + (TAU - startAngle)
   }
 
   const minradius = Math.min(radius[0], radius[1])
@@ -55,20 +55,20 @@ const ellipse = (options) => {
                             (2 * minradius * minradius))
   if (rotation < minangle) throw new Error('startAngle and endAngle do not define a significant rotation')
 
-  segments = Math.floor(segments * (rotation / (Math.PI * 2)))
+  segments = Math.floor(segments * (rotation / TAU))
 
   const centerv = vec2.clone(center)
   const step = rotation / segments // radians per segment
 
   const points = []
-  segments = (rotation < Math.PI * 2) ? segments + 1 : segments
+  segments = (rotation < TAU) ? segments + 1 : segments
   for (let i = 0; i < segments; i++) {
     const angle = (step * i) + startAngle
     const point = vec2.fromValues(radius[0] * cos(angle), radius[1] * sin(angle))
     vec2.add(point, centerv, point)
     points.push(point)
   }
-  if (rotation < Math.PI * 2) points.push(centerv)
+  if (rotation < TAU) points.push(centerv)
   return geom2.fromPoints(points)
 }
 

package/src/primitives/ellipse.test.js

@@ -1,11 +1,12 @@
 const test = require('ava')
 
-const { ellipse } = require('./index')
-
+const { TAU } = require('../maths/constants')
 const geom2 = require('../geometries/geom2')
 
 const comparePoints = require('../../test/helpers/comparePoints')
 
+const { ellipse } = require('./index')
+
 test('ellipse (defaults)', (t) => {
   const geometry = ellipse()
   const obs = geom2.toPoints(geometry)
@@ -84,7 +85,7 @@ test('ellipse (options)', (t) => {
   t.true(comparePoints(obs, exp))
 
   // test startAngle
-  geometry = ellipse({ radius: [3, 5], startAngle: Math.PI / 2, segments: 16 })
+  geometry = ellipse({ radius: [3, 5], startAngle: TAU / 4, segments: 16 })
   obs = geom2.toPoints(geometry)
   exp = [
     [0, 5],
@@ -108,7 +109,7 @@ test('ellipse (options)', (t) => {
   t.true(comparePoints(obs, exp))
 
   // test endAngle
-  geometry = ellipse({ radius: [3, 5], endAngle: Math.PI / 2, segments: 16 })
+  geometry = ellipse({ radius: [3, 5], endAngle: TAU / 4, segments: 16 })
   obs = geom2.toPoints(geometry)
   exp = [
     [3, 0],
@@ -124,7 +125,7 @@ test('ellipse (options)', (t) => {
   t.true(comparePoints(obs, exp))
 
   // test full rotation with non-zero startAngle
-  geometry = ellipse({ startAngle: 1, endAngle: 1 + 2 * Math.PI })
+  geometry = ellipse({ startAngle: 1, endAngle: 1 + TAU })
   obs = geom2.toPoints(geometry)
 
   t.notThrows(() => geom2.validate(geometry))

package/src/primitives/ellipsoid.js

@@ -1,3 +1,4 @@
+const { TAU } = require('../maths/constants')
 const vec3 = require('../maths/vec3')
 
 const geom3 = require('../geometries/geom3')
@@ -44,12 +45,12 @@ const ellipsoid = (options) => {
   const p1 = vec3.create()
   const p2 = vec3.create()
   for (let slice1 = 0; slice1 <= segments; slice1++) {
-    const angle = 2 * Math.PI * slice1 / segments
+    const angle = TAU * slice1 / segments
     const cylinderpoint = vec3.add(vec3.create(), vec3.scale(p1, xvector, cos(angle)), vec3.scale(p2, yvector, sin(angle)))
     if (slice1 > 0) {
       let prevcospitch, prevsinpitch
       for (let slice2 = 0; slice2 <= qsegments; slice2++) {
-        const pitch = 0.5 * Math.PI * slice2 / qsegments
+        const pitch = TAU / 4 * slice2 / qsegments
         const cospitch = cos(pitch)
         const sinpitch = sin(pitch)
         if (slice2 > 0) {

package/src/primitives/roundedCuboid.js

@@ -1,4 +1,4 @@
-const { EPS } = require('../maths/constants')
+const { EPS, TAU } = require('../maths/constants')
 
 const vec2 = require('../maths/vec2')
 const vec3 = require('../maths/vec3')
@@ -11,7 +11,7 @@ const { sin, cos } = require('../maths/utils/trigonometry')
 const { isGT, isGTE, isNumberArray } = require('./commonChecks')
 
 const createCorners = (center, size, radius, segments, slice, positive) => {
-  const pitch = (Math.PI / 2) * slice / segments
+  const pitch = (TAU / 4) * slice / segments
   const cospitch = cos(pitch)
   const sinpitch = sin(pitch)
 
@@ -31,16 +31,16 @@ const createCorners = (center, size, radius, segments, slice, positive) => {
   const corner2Points = []
   const corner3Points = []
   for (let i = 0; i <= layersegments; i++) {
-    const radians = layersegments > 0 ? Math.PI / 2 * i / layersegments : 0
+    const radians = layersegments > 0 ? TAU / 4 * i / layersegments : 0
     const point2d = vec2.fromAngleRadians(vec2.create(), radians)
     vec2.scale(point2d, point2d, layerradius)
     const point3d = vec3.fromVec2(vec3.create(), point2d)
     corner0Points.push(vec3.add(vec3.create(), corner0, point3d))
-    vec3.rotateZ(point3d, point3d, [0, 0, 0], Math.PI / 2)
+    vec3.rotateZ(point3d, point3d, [0, 0, 0], TAU / 4)
     corner1Points.push(vec3.add(vec3.create(), corner1, point3d))
-    vec3.rotateZ(point3d, point3d, [0, 0, 0], Math.PI / 2)
+    vec3.rotateZ(point3d, point3d, [0, 0, 0], TAU / 4)
     corner2Points.push(vec3.add(vec3.create(), corner2, point3d))
-    vec3.rotateZ(point3d, point3d, [0, 0, 0], Math.PI / 2)
+    vec3.rotateZ(point3d, point3d, [0, 0, 0], TAU / 4)
     corner3Points.push(vec3.add(vec3.create(), corner3, point3d))
   }
   if (!positive) {

package/src/primitives/roundedCylinder.js

@@ -1,4 +1,4 @@
-const { EPS } = require('../maths/constants')
+const { EPS, TAU } = require('../maths/constants')
 
 const vec3 = require('../maths/vec3')
 
@@ -74,7 +74,7 @@ const roundedCylinder = (options) => {
   const v2 = vec3.create()
   let prevcylinderpoint
   for (let slice1 = 0; slice1 <= segments; slice1++) {
-    const angle = 2 * Math.PI * slice1 / segments
+    const angle = TAU * slice1 / segments
     const cylinderpoint = vec3.add(vec3.create(), vec3.scale(v1, xvector, cos(angle)), vec3.scale(v2, yvector, sin(angle)))
     if (slice1 > 0) {
       // cylinder wall
@@ -87,7 +87,7 @@ const roundedCylinder = (options) => {
 
       let prevcospitch, prevsinpitch
       for (let slice2 = 0; slice2 <= qsegments; slice2++) {
-        const pitch = 0.5 * Math.PI * slice2 / qsegments
+        const pitch = TAU / 4 * slice2 / qsegments
         const cospitch = cos(pitch)
         const sinpitch = sin(pitch)
         if (slice2 > 0) {

package/src/primitives/roundedRectangle.js

@@ -1,4 +1,4 @@
-const { EPS } = require('../maths/constants')
+const { EPS, TAU } = require('../maths/constants')
 
 const vec2 = require('../maths/vec2')
 
@@ -51,15 +51,15 @@ const roundedRectangle = (options) => {
   const corner2Points = []
   const corner3Points = []
   for (let i = 0; i <= cornersegments; i++) {
-    const radians = Math.PI / 2 * i / cornersegments
+    const radians = TAU / 4 * i / cornersegments
     const point = vec2.fromAngleRadians(vec2.create(), radians)
     vec2.scale(point, point, roundRadius)
     corner0Points.push(vec2.add(vec2.create(), corner0, point))
-    vec2.rotate(point, point, vec2.create(), Math.PI / 2)
+    vec2.rotate(point, point, vec2.create(), TAU / 4)
     corner1Points.push(vec2.add(vec2.create(), corner1, point))
-    vec2.rotate(point, point, vec2.create(), Math.PI / 2)
+    vec2.rotate(point, point, vec2.create(), TAU / 4)
     corner2Points.push(vec2.add(vec2.create(), corner2, point))
-    vec2.rotate(point, point, vec2.create(), Math.PI / 2)
+    vec2.rotate(point, point, vec2.create(), TAU / 4)
     corner3Points.push(vec2.add(vec2.create(), corner3, point))
   }
 

package/src/primitives/star.js

@@ -1,3 +1,4 @@
+const { TAU } = require('../maths/constants')
 const vec2 = require('../maths/vec2')
 
 const geom2 = require('../geometries/geom2')
@@ -13,7 +14,7 @@ const getRadiusRatio = (vertices, density) => {
 }
 
 const getPoints = (vertices, radius, startAngle, center) => {
-  const a = (Math.PI * 2) / vertices
+  const a = TAU / vertices
 
   const points = []
   for (let i = 0; i < vertices; i++) {
@@ -63,7 +64,7 @@ const star = (options) => {
   vertices = Math.floor(vertices)
   density = Math.floor(density)
 
-  startAngle = startAngle % (Math.PI * 2)
+  startAngle = startAngle % TAU
 
   if (innerRadius === 0) {
     if (!isGTE(density, 2)) throw new Error('density must be two or more')

package/src/primitives/torus.js

@@ -1,3 +1,5 @@
+const { TAU } = require('../maths/constants')
+
 const extrudeRotate = require('../operations/extrusions/extrudeRotate')
 const { rotate } = require('../operations/transforms/rotate')
 const { translate } = require('../operations/transforms/translate')
@@ -14,7 +16,7 @@ const { isGT, isGTE } = require('./commonChecks')
  * @param {Integer} [options.innerSegments=32] - number of segments to create per rotation
  * @param {Integer} [options.outerSegments=32] - number of segments to create per rotation
  * @param {Integer} [options.innerRotation=0] - rotation of small (inner) circle in radians
- * @param {Number} [options.outerRotation=(PI * 2)] - rotation (outer) of the torus (RADIANS)
+ * @param {Number} [options.outerRotation=TAU] - rotation (outer) of the torus (RADIANS)
  * @param {Number} [options.startAngle=0] - start angle of the torus (RADIANS)
  * @returns {geom3} new 3D geometry
  * @alias module:modeling/primitives.torus
@@ -30,7 +32,7 @@ const torus = (options) => {
     outerSegments: 32,
     innerRotation: 0,
     startAngle: 0,
-    outerRotation: Math.PI * 2
+    outerRotation: TAU
   }
   const { innerRadius, innerSegments, outerRadius, outerSegments, innerRotation, startAngle, outerRotation } = Object.assign({}, defaults, options)