Boolean modifier

How the precision is kept

Both meshes are triangulated in 64-bit, but their vertex positions are converted to a Float32Array for the Manifold library and the result's positions are read back from the library's vertex array into a Float64Array. The mesh that shows and exports after a boolean modifier therefore has positions that passed through 32-bit.

Open item. Hand the positions to the boolean in 64-bit and read the result back in 64-bit instead of converting them with Float32Array.from.

2 calculations in 1 source file. The code is read from the released app when this page loads. It is the calculation people run, not a copy kept for this page.

const a = trianglesOf(mesh), b = ref.tris;
try {
  const { Manifold, Mesh: MMesh } = manifold;
  const mk = (t) => new Manifold(new MMesh({ numProp: 3, vertProperties: Float32Array.from(t.pos), triVerts: Uint32Array.from(t.tri) }));
  const A = mk(a), Bm = mk(b);
  const R = p.op === 'union' ? Manifold.union(A, Bm) : p.op === 'intersect' ? Manifold.intersection(A, Bm) : Manifold.difference(A, Bm);
  const g = R.getMesh(), np = g.numProp, pos = new Float64Array((g.vertProperties.length / np) * 3);
  for (let i = 0; i < pos.length / 3; i++) { pos[i * 3] = g.vertProperties[i * np]; pos[i * 3 + 1] = g.vertProperties[i * np + 1]; pos[i * 3 + 2] = g.vertProperties[i * np + 2]; }
  const out = fromTris(pos, g.triVerts);

/** A mesh from triangles (positions, indices), sharp where faces bend more than `deg`. */
function fromTris(pos, tri, deg = 30) {
  const pts = [], faces = [];
  for (let i = 0; i < pos.length / 3; i++) pts.push([pos[i * 3], pos[i * 3 + 1], pos[i * 3 + 2]]);
  for (let i = 0; i < tri.length; i += 3) faces.push([tri[i], tri[i + 1], tri[i + 2]]);
  const m = Mesh.fromLists(pts, faces);
  O.mergeByDistance(m, 1e-9, null);
  const lim = Math.cos((deg * Math.PI) / 180), A = [0, 0, 0], B = [0, 0, 0];
  for (let h = 0; h < m.nh; h++) { const t = m.hTw[h]; if (m.heDead(h) || t < h) continue; m.faceNormal(m.hF[h], A); m.faceNormal(m.hF[t], B); if (dot(A, B) < lim) { m.hFl[h] |= FL_SHARP; m.hFl[t] |= FL_SHARP; } }
  return m;
}

In detail

Method

Triangles of both meshes are handed to the Manifold library (union, intersection or difference); the result's triangles become a mesh, vertices at the same place are welded and edges are marked sharp by the angle between their faces.

Number types

Float64Array positions before and after; Float32Array for the vertex properties passed to Manifold; Uint32Array indices.

Tolerances

Weld of the result: 1e-9 (absolute, mesh units). Sharp edge: the faces' unit normals have a dot product below cos 30°.

Limits

Every coordinate of the two inputs is rounded to the nearest 32-bit number before the boolean runs, about 7 significant digits: near 100 m from the mesh's origin neighboring 32-bit numbers are 2⁻¹⁷ m apart, about 7.6 micrometers.

Approach: 32-bit step, flagged

One step stores or exchanges 32-bit values that reach a number a person reads. It is listed here with its open item, and the step is either moved to 64-bit or the app will warn where the number is read.

Every policy that takes this approach