vim-web 0.3.23 → 0.3.25

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

@@ -0,0 +1,66 @@
+/**
+ * @module viw-webgl-viewer/inputs
+ */
+import { InputHandler } from './inputHandler';
+import { Viewer } from '../viewer';
+/**
+ * Manages mouse user inputs
+ */
+export declare class MouseHandler extends InputHandler {
+    private readonly _idleDelayMs;
+    /**
+     * The speed factor for zoom movements using the scroll wheel.
+     * Range: [0.1, 10]
+     */
+    get scrollSpeed(): number;
+    set scrollSpeed(value: number);
+    private _scrollSpeed;
+    /**
+     * The speed factor for zoom movements when using zoom mode.
+     */
+    zoomSpeed: number;
+    /**
+     * The speed factor for rotations movements.
+     */
+    rotateSpeed: number;
+    /**
+     * The speed factor for orbit movements.
+     */
+    orbitSpeed: number;
+    private _buttonDown;
+    private _hasMouseMoved;
+    private _hasCameraMoved;
+    private _idleTimeout;
+    private _idlePosition;
+    private _lastPosition;
+    private _downPosition;
+    constructor(viewer: Viewer);
+    private get camera();
+    private get viewport();
+    private get canvas();
+    private get raycaster();
+    private get inputs();
+    private get gizmoRect();
+    protected addListeners(): void;
+    reset: () => void;
+    private resetIdle;
+    private onMouseOut;
+    private onMouseIdle;
+    private onCameraMoved;
+    private onMouseMove;
+    private onMouseDown;
+    private onMouseDrag;
+    private toRotation;
+    private onMouseMainDrag;
+    private onMouseMiddleDrag;
+    private pan;
+    private onMouseRightDrag;
+    private onMouseWheel;
+    private getButton;
+    private onMouseUp;
+    private onRectEnd;
+    private onDoubleClick;
+    private onMouseClick;
+    private getModifier;
+    private updateRectangle;
+}

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

