bimatter-viewer-react 0.5.12 → 0.6.0

package/README.md

@@ -150,10 +150,16 @@ function App() {
 await loader.loadModel(["/models/model.bmt"]);
 await loader.loadModel(["/models/model.ifc"]);
 await loader.loadModel(["/models/model.ifc"], { useIfcSpace: true });
+await loader.loadModel(["/models/model.bmt"], { materialMode: "performance" });
+await loader.loadModel(["/models/model.bmt"], { useDoubleSideMaterial: true });
 await loader.loadModel(["/models/model.bmt", "/models/model.ifc"]);
 await loader.loadModel(files);
 ```
 
+`materialMode: "performance"` uses a cheaper unlit material. Use `"quality"` or omit it for the default lit material.
+
+`useDoubleSideMaterial` is disabled by default for better FPS. Enable it only when the model needs back faces to be visible.
+
 Use `useWorker` to parse BMT and IFC models outside the main thread:
 
 ```ts
@@ -531,6 +537,22 @@ if (viewer && firstLevel) {
 }
 ```
 
+## Performance Mode
+
+Use `performanceMode` for heavy models or weaker GPUs:
+
+```tsx
+<Viewer modelUrls={["/models/model.bmt"]} performanceMode />
+```
+
+It caps canvas DPR at `1`, disables antialiasing, asks the browser for a high-performance GPU, and uses `materialMode="performance"` unless another material mode is passed.
+
+You can also switch only the model material:
+
+```tsx
+<Viewer modelUrls={["/models/model.bmt"]} materialMode="performance" />
+```
+
 ## Stats And Profiling
 
 Enable FPS stats and console timing logs:

package/lib/{IFCLoader-B_gBDDmN.js → IFCLoader-RIJas-B5.js}

@@ -191328,60 +191328,61 @@ var h_ = class {
 	constructor(e) {
 		this.parser = e;
 	}
-	async serializeAllProperties(e, t) {
-		return await this.getPropertiesAsBlobs(e, t);
-	}
-	async getPropertiesAsBlobs(e, t) {
-		let n = await this.getAllRelDefinesByProps(e), r = {}, i = this.parser.GetLineIDsWithType(e, yd).get(0);
-		if (i === void 0) return r;
-		let a = await this.getItemProperty(e, i) ?? {
-			id: i,
+	async serializeAllProperties(e, t, n) {
+		return await this.getPropertiesAsBlobs(e, t, n);
+	}
+	async getPropertiesAsBlobs(e, t, n) {
+		let r = await this.getAllRelDefinesByProps(e), i = r.size, a = t.size, o = {}, s = this.parser.GetLineIDsWithType(e, yd).get(0);
+		if (s === void 0) return o;
+		let c = await this.getItemProperty(e, s) ?? {
+			id: s,
 			props: {},
 			sets: []
 		};
-		a.sets = [], r[i] = a;
-		for (let t of n) {
-			let n = await this.getItemProperty(e, t);
-			if (n) {
-				let t = p_(n.RelatingPropertyDefinition);
+		c.sets = [], o[s] = c;
+		let l = 0;
+		for (let t of r) {
+			let r = await this.getItemProperty(e, t);
+			if (r) {
+				let t = p_(r.RelatingPropertyDefinition);
 				if (t === null) continue;
-				let i = await this.getItemProperty(e, t, !0), a = {
+				let n = await this.getItemProperty(e, t, !0), i = {
 					id: t,
 					guid: "null",
 					name: "null",
 					props: [],
 					isQuantities: !1
 				};
-				if (i && (i.HasProperties || i.Quantities)) {
-					if (i.Quantities) for (let e of i.Quantities) this.formatItemProperties(e);
-					if (i.HasProperties) for (let e of i.HasProperties) this.formatItemProperties(e);
-					a = {
+				if (n && (n.HasProperties || n.Quantities)) {
+					if (n.Quantities) for (let e of n.Quantities) this.formatItemProperties(e);
+					if (n.HasProperties) for (let e of n.HasProperties) this.formatItemProperties(e);
+					i = {
 						id: t,
-						guid: this.getStringValue(i.GlobalId) ?? "null",
-						name: this.getStringValue(i.Name) ?? "null",
-						props: i.HasProperties ? i.HasProperties : i.Quantities ? i.Quantities : [],
-						isQuantities: !!i.Quantities
+						guid: this.getStringValue(n.GlobalId) ?? "null",
+						name: this.getStringValue(n.Name) ?? "null",
+						props: n.HasProperties ? n.HasProperties : n.Quantities ? n.Quantities : [],
+						isQuantities: !!n.Quantities
 					};
 				}
-				let o = m_(n.RelatedObjects);
-				for (let t of o) if (r[t]) r[t].sets ??= [], r[t].sets.push(a);
+				let a = m_(r.RelatedObjects);
+				for (let t of a) if (o[t]) o[t].sets ??= [], o[t].sets.push(i);
 				else {
 					let n = await this.getItemProperty(e, t);
 					if (n) {
-						let e = this.getStringValue(n.GlobalId), i = n.Name, o = n.ObjectType, s = n.LongName, c = this.getStringValue(n.type), l = {
-							name: i,
-							typeName: o,
+						let e = this.getStringValue(n.GlobalId), r = n.Name, a = n.ObjectType, s = n.LongName, c = this.getStringValue(n.type), l = {
+							name: r,
+							typeName: a,
 							longName: s,
 							type: c,
 							elevation: void 0
 						};
-						r[t] = {
+						o[t] = {
 							id: t,
 							guid: e,
 							props: l,
-							sets: [a]
+							sets: [i]
 						}, c === "IfcBuildingStorey" && (l.elevation = n.Elevation);
-					} else r[t] = {
+					} else o[t] = {
 						id: t,
 						guid: "null",
 						props: {
@@ -191391,16 +191392,29 @@ var h_ = class {
 							type: "null",
 							elevation: void 0
 						},
-						sets: [a]
+						sets: [i]
 					};
 				}
 			}
+			l += 1, this.shouldEmitProgress(l, i) && n?.({
+				loaded: l,
+				phase: "propertySets",
+				total: i
+			});
 		}
-		for (let n of t) {
-			if (r[n]) continue;
-			let t = await this.getItemProperty(e, n);
-			t ? r[n] = {
-				id: n,
+		let u = 0;
+		for (let r of t) {
+			if (o[r]) {
+				u += 1, this.shouldEmitProgress(u, a) && n?.({
+					loaded: u,
+					phase: "elements",
+					total: a
+				});
+				continue;
+			}
+			let t = await this.getItemProperty(e, r);
+			t ? o[r] = {
+				id: r,
 				guid: this.getStringValue(t.GlobalId),
 				props: {
 					name: t.Name,
@@ -191410,8 +191424,8 @@ var h_ = class {
 					elevation: void 0
 				},
 				sets: []
-			} : r[n] = {
-				id: n,
+			} : o[r] = {
+				id: r,
 				guid: "null",
 				props: {
 					name: "null",
@@ -191421,9 +191435,13 @@ var h_ = class {
 					elevation: void 0
 				},
 				sets: []
-			};
+			}, u += 1, this.shouldEmitProgress(u, a) && n?.({
+				loaded: u,
+				phase: "elements",
+				total: a
+			});
 		}
-		return r;
+		return o;
 	}
 	async getItemProperty(e, t, n = !1) {
 		try {
@@ -191585,6 +191603,9 @@ var h_ = class {
 		let i = m_(n[t.related]);
 		e[r] == null ? e[r] = i : e[r] = e[r].concat(i);
 	}
+	shouldEmitProgress(e, t) {
+		return t <= 0 || e <= 0 || e >= t ? !0 : e % Math.max(1, Math.floor(t / 100)) === 0;
+	}
 };
 //#endregion
 //#region src/viewer/Loaders/IFCLoader/IfcGrid.ts
@@ -191820,7 +191841,7 @@ var __ = class {
 				n && (d[t] = this.transformGridData(n, l));
 			}
 			r?.onPhase?.("properties");
-			let f = await this.propertySerializer.serializeAllProperties(a, o), p = await this.propertySerializer.getSpatialStructure(a, !1);
+			let f = await this.propertySerializer.serializeAllProperties(a, o, r?.onPropertiesProgress), p = await this.propertySerializer.getSpatialStructure(a, !1);
 			return c.coordinationMatrix ??= this.coordinationMatrixData, c.props = f, c.structure = p, c.grids = d, {
 				structure: p,
 				propsData: f,

package/lib/Loaders/BmtConverter.d.ts

@@ -11,6 +11,16 @@ export type BmtActiveViewFilterParams = {
     modelID: number;
 };
 export type BmtActiveViewFilter = (params: BmtActiveViewFilterParams) => boolean;
+export type BmtConverterProgressPhase = "preparing" | "filtering" | "properties" | "geometry" | "metadata" | "writing" | "complete";
+export type BmtConverterProgressEvent = {
+    loaded?: number;
+    message?: string;
+    modelID: number;
+    modelIndex: number;
+    phase: BmtConverterProgressPhase;
+    progress: number;
+    total?: number;
+};
 export type BmtConverterOptions = {
     activeView?: boolean;
     activeViewRoot?: Object3D | Object3D[] | null;
@@ -20,6 +30,7 @@ export type BmtConverterOptions = {
     fileNames?: Record<string | number, string>;
     filterElement?: BmtActiveViewFilter;
     maxMeshBytes?: number;
+    onProgress?: (progress: BmtConverterProgressEvent) => void;
     useIfcColors?: boolean;
     useIfcElementAssembly?: boolean;
     useIfcSpace?: boolean;
@@ -89,6 +100,8 @@ export declare class BmtConverter {
     private deflateBytes;
     private encodeText;
     private encodePrettyJson;
+    private shouldEmitItemProgress;
+    private clampProgress;
     private isRecord;
 }
 export declare const bmtConverter: BmtConverter;

package/lib/Loaders/BmtLoader.d.ts

@@ -1,5 +1,6 @@
 import pako from "pako";
 import type { ModelGridsData } from "../utils/ModelGrids";
+import type { ViewerMaterialMode } from "../types";
 export type BmtIndexArray = Uint16Array | Uint32Array;
 export interface BmtMaterialData {
     r: number;
@@ -51,12 +52,17 @@ export type BmtModelStructureNode = {
 };
 export type BmtModelStructure = BmtModelStructureNode | BmtModelStructureNode[] | Record<string, BmtModelStructureNode>;
 export type BmtModelGeometryData = Record<number, BmtGeomData>;
+export type BmtModelRenderSettings = {
+    materialMode?: ViewerMaterialMode;
+    useDoubleSideMaterial?: boolean;
+};
 export interface BmtModelData {
     coordinationMatrix?: string;
     data: BmtModelGeometryData;
     grids?: ModelGridsData;
     name?: string;
     props: BmtModelProps;
+    renderSettings?: BmtModelRenderSettings;
     structure: BmtModelStructure;
 }
 export type BmtGeometryChunkData = {

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

@@ -1,4 +1,4 @@
-import { type IfcElementsAssembly } from "./PropertySerializer";
+import { type IfcElementsAssembly, type IfcPropertiesProgressData } from "./PropertySerializer";
 import { Matrix4 } from "three";
 import { IfcAPI, type LocateFileHandlerFn } from "web-ifc";
 import { type GridData } from "./IfcGrid";
@@ -30,11 +30,13 @@ export type IfcGeometryProgressData = {
     processed: number;
     total: number;
 };
+export type IfcPropertyProgressData = IfcPropertiesProgressData;
 export type IfcParsePhase = "opening" | "opened" | "streaming" | "properties" | "metadata";
 export type IfcParseCallbacks = {
     onGeometryChunk?: (chunk: IfcGeometryChunkData) => void;
     onGeometryProgress?: (progress: IfcGeometryProgressData) => void;
     onPhase?: (phase: IfcParsePhase) => void;
+    onPropertiesProgress?: (progress: IfcPropertyProgressData) => void;
     streamGeometryChunks?: boolean;
 };
 export declare class IFCLoader {

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

@@ -30,12 +30,18 @@ export type IfcElementsAssembly = {
     dict: Record<number, number>;
     ids: number[];
 };
+export type IfcPropertiesProgressData = {
+    loaded: number;
+    phase: "propertySets" | "elements";
+    total: number;
+};
+export type IfcPropertiesProgressCallback = (progress: IfcPropertiesProgressData) => void;
 export declare class PropertySerializer {
     private PropsNames;
     readonly parser: IfcAPI;
     constructor(parser: IfcAPI);
-    serializeAllProperties(modelID: number, ids: Set<number>): Promise<BmtModelProps>;
-    getPropertiesAsBlobs(modelID: number, ids: Set<number>): Promise<BmtModelProps>;
+    serializeAllProperties(modelID: number, ids: Set<number>, onProgress?: IfcPropertiesProgressCallback): Promise<BmtModelProps>;
+    getPropertiesAsBlobs(modelID: number, ids: Set<number>, onProgress?: IfcPropertiesProgressCallback): Promise<BmtModelProps>;
     getItemProperty(modelID: number, id: number, flatten?: boolean): Promise<IfcLineData | null>;
     getElementsAssembly(modelID: number): Promise<IfcElementsAssembly>;
     private formatItemProperties;
@@ -53,5 +59,6 @@ export declare class PropertySerializer {
     newNode(id: number, data: IfcLineData): BmtModelStructureNode;
     getSpatialTreeChunks(modelID: number): Promise<SpatialTreeChunks>;
     saveChunk(chunks: SpatialTreeChunks, propNames: PropertyRelationConfig, rel: IfcLineData): void;
+    private shouldEmitProgress;
 }
 export {};

package/lib/Model.d.ts

@@ -1,14 +1,16 @@
 import type { BmtModelData } from "./Loaders/BmtLoader";
 import { Matrix4, type DataTexture } from "three";
+import type { ViewerMaterialMode } from "./types";
 type ModelProps = {
     colorPaletteTexture: DataTexture;
     coordinationMatrix?: Matrix4 | null;
     modelID: number;
     data: BmtModelData;
+    materialMode?: ViewerMaterialMode;
 };
 export declare function parseModelMatrix(matrix?: string): Matrix4 | null;
 export declare function getModelCoordinationMatrix(data: BmtModelData): Matrix4 | null;
 export declare function getModelCoordinationMatrixSource(data: BmtModelData): string | undefined;
-declare function Model({ colorPaletteTexture, coordinationMatrix, modelID, data, }: ModelProps): import("react/jsx-runtime").JSX.Element;
+declare function Model({ colorPaletteTexture, coordinationMatrix, modelID, data, materialMode: materialModeOverride, }: ModelProps): import("react/jsx-runtime").JSX.Element;
 declare const _default: import("react").MemoExoticComponent<typeof Model>;
 export default _default;

package/lib/SelectableMesh.d.ts

@@ -1,12 +1,15 @@
 import React from "react";
 import { Matrix4, type DataTexture } from "three";
 import type { BmtGeomData, BmtMaterialData } from "./Loaders/BmtLoader";
+import type { ViewerMaterialMode } from "./types";
 type SelectableMeshProps = {
     colorPaletteTexture: DataTexture;
     data: BmtGeomData;
     isIfcSpace?: boolean;
     material: BmtMaterialData;
+    materialMode?: ViewerMaterialMode;
     meshMatrix: Matrix4;
+    useDoubleSideMaterial?: boolean;
 };
-export declare const SelectableMesh: React.MemoExoticComponent<({ colorPaletteTexture, material, data, isIfcSpace, meshMatrix, }: SelectableMeshProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const SelectableMesh: React.MemoExoticComponent<({ colorPaletteTexture, material, materialMode, data, isIfcSpace, meshMatrix, useDoubleSideMaterial, }: SelectableMeshProps) => import("react/jsx-runtime").JSX.Element>;
 export {};

package/lib/Selector/useSelector.d.ts

@@ -1,3 +1,4 @@
+import { type Vector3 } from "three";
 import type { CameraUtilsApi } from "../Camera/useCameraUtils";
 import type { ViewerControlsRef, ViewerModelRef } from "../types";
-export default function useSelector(modelRef: ViewerModelRef, controlRef: ViewerControlsRef, cameraUtils: CameraUtilsApi): void;
+export default function useSelector(modelRef: ViewerModelRef, controlRef: ViewerControlsRef, cameraUtils: CameraUtilsApi, setSelectionOrbitPoint?: (point: Vector3) => void): void;

package/lib/Viewer.d.ts

@@ -1,6 +1,7 @@
 import { type ComponentProps } from "react";
 import type { BmtModelData } from "./Loaders/BmtLoader";
 import { Canvas } from "@react-three/fiber";
+import type { ViewerMaterialMode } from "./types";
 import { type ViewerApi, type ViewerSelection } from "./api/ViewerApi";
 import { type ViewerModelSource } from "./api/loader";
 type ModelsData = Record<number, BmtModelData>;
@@ -10,11 +11,13 @@ export type ViewerProps = {
     camera?: ComponentProps<typeof Canvas>["camera"];
     dpr?: ComponentProps<typeof Canvas>["dpr"];
     defaultSelected?: ViewerSelection;
+    materialMode?: ViewerMaterialMode;
     modelUrls?: string[];
     modelSources?: ViewerModelSource[];
     modelsData?: ModelsData;
     onReady?: (api: ViewerApi) => void;
     onSelectedChange?: (selected: ViewerSelection) => void;
+    performanceMode?: boolean;
     selected?: ViewerSelection;
     showNavCube?: boolean;
     showStats?: boolean;

package/lib/api/loader.d.ts

@@ -1,5 +1,6 @@
 import { type BmtModelData } from "../Loaders/BmtLoader";
 import { type BmtWorkerGeometryChunk, type IfcWorkerGeometryChunk, type WorkerProgressEvent } from "../workers";
+import type { ViewerMaterialMode } from "../types";
 export type ViewerModelSource = string | File;
 export type ViewerLoadedModels = Record<number, BmtModelData>;
 export type ViewerLoaderWorkerChunk = (BmtWorkerGeometryChunk | IfcWorkerGeometryChunk) & {
@@ -8,10 +9,12 @@ export type ViewerLoaderWorkerChunk = (BmtWorkerGeometryChunk | IfcWorkerGeometr
 export type ViewerLoadModelOptions = {
     chunk?: number;
     collectWorkerChunks?: boolean;
+    materialMode?: ViewerMaterialMode;
     maxMeshBytes?: number;
     onChunk?: (chunk: ViewerLoaderWorkerChunk) => void;
     onProgress?: (progress: WorkerProgressEvent) => void;
     streamGeometryChunks?: boolean;
+    useDoubleSideMaterial?: boolean;
     useIfcSpace?: boolean;
     useWorker?: boolean;
     wasmPath?: string;
@@ -34,6 +37,7 @@ declare class ViewerLoaderApi {
     private loadIfcModelInWorker;
     private loadBmtModelInWorker;
     private resetCoordinationMatrixState;
+    private applyRenderSettings;
     resetCoordinationMatrix(): void;
     loadModel(sources: ViewerModelSource | ViewerModelSource[], options?: ViewerLoadModelOptions): Promise<ViewerLoadedModels>;
 }