@x-viewer/plugins 0.9.0

package/dist/types/axis-gizmo/AxisGizmoPlugin.d.ts

@@ -0,0 +1,51 @@
+import { BaseViewer, Plugin, PluginConfig } from "@x-viewer/core";
+/**
+ * AxisGizmo plugin config.
+ */
+export interface AxisGizmoPluginConfig extends Partial<PluginConfig> {
+    /**
+     * UI element id to contain the plugin.
+     */
+    containerId?: string;
+    /**
+     * Ignores z-axis. It is useful for Viewer2d.
+     */
+    ignoreZAxis?: boolean;
+}
+/**
+ * This renderer monitors the host renderer's camera, and keeps a coordinate axes
+ * the same direction as host renderer's
+ */
+export declare class AxisGizmoPlugin extends Plugin {
+    static readonly DEFAULT_ID = "AxisGizmoPlugin";
+    private cfg;
+    private hostCamera?;
+    private container?;
+    private coordinateAxes?;
+    private ignoreZAxis;
+    private camera?;
+    private scene?;
+    private renderer?;
+    private css2dRenderer?;
+    constructor(viewer: BaseViewer, cfg?: AxisGizmoPluginConfig);
+    private init;
+    private initRenderer;
+    private initScene;
+    /**
+     * Sets hostCamera in case it is changed.
+     * It is possible for a viewer to switch camera between a OrthographicCamera and a PerspectiveCamera.
+     */
+    private setHostCamera;
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    private render;
+    private animate;
+    private update;
+    /**
+     * Update axes according to camera direction.
+     * Camera's direction is the only input factor for this class. It always look at the origin.
+     * @param direction
+     */
+    private updateCameraDirection;
+    destroy(): void;
+}

package/dist/types/axis-gizmo/CoordinateAxes.d.ts

@@ -0,0 +1,14 @@
+import { THREE, THREEAddons } from "@x-viewer/core";
+/**
+ * CoordinateAxes class.
+ */
+export declare class CoordinateAxes extends THREE.Object3D {
+    name: string;
+    private readonly AXIS_LENGTH;
+    private readonly AXIS_COLOR_X;
+    private readonly AXIS_COLOR_Y;
+    private readonly AXIS_COLOR_Z;
+    constructor(addTexts?: boolean, ignoreZAxis?: boolean);
+    addTexts(ignoreZAxis?: boolean): void;
+    createText(text: string, color: string, size?: number): THREEAddons.CSS2DObject;
+}

package/dist/types/axis-gizmo/index.d.ts

@@ -0,0 +1,2 @@
+import "./axisgizmo.scss";
+export * from "./AxisGizmoPlugin";

package/dist/types/bottom-bar/BottomBarPlugin.d.ts

@@ -0,0 +1,42 @@
+import { IconClass, BaseViewer, Plugin } from "@x-viewer/core";
+import { Tooltip } from "@x-viewer/ui";
+declare enum BottomBarItemId {
+    statistics = "x-viewer-threejs-statistics",
+    cameraCfg = "x-viewer-threejs-cameraCfg",
+    tips = "x-viewer-threejs-tips"
+}
+interface BottomBarItemConfig {
+    icon: IconClass;
+    mutexIds?: BottomBarItemId[];
+    onActive?: (item: BottomBarItem) => void;
+    onDeactive?: (item: BottomBarItem) => void;
+    onClick?: (item: BottomBarItem) => void;
+    onUpdate?: (item: BottomBarItem) => void;
+}
+/**
+ * Bottom bar plugin is a debug tool for developers.
+ */
+export declare class BottomBarPlugin extends Plugin {
+    private element;
+    itemList: Map<string, BottomBarItem>;
+    constructor(viewer: BaseViewer);
+    update(): void;
+    private init;
+    private createItem;
+}
+declare class BottomBarItem {
+    readonly viewer: BaseViewer;
+    private readonly bottomBar;
+    protected readonly menuId: string;
+    protected cfg: BottomBarItemConfig;
+    private eventBus;
+    private itemconfig;
+    tooltip: Tooltip;
+    element: HTMLElement;
+    active: boolean;
+    constructor(viewer: BaseViewer, bottomBar: BottomBarPlugin, menuId: string, cfg: BottomBarItemConfig);
+    private createButton;
+    setActive(active: boolean): void;
+    update(): void;
+}
+export {};

