vim-web 0.3.43 → 0.3.44-dev.0

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