Struct IfcAPI 

pub struct IfcAPI { /* private fields */ }

Main IFC-Lite API

Implementations

impl IfcAPI

pub fn new() -> Self

Create and initialize the IFC API

pub fn is_ready(&self) -> bool

Check if API is initialized

pub fn parse_streaming(&self, content: String, callback: Function) -> Promise

Parse IFC file with streaming events Calls the callback function for each parse event

Example:

const api = new IfcAPI();
await api.parseStreaming(ifcData, (event) => {
  console.log('Event:', event);
});

pub fn parse(&self, content: String) -> Promise

Parse IFC file (traditional - waits for completion)

Example:

const api = new IfcAPI();
const result = await api.parse(ifcData);
console.log('Entities:', result.entityCount);

pub fn parse_zero_copy(&self, content: String) -> ZeroCopyMesh

Parse IFC file with zero-copy mesh data Maximum performance - returns mesh with direct memory access

Example:

const api = new IfcAPI();
const mesh = await api.parseZeroCopy(ifcData);

// Create TypedArray views (NO COPYING!)
const memory = await api.getMemory();
const positions = new Float32Array(
  memory.buffer,
  mesh.positions_ptr,
  mesh.positions_len
);

// Upload directly to GPU
gl.bufferData(gl.ARRAY_BUFFER, positions, gl.STATIC_DRAW);

pub fn parse_meshes(&self, content: String) -> MeshCollection

Parse IFC file and return individual meshes with express IDs and colors This matches the MeshData[] format expected by the viewer

Example:

const api = new IfcAPI();
const collection = api.parseMeshes(ifcData);
for (let i = 0; i < collection.length; i++) {
  const mesh = collection.get(i);
  console.log('Express ID:', mesh.expressId);
  console.log('Positions:', mesh.positions);
  console.log('Color:', mesh.color);
}

pub fn parse_meshes_instanced(&self, content: String) -> InstancedMeshCollection

Parse IFC file and return instanced geometry grouped by geometry hash This reduces draw calls by grouping identical geometries with different transforms

Example:

const api = new IfcAPI();
const collection = api.parseMeshesInstanced(ifcData);
for (let i = 0; i < collection.length; i++) {
  const geometry = collection.get(i);
  console.log('Geometry ID:', geometry.geometryId);
  console.log('Instances:', geometry.instanceCount);
  for (let j = 0; j < geometry.instanceCount; j++) {
    const inst = geometry.getInstance(j);
    console.log('  Express ID:', inst.expressId);
    console.log('  Transform:', inst.transform);
  }
}

pub fn parse_meshes_instanced_async( &self, content: String, options: JsValue, ) -> Promise

Parse IFC file with streaming instanced geometry batches for progressive rendering Groups identical geometries and yields batches of InstancedGeometry Uses fast-first-frame streaming: simple geometry (walls, slabs) first

Example:

const api = new IfcAPI();
await api.parseMeshesInstancedAsync(ifcData, {
  batchSize: 25,  // Number of unique geometries per batch
  onBatch: (geometries, progress) => {
    for (const geom of geometries) {
      renderer.addInstancedGeometry(geom);
    }
  },
  onComplete: (stats) => {
    console.log(`Done! ${stats.totalGeometries} unique geometries, ${stats.totalInstances} instances`);
  }
});

pub fn parse_meshes_async(&self, content: String, options: JsValue) -> Promise

Parse IFC file with streaming mesh batches for progressive rendering Calls the callback with batches of meshes, yielding to browser between batches

Example:

const api = new IfcAPI();
await api.parseMeshesAsync(ifcData, {
  batchSize: 100,
  onBatch: (meshes, progress) => {
    // Add meshes to scene
    for (const mesh of meshes) {
      scene.add(createThreeMesh(mesh));
    }
    console.log(`Progress: ${progress.percent}%`);
  },
  onComplete: (stats) => {
    console.log(`Done! ${stats.totalMeshes} meshes`);
  }
});

pub fn get_memory(&self) -> JsValue

Get WASM memory for zero-copy access

pub fn version(&self) -> String

Get version string

pub fn get_geo_reference(&self, content: String) -> Option<GeoReferenceJs>

Extract georeferencing information from IFC content Returns null if no georeferencing is present

Example:

const api = new IfcAPI();
const georef = api.getGeoReference(ifcData);
if (georef) {
  console.log('CRS:', georef.crsName);
  const [e, n, h] = georef.localToMap(10, 20, 5);
}

pub fn parse_meshes_with_rtc(&self, content: String) -> MeshCollectionWithRtc

Parse IFC file and return mesh with RTC offset for large coordinates This handles georeferenced models by shifting to centroid

Example:

const api = new IfcAPI();
const result = api.parseMeshesWithRtc(ifcData);
const rtcOffset = result.rtcOffset;
const meshes = result.meshes;

// Convert local coords back to world:
if (rtcOffset.isSignificant()) {
  const [wx, wy, wz] = rtcOffset.toWorld(localX, localY, localZ);
}

pub fn debug_process_entity_953(&self, content: String) -> String

Debug: Test processing entity #953 (FacetedBrep wall)

pub fn debug_process_first_wall(&self, content: String) -> String

Debug: Test processing a single wall

Trait Implementations

impl Default for IfcAPI

fn default() -> Self

Returns the “default value” for a type.

impl From<IfcAPI> for JsValue

fn from(value: IfcAPI) -> Self

Converts to this type from the input type.

impl FromWasmAbi for IfcAPI

type Abi = u32

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

unsafe fn from_abi(js: u32) -> Self

Recover a Self from Self::Abi.

impl IntoWasmAbi for IfcAPI

type Abi = u32

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

fn into_abi(self) -> u32

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

impl LongRefFromWasmAbi for IfcAPI

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = RcRef<IfcAPI>

Same as RefFromWasmAbi::Anchor

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

Same as RefFromWasmAbi::ref_from_abi

impl OptionFromWasmAbi for IfcAPI

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 IfcAPI

fn none() -> Self::Abi

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

impl RefFromWasmAbi for IfcAPI

type Abi = u32

The Wasm ABI type references to Self are recovered from.

type Anchor = RcRef<IfcAPI>

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 IfcAPI

type Abi = u32

Same as RefFromWasmAbi::Abi

type Anchor = RcRefMut<IfcAPI>

Same as RefFromWasmAbi::Anchor

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

Same as RefFromWasmAbi::ref_from_abi

impl TryFromJsValue for IfcAPI

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 IfcAPI

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

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

impl VectorIntoWasmAbi for IfcAPI

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

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

impl WasmDescribe for IfcAPI

fn describe()

impl WasmDescribeVector for IfcAPI

fn describe_vector()

impl SupportsConstructor for IfcAPI

impl SupportsInstanceProperty for IfcAPI

impl SupportsStaticProperty for IfcAPI