vim-web 0.3.23 → 0.3.25

package/dist/types/webgl-viewer/vim-webgl-viewer/camera/cameraMovementSnap.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @module viw-webgl-viewer/camera
+ */
+import { CameraMovement } from './cameraMovement';
+import { Object3D } from '../../vim-loader/object3D';
+import * as THREE from 'three';
+export declare class CameraMovementSnap extends CameraMovement {
+    /**
+     * Moves the camera closer or farther away from orbit target.
+     * @param amount movement size.
+     */
+    zoom(amount: number): void;
+    reset(): void;
+    setDistance(dist: number): void;
+    rotate(angle: THREE.Vector2): void;
+    applyRotation(quaternion: THREE.Quaternion): void;
+    target(target: Object3D | THREE.Vector3): void;
+    orbit(angle: THREE.Vector2): void;
+    move3(vector: THREE.Vector3): void;
+    set(position: THREE.Vector3, target?: THREE.Vector3): void;
+    private lockVector;
+    predictOrbit(angle: THREE.Vector2): THREE.Vector3;
+    predictRotate(angle: THREE.Vector2): THREE.Quaternion;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/camera/orthographic.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module viw-webgl-viewer/camera
+ */
+import * as THREE from 'three';
+import { ViewerSettings } from '../settings/viewerSettings';
+export declare class OrthographicWrapper {
+    camera: THREE.OrthographicCamera;
+    constructor(camera: THREE.OrthographicCamera);
+    frustrumSizeAt(point: THREE.Vector3): THREE.Vector2;
+    applySettings(settings: ViewerSettings): void;
+    updateProjection(size: THREE.Vector2, aspect: number): void;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/camera/perspective.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module viw-webgl-viewer/camera
+ */
+import * as THREE from 'three';
+import { ViewerSettings } from '../settings/viewerSettings';
+export declare class PerspectiveWrapper {
+    camera: THREE.PerspectiveCamera;
+    constructor(camera: THREE.PerspectiveCamera);
+    applySettings(settings: ViewerSettings): void;
+    updateProjection(aspect: number): void;
+    frustrumSizeAt(point: THREE.Vector3): THREE.Vector2;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/environment/cameraLight.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @module viw-webgl-viewer
+ */
+import * as THREE from 'three';
+import { ICamera } from '../camera/camera';
+export declare class CameraLight {
+    readonly light: THREE.DirectionalLight;
+    private readonly _camera;
+    private _unsubscribe;
+    /**
+     * The position of the light.
+     */
+    position: THREE.Vector3;
+    /**
+     * The color of the light.
+     */
+    get color(): THREE.Color;
+    set color(value: THREE.Color);
+    /**
+     * The intensity of the light.
+     */
+    get intensity(): number;
+    set intensity(value: number);
+    /**
+     * Whether the light follows the camera or not.
+     */
+    get followCamera(): boolean;
+    set followCamera(value: boolean);
+    constructor(camera: ICamera, options: {
+        followCamera: boolean;
+        position: THREE.Vector3;
+        color: THREE.Color;
+        intensity: number;
+    });
+    /**
+     * Updates the light's position based on the camera's quaternion.
+     */
+    private updateLightPosition;
+    /**
+     * Disposes of the camera light.
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,44 @@
+/**
+ * @module viw-webgl-viewer
+ */
+import * as THREE from 'three';
+import { ViewerSettings } from '../settings/viewerSettings';
+import { ICamera } from '../camera/camera';
+import { ViewerMaterials } from '../../vim-loader/materials/viewerMaterials';
+import { GroundPlane } from './groundPlane';
+import { Skybox } from './skybox';
+import { Renderer } from '../rendering/renderer';
+import { CameraLight } from './cameraLight';
+/**
+ * Manages ground plane and lights that are part of the THREE.Scene to render but not part of the Vims.
+ */
+export declare class Environment {
+    private readonly _renderer;
+    private readonly _camera;
+    /**
+     * The skylight in the scene.
+     */
+    readonly skyLight: THREE.HemisphereLight;
+    /**
+     * The array of directional lights in the scene.
+     */
+    readonly sunLights: ReadonlyArray<CameraLight>;
+    /**
+     * The ground plane under the model in the scene.
+     */
+    readonly groundPlane: GroundPlane;
+    readonly skybox: Skybox;
+    constructor(camera: ICamera, renderer: Renderer, viewerMaterials: ViewerMaterials, settings: ViewerSettings);
+    /**
+     * Returns all three objects composing the environment
+     */
+    private getObjects;
+    private createSkyLight;
+    private createSunLights;
+    private addObjectsToRenderer;
+    private setupRendererListeners;
+    /**
+     * Dispose of all resources.
+     */
+    dispose(): void;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/environment/groundPlane.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @module viw-webgl-viewer
+ */
+import * as THREE from 'three';
+import { TextureEncoding, ViewerSettings } from '../settings/viewerSettings';
+/**
+ * Manages the THREE.Mesh for the ground plane under the vims
+ */
+export declare class GroundPlane {
+    readonly mesh: THREE.Mesh;
+    private _source;
+    private _size;
+    /**
+     * Whether the ground plane is visible or not.
+     */
+    get visible(): boolean;
+    set visible(value: boolean);
+    private _geometry;
+    private _material;
+    private _texture;
+    constructor(settings: ViewerSettings);
+    adaptToContent(box: THREE.Box3): void;
+    applyTexture(encoding: TextureEncoding, source: string): void;
+    dispose(): void;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/environment/skybox.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @module viw-webgl-viewer
+ */
+import * as THREE from 'three';
+import { ViewerSettings } from '../settings/viewerSettings';
+import { ICamera } from '../camera/camera';
+import { ViewerMaterials } from '../../vim-loader/materials/viewerMaterials';
+import { Renderer } from '../rendering/renderer';
+export declare class Skybox {
+    readonly mesh: THREE.Mesh;
+    /**
+     * Whether the skybox is enabled or not.
+     */
+    get enable(): boolean;
+    /**
+     * Whether the skybox is enabled or not.
+     */
+    set enable(value: boolean);
+    /**
+     * The color of the sky.
+     */
+    get skyColor(): THREE.Color;
+    set skyColor(value: THREE.Color);
+    /**
+     * The color of the ground.
+     */
+    get groundColor(): THREE.Color;
+    set groundColor(value: THREE.Color);
+    /**
+     * The sharpness of the gradient transition between the sky and the ground.
+     */
+    get sharpness(): number;
+    set sharpness(value: number);
+    private readonly _plane;
+    private readonly _material;
+    private readonly _renderer;
+    constructor(camera: ICamera, renderer: Renderer, materials: ViewerMaterials, settings: ViewerSettings);
+    dispose(): void;
+}

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

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+import { AxesSettings } from './axesSettings';
+export declare class Axis {
+    axis: string;
+    direction: THREE.Vector3;
+    size: number;
+    color: string;
+    colorSub: string;
+    position: THREE.Vector3;
+    label: string | undefined;
+    line: number | undefined;
+    constructor(init: Axis);
+}
+export declare function createAxes(settings: AxesSettings): Axis[];

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

@@ -0,0 +1,19 @@
+export declare class AxesSettings {
+    size: number;
+    padding: number;
+    bubbleSizePrimary: number;
+    bubbleSizeSecondary: number;
+    lineWidth: number;
+    fontPxSize: number;
+    fontFamily: string;
+    fontWeight: string;
+    fontColor: string;
+    className: string;
+    colorX: string;
+    colorY: string;
+    colorZ: string;
+    colorXSub: string;
+    colorYSub: string;
+    colorZSub: string;
+    constructor(init?: Partial<AxesSettings>);
+}

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

@@ -0,0 +1,60 @@
+/**
+ * @module viw-webgl-viewer/gizmos
+ */
+import { Camera } from '../../camera/camera';
+import { Viewport } from '../../viewport';
+import { AxesSettings } from './axesSettings';
+/**
+ * The axis gizmos of the viewer.
+ */
+export declare class GizmoAxes {
+    private _initialOptions;
+    private _options;
+    private _camera;
+    private _canvas;
+    private _context;
+    private _rect;
+    private _reparentConnection;
+    private _axes;
+    private _pointerInside;
+    private _isDragging;
+    private _isDragSignificant;
+    private _dragStart;
+    private _dragLast;
+    private _pointer;
+    private _center;
+    private _invRotMat;
+    private _selectedAxis;
+    /**
+     * The canvas on which the axes are drawn.
+     */
+    get canvas(): HTMLCanvasElement;
+    constructor(camera: Camera, viewport: Viewport, options?: Partial<AxesSettings>);
+    reparent(parent: HTMLElement): void;
+    resize(size: number): void;
+    private createCanvas;
+    private onTouchMove;
+    private onTouchEnd;
+    private onPointerDown;
+    private onPointerUp;
+    private onPointerEnter;
+    private onPointerLeave;
+    private onPointerMove;
+    private toMouseVector;
+    private onPointerDrag;
+    private initDrag;
+    private updateDrag;
+    private endDrag;
+    private onMouseClick;
+    update: () => void;
+    private drawLayers;
+    private drawCircle;
+    private drawLine;
+    private setAxisPosition;
+    private pickAxes;
+    /**
+     * Disposes of the gizmo, removing event listeners and cleaning up resources.
+     */
+    dispose(): void;
+}
+export { GizmoAxes as OrbitControlsGizmo };

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

@@ -0,0 +1,23 @@
+/**
+ @module viw-webgl-viewer/gizmos/sectionBox
+*/
+import { Viewer } from '../viewer';
+/**
+ * The loading indicator gizmo.
+ */
+export declare class GizmoLoading {
+    private _viewer;
+    private _spinner;
+    private _visible;
+    constructor(viewer: Viewer);
+    private createBar;
+    /**
+     * Indicates whether the loading gizmo will be rendered.
+     */
+    get visible(): boolean;
+    set visible(value: boolean);
+    /**
+     * Disposes of all resources.
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,71 @@
+/**
+ * @module viw-webgl-viewer/gizmos
+ */
+import * as THREE from 'three';
+import { Renderer } from '../rendering/renderer';
+import { Camera } from '../camera/camera';
+import { ViewerSettings } from '../settings/viewerSettings';
+import { Input } from '../inputs/input';
+/**
+ * Manages the camera target gizmo
+ */
+export declare class GizmoOrbit {
+    private _renderer;
+    private _camera;
+    private _inputs;
+    private _size;
+    private _color;
+    private _opacity;
+    private _opacityAlways;
+    private _showDurationMs;
+    private _box;
+    private _wireframe;
+    private _material;
+    private _materialAlways;
+    private _gizmos;
+    private _disconnectCamera;
+    private _timeout;
+    private _active;
+    private _animation;
+    constructor(renderer: Renderer, camera: Camera, input: Input, settings: ViewerSettings);
+    private connect;
+    private onUpdate;
+    /**
+     * Determines whether the orbit gizmo is enabled.
+     */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /**
+     * Show or hide the gizmo for a brief delay if the gizmo is active.
+     * @param {boolean} [show=true] - Whether to show or hide the gizmo.
+     */
+    show(show?: boolean): void;
+    /**
+     * Updates the position of the orbit gizmo.
+     * @param {THREE.Vector3} position - The new position of the orbit gizmo.
+     */
+    setPosition(position: THREE.Vector3): void;
+    /**
+     * Updates the size of the orbit gizmo.
+     * @param {number} size - The new size of the orbit gizmo.
+     */
+    setSize(size: number): void;
+    /**
+     * Updates the opacity of the orbit gizmo.
+     * @param {number} opacity - The opacity of the non-occluded part.
+     * @param {number} opacityAlways - The opacity of the occluded part.
+     */
+    setOpacity(opacity: number, opacityAlways: number): void;
+    /**
+     * Updates the color of the orbit gizmo.
+     * @param {THREE.Color} color - The new color for the orbit gizmo.
+     */
+    setColor(color: THREE.Color): void;
+    private applySettings;
+    private updateScale;
+    private createGizmo;
+    /**
+     * Disposes of all resources.
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,51 @@
+/**
+ * @module viw-webgl-viewer/gizmos
+ */
+import * as THREE from 'three';
+import { Viewer } from '../viewer';
+/**
+ * Rectangle Gizmo used for rectangle selection.
+ */
+export declare class GizmoRectangle {
+    private line;
+    private viewer;
+    private points;
+    constructor(viewer: Viewer);
+    /**
+     * Removes the object from rendering and dispose resources from memory
+     */
+    dispose(): void;
+    /**
+     * Indicates whether the gizmo is visible.
+     */
+    get visible(): boolean;
+    set visible(value: boolean);
+    /**
+     * Sets the two corner points defining the rectangle.
+     * @param {THREE.Vector2} posA - The position of the first corner.
+     * @param {THREE.Vector2} posB - The position of the second corner.
+     */
+    setCorners(posA: THREE.Vector2, posB: THREE.Vector2): void;
+    private getIntersection;
+    private updateRect;
+    private getBoxSize;
+    /**
+     * Returns the bounding box of the selection.
+     * The bounding box is the projection of the selection rectangle
+     * onto the plane coplanar to the closest hit of 5 raycasts: one in each corner and one in the center.
+     * X-----X
+     * |  X  |
+     * X-----X
+     * @returns {THREE.Box3} The bounding box of the selection.
+     */
+    getBoundingBox(target?: THREE.Box3): THREE.Box3;
+    /**
+     * Performs a raycast from the camera through the five interest points and returns the closest hit position.
+     * @returns {THREE.Vector3} The position of the closest hit.
+     */
+    getClosestHit(): THREE.Vector3;
+    /**
+     * Projects all points on a plane the coplanar to position.
+     */
+    private projectPoints;
+}

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

@@ -0,0 +1,50 @@
+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';
+import { Camera } from '../camera/camera';
+/**
+ * Represents a collection of gizmos used for various visualization and interaction purposes within the viewer.
+ */
+export declare class Gizmos {
+    private readonly viewer;
+    /**
+     * The interface to start and manage measure tool interaction.
+     */
+    get measure(): IMeasure;
+    private readonly _measure;
+    /**
+     * The section box gizmo.
+     */
+    readonly section: SectionBox;
+    /**
+     * The loading indicator gizmo.
+     */
+    readonly loading: GizmoLoading;
+    /**
+     * The camera orbit target gizmo.
+     */
+    readonly orbit: GizmoOrbit;
+    /**
+     * Rectangle Gizmo used for rectangle selection.
+     */
+    readonly rectangle: GizmoRectangle;
+    /**
+     * The axis gizmos of the viewer.
+     */
+    readonly axes: GizmoAxes;
+    /**
+     * The interface for adding and managing sprite markers in the scene.
+     */
+    readonly markers: GizmoMarkers;
+    constructor(viewer: Viewer, camera: Camera);
+    updateAfterCamera(): void;
+    /**
+     * Disposes of all gizmos.
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,64 @@
+import { Vim } from '../../../vim-loader/vim';
+import { Viewer } from '../../viewer';
+import * as THREE from 'three';
+import { SimpleInstanceSubmesh } from '../../../vim-loader/mesh';
+/**
+ * Marker gizmo that display an interactive sphere at a 3D positions
+ * Marker gizmos are still under development.
+ */
+export declare class GizmoMarker {
+    readonly type = "Marker";
+    private _viewer;
+    private _submesh;
+    /**
+     * The vim object from which this object came from.
+     */
+    vim: Vim | undefined;
+    /**
+     * The bim element index associated with this object.
+     */
+    element: number | undefined;
+    /**
+     * The geometry instances  associated with this object.
+     */
+    instances: number[] | undefined;
+    private _outlineAttribute;
+    private _visibleAttribute;
+    private _coloredAttribute;
+    private _focusedAttribute;
+    private _colorAttribute;
+    constructor(viewer: Viewer, submesh: SimpleInstanceSubmesh);
+    updateMesh(mesh: SimpleInstanceSubmesh): void;
+    /** Sets the position of the marker in the 3d scene */
+    set position(value: THREE.Vector3);
+    get position(): THREE.Vector3;
+    /**
+     * Always false
+     */
+    get hasMesh(): boolean;
+    /**
+     * Applies a color override instead of outlines.
+     */
+    get outline(): boolean;
+    set outline(value: boolean);
+    /**
+     * Enlarges the gizmo to indicate focus.
+     */
+    get focused(): boolean;
+    set focused(value: boolean);
+    /**
+     * Determines if the gizmo will be rendered.
+     */
+    get visible(): boolean;
+    set visible(value: boolean);
+    get color(): THREE.Color;
+    set color(color: THREE.Color);
+    get size(): number;
+    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.
+     */
+    getBoundingBox(): THREE.Box3;
+}

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

@@ -0,0 +1,29 @@
+import { Viewer } from '../../viewer';
+import * as THREE from 'three';
+import { GizmoMarker } from './gizmoMarker';
+/**
+ * API for adding and managing sprite markers in the scene.
+ */
+export declare class GizmoMarkers {
+    private _viewer;
+    private _markers;
+    private _mesh;
+    constructor(viewer: Viewer);
+    getMarkerFromIndex(index: number): GizmoMarker;
+    private createMesh;
+    private resizeMesh;
+    /**
+     * Adds a sprite marker at the specified position.
+     * @param {THREE.Vector3} position - The position at which to add the marker.
+     */
+    add(position: THREE.Vector3): GizmoMarker;
+    /**
+     * Removes the specified marker from the scene.
+     * @param {GizmoMarker} marker - The marker to remove.
+     */
+    remove(marker: GizmoMarker): void;
+    /**
+     * Removes all markers from the scene.
+     */
+    clear(): void;
+}