package/dist/types/bottom-bar/index.d.ts

@@ -0,0 +1,2 @@
+import "./bottombar.scss";
+export * from "./BottomBarPlugin";

package/dist/types/context-menu/Constants.d.ts

@@ -0,0 +1,34 @@
+import type { BaseViewer } from "@x-viewer/core";
+import type { AxisPlaneSection, ObjectsBoxSection, PickPlaneSection } from "../sections";
+import type { Toolbar } from "../toolbars";
+/**
+ * Context for ContextMenu
+ * @internal
+ */
+export interface Context {
+    viewer: BaseViewer;
+    hit?: any;
+    instanceId?: number;
+    batchId?: number;
+    /**
+     * For Viewer3d
+     * @internal
+     */
+    section?: ObjectsBoxSection | PickPlaneSection | AxisPlaneSection;
+    toolbar?: Toolbar;
+}
+/**
+ * @internal
+ */
+/**
+ * @internal
+ */
+export interface ContextMenuItem {
+    title?: string;
+    enabled?: boolean;
+    shown?: boolean;
+    getTitle?: (context: Context) => string;
+    getEnabled?: (context: Context) => boolean;
+    getShown?: (context: Context) => boolean;
+    doAction?: (context: Context) => void;
+}

package/dist/types/context-menu/ContextMenu.config.d.ts

@@ -0,0 +1,2 @@
+import { ContextMenuItem } from "./Constants";
+export declare const ContextMenuItems: ContextMenuItem[][];

package/dist/types/context-menu/ContextMenuPlugin.d.ts

@@ -0,0 +1,36 @@
+import { type BaseViewer, Plugin, PluginConfig } from "@x-viewer/core";
+import { Context, ContextMenuItem } from "./Constants";
+/**
+ * Context menu plugin config.
+ */
+export interface ContextMenuPluginConfig extends Partial<PluginConfig> {
+    language?: "cn" | "en";
+}
+/**
+ * Context menu plugin.
+ * Can be used by Viewer3d.
+ */
+export declare class ContextMenuPlugin extends Plugin {
+    static readonly DEFAULT_ID = "ContextMenuPlugin";
+    protected cfg: ContextMenuPluginConfig;
+    protected container: HTMLElement;
+    protected element: HTMLDivElement;
+    protected context: Context;
+    protected itemList: [ContextMenuItem, HTMLElement][];
+    constructor(viewer: BaseViewer, cfg?: ContextMenuPluginConfig);
+    private initLocalization;
+    private initEvents;
+    protected handleClick: () => void;
+    private showContextMenu;
+    private isEnabled;
+    private isShown;
+    private getTitle;
+    private createMenuUI;
+    private createMenuGroup;
+    private createMenuItem;
+    private updateMenuItems;
+    private showMenuElement;
+    show(pageX: number, pageY: number): void;
+    hide(): void;
+    destroy(): void;
+}

package/dist/types/context-menu/Locale.d.ts

