Struct ClippingProcessor 

pub struct ClippingProcessor {
    pub epsilon: f64,
    /* private fields */
}

CSG Clipping Processor

Fields

epsilon: f64

Epsilon for floating point comparisons

Implementations

impl ClippingProcessor

pub fn new() -> Self

Create a new clipping processor

pub fn take_failures(&self) -> Vec<BoolFailure>

Drain and return the failures recorded by this processor since its creation (or the last take_failures call). The processor’s internal log is cleared.

pub fn failure_count(&self) -> usize

Number of failures currently buffered (without draining).

pub fn clip_triangle(&self, triangle: &Triangle, plane: &Plane) -> ClipResult

Clip a triangle against a plane Returns triangles that are in front of the plane

pub fn subtract_mesh( &self, host_mesh: &Mesh, opening_mesh: &Mesh, ) -> Result<Mesh>

Subtract opening mesh from host mesh using CSG boolean operations on the pure-Rust exact mesh-arrangement kernel.

On any failure path the host is returned un-cut and a BoolFailure record is appended to the processor’s failure log (drainable via Self::take_failures). An empty host returns an empty mesh without recording a failure (it’s a fast path, not a fallback).

pub fn subtract_mesh_many( &self, host_mesh: &Mesh, cutters: &[&Mesh], ) -> Result<Mesh>

Subtract a GROUP of pairwise-disjoint opening cutters from the host in ONE conforming arrangement (disjoint-cutter batching).

A REJECTED group (the N-ary arrangement could not fully conform, or no cutter overlaps the host) returns the host UN-CUT and records NO failure: rejection is the expected, handled outcome — the router’s per-opening sequential loop (with the full #635 fallback machinery and its own diagnostics) immediately takes over for the group’s members, so a failure record here would be pure noise on elements whose voids end up perfectly cut (the issue-582/583 zero-CSG-failure bar). Only a genuinely invalid kernel OUTPUT records, exactly like Self::subtract_mesh.

pub fn union_mesh(&self, mesh_a: &Mesh, mesh_b: &Mesh) -> Result<Mesh>

Union two meshes together using CSG boolean operations on the pure-Rust exact kernel.

Empty operands are handled silently — they have a unique correct answer.

pub fn intersection_mesh(&self, mesh_a: &Mesh, mesh_b: &Mesh) -> Result<Mesh>

Intersect two meshes using CSG boolean operations on the pure-Rust exact kernel.

Returns the intersection of two meshes (the volume where both overlap).

pub fn union_meshes(&self, meshes: &[Mesh]) -> Result<Mesh>

Union multiple meshes together

Convenience method that sequentially unions all non-empty meshes. Skips empty meshes to avoid unnecessary CSG operations.

pub fn clip_mesh(&self, mesh: &Mesh, plane: &Plane) -> Result<Mesh>

Clip an entire mesh against a plane

Trait Implementations

impl Default for ClippingProcessor

fn default() -> Self

Returns the “default value” for a type.