vim-web 0.3.23 → 0.3.25

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

@@ -0,0 +1,342 @@
+/**
+ @module viw-webgl-viewer
+*/
+import * as THREE from 'three';
+import { AxesSettings } from '../gizmos/axes/axesSettings';
+export type TextureEncoding = 'url' | 'base64' | undefined;
+export { AxesSettings } from '../gizmos/axes/axesSettings';
+/**
+ * Makes all field optional recursively
+ * https://stackoverflow.com/questions/41980195/recursive-partialt-in-typescript
+ */
+export type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P];
+};
+/** Viewer related options independant from vims */
+export type ViewerSettings = {
+    /**
+     * Webgl canvas related options
+     */
+    canvas: {
+        /**
+         * Canvas dom model id. If none provided a new canvas will be created
+         * Default: undefined.
+         */
+        id: string | undefined;
+        /**
+         * Limits how often canvas will be resized if window is resized in ms.
+         * Default: 200
+         */
+        resizeDelay: number;
+    };
+    /**
+     * Three.js camera related options
+     */
+    camera: {
+        /**
+         * Start with orthographic camera
+         * Default: false
+         */
+        orthographic: boolean;
+        /**
+         * Vector3 of 0 or 1 to enable/disable movement along each axis
+         * Default: THREE.Vector3(1, 1, 1)
+         */
+        allowedMovement: THREE.Vector3;
+        /**
+         * Vector2 of 0 or 1 to enable/disable rotation around x or y.
+         * Default: THREE.Vector2(1, 1)
+         */
+        allowedRotation: THREE.Vector2;
+        /**
+         * Near clipping plane distance
+         * Default: 0.01
+         */
+        near: number;
+        /**
+         * Far clipping plane distance
+         * Default: 15000
+         */
+        far: number;
+        /**
+         * Fov angle in degrees
+         * Default: 50
+         */
+        fov: number;
+        /**
+         * Camera zoom level
+         * Default: 1
+         */
+        zoom: number;
+        /**
+         * Initial forward vector of the camera
+         * THREE.Vector3(1, -1, 1)
+         */
+        forward: THREE.Vector3;
+        /** Camera controls related options */
+        controls: {
+            /**
+             * <p>Set true to start in orbit mode.</p>
+             * <p>Camera has two modes: First person and orbit</p>
+             * <p>First person allows to moves the camera around freely</p>
+             * <p>Orbit rotates the camera around a focus point</p>
+             * Default: true
+             */
+            orbit: boolean;
+            /**
+             * Camera rotation speed factor
+             * Default: 1
+             */
+            rotateSpeed: number;
+            /**
+             * Camera orbit rotation speed factor.
+             * Default: 1
+             */
+            orbitSpeed: number;
+            /**
+             * Camera movement speed factor
+             * Default: 1
+             */
+            moveSpeed: number;
+            /**
+             * Camera movement speed factor on mouse scroll
+             * Default: 1
+             * Range: [0.1, 10]
+             */
+            scrollSpeed: number;
+        };
+        /** Camera gizmo related options */
+        gizmo: {
+            /**
+            * Enables/Disables camera gizmo.
+            * Default: true
+            */
+            enable: boolean;
+            /**
+            * Size of camera gizmo.
+            * Default: 0.01
+            */
+            size: number;
+            /**
+            * Color of camera gizmo.
+            * Default: THREE.Color(255, 255, 255)
+            */
+            color: THREE.Color;
+            /**
+            * Opacity of the camera gizmo.
+            * Default: 0.5
+            */
+            opacity: number;
+            /**
+            * Opacity of the camera gizmo when behind objects.
+            * Default: 0.125
+            */
+            opacityAlways: number;
+        };
+    };
+    /**
+     * Rendering background options
+     */
+    background: {
+        /**
+         * Color of the cavas background
+         * Default: THREE.Color('#96999f')
+         */
+        color: THREE.Color;
+    };
+    /**
+     * Skybox options
+     */
+    skybox: {
+        /**
+         * Enables/Disables skybox.
+         */
+        enable: boolean;
+        /**
+         * Color for the lower part of the skybox.
+         */
+        groundColor: THREE.Color;
+        /**
+         * Color for the upper part of the skybox.
+         */
+        skyColor: THREE.Color;
+        /**
+         * Controls the gradient transition between the sky and the ground.
+         */
+        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
+    */
+    materials: {
+        /**
+        * Default color of standard material
+        */
+        standard: {
+            color: THREE.Color;
+        };
+        /**
+        * Highlight on hover options
+        */
+        highlight: {
+            /**
+            * Highlight color
+            * Default: rgb(106, 210, 255)
+            */
+            color: THREE.Color;
+            /**
+            * Highlight opacity
+            * Default: 0.5
+            */
+            opacity: number;
+        };
+        /**
+        * Isolation material options
+        */
+        isolation: {
+            /**
+            * Isolation material color
+            * Default: rgb(78, 82, 92)
+            */
+            color: THREE.Color;
+            /**
+            * Isolation material opacity
+            * Default: 0.08
+            */
+            opacity: number;
+        };
+        /**
+        * Section box intersection highlight options
+        */
+        section: {
+            /**
+            * Intersection highlight stroke width.
+            * Default: 0.01
+            */
+            strokeWidth: number;
+            /**
+            * Intersection highlight stroke falloff.
+            * Default: 0.75
+            */
+            strokeFalloff: number;
+            /**
+            * Intersection highlight stroke color.
+            * Default: rgb(246, 246, 246)
+            */
+            strokeColor: THREE.Color;
+        };
+        /**
+        * Selection outline options
+        */
+        outline: {
+            /**
+            * Selection outline intensity.
+            * Default: 3
+            */
+            intensity: number;
+            /**
+            * Selection outline falloff.
+            * Default: 3
+            */
+            falloff: number;
+            /**
+            * Selection outline blur.
+            * Default: 2
+            */
+            blur: number;
+            /**
+            * Selection outline color.
+            * Default: rgb(0, 255, 255)
+            */
+            color: THREE.Color;
+        };
+    };
+    /**
+     * Axes gizmo options
+     */
+    axes: Partial<AxesSettings>;
+    /**
+     * Skylight (hemisphere light) options
+     */
+    skylight: {
+        /**
+        * Skylight sky Color.
+        * Default: THREE.Color(153, 204, 255)
+        */
+        skyColor: THREE.Color;
+        /**
+        * Skylight ground color.
+        * Default: THREE.Color(242, 213, 181)
+        */
+        groundColor: THREE.Color;
+        /**
+        * Skylight intensity.
+        * Default: 0.8
+        */
+        intensity: number;
+    };
+    /**
+     * Sunlight (directional light) options
+     * Two Blue-Green lights at odd angles. See defaultViewerSettings.
+     */
+    sunlights: {
+        followCamera: boolean;
+        /** Light position. */
+        position: THREE.Vector3;
+        /** Light color. */
+        color: THREE.Color;
+        /** Light intensity. */
+        intensity: number;
+    }[];
+    rendering: {
+        /**
+         * Enable on-demand rendering which wait for changes before rendering to the canvas.
+         * Default: true
+         */
+        onDemand: boolean;
+    };
+};
+/**
+ * Same as the Setting type but any field can be undefined.
+ */
+export type PartialViewerSettings = RecursivePartial<ViewerSettings>;
+/**
+ * Returns a full viewer settings where all unassigned values are replaced with the default values.
+ * @param settings optional values to use instead of default.
+ */
+export declare function getViewerSettings(settings?: PartialViewerSettings): ViewerSettings;

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

@@ -0,0 +1,9 @@
+import { PartialViewerSettings } from './viewerSettings';
+/**
+ * Parses the url for settings and merges the result with the optional provided settings.
+ * URL settings have priority
+ * @param settings Settings to use if not defined in the url.
+ * @param url URL string with standard parameters.
+ * @returns A PartialSettings object that can further be merged with default values.
+ */
+export declare function getViewerSettingsFromUrl(url?: string, settings?: PartialViewerSettings): PartialViewerSettings;

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

@@ -0,0 +1,100 @@
+/**
+ @module viw-webgl-viewer
+*/
+import { ViewerSettings, PartialViewerSettings } from './settings/viewerSettings';
+import { ICamera } from './camera/camera';
+import { Input } from './inputs/input';
+import { Selection } from './selection';
+import { Environment } from './environment/environment';
+import { Raycaster } from './raycaster';
+import { Viewport } from './viewport';
+import { Gizmos } from './gizmos/gizmos';
+import { Renderer } from './rendering/renderer';
+import { ISignal } from 'ste-signals';
+import { ViewerMaterials } from '../vim-loader/materials/viewerMaterials';
+import { Vim } from '../vim-loader/vim';
+/**
+ * Viewer and loader for vim files.
+ */
+export declare class Viewer {
+    /**
+     * The settings configuration used by the viewer.
+     */
+    readonly settings: ViewerSettings;
+    /**
+     * The renderer used by the viewer for rendering scenes.
+     */
+    readonly renderer: Renderer;
+    /**
+     * The interface for managing the HTML canvas viewport.
+     */
+    readonly viewport: Viewport;
+    /**
+     * The interface for managing viewer selection.
+     */
+    readonly selection: Selection;
+    /**
+     * The interface for manipulating default viewer inputs.
+     */
+    readonly inputs: Input;
+    /**
+     * The interface for performing raycasting into the scene to find objects.
+     */
+    readonly raycaster: Raycaster;
+    /**
+     * The materials used by the viewer to render the vims.
+     */
+    readonly materials: ViewerMaterials;
+    /**
+     * The environment of the viewer, including the ground plane and lights.
+     */
+    readonly environment: Environment;
+    /**
+     * The interface for manipulating the viewer's camera.
+     */
+    get camera(): ICamera;
+    /**
+     * The collection of gizmos available for visualization and interaction within the viewer.
+     */
+    gizmos: Gizmos;
+    /**
+     * A signal that is dispatched when a new Vim object is loaded or unloaded.
+     */
+    get onVimLoaded(): ISignal;
+    private _camera;
+    private _clock;
+    private _vims;
+    private _onVimLoaded;
+    private _updateId;
+    constructor(settings?: PartialViewerSettings);
+    private animate;
+    /**
+     * Retrieves an array containing all currently loaded Vim objects.
+     * @returns {Vim[]} An array of all Vim objects currently loaded in the viewer.
+     */
+    get vims(): Vim[];
+    /**
+     * The number of Vim objects currently loaded in the viewer.
+     */
+    get vimCount(): number;
+    /**
+     * Adds a Vim object to the renderer, triggering the appropriate actions and dispatching events upon successful addition.
+     * @param {Vim} vim - The Vim object to add to the renderer.
+     * @throws {Error} If the Vim object is already added or if loading the Vim would exceed maximum geometry memory.
+     */
+    add(vim: Vim): void;
+    /**
+     * Unloads the given Vim object from the viewer, updating the scene and triggering necessary actions.
+     * @param {Vim} vim - The Vim object to remove from the viewer.
+     * @throws {Error} If attempting to remove a Vim object that is not present in the viewer.
+     */
+    remove(vim: Vim): void;
+    /**
+     * Removes all Vim objects from the viewer, clearing the scene.
+     */
+    clear(): void;
+    /**
+     * Cleans up and releases resources associated with the viewer.
+     */
+    dispose(): void;
+}

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

@@ -0,0 +1,73 @@
+/**
+ @module viw-webgl-viewer
+*/
+import * as THREE from 'three';
+import { CSS2DRenderer } from 'three/examples/jsm/renderers/CSS2DRenderer';
+import { ViewerSettings } from './settings/viewerSettings';
+export declare class Viewport {
+    /**
+     *  HTML Canvas on which the model is rendered
+     */
+    readonly canvas: HTMLCanvasElement;
+    /** HTML Element in which text is rendered */
+    readonly textRenderer: CSS2DRenderer;
+    get text(): HTMLElement;
+    private _unregisterResize;
+    private _ownedCanvas;
+    private _onResize;
+    private _onReparent;
+    /**
+     * Signal dispatched when the canvas reparented.
+     */
+    get onReparent(): import("ste-signals").ISignal;
+    /**
+     * Signal dispatched when the canvas is resized.
+     */
+    get onResize(): import("ste-signals").ISignal;
+    /**
+     * Constructs a new instance of the class with the provided settings.
+     * @param {ViewerSettings} settings The settings object defining viewer configurations.
+     */
+    constructor(settings: ViewerSettings);
+    /**
+     * Either returns html canvas at provided Id or creates a canvas at root level
+     */
+    private static getOrCreateCanvas;
+    private static createCanvas;
+    /** Returns a text renderer that will render html in an html element sibbling to canvas */
+    private createTextRenderer;
+    get parent(): HTMLElement;
+    reparent(parent: HTMLElement): void;
+    /**
+     * Removes the canvas if it's owned by the viewer.
+     */
+    dispose(): void;
+    /**
+     * Returns the pixel size of the parent element.
+     * @returns {THREE.Vector2} The pixel size of the parent element.
+     */
+    getParentSize(): THREE.Vector2;
+    private getParentWidth;
+    private getParentHeight;
+    /**
+     * Returns the pixel size of the canvas.
+     * @returns {THREE.Vector2} The pixel size of the canvas.
+     */
+    getSize(): THREE.Vector2;
+    /**
+     * Calculates and returns the aspect ratio of the parent element.
+     * @returns {number} The aspect ratio (width divided by height) of the parent element.
+     */
+    getAspectRatio(): number;
+    /**
+     * Resizes the canvas and updates the camera to match new parent dimensions.
+     */
+    ResizeToParent(): void;
+    /**
+     * Set a callback for canvas resize with debouncing
+     * https://stackoverflow.com/questions/5825447/javascript-event-for-canvas-resize/30688151
+     * @param callback code to be called
+     * @param timeout time after the last resize before code will be called
+     */
+    private watchResize;
+}