bimatter-viewer-react 0.2.0 → 0.4.0

package/README.md

@@ -4,10 +4,12 @@ React viewer for Bimatter `.bmt` models and `.ifc` models.
 
 All about us you can see on our website [Bimatter](https://bimatter.ru/)
 
-Vanila js viewer core: [bimatter-viewer](https://www.npmjs.com/package/bimatter-viewer?activeTab=code)
+[Demo viewer](https://rkaeplive.github.io/bimatter-viewer-react/)
 
 [GitHub](https://github.com/rkaeplive/bimatter-viewer-react)
 
+Vanila js viewer core: [bimatter-viewer](https://www.npmjs.com/package/bimatter-viewer?activeTab=code)
+
 Write your issuse here: [GitHub](https://github.com/rkaeplive/bimatter-viewer-react/issues)
 
 ## License
@@ -107,6 +109,16 @@ 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:
+
+```ts
+import { loader } from "bimatter-viewer-react";
+
+await loader.loadModel(["/models/architecture.ifc"], {
+    useIfcSpace: true,
+});
+```
+
 ## Loader API
 
 You can load models yourself and pass parsed data to the viewer:
@@ -135,6 +147,7 @@ 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.bmt", "/models/model.ifc"]);
 await loader.loadModel(files);
 ```
@@ -193,10 +206,20 @@ function App() {
 
 `I` - Isolate selected elements
 
+### Clipping
+
+`P` - Create clipping plane by model intersection
+
+### Dimensions
+
+`M` - Toggle dimension drawing mode
+
 ## Viewer API
 
 ```ts
 viewerRef.current?.camera.fitCamera();
+viewerRef.current?.camera.getIntersection();
+viewerRef.current?.camera.getIntersection(true);
 
 viewerRef.current?.geometryUtils.showAll();
 viewerRef.current?.geometryUtils.showByIds([1, 2, 3]);
@@ -206,21 +229,63 @@ viewerRef.current?.geometryUtils.isolateByIds([1, 2, 3]);
 viewerRef.current?.geometryUtils.isolateSelected();
 viewerRef.current?.geometryUtils.resetIsolation();
 viewerRef.current?.geometryUtils.getAllIds();
+viewerRef.current?.geometryUtils.setIfcSpacesVisibility(false);
+viewerRef.current?.geometryUtils.getIfcSpacesVisibility();
+viewerRef.current?.geometryUtils.toggleIIfcSpacesVisibility();
 
 viewerRef.current?.selector.setSelected(0, [10, 20], true);
 viewerRef.current?.selector.addSelected(0, [30]);
 viewerRef.current?.selector.removeSelected(0, [10]);
 viewerRef.current?.selector.resetSelection();
 viewerRef.current?.selector.getSelected();
+viewerRef.current?.selector.setSelectionColor("#1194bd");
+viewerRef.current?.selector.getSelectionColor();
+viewerRef.current?.selector.setPreselectionColor("#68c6e3");
+viewerRef.current?.selector.getPreselectionColor();
 
 viewerRef.current?.colors.setColor(0, [10, 20], "#ff3355");
 viewerRef.current?.colors.clearColor(0, [10]);
 viewerRef.current?.colors.clearModelColors(0);
 viewerRef.current?.colors.clearAllColors();
 
+viewerRef.current?.converter.convertToBmt({
+    activeView: true,
+    useMinVersion: true,
+});
+viewerRef.current?.converter.convertIfcFileToBmt(files, {
+    useIfcColors: true,
+    useIfcElementAssembly: true,
+    useIfcSpace: true,
+    useMinVersion: true,
+});
+
+viewerRef.current?.clipping.createPlane();
+viewerRef.current?.clipping.createClippingRectangle();
+viewerRef.current?.clipping.toggle();
+viewerRef.current?.clipping.setActive(true);
+viewerRef.current?.clipping.setEdgesActive(true);
+viewerRef.current?.clipping.setHelpersActive(true);
+viewerRef.current?.clipping.deleteAllPlanes();
+
+viewerRef.current?.dimensions.setActive(true);
+viewerRef.current?.dimensions.toggle();
+viewerRef.current?.dimensions.cancelDrawing();
+viewerRef.current?.dimensions.changeAxes();
+viewerRef.current?.dimensions.delete();
+viewerRef.current?.dimensions.deleteAll();
+viewerRef.current?.dimensions.setUnit("mm");
+viewerRef.current?.dimensions.setColor("#111827");
+viewerRef.current?.dimensions.setWidth(1);
+viewerRef.current?.dimensions.setSnapDistance(1);
+viewerRef.current?.dimensions.setEndpointScaleFactor(0.015);
+viewerRef.current?.dimensions.getDimensions();
+
 viewerRef.current?.properties.getModelProps();
 viewerRef.current?.properties.getModelStructure();
 viewerRef.current?.utils.getUserDevice();
+viewerRef.current?.utils.getDefaultHotkeysEnabled();
+viewerRef.current?.utils.setDefaultHotkeysEnabled(false);
+viewerRef.current?.utils.toggleDefaultHotkeys();
 viewerRef.current?.utils.getShowStats();
 viewerRef.current?.utils.setShowStats(true);
 viewerRef.current?.utils.getShowNavCube();
@@ -272,6 +337,8 @@ function App() {
 }
 ```
 
+IFC space visibility is a separate mesh-level layer. When spaces are disabled through `setIfcSpacesVisibility(false)`, `showAll()` does not show them again; use `setIfcSpacesVisibility(true)` or `toggleIIfcSpacesVisibility()` for that.
+
 ## Colorize Elements
 
 Use `viewerRef.current.colors` to apply temporary color overrides to model elements. The color is applied by `modelID` and element ids:
@@ -320,6 +387,89 @@ function App() {
 }
 ```
 
+## Convert To BMT
+
+Use `viewerRef.current.converter` to export loaded models to the BMT format. With `activeView: true`, the converter uses the current viewer state and exports only visible elements.
+
+```tsx
+import { useRef } from "react";
+import { Viewer, type ViewerApi } from "bimatter-viewer-react";
+
+function downloadFiles(files: { blob: Blob; name: string }[]) {
+    files.forEach((file) => {
+        const url = URL.createObjectURL(file.blob);
+        const link = document.createElement("a");
+
+        link.href = url;
+        link.download = file.name;
+        link.click();
+        URL.revokeObjectURL(url);
+    });
+}
+
+function App() {
+    const viewerRef = useRef<ViewerApi>(null);
+
+    function convertToBmt() {
+        const result = viewerRef.current?.converter.convertToBmt({
+            activeView: true,
+            fileName: "model",
+            useMinVersion: true,
+        });
+
+        if (result) {
+            downloadFiles(result.files);
+        }
+    }
+
+    return (
+        <>
+            <button onClick={convertToBmt}>Export BMT</button>
+            <Viewer ref={viewerRef} modelUrls={["/models/model.ifc"]} />
+        </>
+    );
+}
+```
+
+Converter options:
+
+```ts
+viewerRef.current?.converter.convertToBmt({
+    activeView: true,
+    fileName: "model",
+    fileNames: {
+        0: "architecture",
+        1: "structure",
+    },
+    filterElement: ({ modelID, elementID }) => {
+        return modelID === 0 && elementID !== 10;
+    },
+    useMinVersion: true,
+});
+```
+
+`activeView` exports only currently visible elements. This includes hide/isolate state because the viewer passes the current scene state to the converter.
+
+`useMinVersion` exports `name.min.bmt` plus `name_props.json`. Without it, props and structure are written into one `.bmt` file.
+
+`fileName` sets a base name for exported files. `fileNames` sets names per `modelID`.
+
+`filterElement` is an optional custom element filter. Return `true` to keep an element in the exported BMT.
+
+IFC file conversion is also available through the same API:
+
+```ts
+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.
+
 ## Controlled Selection
 
 Selection can be controlled by your app state, including Zustand, Redux, or local React state.

package/lib/Camera/useCameraUtils.d.ts

@@ -0,0 +1,28 @@
+import { type Intersection, type Object3D, type Plane, type Vector3 } from "three";
+import type { ViewerModelRef } from "../types";
+export declare const CLIPPING_PLANE_EPSILON = 0.000001;
+export type CameraClippingSource = {
+    getActive: () => boolean;
+    getPlanes: () => Plane[];
+};
+export type CameraIntersectionOptions = {
+    event?: MouseEvent | PointerEvent;
+    filter?: (intersection: Intersection<Object3D>) => boolean;
+    object?: Object3D | Object3D[] | null;
+    recursive?: boolean;
+    respectClipping?: boolean;
+};
+export type ViewerCameraGetIntersection = {
+    (first: true): Intersection<Object3D> | null;
+    (first?: false): Intersection<Object3D>[];
+};
+export type CameraUtilsApi = {
+    getActiveClippingPlanes: () => Plane[];
+    getIntersection: {
+        (first: true, options?: CameraIntersectionOptions): Intersection<Object3D> | null;
+        (first?: false, options?: CameraIntersectionOptions): Intersection<Object3D>[];
+    };
+    setClippingSource: (source: CameraClippingSource | null) => void;
+};
+export declare function isPointVisibleByClippingPlanes(point: Vector3, planes: Plane[]): boolean;
+export default function useCameraUtils(modelRef: ViewerModelRef): CameraUtilsApi;

package/lib/Loaders/BmtConverter.d.ts

@@ -0,0 +1,95 @@
+import { type Object3D } from "three";
+import type { BmtGeomData, BmtModelData } from "./BmtLoader";
+import { type IfcCoordinationMatrixSource, type IfcModelSource } from "./IFCLoader/IFCLoader";
+export type BmtConverterSource = IfcModelSource | IfcModelSource[];
+export type BmtConvertibleModels = BmtModelData | BmtModelData[] | Record<number, BmtModelData>;
+export type BmtVisibleIdsByModel = Record<string | number, Iterable<number>>;
+export type BmtActiveViewFilterParams = {
+    elementID: number;
+    geometry: BmtGeomData;
+    geometryKey: number;
+    modelID: number;
+};
+export type BmtActiveViewFilter = (params: BmtActiveViewFilterParams) => boolean;
+export type BmtConverterOptions = {
+    activeView?: boolean;
+    activeViewRoot?: Object3D | Object3D[] | null;
+    chunk?: number;
+    coordinationMatrix?: IfcCoordinationMatrixSource;
+    fileName?: string;
+    fileNames?: Record<string | number, string>;
+    filterElement?: BmtActiveViewFilter;
+    maxMeshBytes?: number;
+    useIfcColors?: boolean;
+    useIfcElementAssembly?: boolean;
+    useIfcSpace?: boolean;
+    useMinVersion?: boolean;
+    visibleIdsByModel?: BmtVisibleIdsByModel;
+    wasmPath?: string;
+};
+export type BmtConvertedFileType = "bmt" | "json";
+export type BmtConvertedFile = {
+    blob: Blob;
+    bytes: Uint8Array;
+    name: string;
+    type: BmtConvertedFileType;
+};
+export type BmtConversionResult = {
+    files: BmtConvertedFile[];
+    models: Record<number, BmtModelData>;
+};
+export declare class BmtConverter {
+    private readonly textEncoder;
+    private readonly ifcLoader;
+    ConvertIfcFileToBmt(sources: BmtConverterSource, options?: BmtConverterOptions): Promise<BmtConversionResult>;
+    convertIfcFileToBmt(sources: BmtConverterSource, options?: BmtConverterOptions): Promise<BmtConversionResult>;
+    ConvertToBmt(models: BmtConvertibleModels, options?: BmtConverterOptions): BmtConversionResult;
+    convertToBmt(models: BmtConvertibleModels, options?: BmtConverterOptions): BmtConversionResult;
+    private configureIfcLoader;
+    private normalizeModels;
+    private isBmtModelData;
+    private getFileNamesFromSources;
+    private getModelFileBaseName;
+    private normalizeBaseName;
+    private createModelFiles;
+    private createBmtBytes;
+    private writeProps;
+    private writeMeshes;
+    private createMeshPayload;
+    private writeJsonChunk;
+    private writeTextChunk;
+    private writeChunk;
+    private createSerializableModel;
+    private markIfcSpaceGeometries;
+    private markIfcSpaceGeometry;
+    private geometryHasOnlyIds;
+    private getHiddenElementIds;
+    private addGeometryElementIds;
+    private getElementFilter;
+    private filterGeometry;
+    private isValidVertexIndex;
+    private createIndexArray;
+    private filterProps;
+    private filterStructure;
+    private filterStructureNode;
+    private getStructureNodeElementID;
+    private isStructureNode;
+    private getVisibleIdsByModel;
+    private getIfcSpaceIdsByModel;
+    private addVisibleIdsFromObject3D;
+    private isReadableAttribute;
+    private isObjectVisible;
+    private isIfcSpaceObject;
+    private getObjectModelID;
+    private hasMeshMatrices;
+    private getIndexType;
+    private colorToByte;
+    private deflateTypedArray;
+    private deflateBytes;
+    private encodeText;
+    private encodePrettyJson;
+    private isRecord;
+}
+export declare const bmtConverter: BmtConverter;
+export declare function ConvertIfcFileToBmt(sources: BmtConverterSource, options?: BmtConverterOptions): Promise<BmtConversionResult>;
+export declare function ConvertToBmt(models: BmtConvertibleModels, options?: BmtConverterOptions): BmtConversionResult;

package/lib/Loaders/BmtLoader.d.ts

@@ -1,5 +1,5 @@
 import pako from "pako";
-import type { ModelGridsData } from "../ModelGrids";
+import type { ModelGridsData } from "../utils/ModelGrids";
 export type BmtIndexArray = Uint16Array | Uint32Array;
 export interface BmtMaterialData {
     r: number;
@@ -12,6 +12,7 @@ export interface BmtGeomData {
     pos: Float32Array;
     norm?: Float32Array;
     ind: BmtIndexArray;
+    isIfcSpace?: boolean;
     ids: Uint32Array;
     matrix?: string;
     mat: BmtMaterialData;
@@ -85,6 +86,7 @@ export declare class BMTLoader {
         STRUCTURE: number;
         GRIDS: number;
         MATRIX: number;
+        MESHSPACE: number;
     };
     parseMesh(data: Uint8Array): BmtMeshData;
     private getExternalMetadataPath;

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

@@ -21,6 +21,7 @@ export type IfcCoordinationMatrixSource = Matrix4 | number[] | string | null | u
 export declare class IFCLoader {
     useIfcElemetAssembly: boolean;
     useIfcColors: boolean;
+    useIfcSpace: boolean;
     private coordinationMatrix;
     private parser;
     private propertySerializer;
@@ -58,9 +59,11 @@ export declare class IfcParser {
     private readonly meshMatrix;
     private readonly normalMatrix;
     constructor(parser: IfcAPI, ifcModelID: number, options: IfcParserOptions);
-    parseData(allIds: Set<number>, elementsAssembly: IfcElementsAssembly | null): BmtModelData;
+    parseData(allIds: Set<number>, elementsAssembly: IfcElementsAssembly | null, includeSpaces?: boolean): BmtModelData;
+    private streamGeometryChunks;
     private applyGeometryTransformation;
     private planGeometryChunks;
+    private streamMeshes;
     private getMaterialChunkPlan;
     private deleteFlatMesh;
     private canFitInChunk;

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

@@ -1,5 +1,5 @@
 import { IfcAPI } from "web-ifc";
-import type { ModelGridData } from "../../ModelGrids";
+import type { ModelGridData } from "../../utils/ModelGrids";
 type IfcRawValue = boolean | null | number | string | undefined | IfcRawValue[] | {
     value: IfcRawValue;
 };

package/lib/SelectableMesh.d.ts

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

package/lib/Selector/SelectionBox.d.ts

@@ -1,5 +1,5 @@
 import type { MutableRefObject } from "react";
-import { Camera, Object3D, Vector2 } from "three";
+import { Camera, Object3D, Vector2, type Plane } from "three";
 export type ClientRectSelection = {
     minX: number;
     minY: number;
@@ -34,9 +34,10 @@ export type SelectionBoxProfile = {
 export declare const MIN_BOX_SIZE = 6;
 export declare function getClientSelectionRect(start: Vector2, end: Vector2): ClientRectSelection;
 export declare function getSelectionBoxMode(start: Vector2, end: Vector2): SelectionBoxMode;
-export declare function getBoxSelectedIds({ model, camera, domElement, rect, mode, profile, }: {
+export declare function getBoxSelectedIds({ model, camera, clippingPlanes, domElement, rect, mode, profile, }: {
     model: Object3D | null;
     camera: Camera;
+    clippingPlanes?: Plane[];
     domElement: HTMLElement;
     rect: ClientRectSelection;
     mode: SelectionBoxMode;

package/lib/Selector/useSelector.d.ts

@@ -1,3 +1,3 @@
-import type { GeometryIndexApi } from "../GeometryUtils/useGeometryIndex";
+import type { CameraUtilsApi } from "../Camera/useCameraUtils";
 import type { ViewerControlsRef, ViewerModelRef } from "../types";
-export default function useSelector(modelRef: ViewerModelRef, controlRef: ViewerControlsRef, geometryIndex: GeometryIndexApi): void;
+export default function useSelector(modelRef: ViewerModelRef, controlRef: ViewerControlsRef, cameraUtils: CameraUtilsApi): void;

package/lib/api/ViewerApi.d.ts

@@ -1,22 +1,36 @@
 import type { ColorRepresentation } from "three";
 import type { SelectedStore, UserDevice, ViewerGridAxesVisibility, ViewerGridAxisSide, ViewerStoreApi } from "../store/ViewerStore";
 import { type ViewerPropertiesApi } from "./ViewerPropertiesApi";
+import type { ViewerClippingApi } from "../utils/ClippingUtils";
+import type { ViewerDimensionsApi } from "../utils/DimentionsUtils";
+import type { ViewerCameraGetIntersection } from "../Camera/useCameraUtils";
+import type { BmtConversionResult, BmtConverterOptions, BmtConverterSource } from "../Loaders/BmtConverter";
+export type { ViewerClippingApi } from "../utils/ClippingUtils";
+export type { ViewerDimensionsApi } from "../utils/DimentionsUtils";
+export type { ViewerCameraGetIntersection } from "../Camera/useCameraUtils";
 export type ViewerSelection = Record<number, number[]>;
 export type ViewerGeometryUtilsApi = {
     getAllIds: () => number[];
+    getIfcSpacesVisibility: () => boolean;
     hideByIds: (ids: number[]) => void;
     hideSelected: () => void;
     isolateByIds: (ids: number[]) => void;
     isolateSelected: () => void;
     resetIsolation: () => void;
+    setIfcSpacesVisibility: (visible: boolean) => void;
     showAll: () => void;
     showByIds: (ids: number[]) => void;
+    toggleIIfcSpacesVisibility: () => void;
 };
 export type ViewerSelectorApi = {
     addSelected: (modelID: number, ids: number[]) => void;
+    getPreselectionColor: () => ColorRepresentation;
+    getSelectionColor: () => ColorRepresentation;
     getSelected: () => ViewerSelection;
     removeSelected: (modelID: number, ids: number[]) => void;
     resetSelection: (modelID?: number) => void;
+    setPreselectionColor: (color: ColorRepresentation) => void;
+    setSelectionColor: (color: ColorRepresentation) => void;
     setSelected: (modelID: number, ids: number[], reset?: boolean) => void;
 };
 export type ViewerColorsApi = {
@@ -26,13 +40,16 @@ export type ViewerColorsApi = {
     setColor: (modelID: number, ids: number[], color: ColorRepresentation) => void;
 };
 export type ViewerUtilsApi = {
+    getDefaultHotkeysEnabled: () => boolean;
     getGridAxesVisibility: () => ViewerGridAxesVisibility;
     getShowNavCube: () => boolean;
     getShowGridAxes: () => boolean;
     getShowStats: () => boolean;
     getUserDevice: () => UserDevice;
     setGridAxesVisibility: (gridAxesVisibility: Partial<ViewerGridAxesVisibility>) => void;
+    setDefaultHotkeysEnabled: (enabled: boolean) => void;
     setGridAxisVisibility: (side: ViewerGridAxisSide, visible: boolean) => void;
+    toggleDefaultHotkeys: () => void;
     setShowNavCube: (showNavCube: boolean) => void;
     setShowGridAxes: (showGridAxes: boolean) => void;
     setShowStats: (showStats: boolean) => void;
@@ -41,10 +58,19 @@ export type ViewerUtilsApi = {
 };
 export type ViewerCameraApi = {
     fitCamera: () => void;
+    getIntersection: ViewerCameraGetIntersection;
+};
+export type ViewerBmtConverterOptions = Pick<BmtConverterOptions, "activeView" | "fileName" | "fileNames" | "filterElement" | "useIfcColors" | "useIfcElementAssembly" | "useIfcSpace" | "useMinVersion">;
+export type ViewerConverterApi = {
+    convertIfcFileToBmt: (sources: BmtConverterSource, options?: ViewerBmtConverterOptions) => Promise<BmtConversionResult>;
+    convertToBmt: (options?: ViewerBmtConverterOptions) => BmtConversionResult;
 };
 export type ViewerApi = {
     camera: ViewerCameraApi;
+    clipping: ViewerClippingApi;
     colors: ViewerColorsApi;
+    converter: ViewerConverterApi;
+    dimensions: ViewerDimensionsApi;
     geometryUtils: ViewerGeometryUtilsApi;
     properties: ViewerPropertiesApi;
     selector: ViewerSelectorApi;
@@ -52,7 +78,10 @@ export type ViewerApi = {
 };
 export type ViewerSceneApi = {
     camera: ViewerCameraApi;
+    clipping: ViewerClippingApi;
     colors: ViewerColorsApi;
+    converter: ViewerConverterApi;
+    dimensions: ViewerDimensionsApi;
     geometryUtils: ViewerGeometryUtilsApi;
 };
 export declare function serializeSelected(selected: SelectedStore): ViewerSelection;

package/lib/api/loader.d.ts

@@ -1,8 +1,12 @@
 import { type BmtModelData } from "../Loaders/BmtLoader";
 export type ViewerModelSource = string | File;
 export type ViewerLoadedModels = Record<number, BmtModelData>;
+export type ViewerLoadModelOptions = {
+    useIfcSpace?: boolean;
+};
 declare class ViewerLoaderApi {
     coordinationMatrix: string | undefined;
+    useIfcSpace: boolean;
     private bmtLoader;
     private ifcLoader;
     private loadedModelCount;
@@ -10,10 +14,12 @@ declare class ViewerLoaderApi {
     private initLoaders;
     private getBmtLoader;
     private getIfcLoader;
+    private getFileSourceMap;
+    private applyBmtMetadata;
     private loadBmtModel;
     private resetCoordinationMatrixState;
     resetCoordinationMatrix(): void;
-    loadModel(sources: ViewerModelSource | ViewerModelSource[]): Promise<ViewerLoadedModels>;
+    loadModel(sources: ViewerModelSource | ViewerModelSource[], options?: ViewerLoadModelOptions): Promise<ViewerLoadedModels>;
 }
 export declare const loader: ViewerLoaderApi;
 export {};

package/lib/index.d.ts

@@ -1,16 +1,19 @@
 export { default as Viewer } from "./Viewer";
 export type { ViewerModelsData, ViewerProps } from "./Viewer";
-export type { ViewerApi, ViewerCameraApi, ViewerColorsApi, ViewerGeometryUtilsApi, ViewerSelection, ViewerSelectorApi, ViewerUtilsApi, } from "./api/ViewerApi";
+export type { ViewerApi, ViewerCameraApi, ViewerCameraGetIntersection, ViewerClippingApi, ViewerColorsApi, ViewerBmtConverterOptions, ViewerConverterApi, ViewerDimensionsApi, ViewerGeometryUtilsApi, ViewerSelection, ViewerSelectorApi, ViewerUtilsApi, } from "./api/ViewerApi";
 export type { ViewerPropertiesApi } 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 { IFCLoader } from "./Loaders/IFCLoader/IFCLoader";
 export type { IfcLoadedModels, IfcModelSource, } from "./Loaders/IFCLoader/IFCLoader";
-export { ModelGrids } from "./ModelGrids";
-export type { ModelGridAxis, ModelGridData, ModelGridPoint, ModelGridsProps, ModelGridsData, } from "./ModelGrids";
+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";
+export type { ModelGridAxis, ModelGridData, ModelGridPoint, ModelGridsProps, ModelGridsData, } from "./utils/ModelGrids";
 export { loader } from "./api/loader";
-export type { ViewerLoadedModels, ViewerModelSource } from "./api/loader";
-export { NavigationCube } from "./NavigationCube";
+export type { ViewerLoadedModels, ViewerLoadModelOptions, ViewerModelSource, } from "./api/loader";
+export { NavigationCube } from "./utils/NavigationCube";
+export { DimensionLine, DimensionsUtils, useDimensionsUtils, type DimensionUnit, } from "./utils/DimentionsUtils";
 export { createViewerStore } from "./store/ViewerStore";
 export { ViewerStoreProvider } from "./store/ViewerStoreProvider";
 export { useViewerStore, useViewerStoreApi } from "./store/useViewerStore";