Geometry

Inputs are Float64 positions, Uint32 indices, and Int16/Uint16 per-face owners. Limits: 100,000 vertices, 200,000 triangles, 128 shells. Prepared point classifiers support up to 20,000 triangles; containment charges every tested outer triangle per cavity vertex, with 2 million tests by default (maximum 8 million). No GPU, Three.js, WASM, or runtime dependencies. All coordinates must share one local frame; point boundary tolerance is 1e-7 coordinate units, winding tolerance 1e-5. Near-degenerate faces, unresolved orientation, missing cavity parents, detected touching/crossing shells and exhausted budgets throw rather than guess.

Sources: Manifold's oriented boundary representation and Jacobson et al.'s generalized winding numbers.

cells: one entry per input, with stable source index, mesh and volume.

A fully covered source remains an explicitly empty cell.

exterior: the separate whole-union boundary and volume.

inputVolumes, authoredVolume, materialVolume, volumeDifference,

maximumVolumeError and operations. The signed volume difference is not clamped; insignificant negative roundoff can remain.

Cell walls include internal material interfaces. Do not render every cell wall as exposed material or infer that two touching cells are detached. Exterior face provenance, adjacency, strength, density, fracture surfaces and extraction/physics acceptance remain host concerns. In particular this does not turn an existing positive-overlap attachment graph into a surface-interface graph.

Limits: 1–64 inputs, 100,000 input vertices/200,000 input triangles, up to 126 Boolean operations, and 200,000 exported vertices/400,000 exported triangles across all cells plus exterior. Native input/output volume and total conservation errors above 1e-5 reject. These are acceptance budgets, not certified geometric error bounds or a proof against a faulty Boolean backend. Topology checks do not detect all geometric self-intersections. Use a cancellable worker: a synchronous backend call cannot be interrupted by an operation counter.

The implementation uses the set identity C_i = S_i ∖ (S_0 ∪ … ∪ S_(i−1)); its tests use Manifold only as a development dependency. Manifold's documentation describes the native Boolean/volume contract. No Boolean engine is bundled.

For Manifold 3.5.1, the optional @absolutejs/geometry/manifold entry exports createManifoldPartitionKernel(wasm, sourceCount = 64). Pass your initialized module. The optional peer is not imported at runtime and the core entry point does not require Manifold.

The adapter supplies create/subtract/union/intersect/export, native status checks, original mesh IDs, face IDs and backside flags. It creates fresh IDs for overlap operands when no explicit source index is given. Export now preserves native double-precision positions through getManifoldMesh64(solid), also exported from the optional Manifold entry. A temporary property channel stores exact integer indices into a bounded sidecar captured by Manifold's property callback; the final Float32 property index recovers the original double position. No simplification, proximity welding or tolerance change is used. The temporary native copy is freed.

getManifoldMesh64 returns owned arrays with interleaved Float64 vertProperties, numProp, triangle indices, explicit merge maps, original IDs, face IDs, run boundaries and per-run reversed flags. Extra property values keep native getMesh export semantics (including transformed normals); only position precision is upgraded. The input solid remains owned and unchanged by the caller. The result is an export record, not an input accepted directly by Manifold's Float32 Mesh API.

Limits:200,000 triangles,100,000 exported property vertices,16 extra channels, and at most600,000 position callbacks. mergeIndexedMesh accepts Float32 or Float64 position-only buffers and still uses explicit merge ancestry. Core imports remain independent of Manifold.

createManifoldMesh64(wasm, mesh) imports a position-only mesh with numProp: 3, Float64 vertProperties, Uint32 triVerts, and optional native mesh metadata (such as face IDs and original source runs). The partition adapter uses this helper. It constructs the required Float32 native Mesh, then restores the exact original coordinates via native warp before Boolean operations. It rejects nonfinite coordinates, distinct doubles with the same rounded Float32 position, unknown native vertices, and changes to vertex/triangle counts during import or restoration. Input bounds are 100,000 vertices and 200,000 triangles. Intermediate native handles are released; callers own the returned solid.

This does not recover coordinates already lost before this call, repair topology, certify self-intersection freedom, or guarantee every thin mesh can pass the native Float32 constructor. Rejections are explicit. Keep precision-sensitive operations native until final export when possible; repeated serialization/rebasing can still introduce slivers at coincident cut faces.

The ancestry contract does not assign grain across a newly cut face spanning multiple materials, validate a collider, or prove a physical attachment.

axialOrientationTensor([{axis: [1, 0, 0], weight: 1}, ...]) returns the second orientation moment as a transferable row-major Float64Array. Directions are normalized and weights are nonnegative. An axis and its negation contribute identically, avoiding cancellation when blending wood, hair or textile fibre axes. All-zero weights, zero axes and invalid input fail explicitly; at most 4096 samples are accepted. Input arrays are never changed. Finite vector and weight scales near the limits of double precision are normalized before accumulation.

The output is symmetric, positive semidefinite and has trace one. It intentionally does not choose a unique direction for isotropic or conflicting orientations. A second moment discards higher-order distribution information; it is neither a full fibre distribution nor a biological growth, fracture or constitutive model. Use a separate calibrated material model for strength and breaking forces.

Thin-face membership uses scaled normals and dominant-plane projection. Nonzero faces are not rejected by an absolute area cutoff; exactly collinear boundary faces retain their edges. The existing 1e-7 boundary tolerance and winding checks remain unchanged. This does not make Boolean geometry exact below native feature limits, and does not alter source topology or repair degenerate whole solids.

