@maqiuyao/dxf-viewer 0.1.0

package/dist/src/dxfViewer/core/Configs.d.ts

@@ -0,0 +1,250 @@
+import * as THREE from "three";
+/**
+ * Camera projection type.
+ */
+export declare enum CameraProjection {
+    Perspective = "Perspective",
+    Orthographic = "Orthographic"
+}
+/**
+ * Camera config
+ * @internal
+ * @deprecated Use Viewpoint instead
+ */
+export interface CameraConfig {
+    /**
+     * The camera location
+     */
+    eye: THREE.Vector3;
+    /**
+     * The location that the camera looks to
+     */
+    look: THREE.Vector3;
+    /**
+     * @internal
+     */
+    up?: THREE.Vector3;
+    /**
+     * The camera zoom
+     */
+    zoom?: number;
+    /**
+     * The camera's near clip plane
+     */
+    near?: number;
+    /**
+     * The camera's far clip plane
+     */
+    far?: number;
+}
+/**
+ * Model config
+ */
+export interface ModelConfig {
+    /**
+     * Unique id of the model
+     */
+    modelId?: string;
+    /**
+     * Model name
+     */
+    name?: string;
+    /**
+     * Source url of the model
+     */
+    src: string;
+    /**
+     * Used to distinguish format, because it may be hard to know the format by src!
+     * @internal
+     */
+    fileFormat?: string;
+    /**
+     * File encoding, can be used by dxf. Common encoding include "UTF-8", "gb2312", etc.
+     * @internal
+     */
+    encoding?: string;
+    /**
+     * A float array of length 16, definds model's position, rotation and scale
+     */
+    matrix?: number[];
+    /**
+     * If we want to merge meshes/lines/points with the same material
+     * @internal
+     * @default false
+     */
+    merge?: boolean;
+    /**
+     * If we want to generate and show edges/outlines to the modle.
+     * It is useful for Viewer3d.
+     * @internal
+     */
+    edges?: boolean;
+    /**
+     * If this model is visible by default.
+     * @internal
+     */
+    visible?: boolean;
+}
+/**
+ * 2d model config
+ */
+export interface Model2dConfig extends ModelConfig {
+    /**
+     * If to ignore anything of paper space.
+     * There are some scenarios to ignore paper space by default, includes:
+     * - Dxf overlay, aka, loading more than one dxf files into a viewer. We'll only load model space for the first file.
+     * - Dxf compare. Since we'll only compare model space, it won't load paper space at all.
+     *
+     * This option is useful when user want to explicitly ignore paper space.
+     * @default false
+     */
+    ignorePaperSpace?: boolean;
+    /**
+     * Applies this color to everything in this model.
+     * This allows user to show a drawing with a pure color (black, white, etc.).
+     * Color value is between 0 and 1, e.g., [1, 0, 0] means 'red'.
+     */
+    overrideColor?: number[];
+}
+/**
+ * Common viewer config
+ */
+export interface BaseViewerConfig {
+    /**
+     * @description canvas id to contain the viewer.
+     */
+    containerId: string;
+    /**
+     * @internal
+     */
+    language?: "cn" | "en";
+    /**
+     * @internal
+     */
+    logLevel?: "debug" | "info" | "warn" | "error" | "silent";
+    /**
+     * @internal
+     */
+    enableSpinner?: boolean;
+    /**
+     * @internal
+     */
+    enableProgressBar?: boolean;
+    /**
+     * @description just for react native
+     * @internal
+     */
+    context?: WebGLRenderingContext | WebGL2RenderingContext;
+    /**
+     * @description just for react native
+     * @internal
+     */
+    context2d?: CanvasRenderingContext2D;
+}
+/**
+ * This wrappers most config for Viewer3d
+ */
+export interface Viewer3dConfig extends BaseViewerConfig {
+    /**
+     * Default is `meters`
+     * @internal
+     */
+    units?: string;
+    /**
+     * Sets the default locale
+     * @internal
+     */
+    locale?: "cn" | "en";
+}
+/**
+ * This wrappers most config for Viewer2d
+ */
+export interface Viewer2dConfig extends BaseViewerConfig {
+    /**
+     * Enables layout bar so we can switch to other layouts.
+     * The default layout bar is an example UI of the viewer, since plenty of APIs are exposed,
+     * you are recommended to create your own layout bar with customized style, location, etc.
+     */
+    enableLayoutBar?: boolean;
+    /**
+     * If to cache model into indexeddb (or maybe local storage in future).
+     * If enabled, it will get model data from cache the next time model is loaded.
+     * @internal
+     * @default false
+     */
+    enableLocalCache?: boolean;
+}
+/**
+ * Dxf compare config.
+ */
+export interface DxfCompareConfig {
+    /**
+     * Enables to compare properties (color, linetype, line width, etc.)
+     */
+    enableDetailComparision: boolean;
+}
+/**
+ * A default Viewer3dConfig as a template, which enables most plugins.
+ * @internal
+ */
+export declare const DefaultViewer3dConfig: Viewer3dConfig;
+/**
+ * @internal
+ */
+export interface IsolateObjectsParam {
+    id: string;
+    modelId: string;
+}
+/**
+ * @internal
+ */
+export interface IsolateObjectsParams {
+    familyInstanceIds: IsolateObjectsParam[];
+}
+/**
+ * @internal
+ */
+export interface ScreenshotConfig {
+    type: string;
+    quality: number;
+    includeOverlay: boolean;
+}
+/**
+ * Viewpoint definition.
+ */
+export interface Viewpoint {
+    /**
+     * The camera location
+     */
+    eye: THREE.Vector3;
+    /**
+     * The location that the camera looks to
+     */
+    look: THREE.Vector3;
+    /**
+     * @internal
+     */
+    up?: THREE.Vector3;
+    /**
+     * The camera zoom, used by Orthographic camera.
+     */
+    zoom?: number;
+}
+/**
+ * Icon class.
+ * Used by toolbar and bottom bar icons, etc.
+ */
+export interface IconClass {
+    /**
+     * The default icon.
+     */
+    default: string;
+    /**
+     * The icon when item is actived.
+     */
+    active?: string;
+    /**
+     * The icon font class name.
+     */
+    iconFont?: string;
+}