@@ -0,0 +1,48 @@
+import { i18next } from "@x-viewer/core";
+export declare const en: {
+    viewFitAll: string;
+    hideAll: string;
+    showAll: string;
+    xRayAll: string;
+    xRayNone: string;
+    selectNone: string;
+    resetView: string;
+    viewFitEntity: string;
+    hideEntity: string;
+    hideOthers: string;
+    xRayEntity: string;
+    xRayOthers: string;
+    select: string;
+    deselect: string;
+    showSectionPlane: string;
+    showSectionBox: string;
+    showAxisSection: string;
+    hideSectionPlane: string;
+    hideSectionBox: string;
+    hideAxisSection: string;
+    undoSection: string;
+};
+export declare const cn: {
+    viewFitAll: string;
+    hideAll: string;
+    showAll: string;
+    xRayAll: string;
+    xRayNone: string;
+    selectNone: string;
+    resetView: string;
+    viewFitEntity: string;
+    hideEntity: string;
+    hideOthers: string;
+    xRayEntity: string;
+    xRayOthers: string;
+    select: string;
+    deselect: string;
+    showSectionPlane: string;
+    showSectionBox: string;
+    showAxisSection: string;
+    hideSectionPlane: string;
+    hideSectionBox: string;
+    hideAxisSection: string;
+    undoSection: string;
+};
+export declare const i18n: i18next.i18n;

package/dist/types/context-menu/index.d.ts

@@ -0,0 +1,4 @@
+import "./contextmenu.scss";
+export * from "./Constants";
+export * from "./ContextMenuPlugin";
+export * from "./ContextMenu.config";

package/dist/types/dat-gui/Viewer3dDatGui.d.ts

@@ -0,0 +1,66 @@
+import { Plugin, Viewer3d } from "@x-viewer/core";
+import * as dat from "dat.gui";
+/**
+ * Can be used by Viewer3d and BimTilesViewer.
+ * @internal
+ */
+export declare class Viewer3dDatGuiPlugin extends Plugin {
+    protected viewer: Viewer3d;
+    gui?: dat.GUI;
+    /**
+     *
+     * @param viewer pass in the Viewer3D, so we can reference its data members
+     */
+    constructor(viewer: Viewer3d);
+    /**
+     * Defined all controls here, which will be displyed in dat.GUI
+     * Color should follow these formats:
+     * '#ffffff', [0, 0, 0], [0, 0, 0, 0.5], \{ h: 100, s: 0.9, v: 0.3 \}
+     */
+    readonly controls: {
+        showGroundGrid: boolean;
+        showGroundGrass: boolean;
+        skyMode: string[];
+        environments: string[];
+        homeView: () => void;
+        views: string[];
+        OrthographicCamera: boolean;
+        viewpoints: boolean;
+        annotations: boolean;
+        takeSnapshot: () => void;
+        takeSnapshotForViewerBBox: () => void;
+        fullScreen: () => void;
+        webcam: boolean;
+        uploadFile: () => void;
+        showTreeView: boolean;
+        showPropertyPanel: boolean;
+        transparentMode: boolean;
+        enableOutline: boolean;
+        doubleSidedMaterial: boolean;
+        showVertexNormals: boolean;
+        explode: number;
+        sectionMode: string[];
+        alVisible: boolean;
+        alColor: string;
+        alIntensity: number;
+        dlColor: string;
+        showDlHelper: boolean;
+        hlVisible: boolean;
+        hlIntensity: number;
+        hlColor: number[];
+        hlGroundColor: number[];
+        fogEnabled: boolean;
+        fogColor: number;
+        fogNearDistance: number;
+        fogFarDistance: number;
+        distanceCullingFactor: number;
+        errorTarget: number;
+    };
+    /**
+     * Init dat.GUI
+     */
+    init(): void;
+    open(): void;
+    close(): void;
+    destroy(): void;
+}

package/dist/types/dat-gui/index.d.ts

@@ -0,0 +1 @@
+export * from "./Viewer3dDatGui";

package/dist/types/explode/ExplodePlugin.d.ts

