vim-web 0.5.1 → 0.6.0-dev.1

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

@@ -68,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);
@@ -82,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/react-viewers/helpers/loadRequest.d.ts

@@ -1,29 +1,28 @@
 import * as Core from '../../core-viewers';
+import { ILoadRequest as CoreILoadRequest } from '../../core-viewers/webgl/loader/progressive/loadRequest';
+import { IProgress } from '../../core-viewers/shared/loadResult';
 import { LoadingError } from '../webgl/loading';
 type RequestCallbacks = {
-    onProgress: (p: Core.Webgl.IProgressLogs) => void;
+    onProgress: (p: IProgress) => void;
     onError: (e: LoadingError) => void;
     onDone: () => void;
 };
 /**
  * Class to handle loading a request.
+ * Implements ILoadRequest for compatibility with Ultra viewer's load request interface.
  */
-export declare class LoadRequest {
-    readonly source: any;
-    private _callbacks;
+export declare class LoadRequest implements CoreILoadRequest {
+    private _source;
     private _request;
-    private _progress;
-    private _progressPromise;
-    private _isDone;
-    private _completionPromise;
-    constructor(callbacks: RequestCallbacks, source: Core.Webgl.RequestSource, settings?: Core.Webgl.VimPartialSettings);
-    private startRequest;
-    private onProgress;
-    private onSuccess;
-    private onError;
-    private end;
-    getProgress(): AsyncGenerator<Core.Webgl.IProgressLogs, void, void>;
-    getResult(): Promise<import("../../utils").Result<Core.Webgl.Vim>>;
+    private _callbacks;
+    private _onLoaded?;
+    private _progressQueue;
+    private _resultPromise;
+    constructor(callbacks: RequestCallbacks, source: Core.Webgl.RequestSource, settings: Core.Webgl.VimPartialSettings, vimIndex: number, onLoaded?: (vim: Core.Webgl.Vim) => Promise<void> | void);
+    private trackAndGetResult;
+    get isCompleted(): boolean;
+    getProgress(): AsyncGenerator<IProgress>;
+    getResult(): Promise<Core.LoadResult<Core.Webgl.Vim>>;
     abort(): void;
 }
 export {};

package/dist/types/react-viewers/panels/loadingBox.d.ts

@@ -2,7 +2,7 @@
  * @module viw-webgl-react
  */
 import { ReactNode } from 'react';
-export type ProgressMode = '%' | 'bytes';
+export type ProgressMode = 'percent' | 'bytes';
 /**
  * Interface for message information displayed in the LoadingBox.
  * @property message - Optional main message text.

package/dist/types/react-viewers/webgl/loading.d.ts

@@ -5,17 +5,13 @@ import * as Core from '../../core-viewers';
 import { LoadRequest } from '../helpers/loadRequest';
 import { ModalHandle } from '../panels/modal';
 import { WebglSettings } from './settings';
+import { IProgress } from '../../core-viewers/shared/loadResult';
 type AddSettings = {
     /**
      * Controls whether to frame the camera on a vim everytime it is updated.
      * Default: true
      */
     autoFrame?: boolean;
-    /**
-     * Controls whether to initially load the vim content or not.
-     * Default: false
-     */
-    loadEmpty?: boolean;
 };
 export type OpenSettings = Core.Webgl.VimPartialSettings & AddSettings;
 export type LoadingError = {
@@ -34,9 +30,9 @@ export declare class ComponentLoader {
     /**
      * Event emitter for progress updates.
      */
-    onProgress(p: Core.Webgl.IProgressLogs): void;
+    onProgress(p: IProgress): void;
     /**
-       * Event emitter for completion notifications.
+      * Event emitter for completion notifications.
      */
     onDone(): void;
     /**
@@ -44,26 +40,25 @@ export declare class ComponentLoader {
      */
     onError(e: LoadingError): void;
     /**
-     * Asynchronously opens a vim at source, applying the provided settings.
-     * @param source The source to open, either as a string or ArrayBuffer.
-     * @param settings Partial settings to apply to the opened source.
-     * @param onProgress Optional callback function to track progress during opening.
-     * Receives progress logs as input.
-     */
-    open(source: Core.Webgl.RequestSource, settings: OpenSettings, onProgress?: (p: Core.Webgl.IProgressLogs) => void): Promise<Core.Webgl.Vim>;
-    /**
-     * Creates a new load request for the provided source and settings.
+     * Opens a vim file without loading geometry.
+     * Use this for querying BIM data or selective loading.
+     * Call vim.loadAll() or vim.loadSubset() to load geometry later.
      * @param source The url to the vim file or a buffer of the file.
      * @param settings Settings to apply to vim file.
-     * @returns A new load request instance to track progress and get result.
+     * @returns A LoadRequest to track progress and get result. The vim is auto-added on success.
+     * @throws Error if the viewer has reached maximum capacity (256 vims)
      */
-    request(source: Core.Webgl.RequestSource, settings?: Core.Webgl.VimPartialSettings): LoadRequest;
-    add(vim: Core.Webgl.Vim, settings?: AddSettings): void;
+    open(source: Core.Webgl.RequestSource, settings?: OpenSettings): LoadRequest;
     /**
-     * Removes the vim from the viewer and disposes it.
-     * @param vim Vim to remove from the viewer.
+     * Loads a vim file with all geometry.
+     * Use this for immediate viewing.
+     * @param source The url to the vim file or a buffer of the file.
+     * @param settings Settings to apply to vim file.
+     * @returns A LoadRequest to track progress and get result. The vim is auto-added on success.
+     * @throws Error if the viewer has reached maximum capacity (256 vims)
      */
-    remove(vim: Core.Webgl.Vim): void;
+    load(source: Core.Webgl.RequestSource, settings?: OpenSettings): LoadRequest;
+    private loadInternal;
     private initVim;
 }
 export {};

package/dist/types/react-viewers/webgl/viewerRef.d.ts

@@ -8,13 +8,14 @@ import { CameraRef } from '../state/cameraState';
 import { Container } from '../container';
 import { BimInfoPanelRef } from '../bim/bimInfoData';
 import { ControlBarRef } from '../controlbar';
-import { ComponentLoader } from './loading';
+import { OpenSettings } from './loading';
 import { ModalHandle } from '../panels/modal';
 import { SectionBoxRef } from '../state/sectionBoxState';
 import { IsolationRef } from '../state/sharedIsolation';
 import { GenericPanelHandle } from '../generic';
 import { SettingsItem } from '../settings/settingsItem';
 import { WebglSettings } from './settings';
+export type { OpenSettings } from './loading';
 /**
 * Settings API managing settings applied to the viewer.
 */
@@ -64,9 +65,25 @@ export type ViewerRef = {
      */
     core: Core.Webgl.Viewer;
     /**
-     * Vim WebGL loader to download VIMs.
+     * Loads a vim file with all geometry for immediate viewing.
+     * @param source The url or buffer of the vim file
+     * @param settings Optional settings
+     * @returns LoadRequest to track progress and get result
      */
-    loader: ComponentLoader;
+    load: (source: Core.Webgl.RequestSource, settings?: OpenSettings) => Core.Webgl.ILoadRequest;
+    /**
+     * Opens a vim file without loading geometry.
+     * Use for BIM queries or selective loading via vim.loadAll()/loadSubset().
+     * @param source The url or buffer of the vim file
+     * @param settings Optional settings
+     * @returns LoadRequest to track progress and get result
+     */
+    open: (source: Core.Webgl.RequestSource, settings?: OpenSettings) => Core.Webgl.ILoadRequest;
+    /**
+     * Removes a vim from the viewer and disposes it.
+     * @param vim The vim to remove
+     */
+    remove: (vim: Core.Webgl.Vim) => void;
     /**
      * Isolation API managing isolation state in the viewer.
      */

package/dist/types/utils/asyncQueue.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A queue that converts push-based callbacks into an async iterator.
+ * Use this to bridge callback-based APIs with async/await consumers.
+ */
+export declare class AsyncQueue<T> {
+    private _queue;
+    private _waiters;
+    private _closed;
+    /** Push a value to the queue. Wakes up one waiting consumer. */
+    push(value: T): void;
+    /** Close the queue. No more values can be pushed. */
+    close(): void;
+    /** Async iterator that yields queued values until closed. */
+    [Symbol.asyncIterator](): AsyncGenerator<T, void, void>;
+}

package/dist/types/utils/index.d.ts

@@ -1,10 +1,10 @@
 export * from './array';
+export * from './asyncQueue';
 export * from './debounce';
 export * from './interfaces';
 export * from './math3d';
 export * from './partial';
 export * from './promise';
-export * from './result';
 export * from './threeUtils';
 export * from './url';
 export * from './validation';