bimatter-viewer-react 0.1.4 → 0.3.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/utils/ColorsUtils/useElementColors.d.ts

@@ -0,0 +1,16 @@
+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;
+    clearColor: (modelID: number, ids: number[]) => void;
+    clearModelColors: (modelID: number) => void;
+    setColor: (modelID: number, ids: number[], color: ColorRepresentation) => void;
+};
+export type ViewerElementColors = {
+    colorPaletteTexture: DataTexture;
+    colorUtils: ViewerElementColorsApi;
+};
+export declare function useElementColors(geometryIndex: GeometryIndexApi): ViewerElementColors;

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;
@@ -31,5 +31,6 @@ export type GeometryIndex = {
 };
 export type GeometryIndexApi = {
     buildIndex: () => GeometryIndex;
+    resetIndex: () => void;
 };
 export default function useGeometryIndex(modelRef: ViewerModelRef): GeometryIndexApi;

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.1.4",
+  "version": "0.3.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 {};