@x-viewer/core 0.9.0

package/dist/types/core/viewers/Viewer2d.d.ts

@@ -0,0 +1,413 @@
+import * as THREE from "three";
+import { BaseViewer } from "./BaseViewer";
+import { ViewerName } from "./Constants";
+import { Model2dConfig, Viewer2dConfig } from "../../core/Configs";
+import { DxfData, DxfLayer } from "../../core/dxf";
+import { EventInfo } from "../../core/input-manager/InputManager";
+import { Model2d } from "../../core/model";
+export interface EntityData {
+    modelId: string;
+    layerName: string;
+}
+/**
+ * A group of dxf/dwg layers for a drawing.
+ */
+export interface DxfLayers {
+    modelId: string;
+    layers: Record<string, DxfLayer>;
+}
+export interface PdfLayers {
+    modelId: string;
+    layers: Record<string, PdfLayer>;
+}
+export interface PdfLayer {
+    name: string;
+    id: string;
+    index: string;
+    visible: boolean;
+}
+export interface PdfData {
+    threejsObject: THREE.Object3D;
+    layers: Record<string, PdfLayer>;
+    layersAndThreejsObjects?: Record<string, THREE.Object3D[]>;
+    loadedEntityCount: number;
+}
+/**
+ * @internal
+ */
+export declare const GroundPlaneRenderOrder = -1000;
+/**
+ * Threejs objects are organized in tree view as below:
+ *
+ * - modelLevelObject1              (THREE.Group, name = <modelId>)
+ *     - layoutLevelObject1         (THREE.Group, name = <layout name>, used to control layout visibility)
+ *         - entityLevelObject1     (THREE.Point/Line/Mesh/Group)
+ *
+ * - Layer threejs objects
+ * {
+ *    layerName:[threejsObject1,threejsObject2,threejsObject3,...] (THREE.Point/Line/Mesh)
+ * }
+ */
+/**
+ * "dwg" is short for "drawing", it is a file format saved by AutoCAD.
+ * And "dxf" is data exchange format, which can be converted from a dwg file.
+ * We cannot read dwg directly, and need to convert it to dxf first via ODA.
+ *
+ * Supported dxf version: AutoCAD 2018. Both binary and ascii are supported.
+ *
+ * Json Encoding: UTF-8 encoding without BOM
+ *
+ * Coordinate system: right-handed, y-up
+ *
+ * About units:
+ * - The unit of distance follows the master dxf file's unit
+ * - The unit of area follows the master dxf file's unit
+ * - The unit of angle is "degree", counterclockwise
+ * - The unit of time is "second"
+ *
+ * Color: use rgb/rgba, values between 0-1
+ *
+ * About Measurement in Viewer2d:
+ * - A measurement is generated by Viewer2d.
+ * - Measurements data should be stored by users, so users can restore measurements data into Viewer2d later.
+ * - Viewer2d manages measurements data, it can be created, removed, hidden, etc.
+ * - Viewer2d doesn't maintain the relationship between measurement and layout.
+ *
+ * About Markup in Viewer2d:
+ * Markup is pretty similar to measurement.
+ *
+ * About Hotpoint in Viewer2d:
+ * - A hotpoint is created and stored by user.
+ * - A hotpoint can be added to, and removed from Viewer2d.
+ * - Caller should set a hotpointId that is unique in the session of current Viewer2d.
+ * - Viewer2d doesn't hide a hotpoint, user is able to do it.
+ * - Viewer2d doesn't maintain the relationship between hotpoint and layout.
+ *
+ * About layouts
+ * - Each layout has its own home view.
+ * - When switching to another layout, it clears all measurements, markups and hotpoints.
+ * - When switching to another layout, it deactivates any in-progress operation like measurement, markup, etc.
+ *
+ * About overlay
+ * - It supports to add as many models as user want, as long as the browser has sufficient memory, cpu/gpu, etc.
+ * - The first model is called "master" model, others are called "overlay" models.
+ * - It ignores an overlay model's paper space.
+ * - An overlay model's unit should be converted to master model's unit if they are not the same.
+ * - We'll append modelId as prefix for getLayers()
+ *
+ * About comparision
+ * - It compares just "Model" spaces.
+ * - It compares entities with the same handles and types.
+ * - It compares entities' geometries, positions, scales, etc.
+ * - It ignores a layer's visibility, freeze settings.
+ * - It ignores an entity's properties, like linetype, line width, fill pattern, font, color, etc.
+ * - It ignores spatial filters (xclip) of block references.
+ * - It ignores layer relative operations, like moving an entity to another layer, changing a layer color, etc.
+ * - By default, an "Added" entity is rendered in green, a "Removed" entity is in red, a "Modified" entity is composed by two parts, one "Removed" and another "Added".
+ *
+ * About undo/redo
+ * - It supports undo/redo for measurement and markup operations. E.g., creating/deleting/moving a markup.
+ * - Setting/removing a batch of measurements or markups will be taken as one operation.
+ * - Switching to another layout clears all undo/redo history.
+ *
+ * About OSnap
+ * - It supports snapping to the end points and middle point of a line.
+ * - It supports snapping to the intersection point of two lines.
+ * - It supports snapping to the foot of perpendicular against a line.
+ * - It supports snapping to any point along a line.
+ *
+ * @example
+ * ``` typescript
+ * const viewerCfg = {
+ *     containerId: "myCanvas",
+ *     enableSpinner: true,
+ *     enableLayoutBar: true,
+ * };
+ * const modelCfg = {
+ *     modelId: "id_0",
+ *     name: "sample",
+ *     src: "http://www.abc.com/sample.dxf",
+ * }
+ * const fontFiles = ["http://www.abc.com/hztxt.shx", "http://www.abc.com/simplex.shx"];
+ *
+ * const viewer = new Viewer2d(viewerCfg);
+ * await viewer.setFont(fontFiles);
+ * await viewer.loadModel(modelCfg);
+ * ```
+ */
+export declare class Viewer2d extends BaseViewer {
+    name: ViewerName;
+    loadedModels: Model2d[];
+    /**
+     * @internal
+     */
+    masterModelId: string;
+    private activeLayoutName;
+    private dxfLayoutBar?;
+    private layoutInfos;
+    private units;
+    private enableHideVisuallySmallObjects;
+    private sortedHidableObjects;
+    private lastCameraZoom;
+    groundPlane?: THREE.Mesh;
+    raycastableObjects?: THREE.Object3D[];
+    constructor(viewerCfg: Viewer2dConfig);
+    get camera(): THREE.OrthographicCamera;
+    private setDefaultBackground;
+    /**
+     * Used to indicate how many dxf is loading
+     */
+    private loadingDxfCount;
+    /**
+     * @description {en} Loads a dxf file.
+     * The first loaded file will be taken as a "master" model.
+     * Any other files are non-master, we call "overlay" model.
+     * We'll load everything of a master model, including model and paper space.
+     * For an overlay model, we'll only load its model space. And its model space can only
+     * overly to master model's model space.
+     * @description {zh} 加载 dxf 文件。
+     * 第一个加载的文件将被视为“主”模型。
+     * 任何其他文件都是非主文件，我们称之为“叠加”模型。
+     * 我们将加载主模型的所有内容，包括模型和图纸空间。
+     * 对于叠加模型，我们只会加载其模型空间。并且它的模型空间只能叠加到主模型的模型空间上。
+     * @param modelCfg
+     * - {en} The configuration of the model to be loaded.
+     * - {zh} 要加载的模型的配置。
+     * @param onProgress
+     * - {en} A callback function to indicate the loading progress.
+     * - {zh} 用于指示加载进度的回调函数。
+     * @example
+     * ``` typescript
+     * const viewerCfg = {
+     *     containerId: "myCanvas",
+     * };
+     * const modelCfg = {
+     *     modelId: "id_0",
+     *     name: "dxf 0",
+     *     src: "http://www.abc.com/sample.dxf",
+     * }
+     * const viewer = new Viewer2d(viewerCfg);
+     * await viewer.loadModel(modelCfg, (event) => {
+     *     const progress = (event.loaded * 100) / event.total;
+     *     console.log(`Loading progress: ${progress}%`);
+     * });
+     * console.log("Loaded");
+     * ```
+     */
+    loadModel(modelCfg: Model2dConfig, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<void>;
+    /**
+     * Parses a dwg or dxf and return json object.
+     * @param modelCfg
+     * @param onProgress
+     */
+    parseFile(modelCfg: Model2dConfig, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<DxfData>;
+    addModel(model: Model2d): void;
+    private getDxfUnits;
+    private handleOverlayDxf;
+    setObjectHighlight(object: THREE.Object3D): void;
+    setObjectUnHighlight(object: THREE.Object3D): void;
+    clearHighlight(): void;
+    clearSelection(): void;
+    /**
+     * Gets if selection is enabled.
+     */
+    get enableSelection(): boolean;
+    /**
+     * Sets if selection is enabled.
+     */
+    set enableSelection(enable: boolean);
+    /**
+     * Creates a ground plane which is much bigger than bbox.
+     */
+    private updateGroundPlane;
+    getRaycastableObjects(): THREE.Object3D[];
+    /**
+     * Gets the corresponding viewport by judging that the point is in the viewport
+     */
+    private getViewportByPoint;
+    /**
+     * Gets the world position by the mouse's position.
+     */
+    getWorldPositionByMousePick(mousePosition: THREE.Vector2): THREE.Vector3 | undefined;
+    /**
+     * @description {en} Activates a layout.
+     * @description {zh} 激活布局。
+     * @param layoutName
+     * - {en} The name of the layout to be activated.
+     * - {zh} 要激活的布局名称。
+     * @example
+     * ```typescript
+     * viewer.activateLayout('Layout1');
+     * ```
+     */
+    activateLayout(layoutName?: string): void;
+    private getLayoutExtentEx;
+    private getActiveLayoutInfo;
+    private getLayoutByName;
+    /**
+     * Gets loaded entity count
+     * @internal
+     * @returns {number}
+     */
+    getEntityCount(): number;
+    /**
+     * @description Gets layout names of the master model.
+     * @returns Layout names of the master model.
+     * @example
+     * ```typescript
+     * const layoutNames = viewer.getLayoutNames();
+     * console.log(layoutNames); // ['Model', 'Layout1', 'Layout2']
+     * ```
+     */
+    getLayoutNames(): string[];
+    /**
+     * Gets LayoutInfo by layoutName. It creats LayoutInfo if doesn't exist.
+     */
+    private getLayoutInfo;
+    goToHomeView(): void;
+    zoomToBBox(bbox: THREE.Box3): void;
+    /**
+     * @description {en} Gets current view extent.
+     * This is useful for user to save this value as a viewpoint, and jump to this viewpoint next time.
+     * @description {zh} 获取当前视图范围。
+     * 用户可使用该接口获取当前视口范围，并在适当的场景下跳转到该视口范围。
+     * @example
+     * ``` typescript
+     * const box = viewer.getCurrentViewExtent();
+     * console.log("Current view extent:", box);
+     * ```
+     */
+    getCurrentViewExtent(): THREE.Box2;
+    /**
+     * Gets hit result by Normalized Device Coordinates.
+     * Lower left coordinate: (-1, -1)
+     * Upper right coordinate: (1, 1)
+     */
+    protected getHitResultByNdcCoordinate(coord: THREE.Vector2): THREE.Vector2 | undefined;
+    /**
+     * Gets mouse hit result in world coordinate
+     * @example
+     * ``` typescript
+     * document.addEventListener("click", (event) => {
+     *     const result = viewer.getHitResult(event);
+     *     const loc = result?.location;
+     *     if (loc) {
+     *         console.log(`Clicked at x: ${loc[0]}, y: ${loc[1]}`);
+     *     }
+     * });
+     * ```
+     * @internal
+     */
+    getHitResult(event: MouseEvent | PointerEvent | EventInfo): THREE.Vector2 | undefined;
+    /**
+     * @description {en} Gets active layout.
+     * @description {zh} 获取当前布局。
+     * @returns
+     * - {en} Active layout name or undefined.
+     * - {zh} 当前激活的布局名称或undefined。
+     * @example
+     * ``` typescript
+     * const activeLayout = viewer.getActiveLayoutName();
+     * console.log(activeLayout);
+     * ```
+     */
+    getActiveLayoutName(): string | undefined;
+    zoomIn(step?: number): void;
+    zoomOut(step?: number): void;
+    /**
+     * @description {en} Gets dxf layers.
+     * @description {zh} 获取dxf图层。
+     * @returns
+     * - {en} Dxf layers.
+     * - {zh} dxf图层。
+     * @example
+     * ``` typescript
+     * const dxfLayers = viewer.getLayers();
+     * for (let i = 0; i < dxfLayers.length; ++i) {
+     *     const layers = dxfLayers[i].layers;
+     *     const layerNames = Object.keys(layers).sort();
+     *     console.log(layerNames);
+     * }
+     * ```
+     */
+    getLayers(): (DxfLayers | PdfLayers)[];
+    /**
+     * Sets model's (aka, a dxf file) visibility.
+     * @throws Throws exception if modelId doesn't exist.
+     * @internal
+     */
+    setModelVisibility(modelId: string, visible: boolean): void;
+    /**
+     * @description {en} Sets layer's visibility.
+     * @description {zh} 设置图层的可见性。
+     * @param layerName
+     * - {en} Layer's name to show or hide.
+     * - {zh} 要显示或隐藏的图层名称。
+     * @param visible
+     * - {en} Layer's target visibility.
+     * - {zh} 图层的目标可见性。
+     * @param modelId
+     * - {en} Useful when more than one model is loaded, if not specified, will use the master model.
+     * - {zh} 当加载了多个模型时有用，如果未指定，将使用主模型。
+     * @throws Error
+     * - {en}: Throws exception if given modelId doesn't exist.
+     * - {zh} 如果给定的modelId不存在，则抛出异常。
+     * @example
+     * ``` typescript
+     * // Hides layer "0"
+     * viewer.setLayerVisibility("0", false);
+     * ```
+     */
+    setLayerVisibility(layerName: string, visible: boolean, modelId?: string): void;
+    /**
+     * Sets layer's opacity
+     * @internal
+     */
+    setLayerOpacity(layerName: string, opacity: number, modelId?: string): void;
+    /**
+     * Sets layer's color
+     * @throws Throws exception if layer doesn't exist.
+     * @internal
+     */
+    setLayerColor(layerName: string, color: number, modelId?: string): void;
+    /**
+     * Resets a layer's color.
+     * @internal
+     */
+    resetLayerColor(layerName: string, modelId?: string): void;
+    /**
+     * Enables to hide visually small objects in order to improve performance.
+     */
+    enableHidingVisuallySmallObjects(enable: boolean): void;
+    /**
+     * If it enabled to hide visually small objects.
+     */
+    isHidingVisuallySmallObjectsEnabled(): boolean;
+    /**
+     * Gets a proper visible pixel size according to given object count.
+     * You can understand the size as pixel size, but it is not exactly pixel size.
+     * E.g., a line's length is 1000 in world coordinate. When zoom is 1, then it display as (let's say) 1000px.
+     * When we zoom out, so the zoom becomes 0.001, then the line displays as 1px. (Not exactly, but you'd better understand it this way).
+     * So, when there are less objects in scene, it's likely to see smaller object when it takes n(1, etc.) pixels in screen.
+     * And when there are many objects in scene, it's going to hide it when it takes more pixels (7, etc.).
+     * - < 10000 objects: 0.3
+     * - 10000 - 50000 objects: 0.5-3
+     * - > 50000 objects: 3
+     */
+    private getVisiblePixelSize;
+    private setLayoutHidableObjectArray;
+    /**
+     * Updates raycaster threshold to a proper value, so user can easily pick points and lines
+     */
+    private updateRaycasterThreshold;
+    /**
+     * Updates hidable objects' visibility once camera.zoom changed.
+     * @param enableHideVisuallySmallObjects When enableHideVisuallySmallObjects is set to false, we may force
+     * all objects to be visible!
+     */
+    private updateHidableObjectsVisibility;
+    /**
+     * Updates camera zoom value for shader materials, which are created in DxfLoader
+     */
+    private updateCameraZoomUniform;
+}

package/dist/types/core/viewers/Viewer3d.d.ts

@@ -0,0 +1,136 @@
+import * as THREE from "three";
+import { BaseViewer } from "./BaseViewer";
+import { ViewerName } from "./Constants";
+import { EffectManager } from "../effect";
+import { Model3d } from "../model";
+import { Viewer3dConfig, ModelConfig, Viewpoint } from "../../core/Configs";
+export declare class Viewer3d extends BaseViewer {
+    name: ViewerName;
+    loadedModels: Model3d[];
+    distanceCullingFactor: number;
+    protected effect: EffectManager;
+    private shouldDispatchModelLoadEvent;
+    constructor(viewerCfg: Viewer3dConfig, homeView?: Viewpoint);
+    protected setDefaultBackground(): void;
+    is3d(): boolean;
+    loadLocalModel(url: string, modelCfg: ModelConfig, manager?: THREE.LoadingManager, onProgress?: (event: ProgressEvent) => void): Promise<void>;
+    loadModel(modelCfg: ModelConfig, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<void>;
+    private loadModelInternal;
+    addModel(model: Model3d): void;
+    /**
+     * Sets distance culling factor in order to improve performance.
+     * 0 means distance culling is disabled.
+     * 100 means a 1x1 squre mesh is visible within 100.
+     * @internal
+     */
+    setDistanceCullingFactor(val: number): void;
+    /**
+     * Gets distance culling factor.
+     * @internal
+     */
+    getDistanceCullingFactor(): number;
+    /**
+     * Sets an object's opacity.
+     */
+    setObjectOpacity(object: THREE.Object3D, opacity: number): void;
+    /**
+     * Sets an object's opacity.
+     */
+    setOtherObjectsOpacity(object: THREE.Object3D, opacity: number): void;
+    /**
+     * Clears an object's opacity.
+     */
+    clearObjectOpacity(object: THREE.Object3D): void;
+    /**
+     * Sets a model's opacity.
+     */
+    setModelOpacity(modelId: string): void;
+    /**
+     * Clears a model's opacity.
+     */
+    clearModelOpacity(modelId: string): void;
+    /**
+     * Sets all models' opacity.
+     */
+    setModelsOpacity(opacity: number): void;
+    /**
+     * Clears all models' opacity.
+     */
+    clearModelsOpacity(): void;
+    /**
+     * Checks if there is any transparent object in any model.
+     * Note that this only consider the objects that we set as transparent,
+     * it does not count objects that are transparent by default (like glass).
+     */
+    hasTransparentObject(): boolean;
+    /**
+     * Sets an object's visibility.
+     */
+    setObjectVisible(object: THREE.Object3D, visible: boolean): void;
+    /**
+     * Hides all other objects except the given one.
+     */
+    hideOtherObjects(object: THREE.Object3D): void;
+    /**
+     * Sets a model's visibility.
+     */
+    setModelVisible(modelId: string, visible: boolean): void;
+    /**
+     * Sets all models' visibility.
+     */
+    setModelsVisible(visible: boolean): void;
+    /**
+     * Enables a model's outline.
+     */
+    enableModelOutline(modelId: string, enable: boolean): void;
+    /**
+     * Enables all models' outline.
+     */
+    enableModelsOutline(enable: boolean): void;
+    /**
+     * Highlights an object.
+     * TODO: support merged object and InstancedMesh
+     */
+    setObjectHighlight(object: THREE.Object3D): void;
+    /**
+     * Gets highlighted object.
+     */
+    getHighlightedObject(): THREE.Object3D | undefined;
+    clearHighlight(): void;
+    setDoubleSidedMaterials(): void;
+    revertDoubleSidedMaterials(): void;
+    clearSelection(): void;
+    /**
+     * Gets if selection is enabled.
+     */
+    get enableSelection(): boolean;
+    /**
+     * Sets if selection is enabled.
+     */
+    set enableSelection(enable: boolean);
+    /**
+     * Checks if there is any visible object.
+     */
+    hasVisibleObject(): boolean;
+    /**
+     * Checks if there is any invisible object.
+     */
+    hasInvisibleObject(): boolean;
+    enableSsao(enable: boolean): void;
+    getSsaoEnabled(): boolean;
+    setEnvironmentData(data?: Uint16Array): Promise<void>;
+    setEnvironment(hdrUrl: string): Promise<void>;
+    showVertexNormals(show: boolean, size?: number): void;
+    getLights(): {
+        sun: THREE.DirectionalLight;
+        ambient: THREE.Object3D<THREE.Object3DEventMap> | undefined;
+        hemisphere: THREE.Object3D<THREE.Object3DEventMap> | undefined;
+    };
+    debugLights(enable: boolean): void;
+    setModelClipPlanes(modelId: number, planes: THREE.Plane[]): void;
+    setGlobalClipPlanes(planes: THREE.Plane[]): void;
+    /**
+     * Generates "uv1" for specified mesh or all meshes in this model. "uv1" is useful for lightmap.
+     */
+    generateSmartUv1(object?: THREE.Object3D): void;
+}

package/dist/types/core/viewers/Viewer3dLite.d.ts

@@ -0,0 +1,144 @@
+import * as THREE from "three";
+import { IsolateObjectsParam, ModelConfig } from "../../core/Configs";
+import { CameraControlsEx } from "../../core/controls/CameraControlsEx";
+import { ModelData3d } from "../../core/model";
+/**
+ * @internal
+ */
+export declare enum ViewerMode {
+    Browser = 0,
+    Browserless = 1,
+    Headless = 2
+}
+/**
+ * @internal
+ */
+export declare class Viewer3dLite {
+    containerOrCanvas: HTMLDivElement | any;
+    glContext?: WebGLRenderingContext | WebGL2RenderingContext;
+    camera?: THREE.PerspectiveCamera;
+    scene: THREE.Scene;
+    renderer?: THREE.WebGLRenderer;
+    renderTarget?: THREE.WebGLRenderTarget;
+    controls?: CameraControlsEx;
+    selectedObject: any | undefined;
+    loadedModels: ModelData3d[];
+    pmremGenerator?: THREE.PMREMGenerator;
+    private clock;
+    private viewerMode;
+    private raycaster?;
+    private savedMaterialsForOpacity?;
+    private jobCount;
+    private bbox;
+    private outlineMaterial;
+    private outlineRoot;
+    private transparentObjectIds;
+    private requestAnimationFrameHandle?;
+    constructor(containerOrCanvas: HTMLDivElement | any, // eslint-disable-line
+    viewerMode?: ViewerMode, glContext?: WebGLRenderingContext | WebGL2RenderingContext);
+    /**
+     * Initialize everything it needs
+     */
+    init(): void;
+    private initScene;
+    private isBrowserlessMode;
+    private isBrowserMode;
+    private initRenderer;
+    private initCamera;
+    private initControls;
+    private initLights;
+    /**
+     * Initialize mouse/pointer events
+     */
+    private initPointerEvents;
+    animate(): void;
+    destroy(): void;
+    loadLocalModel(url: string, modelCfg: ModelConfig, onProgress?: (event: ProgressEvent) => void): Promise<void>;
+    /**
+     * We don't plan to support onProgress really well in this class.
+     */
+    loadModel(modelCfg: ModelConfig, onProgress?: (event: ProgressEvent) => void): Promise<void>;
+    parseGltf(data: ArrayBuffer | string, modelCfg: ModelConfig, onSuccess: (object: THREE.Object3D) => void, onError?: (event: ErrorEvent) => void): void;
+    /**
+     * Applies options and add object to scene.
+     */
+    applyOptionsAndAddToScene: (url: string, object: THREE.Object3D, modelCfg: ModelConfig, onProgress?: ((event: ProgressEvent) => void) | undefined) => Promise<void>;
+    /**
+     *
+     * @param model
+     * @returns
+     * @description Add model data to viewer.
+     */
+    addModel(model: ModelData3d): void;
+    /**
+     * We won't set a opacity or highlight directly, because that way will lose model's original opacity or color value
+     * @param isAdd is add or remove the opacity we added
+     * @param opacity
+     */
+    addOrRemoveObjectOpacity(isAdd?: boolean, opacity?: number, includeObjectIds?: number[], excludeObjectIds?: number[]): void;
+    hasTransparentObject(): boolean;
+    /**
+     * Gets intersections by given mouse location.
+     * If no MouseEvent is passed in, use (0, 0) as the raycaster's origin.
+     */
+    private getIntersections;
+    /**
+     * Handles mouse click event
+     */
+    private handleMouseClick;
+    selectObject(object?: THREE.Object3D): void;
+    /**
+     * Clears the current selection
+     */
+    clearSelection(): void;
+    /**
+     * Make camera fly to objects
+     */
+    flyToObjects(objects: THREE.Object3D[]): void;
+    /**
+     * Make camera fly to an object
+     */
+    flyToObject(object: THREE.Object3D): void;
+    /**
+     * Flies to current selected object if any
+     */
+    flyToSelectedObject(): void;
+    /**
+     * Make camera fly to target position with given lookAt position
+     * @param position camera's target position
+     * @param lookAt camera's new lookAt position
+     */
+    flyTo(position: THREE.Vector3 | number[], lookAt: THREE.Vector3 | number[], onCompleteCallback?: () => void): void;
+    goToHomeView(): void;
+    /**
+     * Sets environment for the scene.
+     * @param data Uint16Array of the hdr content
+     */
+    setEnvironmentFromDataArray(data?: Uint16Array): void;
+    /**
+     * Tries to adjust camera near/far clip plane according to objects size in scene.
+     * Do this to avoid the case when objects are too small or big thus clipped!
+     */
+    private tryAdjustCameraNearAndFar;
+    isolateObjects(params: IsolateObjectsParam[]): void;
+    private getMeshes;
+    /**
+     * Increases job count, and show spinner accordingly
+     */
+    increaseJobCount(): void;
+    /**
+     * Decreases job count, and hide spinner accordingly
+     */
+    decreaseJobCount(): void;
+    /**
+     * Compute bounding box of loaded models
+     */
+    computeBoundingBox(): THREE.Box3;
+    getContext(): WebGLRenderingContext | WebGL2RenderingContext | undefined;
+    getCameraDirection(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    setFov(fov: number): void;
+}