Struct MeshCollection 

pub struct MeshCollection { /* private fields */ }

Collection of mesh data for returning multiple meshes

Implementations

impl MeshCollection

pub fn geometry_hash_ids(&self) -> Uint32Array

Express ids for the per-entity geometry fingerprints, parallel to Self::geometry_hash_values. Empty unless geometry hashing was enabled via IfcAPI.setComputeGeometryHashes.

pub fn geometry_hash_values(&self) -> BigUint64Array

Per-entity geometry fingerprints as a BigUint64Array, parallel to Self::geometry_hash_ids. u64 is exposed (not hex strings) so JS can compare with === and key maps without allocation. Empty unless geometry hashing was enabled.

pub fn geometry_aabb_values(&self) -> Float64Array

Per-entity world-space AABBs as a Float64Array, SIX values per entry (minx, miny, minz, maxx, maxy, maxz), in the same order as Self::geometry_hash_ids — entry i spans [6*i, 6*i+6). Empty unless geometry hashing was enabled; the same IfcAPI.setComputeGeometryHashes switch gates both, so nothing is computed when the diff feature is off.

Unquantized world f64 (the file’s RTC folded back in), so two revisions that chose different RTC offsets report the same box. This is what lets a consumer say “MOVED” honestly instead of inferring it from a changed hash, which also fires on reshape and on retriangulation.

Frame: WebGL Y-up, like every other box, position, origin and placement that crosses this boundary (see MeshDataJs::local_bounds). The hasher accumulates in the producer’s IFC Z-up frame, so the swap (x,y,z) -> (x,z,-y) is applied here, on the way out. Unconverted, the boxes would not enclose the very meshes processGeometryBatch returns alongside them. Positions are RTC-relative and this box is absolute, so a consumer comparing the two folds rtcOffset* in — itself Y-up-swapped.

Present for every hashed entity. Its companion Self::geometry_volume_values is not — see there.

pub fn geometry_volume_values(&self) -> Float64Array

Per-entity enclosed volume in CUBIC METRES as a Float64Array, one value per entry in Self::geometry_hash_ids order. NaN means NO TRUSTWORTHY VOLUME — the same absent convention as Self::geometry_aabb_values — and it is NaN for roughly a third of entities by design, not by failure.

A value is emitted only when that entity’s produced geometry was PROVABLY a single closed, orientable, single-component solid, as decided by the mesher’s own orientation pass. Read ifc_lite_geometry::GeometryHasher::volume before treating a NaN as a bug: an open SurfaceModel, a material-layered wall (whose slices are open bands by construction), and any element assembled from more than one representation item all correctly report nothing rather than a plausible wrong number. Self::geometry_closure_flags says which.

This is NOT a substitute for an IFC BaseQuantities GrossVolume: it is the volume of the geometry that was actually meshed, after opening cuts, and it says nothing about whether a CSG degradation left the host uncut (see the diagnostics getter).

pub fn geometry_closure_flags(&self) -> Uint8Array

Per-entity topology verdict as a Uint8Array, one packed byte per entry in Self::geometry_hash_ids order:

• bit 0 (1) — every segment closed (no boundary / non-manifold edge)
• bit 1 (2) — every segment orientable
• bit 2 (4) — every segment a single connected component
• bit 3 (8) — the entity produced exactly one segment

0x0F is exactly the set that carries a volume in Self::geometry_volume_values. The individual bits are the diagnosis: a model checker can distinguish “this wall is an open shell” (bit 0 clear) from “this door is a multi-item assembly whose parts may overlap” (bit 3 clear), which are different findings with different fixes.

impl MeshCollection

pub fn push_geometry_hash(&mut self, fp: GeometryFingerprint)

Record one entity’s geometry fingerprint and everything the SAME hashing pass measured about it. Taken as a struct rather than five positional arguments precisely because the five arrays must stay index-parallel: there is one push site per entity, and a caller cannot supply three of the five and silently misalign every later entry.

Absent values are written in place, never skipped — None becomes a six-NaN box / a NaN volume — because shortening an array would mis-attribute every entry past it.

impl MeshCollection

pub fn length(&self) -> usize

Get number of meshes

pub fn get(&self, index: usize) -> Option<MeshDataJs>

Get mesh at index (clones — non-destructive). Prefer takeMesh on the hot streaming path; this stays for callers that read meshes more than once.

pub fn take_mesh(&mut self, index: usize) -> Option<MeshDataJs>

#1097 perf: MOVE the mesh at index out of the collection (the Vec buffers are std::mem::take-n, leaving an empty stub). The streaming worker reads each mesh exactly once, so moving avoids the full vertex- data clone get pays — one fewer copy of positions/normals/indices/uvs/ texture per mesh (the JS getters still do the single Rust→JS copy). Calling it twice for the same index yields the second call an empty mesh.

pub fn total_vertices(&self) -> usize

Get total vertex count across all meshes

pub fn total_triangles(&self) -> usize

Get total triangle count across all meshes

pub fn rtc_offset_x(&self) -> f64

Get RTC offset X (for converting local coords back to world coords) Add this to local X coordinates to get world X coordinates

pub fn rtc_offset_y(&self) -> f64

Get RTC offset Y

pub fn rtc_offset_z(&self) -> f64

Get RTC offset Z

