okgeometry-api 1.4.0 → 1.5.0

package/src/Mesh.ts

@@ -2235,6 +2235,128 @@ export class Mesh {
     );
   }
 
+  /**
+   * Union many meshes into a single mesh in ONE WASM call.
+   *
+   * Substantially faster than chaining pairwise `union()` calls: every input
+   * crosses the JS/WASM boundary once, intermediate results never round-trip
+   * through buffers, mutually disjoint inputs are concatenated instead of
+   * run through CSG, and overlapping inputs are merged smallest-first.
+   *
+   * Requires all inputs to be closed volumes.
+   * @param meshes - Meshes to union (order does not affect the result)
+   * @param options - Optional safety overrides
+   * @returns New mesh containing the combined volume of all inputs
+   */
+  static unionAll(meshes: Mesh[], options?: MeshBooleanOptions): Mesh {
+    ensureInit();
+    const inputs = meshes
+      .filter((mesh) => mesh.faceCount > 0)
+      .map((mesh) => Mesh.normalizeClosedVolumeOrientation(mesh));
+    if (inputs.length === 0) return Mesh.emptyMesh();
+    if (inputs.length === 1) return Mesh.cloneMesh(inputs[0]);
+
+    const openCount = inputs.reduce((count, mesh) => count + (mesh.isClosedVolume() ? 0 : 1), 0);
+    if (openCount > 0) {
+      throw new Error(
+        `Boolean unionAll requires all inputs to be closed volumes (${openCount} of ${inputs.length} inputs are open). `
+        + "Close or cap the open meshes before calling unionAll().",
+      );
+    }
+
+    Mesh.enforceBatchBooleanLimits("unionAll", inputs, options);
+
+    const flags = inputs.every((mesh) => mesh._trustedBooleanInput) ? "trustedInput" : "";
+    const result = wasm.mesh_boolean_union_all(Mesh.packMeshes(inputs), flags);
+    return Mesh.decodeBatchBooleanResult("unionAll", result);
+  }
+
+  /**
+   * Subtract many cutter meshes from this mesh in ONE WASM call.
+   *
+   * The kernel culls cutters that miss this mesh's bounds, unions mutually
+   * overlapping cutters, combines disjoint cutters into one multi-shell
+   * operand, and performs a single CSG subtraction — instead of N pairwise
+   * subtractions that re-process the shrinking host every time.
+   *
+   * The fast batched path requires this mesh and all cutters to be closed
+   * volumes; open-mesh combinations fall back to sequential pairwise
+   * `subtract()` (which carries the split-based open-host trim semantics).
+   * @param others - Cutter meshes to subtract
+   * @param options - Optional safety overrides
+   * @returns New mesh with all cutter volumes removed from this
+   */
+  subtractAll(others: Mesh[], options?: MeshBooleanOptions): Mesh {
+    ensureInit();
+    if (this.faceCount === 0) return Mesh.emptyMesh();
+    const host = Mesh.normalizeClosedVolumeOrientation(this);
+    const cutters = others
+      .filter((mesh) => mesh.faceCount > 0)
+      .map((mesh) => Mesh.normalizeClosedVolumeOrientation(mesh));
+    if (cutters.length === 0) return Mesh.cloneMesh(host);
+    if (cutters.length === 1) return host.subtract(cutters[0], options);
+
+    if (!host.isClosedVolume() || cutters.some((mesh) => !mesh.isClosedVolume())) {
+      return cutters.reduce((acc: Mesh, cutter) => acc.subtract(cutter, options), host);
+    }
+
+    // Cheap bounds cull before crossing into WASM at all.
+    const hostBounds = Mesh.computeRawBounds(host);
+    const relevant = cutters.filter((cutter) => {
+      const cutterBounds = Mesh.computeRawBounds(cutter);
+      const contactTol = Mesh.booleanContactTolerance(hostBounds, cutterBounds);
+      return Mesh.boundsOverlap(hostBounds, cutterBounds, contactTol);
+    });
+    if (relevant.length === 0) return Mesh.cloneMesh(host);
+
+    Mesh.enforceBatchBooleanLimits("subtractAll", [host, ...relevant], options);
+
+    const flags = host._trustedBooleanInput && relevant.every((mesh) => mesh._trustedBooleanInput)
+      ? "trustedInput"
+      : "";
+    const result = wasm.mesh_boolean_difference_all(Mesh.packMeshes([host, ...relevant]), flags);
+    return Mesh.decodeBatchBooleanResult("subtractAll", result);
+  }
+
+  private static enforceBatchBooleanLimits(
+    operation: string,
+    inputs: Mesh[],
+    options?: MeshBooleanOptions,
+  ): void {
+    if (options?.allowUnsafe) return;
+    const limits = Mesh.resolveBooleanLimits(options?.limits);
+    let combinedInputFaces = 0;
+    for (const mesh of inputs) {
+      if (mesh.faceCount > limits.maxInputFacesPerMesh) {
+        throw new Error(
+          `Boolean ${operation} blocked by safety limits `
+          + `(input faces=${mesh.faceCount} > maxInputFacesPerMesh=${limits.maxInputFacesPerMesh}). `
+          + "Simplify inputs, run in a Worker, or pass allowUnsafe: true to force execution.",
+        );
+      }
+      combinedInputFaces += mesh.faceCount;
+    }
+    if (combinedInputFaces > limits.maxCombinedInputFaces) {
+      throw new Error(
+        `Boolean ${operation} blocked by safety limits `
+        + `(combined faces=${combinedInputFaces} > maxCombinedInputFaces=${limits.maxCombinedInputFaces}). `
+        + "Simplify inputs, run in a Worker, or pass allowUnsafe: true to force execution.",
+      );
+    }
+  }
+
+  private static decodeBatchBooleanResult(operation: string, result: Float64Array): Mesh {
+    if (result.length === 0) {
+      throw new Error(`Boolean ${operation} failed and returned an invalid mesh buffer.`);
+    }
+    const vertexCount = result[0];
+    if (!Number.isFinite(vertexCount) || vertexCount < 0) {
+      throw new Error(`Boolean ${operation} failed and returned a corrupt mesh buffer.`);
+    }
+    if (vertexCount === 0) return Mesh.emptyMesh();
+    return Mesh.fromTrustedBuffer(result);
+  }
+
   private splitWithMesh(other: Mesh, options?: MeshBooleanOptions): MeshSplitResult {
     ensureInit();