@x-viewer/core 0.9.0

package/dist/types/core/input-manager/InputManager.d.ts

@@ -0,0 +1,147 @@
+import { Event } from "../../core/utils";
+export type NativeEvent = UIEvent | MouseEvent | PointerEvent | WheelEvent | KeyboardEvent;
+export interface IUIEvent {
+    readonly type: string;
+    readonly target: any;
+    readonly preventDefault: () => void;
+}
+export interface IMouseEvent extends IUIEvent {
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly shiftKey: boolean;
+    readonly button: number;
+    readonly clientX: number;
+    readonly clientY: number;
+    readonly pageX: number;
+    readonly pageY: number;
+    readonly x: number;
+    readonly y: number;
+    readonly timestamp: number;
+}
+export interface IPointerEvent extends IMouseEvent {
+    readonly pointerId: number;
+    readonly pointerType: string;
+}
+export interface IWheelEvent extends IMouseEvent {
+    readonly deltaMode: number;
+    readonly deltaX: number;
+    readonly deltaY: number;
+    readonly deltaZ: number;
+}
+export interface IKeyboardEvent extends IUIEvent {
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly shiftKey: boolean;
+    readonly key: string;
+    readonly code: string;
+}
+export declare enum MouseButton {
+    /** Left Click or Touch */
+    Left = 0,
+    /** Middle Click */
+    Middle = 1,
+    /** Right Click */
+    Right = 2,
+    /** Browser Back */
+    Back = 3,
+    /** Browser Forward */
+    Forward = 4
+}
+type MouseButtonType = MouseButton;
+/**
+ * Event info.
+ */
+export interface EventInfo {
+    x: number;
+    y: number;
+    pageX: number;
+    pageY: number;
+    clientX: number;
+    clientY: number;
+    deltaMode: number;
+    deltaX: number;
+    deltaY: number;
+    movementX: number;
+    movementY: number;
+    code?: string;
+    pointerId: number;
+    pointers?: EventInfo[];
+    button?: MouseButtonType;
+    buttons: MouseButtonType;
+    pointerType: string;
+    key?: string;
+    altKey: boolean;
+    ctrlKey: boolean;
+    shiftKey: boolean;
+    metaKey: boolean;
+    timestamp: number;
+    originalEvent?: NativeEvent;
+}
+/**
+ * Input events.
+ */
+export type InputEvents = {
+    pointerdown: EventInfo;
+    pointermove: EventInfo;
+    pointerup: EventInfo;
+    pointercancel: EventInfo;
+    pointerenter: EventInfo;
+    pointerleave: EventInfo;
+    wheel: EventInfo;
+    click: EventInfo;
+    dblclick: EventInfo;
+    contextmenu: EventInfo;
+    mousedown: EventInfo;
+    mousemove: EventInfo;
+    mouseup: EventInfo;
+    touchstart: EventInfo;
+    touchmove: EventInfo;
+    touchend: EventInfo;
+    keydown: EventInfo;
+    keyup: EventInfo;
+    resize: EventInfo;
+};
+export declare class InputManager extends Event<InputEvents> {
+    private element;
+    private enabled;
+    private keyboardEnabled;
+    protected mouseDownPositionX: number;
+    protected mouseDownPositionY: number;
+    protected lastLeftPointerUpTime: number;
+    private pointers;
+    constructor(element: HTMLElement);
+    getEnabled(): boolean;
+    setEnabled(enable: boolean): void;
+    getkKeyboardEnabled(): boolean;
+    setkKeyboardEnabled(enable: boolean): void;
+    setCursor(cursorStyle: string): void;
+    bindEvents(): void;
+    private handleClick;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handlePointerCancel;
+    private handleMouseWheel;
+    private handleContextMenu;
+    private handlePointerEnter;
+    private handlePointerLeave;
+    private handleResize;
+    private handleKeydown;
+    private handleKeyup;
+    unBindEvents(): void;
+    private getBaseEvent;
+    private stop;
+    private updatePointers;
+    private removePointers;
+    style: {};
+    getBoundingClientRect(): DOMRect;
+    /**
+     * Checks if user clicked on last position, this is used to detect a dblclick event.
+     */
+    private isCloseToLastPosition;
+    /**
+     * Checks if a dblclick event happen.
+     */
+    private isDoubleClick;
+}
+export {};

package/dist/types/core/input-manager/index.d.ts

