vim-web 0.5.0-dev.9 → 0.6.0-dev.0

package/dist/types/core-viewers/webgl/loader/progressive/legacyMeshFactory.d.ts

@@ -4,6 +4,7 @@
 import { Scene } from '../scene';
 import { G3dMaterial, G3d } from 'vim-format';
 import { G3dSubset } from './g3dSubset';
+import { ElementMapping } from '../elementMapping';
 /**
  * Mesh factory to load a standard vim using the progressive pipeline.
  */
@@ -12,7 +13,9 @@ export declare class VimMeshFactory {
     private _materials;
     private _instancedFactory;
     private _scene;
-    constructor(g3d: G3d, materials: G3dMaterial, scene: Scene);
+    private _mapping;
+    private _vimIndex;
+    constructor(g3d: G3d, materials: G3dMaterial, scene: Scene, mapping: ElementMapping, vimIndex?: number);
     /**
      * Adds all instances from subset to the scene
      */

package/dist/types/core-viewers/webgl/loader/progressive/loadRequest.d.ts

@@ -0,0 +1,21 @@
+import { VimPartialSettings } from '../vimSettings';
+import { Vim } from '../vim';
+import { LoadRequest as BaseLoadRequest, ILoadRequest as BaseILoadRequest } from '../../../shared/loadResult';
+import { VimSource } from '../..';
+export type RequestSource = {
+    url?: string;
+    buffer?: ArrayBuffer;
+    headers?: Record<string, string>;
+};
+export type ILoadRequest = BaseILoadRequest<Vim>;
+/**
+ * A request to load a VIM file. Extends the base LoadRequest to add BFast abort handling.
+ * Loading starts immediately upon construction.
+ */
+export declare class LoadRequest extends BaseLoadRequest<Vim> {
+    private _bfast;
+    constructor(source: VimSource, settings: VimPartialSettings, vimIndex: number);
+    private startRequest;
+    private loadFromVim;
+    abort(): void;
+}

package/dist/types/core-viewers/webgl/loader/progressive/subsetBuilder.d.ts

@@ -41,11 +41,12 @@ export declare class VimSubsetBuilder implements SubsetBuilder {
 export declare class VimxSubsetBuilder {
     private _localVimx;
     private _scene;
+    private _vimIndex;
     private _set;
     private _onUpdate;
     get onUpdate(): ISignal;
     get isLoading(): boolean;
-    constructor(localVimx: Vimx, scene: Scene);
+    constructor(localVimx: Vimx, scene: Scene, vimIndex?: number);
     getFullSet(): G3dSubset;
     loadSubset(subset: G3dSubset, settings?: LoadPartialSettings): Promise<void>;
     clear(): void;

package/dist/types/core-viewers/webgl/loader/progressive/subsetRequest.d.ts

@@ -1,7 +1,8 @@
 /**
  * @module vim-loader
  */
-import { Vimx, Scene } from '../..';
+import { Scene } from '../scene';
+import { Vimx } from './vimx';
 import { G3dSubset } from './g3dSubset';
 export type LoadSettings = {
     /** Delay in ms between each rendering list update. @default: 400ms */
@@ -27,7 +28,7 @@ export declare class SubsetRequest {
     private _started;
     private _scene;
     getBoundingBox(): import("three").Box3;
-    constructor(scene: Scene, localVimx: Vimx, subset: G3dSubset);
+    constructor(scene: Scene, localVimx: Vimx, subset: G3dSubset, vimIndex?: number);
     dispose(): void;
     start(settings: LoadPartialSettings): Promise<void>;
     private nextFrame;

package/dist/types/core-viewers/webgl/loader/vim.d.ts

@@ -18,6 +18,16 @@ type VimFormat = 'vim' | 'vimx';
  * Facilitates high-level scene manipulation by providing access to objects.
  */
 export declare class Vim implements IVim<Element3D> {
+    /**
+     * The type of the viewer, indicating it is a WebGL viewer.
+     * Useful for distinguishing between different viewer types in a multi-viewer application.
+     */
+    readonly type = "webgl";
+    /**
+     * The stable ID of this vim in the scene's vim collection (0-255).
+     * Used for GPU picking to identify which vim an element belongs to.
+     */
+    readonly vimIndex: number;
     /**
      * Indicates whether the vim was opened from a vim or vimx file.
      */
@@ -76,13 +86,13 @@ export declare class Vim implements IVim<Element3D> {
    * @param {G3d | undefined} g3d - The G3d object, if available.
    * @param {Scene} scene - The scene containing the vim's geometry.
    * @param {VimSettings} settings - The settings used to open this vim.
+   * @param {number} vimIndex - The stable ID of this vim (0-255) for GPU picking.
    * @param {ElementMapping | ElementNoMapping | ElementMapping2} map - The element mapping.
    * @param {SubsetBuilder} builder - The subset builder for constructing subsets of the Vim object.
    * @param {string} source - The source of the Vim object.
    * @param {VimFormat} format - The format of the Vim object.
-   * @param {boolean} isLegacy - Indicates whether the Vim object uses a legacy loading pipeline.
    */
-    constructor(header: VimHeader | undefined, document: VimDocument, g3d: G3d | undefined, scene: Scene, settings: VimSettings, map: ElementMapping | ElementNoMapping | ElementMapping2, builder: SubsetBuilder, source: string, format: VimFormat);
+    constructor(header: VimHeader | undefined, document: VimDocument, g3d: G3d | undefined, scene: Scene, settings: VimSettings, vimIndex: number, map: ElementMapping | ElementNoMapping | ElementMapping2, builder: SubsetBuilder, source: string, format: VimFormat);
     getBoundingBox(): Promise<THREE.Box3>;
     /**
      * Retrieves the matrix representation of the Vim object's position, rotation, and scale.

package/dist/types/core-viewers/webgl/loader/vimCollection.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @module vim-loader
+ */
+import { ISignal } from 'ste-signals';
+import { IVimCollection } from '../../shared/vimCollection';
+import { Vim } from './vim';
+/**
+ * Maximum number of vims that can be loaded simultaneously.
+ * Limited by the 8-bit vimIndex in GPU picking (256 values: 0-255).
+ */
+export declare const MAX_VIMS = 256;
+/**
+ * Manages a collection of Vim objects with stable IDs for GPU picking.
+ *
+ * Each vim is assigned a stable ID (0-255) that persists for its lifetime.
+ * IDs are allocated sequentially and only reused after all 256 have been used.
+ * This ensures GPU picker can correctly identify vims even after removals.
+ */
+export declare class VimCollection implements IVimCollection<Vim> {
+    private _vimsById;
+    private _nextId;
+    private _freedIds;
+    private _count;
+    private _onChanged;
+    /**
+     * Signal dispatched when collection changes (add/remove/clear).
+     */
+    get onChanged(): ISignal;
+    /**
+     * Allocates a stable ID for a new vim.
+     * Fresh IDs are allocated sequentially (0, 1, 2, ..., 255).
+     * Freed IDs are only reused after all 256 have been allocated once.
+     * @returns The allocated ID, or undefined if all 256 IDs are in use
+     */
+    allocateId(): number | undefined;
+    /**
+     * Whether the collection has reached maximum capacity (256 vims).
+     */
+    get isFull(): boolean;
+    /**
+     * The number of vims currently in the collection.
+     */
+    get count(): number;
+    /**
+     * Adds a vim to the collection using its vimIndex as the ID.
+     * The vim's vimIndex should have been allocated via allocateId().
+     * @param vim The vim to add
+     * @throws Error if the vim's vimIndex slot is already occupied
+     */
+    add(vim: Vim): void;
+    /**
+     * Removes a vim from the collection and frees its ID for reuse.
+     * @param vim The vim to remove
+     * @throws Error if the vim is not in the collection
+     */
+    remove(vim: Vim): void;
+    /**
+     * Gets a vim by its stable ID.
+     * @param id The stable ID (0-255)
+     * @returns The vim at that ID, or undefined if empty
+     */
+    getFromId(id: number): Vim | undefined;
+    /**
+     * Checks if a vim is in the collection.
+     * @param vim The vim to check
+     * @returns True if the vim is in the collection
+     */
+    has(vim: Vim): boolean;
+    /**
+     * Returns all vims as a packed array (for iteration).
+     * @returns Array of all vims currently in the collection
+     */
+    getAll(): Vim[];
+    /**
+     * Clears all vims from the collection and resets ID allocation.
+     */
+    clear(): void;
+}

package/dist/types/core-viewers/webgl/loader/vimSettings.d.ts

@@ -3,7 +3,7 @@
  */
 import { Transparency } from './geometry';
 import * as THREE from 'three';
-export type FileType = 'vim' | 'vimx' | undefined;
+type FileType = 'vim' | 'vimx' | undefined;
 /**
  * Represents settings for configuring the behavior and rendering of a vim object.
  */
@@ -33,6 +33,12 @@ export type VimSettings = {
      * Set to true to enable verbose HTTP logging.
      */
     verboseHttp: boolean;
+};
+/**
+ * Internal settings type that includes vimx-specific fields.
+ * Used internally for loading vimx files.
+ */
+export type VimSettingsFull = VimSettings & {
     /**
      * Specifies the file type (vim or vimx) if it cannot or should not be inferred from the file extension.
      */
@@ -49,7 +55,7 @@ export type VimSettings = {
 /**
  * Default configuration settings for a vim object.
  */
-export declare function getDefaultVimSettings(): VimSettings;
+export declare function getDefaultVimSettings(): VimSettingsFull;
 /**
  * Represents a partial configuration of settings for a vim object.
  */
@@ -57,6 +63,7 @@ export type VimPartialSettings = Partial<VimSettings>;
 /**
  * Wraps Vim options, converting values to related THREE.js types and providing default values.
  * @param {VimPartialSettings} [options] - Optional partial settings for the Vim object.
- * @returns {VimSettings} The complete settings for the Vim object, including defaults.
+ * @returns {VimSettingsFull} The complete settings for the Vim object, including defaults.
  */
-export declare function createVimSettings(options?: VimPartialSettings): VimSettings;
+export declare function createVimSettings(options?: VimPartialSettings): VimSettingsFull;
+export {};

package/dist/types/core-viewers/webgl/viewer/camera/cameraMovement.d.ts

@@ -39,6 +39,14 @@ export declare abstract class CameraMovement {
      * @param {number} amount - The factor by which to change the distance (e.g., 0.5 for halving the distance, 2 for doubling the distance).
      */
     abstract zoom(amount: number): void;
+    /**
+     * Zooms toward a specific point, making it the new orbit target.
+     * Preserves the camera's forward direction while moving closer/farther from the point.
+     * If point is undefined, falls back to regular zoom.
+     * @param {THREE.Vector3 | undefined} point - The world position to zoom toward, or undefined for regular zoom
+     * @param {number} amount - The zoom factor (< 1 zooms in, > 1 zooms out)
+     */
+    zoomTo(point: THREE.Vector3 | undefined, amount: number): void;
     /**
      * Sets the distance between the camera and its target to the specified value.
      * @param {number} dist - The new distance between the camera and its target.

package/dist/types/core-viewers/webgl/viewer/gizmos/gizmoOrbit.d.ts

@@ -7,26 +7,33 @@ import { Camera } from '../camera/camera';
 import { ViewerSettings } from '../settings/viewerSettings';
 import { type InputHandler } from '../../../shared';
 /**
- * Manages the camera target gizmo
+ * Manages the camera target gizmo - displays orbital rings at the camera target
+ * 2 vertical rings (great circles) + 3 horizontal rings (latitude circles)
+ * Each rendered twice: once with depth test, once always visible (for see-through effect)
  */
 export declare class GizmoOrbit {
     private _renderer;
     private _camera;
     private _inputs;
     private _size;
-    private _color;
-    private _opacity;
-    private _opacityAlways;
     private _showDurationMs;
-    private _box;
-    private _wireframe;
-    private _material;
-    private _materialAlways;
+    private _torusGeometry;
+    private _verticalMaterialDepth;
+    private _verticalMaterialAlways;
+    private _horizontalMaterialDepth;
+    private _horizontalMaterialAlways;
+    private _verticalMeshDepth;
+    private _verticalMeshAlways;
+    private _horizontalMeshDepth;
+    private _horizontalMeshAlways;
     private _gizmos;
     private _disconnectCamera;
     private _timeout;
     private _active;
-    private _animation;
+    private _color;
+    private _colorHorizontal;
+    private _opacity;
+    private _opacityAlways;
     constructor(renderer: Renderer, camera: Camera, input: InputHandler, settings: ViewerSettings);
     private connect;
     private onUpdate;
@@ -47,23 +54,21 @@ export declare class GizmoOrbit {
     setPosition(position: THREE.Vector3): void;
     /**
      * Updates the size of the orbit gizmo.
-     * @param {number} size - The new size of the orbit gizmo.
+     * @param {number} size - The new size as fraction of screen (0-1).
      */
     setSize(size: number): void;
     /**
-     * Updates the opacity of the orbit gizmo.
-     * @param {number} opacity - The opacity of the non-occluded part.
-     * @param {number} opacityAlways - The opacity of the occluded part.
+     * Updates the colors of the orbit gizmo.
      */
-    setOpacity(opacity: number, opacityAlways: number): void;
+    setColors(color: THREE.Color, colorHorizontal: THREE.Color): void;
     /**
-     * Updates the color of the orbit gizmo.
-     * @param {THREE.Color} color - The new color for the orbit gizmo.
+     * Updates the opacities of the orbit gizmo.
      */
-    setColor(color: THREE.Color): void;
+    setOpacity(opacity: number, opacityAlways: number): void;
     private applySettings;
     private updateScale;
     private createGizmo;
+    private createInstancedMesh;
     /**
      * Disposes of all resources.
      */

package/dist/types/core-viewers/webgl/viewer/gizmos/markers/gizmoMarker.d.ts

@@ -32,6 +32,7 @@ export declare class Marker implements IVimElement {
      * The index of the marker in the marker collection.
      */
     get index(): number;
+    get isRoom(): boolean;
     private _outlineAttribute;
     private _visibleAttribute;
     private _coloredAttribute;

package/dist/types/core-viewers/webgl/viewer/raycaster.d.ts

@@ -31,7 +31,9 @@ export declare class RaycastResult implements IRaycastResult {
     constructor(intersections: ThreeIntersectionList, firstHit?: THREE.Intersection, object?: Element3D | Marker);
 }
 /**
- * Performs raycasting operations.
+ * Performs CPU-based raycasting operations using Three.js.
+ * This is kept as a reference/fallback implementation.
+ * The primary raycaster is GpuPicker which implements IRaycaster.
  */
 export declare class Raycaster implements IRaycaster {
     private _camera;

package/dist/types/core-viewers/webgl/viewer/rendering/gpuPicker.d.ts

@@ -0,0 +1,127 @@
+/**
+ * @module viw-webgl-viewer/rendering
+ */
+import * as THREE from 'three';
+import { Camera } from '../camera/camera';
+import { RenderScene } from './renderScene';
+import { RenderingSection } from './renderingSection';
+import { Element3D } from '../../loader/element3d';
+import { Vim } from '../../loader/vim';
+import { VimCollection } from '../../loader/vimCollection';
+import type { IRaycaster, IRaycastResult } from '../../../shared';
+import { Marker } from '../gizmos/markers/gizmoMarker';
+/** Raycastable objects for the GpuPicker */
+export type GpuRaycastableObject = Element3D | Marker;
+/**
+ * Packs vimIndex (8 bits) and elementIndex (24 bits) into a single uint32.
+ * Used for GPU picking attribute.
+ */
+export declare function packPickingId(vimIndex: number, elementIndex: number): number;
+/**
+ * Unpacks vimIndex and elementIndex from a packed uint32.
+ */
+export declare function unpackPickingId(packedId: number): {
+    vimIndex: number;
+    elementIndex: number;
+};
+/**
+ * Result of a GPU pick operation containing element index, world position, and surface normal.
+ * Implements IRaycastResult for compatibility with the raycaster interface.
+ */
+export declare class GpuPickResult implements IRaycastResult<GpuRaycastableObject> {
+    /** The element index in the vim */
+    readonly elementIndex: number;
+    /** The vim index identifying which vim the element belongs to */
+    readonly vimIndex: number;
+    /** The world position of the hit */
+    readonly worldPosition: THREE.Vector3;
+    /** The world normal at the hit point */
+    readonly worldNormal: THREE.Vector3;
+    /** Reference to the vim containing the element */
+    private _vim;
+    constructor(elementIndex: number, vimIndex: number, worldPosition: THREE.Vector3, worldNormal: THREE.Vector3, vim: Vim | undefined);
+    /**
+     * The object property for IRaycastResult interface.
+     * Returns the Element3D for the picked element.
+     */
+    get object(): Element3D | undefined;
+    /**
+     * Gets the Element3D object for the picked element.
+     * @returns The Element3D object, or undefined if not found
+     */
+    getElement(): Element3D | undefined;
+}
+/**
+ * Unified GPU picker that outputs element index, depth, vim index, and surface normal in a single render pass.
+ * Implements IRaycaster for compatibility with the viewer's raycaster interface.
+ *
+ * Uses a Float32 render target with:
+ * - R = packed(vimIndex * 16777216 + elementIndex) - supports 256 vims × 16M elements
+ * - G = depth (distance along camera direction, 0 = miss)
+ * - B = normal.x (surface normal X component)
+ * - A = normal.y (surface normal Y component)
+ *
+ * Normal.z is reconstructed as: sqrt(1 - x² - y²), always positive since normal faces camera.
+ */
+export declare class GpuPicker implements IRaycaster<GpuRaycastableObject> {
+    private _renderer;
+    private _camera;
+    private _scene;
+    private _vims;
+    private _section;
+    private _renderTarget;
+    private _pickingMaterial;
+    private _readBuffer;
+    debug: boolean;
+    private _debugSphere;
+    private _debugLine;
+    constructor(renderer: THREE.WebGLRenderer, camera: Camera, scene: RenderScene, vims: VimCollection, section: RenderingSection, width: number, height: number);
+    /**
+     * Updates the render target size to match viewport.
+     */
+    setSize(width: number, height: number): void;
+    /**
+     * Performs GPU picking at the given screen coordinates.
+     * Returns a result object with element index, world position, and getElement() method.
+     *
+     * @param screenPos Screen position in 0-1 range (0,0 is top-left)
+     * @returns Pick result with element index, world position, and getElement(), or undefined if no hit
+     */
+    pick(screenPos: THREE.Vector2): GpuPickResult | undefined;
+    /**
+     * Shows debug visuals (sphere at hit point, line showing normal direction).
+     */
+    private showDebugVisuals;
+    /**
+     * Reconstructs world position from screen coordinates and depth value.
+     */
+    private reconstructWorldPosition;
+    /**
+     * Removes debug visuals (sphere and normal line) from the scene.
+     */
+    clearDebugVisuals(): void;
+    /**
+     * Raycasts from camera to the screen position to find the first object hit.
+     * Implements IRaycaster interface.
+     * @param position - Screen position in 0-1 range (0,0 is top-left)
+     * @returns A promise that resolves to the raycast result, or undefined if no hit
+     */
+    raycastFromScreen(position: THREE.Vector2): Promise<GpuPickResult | undefined>;
+    /**
+     * Raycasts from camera towards a world position to find the first object hit.
+     * Implements IRaycaster interface.
+     * @param position - The world position to raycast towards
+     * @returns A promise that resolves to the raycast result, or undefined if no hit
+     */
+    raycastFromWorld(position: THREE.Vector3): Promise<GpuPickResult | undefined>;
+    /**
+     * Converts a world position to screen coordinates (0-1 range).
+     * @param worldPos - The world position to convert
+     * @returns Screen position in 0-1 range, or undefined if behind camera
+     */
+    private worldToScreen;
+    /**
+     * Disposes of all resources.
+     */
+    dispose(): void;
+}

package/dist/types/core-viewers/webgl/viewer/rendering/renderScene.d.ts

@@ -12,13 +12,13 @@ export declare class RenderScene {
     threeScene: THREE.Scene;
     boxUpdated: boolean;
     smallGhostThreshold: number | undefined;
-    private _vimScenes;
+    private _vimScenesById;
     private _boundingBox;
     private _memory;
     private _2dCount;
     private _outlineCount;
     private _modelMaterial;
-    get meshes(): (import("../..").InsertableMesh | import("../..").Mesh | InstancedMesh)[];
+    get meshes(): (InstancedMesh | import("../..").Mesh | import("../..").InsertableMesh)[];
     constructor();
     get estimatedMemory(): number;
     has2dObjects(): boolean;

package/dist/types/core-viewers/webgl/viewer/rendering/renderer.d.ts

@@ -62,8 +62,15 @@ export declare class Renderer implements IRenderer {
      */
     get background(): THREE.Color | THREE.Texture;
     set background(color: THREE.Color | THREE.Texture);
+    /**
+     * Sets the material used to render models. If set to undefined, the default model or mesh material is used.
+     */
     get modelMaterial(): ModelMaterial;
     set modelMaterial(material: ModelMaterial);
+    /**
+     * The material that will be used when setting model material to undefined.
+     */
+    defaultModelMaterial: ModelMaterial;
     /**
      * Signal dispatched at the end of each frame if the scene was updated, such as visibility changes.
      */

package/dist/types/core-viewers/webgl/viewer/rendering/renderingSection.d.ts

@@ -33,4 +33,8 @@ export declare class RenderingSection {
      */
     set active(value: boolean);
     get active(): boolean;
+    /**
+     * Returns the clipping planes used for section box culling.
+     */
+    get clippingPlanes(): THREE.Plane[];
 }

package/dist/types/core-viewers/webgl/viewer/settings/viewerSettings.d.ts

@@ -106,23 +106,28 @@ export type ViewerSettings = {
             */
             enable: boolean;
             /**
-            * Size of camera gizmo.
-            * Default: 0.01
+            * Size of camera gizmo as fraction of screen (0-1).
+            * Default: 0.1
             */
             size: number;
             /**
-            * Color of camera gizmo.
-            * Default: THREE.Color(255, 255, 255)
+            * Color of vertical rings (great circles).
+            * Default: THREE.Color(0x0590cc) - VIM blue
             */
             color: THREE.Color;
             /**
-            * Opacity of the camera gizmo.
+            * Color of horizontal rings (latitude circles).
+            * Default: THREE.Color(0x58b5dd) - Primary_300
+            */
+            colorHorizontal: THREE.Color;
+            /**
+            * Opacity of the camera gizmo when in front of objects.
             * Default: 0.5
             */
             opacity: number;
             /**
             * Opacity of the camera gizmo when behind objects.
-            * Default: 0.125
+            * Default: 0.1
             */
             opacityAlways: number;
         };

package/dist/types/core-viewers/webgl/viewer/viewer.d.ts

@@ -17,6 +17,11 @@ import { Renderer } from './rendering/renderer';
  * Viewer and loader for vim files.
  */
 export declare class Viewer {
+    /**
+     * The type of the viewer, indicating it is a WebGL viewer.
+     * Useful for distinguishing between different viewer types in a multi-viewer application.
+     */
+    readonly type = "webgl";
     /**
      * The settings configuration used by the viewer.
      */
@@ -63,7 +68,7 @@ export declare class Viewer {
     get onVimLoaded(): ISignal;
     private _camera;
     private _clock;
-    private _vims;
+    private _vimCollection;
     private _onVimLoaded;
     private _updateId;
     constructor(settings?: PartialViewerSettings);
@@ -77,6 +82,16 @@ export declare class Viewer {
      * The number of Vim objects currently loaded in the viewer.
      */
     get vimCount(): number;
+    /**
+     * Allocates a stable ID for a new vim to be loaded.
+     * The ID persists for the vim's lifetime and is used for GPU picking.
+     * @returns The allocated ID (0-255), or undefined if all 256 slots are in use
+     */
+    allocateVimId(): number | undefined;
+    /**
+     * Whether the viewer has reached maximum capacity (256 vims).
+     */
+    get isVimsFull(): boolean;
     /**
      * Adds a Vim object to the renderer, triggering the appropriate actions and dispatching events upon successful addition.
      * @param {Vim} vim - The Vim object to add to the renderer.

package/dist/types/core-viewers/webgl/viewer/viewport.d.ts

@@ -62,7 +62,7 @@ export declare class Viewport {
     /**
      * Resizes the canvas and updates the camera to match new parent dimensions.
      */
-    ResizeToParent(): void;
+    resizeToParent(): void;
     /**
      * Set a callback for canvas resize with debouncing
      * https://stackoverflow.com/questions/5825447/javascript-event-for-canvas-resize/30688151

package/dist/types/react-viewers/bim/bimPanel.d.ts

@@ -3,19 +3,19 @@
  */
 import React from 'react';
 import * as Core from '../../core-viewers';
-import { Settings } from '../settings';
 import { CameraRef } from '../state/cameraState';
 import { IsolationRef } from '../state/sharedIsolation';
 import { ViewerState } from '../webgl/viewerState';
 import { BimInfoPanelRef } from './bimInfoData';
 import { TreeActionRef } from './bimTree';
+import { WebglSettings } from '../webgl/settings';
 export declare function OptionalBimPanel(props: {
     viewer: Core.Webgl.Viewer;
     camera: CameraRef;
     viewerState: ViewerState;
     isolation: IsolationRef;
     visible: boolean;
-    settings: Settings;
+    settings: WebglSettings;
     treeRef: React.MutableRefObject<TreeActionRef | undefined>;
     bimInfoRef: BimInfoPanelRef;
 }): JSX.Element;
@@ -34,7 +34,7 @@ export declare function BimPanel(props: {
     viewerState: ViewerState;
     isolation: IsolationRef;
     visible: boolean;
-    settings: Settings;
+    settings: WebglSettings;
     treeRef: React.MutableRefObject<TreeActionRef | undefined>;
     bimInfoRef: BimInfoPanelRef;
 }): import("react/jsx-runtime").JSX.Element;