bimatter-viewer-react 0.5.13 → 0.6.1

package/README.md

@@ -111,13 +111,13 @@ You can also load mixed model lists:
 />
 ```
 
-IFC spaces are disabled by default. Enable them per load when room volumes should be loaded as an almost-transparent gray mesh:
+IFC spaces are loaded by default when the IFC contains room geometry, but they are hidden in the viewer by default. Disable loading them when room volumes are not needed:
 
 ```ts
 import { loader } from "bimatter-viewer-react";
 
 await loader.loadModel(["/models/architecture.ifc"], {
-    useIfcSpace: true,
+    useIfcSpace: false,
 });
 ```
 
@@ -149,17 +149,22 @@ function App() {
 ```ts
 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.ifc"], { useIfcSpace: false });
+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
 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));
@@ -412,12 +417,11 @@ await viewerRef.current?.converter.convertIfcFileToBmt(files, {
     fileName: "converted_ifc",
     useIfcColors: true,
     useIfcElementAssembly: true,
-    useIfcSpace: true,
     useMinVersion: true,
 });
 ```
 
-`useIfcColors`, `useIfcElementAssembly`, and `useIfcSpace` are used when converting IFC files directly. They do not change already loaded model data in `convertToBmt`. `useIfcSpace` loads IFCSPACE geometry as a separate almost-transparent gray mesh when the IFC contains room geometry.
+`useIfcColors`, `useIfcElementAssembly`, and `useIfcSpace` are used when converting IFC files directly. They do not change already loaded model data in `convertToBmt`. `useIfcSpace` is enabled by default and loads IFCSPACE geometry as a separate almost-transparent gray mesh when the IFC contains room geometry.
 
 ## Controlled Selection
 
@@ -531,6 +535,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-RIJas-B5.js → IFCLoader-Cjkb3xMA.js}

@@ -191720,7 +191720,7 @@ var __ = class {
 }, y_ = class {
 	useIfcElemetAssembly = !1;
 	useIfcColors = !1;
-	useIfcSpace = !1;
+	useIfcSpace = !0;
 	coordinationMatrix = null;
 	parser;
 	propertySerializer;

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/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/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>;
 }