@@ -0,0 +1,46 @@
+import { THREE, BaseViewer, Plugin, PluginConfig } from "@x-viewer/core";
+import { ObjectExploder } from "./ObjectExploder";
+export interface ExplodePluginConfig extends Partial<PluginConfig> {
+    /**
+     * Explode center.
+     * If specified, each object explode based on this position. Otherwise,
+     * each object explode based on its own center.
+     */
+    explodeCenter?: THREE.Vector3;
+    /**
+     * By default, it explodes to every direction. In some scenarios, user may want to
+     * explode only in up/down direction.
+     */
+    explodeUp?: boolean;
+}
+/**
+ * Exploder class is used to explode objects in a viewer.
+ * Can be used by Viewer3d.
+ * @internal
+ */
+export declare class ExplodePlugin extends Plugin {
+    static readonly DEFAULT_ID = "ExplodePlugin";
+    protected cfg: ExplodePluginConfig;
+    protected exploders: ObjectExploder[];
+    constructor(viewer: BaseViewer, cfg?: ExplodePluginConfig);
+    get scene(): THREE.Scene<THREE.Object3DEventMap>;
+    /**
+     * Initialize the
+     */
+    init(): void;
+    /**
+     * Explode objects
+     * @param scale 1 means do not explode at all, recommended value between 1-5.
+     */
+    explode(scale: number): void;
+    /**
+     * Unexplode objects
+     */
+    unexplode(): void;
+    protected onModelLoaded: () => void;
+    /**
+     * Checks if exploder already exists for a model/object.
+     */
+    protected hasExploderForModel(modelObjectId: number): boolean;
+    destroy(): void;
+}

package/dist/types/explode/ObjectExploder.d.ts

@@ -0,0 +1,48 @@
+import { THREE } from "@x-viewer/core";
+/**
+ * ObjectExploder class is used to explode an object
+ * @internal
+ */
+export declare class ObjectExploder {
+    private scene;
+    objectId: number;
+    explodeCenter: THREE.Vector3;
+    private scale;
+    private explodeUp;
+    /**
+     * Constructor of Explode
+     * @param objectId target object id, that is going to be exploded
+     * @param explodeCenter if undefined, will explode object by its center
+     * @param scale scale factor, 1 means 1 time farer away from exploder's position
+     */
+    constructor(scene: THREE.Scene, objectId: number, explodeCenter?: THREE.Vector3 | undefined);
+    /**
+     * Explodes the object
+     */
+    explode(scale: number): void;
+    /**
+     * Explodes a parent or leaf object.
+     * If an object has both geometry and children, we'll move itself
+     * and we shouldn't move its children again.
+     */
+    private explodeObject;
+    /**
+     * Explodes a leaf object (that has geometry, and ususally no children).
+     * It doesn't support THREE.InstancedMesh.
+     */
+    private explodeLeafObject;
+    /**
+     * Unexplodes the object
+     */
+    unexplode(): void;
+    /**
+     * Unexplodes a parent or leaf object
+     */
+    private unexplodeObject;
+    /**
+     * Unexplodes a leaf object
+     */
+    private unexplodeLeafObject;
+    setExplodeUp(explodeUp: boolean): void;
+    private getObjectCenter;
+}

package/dist/types/explode/index.d.ts

@@ -0,0 +1 @@
+export * from "./ExplodePlugin";

package/dist/types/export/ExportPlugin.d.ts

