@x-viewer/core 0.9.0

package/dist/types/core/helpers/BinaryReader.d.ts

@@ -0,0 +1,23 @@
+export declare class BinaryReader {
+    private endian;
+    private position;
+    private data;
+    private decoder;
+    constructor(arraybuffer: ArrayBuffer, endian?: string);
+    readAsciiString(length: number): string;
+    readUtf8String(length: number): string;
+    readBytes(length?: number): Uint8Array;
+    readUint8(): number;
+    readInt8(): number;
+    readUint16(): number;
+    readInt16(): number;
+    readUint32(): number;
+    readInt32(): number;
+    readFloat32(): number;
+    readFloat64(): number;
+    readInt64(): number;
+    readUint64(): number;
+    getPosition(): number;
+    setPosition(position: number): void;
+    isEnd(): boolean;
+}

package/dist/types/core/helpers/BoxSelectHelper.d.ts

@@ -0,0 +1,44 @@
+import * as THREE from "three";
+import { Tooltip } from "../../components/tool-tip";
+import { mouseButtonAction, singleTouchAction } from "../../core/camera-controls/types";
+import type { EventInfo, InputManager } from "../../core/input-manager/InputManager";
+import type { BaseViewer } from "../../core/viewers";
+/**
+ * Box select an area in screen coordinate.
+ * @internal
+ */
+export declare class BoxSelectHelper {
+    static readonly BORDER_COLOR = "#fff000";
+    static readonly BORDER_WIDTH = "2px";
+    protected viewer: BaseViewer;
+    protected input: InputManager;
+    protected mouseDown: boolean;
+    protected mouseMove: boolean;
+    protected mouseDownPositionX: number;
+    protected mouseDownPositionY: number;
+    protected tempKey?: mouseButtonAction;
+    protected tempTouch?: singleTouchAction;
+    protected tempEnableRotate: boolean;
+    protected rectDom?: HTMLDivElement;
+    protected tooltip?: Tooltip;
+    private active;
+    protected resolve?: (value: THREE.Box2 | PromiseLike<THREE.Box2> | undefined) => void;
+    protected reject?: (reason: any) => void;
+    protected isResolvedOrRejected: boolean;
+    constructor(viewer: BaseViewer);
+    private get viewerContainer();
+    isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    private mousedown;
+    private mousemove;
+    private mouseup;
+    keydown: (e: EventInfo) => void;
+    private drawRect;
+    private setRectDomVisible;
+    /**
+     * Starts to select a box area
+     */
+    select(): Promise<THREE.Box2 | undefined>;
+    destroy(): void;
+}

package/dist/types/core/helpers/InstantiateHelper.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from "three";
+/**
+ * InstantiateHelper class is used to instantiate child objects for a given object
+ * @internal
+ */
+export declare class InstantiateHelper {
+    object: THREE.Object3D;
+    constructor(object: THREE.Object3D);
+    /**
+     * Instatiates child objects for given object.
+     */
+    instantiate(): void;
+    /**
+     * Instatiates child objects of given object.
+     * If objects' geometry and material are the same, they can be instanced.
+     */
+    private instantiateInner;
+    /**
+     * Removes a number from array
+     */
+    removeFromArray(arr: number[], toBeRemoved: number): void;
+    /**
+     * Checks if two geometries equal
+     */
+    private geometryEquals;
+}

package/dist/types/core/helpers/LoadingHelper.d.ts