package/dist/src/dxfViewer/core/Constants.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Default language.
+ * @internal
+ */
+export declare const DefaultLanguage = "en";
+/**
+ * To improve performance, we can set object.matrixAutoUpdate = false for static or rarely moving objects and
+ * manually call object.updateMatrix() whenever their position/rotation/quaternion/scale are updated.
+ * Add a constrant here, so developer can change it here easily for debugging.
+ * @internal
+ */
+export declare const MatrixAutoUpdate = false;
+/**
+ * These concept can be complex: hitable, snapable, selectable, visible
+ * Mesh                            Y        Y         Y           Y
+ * text in Viewer2d                Y        N         Y           Y
+ * ground plan                     Y        Y         N           Y
+ * outline                         N        Y         N           Y
+ * OSnap auxiliary object          N        Y         N           N
+ *
+ * So, we must handle them properly. We'll try to put them into different layers.
+ *
+ * For each created object with geometry and material, the default layer is set to enableAll.
+ * If the object is only displayed, it is not necessary to call enableAll. For example, some auxiliary display objects.
+ * For objects that cannot be hitable, snapable, selectable, etc., call ObjectUtils.disableLayerChannels to exclude the corresponding channel.
+ * @example
+ * ``` typescript
+ *   this.groundPlane.layers.enableAll();
+ *   ObjectUtils.disableLayerChannels(this.groundPlane, [LayerForSelectableObjects]);
+ * ```
+ */
+/**
+ * @internal
+ */
+export declare const LayerForHitableObjects = 10;
+/**
+ * @internal
+ */
+export declare const LayerForSnapableObjects = 11;
+/**
+ * @internal
+ */
+export declare const LayerForSelectableObjects = 12;
+/**
+ * Object highlight color.
+ */
+export declare const HighlightColor = 583902;
+/**
+ * Object highlight color in rgba format.
+ */
+export declare const HighlightColorRgba: number[];
+/**
+ * Object outline color.
+ */
+export declare const OutlineColorRgba: number[];
+/**
+ * Default object opacity value.
+ */
+export declare const DefaultOpacity = 0.5;
+/**
+ * Default camera settings.
+ */
+export declare const DefaultCameraNear = 0.1;
+export declare const DefaultCameraFar = 5000;
+export declare const DefaultCameraFov = 45;
+/**
+ * Iconfont class name for toolbar, bottombar, section, etc..
+ * @internal
+ */
+export declare const IconfontClass = "x-viewer-iconfont";
+export declare const IconfontClass2 = "x-viewer-iconfont2";
+/**
+ * @internal
+ * Angle threshold at which two plane normals are parallel. Used to calculate edges.
+ */
+export declare const ThresholdAngleForEdge = 10;

package/dist/src/dxfViewer/core/Units.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Units are defined the same order as to Dxf format
+ */
+export declare enum Units {
+    Unitless = "Unitless",
+    Inches = "Inches",
+    Feet = "Feet",
+    Millimeters = "Millimeters",
+    Centimeters = "Centimeters",
+    Meters = "Meters"
+}
+/**
+ * Gets the unit scale when converting to meter.
+ */
+export declare const UnitScaleToMeter: (src: Units) => 1 | 0.001 | 0.01 | 0.0254 | 0.3048;
+export declare const UnitScaleConversion: (src: Units, dest: Units) => number;