@@ -0,0 +1,53 @@
+import { THREE, BaseViewer, Plugin, PluginConfig, Viewer3d, THREEAddons } from "@x-viewer/core";
+import { BasePanel } from "@x-viewer/ui";
+export declare enum ExportFormats {
+    Glb = "glb",
+    Gltf = "gltf",
+    Obj = "obj",
+    Stl = "stl",
+    Ply = "ply"
+}
+/**
+ * Export plugin config.
+ */
+export interface ExportPluginConfig extends Partial<PluginConfig> {
+    language?: "cn" | "en";
+}
+/**
+ * Export plugin is used to export scene to a 3d model.
+ * @description
+ */
+export declare class ExportPlugin extends Plugin {
+    static readonly DEFAULT_ID = "ExportPlugin";
+    protected cfg: ExportPluginConfig;
+    protected basePanel?: BasePanel;
+    protected viewer3d: Viewer3d;
+    constructor(viewer: BaseViewer, cfg?: ExportPluginConfig);
+    /**
+     * Exports to gltf or glb format.
+     * @param filename pure filename without extension.
+     * @param binary true to export as binary glb, false to export as text gltf.
+     * @internal
+     */
+    exportGltf(filename: string, options?: THREEAddons.GLTFExporterOptions, targetObject?: THREE.Object3D | null): void;
+    /**
+     * Exports to OBJ format.
+     * @param filename pure filename without extension.
+     */
+    exportObj(filename: string, targetObject?: THREE.Object3D | null): void;
+    exportStl(filename: string, targetObject?: THREE.Object3D | null): void;
+    exportPly(filename: string, binary?: boolean, targetObject?: THREE.Object3D | null): void;
+    /**
+     * Shows the export options panel.
+     */
+    showExportPanel(targetFormat?: ExportFormats, filename?: string, targetObject?: THREE.Object3D | null): void;
+    /**
+     * Saves/downloads a blob as a file.
+     * @param blob The blob to save.
+     * @param filename The filename (with extension) to save as.
+     */
+    saveBlobAsFile(blob: Blob, filename: string): void;
+    saveStringAsFile(text: string, filename: string): void;
+    saveArrayBufferAsFile: (buffer: ArrayBuffer, filename: string) => void;
+    destroy(): void;
+}

package/dist/types/export/index.d.ts

@@ -0,0 +1,2 @@
+import "./ExportPlugin.scss";
+export * from "./ExportPlugin";

package/dist/types/ground-grass/GroundGrassPlugin.d.ts

@@ -0,0 +1,45 @@
+import { THREE, BaseViewer, Plugin, PluginConfig } from "@x-viewer/core";
+export interface GroundGrassPluginConfig extends Partial<PluginConfig> {
+    /**
+     * Url of a texture image.
+     */
+    texture?: string;
+    /**
+     * Ground width.
+     */
+    width?: number;
+    /**
+     * Ground height.
+     */
+    height?: number;
+    /**
+     * How many times the texture is repeated.
+     */
+    repeatX?: number;
+    /**
+     * How many times the texture is repeated.
+     */
+    repeatY?: number;
+    /**
+     * If ground grass is visible. It is visible by default.
+     */
+    visible?: boolean;
+}
+/**
+ * Ground grass plugin.
+ * Can be used by Viewer3d.
+ */
+export declare class GroundGrassPlugin extends Plugin {
+    static readonly DEFAULT_ID = "GroundGrassPlugin";
+    protected readonly NAME = "GROUND_GRASS";
+    protected readonly DEFAULT_SIZE = 1000;
+    protected readonly DEFAULT_REPEAT = 20;
+    protected cfg: GroundGrassPluginConfig;
+    protected groundGrass?: THREE.Mesh;
+    constructor(viewer: BaseViewer, cfg?: GroundGrassPluginConfig);
+    protected init(): void;
+    setVisible(visible: boolean): void;
+    protected onModelLoaded: () => void;
+    protected createGrassGround(texture: string, width: number, height: number, repeatX: number, repeatY: number): Promise<THREE.Mesh>;
+    destroy(): void;
+}

package/dist/types/ground-grass/index.d.ts

@@ -0,0 +1 @@
+export * from "./GroundGrassPlugin";

package/dist/types/ground-grid/GroundGridPlugin.d.ts