@@ -0,0 +1 @@
+export { InputManager, InputEvents as InputEvent, MouseButton, EventInfo } from "./InputManager";

package/dist/types/core/interactions/Interaction.d.ts

@@ -0,0 +1,10 @@
+import type { BaseViewer } from "../../core/viewers/BaseViewer";
+export declare class Interaction {
+    protected viewer: BaseViewer;
+    private _events;
+    constructor(viewer: BaseViewer);
+    addEvents(events: string[]): void;
+    removeEvents(events: string[]): void;
+    destroy(): void;
+    clearSelection(): void;
+}

package/dist/types/core/interactions/Viewer2dInteraction.d.ts

@@ -0,0 +1,17 @@
+import { Object3D } from "three";
+import { Interaction } from "./Interaction";
+import { Drawable } from "../../core/canvas/Drawable";
+import type { Viewer2d } from "../../core/viewers/Viewer2d";
+export declare class Viewer2dInteraction extends Interaction {
+    private mouseDown;
+    private mouseMoved;
+    private inputManager;
+    selectedObject?: Object3D | Drawable;
+    constructor(viewer: Viewer2d);
+    private handle_pointerdown;
+    private handle_pointermove;
+    private handle_pointerup;
+    private handleMouseClick;
+    destroy(): void;
+    clearSelection(): void;
+}

package/dist/types/core/interactions/Viewer3dInteraction.d.ts

@@ -0,0 +1,26 @@
+import { Object3D } from "three";
+import { Interaction } from "./Interaction";
+import { BaseViewer } from "../viewers/BaseViewer";
+import { Drawable } from "../../core/canvas/Drawable";
+export declare class Viewer3dInteraction extends Interaction {
+    private mouseMoved;
+    private mouseButtonPressed;
+    private lastLeftPointerUpTime;
+    private mouseDownPositionX;
+    private mouseDownPositionY;
+    private currentIntersection;
+    private isSelected;
+    selectedObject?: Object3D | Drawable;
+    constructor(viewer: BaseViewer);
+    private onObjectSelected;
+    private onObjectDeselected;
+    private isCloseToLastPosition;
+    private isDoubleClick;
+    private handle_pointerdown;
+    private handle_pointermove;
+    private handle_pointerup;
+    private handleClickObject;
+    private handleAnchorPoint;
+    destroy(): void;
+    clearSelection(): void;
+}

package/dist/types/core/interactions/index.d.ts

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

