bimatter-viewer-react 0.4.1 → 0.5.1

package/README.md

@@ -152,6 +152,37 @@ await loader.loadModel(["/models/model.bmt", "/models/model.ifc"]);
 await loader.loadModel(files);
 ```
 
+Use `useWorker` to parse BMT and IFC models outside the main thread:
+
+```ts
+const models = await loader.loadModel(["/models/model.ifc"], {
+    chunk: 200,
+    useIfcSpace: true,
+    useWorker: true,
+    onProgress: (event) => {
+        console.log(event.phase, Math.round(event.progress * 100));
+    },
+    onChunk: (chunk) => {
+        // Optional: add chunk.geometry to your viewer state for progressive render.
+        console.log(chunk.modelID, chunk.geometryID);
+    },
+});
+```
+
+For IFC, `chunk` controls how many geometries are packed before a streamed mesh is emitted. For BMT, chunks are read as they are already stored in the file.
+
+When you render chunks yourself in `onChunk`, set `collectWorkerChunks: false` to avoid keeping the same streamed geometry in the loader helper until the final result:
+
+```ts
+await loader.loadModel(["/models/model.bmt"], {
+    collectWorkerChunks: false,
+    useWorker: true,
+    onChunk: (chunk) => {
+        // Store chunk.geometry in your own model state.
+    },
+});
+```
+
 ## File Upload Example
 
 ```tsx
@@ -180,40 +211,6 @@ function App() {
 }
 ```
 
-## HotKeys
-
-### Selection
-
-`Left Click` - Select element
-
-`Shift + Left Click` - Multi-select element
-
-`Ctrl + Left Click` - Toggle element selection
-
-`Shift + Drag Right` - Select elements fully inside rectangle
-
-`Shift + Drag Left` - Select elements intersected by rectangle
-
-`Ctrl + Drag Right` - Unselect elements fully inside rectangle
-
-`Ctrl + Drag Left` - Unselect elements intersected by rectangle
-
-### Visibility
-
-`C` - Clear hidden / isolated elements
-
-`H` - Hide selected elements
-
-`I` - Isolate selected elements
-
-### Clipping
-
-`P` - Create clipping plane by model intersection
-
-### Dimensions
-
-`M` - Toggle dimension drawing mode
-
 ## Viewer API
 
 ```ts
