@x-viewer/plugins 0.9.0

package/dist/types/overview-map/index.d.ts

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

package/dist/types/pdf/PdfLoader.d.ts

@@ -0,0 +1,238 @@
+import { THREE, PdfLayer, ModelData2d, Model2dConfig, FontManager } from "@x-viewer/core";
+import type { PDFDocumentProxy, PDFOperatorList, PDFPageProxy } from "pdfjs-dist/types/src/display/api";
+import { PageViewport } from "pdfjs-dist/types/web/interfaces";
+import type { PdfLoaderPluginConfig } from "./PdfLoaderPlugin";
+/**
+ * PdfLoader
+ * @description The pdf coordinate origin is in the lower left corner.
+ * @link https://zxyle.github.io/PDF-Explained/
+ * @link https://github.com/mozilla/pdf.js/
+ */
+export declare class PdfLoader extends THREE.Loader<unknown, Model2dConfig> {
+    static readonly MODEL_LAYOUT_NAME = "Model";
+    pdf?: PDFDocumentProxy;
+    pdfPage?: PDFPageProxy;
+    commonObjs?: any;
+    objs?: any;
+    operatorList?: PDFOperatorList;
+    contentVisible: boolean;
+    optionalContentConfig?: any;
+    markedContentStack: any[];
+    stateStack: CanvasExtraState[];
+    current: CanvasExtraState;
+    tempSMask: null;
+    pendingTextPaths?: any[];
+    pendingClip?: any;
+    pendingEOFill: boolean;
+    activeLayoutName: string;
+    defaultLayerId: string;
+    currentLayerId: string;
+    layers: Record<string, PdfLayer>;
+    loadedEntityCount: number;
+    layersAndThreejsObjects?: Record<string, THREE.Object3D[]>;
+    viewportScale: number;
+    baseTransform: THREE.Matrix4;
+    pdfDocumentGroup?: THREE.Group;
+    viewportMesh?: THREE.Mesh;
+    pdfPageGroup?: THREE.Group;
+    currentTransform: THREE.Matrix4;
+    transformStack: THREE.Matrix4[];
+    currentPath?: THREE.Shape;
+    clipPaths?: THREE.Shape[];
+    clipType: any;
+    paths: THREE.Shape[];
+    private pointsMaterials;
+    private lineBasicMaterials;
+    private meshBasicMaterials;
+    fontManager?: FontManager;
+    modelCfg?: Model2dConfig;
+    private lineWithWidthCount;
+    /**
+     * Uses progressive load if this is defined.
+     * @param done Indicates if progressive load is done.
+     */
+    progressiveLoadCallback?: (zOrder: number, done: boolean) => void;
+    constructor(cfg: PdfLoaderPluginConfig);
+    load(modelCfg: Model2dConfig, onLoad: (data: ModelData2d) => void, onProgress: (event: ProgressEvent) => void, onError: (error: any) => void): void;
+    /**
+     *
+     * @param modelCfg
+     * @param onProgress
+     * @returns
+     */
+    loadAsync(modelCfg: Model2dConfig, onProgress: (event: ProgressEvent) => void): Promise<ModelData2d>;
+    loadPage(page: number, onProgress?: (event: ProgressEvent) => void): Promise<undefined>;
+    getPageCount(): number | undefined;
+    private getOperatorList;
+    private _pumpOperatorList;
+    private tryCleanup;
+    private mergePdfObjects;
+    private getPointsMaterial;
+    private getLineBasicMaterial;
+    private getMeshBasicMaterial;
+    getTransformByMatrix4(matrix: THREE.Matrix4): number[];
+    getObject(data: any, fallback?: null): any;
+    beginDrawing(viewport: PageViewport): void;
+    endDrawing(): void;
+    private releaseData;
+    buildLayers(page: PDFPageProxy): Promise<{
+        layerCount: number;
+        layersMap: Record<string, PdfLayer>;
+        layers: any;
+    } | undefined>;
+    private addObjectToModel;
+    executeOperatorList(operatorList: any, onProgress?: (event: ProgressEvent) => void): Promise<void>;
+    setLineWidth(width: number): void;
+    setLineCap(style: number): void;
+    setLineJoin(style: number): void;
+    setMiterLimit(limit: number): void;
+    setDash(dashArray: number[], dashPhase: number): void;
+    setRenderingIntent(intent: any): void;
+    setFlatness(flatness: any): void;
+    setGState(states: any): void;
+    save(): void;
+    restore(): void;
+    /**
+     *
+     * a c e
+     * b d f
+     * 0 0 1
+     */
+    /**
+     *
+     * @param a is scale x.
+     * @param b is skew y.
+     * @param c is skew x.
+     * @param d is scale y
+     * @param e is translate x.
+     * @param f is translate y.
+     * @example
+     * a c e
+     * b d f
+     * 0 0 1
+     */
+    transform(a: number, b: number, c: number, d: number, e: number, f: number): void;
+    moveTo(): void;
+    lineTo(): void;
+    curveTo(): void;
+    curveTo2(): void;
+    curveTo3(): void;
+    closePath(): void;
+    rectangle(): void;
+    stroke(consumePath?: boolean): void;
+    closeStroke(): void;
+    fill(consumePath?: boolean): void;
+    eoFill(): void;
+    fillStroke(): void;
+    eoFillStroke(): void;
+    closeFillStroke(): void;
+    closeEOFillStroke(): void;
+    endPath(): void;
+    clip(): void;
+    eoClip(): void;
+    beginText(): void;
+    endText(): void;
+    setCharSpacing(spacing: number): void;
+    setWordSpacing(spacing: number): void;
+    setHScale(scale: number): void;
+    setLeading(leading: number): void;
+    setFont(fontRefName: string, size: number): void;
+    setTextRenderingMode(mode: number): void;
+    setTextRise(rise: number): void;
+    moveText(x: number, y: number): void;
+    setLeadingMoveText(): void;
+    setTextMatrix(a: number, b: number, c: number, d: number, e: number, f: number): void;
+    nextLine(): void;
+    paintChar(character: string, x: number, y: number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | undefined;
+    showText(glyphs: any[]): void;
+    showType3Text(glyphs: any): void;
+    setCharWidth(xWidth: any, yWidth: any): void;
+    setCharWidthAndBounds(xWidth: number, yWidth: number, llx: number, lly: number, urx: number, ury: number): void;
+    setStrokeColor(): void;
+    setStrokeColorN(): void;
+    setFillColorN(): void;
+    setStrokeRGBColor(r: number, g: number, b: number): void;
+    setFillRGBColor(r: number, g: number, b: number): void;
+    shadingFill(): void;
+    beginInlineImage(): void;
+    beginImageData(): void;
+    markPoint(tag: any): void;
+    markPointProps(tag: any, properties: any): void;
+    beginMarkedContent(tag: any): void;
+    beginMarkedContentProps(tag: any, properties: any): void;
+    endMarkedContent(): void;
+    beginCompat(): void;
+    endCompat(): void;
+    consumePath(clipBox?: number[]): void;
+    paintFormXObjectBegin(matrix: any, bbox: any): void;
+    paintFormXObjectEnd(): void;
+    beginGroup(): void;
+    endGroup(): void;
+    beginAnnotation(): void;
+    endAnnotation(): void;
+    paintImageMaskXObject(): void;
+    paintImageMaskXObjectGroup(): void;
+    paintImageXObject(objId: any): void;
+    paintInlineImageXObject(imgData: any): void;
+    paintInlineImageXObjectGroup(): void;
+    paintImageXObjectRepeat(): void;
+    paintImageMaskXObjectRepeat(): void;
+    paintSolidColorImageMask(): void;
+    _scaleImage(img: any, inverseTransform: THREE.Matrix4): {
+        paintWidth: any;
+        paintHeight: any;
+    };
+    constructPath(ops: number[], args: number[], minMax: any): void;
+    isContentVisible(): boolean;
+}
+declare class CanvasExtraState {
+    alphaIsShape: boolean;
+    fontSize: number;
+    fontSizeScale: number;
+    browserFontSize: number;
+    textMatrix: number[];
+    textMatrixScale: number;
+    fontMatrix: number[];
+    leading: number;
+    x: number;
+    y: number;
+    lineX: number;
+    lineY: number;
+    charSpacing: number;
+    wordSpacing: number;
+    textHScale: number;
+    textRenderingMode: number;
+    textRise: number;
+    fillColor: number;
+    strokeColor: number;
+    patternFill: boolean;
+    fillAlpha: number;
+    strokeAlpha: number;
+    lineWidth: number;
+    activeSMask: null;
+    transferMaps: string;
+    ctxMatrix: THREE.Matrix3;
+    fontDirection?: number;
+    font?: any;
+    clipBox: number[];
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    lineCap: number;
+    lineJoin: number;
+    miterLimit: number;
+    constructor(width: number, height: number);
+    clone(): any;
+    setCurrentPoint(x: number, y: number): void;
+    startNewPathAndClipBox(box: number[]): void;
+    updatePathMinMax(transform: number[], x: number, y: number): void;
+    getPathBoundingBox(pathType?: string, transform?: null): number[];
+    updateRectMinMax(transform: number[], rect: any): void;
+    updateScalingPathMinMax(transform: number[], minMax: number[]): void;
+    updateCurvePathMinMax(transform: number[], x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, minMax: number[]): void;
+    updateClipFromPath(): void;
+    isEmptyClip(): boolean;
+    getClippedPathBoundingBox(pathType?: string, transform?: null): number[];
+}
+export {};

package/dist/types/pdf/PdfLoaderPlugin.d.ts

@@ -0,0 +1,47 @@
+import { THREE, BaseViewer, Model2dConfig, FontManager, Plugin, PluginConfig, Model2d } from "@x-viewer/core";
+import { PdfLoader } from "./PdfLoader";
+/**
+ * Pdf loader plugin config.
+ */
+export interface PdfLoaderPluginConfig extends Partial<PluginConfig> {
+    font?: FontManager;
+    /**
+     * Whether to use progressive load or not.
+     * @default true
+     */
+    enableProgressiveLoad?: boolean;
+    pdfWorker: string;
+}
+/**
+ * Pdf loader plugin.
+ */
+export declare class PdfLoaderPlugin extends Plugin {
+    static readonly DEFAULT_ID = "PdfLoaderPlugin";
+    protected cfg: PdfLoaderPluginConfig;
+    loader?: PdfLoader;
+    constructor(viewer: BaseViewer, cfg: PdfLoaderPluginConfig);
+    /**
+     * Loads a pdf.
+     * @param modelCfg
+     * @param onProgress
+     * @returns
+     */
+    loadAsync(modelCfg: Model2dConfig, onProgress: (event: ProgressEvent) => void): Promise<Model2d>;
+    /**
+     *
+     * @param page
+     * @param onProgress
+     * @returns
+     * @description load specified pdf page
+     */
+    loadPage(page: number, onProgress?: (event: ProgressEvent) => void): Promise<undefined>;
+    /**
+     *
+     * @returns {Number}
+     * @description Get pdf pages number.
+     */
+    getPageCount(): number;
+    private getPdfViewport;
+    worldPosition2PdfPoint(position: THREE.Vector2): THREE.Vector2;
+    pdfPoint2WorldPosition(point: THREE.Vector2): THREE.Vector2;
+}

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

@@ -0,0 +1,2 @@
+export * from "./PdfLoader";
+export * from "./PdfLoaderPlugin";

package/dist/types/property/Locale.d.ts

@@ -0,0 +1,8 @@
+import { i18next } from "@x-viewer/core";
+export declare const en: {
+    property: string;
+};
+export declare const cn: {
+    property: string;
+};
+export declare const i18n: i18next.i18n;

package/dist/types/property/PropertyPlugin.d.ts

@@ -0,0 +1,76 @@
+import { Viewer3d, Plugin, PluginConfig, THREE } from "@x-viewer/core";
+import { BasePanel } from "@x-viewer/ui";
+/**
+ * Tree view plugin config.
+ */
+export interface PropertyPluginConfig extends Partial<PluginConfig> {
+    /**
+     * Container div id.
+     */
+    containerId?: string;
+    /**
+     * If panel is visible. It is visible by default.
+     */
+    visible?: boolean;
+    language?: "cn" | "en";
+}
+/**
+ * Tree view plugin events.
+ */
+type PropertyPluginEvents = {
+    /**
+     * Panel visibility change event.
+     */
+    visibilitychange: boolean;
+};
+/**
+ * Tree view plugin.
+ */
+export declare class PropertyPlugin extends Plugin<PropertyPluginEvents> {
+    static readonly DEFAULT_ID = "PropertyPlugin";
+    protected cfg: PropertyPluginConfig;
+    protected basePanel?: BasePanel;
+    protected container?: HTMLDivElement;
+    protected content?: HTMLDivElement;
+    protected details?: HTMLDivElement;
+    protected selectedObject: THREE.Object3D | undefined;
+    protected lastActiveTabIdx: number;
+    protected nodePanel?: HTMLDivElement;
+    protected nodeModeButtons?: {
+        local: HTMLButtonElement;
+        global: HTMLButtonElement;
+    };
+    protected nodeInputs?: {
+        translation: HTMLInputElement[];
+        rotation: HTMLInputElement[];
+        scale: HTMLInputElement[];
+    };
+    protected geometrySection?: HTMLDivElement;
+    protected boundingBoxSection?: HTMLDivElement;
+    constructor(viewer: Viewer3d, cfg?: PropertyPluginConfig);
+    protected updateContent(): void;
+    private initLocalization;
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    protected onObjectSelected: () => void;
+    protected onObjectDeselected: () => void;
+    private onClose;
+    destroy(): void;
+    protected addContent(): void;
+    private isMaterialTabEnabled;
+    private isNodeTabEnabled;
+    private isPropertyTabEnabled;
+    renderTab(idx: number): void;
+    private clearDetails;
+    private renderMaterial;
+    private renderNode;
+    protected updateNodeInputs(target: THREE.Object3D): void;
+    protected applyNodeInputs(target: THREE.Object3D): void;
+    private updateGeometryInfo;
+    private updateBoundingBoxInfo;
+    private getVertexCount;
+    private getTriangleCount;
+    private getGlobalSize;
+    private renderProperty;
+}
+export {};

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

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

package/dist/types/screenshot/ScreenshotPlugin.d.ts

@@ -0,0 +1,153 @@
+import { THREE } from "@x-viewer/core";
+import { type BaseViewer, BoxSelectHelper, PickMarkupHelper, Plugin, PluginConfig } from "@x-viewer/core";
+/**
+ * Screenshot mode.
+ */
+export declare enum ScreenshotMode {
+    /**
+     * Take screenshot of the whole canvas.
+     */
+    Default = "Default",
+    /**
+     * Take screenshot by box selecting an area.
+     */
+    BoxSelection = "BoxSelection",
+    /**
+     * Take screenshot by picking a markup.
+     */
+    PickMarkup = "PickMarkup"
+}
+/**
+ * Screenshot plugin config.
+ */
+export interface ScreenshotPluginConfig extends Partial<PluginConfig> {
+    /**
+     * Image type.
+     */
+    type?: "image/png" | "image/jpg";
+    /**
+     * Image quality.
+     */
+    quality?: number;
+    /**
+     * Sets background transparent, this must be used for "image/png" format.
+     * @default false
+     * @internal
+     */
+    setBackgroundTransparent?: boolean;
+}
+/**
+ * Screenshot result, which contains a result image and,
+ * for Viewer2d, it also contains the view extent when the screenshot is taken,
+ * for Viewer3d, it contains the camera's position and target.
+ */
+export interface ScreenshotResult {
+    /**
+     * The view extent when the screenshot is taken.
+     * Note that, it is not the image's extent.
+     * And, this is for Viewer2d only.
+     */
+    viewExtent?: THREE.Box2;
+    /**
+     * Used for Viewer3d
+     * @internal
+     */
+    /**
+     * Used for Viewer3d
+     * @internal
+     */
+    /**
+     * Image type, which is "image/png" by default
+     * @internal
+     */
+    imageType: string;
+    /**
+     * The image, in base 64 format.
+     */
+    base64Image: string;
+}
+/**
+ * Screenshot plugin
+ */
+export declare class ScreenshotPlugin extends Plugin {
+    static readonly DEFAULT_ID = "ScreenshotPlugin";
+    protected cfg: ScreenshotPluginConfig;
+    protected boxSelectHelper?: BoxSelectHelper;
+    protected pickMarkupHelper?: PickMarkupHelper;
+    protected originalBackground: THREE.Color | undefined;
+    protected originalClearAlpha: number;
+    constructor(viewer: BaseViewer, cfg?: ScreenshotPluginConfig);
+    /**
+     * @description {en} Gets screenshot of current canvas. Returns an image in format of base64 string.
+     * @description {zh} 获取画布的截屏。该方法返回一个 base64 类型的字符串。
+     * @example
+     * ``` typescript
+     * const plugin = new ScreenshotPlugin(viewer);
+     * const base64Image = plugin.getScreenshot();
+     * console.log(base64Image);
+     * ```
+     */
+    getScreenshot(): string | undefined;
+    /**
+     * Gets screenshot by bbox under screen cooridinate.
+     */
+    getScreenshotByScreenBBox(bbox: THREE.Box2): Promise<string | undefined>;
+    /**
+     * Gets screenshot by bbox under world coordinate.
+     * It needs to convert world to screen coordinate, in order to get the
+     * screenshot range. Assume it maps to bboxA under screen coordinate,
+     * and current view boundary is bboxB (e.g., 0,0 - 1024,768).
+     * Since, a given world coordinate may not be in current view boundary.
+     * The finally screenshot is the overlap of bboxA and bboxB. When
+     * - bboxA includes bboxB, it get screenshot for bboxB
+     * - bboxB includes bboxA, it get screenshot for bboxA
+     * - bboxA overlaps with bboxB, it get screenshot for the overlapped area
+     * - bboxA doesn't overlap with bboxB, it get nothing
+     *
+     * A best practice to use this API is to use orthographic camera, under top view,
+     * and pass in viewer's bbox.
+     */
+    getScreenshotByWorldBBox(bbox: THREE.Box3): Promise<string | undefined>;
+    /**
+     * @description {en} Gets screenshot of a rectangular area, or by box selecting an area. Returns an image in format of base64 string.
+     * @description {zh} 获取矩形区域或者框选区域的截图。返回base64格式的图片。
+     * @param mode
+     * - {en} screenshot mode("Default", "BoxSelection" and "PickMarkup").
+     * - {zh} 截图模式("全屏"， "框选" 和 "选中批注")。
+     * @example
+     * ``` typescript
+     * // {en} Click on markup to take screenshot.
+     * // {zh} 点击批注截屏。
+     * const mode = ScreenshotMode.PickMarkup;
+     * viewer.getScreenshot(mode).then(data => console.log(data));
+     * // {en} Take screenshot by box selecting an area.
+     * // {zh} 根据用户的框选截屏。
+     * const mode = ScreenshotMode.BoxSelection;
+     * viewer.getScreenshot(mode).then(data => console.log(data));
+     * // {en} Take screenshot of the whole view.
+     * // {zh} 全屏截屏。
+     * const mode = ScreenshotMode.Default;
+     * const plugin = new ScreenshotPlugin(viewer);
+     * plugin.getScreenshotAsync(mode).then(data => console.log(data));
+     * ```
+     */
+    getScreenshotAsync(mode?: ScreenshotMode): Promise<undefined | ScreenshotResult>;
+    /**
+     * If ScreenshotPlugin is active.
+     */
+    isActive(): (() => boolean) | undefined;
+    /**
+     * Cancel current operation if any.
+     */
+    cancel(): void;
+    /**
+     * Sets scene background transparent.
+     * This is useful when taking screenshop of png format.
+     * In some cases, user don't want the background with a fixed background color.
+     */
+    private setBackgroundTransparent;
+    /**
+     * Recovers to original background settings.
+     */
+    private recoverBackgroundTransparency;
+}

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

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

package/dist/types/sections/AxisPlaneSection.d.ts

@@ -0,0 +1,63 @@
+import { THREE } from "@x-viewer/core";
+import { EventInfo, InputManager, type BaseViewer } from "@x-viewer/core";
+import { BaseSection } from "./BaseSection";
+import { SectionGizmo } from "../sections/SectionGizmo";
+import { SectionPlaneMesh } from "../sections/SectionPlaneMesh";
+export declare enum AxisType {
+    X = "X",
+    Y = "Y",
+    Z = "Z"
+}
+export declare class AxisPlaneSection extends BaseSection {
+    protected activeAxis: AxisType;
+    protected gizmo?: SectionGizmo;
+    protected planeMesh?: SectionPlaneMesh;
+    protected capsWireframe?: SectionPlaneMesh;
+    protected clipPlane?: THREE.Plane;
+    protected selectedObject?: SectionPlaneMesh | THREE.Mesh | THREE.Object3D;
+    protected axisInfoMap: {
+        [key in AxisType]: {
+            normal: THREE.Vector3;
+        };
+    };
+    protected center: THREE.Vector3;
+    protected clipPlaneConstant?: number;
+    constructor(viewer: BaseViewer, input: InputManager);
+    /**
+     * Activates plane section.
+     * @param type Specifies the axis for sectioning. The default value is "X" axis.
+     * @param clipPlaneConstant It decides where the clip plane is. By default, the clip plane passes through
+     * the center of world bounding box. Caller can specify a different position.
+     * E.g., when type is "X" and clipPlaneConstant is 10, it means the clip plane passes through (10, 0, 0).
+     */
+    activate(type?: AxisType, clipPlaneConstant?: number): void;
+    deactivate(keepSectionState?: boolean): void;
+    reset(): void;
+    /**
+     * Sets a AxisType for plane section.
+     * @param type Specifies the axis for sectioning.
+     * @param clipPlaneConstant It decides where the clip plane is. By default, the clip plane passes through
+     * the center of world bounding box. Caller can specify a different position.
+     * E.g., when type is "X" and clipPlaneConstant is 10, it means the clip plane passes through (10, 0, 0).
+     */
+    setActiveAxis(type: AxisType, clipPlaneConstant?: number): void;
+    /**
+     * Sets gizmo and section plane mesh visibility.
+     */
+    setSectionPlaneVisible(visible: boolean): void;
+    protected initOrUpdateClipPlanes(): void;
+    protected initOrUpdateSectionPlaneMeshes(): void;
+    private createCapsWireframe;
+    protected initOrUpdateGizmo(): void;
+    mousedown: (e: EventInfo) => void;
+    protected mousemove: (e: EventInfo) => void;
+    onDragStart(e: EventInfo): void;
+    onDragMove(e: EventInfo): void;
+    onDragEnd(e: EventInfo): void;
+    getIntersectObjects(): THREE.Object3D[];
+    activateSelectedObject(active: boolean): void;
+    /**
+     * Adjusts a position by activeAxis and clipPlaneConstant.
+     */
+    private adjustPositionByClipPlaneConstant;
+}

package/dist/types/sections/AxisSectionPopPanel.d.ts

@@ -0,0 +1,18 @@
+import { type BaseViewer } from "@x-viewer/core";
+import { PopPanel } from "@x-viewer/ui";
+import { AxisPlaneSection } from "./AxisPlaneSection";
+export declare class AxisSectionPopPanel extends PopPanel {
+    protected axis: string;
+    protected activeItem?: string;
+    protected groupSelectNode?: HTMLElement;
+    protected activeSelectNode?: HTMLElement;
+    protected isVisible: boolean;
+    protected section: AxisPlaneSection;
+    constructor(viewer: BaseViewer);
+    keydown: (e: KeyboardEvent) => void;
+    destroy(): void;
+    createGroupSelectLayout(): void;
+    addGroupSelectItems(): void;
+    createActiveSelectLayout(): void;
+    addActiveItems(): void;
+}

package/dist/types/sections/BaseSection.d.ts

@@ -0,0 +1,61 @@
+import { THREE } from "@x-viewer/core";
+import { EventInfo, InputManager, type BaseViewer } from "@x-viewer/core";
+/**
+ * Abstract base class for AxisPlaneSection, ObjectsBoxSection, etc.
+ */
+export declare abstract class BaseSection {
+    protected viewer: BaseViewer;
+    protected inputManager: InputManager;
+    protected scene: THREE.Scene;
+    protected renderer: THREE.WebGLRenderer;
+    protected raycaster: THREE.Raycaster;
+    protected sectionBox: THREE.Box3;
+    protected lastWorldPos: THREE.Vector3;
+    protected mouseMoved: boolean;
+    protected dragStarted: boolean;
+    protected clipPlanes?: THREE.Plane[];
+    protected vertices?: THREE.Vector3[];
+    protected selectedObject?: THREE.Object3D;
+    protected refrencePlane: THREE.Plane;
+    protected active: boolean;
+    protected capsVisibility: boolean;
+    protected capsWireframeMaterial: THREE.MeshBasicMaterial;
+    /**
+     * If to show section plane and gizmo or not.
+     */
+    showSectionPlane: boolean;
+    capsScene: THREE.Scene;
+    /**
+     * @internal
+     */
+    clippingObjetIds?: number[];
+    constructor(viewer: BaseViewer, input: InputManager);
+    protected get canvas(): HTMLCanvasElement;
+    get isActive(): boolean;
+    protected get camera(): THREE.Camera;
+    private setGlobalClippingEnabled;
+    private setObjectClippingEnabled;
+    clearClippingObjectIds(): void;
+    setClippingEnabled(enable: boolean): void;
+    activate(): void;
+    deactivate(keepSectionState?: boolean): void;
+    setCapsVisible(visible: boolean): void;
+    getCapsVisible(): boolean;
+    protected setControlsEnabled(enable: boolean): void;
+    protected mousedown: (e: EventInfo) => void;
+    protected mousemove: (e: EventInfo) => void;
+    protected mouseup: (e: EventInfo) => void;
+    protected keydown: (e: EventInfo) => void;
+    protected getIntersection(e: EventInfo): THREE.Intersection | undefined;
+    protected updateRaycasterByMouse(e: EventInfo): void;
+    destroy(): void;
+    protected abstract onDragStart(e: EventInfo): void;
+    protected abstract onDragMove(e: EventInfo): void;
+    protected abstract onDragEnd(e: EventInfo): void;
+    protected abstract getIntersectObjects(): THREE.Object3D[];
+    protected abstract activateSelectedObject(active: boolean): void;
+    protected abstract initOrUpdateSectionPlaneMeshes(): void;
+    protected abstract initOrUpdateClipPlanes(): void;
+    abstract reset(): void;
+    abstract setSectionPlaneVisible(visible: boolean): void;
+}