Struct GeometryRouter 

pub struct GeometryRouter { /* private fields */ }

Geometry router - routes entities to processors

Implementations

impl GeometryRouter

pub fn detect_rtc_offset_from_first_element( &self, content: &str, decoder: &mut EntityDecoder<'_>, ) -> (f64, f64, f64)

Detect RTC offset by sampling multiple building elements and computing centroid This handles federated models where different elements may be in different world locations Returns the centroid of sampled element positions if coordinates are large (>10km)

pub fn process_element( &self, element: &DecodedEntity, decoder: &mut EntityDecoder<'_>, ) -> Result<Mesh>

Process building element (IfcWall, IfcBeam, etc.) into mesh Follows the representation chain: Element → Representation → ShapeRepresentation → Items

pub fn process_element_with_submeshes( &self, element: &DecodedEntity, decoder: &mut EntityDecoder<'_>, ) -> Result<SubMeshCollection>

Process element and return sub-meshes with their geometry item IDs. This preserves per-item identity for color/style lookup.

For elements with multiple styled geometry items (like windows with frames + glass), this returns separate sub-meshes that can receive different colors.

pub fn process_element_with_transform( &self, element: &DecodedEntity, decoder: &mut EntityDecoder<'_>, ) -> Result<(Mesh, Matrix4<f64>)>

Process building element and return geometry + transform separately Used for instanced rendering - geometry is returned untransformed, transform is separate

pub fn process_representation_item( &self, item: &DecodedEntity, decoder: &mut EntityDecoder<'_>, ) -> Result<Mesh>

Process a single representation item (IfcExtrudedAreaSolid, etc.) Uses hash-based caching for geometry deduplication across repeated floors

impl GeometryRouter

pub fn process_element_with_voids( &self, element: &DecodedEntity, decoder: &mut EntityDecoder<'_>, void_index: &FxHashMap<u32, Vec<u32>>, ) -> Result<Mesh>

Process element with void subtraction (openings) Process element with voids using optimized plane clipping

This approach is more efficient than full 3D CSG for rectangular openings:

1. Get chamfered wall mesh (preserves chamfered corners)
2. For each opening, use optimized box cutting with internal face generation
3. Apply any clipping operations (roof clips) from original representation Process an element with void subtraction (openings).

This function handles three distinct cases for cutting openings:

1. Floor/Slab openings (vertical Z-extrusion): Uses CSG with actual mesh geometry because the XY footprint may be rotated relative to the slab orientation.

2. Wall openings (horizontal X/Y-extrusion, axis-aligned): Uses AABB clipping for fast, accurate cutting of rectangular openings.

3. Diagonal wall openings: Uses AABB clipping without internal face generation to avoid rotation artifacts.

Important: Internal face generation is disabled for all openings because it causes visual artifacts (rotated faces, thin lines extending from models). The opening cutouts are still geometrically correct - only the internal “reveal” faces are omitted.

impl GeometryRouter

pub fn process_element_with_voids_2d( &self, element: &DecodedEntity, decoder: &mut EntityDecoder<'_>, void_index: &VoidIndex, ) -> Result<Mesh>

Process element with voids using 2D profile-level operations

This is a smarter and more efficient approach that:

1. Classifies voids as coplanar (can subtract in 2D) or non-planar (need 3D CSG)
2. Subtracts coplanar voids at the 2D profile level before extrusion
3. Falls back to 3D CSG only for non-planar voids

Benefits:

• 10-25x faster than full 3D CSG for most openings
• More reliable, especially for floors/slabs with many penetrations
• Cleaner geometry with fewer degenerate triangles

impl GeometryRouter

pub fn new() -> Self

Create new router with default processors

pub fn with_units(content: &str, decoder: &mut EntityDecoder<'_>) -> Self

Create router and extract unit scale from IFC file Automatically finds IFCPROJECT and extracts length unit conversion

pub fn with_units_and_rtc( content: &str, decoder: &mut EntityDecoder<'_>, rtc_offset: (f64, f64, f64), ) -> Self

Create router with unit scale extracted from IFC file AND RTC offset for large coordinates This is the recommended method for georeferenced models (Swiss UTM, etc.)

Arguments

• content - IFC file content
• decoder - Entity decoder
• rtc_offset - RTC offset to subtract from world coordinates (typically model centroid)

pub fn with_scale(unit_scale: f64) -> Self

Create router with pre-calculated unit scale

pub fn with_rtc(rtc_offset: (f64, f64, f64)) -> Self

Create router with RTC offset for large coordinate handling Use this for georeferenced models (e.g., Swiss UTM coordinates)

pub fn with_scale_and_rtc(unit_scale: f64, rtc_offset: (f64, f64, f64)) -> Self

Create router with both unit scale and RTC offset

pub fn set_rtc_offset(&mut self, offset: (f64, f64, f64))

Set the RTC offset for large coordinate handling

pub fn rtc_offset(&self) -> (f64, f64, f64)

Get the current RTC offset

pub fn has_rtc_offset(&self) -> bool

Check if RTC offset is active (non-zero)

pub fn unit_scale(&self) -> f64

Get the current unit scale factor

pub fn register(&mut self, processor: Box<dyn GeometryProcessor>)

Register a geometry processor

pub fn preprocess_faceted_breps( &self, brep_ids: &[u32], decoder: &mut EntityDecoder<'_>, )

Batch preprocess FacetedBrep entities for maximum parallelism Call this before processing elements to enable batch triangulation across all FacetedBrep entities instead of per-entity parallelism

pub fn take_cached_faceted_brep(&self, brep_id: u32) -> Option<Mesh>

Take FacetedBrep from cache (removes entry since each BREP is only used once) Returns owned Mesh directly - no cloning needed

pub fn schema(&self) -> &IfcSchema

Get schema reference

Trait Implementations

impl Default for GeometryRouter

fn default() -> Self

Returns the “default value” for a type.