@@ -0,0 +1,65 @@
+import * as THREE from "three";
+import type { DxfData, DxfLoaderConfig } from "../../core/dxf";
+import type { FontManager } from "../../core/font";
+export declare class LoadingHelper {
+    private static DecoderPath;
+    private static Rhino3dmLibraryPath;
+    private gltfLoader?;
+    private font?;
+    private manager?;
+    constructor(manager?: THREE.LoadingManager);
+    setLoadManager(manager?: THREE.LoadingManager): void;
+    /**
+     * Loads a model from local
+     * @param url Created by URL.createObjectURL(file)
+     * @param src Source filename, used to find out format
+     * @param onProgress On progress callback
+     * @returns Loaded object
+     */
+    loadLocalModel(url: string, src: string, onProgress?: (event: ProgressEvent) => void, mtlUrls?: string[]): Promise<THREE.Object3D>;
+    loadModel(src: string, fileFormat?: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D | void>;
+    loadGltf(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    parseGltf(data: ArrayBuffer | string, path: string, onLoad: (object: THREE.Object3D) => void, onError?: (event: ErrorEvent) => void): void;
+    loadFbx(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    /**
+     *
+     * @param mtlUrls This is only useful when loading obj from local.
+     */
+    loadObj(url: string, onProgress?: (event: ProgressEvent) => void, mtlUrls?: string[]): Promise<THREE.Object3D>;
+    loadStl(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadShp(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadDae(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    /**
+     * Loads rhino 3dm file.
+     */
+    load3dm(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadDxf(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    /**
+     * Loads dxf data, including entities, tables(layers, blocks), etc.
+     * The difference from loadDxf includes
+     *  - It can pass in DxfLoaderConfig.
+     *  - It can read from localCache in case dxfDataId is passed in and enableLocalCache is true.
+     */
+    loadDxfEx(url: string, dxfDataId?: string, onProgress?: (event: ProgressEvent) => void, onLoad?: () => void, cfg?: DxfLoaderConfig): Promise<DxfData>;
+    loadPly(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    /**
+     * It is kind of tricky to load image into scene, but we'll do this by creating a sprite.
+     */
+    loadImage(url: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    /**
+     * Sets font.
+     * Font is required for Viewer2d to view Chinese, etc.
+     */
+    setFont(font: FontManager): void;
+    /**
+     * Sets decoder path for draco loader.
+     * @param path e.g., "libs/draco/gltf/"
+     */
+    static setDracoDecoderPath(path: string): void;
+    /**
+     * Sets decoder path for draco loader.
+     * @param path e.g., "libs/rhino3dm/"
+     */
+    static setRhino3dmLibraryPath(path: string): void;
+    private getGltfLoader;
+}

package/dist/types/core/helpers/MeshBvhHelper.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from "three";
+import { BvhParameter } from "../../core/workers";
+/**
+ * Bvh: Bounding volume hierarchy
+ */
+export declare class MeshBvhHelper {
+    private running;
+    private workers;
+    constructor(workerCount?: number);
+    isRunning(): boolean;
+    generate(geometries: THREE.BufferGeometry[], params?: BvhParameter): Promise<void>;
+    dispose(): void;
+    static createMeshBvhSync(objects: THREE.Object3D[], params?: BvhParameter): void;
+    static createMeshBvhAsync(objects: THREE.Object3D[], params?: BvhParameter): Promise<void>;
+}

package/dist/types/core/helpers/MobileTouchHelperDrawable.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from "three";
+import { Drawable } from "../../core/canvas";
+import { EventInfo } from "../../core/input-manager/InputManager";
+/**
+ * Touch helper for mobile
+ */
+export declare class MobileTouchHelperDrawable extends Drawable {
+    private position;
+    needsFrustumCulled: boolean;
+    renderOrder: number;
+    constructor(position: THREE.Vector2);
+    setPosition(position: THREE.Vector2): void;
+    isPointInPath(p: THREE.Vector3, raycaster?: THREE.Raycaster | undefined): boolean;
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawInnerCircle(ctx: CanvasRenderingContext2D): void;
+    drawOuterRing(ctx: CanvasRenderingContext2D): void;
+    drawSnapTriangle(ctx: CanvasRenderingContext2D): void;
+    translate(tx: number, ty: number): void;
+    getTouchPoint(): {
+        x: number;
+        y: number;
+    };
+    isIntersect(e: EventInfo): boolean;
+    drawSelect(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    getClassType(): string;
+}

package/dist/types/core/helpers/OSnapHelper.d.ts

@@ -0,0 +1,159 @@
+import * as THREE from "three";
+import { CanvasRender, Drawable, DrawableList } from "../../core/canvas";
+import { ILine, OSnapMarkerType } from "../../core/utils";
+export declare class SnapDrawable extends Drawable {
+    static lineColor: string;
+    static readonly FILL_COLOR_NONE = "rgba(0, 0, 0, 0)";
+    static readonly SNAP_LINE_COLOR = "rgba(255, 240, 0, 0.3)";
+    static lineWidth: number;
+    static iconSize: number;
+    needsFrustumCulled: boolean;
+    renderOrder: number;
+    snapType: OSnapMarkerType;
+    private osnapInfo?;
+    private drawSnapFunctions;
+    private snapLineVisible;
+    constructor(type: OSnapMarkerType);
+    setSnapLineVisible(visible: boolean): void;
+    draw(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawDebug(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawSelect(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    isPointInPath(p: THREE.Vector3): boolean;
+    getVertexes(): THREE.Vector3[];
+    drawSnapLine(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    /**
+     *      p1
+     *      |
+     *      | point (origin)
+     *     / \
+     *   /     \
+     *  p2      p3
+     */
+    drawTripleCorss(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawSquare(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawTriangle(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    /**
+     * Snap marker for circle center.
+     */
+    drawCircleWithCross(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    drawCross(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    /**
+     * p4|\
+     *   |  \
+     * p2|____\ p1 (origin)
+     *   |    | \
+     *   |____|___\
+     * P5     p3   P6
+     */
+    drawPerpendicular(ctx: CanvasRenderingContext2D, camera: THREE.Camera): void;
+    update(osnapInfo: OSnapInfo): void;
+    getClassType(): string;
+}
+export declare enum OSnapType {
+    None = 0,
+    Vertex = 1,
+    MiddlePoint = 2,
+    Edge = 4,
+    Face = 8,
+    FootOfPerpendicular = 16,
+    Intersection = 32,
+    CircleCenter = 64
+}
+interface OSnapInfo {
+    point: THREE.Vector3;
+    distance: number;
+    type: OSnapType;
+    line?: ILine;
+}
+export declare class OSnapHelper {
+    protected drawableList: DrawableList;
+    protected overlayRender?: CanvasRender;
+    protected markers: Record<number, SnapDrawable>;
+    protected activeOSnapType: OSnapType;
+    protected snapToleranceInWorldCoord: number;
+    protected intersectionLimit: number;
+    /**
+     * OSnapType priority. Lower value has a higher priority.
+     */
+    osnapTypePriorities: Record<OSnapType, number>;
+    protected enabledOSnapTypes: number;
+    constructor(overlayRender: CanvasRender);
+    private initOSnapMarkers;
+    /**
+     * If a specific OSnapType is enabled.
+     */
+    isOSnapTypeEnabled(type: OSnapType): boolean;
+    /**
+     * Enables a specific OSnapType.
+     */
+    setOSnapTypeEnabled(type: OSnapType, enabled: boolean): void;
+    /**
+     * Sets snap tolerance in world coordinate.
+     */
+    setSnapTolerance(toleranceInWorldCoord: number): void;
+    /**
+     * Gets snap tolerance in world coordinate.
+     */
+    getSnapTolerance(): number;
+    setIntersectionLimit(val: number): void;
+    getIntersectionLimit(): number;
+    /**
+     * Gets osnap marker line color.
+     * @returns rgb/rgba number array, each value is between 0 and 1. e.g. [0.92, 0.95, 0.96].
+     */
+    getMarkerLineColor(): number[];
+    /**
+     * Sets osnap marker line color.
+     * @param color rgb/rgba number array, each value is between 0 and 1. e.g. [0.92, 0.95, 0.96].
+     */
+    setMarkerLineColor(color: number[]): void;
+    /**
+     * Gets osnap marker line width.
+     */
+    getMarkerLineWidth(): number;
+    /**
+     * Sets osnap marker line width.
+     */
+    setMarkerLineWidth(width: number): void;
+    /**
+     * Gets osnap marker icon size in pixel.
+     */
+    getMarkerIconSize(): number;
+    /**
+     * Sets osnap marker icon size in pixel.
+     */
+    setMarkerIconSize(size: number): void;
+    getMarker(type: OSnapType): SnapDrawable;
+    setAllSnapLinesVisible(visible: boolean): void;
+    deactivate(): void;
+    destroy(): void;
+    /**
+     * Tries to find a proper snap point and display corresponding marker.
+     * @param intersections The raycaster intersections, must have been sorted by distance.
+     * @param is3d If it is a 3d or 2d viewer.
+     * @param lastMouseDownPosition Used in order to to get foot of perpendicular.
+     * @returns Target snap point if any
+     */
+    handleSnap(rayCasterResult: THREE.Intersection[], is3d: boolean, lastMouseDownPosition?: THREE.Vector3): THREE.Vector3 | undefined;
+    /**
+     * Tries to find a proper snap point and display corresponding marker.
+     * @param mousePosition Mouse position in world coordinate.
+     * @param intersections
+     * @param is3d If it is a 3d or 2d viewer.
+     * @param lastMouseDownPosition Used in order to to get foot of perpendicular.
+     * @returns Target snap point if any
+     */
+    protected getSnapPointAndUpdateMarker(mousePosition: THREE.Vector3, intersections: THREE.Intersection[], is3d: boolean, lastMouseDownPosition?: THREE.Vector3): THREE.Vector3 | undefined;
+    activateMarker(type: OSnapType, osnapInfo?: OSnapInfo): void;
+    private getFootOfPerpendicular;
+    private getSnapInfo;
+    private getOsnapInfoListFromMesh;
+    private getOsnapInfoFromSegment;
+    private getOsnapInfoListFromLine;
+    private getOsnapInfoListFromPoint;
+    /**
+     * Used for 3d scene to get outline info by faces.
+     */
+    private getIntersectsIncludeOutline;
+}
+export {};

package/dist/types/core/helpers/ObjectPixelSizeHelper.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import CameraControls from "../../core/camera-controls";
+/**
+ * Helper class to adjust object visual size
+ */
+export declare class ObjectPixelSizeHelper {
+    private object;
+    private camera;
+    targetPixelHeight: number;
+    canvasHeight: number;
+    constructor(camera: THREE.Camera, controls: CameraControls, object: THREE.Object3D, targetPixelHeight: number, canvasHeight: number);
+    adjustSize(): void;
+}

package/dist/types/core/helpers/PickMarkupHelper.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from "three";
+import { Tooltip } from "../../components/tool-tip";
+import { EventInfo } from "../../core/input-manager/InputManager";
+import type { BaseViewer } from "../../core/viewers";
+/**
+ * Box select an area in screen coordinate.
+ * @internal
+ */
+export declare class PickMarkupHelper {
+    protected viewer: BaseViewer;
+    private active;
+    protected tooltip?: Tooltip;
+    protected resolve?: (value: THREE.Box2 | PromiseLike<THREE.Box2> | undefined) => void;
+    protected reject?: (reason: any) => void;
+    protected isResolvedOrRejected: boolean;
+    constructor(viewer: BaseViewer);
+    private get viewerContainer();
+    private get camera();
+    isActive(): boolean;
+    private mouseClicked;
+    activate(): void;
+    deactivate(): void;
+    keydown: (e: EventInfo) => void;
+    /**
+     * Starts to pick a markup area.
+     */
+    pick(): Promise<THREE.Box2 | undefined>;
+    destroy(): void;
+}

package/dist/types/core/helpers/RafHelper.d.ts

@@ -0,0 +1,18 @@
+/**
+ * This class implemented setTimeout and setInterval using RequestAnimationFrame
+ * This code references to
+ * https://github.com/aisriver/myHome3D/blob/master/src/utils/RAF.ts
+ * @internal
+ */
+export declare class RafHelper {
+    readonly TIMEOUT = "timeout";
+    readonly INTERVAL = "interval";
+    private timeoutMap;
+    private intervalMap;
+    private run;
+    private setIdMap;
+    setTimeout(cb: () => void, interval: number): symbol;
+    clearTimeout(timer: symbol): void;
+    setInterval(cb: () => void, interval: number): symbol;
+    clearInterval(timer: symbol): void;
+}

package/dist/types/core/helpers/ZoomToRectHelper.d.ts

@@ -0,0 +1,20 @@
+import * as THREE from "three";
+import type { BaseViewer } from "../../core/viewers";
+export declare class ZoomToRectHelper {
+    protected viewer: BaseViewer;
+    private boxSelectHelper?;
+    private active;
+    constructor(viewer: BaseViewer);
+    private get viewerContainer();
+    get camera(): THREE.OrthographicCamera | THREE.PerspectiveCamera;
+    get raycaster(): THREE.Raycaster;
+    isActive(): boolean;
+    activate(): void;
+    deactivate(): void;
+    /**
+     * Picks and get world position by screen position.
+     */
+    protected pickPositionByScreenPoint(p: THREE.Vector2): THREE.Vector3 | undefined;
+    protected handleZoomToRect(leftTop: THREE.Vector2, rightBottom: THREE.Vector2): void;
+    destroy(): void;
+}

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

@@ -0,0 +1,11 @@
+export * from "./InstantiateHelper";
+export * from "./RafHelper";
+export * from "./BinaryReader";
+export * from "./LoadingHelper";
+export * from "./MeshBvhHelper";
+export * from "./ObjectPixelSizeHelper";
+export * from "./OSnapHelper";
+export * from "./PickMarkupHelper";
+export * from "./BoxSelectHelper";
+export * from "./ZoomToRectHelper";
+export * from "./MobileTouchHelperDrawable";

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

@@ -0,0 +1,24 @@
+export * from "./patches";
+export * from "./canvas";
+export * from "./compare";
+export * from "./components";
+export * from "./controls";
+export * from "./dxf";
+export * from "./dxf-parser";
+export * from "./effect";
+export * from "./geometry-offset";
+export * from "./helpers";
+export * from "./input-manager";
+export * from "./interactions";
+export * from "./text-texture";
+export * from "./font";
+export * from "./pick";
+export * from "./utils";
+export * from "./model";
+export * from "./viewers";
+export * from "./workers";
+export * from "./undo";
+export * from "./Configs";
+export * from "./Constants";
+export * from "./Units";
+export * from "./VersionManager";

package/dist/types/core/indexeddb/BaseTable.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Table is known as ObjectStore in IndexedDb
+ */
+export declare class BaseTable {
+    db?: IDBDatabase;
+    isCreatingTable: boolean;
+    constructor();
+    /**
+     * Derived class have to override this method and return a table name!
+     */
+    tableName(): string;
+    /**
+     * Adds a record to a table
+     */
+    add(record: any, successCallback?: any, errorCallback?: any): void;
+    /**
+     * Saves a record
+     */
+    save(record: any, successCallback?: any, errorCallback?: any): void;
+    /**
+     * Deletes a record
+     */
+    delete(key: string, successCallback?: any, errorCallback?: any): void;
+    /**
+     * Updates a record
+     */
+    update(): void;
+    /**
+     * Queries records in a table
+     * @param cursorHandler callback to handle records one by one
+     */
+    query(cursorHandler?: any, errorCallback?: any): void;
+    queryByIndex(indexName: any, indexValue: any, successCallback?: any, errorCallback?: any): void;
+    queryAll(successCallback?: any, errorCallback?: any): void;
+    clearAll(successCallback?: any, errorCallback?: any): void;
+}

package/dist/types/core/indexeddb/DxfDataTable.d.ts

@@ -0,0 +1,22 @@
+import { BaseTable } from "./BaseTable";
+export interface DxfDataTableRecord {
+    dxfDataId: string;
+    dxf: object;
+}
+/**
+ * DxfDataTable in IndexedDb
+ * Table is known as ObjectStore in IndexedDb
+ */
+export declare class DxfDataTable extends BaseTable {
+    tableName(): string;
+    /**
+     * Singleton design pattern
+     */
+    private static _instance;
+    static instance(): DxfDataTable;
+    /**
+     * Queires a dxf data
+     * @param dxfDataId should be a unique id to identify different dxf files
+     */
+    query(dxfDataId: string, successCallback?: any, errorCallback?: any): void;
+}

package/dist/types/core/indexeddb/FontDataTable.d.ts

@@ -0,0 +1,32 @@
+import { BaseTable } from "./BaseTable";
+import type { Orientation, ShxFontType } from "../../core/font/shx";
+export interface FontDataTableRecord {
+    fontType?: ShxFontType;
+    order: number;
+    data: Record<number, Uint8Array>;
+    info: string;
+    orientation: Orientation;
+    baseUp: number;
+    baseDown: number;
+    fileName: string;
+    fileHeader: string;
+    fileVersion: string;
+}
+/**
+ * DxfDataTable in IndexedDb
+ * Table is known as ObjectStore in IndexedDb
+ */
+export declare class FontDataTable extends BaseTable {
+    tableName(): string;
+    /**
+     * Singleton design pattern
+     */
+    private static _instance;
+    static instance(): FontDataTable;
+    /**
+     * Queires a dxf data
+     * @param fileId should be a unique id to identify different dxf files
+     */
+    query(fileName: string): Promise<FontDataTableRecord>;
+    queryAll(): Promise<FontDataTableRecord[]>;
+}

package/dist/types/core/indexeddb/IndexedDbManager.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Definition of an indexeddb table
+ */
+export interface IndexedDbTable {
+    name: string;
+    options?: IDBObjectStoreParameters;
+    indexArray?: {
+        name: string;
+        fields: string[];
+        unique: boolean;
+    }[];
+}
+/**
+ * IndexedDb manager.
+ */
+export declare class IndexedDbManager {
+    private readonly DATABASE_NAME;
+    /**
+     * Default tables.
+     */
+    private readonly DEFAULT_TABLES;
+    private db?;
+    private tables;
+    /**
+     * Singleton design pattern
+     */
+    private static _instance;
+    static instance(): IndexedDbManager;
+    /**
+     * Sets indexeddb tables. This should be called before getDatabase() is called.
+     */
+    setTables(tables: IndexedDbTable[]): void;
+    /**
+     * Gets indexeddb tables.
+     */
+    getTables(): IndexedDbTable[];
+    /**
+     * Makes sure to open database, and the table is already created before add/put/delete, etc.
+     */
+    getDatabase(): Promise<IDBDatabase>;
+    /**
+     * Closes the database.
+     */
+    closeDatabase(): void;
+    private deleteDataBase;
+    private getDB;
+    private getUpgradedDB;
+    private createTable;
+}

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

@@ -0,0 +1,4 @@
+export * from "./BaseTable";
+export * from "./IndexedDbManager";
+export * from "./DxfDataTable";
+export * from "./FontDataTable";