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

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

@@ -18,7 +18,7 @@ test('extrudeRotate: (defaults) extruding of a geom2 produces an expected geom3'
   const geometry2 = geom2.create([[[10, 8], [10, -8], [26, -8], [26, 8]]])
 
   const geometry3 = extrudeRotate({ }, geometry2)
-  const pts = geom3.toPoints(geometry3)
+  const pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 7033.914479497244)
   t.is(measureVolume(geometry3), 27648.000000000007)
@@ -36,7 +36,7 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
 
   // test angle
   let geometry3 = extrudeRotate({ segments: 4, angle: TAU / 8 }, geometry2)
-  let pts = geom3.toPoints(geometry3)
+  let pts = geom3.toVertices(geometry3)
   const exp = [
     [[26, 0, 8], [26, 0, -8], [18.38477631085024, 18.384776310850235, -8]],
     [[26, 0, 8], [18.38477631085024, 18.384776310850235, -8], [18.38477631085024, 18.384776310850235, 8]],
@@ -58,14 +58,14 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeRotate({ segments: 4, angle: -250 * 0.017453292519943295 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 4525.850393739846)
   t.is(measureVolume(geometry3), 13730.527057424617)
   t.is(pts.length, 28)
 
   geometry3 = extrudeRotate({ segments: 4, angle: 250 * 0.017453292519943295 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 4525.8503937398455)
   t.is(measureVolume(geometry3), 13730.527057424617)
@@ -77,7 +77,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
 
   // test startAngle
   let geometry3 = extrudeRotate({ segments: 5, startAngle: TAU / 8 }, geometry2)
-  let pts = geom3.toPoints(geometry3)
+  let pts = geom3.toVertices(geometry3)
   let exp = [
     [7.0710678118654755, 7.071067811865475, 8],
     [18.38477631085024, 18.384776310850235, 8],
@@ -90,7 +90,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
   t.true(comparePoints(pts[6], exp))
 
   geometry3 = extrudeRotate({ segments: 5, startAngle: -TAU / 8 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   exp = [
     [7.0710678118654755, -7.071067811865475, 8],
     [18.38477631085024, -18.384776310850235, 8],
@@ -108,14 +108,14 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
 
   // test segments
   let geometry3 = extrudeRotate({ segments: 4 }, geometry2)
-  let pts = geom3.toPoints(geometry3)
+  let pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 5562.34804770761)
   t.is(measureVolume(geometry3), 18432)
   t.is(pts.length, 32)
 
   geometry3 = extrudeRotate({ segments: 64 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 7230.965353920782)
   t.is(measureVolume(geometry3), 28906.430888871357)
@@ -124,7 +124,7 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   // test overlapping edges
   geometry2 = geom2.create([[[0, 0], [2, 1], [1, 2], [1, 3], [3, 4], [0, 5]]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 84.28200374166053)
   t.is(measureVolume(geometry3), 33.94112549695427)
@@ -133,7 +133,7 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   // test overlapping edges that produce hollow shape
   geometry2 = geom2.create([[[30, 0], [30, 60], [0, 60], [0, 50], [10, 40], [10, 30], [0, 20], [0, 10], [10, 0]]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
-  pts = geom3.toPoints(geometry3)
+  pts = geom3.toVertices(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
   t.is(measureArea(geometry3), 17692.315375839215)
   t.is(measureVolume(geometry3), 147078.2104868019)
@@ -145,7 +145,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   let geometry = geom2.create([[[-1, 8], [-1, -8], [7, -8], [7, 8]]])
 
   let obs = extrudeRotate({ segments: 4, angle: TAU / 4 }, geometry)
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[0, 0, 8], [7, 0, 8], [0, 7, 8]],
     [[7, 0, 8], [7, 0, -8], [0, 7, -8]],
@@ -166,7 +166,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   geometry = geom2.create([[[-1, 8], [-2, 4], [-1, -8], [7, -8], [7, 8]]])
 
   obs = extrudeRotate({ segments: 8, angle: TAU / 4 }, geometry)
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[2, 0, 4], [1, 0, -8], [0.7071067811865476, 0.7071067811865475, -8]],
     [[2, 0, 4], [0.7071067811865476, 0.7071067811865475, -8], [1.4142135623730951, 1.414213562373095, 4]],
@@ -194,4 +194,38 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
+// Test for mat4 reuse optimization: verify rotation matrices are computed correctly
+// This ensures the optimization of computing xRotationMatrix once doesn't break anything
+test('extrudeRotate: (mat4 reuse) rotation matrices produce correct geometry', (t) => {
+  // Simple rectangle that will be rotated to form a tube-like shape
+  const geometry2 = geom2.create([[[6, 1], [5, 1], [5, -1], [6, -1]]])
+
+  // Full rotation with many segments to test matrix reuse across iterations
+  const geometry3 = extrudeRotate({ segments: 32 }, geometry2)
+  const pts = geom3.toVertices(geometry3)
+
+  t.notThrows(() => geom3.validate(geometry3))
+  // 32 segments * 8 walls per segment (4 edges * 2 triangles) = 256 polygons
+  t.is(pts.length, 256)
+
+  // Verify the geometry is closed (first and last slices connect properly)
+  // This tests the Zrotation rounding error fix at index === segments
+  const obs = extrudeRotate({ segments: 16 }, geometry2)
+  t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 204.69587079560992)
+  t.is(measureVolume(obs), 67.35228409625583)
+})
+
+// Test for mat4 reuse with partial rotation (tests both capped and matrix reuse)
+test('extrudeRotate: (mat4 reuse) partial rotation produces correct caps', (t) => {
+  const geometry2 = geom2.create([[[6, 1], [5, 1], [5, -1], [6, -1]]])
+
+  // Quarter rotation - should have start and end caps
+  const obs = extrudeRotate({ segments: 8, angle: TAU / 4 }, geometry2)
+
+  t.notThrows(() => geom3.validate(obs))
+  t.is(measureArea(obs), 53.232491234231944)
+  t.is(measureVolume(obs), 15.556349186104049)
+})
+
 // TEST HOLES

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

@@ -56,3 +56,63 @@ test('extrudeWalls (different shapes)', (t) => {
   walls = extrudeWalls(slice3, slice.transform(matrix, slice2))
   t.is(walls.length, 24)
 })
+
+// Test for vec3 reuse optimization in repartitionEdges
+// When shapes have different edge counts, edges are repartitioned using vec3 operations
+test('extrudeWalls (repartitionEdges vec3 reuse)', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [0, 0, 5])
+
+  // Triangle (3 edges)
+  const triangle = slice.create([[
+    [0, 10, 0], [-8.66, -5, 0], [8.66, -5, 0]
+  ]])
+
+  // Hexagon (6 edges) - LCM with triangle is 6, so triangle edges get split
+  const hexagon = slice.create([[
+    [0, 10, 0], [-8.66, 5, 0],
+    [-8.66, -5, 0],
+    [0, -10, 0],
+    [8.66, -5, 0],
+    [8.66, 5, 0]
+  ]])
+
+  // Triangle to hexagon requires repartitioning (3 -> 6 edges)
+  // This exercises the vec3 reuse optimization in repartitionEdges
+  const walls = extrudeWalls(triangle, slice.transform(matrix, hexagon))
+
+  // 6 edges * 2 triangles per edge = 12 wall polygons
+  t.is(walls.length, 12)
+
+  // Verify all walls are valid triangles
+  walls.forEach((wall) => {
+    t.is(wall.vertices.length, 3)
+  })
+})
+
+// Test for vec3 reuse with higher repartition multiple
+test('extrudeWalls (repartitionEdges with high multiple)', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [0, 0, 10])
+
+  // Square (4 edges)
+  const square = slice.create([[
+    [-5, 5, 0], [-5, -5, 0], [5, -5, 0], [5, 5, 0]
+  ]])
+
+  // Octagon (8 edges) - LCM with square is 8, so square edges get doubled
+  const octagon = slice.create([[
+    [0, 5, 0],
+    [-3.54, 3.54, 0],
+    [-5, 0, 0],
+    [-3.54, -3.54, 0],
+    [0, -5, 0],
+    [3.54, -3.54, 0],
+    [5, 0, 0],
+    [3.54, 3.54, 0]
+  ]])
+
+  // Square to octagon requires repartitioning (4 -> 8 edges)
+  const walls = extrudeWalls(square, slice.transform(matrix, octagon))
+
+  // 8 edges * 2 triangles per edge = 16 wall polygons
+  t.is(walls.length, 16)
+})

package/src/operations/hulls/hull.test.js

@@ -218,7 +218,7 @@ test('hull (single, geom3)', (t) => {
   let geometry = geom3.create()
 
   let obs = hull(geometry)
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 0)
@@ -226,7 +226,7 @@ test('hull (single, geom3)', (t) => {
   geometry = sphere({ radius: 2, segments: 8 })
 
   obs = hull(geometry)
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 44.05375630658983)
@@ -238,7 +238,7 @@ test('hull (multiple, geom3)', (t) => {
   const geometry1 = cuboid({ size: [2, 2, 2] })
 
   let obs = hull(geometry1, geometry1) // same
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
   let exp = [
     [[-1, 1, -1], [-1, 1, 1], [1, 1, 1], [1, 1, -1]],
     [[-1, 1, -1], [1, 1, -1], [1, -1, -1], [-1, -1, -1]],
@@ -257,7 +257,7 @@ test('hull (multiple, geom3)', (t) => {
   const geometry2 = center({ relativeTo: [5, 5, 5] }, cuboid({ size: [3, 3, 3] }))
 
   obs = hull(geometry1, geometry2)
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
   exp = [
     [[1, -1, -1], [6.5, 3.5, 3.5], [6.5, 3.5, 6.5], [1, -1, 1]],
     [[-1, -1, 1], [-1, -1, -1], [1, -1, -1], [1, -1, 1]],
@@ -286,7 +286,7 @@ test('hull (multiple, overlapping, geom3)', (t) => {
   const geometry3 = center({ relativeTo: [-3, -3, -3] }, ellipsoid({ radius: [3, 3, 3], segments: 12 }))
 
   const obs = hull(geometry1, geometry2, geometry3)
-  const pts = geom3.toPoints(obs)
+  const pts = geom3.toVertices(obs)
 
   t.notThrows(() => geom3.validate(obs))
   t.is(measureArea(obs), 282.26819685563686)

package/src/operations/hulls/hullChain.test.js

@@ -61,7 +61,7 @@ test('hullChain (three, geom2)', (t) => {
 })
 
 test('hullChain (three, geom3)', (t) => {
-  const geometry1 = geom3.fromPoints(
+  const geometry1 = geom3.fromVertices(
     [[[-1, -1, -1], [-1, -1, 1], [-1, 1, 1], [-1, 1, -1]],
       [[1, -1, -1], [1, 1, -1], [1, 1, 1], [1, -1, 1]],
       [[-1, -1, -1], [1, -1, -1], [1, -1, 1], [-1, -1, 1]],
@@ -69,7 +69,7 @@ test('hullChain (three, geom3)', (t) => {
       [[-1, -1, -1], [-1, 1, -1], [1, 1, -1], [1, -1, -1]],
       [[-1, -1, 1], [1, -1, 1], [1, 1, 1], [-1, 1, 1]]]
   )
-  const geometry2 = geom3.fromPoints(
+  const geometry2 = geom3.fromVertices(
     [[[3.5, 3.5, 3.5], [3.5, 3.5, 6.5], [3.5, 6.5, 6.5], [3.5, 6.5, 3.5]],
       [[6.5, 3.5, 3.5], [6.5, 6.5, 3.5], [6.5, 6.5, 6.5], [6.5, 3.5, 6.5]],
       [[3.5, 3.5, 3.5], [6.5, 3.5, 3.5], [6.5, 3.5, 6.5], [3.5, 3.5, 6.5]],
@@ -77,7 +77,7 @@ test('hullChain (three, geom3)', (t) => {
       [[3.5, 3.5, 3.5], [3.5, 6.5, 3.5], [6.5, 6.5, 3.5], [6.5, 3.5, 3.5]],
       [[3.5, 3.5, 6.5], [6.5, 3.5, 6.5], [6.5, 6.5, 6.5], [3.5, 6.5, 6.5]]]
   )
-  const geometry3 = geom3.fromPoints(
+  const geometry3 = geom3.fromVertices(
     [[[-4.5, 1.5, -4.5], [-4.5, 1.5, -1.5], [-4.5, 4.5, -1.5], [-4.5, 4.5, -4.5]],
       [[-1.5, 1.5, -4.5], [-1.5, 4.5, -4.5], [-1.5, 4.5, -1.5], [-1.5, 1.5, -1.5]],
       [[-4.5, 1.5, -4.5], [-1.5, 1.5, -4.5], [-1.5, 1.5, -1.5], [-4.5, 1.5, -1.5]],
@@ -88,7 +88,7 @@ test('hullChain (three, geom3)', (t) => {
 
   // open
   let obs = hullChain(geometry1, geometry2, geometry3)
-  let pts = geom3.toPoints(obs)
+  let pts = geom3.toVertices(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
   t.is(measureArea(obs), 266.1454764345133)
@@ -97,7 +97,7 @@ test('hullChain (three, geom3)', (t) => {
 
   // closed
   obs = hullChain(geometry1, geometry2, geometry3, geometry1)
-  pts = geom3.toPoints(obs)
+  pts = geom3.toVertices(obs)
 
   t.notThrows.skip(() => geom3.validate(obs))
   t.is(measureArea(obs), 272.2887171436021)

package/src/operations/hulls/toUniquePoints.js

@@ -21,8 +21,8 @@ export const toUniquePoints = (geometries) => {
     if (geom2.isA(geometry)) {
       geom2.toPoints(geometry).forEach(addPoint)
     } else if (geom3.isA(geometry)) {
-      // points are grouped by polygon
-      geom3.toPoints(geometry).forEach((points) => points.forEach(addPoint))
+      // vertices are grouped by polygon
+      geom3.toVertices(geometry).forEach((vertices) => vertices.forEach(addPoint))
     } else if (path2.isA(geometry)) {
       path2.toPoints(geometry).forEach(addPoint)
     }

package/src/operations/minkowski/index.d.ts

@@ -0,0 +1 @@
+export { minkowskiSum } from './minkowskiSum'

package/src/operations/minkowski/index.js

@@ -0,0 +1,15 @@
+/**
+ * Minkowski sum operations for 3D geometries.
+ *
+ * The Minkowski sum of two shapes A and B is the set of all points that are
+ * the sum of a point in A and a point in B. This is useful for:
+ * - Offsetting/inflating shapes (using a sphere creates rounded edges)
+ * - Collision detection (shapes collide iff their Minkowski difference contains origin)
+ * - Motion planning and swept volumes
+ *
+ * @module modeling/minkowski
+ * @example
+ * import { minkowskiSum } from '@jscad/modeling'
+ * const rounded = minkowskiSum(cube, sphere)
+ */
+export { minkowskiSum } from './minkowskiSum.js'

package/src/operations/minkowski/minkowskiSum.d.ts

@@ -0,0 +1,4 @@
+import type { Geom3 } from '../../geometries/types'
+
+export function minkowskiSum(geometryA: Geom3, geometryB: Geom3): Geom3
+export function minkowskiSum(...geometries: Geom3[]): Geom3

package/src/operations/minkowski/minkowskiSum.js

@@ -0,0 +1,223 @@
+import { flatten } from '../../utils/flatten.js'
+
+import { geom3, poly3 } from '../../geometries/index.js'
+
+import { hullPoints3 } from '../hulls/hullPoints3.js'
+import { unionGeom3 } from '../booleans/unionGeom3.js'
+
+/**
+ * Compute the Minkowski sum of two 3D geometries.
+ *
+ * The Minkowski sum A ⊕ B is the set of all points a + b where a ∈ A and b ∈ B.
+ * Geometrically, this "inflates" geometry A by the shape of geometry B.
+ *
+ * Common use cases:
+ * - Offset a solid by a sphere to round all edges and corners
+ * - Offset a solid by a cube to create chamfered edges
+ * - Collision detection (if Minkowski sum contains origin, shapes overlap)
+ *
+ * For best performance, use convex geometries. Non-convex geometries are supported
+ * when the second operand is convex, but require decomposition and are slower.
+ *
+ * @param {...Object} geometries - two geom3 geometries (second should be convex for non-convex first)
+ * @returns {geom3} new 3D geometry representing the Minkowski sum
+ * @alias module:modeling/minkowski.minkowskiSum
+ *
+ * @example
+ * const { primitives, minkowski } = require('@jscad/modeling')
+ * const cube = primitives.cuboid({ size: [10, 10, 10] })
+ * const sphere = primitives.sphere({ radius: 2, segments: 16 })
+ * const rounded = minkowski.minkowskiSum(cube, sphere)
+ */
+export const minkowskiSum = (...geometries) => {
+  geometries = flatten(geometries)
+
+  if (geometries.length !== 2) {
+    throw new Error('minkowskiSum requires exactly two geometries')
+  }
+
+  const [geomA, geomB] = geometries
+
+  if (!geom3.isA(geomA) || !geom3.isA(geomB)) {
+    throw new Error('minkowskiSum requires geom3 geometries')
+  }
+
+  const aConvex = geom3.isConvex(geomA)
+  const bConvex = geom3.isConvex(geomB)
+
+  // Fast path: both convex
+  if (aConvex && bConvex) {
+    return minkowskiSumConvex(geomA, geomB)
+  }
+
+  // Non-convex A + convex B: decompose A into tetrahedra
+  if (!aConvex && bConvex) {
+    return minkowskiSumNonConvexConvex(geomA, geomB)
+  }
+
+  // Convex A + non-convex B: swap operands (Minkowski sum is commutative)
+  if (aConvex && !bConvex) {
+    return minkowskiSumNonConvexConvex(geomB, geomA)
+  }
+
+  // Both non-convex: not yet supported
+  throw new Error('minkowskiSum of two non-convex geometries is not yet supported')
+}
+
+/*
+ * Compute Minkowski sum of non-convex A with convex B.
+ *
+ * Decomposes A into tetrahedra, computes Minkowski sum of each with B,
+ * then unions all results.
+ */
+const minkowskiSumNonConvexConvex = (geomA, geomB) => {
+  const tetrahedra = decomposeIntoTetrahedra(geomA)
+
+  if (tetrahedra.length === 0) {
+    return geom3.create()
+  }
+
+  // Compute Minkowski sum for each tetrahedron
+  const parts = tetrahedra.map((tet) => minkowskiSumConvex(tet, geomB))
+
+  // Union all parts using internal unionGeom3
+  if (parts.length === 1) {
+    return parts[0]
+  }
+
+  return unionGeom3(parts)
+}
+
+/*
+ * Decompose a geom3 into tetrahedra using face-local apex points.
+ * Each resulting tetrahedron is guaranteed to be convex.
+ *
+ * Unlike centroid-based decomposition, this approach works correctly for
+ * shapes where the centroid is outside the geometry (e.g., torus, U-shapes).
+ * Each polygon gets its own apex point, offset inward along its normal.
+ */
+const decomposeIntoTetrahedra = (geometry) => {
+  const polygons = geom3.toPolygons(geometry)
+
+  if (polygons.length === 0) {
+    return []
+  }
+
+  const tetrahedra = []
+
+  // For each polygon, compute a face-local apex and create tetrahedra
+  for (let i = 0; i < polygons.length; i++) {
+    const polygon = polygons[i]
+    const vertices = polygon.vertices
+
+    // Compute polygon center
+    let cx = 0
+    let cy = 0
+    let cz = 0
+    for (let k = 0; k < vertices.length; k++) {
+      cx += vertices[k][0]
+      cy += vertices[k][1]
+      cz += vertices[k][2]
+    }
+    cx /= vertices.length
+    cy /= vertices.length
+    cz /= vertices.length
+
+    // Get polygon plane (normal + offset)
+    const plane = poly3.plane(polygon)
+    const nx = plane[0]
+    const ny = plane[1]
+    const nz = plane[2]
+
+    // Offset inward along negative normal to create face-local apex
+    // The normal points outward, so we go in the negative direction
+    // Use a small offset - the actual distance doesn't matter much
+    // as long as the apex is on the interior side of the face
+    const offset = 0.1
+    const apex = [ // Vertex used as apex in tetrahedron polygons below
+      cx - nx * offset,
+      cy - ny * offset,
+      cz - nz * offset
+    ]
+
+    // Fan triangulate the polygon and create tetrahedra from apex
+    for (let j = 1; j < vertices.length - 1; j++) {
+      const v0 = vertices[0]
+      const v1 = vertices[j]
+      const v2 = vertices[j + 1]
+
+      // Create tetrahedron from apex and triangle
+      const tetPolygons = createTetrahedronPolygons(apex, v0, v1, v2)
+      tetrahedra.push(geom3.create(tetPolygons))
+    }
+  }
+
+  return tetrahedra
+}
+
+/*
+ * Create the 4 triangular faces of a tetrahedron.
+ *
+ * Tetrahedron has 4 faces, each a triangle
+ */
+const createTetrahedronPolygons = (p0, p1, p2, p3) => [
+  poly3.create([p0, p2, p1]), // base seen from p3
+  poly3.create([p0, p1, p3]), // face opposite p2
+  poly3.create([p1, p2, p3]), // face opposite p0
+  poly3.create([p2, p0, p3]) // face opposite p1
+]
+
+/*
+ * Compute Minkowski sum of two convex polyhedra.
+ *
+ * For convex polyhedra, the Minkowski sum equals the convex hull of
+ * all pairwise vertex sums. This is O(n*m) for n and m vertices,
+ * plus the cost of the convex hull algorithm.
+ */
+const minkowskiSumConvex = (geomA, geomB) => {
+  const pointsA = extractUniqueVertices(geomA)
+  const pointsB = extractUniqueVertices(geomB)
+
+  if (pointsA.length === 0 || pointsB.length === 0) {
+    return geom3.create()
+  }
+
+  // Compute all pairwise sums
+  const summedPoints = []
+  for (let i = 0; i < pointsA.length; i++) {
+    const a = pointsA[i]
+    for (let j = 0; j < pointsB.length; j++) {
+      const b = pointsB[j]
+      summedPoints.push([a[0] + b[0], a[1] + b[1], a[2] + b[2]])
+    }
+  }
+
+  // Compute convex hull of the summed points
+  const hullPolygons = hullPoints3(summedPoints)
+
+  return geom3.create(hullPolygons)
+}
+
+/*
+ * Extract unique vertices from a geom3.
+ * Uses a Set with string keys for deduplication.
+ */
+const extractUniqueVertices = (geometry) => {
+  const found = new Set()
+  const unique = []
+
+  const polygons = geom3.toPolygons(geometry)
+  for (let i = 0; i < polygons.length; i++) {
+    const vertices = polygons[i].vertices
+    for (let j = 0; j < vertices.length; j++) {
+      const v = vertices[j]
+      const key = `${v[0]},${v[1]},${v[2]}`
+      if (!found.has(key)) {
+        found.add(key)
+        unique.push(v)
+      }
+    }
+  }
+
+  return unique
+}