@jscad/modeling 2.6.1 → 2.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jscad/modeling",
-  "version": "2.6.1",
+  "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": "d716497da91f951ddf7b0e0096eb7343846bc4bd"
+  "gitHead": "fbc9b90f0ae02bea4e6e7b974c65e751c3858269"
 }

package/src/colors/colorize.test.js

@@ -58,8 +58,8 @@ test('color (rgba on geometry)', (t) => {
 
 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 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)

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.

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.

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.

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/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
 }
 

package/src/maths/plane/fromPoints.test.js

@@ -13,4 +13,8 @@ test('plane: fromPoints() should return a new plane with correct values', (t) =>
   // planes created from the same points results in an invalid plane
   const obs3 = fromPoints(obs1, [0, 6, 0], [0, 6, 0], [0, 6, 0])
   t.true(compareVectors(obs3, [0 / 0, 0 / 0, 0 / 0, 0 / 0]))
+
+  // polygon with co-linear vertices
+  const obs4 = fromPoints(obs1, [0, 0, 0], [1, 0, 0], [2, 0, 0], [0, 1, 0])
+  t.true(compareVectors(obs4, [0, 0, 1, 0]))
 })

package/src/measurements/measureBoundingBox.js

@@ -31,10 +31,9 @@ const measureBoundingBoxOfPath2Points = (points) => {
     vec2.min(minpoint, minpoint, point)
     vec2.max(maxpoint, maxpoint, point)
   })
-
   boundingBox = [[minpoint[0], minpoint[1], 0], [maxpoint[0], maxpoint[1], 0]]
-  cache.set(points, boundingBox)
 
+  cache.set(points, boundingBox)
   return boundingBox
 }
 
@@ -55,7 +54,6 @@ const measureBoundingBoxOfPath2 = (geometry) => {
   }
 
   cache.set(geometry, boundingBox)
-
   return boundingBox
 }
 
@@ -65,6 +63,7 @@ const measureBoundingBoxOfPath2 = (geometry) => {
  */
 const measureBoundingBoxOfGeom2Points = ({ points, sides }) => {
   const cacheKey = points || sides
+
   let boundingBox = cache.get(cacheKey)
   if (boundingBox) return boundingBox
 
@@ -96,11 +95,9 @@ const measureBoundingBoxOfGeom2Points = ({ points, sides }) => {
       vec2.max(maxpoint, maxpoint, side[0])
     })
   }
-
   boundingBox = [[minpoint[0], minpoint[1], 0], [maxpoint[0], maxpoint[1], 0]]
 
   cache.set(cacheKey, boundingBox)
-
   return boundingBox
 }
 
@@ -121,7 +118,6 @@ const measureBoundingBoxOfGeom2 = (geometry) => {
   }
 
   cache.set(geometry, boundingBox)
-
   return boundingBox
 }
 
@@ -150,7 +146,6 @@ const measureBoundingBoxOfGeom3Polygons = (polygons) => {
   boundingBox = [[minpoint[0], minpoint[1], minpoint[2]], [maxpoint[0], maxpoint[1], maxpoint[2]]]
 
   cache.set(polygons, boundingBox)
-
   return boundingBox
 }
 
@@ -171,13 +166,13 @@ const measureBoundingBoxOfGeom3 = (geometry) => {
   }
 
   cache.set(geometry, boundingBox)
-
   return boundingBox
 }
 