Plane-clipped tetrahedron moments

tetrahedronPlaneMoments(vertices, planePoint, planeNormal) integrates the part of a four-vertex oriented tetrahedron on the side dot(position - planePoint, planeNormal) <= 0. The normal need not be unit length. It returns signed clipped/full volumes, their ratio, a centroid (null for an empty cut), a reference point and signed first moments relative to that reference. Input arrays are borrowed synchronously and never changed. No engine or native allocation is required; work is bounded by four faces and six crossed edges.

Orientation matters: reversing two vertices reverses signed volume and moments. For a valid closed-solid tetrahedral decomposition, sum signed contributions; do not take each contribution's absolute value. To combine first moments with a common reference r, add firstMoment + signedVolume (reference - r). The helper does not construct or validate that decomposition. Tiny represented wet corners are retained using a shared cut-vertex integration origin, with no absolute volume cutoff. Degenerate or unrepresentable results throw; this is floating-point geometry, not exact predicates. A ratio can exceed one by accepted floating-point roundoff up to 1e-12; no silent clamping repairs the output.

This measures geometry, not buoyancy or fluid response. A sealed air compartment and an open flooded cavity do not exclude the same water volume; the caller must supply the appropriate physical region. Water-surface curvature, density, force, torque, pressure dynamics and clock ownership are separate responsibilities.

Prepared plane moments (0.11)

For repeated cuts of an unchanged body-local tetrahedron, use prepareTetrahedronPlaneMoments(vertices) and call the returned function with (planePoint, planeNormal). Preparation owns a copy of the four vertices and caches plane-independent normalization and full moments. Each query returns the same signed-volume, centroid and relative-first-moment contract as tetrahedronPlaneMoments. Returned arrays can be changed without modifying later queries. Rebuild the prepared query when source geometry changes.

For moving rigid bodies, transform the plane into body-local coordinates and transform the resulting centroid back. The package does not supply rigid-body forces, water clocks, sealing/flooding rules or a displacement-mesh validity certificate. Signed tetrahedral contributions must retain their orientation.

coordinate — ≤ 1000, and bounded native exports. Default cut budget is the smaller

of 32 and the remaining source-ID capacity. Snapshot statistics expose native counts, volume/tolerance, exported triangles and removed sheet triangles for host diagnostics. No GPU or engine initialization is performed by this adapter.

Double import now assigns a unique original face ID per triangle when IDs are omitted. Without this, the native Float32 constructor can merge rounded coplanar faces before restoration; immediate import volume can still match while a later cut changes. Explicit face IDs retain caller semantics.

Disjoint or merely touching cutter bounds skip native splitting (broadPhaseSkipped). This remains allowed after the accepted-cut quota is full. Empty snapshots report nativeTolerance: null; skipped empty results report nativeEvaluated: false. No near-contact tolerance is introduced by this broad phase.

Closed-solid surface queries validate the plane once, then use an internal normalized-plane path for each triangle. Public triangle queries retain their input validation and owned results. Surface flux is accumulated with scalar coordinates to avoid temporary vectors; clipping rules, component ownership, precision guards and summation order are unchanged.

Bounded surface domains (queued 0.17.0 extension)

partitionTriangleAffineDomains(triangle, domains, options) partitions a triangle into convex polygons. Each domain is an intersection of affine fields supplied as three values at the input vertices; nonnegative values are inside. Returned reference, relativePositions, barycentric and domains arrays are owned by the result. Positions stay relative to the input triangle origin, avoiding collapse when a small partition sits at a large absolute coordinate. Retain the origin through downstream transforms; adding it prematurely can lose that precision. Domain indices describe each polygon's relative interior; zero-area boundary fragments are not separate cells. An identically zero field includes the full polygon. partitionTriangleBoxDomains supplies the six fields for each axis-aligned box.

Use the barycentric coordinates for attribute interpolation and fan-triangulate each convex polygon. Defaults limit output to 1,024 cells and 8,192 vertices; explicit limits are checked during partitioning. Invalid input, unrepresentable intersections, area-conservation failure or exhausted budgets throw, without returning partial results. These are bounded double-precision operations, not exact-arithmetic Boolean solid repair. Domain membership is not a proof of solid ownership: applications must establish their own material/volume assumptions.

For example, the triangle [[0,0,0],[1,0,0],[0,1,0]] and one domain [[[-0.5,0.5,0.5]]] separate the region x+y >= 0.5; its area is 0.375. A positive rescaling of the affine field describes the same domain.

Repeated source-face interpolation

prepareTriangleWeights(a, b, c, maximumPlaneDistance?) owns a prepared source triangle and returns a point-query function. Use it when multiple cut vertices share the same source face. It preserves dominant-plane projection, outside-face rejection and the existing projection-distance limits; each result is an owned three-element array. triangleWeights remains the one-shot form. Nonrepresentable geometry or query arithmetic rejects instead of returning nonfinite weights.

This module imports no renderer, React or physics engine. A support hit is not a solid-membership result, a contact manifold or proof that a body is balanced. Multiple chunks must be queried in their own coordinate frames; missing neighboring geometry remains unknown. Use repeated sample queries to build application-specific support policies rather than treating a single center hit as whole-object support.