@@ -574,3 +571,37 @@ viewerRef.current?.utils.setGridAxesVisibility({
     top: false,
 });
 ```
+
+## HotKeys
+
+### Selection
+
+`Left Click` - Select element
+
+`Shift + Left Click` - Multi-select element
+
+`Ctrl + Left Click` - Toggle element selection
+
+`Shift + Drag Right` - Select elements fully inside rectangle
+
+`Shift + Drag Left` - Select elements intersected by rectangle
+
+`Ctrl + Drag Right` - Unselect elements fully inside rectangle
+
+`Ctrl + Drag Left` - Unselect elements intersected by rectangle
+
+### Visibility
+
+`C` - Clear hidden / isolated elements
+
+`H` - Hide selected elements
+
+`I` - Isolate selected elements
+
+### Clipping
+
+`P` - Create clipping plane by model intersection
+
+### Dimensions
+
+`M` - Toggle dimension drawing mode

package/lib/Loaders/BmtLoader.d.ts

@@ -59,6 +59,24 @@ export interface BmtModelData {
     props: BmtModelProps;
     structure: BmtModelStructure;
 }
+export type BmtGeometryChunkData = {
+    chunkIndex: number;
+    geometry: BmtGeomData;
+    geometryID: number;
+    isIfcSpace: boolean;
+    loadedBytes: number;
+    totalBytes: number;
+};
+export type BmtParseProgressData = {
+    emittedChunks: number;
+    loadedBytes: number;
+    totalBytes: number;
+};
+export type BmtParseCallbacks = {
+    onGeometryChunk?: (chunk: BmtGeometryChunkData) => void;
+    onProgress?: (progress: BmtParseProgressData) => void;
+    streamGeometryChunks?: boolean;
+};
 type BmtMeshData = {
     colorId: BmtMaterialData;
     ids: Uint8Array;
@@ -93,7 +111,7 @@ export declare class BMTLoader {
     private getExternalMetadataPath;
     private loadExternalMetadata;
     private getModelNameFromPath;
-    loadModel(path: string): Promise<BmtModelData>;
-    parseBinaryFile(data: ArrayBuffer): BmtModelData;
+    loadModel(path: string, callbacks?: BmtParseCallbacks): Promise<BmtModelData>;
+    parseBinaryFile(data: ArrayBuffer, callbacks?: BmtParseCallbacks): BmtModelData;
 }
 export {};

package/lib/Loaders/IFCLoader/IFCLoader.d.ts

@@ -2,7 +2,7 @@ import { type IfcElementsAssembly } from "./PropertySerializer";
 import { Matrix4 } from "three";
 import { IfcAPI, type LocateFileHandlerFn } from "web-ifc";
 import { type GridData } from "./IfcGrid";
-import type { BmtModelData, BmtModelProps, BmtModelStructure } from "../BmtLoader";
+import type { BmtGeomData, BmtModelData, BmtModelProps, BmtModelStructure } from "../BmtLoader";
 type IfcParserOptions = {
     geometryTransformation?: number[];
     maxGeometriesPerMesh: number;
@@ -18,6 +18,25 @@ type IfcModelDataResult = {
 export type IfcModelSource = string | File;
 export type IfcLoadedModels = Record<number, BmtModelData>;
 export type IfcCoordinationMatrixSource = Matrix4 | number[] | string | null | undefined;
+export type IfcGeometryChunkData = {
+    chunkIndex: number;
+    geometry: BmtGeomData;
+    geometryID: number;
+    isIfcSpace: boolean;
+    totalChunks: number;
+};
+export type IfcGeometryProgressData = {
+    emittedChunks: number;
+    processed: number;
+    total: number;
+};
+export type IfcParsePhase = "opening" | "opened" | "streaming" | "properties" | "metadata";
+export type IfcParseCallbacks = {
+    onGeometryChunk?: (chunk: IfcGeometryChunkData) => void;
+    onGeometryProgress?: (progress: IfcGeometryProgressData) => void;
+    onPhase?: (phase: IfcParsePhase) => void;
+    streamGeometryChunks?: boolean;
+};
 export declare class IFCLoader {
     useIfcElemetAssembly: boolean;
     useIfcColors: boolean;
@@ -31,20 +50,20 @@ export declare class IFCLoader {
     chunk: number;
     maxMeshBytes: number;
     constructor();
-    getPath(): string;
-    initParser(func?: LocateFileHandlerFn): Promise<void>;
+    getPath: LocateFileHandlerFn;
+    initParser(func?: LocateFileHandlerFn, forceSingleThread?: boolean): Promise<void>;
     set wasmPath(path: string);
     get _parser(): IfcAPI;
     set _parser(parser: IfcAPI);
     loadModel(sources: IfcModelSource | IfcModelSource[], coordinationMatrix?: IfcCoordinationMatrixSource): Promise<IfcLoadedModels>;
-    parseBinaryFile(file: ArrayBuffer, coordinationMatrix?: IfcCoordinationMatrixSource): Promise<BmtModelData>;
+    parseBinaryFile(file: ArrayBuffer, coordinationMatrix?: IfcCoordinationMatrixSource, callbacks?: IfcParseCallbacks): Promise<BmtModelData>;
     private loadSingleModel;
     private parseInitializedBuffer;
     getModelData(path: string): Promise<IfcModelDataResult>;
     setCoordinationMatrix(matrix: IfcCoordinationMatrixSource): void;
     resetCoordinationMatrix(): void;
     get coordinationMatrixData(): string | undefined;
-    getModelDataFromBuffer(file: ArrayBuffer, coordinationMatrix?: IfcCoordinationMatrixSource): Promise<IfcModelDataResult | false>;
+    getModelDataFromBuffer(file: ArrayBuffer, coordinationMatrix?: IfcCoordinationMatrixSource, callbacks?: IfcParseCallbacks): Promise<IfcModelDataResult | false>;
     private createCoordinationMatrix;
     private getOptionalGridCoordinate;
     private transformGridPoint;
@@ -59,7 +78,14 @@ export declare class IfcParser {
     private readonly meshMatrix;
     private readonly normalMatrix;
     constructor(parser: IfcAPI, ifcModelID: number, options: IfcParserOptions);
-    parseData(allIds: Set<number>, elementsAssembly: IfcElementsAssembly | null, includeSpaces?: boolean): BmtModelData;
+    getGeometryProgressTotal(): number;
+    parseData(allIds: Set<number>, elementsAssembly: IfcElementsAssembly | null, includeSpaces?: boolean, callbacks?: IfcParseCallbacks): BmtModelData;
+    private parseDataStreaming;
+    private streamDynamicGeometryChunks;
+    private getDynamicChunkBuilder;
+    private writeGeometryPayloadToDynamicBuilder;
+    private flushDynamicGeometryChunks;
+    private emitDynamicGeometryChunk;
     private streamGeometryChunks;
     private applyGeometryTransformation;
     private planGeometryChunks;
@@ -75,6 +101,9 @@ export declare class IfcParser {
     private getGeometryByteSize;
     private writeGeometryPayload;
     private createModelDataFromChunks;
+    private getTotalChunkCount;
+    private emitCompletedGeometryChunk;
+    private createGeometryDataFromBuilder;
     private getElementId;
     private getFiniteNumber;
     private getDisplayColor;

package/lib/api/loader.d.ts

@@ -1,8 +1,20 @@
 import { type BmtModelData } from "../Loaders/BmtLoader";
+import { type BmtWorkerGeometryChunk, type IfcWorkerGeometryChunk, type WorkerProgressEvent } from "../workers";
 export type ViewerModelSource = string | File;
 export type ViewerLoadedModels = Record<number, BmtModelData>;
+export type ViewerLoaderWorkerChunk = (BmtWorkerGeometryChunk | IfcWorkerGeometryChunk) & {
+    modelID: number;
+};
 export type ViewerLoadModelOptions = {
+    chunk?: number;
+    collectWorkerChunks?: boolean;
+    maxMeshBytes?: number;
+    onChunk?: (chunk: ViewerLoaderWorkerChunk) => void;
+    onProgress?: (progress: WorkerProgressEvent) => void;
+    streamGeometryChunks?: boolean;
     useIfcSpace?: boolean;
+    useWorker?: boolean;
+    wasmPath?: string;
 };
 declare class ViewerLoaderApi {
     coordinationMatrix: string | undefined;
@@ -17,6 +29,10 @@ declare class ViewerLoaderApi {
     private getFileSourceMap;
     private applyBmtMetadata;
     private loadBmtModel;
+    private createWorkerProgressHandler;
+    private createWorkerChunkHandler;
+    private loadIfcModelInWorker;
+    private loadBmtModelInWorker;
     private resetCoordinationMatrixState;
     resetCoordinationMatrix(): void;
     loadModel(sources: ViewerModelSource | ViewerModelSource[], options?: ViewerLoadModelOptions): Promise<ViewerLoadedModels>;

package/lib/index.d.ts

@@ -3,9 +3,9 @@ export type { ViewerModelsData, ViewerProps } from "./Viewer";
 export type { ViewerApi, ViewerCameraApi, ViewerCameraGetIntersection, ViewerClippingApi, ViewerColorsApi, ViewerBmtConverterOptions, ViewerConverterApi, ViewerDimensionsApi, ViewerGeometryUtilsApi, ViewerSelection, ViewerSelectorApi, ViewerUtilsApi, } from "./api/ViewerApi";
 export type { ViewerPropertiesApi, ViewerPropertiesExcelOptions, } from "./api/ViewerPropertiesApi";
 export { BMTLoader } from "./Loaders/BmtLoader";
-export type { BmtModelGeometryData, BmtGeomData, BmtIndexArray, BmtMaterialData, BmtElementProps, BmtModelData, BmtModelProps, BmtModelStructure, BmtModelStructureNode, BmtPropertyRecord, BmtPropertySet, BmtPropertyValue, } from "./Loaders/BmtLoader";
+export type { BmtGeometryChunkData, BmtParseCallbacks, BmtParseProgressData, BmtModelGeometryData, BmtGeomData, BmtIndexArray, BmtMaterialData, BmtElementProps, BmtModelData, BmtModelProps, BmtModelStructure, BmtModelStructureNode, BmtPropertyRecord, BmtPropertySet, BmtPropertyValue, } from "./Loaders/BmtLoader";
 export { IFCLoader } from "./Loaders/IFCLoader/IFCLoader";
-export type { IfcLoadedModels, IfcModelSource, } from "./Loaders/IFCLoader/IFCLoader";
+export type { IfcLoadedModels, IfcGeometryChunkData, IfcModelSource, IfcParseCallbacks, } from "./Loaders/IFCLoader/IFCLoader";
 export { BmtConverter, ConvertIfcFileToBmt, ConvertToBmt, bmtConverter, } from "./Loaders/BmtConverter";
 export type { BmtActiveViewFilter, BmtActiveViewFilterParams, BmtConvertibleModels, BmtConversionResult, BmtConvertedFile, BmtConvertedFileType, BmtConverterOptions, BmtConverterSource, BmtVisibleIdsByModel, } from "./Loaders/BmtConverter";
 export { ModelGrids } from "./utils/ModelGrids";
@@ -13,7 +13,9 @@ export type { ModelGridAxis, ModelGridData, ModelGridPoint, ModelGridsProps, Mod
 export { exportExcel, exportModelPropertiesToExcel, } from "./utils/ExportUtils";
 export type { ExportedExcelFile, ExportModelSource, ModelPropertiesExcelOptions, } from "./utils/ExportUtils";
 export { loader } from "./api/loader";
-export type { ViewerLoadedModels, ViewerLoadModelOptions, ViewerModelSource, } from "./api/loader";
+export type { ViewerLoadedModels, ViewerLoadModelOptions, ViewerLoaderWorkerChunk, ViewerModelSource, } from "./api/loader";
+export { createBmtWorker, createIfcWorker, loadBmtModelsInWorker, loadIfcModelsInWorker, } from "./workers";
+export type { BmtWorkerClientOptions, BmtWorkerError, BmtWorkerGeometryChunk, BmtWorkerLoadedModels, BmtWorkerLoadOptions, BmtWorkerLoadRequest, BmtWorkerModelSource, BmtWorkerResponse, BmtWorkerSource, IfcWorkerClientOptions, IfcWorkerError, IfcWorkerGeometryChunk, IfcWorkerLoadedModels, IfcWorkerLoadOptions, IfcWorkerLoadRequest, IfcWorkerModelSource, IfcWorkerResponse, IfcWorkerSource, WorkerProgressEvent, WorkerProgressPhase, } from "./workers";
 export { FilteredElementsCollector } from "./Selector/FilteredElementsCollector";
 export type { FilteredElement, FilteredElementId, FilteredElementIdsResult, FilteredElementPredicate, FilteredElementsResult, FilteredElementsSource, FilteredElementWithModel, IfcClass, IfcClassName, } from "./Selector/FilteredElementsCollector";
 export { NavigationCube } from "./utils/NavigationCube";