vim-web 0.3.23 → 0.3.25

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

@@ -0,0 +1,103 @@
+/**
+ * @module viw-webgl-viewer/gizmos/measure
+ */
+import * as THREE from 'three';
+import { InputAction } from '../../raycaster';
+import { Viewer } from '../../viewer';
+import { MeasureStage } from './measureFlow';
+/**
+ * Interacts with the measure tool.
+ */
+export interface IMeasure {
+    /**
+     * Start point of the current measure or undefined if no active measure.
+     */
+    get startPoint(): THREE.Vector3 | undefined;
+    /**
+     * End point of the current measure or undefined if no active measure.
+     */
+    get endPoint(): THREE.Vector3 | undefined;
+    /**
+     * Vector from start to end of the current measure or undefined if no active measure.
+     */
+    get measurement(): THREE.Vector3 | undefined;
+    /**
+     * Stage of the current measure or undefined if no active measure.
+     */
+    get stage(): MeasureStage | undefined;
+    /**
+     * Starts a new measure flow where the two next click are overriden.
+     * Currently running flow if any will be aborted.
+     * 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>;
+    /**
+     * Aborts the current measure flow, fails the related promise.
+     */
+    abort(): void;
+    /**
+     * Clears meshes.
+     */
+    clear(): void;
+}
+/**
+ * Manages measure flow and gizmos
+ */
+export declare class Measure implements IMeasure {
+    private _viewer;
+    private _meshes;
+    private _startPos;
+    private _endPos;
+    private _measurement;
+    private _flow;
+    private _previousScheme;
+    /**
+     * Start point of the current measure or undefined if no active measure.
+     */
+    get startPoint(): THREE.Vector3;
+    /**
+     * End point of the current measure or undefined if no active measure.
+     */
+    get endPoint(): THREE.Vector3;
+    /**
+     * Vector from start to end of the current measure or undefined if no active measure.
+     */
+    get measurement(): THREE.Vector3;
+    /**
+     * Stage of the current measure or undefined if no active measure.
+     */
+    get stage(): MeasureStage | undefined;
+    constructor(viewer: Viewer);
+    /**
+     * Starts a new measure flow where the two next click are overriden.
+     * Currently running flow if any will be aborted.
+     * 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>;
+    /**
+     * Should be private.
+     */
+    onFirstClick(action: InputAction): void;
+    /**
+     * Should be private.
+     */
+    onMouseMove(): void;
+    /**
+     * Should be private.
+     */
+    onMouseIdle(action: InputAction): void;
+    /**
+     * Should be private.
+     */
+    onSecondClick(action: InputAction): boolean;
+    /**
+     * Aborts the current measure flow, fails the related promise.
+     */
+    abort(): void;
+    /**
+     * Clears meshes.
+     */
+    clear(): void;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/gizmos/measure/measureFlow.d.ts

@@ -0,0 +1,36 @@
+/**
+ @module viw-webgl-viewer/gizmos/measure
+*/
+import { InputScheme } from '../../inputs/input';
+import { InputAction } from '../../raycaster';
+import { Measure } from './measure';
+export type MeasureStage = 'ready' | 'active' | 'done' | 'failed';
+/**
+ * Inputs scheme for measuring as a small state machine.
+ */
+export declare class MeasureFlow implements InputScheme {
+    private readonly _gizmoMeasure;
+    private _stage;
+    private removeMouseListener;
+    constructor(gizmoMeasure: Measure);
+    onProgress: ((stage: MeasureStage) => void) | undefined;
+    onComplete: ((success: boolean) => void) | undefined;
+    get stage(): MeasureStage;
+    private unregister;
+    /**
+     * Cancels current measuring flow.
+     */
+    abort(): void;
+    /**
+     * Implementation for InputScheme onMainAction
+     */
+    onMainAction(action: InputAction): void;
+    /**
+     * Implementation for InputScheme onIdleAction
+     */
+    onIdleAction(action: InputAction): void;
+    /**
+     * Implementation for InputScheme onKeyAction
+     */
+    onKeyAction(key: number): boolean;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/gizmos/measure/measureGizmo.d.ts

@@ -0,0 +1,44 @@
+/**
+ @module viw-webgl-viewer/gizmos/measure
+*/
+import * as THREE from 'three';
+import { Viewer } from '../../viewer';
+/**
+ * Reprents all graphical elements associated with a measure.
+ */
+export declare class MeasureGizmo {
+    private _viewer;
+    private _startMarker;
+    private _endMarker;
+    private _line;
+    private _lineX;
+    private _lineY;
+    private _lineZ;
+    private _group;
+    private _label;
+    private _html;
+    private _animId;
+    constructor(viewer: Viewer);
+    private _animate;
+    private screenDist;
+    /**
+     * Sets up a new measure
+     */
+    start(start: THREE.Vector3): void;
+    /**
+     * Hides existing measure.
+     */
+    hide(): void;
+    /**
+     * Updates current measure
+     */
+    update(start: THREE.Vector3, pos: THREE.Vector3): void;
+    /**
+     * Finishes current measure.
+     */
+    finish(start: THREE.Vector3, end: THREE.Vector3): boolean;
+    /**
+     * Disposes all resources.
+     */
+    dispose(): void;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/gizmos/measure/measureHtml.d.ts

@@ -0,0 +1,26 @@
+/**
+ @module viw-webgl-viewer/gizmos/measure
+*/
+/**
+ * Different styles of measure display.
+ */
+export type MeasureStyle = 'all' | 'Dist' | 'X' | 'Y' | 'Z';
+/**
+ * Structure of the html element used for measure.
+ */
+export type MeasureElement = {
+    div: HTMLElement;
+    value: HTMLTableCellElement | undefined;
+    values: {
+        dist: HTMLTableCellElement | undefined;
+        x: HTMLTableCellElement | undefined;
+        y: HTMLTableCellElement | undefined;
+        z: HTMLTableCellElement | undefined;
+    };
+};
+/**
+ * Creates a html structure for measure value overlays
+ * It either creates a single rows or all rows depending on style
+ * Structure is a Table of Label:Value
+ */
+export declare function createMeasureElement(style: MeasureStyle): MeasureElement;

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

@@ -0,0 +1,70 @@
+/**
+ @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.
+ */
+export declare class SectionBox {
+    private _viewer;
+    private _inputs;
+    private _cube;
+    private _outline;
+    private _highlight;
+    private _normal;
+    private _clip;
+    private _visible;
+    private _interactive;
+    private _onStateChanged;
+    private _onBoxConfirm;
+    private _onHover;
+    /**
+     * Signal dispatched when clip, show, or interactive are updated.
+     */
+    get onStateChanged(): import("ste-signals").ISignal;
+    /**
+     * Signal dispatched when user is done manipulating the box.
+     */
+    get onBoxConfirm(): import("ste-simple-events").ISimpleEvent<THREE.Box3>;
+    /**
+     * Signal dispatched with true when pointer enters box and false when pointer leaves.
+     */
+    get onHover(): import("ste-simple-events").ISimpleEvent<boolean>;
+    private get renderer();
+    private get section();
+    constructor(viewer: Viewer);
+    /**
+     * Section bounding box, to update the box use fitBox.
+     */
+    get box(): THREE.Box3;
+    /**
+     * Determines whether the section gizmo will section the model with clipping planes.
+     */
+    get clip(): boolean;
+    set clip(value: boolean);
+    /**
+     * Determines whether the gizmo reacts to user inputs.
+     */
+    get interactive(): boolean;
+    set interactive(value: boolean);
+    /**
+     * Determines whether the gizmo will be rendered.
+     */
+    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.
+     */
+    fitBox(box: THREE.Box3, padding?: number): void;
+    /**
+     * Call this if there were direct changes to renderer.section
+     */
+    update(): void;
+    /**
+     * Removes gizmo from rendering and inputs and dispose all resources.
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,47 @@
+/**
+ * @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.
+     */
+    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/webgl-viewer/vim-webgl-viewer/gizmos/sectionBox/sectionBoxInputs.d.ts

@@ -0,0 +1,39 @@
+/**
+ @module viw-webgl-viewer/gizmos/sectionBox
+*/
+import { Viewer } from '../../viewer';
+import * as THREE from 'three';
+/**
+ * Defines user interactions with the section box.
+ */
+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;
+    onFaceEnter: ((normal: THREE.Vector3) => void) | undefined;
+    onBoxStretch: ((box: THREE.Box3) => void) | undefined;
+    onBoxConfirm: ((box: THREE.Box3) => void) | undefined;
+    constructor(viewer: Viewer, cube: THREE.Object3D, box: THREE.Box3);
+    private reg;
+    register(): void;
+    capturePointer(pointerId: number): void;
+    releasePointer(): void;
+    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.Event>>[];
+}

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

@@ -0,0 +1,128 @@
+/**
+ * @module viw-webgl-viewer/inputs
+ */
+import * as THREE from 'three';
+import { Viewer } from '../viewer';
+import { KeyboardHandler } from './keyboard';
+import { TouchHandler } from './touch';
+import { MouseHandler } from './mouse';
+import { InputAction } from '../raycaster';
+export { KEYS } from './keyboard';
+/** Pointers mode supported by the viewer */
+export type PointerMode = 'orbit' | 'look' | 'pan' | 'zoom' | 'rect';
+/**
+ * Defines an input scheme for the viewer.
+ */
+export interface InputScheme {
+    /**
+     * Called when mouse clicked or mobile tap.
+     */
+    onMainAction(hit: InputAction): void;
+    /**
+     * Called once when mouse and camera have been idle for some time with the position where it stopped.
+     * Called once when the mouse moves again with undefined
+     */
+    onIdleAction(hit: InputAction | undefined): void;
+    /**
+     * Called when a key is pressed and released.
+     */
+    onKeyAction(key: number): boolean;
+}
+/**
+ * Vim viewer default input scheme
+ */
+export declare class DefaultInputScheme implements InputScheme {
+    private _viewer;
+    constructor(viewer: Viewer);
+    onMainAction(action: InputAction): void;
+    onIdleAction(hit: InputAction): void;
+    onKeyAction(key: number): boolean;
+}
+/**
+ * Manages and registers all viewer user inputs for mouse, keyboard and touch
+ */
+export declare class Input {
+    private _viewer;
+    /**
+     * Touch input handler
+     */
+    touch: TouchHandler;
+    /**
+     * Mouse input handler
+     */
+    mouse: MouseHandler;
+    /**
+     * Keyboard input handler
+     */
+    keyboard: KeyboardHandler;
+    private _pointerActive;
+    private _pointerFallback;
+    private _pointerOverride;
+    constructor(viewer: Viewer);
+    /**
+     * Returns the last main mode (orbit, look) that was active.
+     */
+    get pointerFallback(): PointerMode;
+    /**
+     * Returns current pointer mode.
+     */
+    get pointerActive(): PointerMode;
+    /**
+     * A temporary pointer mode used for temporary icons.
+     */
+    get pointerOverride(): PointerMode | undefined;
+    set pointerOverride(value: PointerMode | undefined);
+    /**
+     * Changes pointer interaction mode. Look mode will set camera orbitMode to false.
+     */
+    set pointerActive(value: PointerMode);
+    private _onPointerModeChanged;
+    /**
+     * Event called when pointer interaction mode changes.
+     */
+    get onPointerModeChanged(): import("ste-signals").ISignal;
+    private _onPointerOverrideChanged;
+    /**
+     * Event called when the pointer is temporarily overriden.
+     */
+    get onPointerOverrideChanged(): import("ste-signals").ISignal;
+    private _onContextMenu;
+    /**
+     * Event called when when context menu could be displayed
+     */
+    get onContextMenu(): import("ste-simple-events").ISimpleEvent<THREE.Vector2>;
+    private _scheme;
+    /**
+     * Get or set the current viewer input scheme, set undefined to revert to default.
+     */
+    get scheme(): InputScheme | undefined;
+    set scheme(value: InputScheme | undefined);
+    /**
+     * Calls main action on the current input scheme
+     */
+    MainAction(action: InputAction): void;
+    /**
+     * Calls idle action on the current input scheme
+     */
+    IdleAction(action: InputAction | undefined): void;
+    /**
+     * Calls key action on the current input scheme
+     */
+    KeyAction(key: number): boolean;
+    /**
+     * Calls context menu action
+     */
+    ContextMenu(position: THREE.Vector2 | undefined): void;
+    /**
+     * Register inputs handlers for default viewer behavior
+     */
+    registerAll(): void;
+    /**
+     * Unregisters all input handlers
+     */
+    unregisterAll: () => void;
+    /**
+     * Resets all input state
+     */
+    resetAll(): void;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/inputs/inputHandler.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @module viw-webgl-viewer/inputs
+ */
+import { Viewer } from '../viewer';
+/**
+ * Base class for various input handlers.
+ * It provides convenience to register to and unregister from events.
+ */
+export declare class InputHandler {
+    protected _viewer: Viewer;
+    protected _unregisters: Function[];
+    constructor(viewer: Viewer);
+    protected reg: (handler: Document | HTMLElement | Window, type: string, listener: (event: any) => void) => void;
+    /**
+     * Register handler to related browser events
+     * Prevents double registrations
+     */
+    register(): void;
+    protected addListeners(): void;
+    /**
+     * Unregister handler from related browser events
+     * Prevents double unregistration
+     */
+    unregister(): void;
+    /**
+     * Reset handler states such as button down, drag, etc.
+     */
+    reset(): void;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/inputs/keyboard.d.ts

@@ -0,0 +1,113 @@
+/**
+ * @module viw-webgl-viewer/inputs
+ */
+import { InputHandler } from './inputHandler';
+/**
+ * Key values for viewer
+ */
+export declare const KEYS: {
+    KEY_0: number;
+    KEY_1: number;
+    KEY_2: number;
+    KEY_3: number;
+    KEY_4: number;
+    KEY_5: number;
+    KEY_6: number;
+    KEY_7: number;
+    KEY_8: number;
+    KEY_9: number;
+    KEY_LEFT: number;
+    KEY_RIGHT: number;
+    KEY_UP: number;
+    KEY_DOWN: number;
+    KEY_CTRL: number;
+    KEY_SHIFT: number;
+    KEY_ENTER: number;
+    KEY_SPACE: number;
+    KEY_TAB: number;
+    KEY_ESCAPE: number;
+    KEY_BACKSPACE: number;
+    KEY_HOME: number;
+    KEY_END: number;
+    KEY_INSERT: number;
+    KEY_DELETE: number;
+    KEY_ALT: number;
+    KEY_F1: number;
+    KEY_F2: number;
+    KEY_F3: number;
+    KEY_F4: number;
+    KEY_F5: number;
+    KEY_F6: number;
+    KEY_F7: number;
+    KEY_F8: number;
+    KEY_F9: number;
+    KEY_F10: number;
+    KEY_F11: number;
+    KEY_F12: number;
+    KEY_NUMPAD0: number;
+    KEY_NUMPAD1: number;
+    KEY_NUMPAD2: number;
+    KEY_NUMPAD3: number;
+    KEY_NUMPAD4: number;
+    KEY_NUMPAD5: number;
+    KEY_NUMPAD6: number;
+    KEY_NUMPAD7: number;
+    KEY_NUMPAD8: number;
+    KEY_NUMPAD9: number;
+    KEY_ADD: number;
+    KEY_SUBTRACT: number;
+    KEY_MULTIPLY: number;
+    KEY_DIVIDE: number;
+    KEY_SEPARATOR: number;
+    KEY_DECIMAL: number;
+    KEY_OEM_PLUS: number;
+    KEY_OEM_MINUS: number;
+    KEY_A: number;
+    KEY_B: number;
+    KEY_C: number;
+    KEY_D: number;
+    KEY_E: number;
+    KEY_F: number;
+    KEY_G: number;
+    KEY_H: number;
+    KEY_I: number;
+    KEY_J: number;
+    KEY_K: number;
+    KEY_L: number;
+    KEY_M: number;
+    KEY_N: number;
+    KEY_O: number;
+    KEY_P: number;
+    KEY_Q: number;
+    KEY_R: number;
+    KEY_S: number;
+    KEY_T: number;
+    KEY_U: number;
+    KEY_V: number;
+    KEY_W: number;
+    KEY_X: number;
+    KEY_Y: number;
+    KEY_Z: number;
+};
+/**
+ * Manages keyboard user inputs
+ */
+export declare class KeyboardHandler extends InputHandler {
+    private SHIFT_MULTIPLIER;
+    isUpPressed: boolean;
+    isDownPressed: boolean;
+    isLeftPressed: boolean;
+    isRightPressed: boolean;
+    isEPressed: boolean;
+    isQPressed: boolean;
+    isShiftPressed: boolean;
+    isCtrlPressed: boolean;
+    arrowsEnabled: boolean;
+    protected addListeners(): void;
+    reset(): void;
+    private get camera();
+    private onKeyUp;
+    private onKeyDown;
+    private onKey;
+    private applyMove;
+}