@@ -0,0 +1,45 @@
+/**
+ * @module viw-webgl-viewer/inputs
+ */
+import { InputHandler } from './inputHandler';
+import { Viewer } from '../viewer';
+/**
+ * Manages user touch inputs.
+ */
+export declare class TouchHandler extends InputHandler {
+    private readonly TAP_DURATION_MS;
+    private readonly DOUBLE_TAP_DELAY_MS;
+    private readonly TAP_MAX_MOVE_PIXEL;
+    private readonly ZOOM_SPEED;
+    private readonly MOVE_SPEED;
+    /**
+     * Speed factor for rotation movements
+     */
+    rotateSpeed: number;
+    /**
+     * Speed factor for orbit movements
+     */
+    orbitSpeed: number;
+    constructor(viewer: Viewer);
+    private get camera();
+    private get viewport();
+    private _touch;
+    private _touch1;
+    private _touch2;
+    private _touchStartTime;
+    private _lastTapMs;
+    private _touchStart;
+    protected addListeners(): void;
+    reset: () => void;
+    private onTap;
+    private onTouchStart;
+    private toRotation;
+    private onDrag;
+    private onDoubleDrag;
+    private onPinchOrSpread;
+    private onTouchMove;
+    private onTouchEnd;
+    private isSingleTouch;
+    private touchToVector;
+    private average;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/raycaster.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @module viw-webgl-viewer
+ */
+import * as THREE from 'three';
+import { Object3D } from '../vim-loader/object3D';
+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';
+/**
+ * Type alias for THREE intersection array
+ */
+export type ThreeIntersectionList = THREE.Intersection<THREE.Object3D<THREE.Event>>[];
+export type ActionType = 'main' | 'double' | 'idle';
+export type ActionModifier = 'none' | 'shift' | 'ctrl';
+/**
+ * Highlevel aggregate of information about a raycast result
+ */
+export declare class RaycastResult {
+    object: Object3D | GizmoMarker | 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;
+}
+export declare class Raycaster {
+    private _viewport;
+    private _camera;
+    private _scene;
+    private _renderer;
+    private _raycaster;
+    constructor(viewport: Viewport, 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.
+     */
+    raycast2(position: THREE.Vector2): RaycastResult;
+    private filterHits;
+    /**
+     * Performs a raycast by projecting a ray from the camera position to a world position.
+     * @param {THREE.Vector3} position - The world position for raycasting.
+     */
+    raycast3(position: THREE.Vector3): RaycastResult;
+    /**
+     * Performs a raycast by projecting a ray from the camera center.
+     */
+    raycastForward(): RaycastResult;
+    /**
+     * Returns a THREE.Raycaster projecting a ray from camera position to screen position
+     */
+    fromPoint2(position: THREE.Vector2, target?: THREE.Raycaster): THREE.Raycaster;
+    /**
+     * 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.
+     */
+    fromPoint3(position: THREE.Vector3, target?: THREE.Raycaster): THREE.Raycaster;
+}
+/**
+ * Represents an input action with its position and modifiers.
+ */
+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;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * @module viw-webgl-viewer/rendering
+ */
+import THREE from 'three';
+import { Pass } from 'three/examples/jsm/postprocessing/Pass';
+import { ViewerMaterials } from '../../vim-loader/materials/viewerMaterials';
+/**
+ * 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);
+    dispose(): void;
+    render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget): void;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/rendering/outlinePass.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @module viw-webgl-viewer/rendering
+ */
+import * as THREE from 'three';
+import { Pass } from 'three/examples/jsm/postprocessing/Pass.js';
+import { OutlineMaterial } from '../../vim-loader/materials/outlineMaterial';
+/**
+ * Edge detection pass on the current readbuffer depth texture.
+ */
+export declare class OutlinePass extends Pass {
+    private _fsQuad;
+    material: OutlineMaterial;
+    constructor(sceneBuffer: THREE.Texture, camera: THREE.PerspectiveCamera | THREE.OrthographicCamera, material?: OutlineMaterial);
+    setSize(width: number, height: number): void;
+    get camera(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    set camera(value: THREE.PerspectiveCamera | THREE.OrthographicCamera);
+    dispose(): void;
+    render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget): void;
+}

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

@@ -0,0 +1,49 @@
+/**
+ * @module viw-webgl-viewer/rendering
+ */
+import * as THREE from 'three';
+import { Scene } from '../../vim-loader/scene';
+/**
+ * Wrapper around the THREE scene that tracks bounding box and other information.
+ */
+export declare class RenderScene {
+    scene: THREE.Scene;
+    boxUpdated: boolean;
+    private _vimScenes;
+    private _boundingBox;
+    private _memory;
+    private _2dCount;
+    constructor();
+    get estimatedMemory(): number;
+    has2dObjects(): boolean;
+    hasOutline(): boolean;
+    /** Clears the scene updated flags */
+    clearUpdateFlags(): void;
+    /**
+     * Returns the bounding box encompasing all rendererd objects.
+     * @param target box in which to copy result, a new instance is created if undefined.
+     */
+    getBoundingBox(target?: THREE.Box3): THREE.Box3;
+    /**
+     * Returns the bounding box of the average center of all meshes.
+     * Less precise but is more stable against outliers.
+     */
+    getAverageBoundingBox(): THREE.Box3;
+    /**
+     * Add object to be rendered
+     */
+    add(target: Scene | THREE.Object3D): void;
+    private count2dObjects;
+    private unparent2dObjects;
+    /**
+     * Remove object from rendering
+     */
+    remove(target: Scene | THREE.Object3D): void;
+    /**
+     * Removes all rendered objects
+     */
+    clear(): void;
+    private addScene;
+    updateBox(box: THREE.Box3 | undefined): void;
+    private removeScene;
+}

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

@@ -0,0 +1,125 @@
+/**
+ * @module viw-webgl-viewer/rendering
+ */
+import * as THREE from 'three';
+import { IRenderer, Scene } from '../../vim-loader/scene';
+import { Viewport } from '../viewport';
+import { RenderScene } from './renderScene';
+import { ViewerMaterials } from '../../vim-loader/materials/viewerMaterials';
+import { CSS2DRenderer } from 'three/examples/jsm/renderers/CSS2DRenderer';
+import { Camera } from '../camera/camera';
+import { RenderingSection } from './renderingSection';
+import { ViewerSettings } from '../settings/viewerSettings';
+/**
+ * Manages how vim objects are added and removed from the THREE.Scene to be rendered
+ */
+export declare class Renderer implements IRenderer {
+    /**
+     * The THREE WebGL renderer.
+     */
+    readonly renderer: THREE.WebGLRenderer;
+    /**
+     * The THREE sample ui renderer
+     */
+    readonly textRenderer: CSS2DRenderer;
+    /**
+     * Interface to interact with section box directly without using the gizmo.
+     */
+    readonly section: RenderingSection;
+    /**
+     * Determines whether antialias will be applied to rendering or not.
+     */
+    antialias: boolean;
+    private _scene;
+    private _viewport;
+    private _camera;
+    private _composer;
+    private _materials;
+    private _renderText;
+    private _skipAntialias;
+    private _needsUpdate;
+    private _onSceneUpdate;
+    private _onBoxUpdated;
+    private _sceneUpdated;
+    private maxMemory;
+    /**
+     * Indicates whether the scene needs to be re-rendered.
+     * Can only be set to true. Cleared on each render.
+     */
+    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.
+     */
+    dispose(): void;
+    /**
+     * Gets or sets the background color or texture of the scene.
+     */
+    get background(): THREE.Color | THREE.Texture;
+    set background(color: THREE.Color | THREE.Texture);
+    /**
+     * Signal dispatched at the end of each frame if the scene was updated, such as visibility changes.
+     */
+    get onSceneUpdated(): import("ste-signals").ISignal;
+    /**
+     * Signal dispatched when bounding box is updated.
+     */
+    get onBoxUpdated(): import("ste-signals").ISignal;
+    /**
+     * Determines whether text rendering is enabled or not.
+     */
+    get textEnabled(): boolean;
+    set textEnabled(value: boolean);
+    /**
+     * Returns the bounding box encompassing all rendered objects.
+     * @param target - Box in which to copy the result. A new instance is created if undefined.
+     * @returns The bounding box encompassing all rendered objects.
+     */
+    getBoundingBox(target?: THREE.Box3): THREE.Box3;
+    /**
+     * Updates the global rendering bounding box.
+     * @param box - The new bounding box.
+     */
+    updateBox(box: THREE.Box3): void;
+    /**
+     * Notifies that a scene was updated this frame.
+     */
+    notifySceneUpdate(): void;
+    /**
+     * Renders what is in the camera's view.
+     */
+    render(): void;
+    /**
+     * Adds an object to be rendered.
+     * @param target The object or scene to add for rendering.
+     */
+    add(target: Scene | THREE.Object3D): boolean;
+    /**
+     * Removes an object from rendering.
+     * @param target The object or scene to remove from rendering.
+     */
+    remove(target: Scene | THREE.Object3D): void;
+    /**
+     * Clears all objects from rendering.
+     */
+    clear(): void;
+    /**
+     * Returns an estimate of the memory used by the renderer.
+     */
+    get estimatedMemory(): number;
+    /**
+     * Determines the target sample count on the rendering target.
+     * Higher number increases quality.
+     */
+    get samples(): number;
+    set samples(value: number);
+    private fitViewport;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/rendering/renderingComposer.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @module viw-webgl-viewer/rendering
+ */
+import * as THREE from 'three';
+import { Viewport } from '../viewport';
+import { RenderScene } from './renderScene';
+import { ViewerMaterials } from '../../vim-loader/materials/viewerMaterials';
+import { Camera } from '../camera/camera';
+/**
+ * Composer for AA and Outline effects.
+ */
+export declare class RenderingComposer {
+    private _renderer;
+    private _scene;
+    private _materials;
+    private _camera;
+    private _samples;
+    private _size;
+    private _composer;
+    private _renderPass;
+    private _ssaaRenderPass;
+    private _selectionRenderPass;
+    private _transferPass;
+    private _outlines;
+    private _clock;
+    private _nextAATime;
+    onDemand: boolean;
+    private _outlinePass;
+    private _fxaaPass;
+    private _mergePass;
+    private _outlineTarget;
+    private _sceneTarget;
+    constructor(renderer: THREE.WebGLRenderer, scene: RenderScene, viewport: Viewport, materials: ViewerMaterials, camera: Camera);
+    private setup;
+    private setupRendering;
+    private setupOutline;
+    get outlines(): boolean;
+    set outlines(value: boolean);
+    get camera(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    set camera(value: THREE.PerspectiveCamera | THREE.OrthographicCamera);
+    setSize(width: number, height: number): void;
+    get samples(): number;
+    set samples(value: number);
+    render(updated: boolean, antialias: boolean): void;
+    dispose(): void;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/rendering/renderingSection.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module viw-webgl-viewer/rendering
+ */
+import * as THREE from 'three';
+import { ViewerMaterials } from '../../vim-loader/materials/viewerMaterials';
+import { Renderer } from './renderer';
+/**
+ * Manages a section box from renderer clipping planes
+ */
+export declare class RenderingSection {
+    private _renderer;
+    private _materials;
+    private _active;
+    /**
+     * Current section box. To update the box use fitbox.
+     */
+    readonly box: THREE.Box3;
+    private maxX;
+    private minX;
+    private maxY;
+    private minY;
+    private maxZ;
+    private minZ;
+    private planes;
+    constructor(renderer: Renderer, materials: ViewerMaterials);
+    /**
+     * Resizes the section box to match the dimensions of the provided bounding box.
+     * @param box The bounding box to match the section box to.
+     */
+    fitBox(box: THREE.Box3): void;
+    /**
+     * Determines whether objecets outside the section box will be culled or not.
+     */
+    set active(value: boolean);
+    get active(): boolean;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/rendering/transferPass.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module viw-webgl-viewer/rendering
+ */
+import THREE from 'three';
+import { Pass } from 'three/examples/jsm/postprocessing/Pass';
+/**
+ * Copies a source buffer to the current write buffer.
+ */
+export declare class TransferPass extends Pass {
+    private _fsQuad;
+    private _uniforms;
+    constructor(sceneTexture: THREE.Texture);
+    dispose(): void;
+    render(renderer: THREE.WebGLRenderer, writeBuffer: THREE.WebGLRenderTarget, readBuffer: THREE.WebGLRenderTarget): void;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/selection.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @module viw-webgl-viewer
+ */
+import * as THREE from 'three';
+import { Vim, ViewerMaterials } from '..';
+import { GizmoMarker } from './gizmos/markers/gizmoMarker';
+import { Object3D } from '../vim-loader/object3D';
+export type SelectableObject = Object3D | GizmoMarker;
+/**
+ * Provides selection behaviour for the viewer
+ * Supports multi-selection as long as all objects are from the same vim.
+ */
+export declare class Selection {
+    private _materials;
+    private _objects;
+    private _focusedObject;
+    private _vim;
+    private _lastFocusTime;
+    private _onValueChanged;
+    private _unsub;
+    constructor(materials: ViewerMaterials);
+    /**
+     * Event called when selection changes or is cleared
+     */
+    get onValueChanged(): import("ste-signals").ISignal;
+    /**
+     * Returns the Vim instance from which elements are selected.
+     * Cross-Vim selection is not supported.
+     */
+    get vim(): Vim;
+    /**
+     * Returns selected object as an iterator.
+     */
+    get objects(): SetIterator<SelectableObject>;
+    /**
+     * Retrieves the bounding box of the selection. Returns `undefined` if there's no selection.
+     * @param {THREE.Box3} [target] Optional parameter to specify a box to use for the result.
+     * @returns {THREE.Box3 | undefined} The bounding box of the selection or `undefined` if no selection exists.
+     */
+    getBoundingBox(target?: THREE.Box3): THREE.Box3 | undefined;
+    /**
+     * Adds focus highlight to a single object. Pass `undefined` to remove the highlight.
+     * @param {IObject | undefined} object The object to focus on, or `undefined` to remove the highlight.
+     */
+    focus(object: SelectableObject | undefined): void;
+    /**
+     * Selects the given objects and unselects all other objects.
+     * Pass `null`, `undefined`, or an empty array as argument to clear selection.
+     * @param {IObject | IObject[] | undefined} object The object or array of objects to select,
+     *        or `null`, `undefined`, or an empty array to clear the selection.
+     */
+    select(object: SelectableObject | SelectableObject[] | undefined): void;
+    /**
+     * Returns true if the given object is currently selected.
+     * @param {IObject} object The object to check for selection.
+     * @returns {boolean} True if the object is selected, false otherwise.
+     */
+    has(object: SelectableObject): boolean;
+    /**
+     * Returns the current count of selected objects.
+     */
+    get count(): number;
+    /**
+     * Adds the given objects to the current selection.
+     * @param {...IObject[]} objects The objects to add to the selection.
+     */
+    add(...objects: SelectableObject[]): void;
+    /**
+     * Removes the given objects from the current selection.
+     * @param {...IObject[]} objects The objects to remove from the selection.
+     */
+    remove(...objects: SelectableObject[]): void;
+    /**
+     * Toggles the selection state of the given objects:
+     * - Adds unselected elements of the given objects to the selection.
+     * - Removes selected elements of the given objects from the selection.
+     * @param {...IObject[]} objects The objects to toggle selection for.
+     */
+    toggle(...objects: SelectableObject[]): void;
+    /**
+     * Clears the current selection.
+     */
+    clear(): void;
+    /**
+     * Disposes of all resources and stops animations.
+     */
+    dispose(): void;
+    private clearOnNewVim;
+    update(): void;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/settings/defaultViewerSettings.d.ts

@@ -0,0 +1,5 @@
+import { ViewerSettings } from './viewerSettings';
+/**
+ * Defines the default values for the VIM Viewer settings.
+ */
+export declare const defaultViewerSettings: ViewerSettings;