@x-viewer/core 0.9.0

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

@@ -0,0 +1,253 @@
+import * as THREE from "three";
+import { CSS2DRenderer } from "three/examples/jsm/renderers/CSS2DRenderer.js";
+import { ViewerName } from "./Constants";
+import type { Plugin } from "./Plugin";
+import { ViewerEvent } from "./ViewerEvent";
+import { ProgressBar, Spinner } from "../components";
+import { BaseViewerConfig, CameraInfo, CameraProjection, ModelConfig, Viewpoint } from "../../core/Configs";
+import { CameraManager } from "../../core/camera";
+import { CanvasRender } from "../../core/canvas";
+import { Container } from "../../core/components/Container";
+import { FontManager } from "../../core/font";
+import { ZoomToRectHelper } from "../../core/helpers";
+import { LoadingHelper } from "../../core/helpers/LoadingHelper";
+import { InputManager } from "../../core/input-manager";
+import { Interaction } from "../../core/interactions/Interaction";
+import { Model } from "../../core/model";
+import { PickManager } from "../../core/pick";
+import { SceneManager } from "../../core/scene/SceneManager";
+import { UndoManager } from "../../core/undo";
+import { Event } from "../../core/utils";
+type ViewerEvents = {
+    [K in ViewerEvent]: any;
+};
+export declare abstract class BaseViewer<BaseViewerEvents extends ViewerEvents = Record<ViewerEvent, any>> extends Event<BaseViewerEvents> {
+    name: ViewerName;
+    protected viewerCfg: BaseViewerConfig;
+    private clock;
+    protected targetMaxFps: number;
+    protected timeStamp: number;
+    private renderEnabled;
+    /**
+     * @internal
+     */
+    protected requestAnimationFrameHandle?: number;
+    container: Container;
+    protected plugins: Plugin[];
+    loadedModels: Model[];
+    private raf?;
+    private timeoutSymbol?;
+    protected homeView?: Viewpoint;
+    protected inputManager: InputManager;
+    protected cameraManager: CameraManager;
+    protected sceneManager: SceneManager;
+    protected fontManager?: FontManager;
+    protected pickManager: PickManager;
+    protected undoManager: UndoManager;
+    protected overlayRender: CanvasRender;
+    protected css2dRenderer: CSS2DRenderer;
+    protected spinner: Spinner;
+    protected progressBar?: ProgressBar;
+    protected loaderHelper: LoadingHelper;
+    protected zoomToRectHelper?: ZoomToRectHelper;
+    protected interaction?: Interaction;
+    /**
+     * Enables selecting an object
+     */
+    protected _enableSelection: boolean;
+    constructor(viewerCfg: BaseViewerConfig);
+    private initLogLevel;
+    private initLocalization;
+    get viewerContainer(): HTMLElement;
+    get widgetContainer(): HTMLElement;
+    getUndoManager(): UndoManager;
+    getInputManager(): InputManager;
+    getCssRender(): CSS2DRenderer;
+    getCameraManager(): CameraManager;
+    getOverlayRender(): CanvasRender;
+    getSceneManager(): SceneManager;
+    /**
+     * The WebGLRenderer.
+     */
+    get renderer(): THREE.WebGLRenderer;
+    /**
+     * Current camera.
+     */
+    get camera(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    /**
+     * Current Scene.
+     */
+    get scene(): THREE.Scene<THREE.Object3DEventMap>;
+    /**
+     * Gets if selection is enabled.
+     */
+    abstract get enableSelection(): boolean;
+    /**
+     * Sets if selection is enabled.
+     * A derived class may need to clean up selected object if any.
+     */
+    abstract set enableSelection(enable: boolean);
+    abstract setObjectHighlight(object: THREE.Object3D): void;
+    abstract clearHighlight(): void;
+    getRaycaster(): THREE.Raycaster;
+    getPickManager(): PickManager;
+    getViewerConfig(): BaseViewerConfig;
+    getSpinner(): Spinner;
+    getFontManager(): FontManager | undefined;
+    setInteraction(interaction: Interaction): void;
+    private initCSS2DRenderer;
+    /**
+     * In order to have a better performance, it should only render when necessary.
+     * Usually, we should enable render for these cases:
+     *  - Anything added to, removed from scene, or objects' position, scale, rotation, opacity, material, etc. changed
+     *  - Anything selected/unselected
+     *  - Camera changed
+     *  - Render area resized
+     * @internal
+     */
+    enableRender: (time?: number) => void;
+    protected animate(timeStamp?: number): void;
+    resize(): void;
+    /**
+     * Sets decoder path for draco loader.
+     * Draco decoder will be used if a model is draco encoded.
+     * @param decoderPath e.g., "libs/draco/gltf/"
+     * @internal
+     */
+    setDracoDecoderPath(path: string): void;
+    abstract loadModel(modelCfg: ModelConfig, onProgress?: (event: ProgressEvent) => void): Promise<void>;
+    addModel(model: Model): void;
+    removeModelById(modelId: string): void;
+    setFont(urls: string[]): Promise<void>;
+    /**
+     *
+     * @description 2d ignore position z.
+     */
+    is3d(): boolean;
+    /**
+     * Gets how long a pixel represents in world coordinate.
+     * This works fine for OrthographicCamera.
+     * As for PerspectiveCamera, a pixel represents different size for different position,
+     * depends on how far the camera is and its fov, etc. We'll simply take the camera target as the position to calculate.
+     * @internal
+     */
+    getPixelSizeInWorldCoord(): number;
+    /**
+     * @description {en} Asks user to select a box area, and zooms to it.
+     * @description {zh} 询问用户选择一个框选区域，然后缩放到该区域。
+     * @example
+     * ``` typescript
+     * viewer.zoomToRect();
+     * ```
+     */
+    zoomToRect(): void;
+    /**
+     * @internal
+     */
+    deactivateZoomRect(): void;
+    /**
+     * Gets an unique modelId in case the expected id is duplicated.
+     */
+    protected getUniqueModelId(expectedModelId: string): string;
+    /**
+     * Gets all objects' bounding box.
+     */
+    getBBox(): THREE.Box3;
+    /**
+     * Flies to given object and keep current view direction unchanged.
+     */
+    flyToObject(object: THREE.Object3D): void;
+    flyToObjectFront(object: THREE.Object3D): Promise<unknown>;
+    flyToObjects(objects: THREE.Object3D[]): 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, lookAt: THREE.Vector3, enableTransition?: boolean): void;
+    /**
+     * Views objects by given direction.
+     */
+    flyToDirection(direction: THREE.Vector3): void;
+    /**
+     * Goes to home view.
+     */
+    goToHomeView(): void;
+    /**
+     * Fits the camera to view all objects in scene, keeps current view
+     * direction unchanged.
+     */
+    viewFitAll(): void;
+    /**
+     * Zooms to given bounding box.
+     */
+    zoomToBBox(bbox: THREE.Box3): void;
+    /**
+     * Picks the closest object by mouse position.
+     */
+    pickObject(mousePosition: THREE.Vector2, layerChannels?: number[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | undefined;
+    /**
+     * Picks objects by mouse position.
+     */
+    pickObjects(mousePosition: THREE.Vector2, layerChannels?: number[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[];
+    getRaycastableObjects(): THREE.Object3D<THREE.Object3DEventMap>[];
+    /**
+     * @description {en} Sets background color.
+     * @param r Red channel value between 0 and 1.
+     * @param g Green channel value between 0 and 1.
+     * @param b Blue channel value between 0 and 1.
+     * @example
+     * ``` typescript
+     * // Sets background to gray
+     * viewer.setBackgroundColor(0.5, 0.5, 0.5);
+     * ```
+     */
+    setBackgroundColor(r: number, g: number, b: number): void;
+    /**
+     * Sets global clip planes.
+     * This is mainly used by 3d viewers.
+     */
+    setGlobalClipPlanes(planes: THREE.Plane[]): void;
+    getCameraProjection(): CameraProjection;
+    setCameraProjection(proj: CameraProjection): void;
+    enableControl(enable: boolean): void;
+    enableRotate(enable: boolean): void;
+    enableZoom(enable: boolean): void;
+    enablePan(enable: boolean): void;
+    getHomeView(): Viewpoint | undefined;
+    setHomeView(viewpoint: Viewpoint): void;
+    getCameraInfo(): CameraInfo;
+    goToViewpoint(vp: Viewpoint): void;
+    getCameraDirection(): THREE.Vector3;
+    getRenderInfo(): {
+        drawCalls: number;
+        lines: number;
+        points: number;
+        triangles: number;
+        geometries: number;
+        textures: number;
+        materials: number;
+    };
+    /**
+     *
+     */
+    destroy(): void;
+    /**
+     * Installs a Plugin.
+     */
+    addPlugin(plugin: Plugin): void;
+    /**
+     * Uninstalls a Plugin, clearing content from it first.
+     */
+    removePlugin(plugin: Plugin): void;
+    /**
+     * Clears all plugins.
+     * A plugin is not created by viewer, thus, won't be destroyed by viewer.
+     */
+    clearPlugins(): void;
+    /**
+     * Finds a Plugin.
+     */
+    findPlugin(id: string): Plugin | undefined;
+}
+export {};

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

@@ -0,0 +1,130 @@
+import * as THREE from "three";
+import { BaseViewer } from "./BaseViewer";
+import { ViewerName } from "./Constants";
+import { Viewer3dConfig, ModelConfig, Viewpoint } from "../../core/Configs";
+import { EffectManager } from "../../core/effect";
+import { EventInfo } from "../../core/input-manager/InputManager";
+import { BimTilesModel, TileObject } from "../../core/model";
+/**
+ * BimTilesViewer
+ */
+export declare class BimTilesViewer extends BaseViewer {
+    name: ViewerName;
+    protected pickUsageScene: THREE.Scene;
+    protected effect: EffectManager;
+    loadedModels: BimTilesModel[];
+    selectedObject?: TileObject;
+    /**
+     * Enables the feature to hover on an object and blend it color a bit.
+     */
+    enableHoverEffect: boolean;
+    constructor(viewerCfg: Viewer3dConfig, homeView?: Viewpoint);
+    protected setupDefaultEvents(): void;
+    protected setDefaultBackground(): void;
+    private renderImmediately;
+    protected handleAnchorPoint(intersect?: THREE.Intersection): void;
+    protected handleClickObject(intersection: TileObject): void;
+    is3d(): boolean;
+    /**
+     * Sets a model's opacity.
+     */
+    setModelOpacity(modelId: string, opacity: number): void;
+    /**
+     * Clears a model's opacity.
+     */
+    clearModelOpacity(modelId: string): void;
+    /**
+     * Sets all models' opacity.
+     */
+    setModelsOpacity(opacity: number): void;
+    /**
+     * Clears all models' opacity.
+     */
+    clearModelsOpacity(): void;
+    /**
+     * Enables a model's outline.
+     */
+    enableModelOutline(modelId: string, enable: boolean): void;
+    /**
+     * Enables all models' outline.
+     */
+    enableModelsOutline(enable: boolean): void;
+    setModelVisible(modelId: string, visible: boolean): void;
+    setModelsVisible(visible: boolean): void;
+    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);
+    flyToUserId(tilesetId: number, userId: number): void;
+    getBoxByUserId(tilesetId: number, userId: number): THREE.Box3 | undefined;
+    protected handleMouseMove(event: EventInfo): void;
+    private update3dTiles;
+    /**
+     * BimTiles does not support external incoming matrix.
+     * Don't support external incoming modelId.
+     */
+    loadModel(modelCfg: ModelConfig, onProgress?: ((event: ProgressEvent<EventTarget>) => void) | undefined): Promise<void>;
+    setObjectHighlight(object: THREE.Object3D): void;
+    setObjectHighlightedByUserIds(modelId: number, userIds: number[], highlight: boolean): void;
+    setObjectOpacityByUserIds(modelId: number, userIds: number[], opacity: number): void;
+    setOtherObjectOpacityByUserIds(modelId: number, userIds: number[], opacity: number): void;
+    setObjectVisibleByUserIds(modelId: number, userIds: number[], visible: boolean): void;
+    setOtherObjectVisibleByUserIds(modelId: number, userIds: number[], visible: boolean): void;
+    setObjectHoveredByUserId(modelId: number, userId: number, hovered: boolean): void;
+    /**
+     * Gets the hovered object if any.
+     */
+    getHoveredObject(): TileObject | undefined;
+    clearHovered(): void;
+    /**
+     * Checks if there is any visible object.
+     */
+    hasVisibleObject(): boolean;
+    /**
+     * Checks if there is any invisible object.
+     */
+    hasInvisibleObject(): boolean;
+    /**
+     * Isolates given object.
+     * Which means, other objects will be hidden or transparent.
+     */
+    /**
+     * Isolates given objects.
+     * Which means, other objects will be hidden or transparent.
+     */
+    setModelClipPlanes(modelId: number, planes: THREE.Plane[]): void;
+    setGlobalClipPlanes(planes: THREE.Plane[]): 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;
+    /**
+     * Picks objects by mouse position.
+     * First get the object through the gpu, and then get the specific intersection point
+     */
+    pickObjects(mousePosition: THREE.Vector2, layerChannels?: number[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>>[];
+    /**
+     * `errorTarget` refers to The target screenspace error in pixels to target when updating the geometry.
+     * It represents the maximum acceptable error in pixels for the tiles' geometry.
+     * When the actual screenspace error of a tile is below this target, the tile will not be rendered,
+     * as it is considered too detailed for the current view.
+     * So, a higher `errorTarget` value results in better performance, but less detail in the rendered scene.
+     * @default 8
+     */
+    getErrorTarget(): number;
+    /**
+     * Sets errorTarget for all models.
+     */
+    setErrorTarget(errorTarget: number): void;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @internal
+ */
+export declare enum ViewerName {
+    BaseViewer = "BaseViewer",
+    Viewer3d = "Viewer3d",
+    Viewer2d = "Viewer2d",
+    BimTilesViewer = "BimTilesViewer"
+}

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

@@ -0,0 +1,30 @@
+import type { BaseViewer } from "./BaseViewer";
+import { Event } from "../utils";
+/**
+ * Base plugin config.
+ */
+export interface PluginConfig {
+    /**
+     * ID for this Plugin, unique within its viewer.
+     */
+    id: string;
+}
+/**
+ * Base plugin class.
+ */
+export declare abstract class Plugin<PluginEvents extends Record<string, unknown> = {}> extends Event<PluginEvents> {
+    readonly id: string;
+    protected viewer: BaseViewer;
+    /**
+     * Creates this Plugin and installs it into the given {@link Viewer}.
+     *
+     * @param {string} id ID for this plugin, unique among all plugins in the viewer.
+     * @param {Viewer} viewer The viewer.
+     * @param {Object} [cfg] Options
+     */
+    constructor(viewer: BaseViewer, cfg: PluginConfig);
+    /**
+     * Destroys this Plugin and removes it from its viewer.
+     */
+    destroy(): void;
+}