@jscad/modeling 2.9.2 → 2.9.5

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):
@@ -13,8 +15,8 @@
  * let matrix = fromZRotation(create(), Math.PI / 2)
  */
 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/isMirroring.js

@@ -1,7 +1,3 @@
-const cross = require('../vec3/cross')
-const dot = require('../vec3/dot')
-const fromValues = require('../vec3/fromValues')
-
 /**
  * Determine whether the given matrix is a mirroring transformation.
  *
@@ -10,15 +6,19 @@ const fromValues = require('../vec3/fromValues')
  * @alias module:modeling/maths/mat4.isMirroring
  */
 const isMirroring = (matrix) => {
-  const u = fromValues(matrix[0], matrix[4], matrix[8])
-  const v = fromValues(matrix[1], matrix[5], matrix[9])
-  const w = fromValues(matrix[2], matrix[6], matrix[10])
+  // const xVector = [matrix[0], matrix[4], matrix[8]]
+  // const yVector = [matrix[1], matrix[5], matrix[9]]
+  // const zVector = [matrix[2], matrix[6], matrix[10]]
 
-  // for a true orthogonal, non-mirrored base, u.cross(v) == w
+  // for a true orthogonal, non-mirrored base, xVector.cross(yVector) == zVector
   // If they have an opposite direction then we are mirroring
-  const mirrorvalue = dot(cross(u, u, v), w)
-  const ismirror = (mirrorvalue < 0)
-  return ismirror
+  // calcuate xVector.cross(yVector)
+  const x = matrix[4] * matrix[9] - matrix[8] * matrix[5]
+  const y = matrix[8] * matrix[1] - matrix[0] * matrix[9]
+  const z = matrix[0] * matrix[5] - matrix[4] * matrix[1]
+  // calcualte dot(cross, zVector)
+  const d = x * matrix[2] + y * matrix[6] + z * matrix[10]
+  return (d < 0)
 }
 
 module.exports = isMirroring

package/src/maths/mat4/rotate.js

