@jscad/modeling 3.0.2-alpha.0 → 3.0.4-alpha.0

package/src/geometries/slice/validate.js

@@ -6,13 +6,14 @@ import { isA } from './isA.js'
 
 /**
  * Determine if the given object is a valid slice.
+ *
  * Checks for valid data points.
  *
- * **If the geometry is not valid, an exception will be thrown with details of the geometry error.**
+ * **NOTE: If the geometry is not valid, an exception will be thrown with details of the geometry error.**
  *
  * @param {object} object - the object to interrogate
  * @throws {Error} error if the geometry is not valid
- * @alias module:modeling/geometries/slice.validate
+ * @alias module:modeling/slice.validate
  */
 export const validate = (object) => {
   if (!isA(object)) {

package/src/index.d.ts

@@ -10,6 +10,7 @@ export { degToRad, flatten, radiusToSegments, radToDeg } from './utils'
 export * as booleans from './operations/booleans'
 export * as extrusions from './operations/extrusions'
 export * as hulls from './operations/hulls'
+export * as minkowski from './operations/minkowski'
 export * as modifiers from './operations/modifiers'
 export * as offsets from './operations/offsets'
 export * as transforms from './operations/transforms'

package/src/index.js

@@ -1,3 +1,6 @@
+/**
+ * @module modeling
+ */
 export * from './colors/index.js'
 export * from './curves/index.js'
 export * from './geometries/index.js'
@@ -10,6 +13,7 @@ export { degToRad, flatten, radiusToSegments, radToDeg } from './utils/index.js'
 export * from './operations/booleans/index.js'
 export * from './operations/extrusions/index.js'
 export * from './operations/hulls/index.js'
+export * from './operations/minkowski/index.js'
 export * from './operations/modifiers/index.js'
 export * from './operations/offsets/index.js'
 export * from './operations/transforms/index.js'

package/src/maths/constants.js

@@ -1,19 +1,21 @@
 /**
  * Epsilon used during determination of near zero distances.
- * This should be 1 / spacialResolution.
- * @default
+ *
+ * @constant
  * @alias module:modeling/maths.EPS
  * @example
- * const { EPS } = maths.constants
+ * import { EPS } from '@jscad/modeling'
  */
 export const EPS = 1e-5
 
 /**
  * Smaller epsilon used for measuring near zero distances.
- * @default
+ *
+ * @constant
+ * @static
  * @alias module:modeling/maths.NEPS
  * @example
- * const { NEPS } = maths.constants
+ * import { NEPS } from '@jscad/modeling'
  */
 export const NEPS = 1e-13
 // NEPS is derived from a series of tests to determine the optimal precision
@@ -22,10 +24,12 @@ export const NEPS = 1e-13
 
 /**
  * The TAU property represents the ratio of the circumference of a circle to its radius.
+ *
  * Approximately 6.28318530717958647692
+ *
+ * @constant
  * @alias module:modeling/maths.TAU
- * @default
  * @example
- * const { TAU } = maths.constants
+ * import { TAU } from '@jscad/modeling'
  */
 export const TAU = Math.PI * 2

package/src/maths/index.js

@@ -1,10 +1,11 @@
 /**
  * Maths are computational units for fundamental Euclidean geometry. All maths operate upon array data structures.
+ *
  * Note: Maths data structures are considered immutable, so never change the contents directly.
  * @see Most computations are based upon the glMatrix library (glmatrix.net)
  * @module modeling/maths
  * @example
- * import { constants, line2, line3, mat4, plane, utils, vec2, vec3, vec4 } from '@jscad/modeling'
+ * import { TAU, line2, line3, mat4, plane, utils, vec2, vec3, vec4 } from '@jscad/modeling'
  */
 export * from './constants.js'
 export * as line2 from './line2/index.js'

package/src/maths/mat4/isOnlyTransformScale.js

@@ -17,7 +17,7 @@ export const isOnlyTransformScale = (matrix) => (
   matrix[15] === 1
 )
 
-/**
+/*
  * @param {number} num
  * @returns {boolean}
  */

package/src/operations/booleans/index.js

@@ -1,8 +1,10 @@
 /**
  * All shapes (primitives or the results of operations) can be passed to boolean functions
  * to perform logical operations, e.g. remove a hole from a board.
+ *
  * In all cases, the function returns the results, and never changes the original shapes.
  * @module modeling/booleans
+ *
  * @example
  * import { intersect, scission, subtract, union } from '@jscad/modeling'
  */

package/src/operations/booleans/intersect.js

@@ -6,7 +6,6 @@ import * as geom3 from '../../geometries/geom3/index.js'
 
 import { intersectGeom2 } from './intersectGeom2.js'
 import { intersectGeom3 } from './intersectGeom3.js'
-
 /**
  * Return a new geometry representing space in both the first geometry and
  * all subsequent geometries.

package/src/operations/booleans/intersectGeom3.test.js

@@ -17,7 +17,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
 
   // intersect of one object
   const result1 = intersect(geometry1)
-  let obs = geom3.toPoints(result1)
+  let obs = geom3.toVertices(result1)
   let exp = [
     [[2, 0, 0], [1.4142135623730951, -1.414213562373095, 0],
       [1.0000000000000002, -1, -1.414213562373095], [1.4142135623730951, 0, -1.414213562373095]],
@@ -78,7 +78,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   const geometry2 = center({ relativeTo: [10, 10, 10] }, cuboid({ size: [4, 4, 4] }))
 
   const result2 = intersect(geometry1, geometry2)
-  obs = geom3.toPoints(result2)
+  obs = geom3.toVertices(result2)
   t.notThrows(() => geom3.validate(result2))
   t.is(measureArea(result2), 0)
   t.is(measureVolume(result2), 0)
@@ -88,7 +88,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
   const geometry3 = cuboid({ size: [18, 18, 18] })
 
   const result3 = intersect(geometry2, geometry3)
-  obs = geom3.toPoints(result3)
+  obs = geom3.toVertices(result3)
 
   // the order changes based on the best plane chosen in Node.js
   exp = [
@@ -108,7 +108,7 @@ test('intersect: intersect of one or more geom3 objects produces expected geomet
 
   // intersect of two completely overlapping objects
   const result4 = intersect(geometry1, geometry3)
-  obs = geom3.toPoints(result4)
+  obs = geom3.toVertices(result4)
   t.notThrows.skip(() => geom3.validate(result4))
   t.is(measureArea(result4), 44.053756306589825)
   t.is(measureVolume(result4), 25.751611331979678)

package/src/operations/booleans/scission.js

@@ -1,7 +1,6 @@
 import * as geom3 from '../../geometries/geom3/index.js'
 
 import { scissionGeom3 } from './scissionGeom3.js'
-
 /**
  * Scission (divide) the given geometry into the component pieces.
  *

package/src/operations/booleans/subtractGeom3.test.js

@@ -17,7 +17,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
 
   // subtract of one object
   const result1 = subtract(geometry1)
-  let obs = geom3.toPoints(result1)
+  let obs = geom3.toVertices(result1)
   let exp = [
     [[2, 0, 0], [1.4142135623730951, -1.414213562373095, 0],
       [1.0000000000000002, -1, -1.414213562373095], [1.4142135623730951, 0, -1.414213562373095]],
@@ -78,7 +78,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
   const geometry2 = center({ relativeTo: [10, 10, 10] }, cuboid({ size: [4, 4, 4] }))
 
   const result2 = subtract(geometry1, geometry2)
-  obs = geom3.toPoints(result2)
+  obs = geom3.toVertices(result2)
   t.notThrows.skip(() => geom3.validate(result2))
   t.is(measureArea(result2), 44.053756306589825)
   t.is(measureVolume(result2), 25.751611331979678)
@@ -88,7 +88,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
   const geometry3 = cuboid({ size: [18, 18, 18] })
 
   const result3 = subtract(geometry2, geometry3)
-  obs = geom3.toPoints(result3)
+  obs = geom3.toVertices(result3)
   exp = [
     [[12, 8, 8], [12, 12, 8], [12, 12, 12], [12, 8, 12]],
     [[8, 12, 8], [8, 12, 12], [12, 12, 12], [12, 12, 8]],
@@ -111,7 +111,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
 
   // subtract of two completely overlapping objects
   const result4 = subtract(geometry1, geometry3)
-  obs = geom3.toPoints(result4)
+  obs = geom3.toVertices(result4)
   t.notThrows(() => geom3.validate(result4))
   t.is(measureArea(result4), 0)
   t.is(measureVolume(result4), 0)

package/src/operations/booleans/trees/splitLineSegmentByPlane.js

@@ -4,10 +4,7 @@ export const splitLineSegmentByPlane = (plane, p1, p2) => {
   const direction = vec3.subtract(vec3.create(), p2, p1)
   let lambda = (plane[3] - vec3.dot(plane, p1)) / vec3.dot(plane, direction)
 
-  Number.isNaN(lambda) ? lambda = 0
-    : lambda > 1 ? lambda = 1
-      : lambda < 0 ? lambda = 0
-        : lambda
+  Number.isNaN(lambda) ? lambda = 0 : lambda > 1 ? lambda = 1 : lambda < 0 ? lambda = 0 : lambda
 
   vec3.scale(direction, direction, lambda)
   vec3.add(direction, p1, direction)

package/src/operations/booleans/trees/splitPolygonByPlane.test.js

@@ -0,0 +1,138 @@
+import test from 'ava'
+
+import { poly3 } from '../../../geometries/index.js'
+import { plane } from '../../../maths/index.js'
+
+import { splitPolygonByPlane } from './splitPolygonByPlane.js'
+
+test('splitPolygonByPlane: test coplanar-front polygon returns type 0.', (t) => {
+  // Polygon in XY plane at z=0
+  const polygon = poly3.create([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]])
+  // Plane is also XY plane at z=0, normal pointing up
+  const splane = plane.fromPoints(plane.create(), [0, 0, 0], [1, 0, 0], [1, 1, 0])
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 0) // coplanar-front
+  t.is(result.front, undefined)
+  t.is(result.back, undefined)
+})
+
+test('splitPolygonByPlane: test polygon entirely in front returns type 2.', (t) => {
+  // Polygon at z=5
+  const polygon = poly3.create([[0, 0, 5], [1, 0, 5], [1, 1, 5], [0, 1, 5]])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0] // normal (0,0,1), w=0
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 2) // front
+  t.is(result.front, undefined)
+  t.is(result.back, undefined)
+})
+
+test('splitPolygonByPlane: test polygon entirely in back returns type 3.', (t) => {
+  // Polygon at z=-5
+  const polygon = poly3.create([[0, 0, -5], [1, 0, -5], [1, 1, -5], [0, 1, -5]])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0] // normal (0,0,1), w=0
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 3) // back
+  t.is(result.front, undefined)
+  t.is(result.back, undefined)
+})
+
+test('splitPolygonByPlane: test spanning polygon returns type 4 with front and back.', (t) => {
+  // Polygon spanning z=0 plane (from z=-1 to z=1)
+  const polygon = poly3.create([[0, 0, -1], [1, 0, -1], [1, 0, 1], [0, 0, 1]])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0] // normal (0,0,1), w=0
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 4) // spanning
+  t.not(result.front, undefined)
+  t.not(result.back, undefined)
+
+  // Front polygon should have z >= 0
+  const frontPoints = poly3.toVertices(result.front)
+  t.true(frontPoints.length >= 3)
+  frontPoints.forEach((p) => {
+    t.true(p[2] >= -1e-5, `front point z=${p[2]} should be >= 0`)
+  })
+
+  // Back polygon should have z <= 0
+  const backPoints = poly3.toVertices(result.back)
+  t.true(backPoints.length >= 3)
+  backPoints.forEach((p) => {
+    t.true(p[2] <= 1e-5, `back point z=${p[2]} should be <= 0`)
+  })
+})
+
+test('splitPolygonByPlane: test duplicate vertices are removed from split result.', (t) => {
+  // Create a polygon that when split would produce duplicate vertices
+  // Triangle with one vertex on the plane
+  const polygon = poly3.create([[0, 0, 0], [1, 0, 1], [1, 0, -1]])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0]
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 4) // spanning
+
+  // Verify no consecutive duplicate vertices in front
+  if (result.front) {
+    const frontPoints = poly3.toVertices(result.front)
+    for (let i = 0; i < frontPoints.length; i++) {
+      const curr = frontPoints[i]
+      const next = frontPoints[(i + 1) % frontPoints.length]
+      const dx = curr[0] - next[0]
+      const dy = curr[1] - next[1]
+      const dz = curr[2] - next[2]
+      const distSq = dx * dx + dy * dy + dz * dz
+      t.true(distSq > 1e-10, 'front polygon should not have duplicate consecutive vertices')
+    }
+  }
+
+  // Verify no consecutive duplicate vertices in back
+  if (result.back) {
+    const backPoints = poly3.toVertices(result.back)
+    for (let i = 0; i < backPoints.length; i++) {
+      const curr = backPoints[i]
+      const next = backPoints[(i + 1) % backPoints.length]
+      const dx = curr[0] - next[0]
+      const dy = curr[1] - next[1]
+      const dz = curr[2] - next[2]
+      const distSq = dx * dx + dy * dy + dz * dz
+      t.true(distSq > 1e-10, 'back polygon should not have duplicate consecutive vertices')
+    }
+  }
+})
+
+test('splitPolygonByPlane: test complex spanning polygon splits correctly.', (t) => {
+  // Hexagon spanning the XY plane
+  const polygon = poly3.create([
+    [1, 0, -1],
+    [0.5, 0.866, -1],
+    [-0.5, 0.866, 1],
+    [-1, 0, 1],
+    [-0.5, -0.866, 1],
+    [0.5, -0.866, -1]
+  ])
+  // Plane at z=0
+  const splane = [0, 0, 1, 0]
+
+  const result = {}
+  splitPolygonByPlane(result, splane, polygon)
+  t.is(result.type, 4) // spanning
+  t.not(result.front, undefined)
+  t.not(result.back, undefined)
+
+  // Both resulting polygons should be valid (at least 3 vertices)
+  const frontPoints = poly3.toVertices(result.front)
+  const backPoints = poly3.toVertices(result.back)
+  t.true(frontPoints.length >= 3, 'front polygon should have at least 3 vertices')
+  t.true(backPoints.length >= 3, 'back polygon should have at least 3 vertices')
+})

package/src/operations/booleans/unionGeom3.test.js

@@ -17,7 +17,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
 
   // union of one object
   const result1 = union(geometry1)
-  let obs = geom3.toPoints(result1)
+  let obs = geom3.toVertices(result1)
   let exp = [
     [[2, 0, 0], [1.4142135623730951, -1.414213562373095, 0],
       [1.0000000000000002, -1, -1.414213562373095], [1.4142135623730951, 0, -1.414213562373095]],
@@ -78,7 +78,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
   const geometry2 = center({ relativeTo: [10, 10, 10] }, cuboid({ size: [4, 4, 4] }))
 
   const result2 = union(geometry1, geometry2)
-  obs = geom3.toPoints(result2)
+  obs = geom3.toVertices(result2)
   t.notThrows.skip(() => geom3.validate(result2))
   t.is(measureArea(result2), 140.05375630658983)
   t.is(measureVolume(result2), 89.75161133197969)
@@ -88,7 +88,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
   const geometry3 = cuboid({ size: [18, 18, 18] })
 
   const result3 = union(geometry2, geometry3)
-  obs = geom3.toPoints(result3)
+  obs = geom3.toVertices(result3)
   exp = [
     [[12, 8, 8], [12, 12, 8], [12, 12, 12], [12, 8, 12]],
     [[8, 12, 8], [8, 12, 12], [12, 12, 12], [12, 12, 8]],
@@ -117,7 +117,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
 
   // union of two completely overlapping objects
   const result4 = union(geometry1, geometry3)
-  obs = geom3.toPoints(result4)
+  obs = geom3.toVertices(result4)
   exp = [
     [[-9, -9, -9], [-9, -9, 9], [-9, 9, 9], [-9, 9, -9]],
     [[9, -9, -9], [9, 9, -9], [9, 9, 9], [9, -9, 9]],
@@ -138,9 +138,44 @@ test('union of geom3 with rounding issues #137', (t) => {
   const geometry2 = center({ relativeTo: [0, 0, -4.400001] }, cuboid({ size: [44, 26, 1.8] })) // introduce precision error
 
   const result = union(geometry1, geometry2)
-  const pts = geom3.toPoints(result)
+  const pts = geom3.toVertices(result)
   t.notThrows(() => geom3.validate(result))
   t.is(measureArea(result), 3240.00014)
   t.is(measureVolume(result), 7779.201144000001)
   t.is(pts.length, 6) // number of polygons in union
 })
+
+// Test for push loop optimization: verify union works correctly with multiple geometries
+// This ensures the concat-to-push-loop optimization handles array merging properly
+test('union of geom3 with multiple overlapping geometries', (t) => {
+  // Create several overlapping cuboids to generate a complex union
+  const geometry1 = cuboid({ size: [10, 10, 10] })
+  const geometry2 = center({ relativeTo: [5, 0, 0] }, cuboid({ size: [10, 10, 10] }))
+  const geometry3 = center({ relativeTo: [0, 5, 0] }, cuboid({ size: [10, 10, 10] }))
+
+  // Union should work correctly with multiple geometries
+  const obs = union(geometry1, geometry2, geometry3)
+  const pts = geom3.toVertices(obs)
+
+  // Skip manifold validation - focus on testing polygon merging works correctly
+  // (CSG on overlapping boxes can produce non-manifold edges at coplanar faces)
+  // Should produce a merged geometry with polygons from all inputs
+  t.true(pts.length > 6) // more than a single cube
+})
+
+// Test for push loop optimization: verify non-overlapping geometries combine correctly
+test('union of multiple non-overlapping geom3 preserves all polygons', (t) => {
+  // Create multiple small cuboids that don't overlap
+  const cubes = []
+  for (let i = 0; i < 10; i++) {
+    cubes.push(center({ relativeTo: [i * 5, 0, 0] }, cuboid({ size: [2, 2, 2] })))
+  }
+
+  // Union all of them
+  const obs = union(...cubes)
+  const pts = geom3.toVertices(obs)
+
+  t.notThrows(() => geom3.validate(obs))
+  // Each cuboid has 6 faces, so 10 cuboids = 60 polygons
+  t.is(pts.length, 60)
+})

package/src/operations/extrusions/extrudeFromSlices.js

@@ -59,7 +59,7 @@ export const extrudeFromSlices = (options, base) => {
   let startSlice = null
   let endSlice = null
   let prevSlice = null
-  let polygons = []
+  const polygons = []
   for (let s = 0; s < numberOfSlices; s++) {
     // invoke the callback function to get the next slice
     // NOTE: callback can return null to skip the slice
@@ -71,7 +71,10 @@ export const extrudeFromSlices = (options, base) => {
       if (currentSlice.contours.length === 0) throw new Error('the callback function must return slices with one or more contours')
 
       if (prevSlice) {
-        polygons = polygons.concat(extrudeWalls(prevSlice, currentSlice))
+        const walls = extrudeWalls(prevSlice, currentSlice)
+        for (let i = 0; i < walls.length; i++) {
+          polygons.push(walls[i])
+        }
       }
 
       // save start and end slices for caps if necessary
@@ -85,17 +88,24 @@ export const extrudeFromSlices = (options, base) => {
   if (capEnd) {
     // create a cap at the end
     const endPolygons = slice.toPolygons(endSlice)
-    polygons = polygons.concat(endPolygons)
+    for (let i = 0; i < endPolygons.length; i++) {
+      polygons.push(endPolygons[i])
+    }
   }
   if (capStart) {
     // create a cap at the start
     const startPolygons = slice.toPolygons(startSlice).map(poly3.invert)
-    polygons = polygons.concat(startPolygons)
+    for (let i = 0; i < startPolygons.length; i++) {
+      polygons.push(startPolygons[i])
+    }
   }
   if (!capStart && !capEnd) {
     // create walls between end and start slices
     if (close && !slice.equals(endSlice, startSlice)) {
-      polygons = polygons.concat(extrudeWalls(endSlice, startSlice))
+      const walls = extrudeWalls(endSlice, startSlice)
+      for (let i = 0; i < walls.length; i++) {
+        polygons.push(walls[i])
+      }
     }
   }
   return geom3.create(polygons)

package/src/operations/extrusions/extrudeFromSlices.test.js

@@ -17,7 +17,7 @@ test('extrudeFromSlices (defaults)', (t) => {
   const geometry2 = square({ size: 20 })
 
   let geometry3 = extrudeFromSlices({ }, geometry2)
-  let pts = geom3.toPoints(geometry3)
+  let pts = geom3.toVertices(geometry3)
   const exp = [
     [[-10, -10, 0], [10, -10, 0], [10, -10, 1]],
     [[-10, -10, 0], [10, -10, 1], [-10, -10, 1]],
@@ -39,7 +39,7 @@ test('extrudeFromSlices (defaults)', (t) => {
 
   const poly2 = poly3.create([[-10, -10, 0], [10, -10, 0], [10, 10, 0], [-10, 10, 0]])
   geometry3 = extrudeFromSlices({ }, poly2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
 
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 880)
@@ -75,7 +75,7 @@ test('extrudeFromSlices (torus)', (t) => {
       }
     }, hex
   )
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 7070.694617452831)
   t.is(measureVolume(geometry3), 29393.876913398108)
@@ -96,7 +96,7 @@ test('extrudeFromSlices (same shape, changing dimensions)', (t) => {
       }
     }, base
   )
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   // expected to throw because capEnd is false (non-closed geometry)
   t.throws(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 53.70100297794013)
@@ -117,7 +117,7 @@ test('extrudeFromSlices (changing shape, changing dimensions)', (t) => {
       }
     }, base
   )
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   t.notThrows.skip(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 1965.8643589631802)
   t.is(measureVolume(geometry3), 5260.067107417433)
@@ -130,7 +130,7 @@ test('extrudeFromSlices (holes)', (t) => {
     [[-5, -5], [-5, 5], [5, 5], [5, -5]]
   ])
   const geometry3 = extrudeFromSlices({ }, geometry2)
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   const exp = [
     [[-10, 10, 0], [-10, -10, 0], [-10, -10, 1]],
     [[-10, 10, 0], [-10, -10, 1], [-10, 10, 1]],

package/src/operations/extrusions/extrudeLinear.test.js

@@ -18,7 +18,7 @@ test('extrudeLinear (defaults)', (t) => {
   const geometry2 = square({ size: 10 })
 
   const geometry3 = extrudeLinear({ }, geometry2)
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   const exp = [
     [[-5, -5, 0], [5, -5, 0], [5, -5, 1]],
     [[-5, -5, 0], [5, -5, 1], [-5, -5, 1]],
@@ -55,7 +55,7 @@ test('extrudeLinear (no twist)', (t) => {
   const geometry2 = square({ size: 10 })
 
   let geometry3 = extrudeLinear({ height: 15 }, geometry2)
-  let pts = geom3.toPoints(geometry3)
+  let pts = geom3.toVertices(geometry3)
   let exp = [
     [[-5, -5, 0], [5, -5, 0], [5, -5, 15]],
     [[-5, -5, 0], [5, -5, 15], [-5, -5, 15]],
@@ -77,7 +77,7 @@ test('extrudeLinear (no twist)', (t) => {
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: -15 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   exp = [
     [[-5, 5, 0], [5, 5, 0], [5, 5, -15]],
     [[-5, 5, 0], [5, 5, -15], [-5, 5, -15]],
@@ -103,7 +103,7 @@ test('extrudeLinear (twist)', (t) => {
   const geometry2 = square({ size: 10 })
 
   let geometry3 = extrudeLinear({ height: 15, twistAngle: -TAU / 8 }, geometry2)
-  let pts = geom3.toPoints(geometry3)
+  let pts = geom3.toVertices(geometry3)
   let exp = [
     [[-5, -5, 0], [5, -5, 0], [4.440892098500626e-16, -7.0710678118654755, 15]],
     [[-5, -5, 0], [4.440892098500626e-16, -7.0710678118654755, 15], [-7.0710678118654755, -4.440892098500626e-16, 15]],
@@ -133,7 +133,7 @@ test('extrudeLinear (twist)', (t) => {
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: 15, twistAngle: TAU / 4, twistSteps: 3 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   exp = [
     [[-5, -5, 0], [5, -5, 0], [6.830127018922193, -1.830127018922194, 5]],
     [[-5, -5, 0], [6.830127018922193, -1.830127018922194, 5], [-1.830127018922194, -6.830127018922193, 5]],
@@ -168,7 +168,7 @@ test('extrudeLinear (twist)', (t) => {
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeLinear({ height: 15, twistAngle: TAU / 2, twistSteps: 30 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 1091.9932843446968)
   t.is(measureVolume(geometry3), 1444.9967160503095)
@@ -181,7 +181,7 @@ test('extrudeLinear (holes)', (t) => {
     [[-2, -2], [-2, 2], [2, 2], [2, -2]]
   ])
   const geometry3 = extrudeLinear({ height: 15 }, geometry2)
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   const exp = [
     [[-5, 5, 0], [-5, -5, 0], [-5, -5, 15]],
     [[-5, 5, 0], [-5, -5, 15], [-5, 5, 15]],
@@ -227,7 +227,7 @@ test('extrudeLinear (path2)', (t) => {
   const geometry2 = path2.fromPoints({ closed: true }, [[6, 10], [0, 0], [12, 0]])
   const geometry3 = extrudeLinear({ height: 15 }, geometry2)
   t.notThrows(() => geom3.validate(geometry3))
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   const exp = [
     [[6, 10, 0], [0, 0, 0], [0, 0, 15]],
     [[6, 10, 0], [0, 0, 15], [6, 10, 15]],

package/src/operations/extrusions/extrudeRotate.js

@@ -110,13 +110,14 @@ export const extrudeRotate = (options, geometry) => {
   baseSlice = slice.reverse(baseSlice)
 
   const matrix = mat4.create()
+  const xRotationMatrix = mat4.fromXRotation(mat4.create(), TAU / 4) // compute once, reuse
   const createSlice = (progress, index, base) => {
     let Zrotation = rotationPerSlice * index + startAngle
     // fix rounding error when rotating TAU radians
     if (totalRotation === TAU && index === segments) {
       Zrotation = startAngle
     }
-    mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), mat4.fromXRotation(mat4.create(), TAU / 4))
+    mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), xRotationMatrix)
 
     return slice.transform(matrix, base)
   }