bimatter-viewer-react 0.2.0 → 0.4.0

package/lib/store/ViewerStore.d.ts

@@ -1,5 +1,7 @@
 import { type StoreApi } from "zustand/vanilla";
+import type { ColorRepresentation } from "three";
 import type { BmtModelProps, BmtModelStructure } from "../Loaders/BmtLoader";
+import type { ViewerApi } from "../api/ViewerApi";
 export type UserDevice = "pc" | "mobile";
 export type ViewerGridAxisSide = "bottom" | "left" | "right" | "top";
 export type ViewerGridAxesVisibility = Record<ViewerGridAxisSide, boolean> & {
@@ -10,19 +12,31 @@ export interface SelectedStore {
 }
 export type ViewerModelPropsStore = Record<number, BmtModelProps>;
 export type ViewerModelStructureStore = Record<number, BmtModelStructure>;
+export declare const DEFAULT_SELECTION_COLOR = "rgb(17, 148, 189)";
+export declare const DEFAULT_PRESELECTION_COLOR = "rgb(104, 198, 227)";
 export type ViewerStore = {
+    api: ViewerApi | null;
+    defaultHotkeysEnabled: boolean;
     modelProps: ViewerModelPropsStore;
     modelStructure: ViewerModelStructureStore;
     gridAxesVisibility: ViewerGridAxesVisibility;
+    preselectionColor: ColorRepresentation;
     selected: SelectedStore;
+    selectionColor: ColorRepresentation;
+    selectionInteractionDisabled: boolean;
     showNavCube: boolean;
     showStats: boolean;
     userDevice: UserDevice;
+    setApi: (api: ViewerApi | null) => void;
+    setDefaultHotkeysEnabled: (enabled: boolean) => void;
     setGridAxesVisibility: (gridAxesVisibility: Partial<ViewerGridAxesVisibility>) => void;
     setGridAxisVisibility: (side: ViewerGridAxisSide, visible: boolean) => void;
     setShowGridAxes: (visible: boolean) => void;
     setModelProps: (modelProps: ViewerModelPropsStore) => void;
     setModelStructure: (modelStructure: ViewerModelStructureStore) => void;
+    setPreselectionColor: (color: ColorRepresentation) => void;
+    setSelectionColor: (color: ColorRepresentation) => void;
+    setSelectionInteractionDisabled: (disabled: boolean) => void;
     setShowNavCube: (showNavCube: boolean) => void;
     setShowStats: (showStats: boolean) => void;
     setSelection: (selected: SelectedStore) => void;

package/lib/utils/ClippingUtils/ClippingEdges.d.ts

@@ -0,0 +1,23 @@
+import { BufferGeometry, LineBasicMaterial, LineSegments, Plane } from "three";
+import type { ClippingUtils } from "./ClippingUtils";
+export declare class ClippingEdges {
+    active: boolean;
+    readonly material: LineBasicMaterial;
+    readonly plane: Plane;
+    private readonly context;
+    private readonly lines;
+    private readonly inverseMatrix;
+    private readonly localPlane;
+    private readonly tempLine;
+    private readonly tempVector;
+    private readonly tempVector1;
+    private readonly tempVector2;
+    private readonly tempVector3;
+    constructor(context: ClippingUtils, plane: Plane);
+    create(): LineSegments<BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, import("three").Material<import("three").MaterialEventMap> | import("three").Material<import("three").MaterialEventMap>[], import("three").Object3DEventMap>[];
+    syncMeshes(): void;
+    dispose(): void;
+    setVisible(visible: boolean): void;
+    toggle(): void;
+    update(): void;
+}

package/lib/utils/ClippingUtils/ClippingUtils.d.ts

@@ -0,0 +1,87 @@
+import { Camera, Material, Mesh, Plane, Raycaster, Scene, Vector3, WebGLRenderer } from "three";
+import type { CameraUtilsApi } from "../../Camera/useCameraUtils";
+import type { ViewerStoreApi } from "../../store/ViewerStore";
+import type { ViewerControlsRef, ViewerModelRef } from "../../types";
+import { ClippingEdges } from "./ClippingEdges";
+import { PlaneHelper } from "./PlaneHelper";
+type ClippingContext = {
+    camera: Camera;
+    cameraUtils: CameraUtilsApi;
+    controlRef: ViewerControlsRef;
+    domElement: HTMLCanvasElement;
+    modelRef: ViewerModelRef;
+    raycaster: Raycaster;
+    renderer: WebGLRenderer;
+    scene: Scene;
+    viewerStore: ViewerStoreApi;
+};
+export type ViewerClippingApi = {
+    createClippingRectangle: () => Plane[];
+    createPlane: (event?: MouseEvent | PointerEvent) => Plane | null;
+    deleteAllPlanes: () => void;
+    getEdgesActive: () => boolean;
+    getHelpersActive: () => boolean;
+    getPlanes: () => Plane[];
+    getActive: () => boolean;
+    setActive: (active: boolean) => void;
+    setEdgesActive: (active: boolean) => void;
+    setHelpersActive: (active: boolean) => void;
+    toggle: () => void;
+    updateEdges: () => void;
+    updateMaterials: () => void;
+};
+export declare class ClippingUtils {
+    planes: Plane[];
+    edges: ClippingEdges[];
+    helpers: PlaneHelper[];
+    private active;
+    private context;
+    private edgesActive;
+    private helperDragActive;
+    private helpersActive;
+    private helperHoverMoveState;
+    private updateEdgesFrame;
+    private updateHelpersFrame;
+    constructor(context: ClippingContext);
+    setContext(context: ClippingContext): void;
+    getActive(): boolean;
+    getEdgesActive(): boolean;
+    getHelpersActive(): boolean;
+    getPlanes(): Plane[];
+    getScene(): Scene<import("three").Object3DEventMap>;
+    getCamera(): Camera;
+    getCameraUtils(): CameraUtilsApi;
+    getDomElement(): HTMLCanvasElement;
+    getRaycaster(): Raycaster;
+    getControlRef(): ViewerControlsRef;
+    getMeshes(): Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, Material<import("three").MaterialEventMap> | Material<import("three").MaterialEventMap>[], import("three").Object3DEventMap>[];
+    getHelperHoverIsMoving(): boolean;
+    getHelperDragActive(): boolean;
+    setHelperDragActive(active: boolean): void;
+    clearHelpersHover(except?: PlaneHelper): void;
+    setHelperHoverMoveStart: () => void;
+    setHelperHoverMoveEnd: () => void;
+    setHelperHoverMoving: () => void;
+    private getModelWorldBox;
+    setControlsEnabled(enabled: boolean): void;
+    setSelectionInteractionDisabled(disabled: boolean): void;
+    updateMaterials(): void;
+    setActive(active: boolean): void;
+    toggle(): void;
+    createPlane(event?: MouseEvent | PointerEvent): Plane | null;
+    createClippingRectangle(): Plane[];
+    addPlane(plane: Plane, location: Vector3, normal: Vector3): void;
+    deleteAllPlanes(): void;
+    setHelpersActive(active: boolean): void;
+    setEdgesActive(active: boolean): void;
+    updateEdges(): void;
+    updateHelpers(): void;
+    requestEdgesUpdate(): void;
+    requestHelpersUpdate(): void;
+    syncWithModel(): void;
+    dispose(): void;
+}
+export declare function useClippingUtils(modelRef: ViewerModelRef, controlRef: ViewerControlsRef, cameraUtils: CameraUtilsApi): ViewerClippingApi & {
+    syncWithModel: () => void;
+};
+export {};

package/lib/utils/ClippingUtils/PlaneHelper.d.ts

@@ -0,0 +1,54 @@
+import { Box3, Group, LineDashedMaterial, MeshBasicMaterial, Object3D, Plane, Vector3 } from "three";
+import type { ClippingUtils } from "./ClippingUtils";
+export declare function getClippingHelperBoundsOffset(box: Box3): number;
+export declare class PlaneHelper extends Object3D {
+    readonly helper: Group<import("three").Object3DEventMap>;
+    readonly borderMaterial: LineDashedMaterial;
+    readonly material: MeshBasicMaterial;
+    readonly plane: Plane;
+    private active;
+    private readonly border;
+    private readonly context;
+    private readonly location;
+    private readonly normal;
+    private readonly planeMesh;
+    private readonly pointer;
+    private layout;
+    private dragState;
+    private hovered;
+    private listenersActive;
+    constructor(context: ClippingUtils, plane: Plane, location: Vector3, normal: Vector3);
+    setVisible(visible: boolean): void;
+    toggle(): void;
+    clearHover(): void;
+    dispose(): void;
+    private addToView;
+    private removeFromView;
+    updateClipping(): void;
+    private updateBorderDash;
+    private addEventListeners;
+    private removeEventListeners;
+    private getPointerIntersection;
+    private getNearestHelperIntersection;
+    private hasModelIntersection;
+    private getPointerPointOnPlane;
+    private onPointerDown;
+    private onPointerMove;
+    private onPointerUp;
+    private updateHoverState;
+    private setHovered;
+    private createPlaneMesh;
+    private createBorder;
+    private replaceGeometry;
+    private createFillGeometry;
+    private createBorderGeometry;
+    private getClippedPolygon;
+    private clipPolygonByPlane;
+    private getLocalPointDistanceToPlane;
+    private getPlaneIntersectionPoint;
+    private getHelperLayout;
+    private getPlaneBasis;
+    private applyPlaneOrientation;
+    private getModelWorldBox;
+    private getBoxCorners;
+}

package/lib/utils/ClippingUtils/index.d.ts

@@ -0,0 +1,2 @@
+export { useClippingUtils } from "./ClippingUtils";
+export type { ViewerClippingApi } from "./ClippingUtils";

package/lib/{Colors → utils/ColorsUtils}/useElementColors.d.ts

@@ -1,6 +1,7 @@
 import { DataTexture, type ColorRepresentation } from "three";
 import type { GeometryIndexApi } from "../GeometryUtils/useGeometryIndex";
 export declare const MAX_ELEMENT_COLOR_PALETTE_SIZE = 256;
+export declare const SELECTION_COLOR_INDEX = 1;
 export type ViewerElementColorsApi = {
     applyStoredColors: () => void;
     clearAllColors: () => void;

package/lib/utils/DimentionsUtils/DimentionLine.d.ts

@@ -0,0 +1,59 @@
+import { BufferGeometry, Color, ConeGeometry, Group, Line, LineDashedMaterial, Mesh, MeshBasicMaterial, Sprite, Vector3, type Camera } from "three";
+export type DimensionUnit = "m" | "mm";
+export type DimensionLineOptions = {
+    boundingMaterial: MeshBasicMaterial;
+    endpointGeometry: ConeGeometry;
+    endpointMaterial: MeshBasicMaterial;
+    endpointScale: Vector3;
+    lineMaterial: LineDashedMaterial;
+    root: Group;
+    start: Vector3;
+    end: Vector3;
+};
+export declare class DimensionLine {
+    static scale: number;
+    static scaleFactor: number;
+    static units: DimensionUnit;
+    readonly root: Group<import("three").Object3DEventMap>;
+    readonly start: Vector3;
+    readonly endpointMeshes: Mesh[];
+    boundingMesh: Mesh | null;
+    end: Vector3;
+    line: Line;
+    private readonly boundingMaterial;
+    private readonly endpointGeometry;
+    private readonly endpointMaterial;
+    private readonly lineGeometry;
+    private readonly lineMaterial;
+    private readonly ownerRoot;
+    private endpointBaseScale;
+    private labelHeight;
+    private labelSprite;
+    private labelText;
+    private labelTexture;
+    private labelWidth;
+    constructor({ boundingMaterial, endpointGeometry, endpointMaterial, endpointScale, lineMaterial, root, start, end, }: DimensionLineOptions);
+    get length(): number;
+    get center(): Vector3;
+    get text(): Sprite<import("three").Object3DEventMap>;
+    get boundingBox(): Mesh<BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>, import("three").Material<import("three").MaterialEventMap> | import("three").Material<import("three").MaterialEventMap>[], import("three").Object3DEventMap> | null;
+    set dimensionColor(dimensionColor: Color);
+    set visibility(visible: boolean);
+    set endpointScale(scale: Vector3);
+    set endPoint(point: Vector3);
+    createBoundingBox(): void;
+    removeFromScene(): void;
+    dispose(): void;
+    updateForCamera(camera: Camera, viewportHeight: number): void;
+    private addEndpointMeshes;
+    private addEndpointMesh;
+    private createLabelSprite;
+    private createBoundingBoxMesh;
+    private getTextContent;
+    private updateLabel;
+    private updatePositions;
+    private updateBoundingBox;
+    private rescaleMesh;
+    private rescaleBoundingMesh;
+    private rescaleLabel;
+}

package/lib/utils/DimentionsUtils/DimentionsUtils.d.ts

@@ -0,0 +1,97 @@
+import { Color, ConeGeometry, SphereGeometry, type Camera, type Scene } from "three";
+import type { CameraUtilsApi } from "../../Camera/useCameraUtils";
+import type { ViewerStoreApi } from "../../store/ViewerStore";
+import type { ViewerControlsRef, ViewerModelRef } from "../../types";
+import { DimensionLine, type DimensionUnit } from "./DimentionLine";
+type DimensionsContext = {
+    camera: Camera;
+    cameraUtils: CameraUtilsApi;
+    controlRef: ViewerControlsRef;
+    domElement: HTMLCanvasElement;
+    modelRef: ViewerModelRef;
+    scene: Scene;
+    viewerStore: ViewerStoreApi;
+    viewportHeight: number;
+};
+export type ViewerDimensionsApi = {
+    cancelDrawing: () => void;
+    changeAxes: () => void;
+    delete: () => void;
+    deleteAll: () => void;
+    getActive: () => boolean;
+    getDimensions: () => DimensionLine[];
+    getSnapDistance: () => number;
+    getUnit: () => DimensionUnit;
+    setActive: (active: boolean) => void;
+    setColor: (color: string | Color) => void;
+    setEndpointScaleFactor: (factor: number) => void;
+    setSnapDistance: (distance: number) => void;
+    setUnit: (unit: DimensionUnit) => void;
+    setWidth: (width: number) => void;
+    toggle: () => void;
+};
+export declare class DimensionsUtils {
+    private active;
+    private axis;
+    private readonly boundingMaterial;
+    private context;
+    private currentDimension;
+    private dimensions;
+    private readonly endpointGeometry;
+    private readonly endpointMaterial;
+    private endpointScale;
+    private readonly lineMaterial;
+    private measureInProcess;
+    private moveState;
+    private readonly previewMarker;
+    private readonly root;
+    private snapDistance;
+    private startPoint;
+    private unit;
+    constructor(context: DimensionsContext);
+    setContext(context: DimensionsContext): void;
+    getActive(): boolean;
+    getDimensions(): DimensionLine[];
+    getSnapDistance(): number;
+    getUnit(): DimensionUnit;
+    setActive(active: boolean): void;
+    toggle(): void;
+    setColor(color: string | Color): void;
+    setEndpointScaleFactor(factor: number): void;
+    setSnapDistance(distance: number): void;
+    setUnit(unit: DimensionUnit): void;
+    setWidth(width: number): void;
+    cancelDrawing(): void;
+    delete(): void;
+    deleteAll(): void;
+    changeAxes(): void;
+    updateFrame(): void;
+    syncWithModel(): void;
+    dispose(): void;
+    private addEventListeners;
+    private removeEventListeners;
+    private drawStart;
+    private drawPreview;
+    private drawEnd;
+    private createDimension;
+    private getModelHit;
+    private getBoundingBoxes;
+    private getClosestVertex;
+    private getPreviewEndPoint;
+    private getNextAxis;
+    private getIsMoving;
+    private rescalePreviewMarker;
+    private setSelectionInteractionDisabled;
+    private onClick;
+    private onPointerMove;
+    private onPointerDown;
+    private onPointerUp;
+    private onControlsChange;
+    private onKeyDown;
+    static createEndpointGeometry(height?: number, radius?: number): ConeGeometry;
+    static createPreviewGeometry(): SphereGeometry;
+}
+export declare function useDimensionsUtils(modelRef: ViewerModelRef, controlRef: ViewerControlsRef, cameraUtils: CameraUtilsApi): ViewerDimensionsApi & {
+    syncWithModel: () => void;
+};
+export {};

package/lib/utils/DimentionsUtils/index.d.ts

@@ -0,0 +1,2 @@
+export { DimensionsUtils, useDimensionsUtils, type ViewerDimensionsApi, } from "./DimentionsUtils";
+export { DimensionLine, type DimensionUnit } from "./DimentionLine";

package/lib/{GeometryUtils → utils/GeometryUtils}/useGeometryIndex.d.ts

@@ -1,6 +1,6 @@
 import { Mesh, Object3D } from "three";
 import type { MeshBVH } from "three-mesh-bvh";
-import type { ViewerModelRef } from "../types";
+import type { ViewerModelRef } from "../../types";
 export type IndexArray = Uint16Array | Uint32Array;
 export type IndexRange = {
     count: number;
@@ -9,6 +9,7 @@ export type IndexRange = {
 export type MeshGeometryRecord = {
     hiddenIds: Set<number>;
     initialVisible: boolean;
+    isIfcSpace: boolean;
     mesh: Mesh;
     modelID: number;
     originalBoundsTree: MeshBVH | null;
@@ -24,6 +25,7 @@ export type ElementIndexEntry = {
 };
 export type GeometryIndex = {
     elementIndex: Map<number, ElementIndexEntry[]>;
+    ifcSpacesVisible: boolean;
     indexedModel: Object3D | null;
     isolatedIdsByModel: Map<number, Set<number>> | null;
     isolatedIds: Set<number> | null;

package/lib/{GeometryUtils → utils/GeometryUtils}/useGeometryUtils.d.ts

@@ -2,12 +2,15 @@ import type { GeometryIndexApi } from "./useGeometryIndex";
 export type GeometryUtilsApi = {
     buildIndex: GeometryIndexApi["buildIndex"];
     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 default function useGeometryUtils(geometryIndex: GeometryIndexApi): GeometryUtilsApi;

package/lib/utils/Hotkeys/useHotkeysUtils.d.ts

@@ -0,0 +1 @@
+export default function useHotkeys(): void;

package/lib/{NavigationCube → utils/NavigationCube}/NavigationCube.d.ts

@@ -1,4 +1,4 @@
-import type { ViewerCameraRef, ViewerControlsRef, ViewerModelRef } from "../types";
+import type { ViewerCameraRef, ViewerControlsRef, ViewerModelRef } from "../../types";
 type NavigationCubeProps = {
     active?: boolean;
     cameraRef: ViewerCameraRef;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bimatter-viewer-react",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "license": "PolyForm-Noncommercial-1.0.0",
   "type": "module",
   "main": "./lib/index.js",
@@ -53,6 +53,7 @@
     "eslint-plugin-react-hooks": "^7.1.1",
     "eslint-plugin-react-refresh": "^0.5.2",
     "globals": "^17.5.0",
+    "lil-gui": "^0.21.0",
     "react": "^19.2.5",
     "react-dom": "^19.2.5",
     "three": "^0.184.0",

package/lib/Hotkeys/useHotkeysUtils.d.ts

@@ -1,2 +0,0 @@
-import type { GeometryUtilsApi } from "../GeometryUtils/useGeometryUtils";
-export default function useHotkeys(geometryUtils: GeometryUtilsApi): void;

package/lib/ModelGrids copy/ModelGrids.d.ts

@@ -1,61 +0,0 @@
-import { Color, Group, LineBasicMaterial, Texture, Vector3, type Matrix4 } from "three";
-import { CSS2DObject } from "three/examples/jsm/renderers/CSS2DRenderer.js";
-import type { GridData } from "../Loaders/IFCLoader/IfcGrid";
-import type { ModelGridAxis, ModelGridPoint } from "../ModelGrids";
-type LegacyViewerContext = {
-    boundingBox: {
-        min: Vector3;
-    };
-    context: {
-        container: {
-            style: {
-                background: string;
-            };
-        };
-        context: {
-            scene: {
-                threeScene: {
-                    add: (object: Group) => void;
-                    background: Color | Texture | null;
-                };
-            };
-        };
-        loaders: {
-            coordinationMatrix?: Matrix4 | null;
-        };
-    };
-};
-type LegacyGridAxisType = "u" | "v";
-type RgbColor = {
-    b: number;
-    g: number;
-    r: number;
-};
-export declare class ModelGrids {
-    topTags: CSS2DObject[];
-    botTags: CSS2DObject[];
-    leftTags: CSS2DObject[];
-    rightTags: CSS2DObject[];
-    _active: boolean;
-    grids: GridData[];
-    color: string;
-    material: LineBasicMaterial;
-    mesh: Group;
-    readonly context: LegacyViewerContext;
-    constructor(context: LegacyViewerContext, grids: {
-        [key: string]: GridData;
-    });
-    init(): Promise<void>;
-    addGrid(gridGroup: Group, data: ModelGridAxis, locCoordinates: ModelGridPoint, type: LegacyGridAxisType, lowY: Vector3): void;
-    viewTop(bool: boolean): void;
-    viewBot(bool: boolean): void;
-    viewLeft(bool: boolean): void;
-    viewRight(bool: boolean): void;
-    get active(): boolean;
-    set active(active: boolean);
-    hexToRgb(hex: string): RgbColor;
-    hex2hsl(hex: string): number[];
-    rgb2hsl(r: number, g: number, b: number): number[];
-    changeColor(color: Color | string): "#000000" | "#FFFFFF";
-}
-export {};