vim-web 0.3.42 → 0.3.44-dev.0

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

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+/**
+ * Defines the box mesh for the section box.
+ */
+export declare class SectionBoxMesh extends THREE.Mesh {
+    constructor();
+    /**
+     * Resize the mesh to the given box.
+     */
+    fitBox(box: THREE.Box3): void;
+    /**
+     * Disposes of all resources.
+     */
+    dispose(): void;
+}

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

@@ -1,18 +1,21 @@
 /**
- @module viw-webgl-viewer/gizmos/sectionBox
-*/
+ * @module viw-webgl-viewer/gizmos/sectionBox
+ */
 import { Viewer } from '../../viewer';
 import * as THREE from 'three';
 /**
- * Gizmo for section box, serving as a proxy between the renderer and the user.
+ * Manages a section box gizmo, serving as a proxy between the renderer and the user.
+ *
+ * This class:
+ *  - Maintains a Three.js `Box3` that defines the clipping region.
+ *  - Handles user interaction via {@link BoxInputs}.
+ *  - Updates a {@link SectionBoxGizmo} to visualize the clipping box.
+ *  - Dispatches signals when the box is resized or interaction state changes.
  */
 export declare class SectionBox {
     private _viewer;
+    private _gizmos;
     private _inputs;
-    private _cube;
-    private _outline;
-    private _highlight;
-    private _normal;
     private _clip;
     private _visible;
     private _interactive;
@@ -20,51 +23,82 @@ export declare class SectionBox {
     private _onBoxConfirm;
     private _onHover;
     /**
-     * Signal dispatched when clip, show, or interactive are updated.
+     * @internal
+     * A convenience getter to the viewer's renderer.
+     */
+    private get renderer();
+    /**
+     * @internal
+     * A convenience getter to the `Section` module in the renderer.
+     */
+    private get section();
+    /**
+     * Dispatches when any of the following properties change:
+     * - {@link clip} (clipping planes active)
+     * - {@link visible} (gizmo visibility)
+     * - {@link interactive} (pointer inputs active)
      */
     get onStateChanged(): import("ste-signals").ISignal;
     /**
-     * Signal dispatched when user is done manipulating the box.
+     * Dispatches when the user finishes manipulating (dragging) the box.
+     * The payload is the final {@link THREE.Box3} used for clipping.
      */
     get onBoxConfirm(): import("ste-simple-events").ISimpleEvent<THREE.Box3>;
     /**
-     * Signal dispatched with true when pointer enters box and false when pointer leaves.
+     * Dispatches a boolean indicating pointer hover state on the box handles:
+     *  - `true` if the pointer has entered a handle
+     *  - `false` if it has left or no handle is hovered
      */
     get onHover(): import("ste-simple-events").ISimpleEvent<boolean>;
-    private get renderer();
-    private get section();
+    /**
+     * Creates a new SectionBox gizmo controller.
+     *
+     * @param viewer - The parent {@link Viewer} in which the section box is rendered.
+     */
     constructor(viewer: Viewer);
     /**
-     * Section bounding box, to update the box use fitBox.
+     * The shared bounding box that defines the section region.
+     *
+     * To programmatically update the box, see {@link fitBox}.
      */
     get box(): THREE.Box3;
     /**
-     * Determines whether the section gizmo will section the model with clipping planes.
+     * Determines whether the section gizmo applies clipping planes to the model.
+     *
+     * When `true`, `renderer.section.active` is enabled.
      */
     get clip(): boolean;
     set clip(value: boolean);
     /**
-     * Determines whether the gizmo reacts to user inputs.
+     * Determines whether the gizmo is interactive (i.e. responds to pointer events).
+     *
+     * When `true`, pointer events are registered and box handles can be dragged.
      */
     get interactive(): boolean;
     set interactive(value: boolean);
     /**
-     * Determines whether the gizmo will be rendered.
+     * Determines whether the section box gizmo is visible in the scene.
      */
     get visible(): boolean;
     set visible(value: boolean);
     /**
-     * Sets the section gizmo size to match the given box.
-     * @param {THREE.Box3} box - The box to match the section gizmo size to.
-     * @param {number} [padding=1] - The padding to apply to the box.
+     * Resizes the section gizmo to match the given box, optionally expanded by a padding.
+     * After resizing, this method also updates the renderer's clipping box.
+     *
+     * @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, padding?: number): void;
     /**
-     * Call this if there were direct changes to renderer.section
+     * Updates the section box to match the current size of `this.section.box`.
+     *
+     * Call this if the renderer's section box is changed by code outside this class.
      */
     update(): void;
     /**
-     * Removes gizmo from rendering and inputs and dispose all resources.
+     * Disposes of the gizmo and input event listeners, cleaning up related resources.
+     *
+     * After disposal, this `SectionBox` instance should no longer be used.
      */
     dispose(): void;
 }

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

@@ -1,47 +1,17 @@
-/**
- * @module viw-webgl-viewer/gizmos/sectionBox
- */
 import * as THREE from 'three';
-/**
- * Defines the thin outline on the edges of the section box.
- */
-export declare class BoxOutline extends THREE.LineSegments {
-    constructor();
-    /**
-     * Resize the outline to the given box.
-     */
+import { SectionBoxMesh } from './SectionBoxMesh';
+import { SectionBoxOutline } from './sectionBoxOutline';
+import { SectionBoxHandles } from './sectionBoxHandles';
+import { Renderer } from '../../rendering/renderer';
+export declare class SectionBoxGizmo {
+    private _renderer;
+    readonly cube: SectionBoxMesh;
+    readonly outline: SectionBoxOutline;
+    readonly handles: SectionBoxHandles;
+    private _visible;
+    get visible(): boolean;
+    set visible(value: boolean);
+    constructor(renderer: Renderer);
     fitBox(box: THREE.Box3): void;
-    /**
-     * Disposes of all resources.
-     */
-    dispose(): void;
-}
-/**
- * Defines the box mesh for the section box.
- */
-export declare class BoxMesh extends THREE.Mesh {
-    constructor();
-    /**
-     * Resize the mesh to the given box.
-     */
-    fitBox(box: THREE.Box3): void;
-    /**
-     * Disposes of all resources.
-     */
-    dispose(): void;
-}
-/**
- * Defines the face highlight on hover for the section box.
- */
-export declare class BoxHighlight extends THREE.Mesh {
-    constructor();
-    /**
-     * Sets the face to highlight
-     * @param normal a direction vector from theses options (X,-X, Y,-Y, Z,-Z)
-     */
-    highlight(box: THREE.Box3, normal: THREE.Vector3): void;
-    /**
-     * Disposes all resources.
-     */
     dispose(): void;
 }

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

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

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

@@ -0,0 +1,19 @@
+/**
+ * @module viw-webgl-viewer/gizmos/sectionBox
+ */
+import * as THREE from 'three';
+import { SectionBoxHandle } from './sectionBoxHandle';
+export declare class SectionBoxHandles {
+    readonly up: SectionBoxHandle;
+    readonly down: SectionBoxHandle;
+    readonly left: SectionBoxHandle;
+    readonly right: SectionBoxHandle;
+    readonly front: SectionBoxHandle;
+    readonly back: SectionBoxHandle;
+    readonly meshes: THREE.Group;
+    constructor();
+    get visible(): boolean;
+    set visible(value: boolean);
+    fitBox(box: THREE.Box3): void;
+    dispose(): void;
+}

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

@@ -1,40 +1,155 @@
 /**
- @module viw-webgl-viewer/gizmos/sectionBox
-*/
+ * @module viw-webgl-viewer/gizmos/sectionBox
+ */
 import { Viewer } from '../../viewer';
 import * as THREE from 'three';
+import { SectionBoxHandles } from './sectionBoxHandles';
 /**
- * Defines user interactions with the section box.
+ * Manages pointer interactions (mouse, touch, etc.) on a {@link SectionBoxHandles} to
+ * reshape a Three.js `Box3`. This includes detecting which handle is hovered or dragged,
+ * capturing the pointer for smooth dragging, and enforcing a minimum box size.
  */
 export declare class BoxInputs {
-    viewer: Viewer;
-    cube: THREE.Object3D;
-    sharedBox: THREE.Box3;
-    faceNormal: THREE.Vector3;
-    dragOrigin: THREE.Vector3;
-    dragpPlane: THREE.Plane;
-    mouseDown: boolean | undefined;
-    raycaster: THREE.Raycaster;
-    lastBox: THREE.Box3;
-    unregisters: (() => void)[];
-    lastMouse: PointerEvent;
-    ctrlDown: boolean;
-    capturedId: number | undefined;
+    /** The parent Viewer controlling the scene. */
+    private _viewer;
+    /** The handles mesh group containing the draggable cones/faces. */
+    private _handles;
+    /** The main box that is being reshaped by dragging handles. */
+    private _sharedBox;
+    /** The currently hovered/dragged handle, if any. */
+    private _handle;
+    /** The origin point for dragging, updated on pointer down. */
+    private _dragOrigin;
+    /** The plane used for drag intersection (perpendicular to the camera direction). */
+    private _dragPlane;
+    /** Whether a pointer is currently down on a handle. */
+    private _mouseDown;
+    /** A reusable Raycaster for picking and plane intersection. */
+    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;
+    /**
+     * 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.
+     */
     onFaceEnter: ((normal: THREE.Vector3) => void) | undefined;
+    /**
+     * Called continuously as the box is reshaped by dragging.
+     * @param box - The updated box after the latest drag move.
+     */
     onBoxStretch: ((box: THREE.Box3) => void) | undefined;
+    /**
+     * Called when the user has finished reshaping the box (pointer up).
+     * @param box - The final box after dragging ends.
+     */
     onBoxConfirm: ((box: THREE.Box3) => void) | undefined;
-    constructor(viewer: Viewer, cube: THREE.Object3D, box: THREE.Box3);
-    private reg;
+    /**
+     * Creates a new BoxInputs instance for pointer-driven box resizing.
+     *
+     * @param viewer - The parent {@link Viewer} that renders the scene.
+     * @param handles - A {@link SectionBoxHandles} instance containing the draggable mesh handles.
+     * @param box - The shared bounding box (`Box3`) that will be updated by dragging.
+     */
+    constructor(viewer: Viewer, handles: SectionBoxHandles, box: THREE.Box3);
+    /**
+     * Registers pointer event listeners on the viewer's canvas.
+     * If already registered, it does nothing.
+     */
     register(): void;
-    onPointerLeave(event: PointerEvent): void;
-    capturePointer(pointerId: number): void;
-    releasePointer(): void;
+    /**
+     * Unregisters any previously set pointer event listeners, releasing pointer capture
+     * and resetting drag state.
+     */
     unregister(): void;
-    onKey(event: KeyboardEvent): void;
-    onMouseMove(event: PointerEvent): void;
-    onMouseUp(event: PointerEvent): void;
-    onMouseDown(event: PointerEvent): void;
-    onDrag(event: any): void;
-    stretch(normal: THREE.Vector3, amount: number): THREE.Box3;
-    raycast(position: THREE.Vector2, reverse: boolean): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[];
+    /**
+     * 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}.
+     * - Otherwise, performs a raycast to detect which handle is under the pointer.
+     *
+     * @param event - The pointermove event.
+     */
+    private onMouseMove;
+    /**
+     * Handles pointer up events. Ends dragging and triggers {@link onBoxConfirm}.
+     *
+     * @param event - The pointerup event.
+     */
+    private onMouseUp;
+    /**
+     * Handles pointer down events. Begins drag if a handle is hit, capturing the pointer.
+     *
+     * @param event - The pointerdown event.
+     */
+    private onMouseDown;
+    /**
+     * Continues the drag operation. Determines the new position on the drag plane
+     * and computes how far we moved along the handle's forward axis.
+     *
+     * @param event - The pointermove event while dragging.
+     */
+    private onDrag;
+    /**
+     * Expands or contracts the `_sharedBox` along one axis by a certain amount,
+     * ensuring the box cannot shrink below the minimum size (`MIN_BOX_SIZE`).
+     *
+     * @param axis - The axis ('x', 'y', or 'z') to stretch.
+     * @param sign - +1 if stretching the 'max' side, -1 if stretching the 'min' side.
+     * @param amount - The numeric offset along that axis to add or subtract.
+     * @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.
+     *
+     * @param position - The pointer position in canvas coordinates.
+     * @returns An array of intersection results, if any.
+     */
+    private raycast;
+    /**
+     * Raycasts into the drag plane from the given pointer position.
+     *
+     * @param position - The pointer position in canvas coordinates.
+     * @returns The intersection point in 3D space, or `null` if none.
+     */
+    private raycastPlane;
 }

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

@@ -0,0 +1,15 @@
+import * as THREE from 'three';
+/**
+ * Defines the thin outline on the edges of the section box.
+ */
+export declare class SectionBoxOutline extends THREE.LineSegments {
+    constructor(color: THREE.Color);
+    /**
+     * Resize the outline to the given box.
+     */
+    fitBox(box: THREE.Box3): void;
+    /**
+     * Disposes of all resources.
+     */
+    dispose(): void;
+}

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

@@ -3,11 +3,11 @@
  */
 import * as THREE from 'three';
 import { Viewer } from '../viewer';
-import { KeyboardHandler } from './keyboard';
-import { TouchHandler } from './touch';
-import { MouseHandler } from './mouse';
+import { KeyboardHandler } from './keyboardHandler';
+import { TouchHandler } from './touchHandler';
+import { MouseHandler } from './mouseHandler';
 import { InputAction } from '../raycaster';
-export { KEYS } from './keyboard';
+export { KEYS } from './keyboardHandler';
 /** Pointers mode supported by the viewer */
 export type PointerMode = 'orbit' | 'look' | 'pan' | 'zoom' | 'rect';
 /**

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

@@ -3,18 +3,21 @@
  */
 import * as THREE from 'three';
 import { Scene } from '../../loader/scene';
+import { ModelMaterial } from '../../loader/materials/viewerMaterials';
+import { InstancedMesh } from '../../loader/progressive/instancedMesh';
 /**
  * Wrapper around the THREE scene that tracks bounding box and other information.
  */
 export declare class RenderScene {
     scene: THREE.Scene;
     boxUpdated: boolean;
+    smallGhostThreshold: number | undefined;
     private _vimScenes;
     private _boundingBox;
     private _memory;
     private _2dCount;
-    private _material;
-    get models(): (import("../..").InsertableMesh | import("../../loader/mesh").Mesh | import("../../loader/progressive/instancedMesh").InstancedMesh)[];
+    private _modelMaterial;
+    get meshes(): (import("../..").InsertableMesh | import("../../loader/mesh").Mesh | InstancedMesh)[];
     constructor();
     get estimatedMemory(): number;
     has2dObjects(): boolean;
@@ -45,8 +48,9 @@ export declare class RenderScene {
      * Removes all rendered objects
      */
     clear(): void;
-    get material(): THREE.Material;
-    set material(material: THREE.Material);
+    get modelMaterial(): ModelMaterial;
+    set modelMaterial(material: ModelMaterial);
+    private updateInstanceMeshVisibility;
     private addScene;
     updateBox(box: THREE.Box3 | undefined): void;
     private removeScene;

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

@@ -5,7 +5,7 @@ import * as THREE from 'three';
 import { IRenderer, Scene } from '../../loader/scene';
 import { Viewport } from '../viewport';
 import { RenderScene } from './renderScene';
-import { ViewerMaterials } from '../../loader/materials/viewerMaterials';
+import { ModelMaterial, ViewerMaterials } from '../../loader/materials/viewerMaterials';
 import { CSS2DRenderer } from 'three/examples/jsm/renderers/CSS2DRenderer';
 import { Camera } from '../camera/camera';
 import { RenderingSection } from './renderingSection';
@@ -36,7 +36,6 @@ export declare class Renderer implements IRenderer {
     private _composer;
     private _materials;
     private _renderText;
-    private _skipAntialias;
     private _needsUpdate;
     private _onSceneUpdate;
     private _onBoxUpdated;
@@ -52,13 +51,6 @@ export declare class Renderer implements IRenderer {
      */
     get needsUpdate(): boolean;
     set needsUpdate(value: boolean);
-    /**
-   * Indicates whether the next render should skip antialiasing.
-   * Useful for expensive operations such as the section box.
-   * Can only be set to true. Cleared on each render.
-   */
-    get skipAntialias(): boolean;
-    set skipAntialias(value: boolean);
     constructor(scene: RenderScene, viewport: Viewport, materials: ViewerMaterials, camera: Camera, settings: ViewerSettings);
     /**
      * Removes all objects from rendering and disposes the WebGL context.
@@ -69,6 +61,8 @@ export declare class Renderer implements IRenderer {
      */
     get background(): THREE.Color | THREE.Texture;
     set background(color: THREE.Color | THREE.Texture);
+    get modelMaterial(): ModelMaterial;
+    set modelMaterial(material: ModelMaterial);
     /**
      * Signal dispatched at the end of each frame if the scene was updated, such as visibility changes.
      */
@@ -82,6 +76,8 @@ export declare class Renderer implements IRenderer {
      */
     get textEnabled(): boolean;
     set textEnabled(value: boolean);
+    get smallGhostThreshold(): number;
+    set smallGhostThreshold(value: number);
     /**
      * Returns the bounding box encompassing all rendered objects.
      * @param target - Box in which to copy the result. A new instance is created if undefined.

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

@@ -51,6 +51,7 @@ export declare class Selection {
      *        or `null`, `undefined`, or an empty array to clear the selection.
      */
     select(object: SelectableObject | SelectableObject[] | undefined): void;
+    any(): boolean;
     /**
      * Returns true if the given object is currently selected.
      * @param {IObject} object The object to check for selection.

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

@@ -165,41 +165,6 @@ export type ViewerSettings = {
          */
         sharpness: number;
     };
-    /**
-     * Ground plane under the scene options.
-     */
-    groundPlane: {
-        /**
-        * Enables/Disables plane under scene
-        * Default: true
-        */
-        visible: boolean;
-        /**
-        * Controls how the texture will be retrieved using the texture field.
-        * Default: base64
-        */
-        encoding: TextureEncoding;
-        /**
-        * Local or remote texture url for plane
-        * Default: Vim halo ground provided with the viewer.
-        */
-        texture: string;
-        /**
-        * Opacity of the plane
-        * Default: 1
-        */
-        opacity: number;
-        /**
-        * Color of the plane
-        * Default: THREE.Color(0xff, 0xff, 0xff)
-        */
-        color: THREE.Color;
-        /**
-        * Size of the ground plane relative to the model
-        * Default: 5
-        */
-        size: number;
-    };
     /**
     * Object highlight on click options
     */
@@ -226,16 +191,16 @@ export type ViewerSettings = {
             opacity: number;
         };
         /**
-        * Isolation material options
+        * Ghost material options
         */
-        isolation: {
+        ghost: {
             /**
-            * Isolation material color
+            * Ghost material color
             * Default: rgb(78, 82, 92)
             */
             color: THREE.Color;
             /**
-            * Isolation material opacity
+            * Ghost material opacity
             * Default: 0.08
             */
             opacity: number;

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

@@ -2,7 +2,7 @@
  @module viw-webgl-viewer
 */
 import { ViewerSettings, PartialViewerSettings } from './settings/viewerSettings';
-import { ICamera } from './camera/camera';
+import { ICamera } from './camera/ICamera';
 import { Input } from './inputs/input';
 import { Selection } from './selection';
 import { Environment } from './environment/environment';

package/dist/types/react-viewers/helpers/inputs.d.ts

@@ -3,8 +3,8 @@
  */
 import * as VIM from '../../core-viewers/webgl/index';
 import { SideState } from '../sidePanel/sideState';
-import { Isolation } from './isolation';
 import { ComponentCamera } from './camera';
+import { Isolation } from './isolation';
 /**
  * Custom viewer input scheme for the vim component
  */
@@ -14,7 +14,6 @@ export declare class ComponentInputs implements VIM.InputScheme {
     private _default;
     private _isolation;
     private _sideState;
-    private _help;
     constructor(viewer: VIM.Viewer, camera: ComponentCamera, isolation: Isolation, sideState: SideState);
     private _getSelection;
     onMainAction(hit: VIM.InputAction): void;