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

package/src/primitives/roundedCylinder.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('roundedCylinder (defaults)', (t) => {
   const obs = roundedCylinder()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 16.844951865908268)
@@ -20,7 +20,7 @@ test('roundedCylinder (defaults)', (t) => {
 
 test('roundedCylinder (zero height)', (t) => {
   const obs = roundedCylinder({ height: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)
@@ -29,7 +29,7 @@ test('roundedCylinder (zero height)', (t) => {
 
 test('roundedCylinder (zero radius)', (t) => {
   const obs = roundedCylinder({ radius: 0, roundRadius: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)
@@ -38,7 +38,7 @@ test('roundedCylinder (zero radius)', (t) => {
 
 test('roundedCylinder (zero roundRadius)', (t) => {
   const obs = roundedCylinder({ roundRadius: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 18.789084266699856)
   t.is(measureVolume(obs), 6.2428903045161)
@@ -48,7 +48,7 @@ test('roundedCylinder (zero roundRadius)', (t) => {
 test('roundedCylinder (options)', (t) => {
   // test segments
   let obs = roundedCylinder({ segments: 5 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
   ]
 
@@ -59,7 +59,7 @@ test('roundedCylinder (options)', (t) => {
 
   // test center
   obs = roundedCylinder({ segments: 5, center: [-5, -5, -5] })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-4.048943483704846, -4.6909830056250525, -5.8], [-5, -4, -5.8],
       [-5, -4, -4.2], [-4.048943483704846, -4.6909830056250525, -4.2]],
@@ -91,7 +91,7 @@ test('roundedCylinder (options)', (t) => {
 
   // test height
   obs = roundedCylinder({ segments: 5, height: 20 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[0.9510565162951535, 0.30901699437494745, -9.8], [0, 1, -9.8],
       [0, 1, 9.8], [0.9510565162951535, 0.30901699437494745, 9.8]],
@@ -123,7 +123,7 @@ test('roundedCylinder (options)', (t) => {
 
   // test radius
   obs = roundedCylinder({ segments: 5, radius: 10 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[9.510565162951535, 3.0901699437494745, -0.8], [0, 10, -0.8],
       [0, 10, 0.8], [9.510565162951535, 3.0901699437494745, 0.8]],
@@ -154,7 +154,7 @@ test('roundedCylinder (options)', (t) => {
 
   // test round radius
   obs = roundedCylinder({ segments: 5, height: 20, radius: 5, roundRadius: 2 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[4.755282581475767, 1.5450849718747373, -8], [0, 5, -8],
       [0, 5, 8], [4.755282581475767, 1.5450849718747373, 8]],

package/src/primitives/sphere.test.js

@@ -10,7 +10,7 @@ import { comparePolygonsAsPoints } from '../../test/helpers/index.js'
 
 test('sphere (defaults)', (t) => {
   const obs = sphere()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 12.465694088650583)
@@ -21,7 +21,7 @@ test('sphere (defaults)', (t) => {
 test('sphere (options)', (t) => {
   // test radius
   let obs = sphere({ radius: 5, segments: 12 })
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = []
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 296.5322084069296)
@@ -31,7 +31,7 @@ test('sphere (options)', (t) => {
 
   // test segments
   obs = sphere({ segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[1, 0, 0], [0.7071067811865476, -0.7071067811865475, 0],
       [0.5000000000000001, -0.5, -0.7071067811865475], [0.7071067811865476, 0, -0.7071067811865475]],
@@ -116,7 +116,7 @@ test('sphere (options)', (t) => {
 
   // test center
   obs = sphere({ center: [-3, 5, 7], segments: 8 })
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[-2, 5, 7], [-2.2928932188134525, 4.292893218813452, 7],
       [-2.5, 4.5, 6.292893218813452], [-2.2928932188134525, 5, 6.292893218813452]],
@@ -176,7 +176,7 @@ test('sphere (options)', (t) => {
 
 test('sphere (zero radius)', (t) => {
   const obs = sphere({ radius: 0 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 0)
   t.is(measureVolume(obs), 0)

package/src/primitives/torus.test.js

@@ -12,7 +12,7 @@ import { comparePoints } from '../../test/helpers/index.js'
 
 test('torus (defaults)', (t) => {
   const obs = torus()
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 157.0282327749074)
@@ -26,7 +26,7 @@ test('torus (defaults)', (t) => {
 
 test('torus (simple options)', (t) => {
   const obs = torus({ innerRadius: 0.5, innerSegments: 4, outerRadius: 5, outerSegments: 8 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 83.36086132479792)
   t.is(measureVolume(obs), 14.14213562373095)
@@ -39,7 +39,7 @@ test('torus (simple options)', (t) => {
 
 test('torus (complex options)', (t) => {
   const obs = torus({ innerRadius: 1, outerRadius: 5, innerSegments: 32, outerSegments: 72, startAngle: TAU / 4, outerRotation: TAU / 4 })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 55.472610544494)
   t.is(measureVolume(obs), 24.484668362201525)
@@ -52,7 +52,7 @@ test('torus (complex options)', (t) => {
 
 test('torus (startAngle)', (t) => {
   const obs = torus({ startAngle: 1, endAngle: 1 + TAU })
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 157.0282327749074)
   t.is(measureVolume(obs), 77.94735870844195)

package/src/geometries/geom2/fromCompactBinary.d.ts

@@ -1,3 +0,0 @@
-import type { Geom2 } from './type.d.ts'
-
-export function fromCompactBinary(data: Array<number> | Float32Array | Float64Array): Geom2

package/src/geometries/geom2/fromCompactBinary.js

@@ -1,40 +0,0 @@
-import * as mat4 from '../../maths/mat4/index.js'
-import * as vec2 from '../../maths/vec2/index.js'
-
-import { create } from './create.js'
-
-/**
- * Create a new 2D geometry from the given compact binary data.
- * @param {Array} data - compact binary data
- * @returns {Geom2} a new geometry
- * @alias module:modeling/geometries/geom2.fromCompactBinary
- */
-export const fromCompactBinary = (data) => {
-  if (data[0] !== 0) throw new Error('invalid compact binary data')
-
-  const created = create()
-
-  created.transforms = mat4.clone(data.slice(1, 17))
-
-  for (let i = 21; i < data.length;) {
-    const length = data[i++] // number of points for this polygon
-    if (length < 0 || i + length * 2 > data.length) {
-      throw new Error('invalid compact binary data')
-    }
-    const outline = []
-    for (let j = 0; j < length; j++) {
-      const x = data[i + j * 2]
-      const y = data[i + j * 2 + 1]
-      outline.push(vec2.fromValues(x, y))
-    }
-    created.outlines.push(outline)
-    i += length * 2
-  }
-
-  // transfer known properties, i.e. color
-  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/geom2/fromToCompactBinary.test.js

@@ -1,100 +0,0 @@
-import test from 'ava'
-
-import { fromCompactBinary, toCompactBinary, create } from './index.js'
-
-test('toCompactBinary: converts geom2 into a compact form', (t) => {
-  const geometry1 = create()
-  const compacted1 = toCompactBinary(geometry1)
-  const expected1 = new Float32Array([
-    0, // type flag
-    1, 0, 0, 0, // transforms
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1,
-    -1, -1, -1, -1 // color
-  ])
-  t.deepEqual(compacted1, expected1)
-
-  // geometry with a hole
-  const geometry2 = create([
-    [[10, 10], [-10, -10], [10, -10]],
-    [[5, -5], [6, -4], [6, -5]]
-  ])
-  const compacted2 = toCompactBinary(geometry2)
-  const expected2 = new Float32Array([
-    0, // type flag
-    1, 0, 0, 0, // transforms
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1,
-    -1, -1, -1, -1, // color
-    3, 10, 10, -10, -10, 10, -10, // poly1
-    3, 5, -5, 6, -4, 6, -5 // poly2
-  ])
-  t.deepEqual(compacted2, expected2)
-
-  // test color as well
-  geometry2.color = [1, 2, 3, 4]
-  const compacted3 = toCompactBinary(geometry2)
-  const expected3 = new Float32Array([
-    0, // type flag
-    1, 0, 0, 0, // transforms
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1,
-    1, 2, 3, 4, // color
-    3, 10, 10, -10, -10, 10, -10, // poly1
-    3, 5, -5, 6, -4, 6, -5 // poly2
-  ])
-  t.deepEqual(compacted3, expected3)
-})
-
-test('fromCompactBinary: convert a compact form into a geom2', (t) => {
-  const compacted1 = [
-    0, // type flag
-    1, 0, 0, 0, // transforms
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1,
-    -1, -1, -1, -1 // color
-  ]
-  const expected1 = create()
-  const geometry1 = fromCompactBinary(compacted1)
-
-  t.deepEqual(geometry1, expected1)
-
-  // geometry with a hole
-  const compacted2 = [
-    0, // type flag
-    1, 0, 0, 0, // transforms
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1,
-    -1, -1, -1, -1, // color
-    3, 10, 10, -10, -10, 10, -10, // poly1
-    3, 5, -5, 6, -5, 6, -4 // poly2
-  ]
-  const expected2 = create([
-    [[10, 10], [-10, -10], [10, -10]],
-    [[5, -5], [6, -5], [6, -4]]
-  ])
-  const geometry2 = fromCompactBinary(compacted2)
-
-  t.deepEqual(geometry2, expected2)
-
-  // test color as well
-  const compacted3 = [
-    0, // type flag
-    1, 0, 0, 0, // transforms
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1,
-    4, 5, 6, 7, // color
-    3, 10, 10, -10, -10, 10, -10, // poly1
-    3, 5, -5, 6, -5, 6, -4 // poly2
-  ]
-  expected2.color = [4, 5, 6, 7]
-  const geometry3 = fromCompactBinary(compacted3)
-
-  t.deepEqual(geometry3, expected2)
-})

package/src/geometries/geom2/toCompactBinary.d.ts

@@ -1,3 +0,0 @@
-import type { Geom2 } from './type.d.ts'
-
-export function toCompactBinary(geom: Geom2): Float32Array

package/src/geometries/geom2/toCompactBinary.js

@@ -1,56 +0,0 @@
-/**
- * Produces a compact binary representation from the given geometry.
- * @param {Geom2} geometry - the geometry
- * @returns {TypedArray} compact binary representation
- * @alias module:modeling/geometries/geom2.toCompactBinary
- */
-export const toCompactBinary = (geometry) => {
-  const transforms = geometry.transforms
-  let color = [-1, -1, -1, -1]
-  if (geometry.color) color = geometry.color
-
-  // Compute array size
-  let size = 21
-  geometry.outlines.forEach((outline) => {
-    size += 2 * outline.length + 1
-  })
-
-  // FIXME why Float32Array?
-  const compacted = new Float32Array(size) // type + transforms + color + points
-
-  compacted[0] = 0 // type code: 0 => geom2, 1 => geom3 , 2 => path2
-
-  compacted[1] = transforms[0]
-  compacted[2] = transforms[1]
-  compacted[3] = transforms[2]
-  compacted[4] = transforms[3]
-  compacted[5] = transforms[4]
-  compacted[6] = transforms[5]
-  compacted[7] = transforms[6]
-  compacted[8] = transforms[7]
-  compacted[9] = transforms[8]
-  compacted[10] = transforms[9]
-  compacted[11] = transforms[10]
-  compacted[12] = transforms[11]
-  compacted[13] = transforms[12]
-  compacted[14] = transforms[13]
-  compacted[15] = transforms[14]
-  compacted[16] = transforms[15]
-
-  compacted[17] = color[0]
-  compacted[18] = color[1]
-  compacted[19] = color[2]
-  compacted[20] = color[3]
-
-  let index = 21
-  geometry.outlines.forEach((outline) => {
-    compacted[index++] = outline.length
-    outline.forEach((point) => {
-      compacted[index++] = point[0]
-      compacted[index++] = point[1]
-    })
-  })
-
-  // TODO: how about custom properties or fields ?
-  return compacted
-}

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

@@ -1,3 +0,0 @@
-import type { Geom3 } from './type.d.ts'
-
-export function fromCompactBinary(data: Array<number> | Float32Array | Float64Array): Geom3

package/src/geometries/geom3/fromCompactBinary.js

@@ -1,42 +0,0 @@
-import * as vec3 from '../../maths/vec3/index.js'
-import * as mat4 from '../../maths/mat4/index.js'
-
-import * as poly3 from '../poly3/index.js'
-
-import { create } from './create.js'
-
-/**
- * Construct a new 3D geometry from the given compact binary data.
- * @param {TypedArray} data - compact binary data
- * @returns {Geom3} a new geometry
- * @alias module:modeling/geometries/geom3.fromCompactBinary
- */
-export const fromCompactBinary = (data) => {
-  if (data[0] !== 1) throw new Error('invalid compact binary data')
-
-  const created = create()
-
-  created.transforms = mat4.clone(data.slice(1, 17))
-
-  const numberOfVertices = data[21]
-  let ci = 22
-  let vi = data.length - (numberOfVertices * 3)
-  while (vi < data.length) {
-    const verticesPerPolygon = data[ci]
-    ci++
-
-    const vertices = []
-    for (let i = 0; i < verticesPerPolygon; i++) {
-      vertices.push(vec3.fromValues(data[vi], data[vi + 1], data[vi + 2]))
-      vi += 3
-    }
-    created.polygons.push(poly3.create(vertices))
-  }
-
-  // transfer known properties, i.e. color
-  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/fromPointsConvex.js

@@ -1,25 +0,0 @@
-import { runner } from '../../operations/hulls/quickhull/index.js'
-import { create } from './create.js'
-import * as poly3 from '../poly3/index.js'
-
-/**
- * Construct a new convex 3D geometry from a list of unique points.
- *
- * @param {Array} uniquePoints - list of points to construct convex 3D geometry
- * @returns {geom3} a new geometry
- * @alias module:modeling/geometries/geom3.fromPointsConvex
- */
-export const fromPointsConvex = (uniquePoints) => {
-  if (!Array.isArray(uniquePoints)) {
-    throw new Error('the given points must be an array')
-  }
-
-  const faces = runner(uniquePoints, { skipTriangulation: true })
-
-  const polygons = faces.map((face) => {
-    const vertices = face.map((index) => uniquePoints[index])
-    return poly3.create(vertices)
-  })
-
-  return create(polygons)
-}

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

@@ -1,139 +0,0 @@
-import test from 'ava'
-
-import { fromCompactBinary, toCompactBinary, create, fromPoints } from './index.js'
-
-test('toCompactBinary: converts geom3 (default)', (t) => {
-  const geometry = create()
-  const compacted = toCompactBinary(geometry)
-  const expected = new Float32Array(
-    [
-      1, // type
-      1, 0, 0, 0, // transforms
-      0, 1, 0, 0,
-      0, 0, 1, 0,
-      0, 0, 0, 1,
-      -1, -1, -1, -1, // color
-      0 // number of vertices
-    ]
-  )
-  t.deepEqual(compacted, expected)
-})
-
-test('toCompactBinary: converts geom3 into a compact form', (t) => {
-  // two polygons; 3 vertices, 4 vertices
-  const vertices = [[[0, 0, 0], [1, 0, 0], [2, 0, 2]], [[0, 0, 0], [1, 0, 0], [2, 0, 2], [-3, 0, 3]]]
-  const geometry = fromPoints(vertices)
-  const compacted = toCompactBinary(geometry)
-  const expected = new Float32Array(
-    [
-      1, // type
-      1, 0, 0, 0, // transforms
-      0, 1, 0, 0,
-      0, 0, 1, 0,
-      0, 0, 0, 1,
-      -1, -1, -1, -1, // color
-      7, // number of vertices
-      3, // number of vertices per polygon (2)
-      4,
-      0, 0, 0, // vertices (7)
-      1, 0, 0,
-      2, 0, 2,
-      0, 0, 0,
-      1, 0, 0,
-      2, 0, 2,
-      -3, 0, 3
-    ]
-  )
-
-  t.deepEqual(compacted, expected)
-
-  // test color as well
-  geometry.color = [1, 2, 3, 4]
-  const compacted2 = toCompactBinary(geometry)
-  const expected2 = new Float32Array(
-    [
-      1, // type
-      1, 0, 0, 0, // transforms
-      0, 1, 0, 0,
-      0, 0, 1, 0,
-      0, 0, 0, 1,
-      1, 2, 3, 4, // color
-      7, // number of vertices
-      3, // number of vertices per polygon (2)
-      4,
-      0, 0, 0, // vertices (7)
-      1, 0, 0,
-      2, 0, 2,
-      0, 0, 0,
-      1, 0, 0,
-      2, 0, 2,
-      -3, 0, 3
-    ]
-  )
-
-  t.deepEqual(compacted2, expected2)
-})
-
-test('fromCompactBinary: convert a compact form into a geom3', (t) => {
-  const compactedDefault = [
-    1, // type
-    1, 0, 0, 0, // transforms
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1,
-    -1, -1, -1, -1, // color
-    0 // number of vertices
-  ]
-  let expected = create()
-  let geometry = fromCompactBinary(compactedDefault)
-
-  t.deepEqual(geometry, expected)
-
-  const compacted1 = [
-    1, // type
-    1, 0, 0, 0, // transforms
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1,
-    -1, -1, -1, -1, // color
-    7, // number of vertices
-    3, // number of vertices per polygon (2)
-    4,
-    0, 0, 0, // vertices (7)
-    1, 0, 0,
-    2, 0, 2,
-    0, 0, 0,
-    1, 0, 0,
-    2, 0, 2,
-    -3, 0, 3
-  ]
-  const vertices = [[[0, 0, 0], [1, 0, 0], [2, 0, 2]], [[0, 0, 0], [1, 0, 0], [2, 0, 2], [-3, 0, 3]]]
-  expected = fromPoints(vertices)
-  geometry = fromCompactBinary(compacted1)
-
-  t.deepEqual(geometry, expected)
-
-  // test color as well
-  const compacted2 = [
-    1, // type
-    1, 0, 0, 0, // transforms
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1,
-    4, 5, 6, 7, // color
-    7, // number of vertices
-    3, // number of vertices per polygon (2)
-    4,
-    0, 0, 0, // vertices (7)
-    1, 0, 0,
-    2, 0, 2,
-    0, 0, 0,
-    1, 0, 0,
-    2, 0, 2,
-    -3, 0, 3
-  ]
-  expected.color = [4, 5, 6, 7]
-  geometry = fromCompactBinary(compacted2)
-
-  t.deepEqual(geometry, expected)
-})

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

@@ -1,3 +0,0 @@
-import type { Geom3 } from './type.d.ts'
-
-export function toCompactBinary(geom: Geom3): Float32Array

package/src/geometries/geom3/toCompactBinary.js

@@ -1,66 +0,0 @@
-import * as poly3 from '../poly3/index.js'
-
-/**
- * Return the given geometry in compact binary representation.
- * @param {Geom3} geometry - the geometry
- * @return {TypedArray} compact binary representation
- * @alias module:modeling/geometries/geom3.toCompactBinary
- */
-export const toCompactBinary = (geometry) => {
-  const polygons = geometry.polygons
-  const transforms = geometry.transforms
-
-  const numberOfPolygons = polygons.length
-  const numberOfVertices = polygons.reduce((count, polygon) => count + polygon.vertices.length, 0)
-  let color = [-1, -1, -1, -1]
-  if (geometry.color) color = geometry.color
-
-  // FIXME why Float32Array?
-  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
-
-  compacted[1] = transforms[0]
-  compacted[2] = transforms[1]
-  compacted[3] = transforms[2]
-  compacted[4] = transforms[3]
-  compacted[5] = transforms[4]
-  compacted[6] = transforms[5]
-  compacted[7] = transforms[6]
-  compacted[8] = transforms[7]
-  compacted[9] = transforms[8]
-  compacted[10] = transforms[9]
-  compacted[11] = transforms[10]
-  compacted[12] = transforms[11]
-  compacted[13] = transforms[12]
-  compacted[14] = transforms[13]
-  compacted[15] = transforms[14]
-  compacted[16] = transforms[15]
-
-  compacted[17] = color[0]
-  compacted[18] = color[1]
-  compacted[19] = color[2]
-  compacted[20] = color[3]
-
-  compacted[21] = numberOfVertices
-
-  let ci = 22
-  let vi = ci + numberOfPolygons
-  polygons.forEach((polygon) => {
-    const vertices = poly3.toVertices(polygon)
-    // record the number of vertices per polygon
-    compacted[ci] = vertices.length
-    ci++
-    // convert the vertices
-    for (let i = 0; i < vertices.length; i++) {
-      const vertex = vertices[i]
-      compacted[vi + 0] = vertex[0]
-      compacted[vi + 1] = vertex[1]
-      compacted[vi + 2] = vertex[2]
-      vi += 3
-    }
-  })
-  // TODO: how about custom properties or fields ?
-  return compacted
-}

package/src/geometries/path2/fromCompactBinary.d.ts

@@ -1,3 +0,0 @@
-import type { Path2 } from './type.d.ts'
-
-export function fromCompactBinary(data: Array<number> | Float32Array | Float64Array): Path2

package/src/geometries/path2/fromCompactBinary.js

@@ -1,31 +0,0 @@
-import * as mat4 from '../../maths/mat4/index.js'
-import * as vec2 from '../../maths/vec2/index.js'
-
-import { create } from './create.js'
-
-/**
- * Create a new path from the given compact binary data.
- * @param {TypedArray} data - compact binary data
- * @returns {Path2} a new path
- * @alias module:modeling/geometries/path2.fromCompactBinary
- */
-export const fromCompactBinary = (data) => {
-  if (data[0] !== 2) throw new Error('invalid compact binary data')
-
-  const created = create()
-
-  created.transforms = mat4.clone(data.slice(1, 17))
-
-  created.isClosed = !!data[17]
-
-  for (let i = 22; i < data.length; i += 2) {
-    const point = vec2.fromValues(data[i], data[i + 1])
-    created.points.push(point)
-  }
-  // transfer known properties, i.e. color
-  if (data[18] >= 0) {
-    created.color = [data[18], data[19], data[20], data[21]]
-  }
-  // TODO: how about custom properties or fields ?
-  return created
-}