@@ -1,3 +1,7 @@
+const { EPS } = require('../constants')
+
+const { sin, cos } = require('../utils/trigonometry')
+
 const copy = require('./copy')
 
 /**
@@ -12,20 +16,20 @@ const copy = require('./copy')
  */
 const rotate = (out, matrix, radians, 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) < 0.000001) {
+  if (Math.abs(lengthSquared) < EPS) {
     // axis is 0,0,0 or almost
     return copy(out, matrix)
   }
 
-  len = 1 / len
+  const len = 1 / Math.sqrt(lengthSquared)
   x *= len
   y *= len
   z *= len
 
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
   const t = 1 - c
 
   const a00 = matrix[0]

package/src/maths/mat4/rotateX.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Rotates a matrix by the given angle around the X axis.
  *
@@ -8,8 +10,8 @@
  * @alias module:modeling/maths/mat4.rotateX
  */
 const rotateX = (out, matrix, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
   const a10 = matrix[4]
   const a11 = matrix[5]
   const a12 = matrix[6]

package/src/maths/mat4/rotateY.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Rotates a matrix by the given angle around the Y axis.
  *
@@ -8,8 +10,8 @@
  * @alias module:modeling/maths/mat4.rotateY
  */
 const rotateY = (out, matrix, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
   const a00 = matrix[0]
   const a01 = matrix[1]
   const a02 = matrix[2]

package/src/maths/mat4/rotateZ.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Rotates a matrix by the given angle around the Z axis.
  *
@@ -8,8 +10,8 @@
  * @alias module:modeling/maths/mat4.rotateZ
  */
 const rotateZ = (out, matrix, radians) => {
-  const s = Math.sin(radians)
-  const c = Math.cos(radians)
+  const s = sin(radians)
+  const c = cos(radians)
   const a00 = matrix[0]
   const a01 = matrix[1]
   const a02 = matrix[2]

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

@@ -52,10 +52,9 @@ test('mat4: translate() called with three parameters should update a mat4 with c
   t.true(compareVectors(obs4, [1, 0, 0, 0, 0, 3, 0, 0, 0, 0, 5, 0, 2, 9, 30, 1]))
   t.true(compareVectors(ret4, [1, 0, 0, 0, 0, 3, 0, 0, 0, 0, 5, 0, 2, 9, 30, 1]))
 
-  const r = (90 * 0.017453292519943295)
   const rotateZMatrix = [
-    Math.cos(r), -Math.sin(r), 0, 0,
-    Math.sin(r), Math.cos(r), 0, 0,
+    0, -1, 0, 0,
+    1, 0, 0, 0,
     0, 0, 1, 0,
     0, 0, 0, 1
   ]

package/src/maths/utils/aboutEqualNormals.js

@@ -1,8 +1,4 @@
-// Normals are directional vectors with component values from 0 to 1.0, requiring specialized comparison
-// This EPS is derived from a series of tests to determine the optimal precision for comparing coplanar polygons,
-// as provided by the sphere primitive at high segmentation
-// This EPS is for 64 bit Number values
-const NEPS = 1e-13
+const { NEPS } = require('../constants')
 
 /**
  * Compare two normals (unit vectors) for near equality.

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

@@ -3,5 +3,6 @@ export { default as area } from './area'
 export { default as interpolateBetween2DPointsForY } from './interpolateBetween2DPointsForY'
 export { default as intersect } from './intersect'
 export { default as solve2Linear } from './solve2Linear'
+export { sin, cos } from './trigonometry'
 
 export as namespace utils

package/src/maths/utils/index.js

@@ -7,7 +7,9 @@
 module.exports = {
   aboutEqualNormals: require('./aboutEqualNormals'),
   area: require('./area'),
+  cos: require('./trigonometry').cos,
   interpolateBetween2DPointsForY: require('./interpolateBetween2DPointsForY'),
   intersect: require('./intersect'),
+  sin: require('./trigonometry').sin,
   solve2Linear: require('./solve2Linear')
 }

package/src/{utils → maths/utils}/trigonometry.js

@@ -1,5 +1,4 @@
-
-const NEPS = 1e-13
+const { NEPS } = require('../constants')
 
 /*
  * Returns zero if n is within epsilon of zero, otherwise return n

package/src/maths/vec2/distance.js

@@ -9,7 +9,7 @@
 const distance = (a, b) => {
   const x = b[0] - a[0]
   const y = b[1] - a[1]
-  return Math.hypot(x, y)
+  return Math.sqrt(x * x + y * y)
 }
 
 module.exports = distance

package/src/maths/vec2/fromAngleRadians.js

@@ -1,3 +1,5 @@
+const { sin, cos } = require('../utils/trigonometry')
+
 /**
  * Create a new vector in the direction of the given angle.
  *
@@ -7,8 +9,8 @@
  * @alias module:modeling/maths/vec2.fromAngleRadians
  */
 const fromAngleRadians = (out, radians) => {
-  out[0] = Math.cos(radians)
-  out[1] = Math.sin(radians)
+  out[0] = cos(radians)
+  out[1] = sin(radians)
   return out
 }
 

package/src/maths/vec2/length.js

@@ -5,6 +5,6 @@
  * @returns {Number} length
  * @alias module:modeling/maths/vec2.length
  */
-const length = (vector) => Math.hypot(vector[0], vector[1])
+const length = (vector) => Math.sqrt(vector[0] * vector[0] + vector[1] * vector[1])
 
 module.exports = length

package/src/maths/vec2/length.test.js

@@ -25,15 +25,5 @@ test('vec2: length() should return correct values', (t) => {
   const length5 = length(vec5)
   nearlyEqual(t, length5, 2.23606, EPS)
 
-  // huge vector
-  const vec6 = fromValues(1e200, 1e200)
-  const length6 = length(vec6)
-  nearlyEqual(t, length6, Math.SQRT2 * 1e200, EPS)
-
-  // tiny vector
-  const vec7 = fromValues(1e-200, 1e-200)
-  const length7 = length(vec7)
-  nearlyEqual(t, length7, Math.SQRT2 * 1e-200, EPS)
-
   t.true(true)
 })

package/src/maths/vec3/angle.js

@@ -15,8 +15,8 @@ const angle = (a, b) => {
   const bx = b[0]
   const by = b[1]
   const bz = b[2]
-  const mag1 = Math.hypot(ax, ay, az)
-  const mag2 = Math.hypot(bx, by, bz)
+  const mag1 = Math.sqrt(ax * ax + ay * ay + az * az)
+  const mag2 = Math.sqrt(bx * bx + by * by + bz * bz)
   const mag = mag1 * mag2
   const cosine = mag && dot(a, b) / mag
   return Math.acos(Math.min(Math.max(cosine, -1), 1))

package/src/maths/vec3/angle.test.js

@@ -30,17 +30,5 @@ test('vec3: angle() should return correct values', (t) => {
   const angle5 = angle(vec5a, vec5b)
   nearlyEqual(t, angle5, 0.785398, EPS)
 
-  // tiny values
-  const vec6a = fromValues(1, 0, 0)
-  const vec6b = fromValues(1e-200, 1e-200, 0)
-  const angle6 = angle(vec6a, vec6b)
-  nearlyEqual(t, angle6, 0.785398, EPS)
-
-  // huge values
-  const vec7a = fromValues(1, 0, 0)
-  const vec7b = fromValues(1e200, 1e200, 0)
-  const angle7 = angle(vec7a, vec7b)
-  nearlyEqual(t, angle7, 0.785398, EPS)
-
   t.true(true)
 })

package/src/maths/vec3/distance.js

@@ -10,7 +10,7 @@ const distance = (a, b) => {
   const x = b[0] - a[0]
   const y = b[1] - a[1]
   const z = b[2] - a[2]
-  return Math.hypot(x, y, z)
+  return Math.sqrt(x * x + y * y + z * z)
 }
 
 module.exports = distance

package/src/maths/vec3/length.js

@@ -9,7 +9,7 @@ const length = (vector) => {
   const x = vector[0]
   const y = vector[1]
   const z = vector[2]
-  return Math.hypot(x, y, z)
+  return Math.sqrt(x * x + y * y + z * z)
 }
 
 module.exports = length

package/src/maths/vec3/length.test.js

@@ -41,15 +41,5 @@ test('vec3: length() should return correct values', (t) => {
   const length9 = length(vec9)
   nearlyEqual(t, length9, 3.74165, EPS)
 
-  // huge vector
-  const vec10 = fromValues(1e200, 0, 1e200)
-  const length10 = length(vec10)
-  nearlyEqual(t, length10, Math.SQRT2 * 1e200, EPS)
-
-  // tiny vector
-  const vec11 = fromValues(1e-200, 0, 1e-200)
-  const length11 = length(vec11)
-  nearlyEqual(t, length11, Math.SQRT2 * 1e-200, EPS)
-
   t.true(true)
 })

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

@@ -0,0 +1,69 @@
+const test = require('ava')
+
+const { comparePoints } = require('../../../test/helpers')
+
+const { geom2 } = require('../../geometries')
+
+const { circle, rectangle } = require('../../primitives')
+
+const { intersect } = require('./index')
+
+const { center } = require('../transforms/center')
+
+test('intersect: intersect of one or more geom2 objects produces expected geometry', (t) => {
+  const geometry1 = circle({ radius: 2, segments: 8 })
+
+  // intersect of one object
+  const result1 = intersect(geometry1)
+  let obs = geom2.toPoints(result1)
+  let exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result1))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // intersect of two non-overlapping objects
+  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
+
+  const result2 = intersect(geometry1, geometry2)
+  obs = geom2.toPoints(result2)
+  t.notThrows(() => geom2.validate(result2))
+  t.is(obs.length, 0)
+
+  // intersect of two partially overlapping objects
+  const geometry3 = rectangle({ size: [18, 18] })
+
+  const result3 = intersect(geometry2, geometry3)
+  obs = geom2.toPoints(result3)
+  exp = [
+    [9, 9], [8, 9], [8, 8], [9, 8]
+  ]
+  t.notThrows(() => geom2.validate(result3))
+  t.is(obs.length, 4)
+  t.true(comparePoints(obs, exp))
+
+  // intersect of two completely overlapping objects
+  const result4 = intersect(geometry1, geometry3)
+  obs = geom2.toPoints(result4)
+  exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result4))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+})

package/src/operations/booleans/intersectGeom3.js

@@ -1,6 +1,7 @@
 const flatten = require('../../utils/flatten')
 
-const retessellate = require('./retessellate')
+const retessellate = require('../modifiers/retessellate')
+
 const intersectSub = require('./intersectGeom3Sub')
 
 /*

package/src/operations/booleans/{intersect.test.js → intersectGeom3.test.js}

@@ -1,83 +1,15 @@
 const test = require('ava')
 
-const { comparePolygonsAsPoints, comparePoints } = require('../../../test/helpers')
+const { comparePolygonsAsPoints } = require('../../../test/helpers')
 
-const { geom2, geom3 } = require('../../geometries')
+const { geom3 } = require('../../geometries')
 
-const { circle, rectangle, sphere, cuboid } = require('../../primitives')
+const { sphere, cuboid } = require('../../primitives')
 
 const { intersect } = require('./index')
 
 const { center } = require('../transforms/center')
 
-//  test('intersect: intersect of a path produces expected changes to points', (t) => {
-//    let geometry = path.fromPoints({}, [[0, 1, 0], [1, 0, 0]])
-//
-//    geometry = intersect({normal: [1, 0, 0]}, geometry)
-//    let obs = path.toPoints(geometry)
-//    let exp = []
-//
-//    t.deepEqual(obs, exp)
-//  })
-
-test('intersect: intersect of one or more geom2 objects produces expected geometry', (t) => {
-  const geometry1 = circle({ radius: 2, segments: 8 })
-
-  // intersect of one object
-  const result1 = intersect(geometry1)
-  let obs = geom2.toPoints(result1)
-  let exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result1))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-
-  // intersect of two non-overlapping objects
-  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
-
-  const result2 = intersect(geometry1, geometry2)
-  obs = geom2.toPoints(result2)
-  t.notThrows(() => geom2.validate(result2))
-  t.is(obs.length, 0)
-
-  // intersect of two partially overlapping objects
-  const geometry3 = rectangle({ size: [18, 18] })
-
-  const result3 = intersect(geometry2, geometry3)
-  obs = geom2.toPoints(result3)
-  exp = [
-    [9, 9], [8, 9], [8, 8], [9, 8]
-  ]
-  t.notThrows(() => geom2.validate(result3))
-  t.is(obs.length, 4)
-  t.true(comparePoints(obs, exp))
-
-  // intersect of two completely overlapping objects
-  const result4 = intersect(geometry1, geometry3)
-  obs = geom2.toPoints(result4)
-  exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result4))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-})
-
 test('intersect: intersect of one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = sphere({ radius: 2, segments: 8 })
 

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

@@ -0,0 +1,72 @@
+const test = require('ava')
+
+const { comparePoints } = require('../../../test/helpers')
+
+const { geom2 } = require('../../geometries')
+
+const { circle, rectangle } = require('../../primitives')
+
+const { subtract } = require('./index')
+
+const { center } = require('../transforms/center')
+
+test('subtract: subtract of one or more geom2 objects produces expected geometry', (t) => {
+  const geometry1 = circle({ radius: 2, segments: 8 })
+
+  // subtract of one object
+  const result1 = subtract(geometry1)
+  let obs = geom2.toPoints(result1)
+  let exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result1))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two non-overlapping objects
+  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
+
+  const result2 = subtract(geometry1, geometry2)
+  obs = geom2.toPoints(result2)
+  exp = [
+    [2, 0],
+    [1.4142000000000001, 1.4142000000000001],
+    [0, 2],
+    [-1.4142000000000001, 1.4142000000000001],
+    [-2, 0],
+    [-1.4142000000000001, -1.4142000000000001],
+    [0, -2],
+    [1.4142000000000001, -1.4142000000000001]
+  ]
+  t.notThrows(() => geom2.validate(result2))
+  t.is(obs.length, 8)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two partially overlapping objects
+  const geometry3 = rectangle({ size: [18, 18] })
+
+  const result3 = subtract(geometry2, geometry3)
+  obs = geom2.toPoints(result3)
+  exp = [
+    [12, 12], [9, 9], [8, 9], [8, 12], [9, 8], [12, 8]
+  ]
+  t.notThrows(() => geom2.validate(result3))
+  t.is(obs.length, 6)
+  t.true(comparePoints(obs, exp))
+
+  // subtract of two completely overlapping objects
+  const result4 = subtract(geometry1, geometry3)
+  obs = geom2.toPoints(result4)
+  exp = [
+  ]
+  t.notThrows(() => geom2.validate(result4))
+  t.is(obs.length, 0)
+  t.deepEqual(obs, exp)
+})

package/src/operations/booleans/subtractGeom3.js

@@ -1,6 +1,7 @@
 const flatten = require('../../utils/flatten')
 
-const retessellate = require('./retessellate')
+const retessellate = require('../modifiers/retessellate')
+
 const subtractSub = require('./subtractGeom3Sub')
 
 /*

package/src/operations/booleans/{subtract.test.js → subtractGeom3.test.js}

@@ -1,86 +1,15 @@
 const test = require('ava')
 
-const { comparePolygonsAsPoints, comparePoints } = require('../../../test/helpers')
+const { comparePolygonsAsPoints } = require('../../../test/helpers')
 
-const { geom2, geom3 } = require('../../geometries')
+const { geom3 } = require('../../geometries')
 
-const { circle, rectangle, sphere, cuboid } = require('../../primitives')
+const { sphere, cuboid } = require('../../primitives')
 
 const { subtract } = require('./index')
 
 const { center } = require('../transforms/center')
 
-// test('subtract: subtract of a path produces expected changes to points', (t) => {
-//   let geometry = path.fromPoints({}, [[0, 1, 0], [1, 0, 0]])
-//
-//   geometry = subtract({normal: [1, 0, 0]}, geometry)
-//   let obs = path.toPoints(geometry)
-//   let exp = []
-//
-//   t.deepEqual(obs, exp)
-// })
-
-test('subtract: subtract of one or more geom2 objects produces expected geometry', (t) => {
-  const geometry1 = circle({ radius: 2, segments: 8 })
-
-  // subtract of one object
-  const result1 = subtract(geometry1)
-  let obs = geom2.toPoints(result1)
-  let exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result1))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-
-  // subtract of two non-overlapping objects
-  const geometry2 = center({ relativeTo: [10, 10, 0] }, rectangle({ size: [4, 4] }))
-
-  const result2 = subtract(geometry1, geometry2)
-  obs = geom2.toPoints(result2)
-  exp = [
-    [2, 0],
-    [1.4142000000000001, 1.4142000000000001],
-    [0, 2],
-    [-1.4142000000000001, 1.4142000000000001],
-    [-2, 0],
-    [-1.4142000000000001, -1.4142000000000001],
-    [0, -2],
-    [1.4142000000000001, -1.4142000000000001]
-  ]
-  t.notThrows(() => geom2.validate(result2))
-  t.is(obs.length, 8)
-  t.true(comparePoints(obs, exp))
-
-  // subtract of two partially overlapping objects
-  const geometry3 = rectangle({ size: [18, 18] })
-
-  const result3 = subtract(geometry2, geometry3)
-  obs = geom2.toPoints(result3)
-  exp = [
-    [12, 12], [9, 9], [8, 9], [8, 12], [9, 8], [12, 8]
-  ]
-  t.notThrows(() => geom2.validate(result3))
-  t.is(obs.length, 6)
-  t.true(comparePoints(obs, exp))
-
-  // subtract of two completely overlapping objects
-  const result4 = subtract(geometry1, geometry3)
-  obs = geom2.toPoints(result4)
-  exp = [
-  ]
-  t.notThrows(() => geom2.validate(result4))
-  t.is(obs.length, 0)
-  t.deepEqual(obs, exp)
-})
-
 test('subtract: subtract of one or more geom3 objects produces expected geometry', (t) => {
   const geometry1 = sphere({ radius: 2, segments: 8 })
 

package/src/operations/booleans/to3DWalls.js

@@ -14,7 +14,7 @@ const to3DWall = (z0, z1, side) => {
     vec3.fromVec2(vec3.create(), side[1], z1),
     vec3.fromVec2(vec3.create(), side[0], z1)
   ]
-  return poly3.fromPoints(points)
+  return poly3.create(points)
 }
 
 /*