package/dist/types/core/materials/BimTilesHighlightMaterial.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from "three";
+import { BimTilesMaterialParameters } from "./BimTilesMaterial";
+/**
+ * Material used for highlighting objects.
+ */
+export declare class BimTilesHighlightMaterial extends THREE.MeshStandardMaterial {
+    isBimTilesHighlightMaterial: boolean;
+    type: string;
+    transparent: boolean;
+    opacity: number;
+    depthTest: boolean;
+    side: 2;
+    uniforms: {
+        [uniform: string]: THREE.IUniform<any>;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+    stateTexture: THREE.DataTexture;
+    constructor(params: BimTilesMaterialParameters);
+    setValues(params: BimTilesMaterialParameters): void;
+}

package/dist/types/core/materials/BimTilesMaterial.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from "three";
+import { MeshStandardMaterialParameters } from "three";
+export interface BimTilesMaterialParameters extends MeshStandardMaterialParameters {
+    stateTexture: THREE.DataTexture;
+}
+/**
+ * Customized material used by bimtiles.
+ */
+export declare class BimTilesMaterial extends THREE.MeshStandardMaterial {
+    isBimTilesMaterial: boolean;
+    type: string;
+    uniforms: {
+        [uniform: string]: THREE.IUniform<any>;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+    stateTexture: THREE.DataTexture;
+    readonly defaultOutlineColor: THREE.Color;
+    protected useBCOutline: boolean;
+    protected outlineVisible: boolean;
+    constructor(params: BimTilesMaterialParameters);
+    setOutlineVisible(visible: boolean): void;
+    enableOutline(enable: boolean): void;
+    setOutLineColor(color?: THREE.Color): void;
+    setValues(params: BimTilesMaterialParameters): void;
+}

package/dist/types/core/materials/BimTilesPickMaterial.d.ts

@@ -0,0 +1,9 @@
+import * as THREE from "three";
+import { BimTilesMaterialParameters } from "./BimTilesMaterial";
+export declare class BimTilesPickMaterial extends THREE.ShaderMaterial {
+    isBimTilesPickMaterial: boolean;
+    type: string;
+    stateTexture: THREE.DataTexture;
+    constructor(params: BimTilesMaterialParameters);
+    setValues(params: BimTilesMaterialParameters): void;
+}

package/dist/types/core/materials/BimTilesTransparentMaterial.d.ts

@@ -0,0 +1,20 @@
+import * as THREE from "three";
+import { BimTilesMaterialParameters } from "./BimTilesMaterial";
+/**
+ * Material used for transparent objects.
+ */
+export declare class BimTilesTransparentMaterial extends THREE.MeshStandardMaterial {
+    isBimTilesTransparentMaterial: boolean;
+    type: string;
+    transparent: boolean;
+    opacity: number;
+    side: 0;
+    uniforms: {
+        [uniform: string]: THREE.IUniform<any>;
+    };
+    vertexShader: string;
+    fragmentShader: string;
+    stateTexture: THREE.DataTexture;
+    constructor(params: BimTilesMaterialParameters);
+    setValues(params: BimTilesMaterialParameters): void;
+}

package/dist/types/core/materials/StandardMaterialEx.d.ts

@@ -0,0 +1,16 @@
+import * as THREE from "three";
+export declare class StandardMaterialEx extends THREE.MeshStandardMaterial {
+    isStandardMaterialEx: boolean;
+    useBCOutline: boolean;
+    outlineVisible: boolean;
+    outlineColor: THREE.Color;
+    uniforms: Record<string, any>;
+    vertexShader: string;
+    fragmentShader: string;
+    useForCap: boolean;
+    constructor(params?: any);
+    refreshUniforms(): void;
+    setOutlineVisible(visible: boolean): void;
+    setOutLineColor(color?: THREE.Color): void;
+    copy(source: any): this;
+}

package/dist/types/core/materials/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./StandardMaterialEx";
+export * from "./BimTilesMaterial";
+export * from "./BimTilesPickMaterial";
+export * from "./BimTilesHighlightMaterial";
+export * from "./BimTilesTransparentMaterial";

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

@@ -0,0 +1,58 @@
+import * as THREE from "three";
+import type { DxfData } from "../../core/dxf";
+import type { PdfData } from "../../core/viewers";
+/**
+ * Loaded 3d model info for Viewer3d.
+ */
+export interface ModelData3d {
+    /**
+     * modelId that is unique for loaded models
+     */
+    modelId: string;
+    /**
+     * Three.js object.
+     */
+    object?: THREE.Object3D;
+    /**
+     * Bounding box of the model.
+     */
+    bbox?: THREE.Box3;
+    /**
+     * Edge objects of the model.
+     */
+    edges?: THREE.LineSegments[];
+    /**
+     * TilesRenderer for BimTiles
+     * @internal
+     */
+    tilesRenderer?: any;
+}
+/**
+ * Loaded 2d model info for Viewer2d.
+ */
+export interface ModelData2d {
+    /**
+     * modelId that is unique for loaded models
+     */
+    modelId: string;
+    /**
+     * Used for dxf data.
+     */
+    dxfData?: DxfData;
+    /**
+     * Used for pdf data.
+     */
+    pdfData?: PdfData;
+    /**
+     * Model space transform matrix.
+     * @internal
+     */
+    msTransformMatrix?: THREE.Matrix4;
+}
+/**
+ * BimTile object.
+ */
+export interface TileObject {
+    tilesetId: number;
+    userId: number;
+}

package/dist/types/core/model/Model.d.ts

@@ -0,0 +1,18 @@
+import * as THREE from "three";
+/**
+ * Base model class.
+ */
+export declare abstract class Model {
+    /**
+     * The model id, it should be unique in the lifecycle of a viewer.
+     */
+    abstract modelId: string;
+    /**
+     * Gets the THREE.Object3D of this model.
+     */
+    abstract getModelObject(): THREE.Object3D;
+    /**
+     * Gets the bounding box of this model.
+     */
+    abstract getBBox(): THREE.Box3;
+}

package/dist/types/core/model/Model2d.d.ts

@@ -0,0 +1,142 @@
+import * as THREE from "three";
+import { ModelData2d } from "./Constants";
+import { Units } from "../../core/Units";
+import { DxfData } from "../../core/dxf";
+import { ILayer, ILayoutObject, IPoint, IViewport, IViewportEntity } from "../../core/dxf-parser";
+import { Model } from "../../core/model/Model";
+import type { PdfData, PdfLayer } from "../../core/viewers/Viewer2d";
+/**
+ * Loaded 2d model info for Viewer2d.
+ */
+export declare class Model2d extends Model {
+    modelId: string;
+    private modelData;
+    modelObject: THREE.Object3D;
+    private bbox?;
+    constructor(modelData: ModelData2d);
+    get pdfData(): PdfData | undefined;
+    get dxfData(): DxfData | undefined;
+    /**
+     * @internal
+     */
+    get msTransformMatrix(): THREE.Matrix4 | undefined;
+    /**
+     * @internal
+     */
+    set msTransformMatrix(matrix: THREE.Matrix4 | undefined);
+    /**
+     * @internal
+     */
+    get loadedEntityCount(): number;
+    /**
+     * Gets dxf data header.
+     */
+    get header(): Record<string, string | number | IPoint> | undefined;
+    /**
+     * Gets dxf data viewports.
+     */
+    get viewports(): IViewport[] | undefined;
+    /**
+     * Gets layers.
+     */
+    get layers(): Record<string, ILayer | PdfLayer> | undefined;
+    /**
+     * Gets dxf data layoutViewportsMap.
+     * @internal
+     */
+    get layoutViewportsMap(): Record<string, IViewportEntity[]> | undefined;
+    /**
+     * Gets three.js object of the model.
+     */
+    getModelObject(): THREE.Object3D;
+    /**
+     * Gets model bounding box.
+     */
+    getBBox(): THREE.Box3;
+    /**
+     * Gets dxf units.
+     * @internal
+     */
+    getUnits(): Units;
+    /**
+     * Gets dxf model space extent.
+     * @internal
+     */
+    getModelSpaceExtent(): THREE.Box3 | undefined;
+    /**
+     * Gets layer by layer name.
+     */
+    getLayer(layerName: string): ILayer | PdfLayer | undefined;
+    /**
+     * Gets layer object and three.js object by layer name.
+     */
+    getObjectsByLayer(layerName: string): THREE.Object3D[] | undefined;
+    /**
+     * Gets layout of dxf data.
+     */
+    getLayouts(): ILayoutObject[];
+    getLayoutByName(layoutName: string): ILayoutObject | undefined;
+    /**
+     * Gets layout extent of dxf data.
+     * @internal
+     */
+    getLayoutExtent(layout: ILayoutObject): THREE.Box3;
+    /**
+     * Gets layout viewports.
+     * @internal
+     */
+    getLayoutViewports(layout: ILayoutObject): IViewportEntity[];
+    /**
+     * Gets the layout level three.js object.
+     */
+    getLayoutLevelObject(layoutName: string): THREE.Object3D | undefined;
+    /**
+     * Sets model visibility.
+     */
+    setVisible(visible: boolean): void;
+    /**
+     * Sets layer visibility.
+     */
+    setLayerVisible(layerName: string, visible: boolean, enableHideVisuallySmallObjects?: boolean, cameraZoom?: number): void;
+    /**
+     * Sets layer opacity.
+     */
+    setLayerOpacity(layerName: string, opacity: number): void;
+    /**
+     * Sets layer color.
+     */
+    setLayerColor(layerName: string, color: number): void;
+    /**
+     * Resets layer color.
+     */
+    resetLayerColor(layerName: string): void;
+    /**
+     * @internal
+     */
+    switchTransformMs(layoutName: string): void;
+    activateLayout(layoutName: string | undefined, isLayoutInitialized: boolean): void;
+    getFilteredViewports(layout: ILayoutObject): IViewportEntity[];
+    private generateObjectsByViewport;
+    private setMaterialUniforms;
+    private getObjectsByBoundingBox;
+    /**
+     * Shows objects for given layout, and hide any other layouts.
+     */
+    showLayoutObjects(layoutName: string): void;
+    /**
+     * Checks if a layer is frozen for viewport (VP Freeze)
+     */
+    private isLayerFrozenForViewport;
+    addSpatialFilterSection(object: THREE.Object3D, dxfData: DxfData, bFromViewport?: boolean): void;
+    private findSpatialFilter;
+    private getAnyMaterial;
+    private generateSectionsBySpatialFilter;
+    private hasObject;
+    private hasObjectWithId;
+    /**
+     * Highlights an object.
+     */
+    highlightObject(object: THREE.Object3D): void;
+    unHighlightObject(object: THREE.Object3D): void;
+    clearHighlight(): void;
+}

package/dist/types/core/model/Model3d.d.ts

@@ -0,0 +1,137 @@
+import * as THREE from "three";
+import { ModelData3d } from "./Constants";
+import { Model } from "./Model";
+/**
+ * Loaded 3d model info for Viewer3d.
+ */
+export declare class Model3d extends Model {
+    modelId: string;
+    bbox?: THREE.Box3;
+    /**
+     * Root object that contains normal object, object for highlight, object for transparent, etc.
+     */
+    rootObject: THREE.Group;
+    /**
+     * Normal model object.
+     */
+    modelObject: THREE.Object3D;
+    /**
+     * Object for highlight usage.
+     */
+    highlighUsage: THREE.Group;
+    /**
+     * Object for transparent usage.
+     */
+    transparentUsage: THREE.Group;
+    /**
+     * Each edge object is created under its Mesh object.
+     * These are references of edge objects.
+     */
+    edges?: THREE.Object3D[];
+    /**
+     * Object that is being highlighted.
+     */
+    highlightedObject?: THREE.Object3D;
+    constructor(modelData: ModelData3d);
+    /**
+     * Gets the THREE.Object3D of this model.
+     */
+    getModelObject(): THREE.Object3D;
+    /**
+     * Gets the bounding box of this model.
+     */
+    getBBox(): THREE.Box3;
+    /**
+     * Enables/disables edges.
+     */
+    enableOutline(enable: boolean, onProgress?: (event: ProgressEvent) => void): Promise<void>;
+    /**
+     * Sets object's color.
+     */
+    setObjectColor(object: THREE.Object3D, color: number): void;
+    /**
+     * Sets object's opacity.
+     * TODO: The handling of instances and batches this time is not perfect. For example, the situation of multiple instances or batches was not considered.
+     * Optimization will be carried out in the future.
+     */
+    setObjectOpacity(targetObject: THREE.Object3D, opacity?: number, batchId?: number, instanceId?: number): void;
+    /**
+     * Clears object's opacity.
+     */
+    clearObjectOpacity(object: THREE.Object3D, batchId?: number, instanceId?: number): void;
+    /**
+     * Is object transparent.
+     */
+    isObjectTransparent(object: THREE.Object3D): boolean;
+    /**
+     * Checks if there is any transparent object in 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 model's opacity.
+     */
+    setOpacity(opacity?: number): void;
+    /**
+     * Clears model's opacity.
+     */
+    clearOpacity(): void;
+    /**
+     * Highlights an object.
+     */
+    highlightObjectById(objectId: number, batchId?: number, instanceId?: number): void;
+    /**
+     * Highlights an object.
+     */
+    highlightObject(object: THREE.Object3D, batchId?: number, instanceId?: number): void;
+    /**
+     * Gets highlighted object.
+     */
+    getHighlightedObject(): THREE.Object3D | undefined;
+    /**
+     * If there is highlighted object.
+     */
+    hasHighlightedObject(): boolean;
+    /**
+     * Clears highlight for object(s) if any.
+     */
+    clearHighlight(): void;
+    setDoubleSidedMaterials(): void;
+    revertDoubleSidedMaterials(): void;
+    /**
+     * Sets an object's visibility.
+     */
+    setObjectVisible(object: THREE.Object3D, visible: boolean): void;
+    /**
+     * Sets model's visibility.
+     */
+    setVisible(visible: boolean): void;
+    /**
+     * Checks if there is any visible object.
+     */
+    hasVisibleObject(): boolean;
+    /**
+     * Checks if there is any invisible object.
+     */
+    hasInvisibleObject(): boolean;
+    private createBatchMeshById;
+    private createInstanceMeshById;
+    setClipPlanes(clippingPlanes: THREE.Plane[]): void;
+    /**
+     * @internal
+     */
+    getObjectTree(): void;
+    /**
+     * If current Model3d contains target object.
+     */
+    hasObject(object: THREE.Object3D): boolean;
+    /**
+     * If current Model3d contains target object.
+     */
+    hasObjectWithId(id: number): THREE.Object3D<THREE.Object3DEventMap> | undefined;
+    /**
+     * Generates "uv1" for all meshes in this model. "uv1" is useful for lightmap.
+     */
+    generateSmartUv1(): void;
+}