@@ -0,0 +1,46 @@
+import { THREE, BaseViewer, Plugin, PluginConfig } from "@x-viewer/core";
+/**
+ * Ground grid plugin.
+ */
+export interface GroundGridPluginConfig extends Partial<PluginConfig> {
+    /**
+     * Ground size.
+     */
+    size?: number;
+    /**
+     * Number of divisions.
+     */
+    divisions?: number;
+    /**
+     * If ground grid is visible. It is visible by default.
+     */
+    visible?: boolean;
+}
+/**
+ * Ground grid plugin.
+ * Can be used by Viewer3d.
+ */
+export declare class GroundGridPlugin extends Plugin {
+    static readonly DEFAULT_ID = "GroundGridPlugin";
+    protected readonly NAME = "GROUND_GRID";
+    protected readonly DEFAULT_SIZE = 1000;
+    protected readonly DEFAULT_DIVISIONS = 100;
+    protected readonly DEFAULT_MAT_PARAMS: {
+        color: number;
+        transparent: boolean;
+        opacity: number;
+        wireframeLinewidth: number;
+    };
+    protected cfg: GroundGridPluginConfig;
+    protected gridHelper?: THREE.GridHelper;
+    constructor(viewer: BaseViewer, cfg?: GroundGridPluginConfig);
+    protected init(): void;
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    protected onModelLoaded: () => void;
+    /**
+     * Creates ground grid
+     */
+    protected createGroundGrid(size?: number, divisions?: number, groundCenter?: THREE.Vector3): THREE.GridHelper;
+    destroy(): void;
+}

package/dist/types/ground-grid/index.d.ts

@@ -0,0 +1 @@
+export * from "./GroundGridPlugin";

package/dist/types/ground-shaow/GroundShadowPlugin.d.ts

@@ -0,0 +1,64 @@
+import { THREE, BaseViewer, Plugin, PluginConfig } from "@x-viewer/core";
+/**
+ * Ground shadow config.
+ */
+export interface GroundShadowPluginConfig extends Partial<PluginConfig> {
+    /**
+     * Blur amount for the shadow.
+     * Default is 5.
+     */
+    blur?: number;
+    /**
+     * Darkness of the shadow.
+     * Default is 0.8.
+     */
+    darkness?: number;
+    /**
+     * Delay in milliseconds before updating the shadow after a model is loaded.
+     * Default is 2000.
+     * This is to avoid updating the shadow too frequently when many models are loaded at once.
+     */
+    updateDelay?: number;
+    /**
+     * Enable or disable the ground shadow.
+     * Default is true.
+     */
+    enabled?: boolean;
+}
+/**
+ * Ground shadow plugin is used to show shadow for models.
+ * Can be used by Viewer3d.
+ * @description
+ */
+export declare class GroundShadowPlugin extends Plugin {
+    static readonly DEFAULT_ID = "GroundShadowPlugin";
+    protected cfg: GroundShadowPluginConfig;
+    enabled: boolean;
+    protected shadowGroup?: THREE.Group;
+    protected blurPlane?: THREE.Mesh;
+    protected depthMaterial?: THREE.MeshDepthMaterial;
+    protected horizontalBlurMaterial?: THREE.ShaderMaterial;
+    protected verticalBlurMaterial?: THREE.ShaderMaterial;
+    protected shadowCamera?: THREE.OrthographicCamera;
+    protected renderTarget?: THREE.WebGLRenderTarget;
+    protected renderTargetBlur?: THREE.WebGLRenderTarget;
+    private shouldRender;
+    private timeout?;
+    constructor(viewer: BaseViewer, cfg?: GroundShadowPluginConfig);
+    protected get scene(): THREE.Scene<THREE.Object3DEventMap>;
+    protected get renderer(): THREE.WebGLRenderer;
+    setEnabled(enabled: boolean): void;
+    isEnabled(): boolean;
+    /**
+     * Updates ground shadow.
+     */
+    update(): void;
+    protected onModelUpdate: () => void;
+    protected onShadowRender: () => void;
+    private initMaterial;
+    private initRenderTarget;
+    private updateGroundShadow;
+    private blurShadow;
+    protected render(): void;
+    destroy(): void;
+}

package/dist/types/ground-shaow/index.d.ts

@@ -0,0 +1 @@
+export * from "./GroundShadowPlugin";