@jscad/modeling 2.5.2 → 2.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.5.2",
+  "version": "2.7.0",
   "description": "Constructive Solid Geometry (CSG) Library for JSCAD",
   "repository": "https://github.com/jscad/OpenJSCAD.org",
   "main": "src/index.js",
@@ -60,5 +60,5 @@
     "nyc": "15.1.0",
     "uglifyify": "5.0.2"
   },
-  "gitHead": "a761f641bb2ac6016dc4a02ef86ce279dd553d7c"
+  "gitHead": "fbc9b90f0ae02bea4e6e7b974c65e751c3858269"
 }

package/src/colors/colorize.js

@@ -6,13 +6,13 @@ const path2 = require('../geometries/path2')
 const poly3 = require('../geometries/poly3')
 
 const colorGeom2 = (color, object) => {
-  const newgeom2 = geom2.create(geom2.toSides(object))
+  const newgeom2 = geom2.clone(object)
   newgeom2.color = color
   return newgeom2
 }
 
 const colorGeom3 = (color, object) => {
-  const newgeom3 = geom3.create(geom3.toPolygons(object))
+  const newgeom3 = geom3.clone(object)
   newgeom3.color = color
   return newgeom3
 }
@@ -31,10 +31,9 @@ const colorPoly3 = (color, object) => {
 
 /**
  * Assign the given color to the given objects.
- * Note: The color should only be assigned after performing all operations.
  * @param {Array} color - RGBA color values, where each value is between 0 and 1.0
- * @param {Object|Array} objects - the objects of which to color
- * @return {Object|Array} new geometry, or list of new geometries with an additional attribute 'color'
+ * @param {Object|Array} objects - the objects of which to apply the given color
+ * @return {Object|Array} new object, or list of new objects with an additional attribute 'color'
  * @alias module:modeling/colors.colorize
  *
  * @example

package/src/colors/colorize.test.js

@@ -43,23 +43,30 @@ test('color (rgba on geometry)', (t) => {
   const obs = colorize([1, 1, 0.5, 0.8], obj0, obj1, obj2, obj3)
   t.is(obs.length, 4)
 
-  let exp = geom2.clone(obj0)
-  exp.color = [1, 1, 0.5, 0.8]
   t.not(obj0, obs[0])
-  t.deepEqual(obs[0], exp)
+  t.deepEqual(obs[0].color, [1, 1, 0.5, 0.8])
 
-  exp = geom3.clone(obj1)
-  exp.color = [1, 1, 0.5, 0.8]
   t.not(obj1, obs[1])
-  t.deepEqual(obs[1], exp)
+  t.deepEqual(obs[1].color, [1, 1, 0.5, 0.8])
 
-  exp = path2.clone(obj2)
-  exp.color = [1, 1, 0.5, 0.8]
   t.not(obj2, obs[2])
-  t.deepEqual(obs[2], exp)
+  t.deepEqual(obs[2].color, [1, 1, 0.5, 0.8])
 
-  exp = poly3.clone(obj3)
-  exp.color = [1, 1, 0.5, 0.8]
   t.not(obj3, obs[3])
-  t.deepEqual(obs[3], exp)
+  t.deepEqual(obs[3].color, [1, 1, 0.5, 0.8])
+})
+
+test('color (returns new object)', (t) => {
+  const obj0 = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
+  // const obj1 = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
+  // const obj2 = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
+  const obj3 = geom2.fromPoints([[0, 0], [1, 0], [0, 1]])
+
+  const obs = colorize([1, 1, 1, 0.8], obj0, obj3)
+  t.not(obj0, obs[0])
+  t.deepEqual(obs[0].color, [1, 1, 1, 0.8])
+  t.is(obj0.color, undefined)
+  t.not(obj3, obs[1])
+  t.deepEqual(obs[1].color, [1, 1, 1, 0.8])
+  t.is(obj3.color, undefined)
 })

package/src/geometries/geom2/applyTransforms.js

@@ -19,7 +19,7 @@ const applyTransforms = (geometry) => {
     const p1 = vec2.transform(vec2.create(), side[1], geometry.transforms)
     return [p0, p1]
   })
-  mat4.identity(geometry.transforms)
+  geometry.transforms = mat4.create()
   return geometry
 }
 

package/src/geometries/geom2/clone.js

@@ -1,19 +1,9 @@
-const mat4 = require('../../maths/mat4')
-const vec2 = require('../../maths/vec2')
-
-const create = require('./create')
-
 /**
- * Performs a deep clone of the given geometry.
+ * Performs a shallow clone of the given geometry.
  * @param {geom2} geometry - the geometry to clone
  * @returns {geom2} new geometry
  * @alias module:modeling/geometries/geom2.clone
  */
-const clone = (geometry) => {
-  const out = create()
-  out.sides = geometry.sides.map((side) => [vec2.clone(side[0]), vec2.clone(side[1])])
-  out.transforms = mat4.clone(geometry.transforms)
-  return out
-}
+const clone = (geometry) => Object.assign({}, geometry)
 
 module.exports = clone

package/src/geometries/geom2/transform.js

@@ -1,7 +1,5 @@
 const mat4 = require('../../maths/mat4')
 
-const create = require('./create')
-
 /**
  * Transform the given geometry using the given matrix.
  * This is a lazy transform of the sides, as this function only adjusts the transforms.
@@ -15,10 +13,8 @@ const create = require('./create')
  * let newgeometry = transform(fromZRotation(degToRad(90)), geometry)
  */
 const transform = (matrix, geometry) => {
-  const newgeometry = create(geometry.sides) // reuse the sides
-
-  mat4.multiply(newgeometry.transforms, matrix, geometry.transforms)
-  return newgeometry
+  const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  return Object.assign({}, geometry, { transforms })
 }
 
 module.exports = transform

package/src/geometries/geom3/applyTransforms.js

@@ -17,7 +17,7 @@ const applyTransforms = (geometry) => {
   // const isMirror = mat4.isMirroring(geometry.transforms)
   // TBD if (isMirror) newvertices.reverse()
   geometry.polygons = geometry.polygons.map((polygon) => poly3.transform(geometry.transforms, polygon))
-  mat4.identity(geometry.transforms)
+  geometry.transforms = mat4.create()
   return geometry
 }
 

package/src/geometries/geom3/clone.js

@@ -1,21 +1,9 @@
-const mat4 = require('../../maths/mat4')
-
-const poly3 = require('../poly3')
-
-const create = require('./create')
-
 /**
- * Performs a deep clone of the given geometry.
+ * Performs a shallow clone of the given geometry.
  * @param {geom3} geometry - the geometry to clone
  * @returns {geom3} a new geometry
  * @alias module:modeling/geometries/geom3.clone
  */
-const clone = (geometry) => {
-  const out = create()
-  out.polygons = geometry.polygons.map((polygon) => poly3.clone(polygon))
-  out.isRetesselated = geometry.isRetesselated
-  out.transforms = mat4.clone(geometry.transforms)
-  return out
-}
+const clone = (geometry) => Object.assign({}, geometry)
 
 module.exports = clone

package/src/geometries/geom3/clone.test.js

@@ -7,7 +7,6 @@ const { comparePolygons, compareVectors } = require('../../../test/helpers/')
 test('clone: Creates a clone on an empty geom3', (t) => {
   const expected = {
     polygons: [],
-    isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   const geometry = create()
@@ -22,7 +21,6 @@ test('clone: Creates a clone of a populated geom3', (t) => {
     polygons: [
       { vertices: [[0, 0, 0], [1, 0, 0], [1, 0, 1]] }
     ],
-    isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   const geometry = fromPoints(points)

package/src/geometries/geom3/create.js

@@ -4,7 +4,6 @@ const mat4 = require('../../maths/mat4')
  * Represents a 3D geometry consisting of a list of polygons.
  * @typedef {Object} geom3
  * @property {Array} polygons - list of polygons, each polygon containing three or more points
- * @property {Boolean} isRetesselated - true if retesselation has been performed
  * @property {mat4} transforms - transforms to apply to the sides, see transform()
  */
 
@@ -20,7 +19,6 @@ const create = (polygons) => {
   }
   return {
     polygons: polygons,
-    isRetesselated: false,
     transforms: mat4.create()
   }
 }

package/src/geometries/geom3/create.test.js

@@ -7,7 +7,6 @@ const { create } = require('./index')
 test('create: Creates an empty geom3', (t) => {
   const expected = {
     polygons: [],
-    isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   t.deepEqual(create(), expected)
@@ -20,7 +19,6 @@ test('create: Creates a populated geom3', (t) => {
   const polygons = [polygon]
   const expected = {
     polygons: polygons,
-    isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   t.deepEqual(create(polygons), expected)

package/src/geometries/geom3/fromCompactBinary.js

@@ -18,10 +18,8 @@ const fromCompactBinary = (data) => {
 
   created.transforms = mat4.clone(data.slice(1, 17))
 
-  created.isRetesselated = !!data[17]
-
-  const numberOfVertices = data[22]
-  let ci = 23
+  const numberOfVertices = data[21]
+  let ci = 22
   let vi = data.length - (numberOfVertices * 3)
   while (vi < data.length) {
     const verticesPerPolygon = data[ci]
@@ -36,8 +34,8 @@ const fromCompactBinary = (data) => {
   }
 
   // transfer known properities, i.e. color
-  if (data[18] >= 0) {
-    created.color = [data[18], data[19], data[20], data[21]]
+  if (data[17] >= 0) {
+    created.color = [data[17], data[18], data[19], data[20]]
   }
   // TODO: how about custom properties or fields ?
   return created

package/src/geometries/geom3/fromToCompactBinary.test.js

@@ -12,7 +12,6 @@ test('toCompactBinary: converts geom3 (default)', (t) => {
       0, 1, 0, 0,
       0, 0, 1, 0,
       0, 0, 0, 1,
-      0, // isRetesselated flag
       -1, -1, -1, -1, // color
       0 // number of vertices
     ]
@@ -32,7 +31,6 @@ test('toCompactBinary: converts geom3 into a compact form', (t) => {
       0, 1, 0, 0,
       0, 0, 1, 0,
       0, 0, 0, 1,
-      0, // isRetesselated flag
       -1, -1, -1, -1, // color
       7, // number of vertices
       3, // number of vertices per polygon (2)
@@ -59,7 +57,6 @@ test('toCompactBinary: converts geom3 into a compact form', (t) => {
       0, 1, 0, 0,
       0, 0, 1, 0,
       0, 0, 0, 1,
-      0, // isRetesselated flag
       1, 2, 3, 4, // color
       7, // number of vertices
       3, // number of vertices per polygon (2)
@@ -84,7 +81,6 @@ test('fromCompactBinary: convert a compact form into a geom3', (t) => {
     0, 1, 0, 0,
     0, 0, 1, 0,
     0, 0, 0, 1,
-    0, // isRetesselated flag
     -1, -1, -1, -1, // color
     0 // number of vertices
   ]
@@ -99,7 +95,6 @@ test('fromCompactBinary: convert a compact form into a geom3', (t) => {
     0, 1, 0, 0,
     0, 0, 1, 0,
     0, 0, 0, 1,
-    0, // isRetesselated flag
     -1, -1, -1, -1, // color
     7, // number of vertices
     3, // number of vertices per polygon (2)
@@ -125,7 +120,6 @@ test('fromCompactBinary: convert a compact form into a geom3', (t) => {
     0, 1, 0, 0,
     0, 0, 1, 0,
     0, 0, 0, 1,
-    0, // isRetesselated flag
     4, 5, 6, 7, // color
     7, // number of vertices
     3, // number of vertices per polygon (2)

package/src/geometries/geom3/invert.test.js

@@ -7,7 +7,6 @@ const { comparePolygons, compareVectors } = require('../../../test/helpers/')
 test('invert: Creates a invert on an empty geom3', (t) => {
   const expected = {
     polygons: [],
-    isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   const geometry = create()
@@ -22,7 +21,6 @@ test('invert: Creates a invert of a populated geom3', (t) => {
     polygons: [
       { vertices: [[1, 0, 1], [1, 0, 0], [0, 0, 0]] }
     ],
-    isRetesselated: false,
     transforms: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   const geometry = fromPoints(points)

package/src/geometries/geom3/toCompactBinary.js

@@ -16,8 +16,8 @@ const toCompactBinary = (geom) => {
   if (geom.color) color = geom.color
 
   // FIXME why Float32Array?
-  const compacted = new Float32Array(1 + 16 + 1 + 4 + 1 + numberOfPolygons + (numberOfVertices * 3))
-  // type + transforms + isRetesselated + color + numberOfPolygons + numberOfVerticesPerPolygon[] + vertices data[]
+  const compacted = new Float32Array(1 + 16 + 4 + 1 + numberOfPolygons + (numberOfVertices * 3))
+  // type + transforms + color + numberOfPolygons + numberOfVerticesPerPolygon[] + vertices data[]
 
   compacted[0] = 1 // type code: 0 => geom2, 1 => geom3 , 2 => path2
 
@@ -38,16 +38,14 @@ const toCompactBinary = (geom) => {
   compacted[15] = transforms[14]
   compacted[16] = transforms[15]
 
-  compacted[17] = geom.isRetesselated ? 1 : 0
+  compacted[17] = color[0]
+  compacted[18] = color[1]
+  compacted[19] = color[2]
+  compacted[20] = color[3]
 
-  compacted[18] = color[0]
-  compacted[19] = color[1]
-  compacted[20] = color[2]
-  compacted[21] = color[3]
+  compacted[21] = numberOfVertices
 
-  compacted[22] = numberOfVertices
-
-  let ci = 23
+  let ci = 22
   let vi = ci + numberOfPolygons
   polygons.forEach((polygon) => {
     const points = poly3.toPoints(polygon)

package/src/geometries/geom3/transform.js

@@ -1,7 +1,5 @@
 const mat4 = require('../../maths/mat4')
 
-const create = require('./create')
-
 /**
  * Transform the given geometry using the given matrix.
  * This is a lazy transform of the polygons, as this function only adjusts the transforms.
@@ -15,11 +13,8 @@ const create = require('./create')
  * let newgeometry = transform(fromXRotation(degToRad(90)), geometry)
  */
 const transform = (matrix, geometry) => {
-  const newgeometry = create(geometry.polygons) // reuse the polygons
-  newgeometry.isRetesselated = geometry.isRetesselated
-
-  mat4.multiply(newgeometry.transforms, matrix, geometry.transforms)
-  return newgeometry
+  const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  return Object.assign({}, geometry, { transforms })
 }
 
 module.exports = transform

package/src/geometries/geom3/transform.test.js

@@ -18,7 +18,6 @@ test('transform: Adjusts the transforms of a populated geom3', (t) => {
     polygons: [
       { vertices: [[0, 0, 0], [1, 0, 0], [1, 0, 1]] }
     ],
-    isRetesselated: false,
     transforms: [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]
   }
   const geometry = fromPoints(points)

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

@@ -6,6 +6,5 @@ export default Geom3
 
 declare interface Geom3 extends Colored {
   polygons: Array<Poly3>
-  isRetesselated: boolean
   transforms: Mat4
 }

package/src/geometries/path2/applyTransforms.js

@@ -13,7 +13,7 @@ const applyTransforms = (geometry) => {
   if (mat4.isIdentity(geometry.transforms)) return geometry
 
   geometry.points = geometry.points.map((point) => vec2.transform(vec2.create(), point, geometry.transforms))
-  mat4.identity(geometry.transforms)
+  geometry.transforms = mat4.create()
   return geometry
 }
 

package/src/geometries/path2/clone.js

@@ -1,20 +1,9 @@
-const mat4 = require('../../maths/mat4')
-const vec2 = require('../../maths/vec2')
-
-const create = require('./create')
-
 /**
- * Performs a deep clone of the give geometry.
+ * Performs a shallow clone of the give geometry.
  * @param {path2} geometry - the geometry to clone
  * @returns {path2} a new path
  * @alias module:modeling/geometries/path2.clone
  */
-const clone = (geometry) => {
-  const out = create()
-  out.points = geometry.points.map((point) => vec2.clone(point))
-  out.isClosed = geometry.isClosed
-  out.transforms = mat4.clone(geometry.transforms)
-  return out
-}
+const clone = (geometry) => Object.assign({}, geometry)
 
 module.exports = clone

package/src/geometries/path2/transform.js

@@ -1,7 +1,5 @@
 const mat4 = require('../../maths/mat4')
 
-const create = require('./create')
-
 /**
  * Transform the given geometry using the given matrix.
  * This is a lazy transform of the points, as this function only adjusts the transforms.
@@ -15,11 +13,8 @@ const create = require('./create')
  * let newpath = transform(fromZRotation(Math.PI / 4), path)
  */
 const transform = (matrix, geometry) => {
-  const newgeometry = create(geometry.points) // reuse the points
-  newgeometry.isClosed = geometry.isClosed
-
-  mat4.multiply(newgeometry.transforms, matrix, geometry.transforms)
-  return newgeometry
+  const transforms = mat4.multiply(mat4.create(), matrix, geometry.transforms)
+  return Object.assign({}, geometry, { transforms })
 }
 
 module.exports = transform

package/src/geometries/poly3/isConvex.js

@@ -13,7 +13,7 @@ const areVerticesConvex = (vertices) => {
   const numvertices = vertices.length
   if (numvertices > 2) {
     // note: plane ~= normal point
-    const normal = plane.fromPoints(plane.create(), vertices[0], vertices[1], vertices[2])
+    const normal = plane.fromPoints(plane.create(), ...vertices)
     let prevprevpos = vertices[numvertices - 2]
     let prevpos = vertices[numvertices - 1]
     for (let i = 0; i < numvertices; i++) {

package/src/geometries/poly3/measureArea.js

@@ -1,4 +1,4 @@
-const vec3 = require('../../maths/vec3')
+const plane = require('./plane')
 
 /**
  * Measure the area of the given polygon.
@@ -14,19 +14,18 @@ const measureArea = (poly3) => {
   }
   const vertices = poly3.vertices
 
-  // calculate a real normal
-  const a = vertices[0]
-  const b = vertices[1]
-  const c = vertices[2]
-  const ba = vec3.subtract(vec3.create(), b, a)
-  const ca = vec3.subtract(vec3.create(), c, a)
-  const normal = vec3.cross(ba, ba, ca)
+  // calculate a normal vector
+  const normal = plane(poly3)
 
-  // determin direction of projection
+  // determine direction of projection
   const ax = Math.abs(normal[0])
   const ay = Math.abs(normal[1])
   const az = Math.abs(normal[2])
-  const an = Math.sqrt((ax * ax) + (ay * ay) + (az * az)) // length of normal
+
+  if (ax + ay + az === 0) {
+    // normal does not exist
+    return 0
+  }
 
   let coord = 3 // ignore Z coordinates
   if ((ax > ay) && (ax > az)) {
@@ -50,7 +49,7 @@ const measureArea = (poly3) => {
       }
       area += (vertices[0][1] * (vertices[1][2] - vertices[n - 1][2]))
       // scale to get area
-      area *= (an / (2 * normal[0]))
+      area /= (2 * normal[0])
       break
 
     case 2: // ignore Y coordinates
@@ -62,7 +61,7 @@ const measureArea = (poly3) => {
       }
       area += (vertices[0][2] * (vertices[1][0] - vertices[n - 1][0]))
       // scale to get area
-      area *= (an / (2 * normal[1]))
+      area /= (2 * normal[1])
       break
 
     case 3: // ignore Z coordinates
@@ -75,7 +74,7 @@ const measureArea = (poly3) => {
       }
       area += (vertices[0][0] * (vertices[1][1] - vertices[n - 1][1]))
       // scale to get area
-      area *= (an / (2 * normal[2]))
+      area /= (2 * normal[2])
       break
   }
   return area

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

@@ -37,6 +37,21 @@ test('poly3: measureArea() should return correct values', (t) => {
   let ret4 = measureArea(ply4)
   t.is(ret4, 19.5)
 
+  // colinear vertices non-zero area
+  const ply5 = fromPoints([[0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0]])
+  const ret5 = measureArea(ply5)
+  t.is(ret5, 1)
+
+  // colinear vertices empty area
+  const ply6 = fromPoints([[0, 0, 0], [1, 0, 0], [2, 0, 0]])
+  const ret6 = measureArea(ply6)
+  t.is(ret6, 0)
+
+  // duplicate vertices empty area
+  const ply7 = fromPoints([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
+  const ret7 = measureArea(ply7)
+  t.is(ret7, 0)
+
   // rotated to various angles
   let rotation = mat4.fromZRotation(mat4.create(), (45 * 0.017453292519943295))
   ply1 = transform(rotation, ply1)

package/src/geometries/poly3/plane.js

@@ -2,8 +2,7 @@ const mplane = require('../../maths/plane/')
 
 const plane = (polygon) => {
   if (!polygon.plane) {
-    const vertices = polygon.vertices
-    polygon.plane = mplane.fromPoints(mplane.create(), vertices[0], vertices[1], vertices[2])
+    polygon.plane = mplane.fromPoints(mplane.create(), ...polygon.vertices)
   }
   return polygon.plane
 }

package/src/maths/mat4/index.js

@@ -21,6 +21,7 @@ module.exports = {
   fromZRotation: require('./fromZRotation'),
   identity: require('./identity'),
   isIdentity: require('./isIdentity'),
+  isOnlyTransformScale: require('./isOnlyTransformScale'),
   isMirroring: require('./isMirroring'),
   mirrorByPlane: require('./mirrorByPlane'),
   multiply: require('./multiply'),

package/src/maths/mat4/isOnlyTransformScale.js

@@ -0,0 +1,21 @@
+
+/**
+ * Determine whether the given matrix is translate+scale.
+ * this code returns true for 180 rotation as it can be interpreted as scale (-1,-1)
+ *
+ * this method is primarily useful for measureBoundingBox
+ *
+ */
+const isOnlyTransformScale = (matrix) => (
+
+  // TODO check if it is worth the effort to add recognition of 90 deg rotations
+
+  isZero(matrix[1]) && isZero(matrix[2]) && isZero(matrix[3]) &&
+  isZero(matrix[4]) && isZero(matrix[6]) && isZero(matrix[7]) &&
+  isZero(matrix[8]) && isZero(matrix[9]) && isZero(matrix[11]) &&
+  matrix[15] === 1
+)
+
+const isZero = (num) => Math.abs(num) < Number.EPSILON
+
+module.exports = isOnlyTransformScale

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

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

package/src/maths/plane/fromPoints.js

@@ -10,17 +10,39 @@ const vec3 = require('../vec3')
  * @returns {plane} out
  * @alias module:modeling/maths/plane.fromPoints
  */
-const fromPoints = (out, a, b, c) => {
-  const ba = vec3.subtract(vec3.create(), b, a)
-  const ca = vec3.subtract(vec3.create(), c, a)
-  vec3.cross(ba, ba, ca)
-  vec3.normalize(ba, ba) // normal part
-  const w = vec3.dot(ba, a)
+const fromPoints = (out, ...vertices) => {
+  const len = vertices.length
 
-  out[0] = ba[0]
-  out[1] = ba[1]
-  out[2] = ba[2]
-  out[3] = w
+  // 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
 }