Manifold Geometry Library

Manifold is a high-performance geometry library designed for creating and operating on manifold triangle meshes. A manifold mesh represents a solid object, making it essential for CAD, manufacturing, and structural analysis.

Key features include:

• Guaranteed Manifold Output: A robust mesh Boolean algorithm designed to handle edge cases reliably.
• Performance: Extensive use of parallelization (via TBB) and efficient algorithms.
• Vertex Properties: Support for arbitrary vertex properties and material mapping.
• Smooth Interpolation: A suite of refining functions for smooth mesh interpolation (handling triangles, quads, and flat polygonal faces).
• SDF Support: A level set function for evaluating signed-distance functions (SDF) that outperforms Marching Cubes.

You can integrate Manifold into your applications using one of three primary methods depending on your requirements for sandboxing, utility access, or low-level control:

1. ManifoldCAD worker: A web worker-based code evaluation sandbox. It bundles scripts, includes dependencies (even fetching them from a CDN at runtime), and evaluates scripts as dynamically created functions. This provides script sandboxing and runtime package inclusion but introduces more overhead.
2. ManifoldCAD libraries directly: Use the ManifoldCAD modules (importers, exporters, garbage collection, etc.) outside of the full ManifoldCAD environment. These modules are relatively lightweight.
3. Manifold WASM module directly: Use the raw WASM module without the ManifoldCAD abstractions or worker sandboxing.

When working with manifold meshes, choosing the right file format is critical to preserving topology and vertex properties:

• Avoid STL: STL is lossy and inefficient. Saving a manifold mesh to STL does not guarantee the re-imported mesh will remain manifold because topology is lost.
• Use 3MF: Highly recommended for manifold meshes representing solid objects.
• Use glTF/GLB: Recommended if using vertex properties (like interpolated normals or UV coordinates). Specifically, use the EXT_mesh_manifold extension to allow lossless and efficient transmission of manifoldness even with property boundaries.
• OBJ: Supported with high precision, but limited in functionality and primarily intended for testing.

Boolean2 uses winding numbers to determine which sub-edges to retain. A sub-edge is kept if the requested rule classifies its two sides differently (one side inside the result, the other outside).

Supported logical operations via winding rules:

• Add (Union/Fill): Retains edges where the winding number w > 0. This is the default positive-winding rule.
• Subtract: Implemented by appending the second input with negative multiplicity and then applying the Add rule.
• Intersect: Retains edges where the winding number w > 1 (assuming normalized unit-winding operands).

ManifoldCAD uses a right-handed coordinate system where +Z is up. Length units are in millimetres.

Note on glTF Interop: Standard glTF uses a right-handed system but specifies +Y as up and uses metres as the unit. ManifoldCAD automatically handles scaling and rotation during glTF import/export to ensure consistency. For example, an arrow pointing in the +Z direction in ManifoldCAD will point in the +Y direction in a glTF file, but it will maintain its orientation (pointing up) and its physical size.

To build a version of Manifold with fuzzing support, use the following CMake configuration:

• -DMANIFOLD_FUZZ=ON
• -DMANIFOLD_PYBIND=OFF
• -DCMAKE_CXX_COMPILER=clang++
• -DMANIFOLD_PAR=OFF (may be required)

Note: On MacOS, you may need to set ASAN_OPTIONS=detect_container_overflow=0 when building the binary.

Manifold's rotation API expects values in degrees. This design allows the library to eliminate floating point errors for multiples of 90° and utilize more efficient code paths.

Important: Avoid passing computed approximations (like -89.999999999999) instead of exact degree values (like -90), as this can cause mesh cracks. If your logic uses radians (e.g., from Math.atan2), convert them to degrees before calling Manifold rotation methods.

// Pass degrees directly
box.rotate([90, 0, 0]);
box.rotate([0, 45, 0]);

// Convert radians to degrees if necessary
const toDeg = (rad) => rad * (180 / Math.PI);
const angle = Math.atan2(y, x); // radians
box.rotate([0, 0, toDeg(angle)]);