pub fn has_rtc_offset(&self) -> bool

Check if RTC offset is significant (>10km)

pub fn building_rotation(&self) -> Option<f64>

Get building rotation angle in radians (from IfcSite placement) Returns None if no rotation was detected

pub fn geometry_hash_count(&self) -> usize

Number of per-entity geometry fingerprints recorded.

pub fn diagnostics(&self) -> JsValue

The batch’s typed CSG / opening diagnostics as a JS object (the GeometryDiagnostics contract), or undefined if none were recorded. The worker merges these across batches. One serialized value keeps the rich nested shape as a single FFI crossing instead of dozens of getters.

impl MeshCollection

pub fn new() -> Self

Create new empty collection

pub fn with_capacity(capacity: usize) -> Self

Create new collection with capacity hint

pub fn add(&mut self, mesh: MeshDataJs)

Add a mesh to the collection

pub fn set_diagnostics(&mut self, diagnostics: GeometryDiagnostics)

Attach the batch’s typed CSG / opening diagnostics (the public GeometryDiagnostics contract).

pub fn from_vec(meshes: Vec<MeshDataJs>) -> Self

Create from vec of meshes

pub fn len(&self) -> usize

Get number of meshes (internal)

pub fn is_empty(&self) -> bool

Check if collection is empty

pub fn set_rtc_offset(&mut self, x: f64, y: f64, z: f64)

Set the RTC offset (called during parsing when large coordinates are detected)

pub fn set_building_rotation(&mut self, rotation: Option<f64>)

Set the building rotation angle in radians

pub fn apply_rtc_offset(&mut self, x: f64, y: f64, z: f64)

Apply RTC offset to all meshes (shift coordinates) This is used when meshes are collected first and then shifted

Trait Implementations

impl Clone for MeshCollection

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for MeshCollection

fn default() -> Self

Returns the “default value” for a type.

impl From<MeshCollection> for JsValue

fn from(value: MeshCollection) -> Self

Converts to this type from the input type.

impl FromWasmAbi for MeshCollection

type Abi = WasmPtr<WasmRefCell<MeshCollection>>

The Wasm ABI type that this converts from when coming back out from the ABI boundary.

unsafe fn from_abi(js: Self::Abi) -> Self

Recover a Self from Self::Abi.

impl IntoWasmAbi for MeshCollection

type Abi = WasmPtr<WasmRefCell<MeshCollection>>

The Wasm ABI type that this converts into when crossing the ABI boundary.

fn into_abi(self) -> Self::Abi

Convert self into Self::Abi so that it can be sent across the wasm ABI boundary.

impl LongRefFromWasmAbi for MeshCollection

type Abi = WasmPtr<WasmRefCell<MeshCollection>>

Same as RefFromWasmAbi::Abi

type Anchor = RcRef<MeshCollection>

Same as RefFromWasmAbi::Anchor

unsafe fn long_ref_from_abi(js: Self::Abi) -> Self::Anchor

Same as RefFromWasmAbi::ref_from_abi

impl OptionFromWasmAbi for MeshCollection

fn is_none(abi: &Self::Abi) -> bool

Tests whether the argument is a “none” instance. If so it will be deserialized as None, and otherwise it will be passed to FromWasmAbi.

impl OptionIntoWasmAbi for MeshCollection

fn none() -> Self::Abi

Returns an ABI instance indicating “none”, which JS will interpret as the None branch of this option.

impl RefFromWasmAbi for MeshCollection

type Abi = WasmPtr<WasmRefCell<MeshCollection>>

The Wasm ABI type references to Self are recovered from.

type Anchor = RcRef<MeshCollection>

The type that holds the reference to Self for the duration of the invocation of the function that has an &Self parameter. This is required to ensure that the lifetimes don’t persist beyond one function call, and so that they remain anonymous.

unsafe fn ref_from_abi(js: Self::Abi) -> Self::Anchor

Recover a Self::Anchor from Self::Abi.

impl RefMutFromWasmAbi for MeshCollection

type Abi = WasmPtr<WasmRefCell<MeshCollection>>

Same as RefFromWasmAbi::Abi

type Anchor = RcRefMut<MeshCollection>

Same as RefFromWasmAbi::Anchor

unsafe fn ref_mut_from_abi(js: Self::Abi) -> Self::Anchor

Same as RefFromWasmAbi::ref_from_abi

impl SupportsConstructor for MeshCollection

impl SupportsInstanceProperty for MeshCollection

impl SupportsStaticProperty for MeshCollection

impl TryFromJsValue for MeshCollection

fn try_from_js_value(value: JsValue) -> Result<Self, JsValue>

Performs the conversion.

fn try_from_js_value_ref(value: &JsValue) -> Option<Self>

Performs the conversion.

impl VectorFromWasmAbi for MeshCollection

type Abi = <Box<[JsValue]> as FromWasmAbi>::Abi

unsafe fn vector_from_abi(js: Self::Abi) -> Box<[MeshCollection]>

impl VectorIntoWasmAbi for MeshCollection

type Abi = <Box<[JsValue]> as IntoWasmAbi>::Abi

fn vector_into_abi(vector: Box<[MeshCollection]>) -> Self::Abi

impl WasmDescribe for MeshCollection

fn describe()

impl WasmDescribeVector for MeshCollection

fn describe_vector()