-/* swap values if specific axis value in the second vector has lower value than the axis value in first vector */
+/*
+ * swap values if specific axis value in the second vector has lower value than the axis value in first vector
+ */
 const fixBound = (i, v1, v2) => {
-  // this function will likely be inlined by the JS optimization compiler
   if (v1[i] > v2[i]) {
     const tmp = v1[i]
     v1[i] = v2[i]
@@ -185,18 +180,21 @@ const fixBound = (i, v1, v2) => {
   }
 }
 
+/*
+ * Transform the given bounding box
+ */
 const transformBoundingBox = (boundingBox, transforms) => {
-  if (transforms && !mat4.isIdentity(transforms)) {
-    const out = [vec3.transform(vec3.create(), boundingBox[0], transforms), vec3.transform(vec3.create(), boundingBox[1], transforms)]
+  if (!mat4.isIdentity(transforms)) {
+    vec3.transform(boundingBox[0], boundingBox[0], transforms)
+    vec3.transform(boundingBox[1], boundingBox[1], transforms)
 
     // we now have a new 2 vectors:  [v1,v2] => [ [x1,y1,z1],  [x2,y2,z2] ]
     // transform can move bounding box corner in such way that it is no longer true that
     //  - v1 = [min(x1,x2),min(y1,y2),min(z1,z2)]
     //  - v2 = [max(x1,x2),max(y1,y2),max(z1,z2)]
-    fixBound(0, ...out)// swap x, if higher value is in first vector
-    fixBound(1, ...out)// swap y, if higher value is in first vector
-    fixBound(2, ...out)// swap z, if higher value is in first vector
-    return out
+    fixBound(0, ...boundingBox) // swap x, if higher value is in first vector
+    fixBound(1, ...boundingBox) // swap y, if higher value is in first vector
+    fixBound(2, ...boundingBox) // swap z, if higher value is in first vector
   }
   return boundingBox
 }
@@ -223,15 +221,4 @@ const measureBoundingBox = (...geometries) => {
   return results.length === 1 ? results[0] : results
 }
 
-/**
- * Shortcut for geometries that are complex but have a fast way to calculate bounding box.
- * Ellipsoid, or cylinder can provide boundingBox that pre-calculated based on parameters without traversing points.
- *
- * Another option is to calculate boundingBox durint toPoints (so the boundingBox could be calculated during transform)
- *
- * NOTE: It seems that measureBoundingBox is used all over the place, and it would be wise to allow
- * shortcuts for calculating it, as default implementation goes through all points in geometry which is bound to be slow.
-*/
-measureBoundingBox.setCache = (geometry, boundingBox) => cache.set(geometry, boundingBox)
-
 module.exports = measureBoundingBox

package/src/measurements/measureCenterOfMass.js

@@ -4,7 +4,6 @@ const vec3 = require('../maths/vec3')
 
 const geom2 = require('../geometries/geom2')
 const geom3 = require('../geometries/geom3')
-const path2 = require('../geometries/path2')
 
 const cacheOfCenterOfMass = new WeakMap()
 

package/src/measurements/measureEpsilon.js

@@ -8,25 +8,19 @@ const measureBoundingBox = require('./measureBoundingBox')
  * Measure the epsilon of the given (path2) geometry.
  * @return {Number} the epsilon (precision) of the geometry
  */
-const measureEpsilonOfPath2 = (geometry) => {
-  return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
-}
+const measureEpsilonOfPath2 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
 
 /*
  * Measure the epsilon of the given (geom2) geometry.
  * @return {Number} the epsilon (precision) of the geometry
  */
-const measureEpsilonOfGeom2 = (geometry) => {
-  return calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
-}
+const measureEpsilonOfGeom2 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 2)
 
 /*
  * Measure the epsilon of the given (geom3) geometry.
  * @return {Float} the epsilon (precision) of the geometry
  */
-const measureEpsilonOfGeom3 = (geometry) => {
-  return calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
-}
+const measureEpsilonOfGeom3 = (geometry) => calculateEpsilonFromBounds(measureBoundingBox(geometry), 3)
 
 /**
  * Measure the epsilon of the given geometries.

package/src/operations/booleans/reTesselateCoplanarPolygons.js

@@ -309,7 +309,7 @@ const reTesselateCoplanarPolygons = (sourcepolygons) => {
           const polygon = poly3.fromPointsAndPlane(vertices3d, plane) // TODO support shared
 
           // if we let empty polygon out, next retesselate will crash
-          if(polygon.vertices.length) destpolygons.push(polygon)
+          if (polygon.vertices.length) destpolygons.push(polygon)
         }
       }
     } // if(yindex > 0)

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

@@ -20,7 +20,6 @@ const splitPolygonByPlane = require('./splitPolygonByPlane')
 // remove() removes a polygon from the tree. Once a polygon is removed, the parent polygons are invalidated
 // since they are no longer intact.
 class PolygonTreeNode {
-
   // constructor creates the root node
   constructor () {
     this.parent = null

package/src/operations/expansions/expand.test.js

@@ -120,7 +120,7 @@ test('expand: expanding of a geom3 produces expected changes to polygons', (t) =
   const geometry2 = sphere({ radius: 5, segments: 8 })
   const obs2 = expand({ delta: 5 }, geometry2)
   const pts2 = geom3.toPoints(obs2)
-  t.is(pts2.length, 2059)
+  t.is(pts2.length, 2065)
 })
 
 test('expand (options): offsetting of a complex geom2 produces expected offset geom2', (t) => {

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

@@ -107,10 +107,14 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[7, -4.898587196589413e-16, -8], [4.898587196589413e-16, -2.999519565323715e-32, -8], [9.184850993605148e-16, 7, -8]],
     [[7, 4.898587196589413e-16, 8], [7, -4.898587196589413e-16, -8], [9.184850993605148e-16, 7, -8]],
     [[7, 4.898587196589413e-16, 8], [9.184850993605148e-16, 7, -8], [-6.123233995736767e-17, 7, 8]],
-    [[-4.898587196589414e-16, 0, 8], [-6.123233995736777e-17, 6.999999999999999, 8],
-     [9.18485099360515e-16, 7.000000000000001, -8], [4.898587196589413e-16, 0, -8]],
-    [[7, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8],
-     [0, -4.898587196589413e-16, -8], [7, -4.898587196589413e-16, -8]]
+    [
+      [-4.898587196589414e-16, 0, 8], [-6.123233995736777e-17, 6.999999999999999, 8],
+      [9.18485099360515e-16, 7.000000000000001, -8], [4.898587196589413e-16, 0, -8]
+    ],
+    [
+      [7, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8],
+      [0, -4.898587196589413e-16, -8], [7, -4.898587196589413e-16, -8]
+    ]
   ]
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -133,12 +137,16 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[0.7071067811865472, 0.7071067811865478, 8], [1.414213562373095, 1.4142135623730951, 4], [-1.2246467991473532e-16, 2, 4]],
     [[0.7071067811865472, 0.7071067811865478, 8], [-1.2246467991473532e-16, 2, 4], [-4.286263797015736e-16, 1, 8]],
     [[-3.4638242249419727e-16, 3.4638242249419736e-16, 8], [0.7071067811865472, 0.7071067811865478, 8], [-4.286263797015736e-16, 1, 8]],
-    [[-4.898587196589412e-16, 0, 8], [-4.2862637970157346e-16, 0.9999999999999998, 8],
-     [-1.2246467991473475e-16, 2.0000000000000004, 3.9999999999999964], [5.510910596163092e-16, 1.0000000000000004, -8],
-     [ 4.898587196589414e-16, 0, -8]],
-    [[0, -4.898587196589413e-16, -8.000000000000002], [1.0000000000000027, -4.898587196589413e-16, -8.000000000000002],
-     [2.000000000000001, 2.449293598294702e-16, 3.9999999999999964], [1.0000000000000004, 4.898587196589411e-16, 8],
-     [0, 4.898587196589411e-16, 8]]
+    [
+      [-4.898587196589412e-16, 0, 8], [-4.2862637970157346e-16, 0.9999999999999998, 8],
+      [-1.2246467991473475e-16, 2.0000000000000004, 3.9999999999999964], [5.510910596163092e-16, 1.0000000000000004, -8],
+      [4.898587196589414e-16, 0, -8]
+    ],
+    [
+      [0, -4.898587196589413e-16, -8.000000000000002], [1.0000000000000027, -4.898587196589413e-16, -8.000000000000002],
+      [2.000000000000001, 2.449293598294702e-16, 3.9999999999999964], [1.0000000000000004, 4.898587196589411e-16, 8],
+      [0, 4.898587196589411e-16, 8]
+    ]
   ]
   t.is(pts.length, 14)
   t.true(comparePolygonsAsPoints(pts, exp))

package/src/operations/modifiers/generalize.js

@@ -19,7 +19,6 @@ const generalizePath2 = (options, geometry) => {
   return geometry
 }
 
-
 /*
  */
 const generalizeGeom2 = (options, geometry) => {

package/src/operations/modifiers/snapPolygons.js

@@ -17,7 +17,7 @@ const snapPolygons = (epsilon, polygons) => {
     const newvertices = []
     for (let i = 0; i < snapvertices.length; i++) {
       const j = (i + 1) % snapvertices.length
-      if (! vec3.equals(snapvertices[i], snapvertices[j])) newvertices.push(snapvertices[i])
+      if (!vec3.equals(snapvertices[i], snapvertices[j])) newvertices.push(snapvertices[i])
     }
     const newpolygon = poly3.create(newvertices)
     if (polygon.color) newpolygon.color = polygon.color

package/src/operations/modifiers/snapPolygons.test.js

@@ -34,28 +34,28 @@ test('snapPolygons: snap of polygons produces expected results', (t) => {
       [-24.445112000000115, 19.346837333333426, 46.47572533333356],
       [-24.44446933333345, 19.346837333333426, 46.47508266666689],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
-      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234],
+      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234]
     ]), // OK
     poly3.fromPoints([
       [-24.445112000000115, 19.346837333333426, 46.47572533333356],
       [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
-      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234],
+      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234]
     ]),
     poly3.fromPoints([
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
       [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234],
       [-23.70540266666678, 18.79864266666676, 39.56448800000019],
-      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234],
+      [-23.70540266666678 - 0.00001234, 18.79864266666676 + 0.000001234, 39.56448800000019 + 0.00001234]
     ]),
     // inverted polygon
     poly3.fromPoints([
-      [ 20.109133333333336, -4.894033333333335, -1.0001266666666668 ],
-      [ 20.021120000000003, -5.1802133333333344, -1.0001266666666668 ],
-      [ 20.020300000000002, -5.182946666666668, -1.0001266666666668 ],
-      [ 10.097753333333335, -5.182946666666668, -1.0001266666666668 ],
-      [ 10.287720000000002, -4.894033333333335, -1.0001266666666668 ]
-    ]),
+      [20.109133333333336, -4.894033333333335, -1.0001266666666668],
+      [20.021120000000003, -5.1802133333333344, -1.0001266666666668],
+      [20.020300000000002, -5.182946666666668, -1.0001266666666668],
+      [10.097753333333335, -5.182946666666668, -1.0001266666666668],
+      [10.287720000000002, -4.894033333333335, -1.0001266666666668]
+    ])
   ]
 
   const results = snapPolygons(0.0001, polygons)
