vim-web 0.3.44-dev.6 → 0.3.44-dev.60

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

@@ -2,7 +2,6 @@ import { Viewer } from '../viewer';
 import { GizmoAxes } from './axes/gizmoAxes';
 import { GizmoLoading } from './gizmoLoading';
 import { GizmoOrbit } from './gizmoOrbit';
-import { GizmoRectangle } from './gizmoRectangle';
 import { IMeasure } from './measure/measure';
 import { SectionBox } from './sectionBox/sectionBox';
 import { GizmoMarkers } from './markers/gizmoMarkers';
@@ -29,10 +28,6 @@ export declare class Gizmos {
      * The camera orbit target gizmo.
      */
     readonly orbit: GizmoOrbit;
-    /**
-     * Rectangle Gizmo used for rectangle selection.
-     */
-    readonly rectangle: GizmoRectangle;
     /**
      * The axis gizmos of the viewer.
      */

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

@@ -0,0 +1,7 @@
+export * from './gizmos';
+export * from './gizmoLoading';
+export type * from './gizmoOrbit';
+export type * from './axes';
+export type * from './markers';
+export type * from './measure';
+export type * from './sectionBox';

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

@@ -2,63 +2,111 @@ import { Vim } from '../../../loader/vim';
 import { Viewer } from '../../viewer';
 import * as THREE from 'three';
 import { SimpleInstanceSubmesh } from '../../../loader/mesh';
+import { IVimObject } from '../../../../shared/vim';
 /**
- * Marker gizmo that display an interactive sphere at a 3D positions
+ * Marker gizmo that displays an interactive sphere at a 3D position.
  * Marker gizmos are still under development.
  */
-export declare class GizmoMarker {
+export declare class Marker implements IVimObject {
     readonly type = "Marker";
     private _viewer;
     private _submesh;
+    private static _tmpMatrix;
+    private static _unitVector;
     /**
-     * The vim object from which this object came from.
+     * The Vim object from which this object came.
+     * Can be undefined if the object is not part of a Vim.
      */
     vim: Vim | undefined;
     /**
-     * The bim element index associated with this object.
+     * The BIM element index associated with this object.
+     * Can be undefined if the object is not part of a Vim.
      */
     element: number | undefined;
     /**
-     * The geometry instances  associated with this object.
+     * The geometry instances associated with this object.
+     * This is used when the marker is derived from multiple instances.
      */
     instances: number[] | undefined;
+    /**
+     * The index of the marker in the marker collection.
+     */
+    get index(): number;
     private _outlineAttribute;
     private _visibleAttribute;
     private _coloredAttribute;
     private _focusedAttribute;
     private _colorAttribute;
+    /**
+     * Constructs a new Marker object.
+     * @param viewer - The viewer managing rendering and interaction.
+     * @param submesh - The instanced submesh this marker is bound to.
+     */
     constructor(viewer: Viewer, submesh: SimpleInstanceSubmesh);
+    /**
+     * Updates the underlying submesh and rebinds all attributes to the new mesh.
+     * @param mesh - The new submesh to bind to this marker.
+     */
     updateMesh(mesh: SimpleInstanceSubmesh): void;
-    /** Sets the position of the marker in the 3d scene */
+    /**
+     * Sets the world position of the marker.
+     */
     set position(value: THREE.Vector3);
+    /**
+     * Gets the world position of the marker.
+     */
     get position(): THREE.Vector3;
     /**
-     * Always false
+     * Always false; marker is a gizmo and not an actual mesh.
      */
     get hasMesh(): boolean;
     /**
-     * Applies a color override instead of outlines.
+     * Gets whether the marker is outlined (highlighted).
      */
     get outline(): boolean;
+    /**
+     * Sets whether the marker is outlined (highlighted).
+     */
     set outline(value: boolean);
     /**
-     * Enlarges the gizmo to indicate focus.
+     * Gets whether the marker is focused (enlarged).
      */
     get focused(): boolean;
+    /**
+     * Sets whether the marker is focused (enlarged).
+     */
     set focused(value: boolean);
     /**
-     * Determines if the gizmo will be rendered.
+     * Gets whether the marker is visible in the scene.
      */
     get visible(): boolean;
+    /**
+     * Sets whether the marker is visible in the scene.
+     */
     set visible(value: boolean);
+    /**
+     * Gets the current color override for the marker.
+     */
     get color(): THREE.Color;
-    set color(color: THREE.Color);
+    /**
+     * Sets the color override for the marker.
+     * Passing undefined disables the override.
+     */
+    set color(color: THREE.Color | undefined);
+    /**
+     * Gets the uniform scale factor applied to the marker.
+     */
     get size(): number;
+    /**
+     * Sets the uniform scale factor for the marker.
+     * Only updates the matrix if the size has changed.
+     */
     set size(value: number);
     /**
-     * Retrieves the bounding box of the object from cache or computes it if needed.
-     * Returns a unit box arount the marker position.
-     * @returns {THREE.Box3 | undefined} The bounding box of the object.
+     * Retrieves the bounding box of the object.
+     * Returns a unit-sized box centered at the marker position.
+     * Returned as a promise to satisfy interface, but computed synchronously.
+     * @returns The bounding box of the marker.
      */
-    getBoundingBox(): THREE.Box3;
+    getBoundingBox(): Promise<THREE.Box3>;
 }

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

@@ -1,29 +1,52 @@
 import { Viewer } from '../../viewer';
 import * as THREE from 'three';
-import { GizmoMarker } from './gizmoMarker';
+import { Marker } from './gizmoMarker';
 /**
  * API for adding and managing sprite markers in the scene.
+ * Uses THREE.InstancedMesh for performance.
  */
 export declare class GizmoMarkers {
     private _viewer;
     private _markers;
     private _mesh;
+    private _reusableMatrix;
+    /**
+     * Constructs the marker manager and sets up an initial instanced mesh.
+     * @param viewer - The rendering context this marker system belongs to.
+     */
     constructor(viewer: Viewer);
-    getMarkerFromIndex(index: number): GizmoMarker;
+    /**
+     * Returns the marker at the given index.
+     * @param index - The marker index.
+     * @returns The Marker instance or undefined.
+     */
+    getMarkerFromIndex(index: number): Marker | undefined;
+    /**
+     * Creates a new instanced mesh with given capacity, optionally reusing geometry/material.
+     * @param previous - Optional mesh to reuse properties from.
+     * @param capacity - Number of instances the mesh should support.
+     * @returns A new THREE.InstancedMesh.
+     */
     private createMesh;
+    /**
+     * Doubles the mesh capacity and copies over all instance data and marker bindings.
+     */
     private resizeMesh;
     /**
      * Adds a sprite marker at the specified position.
-     * @param {THREE.Vector3} position - The position at which to add the marker.
+     * Resizes mesh if capacity is reached.
+     * @param position - The world position to add the marker at.
+     * @returns The newly created Marker.
      */
-    add(position: THREE.Vector3): GizmoMarker;
+    add(position: THREE.Vector3): Marker;
     /**
      * Removes the specified marker from the scene.
-     * @param {GizmoMarker} marker - The marker to remove.
+     * Uses swap-and-pop to maintain dense storage.
+     * @param marker - The marker to remove.
      */
-    remove(marker: GizmoMarker): void;
+    remove(marker: Marker): void;
     /**
-     * Removes all markers from the scene.
+     * Removes all markers from the scene and resets mesh count.
      */
     clear(): void;
 }

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

@@ -0,0 +1,2 @@
+export * from './gizmoMarker';
+export * from './gizmoMarkers';

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

@@ -0,0 +1,3 @@
+export * from './measure';
+export * from './measureGizmo';
+export * from './measureHtml';

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

@@ -2,9 +2,8 @@
  * @module viw-webgl-viewer/gizmos/measure
  */
 import * as THREE from 'three';
-import { InputAction } from '../../raycaster';
+import { IRaycastResult } from '../../raycaster';
 import { Viewer } from '../../viewer';
-import { MeasureStage } from './measureFlow';
 /**
  * Interacts with the measure tool.
  */
@@ -31,7 +30,7 @@ export interface IMeasure {
      * Promise is resolved if flow is succesfully completed, rejected otherwise.
      * Do not override viewer.onMouseClick while this flow is active.
      */
-    start(onProgress?: () => void): Promise<void>;
+    start(): Promise<void>;
     /**
      * Aborts the current measure flow, fails the related promise.
      */
@@ -41,6 +40,7 @@ export interface IMeasure {
      */
     clear(): void;
 }
+export type MeasureStage = 'ready' | 'active' | 'done' | 'failed';
 /**
  * Manages measure flow and gizmos
  */
@@ -50,8 +50,9 @@ export declare class Measure implements IMeasure {
     private _startPos;
     private _endPos;
     private _measurement;
-    private _flow;
-    private _previousScheme;
+    private _previousOnClick;
+    private _promise;
+    private _stage;
     /**
      * Start point of the current measure or undefined if no active measure.
      */
@@ -75,23 +76,16 @@ export declare class Measure implements IMeasure {
      * Promise is resolved if flow is succesfully completed, rejected otherwise.
      * Do not override viewer.onMouseClick while this flow is active.
      */
-    start(onProgress?: () => void): Promise<void>;
+    start(): Promise<void>;
+    private onClick;
     /**
      * Should be private.
      */
-    onFirstClick(action: InputAction): void;
+    onFirstClick(hit: IRaycastResult): void;
     /**
      * Should be private.
      */
-    onMouseMove(): void;
-    /**
-     * Should be private.
-     */
-    onMouseIdle(action: InputAction): void;
-    /**
-     * Should be private.
-     */
-    onSecondClick(action: InputAction): boolean;
+    onSecondClick(hit: IRaycastResult): boolean;
     /**
      * Aborts the current measure flow, fails the related promise.
      */

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

@@ -0,0 +1,7 @@
+export * from './sectionBox';
+export * from './sectionBoxGizmo';
+export * from './sectionBoxHandle';
+export * from './sectionBoxHandles';
+export * from './sectionBoxInputs';
+export * from './SectionBoxMesh';
+export * from './sectionBoxOutline';

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

@@ -57,11 +57,10 @@ export declare class SectionBox {
      */
     constructor(viewer: Viewer);
     /**
-     * The shared bounding box that defines the section region.
-     *
-     * To programmatically update the box, see {@link fitBox}.
+     * Returns a copy of the current section box.
+     * To programmatically update the box, see {@link setBox}.
      */
-    get box(): THREE.Box3;
+    getBox(): THREE.Box3;
     /**
      * Determines whether the section gizmo applies clipping planes to the model.
      *
@@ -88,7 +87,7 @@ export declare class SectionBox {
      * @param box - The bounding box to match (required).
      * @param padding - The scalar amount by which to expand the bounding box. Default is `1`.
      */
-    fitBox(box: THREE.Box3): void;
+    setBox(box: THREE.Box3): void;
     /**
      * Updates the section box to match the current size of `this.section.box`.
      *

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

@@ -3,7 +3,7 @@ import { SectionBoxMesh } from './SectionBoxMesh';
 import { SectionBoxOutline } from './sectionBoxOutline';
 import { SectionBoxHandles } from './sectionBoxHandles';
 import { Renderer } from '../../rendering/renderer';
-import { ICamera } from '../../camera/camera';
+import { ICamera } from '../../camera';
 export declare class SectionBoxGizmo {
     private _renderer;
     readonly cube: SectionBoxMesh;

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

@@ -1,16 +1,18 @@
 import * as THREE from 'three';
-import { ICamera } from '../../camera/camera';
-export type Axis = 'x' | 'y' | 'z';
+import { ICamera } from '../../camera';
+export type AxisName = 'x' | 'y' | 'z';
 export declare class SectionBoxHandle extends THREE.Mesh {
-    readonly axis: Axis;
+    readonly axis: AxisName;
     readonly sign: number;
     private _forward;
     private _color;
     private _highlightColor;
     private _materials;
+    private _camera;
     private _camSub;
-    constructor(axes: Axis, sign: number, size: number, color?: THREE.Color);
+    constructor(axes: AxisName, sign: number, size: number, color?: THREE.Color);
     trackCamera(camera: ICamera): void;
+    update(): void;
     setPosition(position: THREE.Vector3): void;
     get forward(): THREE.Vector3;
     highlight(value: boolean): void;

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

@@ -3,7 +3,7 @@
  */
 import * as THREE from 'three';
 import { SectionBoxHandle } from './sectionBoxHandle';
-import { ICamera } from '../../camera/camera';
+import { ICamera } from '../../camera';
 export declare class SectionBoxHandles {
     readonly up: SectionBoxHandle;
     readonly down: SectionBoxHandle;

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

@@ -28,10 +28,8 @@ export declare class BoxInputs {
     private _raycaster;
     /** The box state before the current drag. */
     private _lastBox;
-    /** A collection of unregister callbacks for event listeners. */
-    private _unregisters;
-    /** The ID of the pointer that is captured, if any. */
-    private _capturedPointerId;
+    /** A callback to restore the original input listeners after unregistering. */
+    private _restoreOriginalInputs;
     /**
      * Called when the pointer enters or leaves a handle face.
      * @param normal - The normal (forward) vector of the hovered handle, or a zero vector if none.
@@ -65,35 +63,6 @@ export declare class BoxInputs {
      * and resetting drag state.
      */
     unregister(): void;
-    /**
-     * Indicates if a pointer is currently captured for dragging.
-     */
-    get pointerCaptured(): boolean;
-    /**
-     * A helper method to attach an event listener and store its unregister callback.
-     *
-     * @param handler - The DOM element or Window to attach the listener to.
-     * @param type - The pointer event type, e.g. 'pointerdown'.
-     * @param listener - The event handler function.
-     */
-    private reg;
-    /**
-     * Called when the pointer leaves the canvas. If not dragging,
-     * invokes {@link onFaceEnter} to indicate no active handle is hovered.
-     *
-     * @param event - The pointerleave event.
-     */
-    private onPointerLeave;
-    /**
-     * Sets pointer capture on the canvas for a specific pointer (ID).
-     *
-     * @param pointerId - The pointer ID to capture.
-     */
-    private capturePointer;
-    /**
-     * Releases any captured pointer on the canvas, if present.
-     */
-    private releasePointer;
     /**
      * Handles pointer movement events.
      * - If dragging, calls {@link onDrag}.
@@ -131,13 +100,6 @@ export declare class BoxInputs {
      * @returns A **new** `Box3` instance with updated min/max coordinates.
      */
     private stretch;
-    /**
-     * Prepares the internal raycaster for a given 2D pointer position.
-     *
-     * @param position - The pointer position in canvas coordinates.
-     * @returns The updated raycaster pointing from the camera through this position.
-     */
-    private getRaycaster;
     /**
      * Raycasts into the handle meshes from the given pointer position.
      *
@@ -152,4 +114,5 @@ export declare class BoxInputs {
      * @returns The intersection point in 3D space, or `null` if none.
      */
     private raycastPlane;
+    private setupRaycaster;
 }

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

@@ -0,0 +1,10 @@
+export * from './viewer';
+export * from './settings';
+export type * from './environment';
+export type * from './gizmos';
+export type * from './raycaster';
+export { Layers } from './raycaster';
+export type * from './selection';
+export type * from './viewport';
+export type * from './rendering';
+export type * from './camera';

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

@@ -0,0 +1,3 @@
+import { InputHandler } from "../../shared/inputHandler";
+import { Viewer } from "./viewer";
+export declare function createInputHandler(viewer: Viewer): InputHandler;

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

@@ -2,88 +2,68 @@
  * @module viw-webgl-viewer
  */
 import * as THREE from 'three';
-import { Object3D } from '../loader/object3D';
+import { Element3D } from '../loader/element3d';
 import { RenderScene } from './rendering/renderScene';
-import { Viewport } from './viewport';
 import { Camera } from './camera/camera';
 import { Renderer } from './rendering/renderer';
-import { GizmoMarker } from './gizmos/markers/gizmoMarker';
+import { Marker } from './gizmos/markers/gizmoMarker';
+import type { IRaycaster as IRaycasterBase, IRaycastResult as IRaycastResultBase } from '../../shared';
 /**
- * Type alias for THREE intersection array
+ * Type alias for an array of THREE.Intersection objects.
  */
 export type ThreeIntersectionList = THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[];
-export type ActionType = 'main' | 'double' | 'idle';
-export type ActionModifier = 'none' | 'shift' | 'ctrl';
+export type RaycastableObject = Element3D | Marker;
+export type IRaycastResult = IRaycastResultBase<RaycastableObject>;
+export type IRaycaster = IRaycasterBase<RaycastableObject>;
+export declare enum Layers {
+    Default = 0,
+    NoRaycast = 1
+}
 /**
- * Highlevel aggregate of information about a raycast result
+ * A simple container for raycast results.
  */
-export declare class RaycastResult {
-    object: Object3D | GizmoMarker | undefined;
+export declare class RaycastResult implements IRaycastResult {
+    object: Element3D | Marker | undefined;
     intersections: ThreeIntersectionList;
     firstHit: THREE.Intersection | undefined;
-    constructor(intersections: ThreeIntersectionList);
-    private GetFirstVimHit;
-    private GetFirstMarkerHit;
-    private getVimObjectFromHit;
-    get isHit(): boolean;
-    get distance(): number;
-    get position(): THREE.Vector3;
-    get threeId(): number;
-    get faceIndex(): number;
+    get worldNormal(): THREE.Vector3;
+    get worldPosition(): THREE.Vector3;
+    constructor(intersections: ThreeIntersectionList, firstHit?: THREE.Intersection, object?: Element3D | Marker);
 }
-export declare class Raycaster {
-    private _viewport;
+/**
+ * Performs raycasting operations.
+ */
+export declare class Raycaster implements IRaycaster {
     private _camera;
     private _scene;
     private _renderer;
     private _raycaster;
-    constructor(viewport: Viewport, camera: Camera, scene: RenderScene, renderer: Renderer);
+    constructor(camera: Camera, scene: RenderScene, renderer: Renderer);
     /**
-     * Performs a raycast by projecting a ray from the camera position to a screen position.
-     * @param {THREE.Vector2} position - The screen position for raycasting.
+     * Performs a raycast from the camera using normalized screen coordinates.
+     * Coordinates must be within [0, 1] for both x and y.
      */
-    raycast2(position: THREE.Vector2): RaycastResult;
-    private filterHits;
+    raycastFromScreen(position: THREE.Vector2): Promise<RaycastResult>;
     /**
-     * Performs a raycast by projecting a ray from the camera position to a world position.
-     * @param {THREE.Vector3} position - The world position for raycasting.
+     * Performs a raycast from the camera towards a specified world position.
      */
-    raycast3(position: THREE.Vector3): RaycastResult;
+    raycastFromWorld(position: THREE.Vector3): Promise<RaycastResult>;
+    private filterHits;
     /**
-     * Performs a raycast by projecting a ray from the camera center.
+     * Processes the list of intersections to determine the first valid hit.
+     * It first checks for a marker hit, then for a model object hit.
      */
-    raycastForward(): RaycastResult;
+    private processIntersections;
     /**
-     * Returns a THREE.Raycaster projecting a ray from camera position to screen position
+     * Extracts the core model object from a raycast hit.
      */
-    fromPoint2(position: THREE.Vector2, target?: THREE.Raycaster): THREE.Raycaster;
+    private getVimObjectFromHit;
     /**
-     * Returns a THREE.Raycaster projecting a ray from the camera position to a screen position.
-     * @param {THREE.Vector2} position - The screen position for raycasting.
-     * @returns {THREE.Raycaster} A raycaster object for performing raycasting.
+     * Creates a WebglRaycastResult from a list of intersections by processing the hits.
      */
-    fromPoint3(position: THREE.Vector3, target?: THREE.Raycaster): THREE.Raycaster;
+    private createResultFromIntersections;
 }
 /**
- * Represents an input action with its position and modifiers.
+ * Converts normalized screen coordinates (0-1 range) into Three.js NDC ([-1, 1] range).
  */
-export declare class InputAction {
-    readonly position: THREE.Vector2;
-    readonly modifier: ActionModifier;
-    readonly type: ActionType;
-    private _raycaster;
-    constructor(type: ActionType, modifier: ActionModifier, position: THREE.Vector2, raycaster: Raycaster);
-    private _raycast;
-    /**
-     * A THREE.Raycaster object for custom raycasting.
-     */
-    get raycaster(): THREE.Raycaster;
-    /**
-     * Performs raycasting for VIM objects at the current point. This operation can be computationally expensive.
-     */
-    get raycast(): RaycastResult;
-    /**
-     * Returns the object at the current point. This operation can cause a computationally expensive raycast evaluation.
-     */
-    get object(): Object3D | GizmoMarker;
-}
+export declare function threeNDCFromVector2(position: THREE.Vector2): THREE.Vector2;

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

@@ -0,0 +1,4 @@
+export type * from './renderingSection';
+export type * from './renderer';
+export type * from './renderScene';
+export type * from './renderingComposer';

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

@@ -3,14 +3,14 @@
  */
 import * as THREE from 'three';
 import { Pass } from 'three/examples/jsm/postprocessing/Pass';
-import { ViewerMaterials } from '../../loader/materials/viewerMaterials';
+import { Materials } from '../../loader/materials/materials';
 /**
  * Merges a source buffer into the the current write buffer.
  */
 export declare class MergePass extends Pass {
     private _fsQuad;
     private _material;
-    constructor(source: THREE.Texture, materials?: ViewerMaterials);
+    constructor(source: THREE.Texture, materials?: Materials);
     get source(): THREE.Texture;
     set source(value: THREE.Texture);
     dispose(): void;