Struct ReferenceMeshCompiler 

pub struct ReferenceMeshCompiler<B> { /* private fields */ }

Scalar reference compiler.

Generic over the boolean provider so this crate never depends on a particular one: axiolid-mesh-boolean-boolmesh is an adapter, and a different provider swaps in without touching this code.

Implementations

impl<B> ReferenceMeshCompiler<B>

pub const fn new(boolean: B) -> Self

Bind a boolean provider.

pub const fn boolean(&self) -> &B

The bound provider.

impl<B: MeshBoolean> ReferenceMeshCompiler<B>

pub const fn boolean_provider(&self) -> &B

The boolean provider this compiler dispatches to.

Exposed so an application can apply its own source-format set operations with the same provider the compiler uses, rather than constructing a second one that might differ.

pub fn compile_mesh_with_deviation( &self, graph: &GeometryGraph, root: NodeId, options: &ExecutionOptions, ) -> GeomResult<(CompileOutcome, DeviationReport)>

Compile one root and report how far its exact surface may lie from the mesh (#232).

The outcome is MeshCompiler::compile_mesh_reported’s. The report carries a certified upper bound on the distance from every point of the exact surface to the mesh’s triangles, in world units, the paths that contributed, and whether the bound is within the chord budget asked for; see crate::DeviationReport and the deviation module for what each path’s bound rests on. A path with no certified bound is named, and makes the overall bound None. A boolean is measured against the result crate::ReferenceExactCompiler builds for it, where it builds one (#235): that costs an exact compilation and a certified search for each boolean whose result the root emits (not for the inner booleans of a chain).

An inherent method rather than a MeshCompiler one: the bound is this compiler’s claim about its own meshes, and another compiler would have to prove its own before it could make it.

Errors

As MeshCompiler::compile_mesh_reported.

Trait Implementations

impl<B: MeshBoolean> Backend for ReferenceMeshCompiler<B>

fn descriptor(&self) -> BackendDescriptor

Runtime descriptor and capability inventory.

impl<B: Clone> Clone for ReferenceMeshCompiler<B>

fn clone(&self) -> ReferenceMeshCompiler<B>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Debug> Debug for ReferenceMeshCompiler<B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B: MeshBoolean> MeshCompiler for ReferenceMeshCompiler<B>

fn scratch_requirement(&self) -> ScratchRequirement

Bounded by the peak mesh size, which is data-dependent, so the honest answer is unbounded rather than an invented constant.

fn compile_mesh_reported( &self, graph: &GeometryGraph, root: NodeId, options: &ExecutionOptions, ) -> GeomResult<CompileOutcome>

Every channel on the result, and every channel an input had that the result lost, is reported with its fate (#115).

fn compile_mesh_batch_into( &self, graph: &GeometryGraph, roots: &[NodeId], options: &ExecutionOptions, destination: &mut Vec<TriMesh>, ) -> GeomResult<()>

Overriding the _into seam gives both call shapes one shared cache, so a subtree referenced by several roots is compiled once per batch.

fn compile_mesh( &self, graph: &GeometryGraph, root: NodeId, options: &ExecutionOptions, ) -> GeomResult<TriMesh>

Compile one root.

fn output_bound(&self) -> OutputBound

Outputs produced per requested root.

fn compile_mesh_batch( &self, graph: &GeometryGraph, roots: &[NodeId], options: &ExecutionOptions, ) -> Result<Vec<TriMesh>, GeomError>

Compile roots as a batch.

impl<B: MeshBoolean> PolylineCompiler for ReferenceMeshCompiler<B>

Curve nodes to polylines (#311): Curve2 (lifted to z = 0), Curve3 and OpenProfile, and their placements, each bisected until every span’s certified chord bound fits the budget. See crate::polyline for what is bounded how and what is refused.

fn compile_polyline( &self, graph: &GeometryGraph, root: NodeId, options: &ExecutionOptions, ) -> GeomResult<PolylineOutcome>

Compile one root to a polyline within the options’ chord budget.