@@ -66,5 +66,5 @@ test('snapPolygons: snap of polygons produces expected results', (t) => {
     [-24.4445, 19.3468, 46.475100000000005],
     [-23.7054, 18.7986, 39.5645]
   ])
-  t.deepEqual(results[3], exp3)
+  t.deepEqual(results[3].vertices, exp3.vertices)
 })

package/src/primitives/index.d.ts

@@ -18,5 +18,6 @@ export { default as sphere, SphereOptions } from './sphere'
 export { default as square, SquareOptions } from './square'
 export { default as star, StarOptions } from './star'
 export { default as torus, TorusOptions } from './torus'
+export { default as triangle, TriangleOptions } from './triangle'
 
 export as namespace primitives

package/src/primitives/index.js

@@ -26,5 +26,6 @@ module.exports = {
   sphere: require('./sphere'),
   square: require('./square'),
   star: require('./star'),
-  torus: require('./torus')
+  torus: require('./torus'),
+  triangle: require('./triangle')
 }

package/src/primitives/triangle.d.ts

@@ -0,0 +1,10 @@
+import Geom2 from '../geometries/geom2/type'
+
+export default triangle
+
+export interface TriangleOptions {
+  type?: 'AAA' | 'AAS' | 'ASA' | 'SAS' | 'SSA' | 'SSS'
+  values?: [number, number, number]
+}
+
+declare function triangle(options?: TriangleOptions): Geom2