package/dist/src/dxfViewer/core/VersionManager.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Gets the sdk version ran on this device from local storage.
+ */
+export declare const getVersionFromLocalStorage: () => string | null;
+/**
+ * Sets the sdk version to local storage.
+ */
+export declare const setVersionToLocalStorage: () => void;
+/**
+ * Checks if current sdk version and last version are different.
+ * There can be storage data formant change if sdk version is updated,
+ * we may simply clean up local storage in this case.
+ */
+export declare const checkIsNewVersion: () => boolean;

package/dist/src/dxfViewer/core/camera/CameraManager.d.ts

@@ -0,0 +1,81 @@
+import { CameraConfig, CameraProjection, Viewpoint } from '../Configs';
+import { default as CameraControls } from '../camera-controls';
+import { FitToOptions } from '../camera-controls/types';
+import { ControlsMode } from '../controls/Control';
+import { InputManager } from '../input-manager/InputManager';
+import { BaseViewer } from '../viewers/BaseViewer';
+import * as THREE from "three";
+export declare class CameraManager {
+    private viewer;
+    readonly perspectiveCamera: THREE.PerspectiveCamera;
+    readonly orthographicCamera: THREE.OrthographicCamera;
+    activeCamera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    readonly cameraControls: CameraControls;
+    private previousDistance;
+    private previousAzimuthRotateSpeed;
+    private previousPolarRotateSpeed;
+    private previousDollySpeed;
+    private previousTruckSpeed;
+    private previousMouseLeft;
+    protected enableKeyDown: boolean;
+    /**
+     * A map/list of different controls
+     */
+    private controlsMap;
+    private activeControls;
+    private projection;
+    /**
+     * For OrbitControls, a user would like to rotate around where mouse is clicked,
+     * rather than the screen center.
+     * We'll display an anchor at where mouse is clicked.
+     */
+    protected anchor: HTMLElement;
+    private onKeyDown;
+    private onChange;
+    constructor(viewer: BaseViewer);
+    get viewerContainer(): HTMLElement;
+    get inputManager(): InputManager;
+    private createAnchor;
+    protected setAnchorPosition(x: number, y: number): void;
+    setOrbitPointVisible(visible: boolean): void;
+    isOrbitPointVisible(): boolean;
+    private setOrthoCameraAspect;
+    private setupCameras;
+    private setCameraPositionAndTarget;
+    private setupControls;
+    private setOrthoCamera;
+    private getDims;
+    private setupOrthoCamera;
+    private setPerspectiveCamera;
+    update(delta: number): boolean;
+    updateAspect(): void;
+    get camera(): THREE.PerspectiveCamera | THREE.OrthographicCamera;
+    enableKeyControl(enable: boolean): void;
+    getTarget(): THREE.Vector3;
+    getPosition(): THREE.Vector3;
+    adjustCameraByBBox(bbox: THREE.Box3): void;
+    enableControl(active: boolean): void;
+    get enableRotate(): boolean;
+    set enableRotate(enable: boolean);
+    enableZoom(enable: boolean): void;
+    enablePan(enable: boolean): void;
+    enableMouseLeft(enable: boolean): void;
+    setCameraPosition(position: THREE.Vector3): void;
+    setCameraTarget(target: THREE.Vector3): void;
+    flyTo(position: THREE.Vector3, lookAt: THREE.Vector3, enableTransition?: boolean): void;
+    flyToPosition(x: number, y: number, z: number): void;
+    flyToBox(box: THREE.Box3, options?: Partial<FitToOptions>): void;
+    fitToSphere(box: THREE.Object3D | THREE.Sphere): void;
+    flyToObject(object: THREE.Object3D): void;
+    flyToViewpoint(viewpoint: Viewpoint): void;
+    getDistanceToFitSphere(radius: number): number;
+    setNavigationMode(mode: ControlsMode): void;
+    getProjection(): CameraProjection;
+    setProjection(proj: CameraProjection): void;
+    setOrbitPoint(point: THREE.Vector3): void;
+    getCameraDirection(): THREE.Vector3;
+    getCameraConfig(): CameraConfig;
+    getCurrentViewpoint(): Viewpoint;
+    setCameraConfig(cameraCfg: CameraConfig): void;
+    destroy(): void;
+}

package/dist/src/dxfViewer/core/camera/index.d.ts

@@ -0,0 +1 @@
+export * from './CameraManager';