@x-viewer/core 0.9.0

package/dist/types/core/utils/MergeUtils.d.ts

@@ -0,0 +1,126 @@
+import * as THREE from "three";
+import { DxfObject } from "../dxf/DxfObject";
+/**
+ * Used for merged mesh
+ * @internal
+ */
+export interface Batch {
+    batchId: number;
+    name?: string;
+    id?: string;
+    positionStart: number;
+    positionCount: number;
+    indexStart: number;
+    indexCount: number;
+    boundingSphere?: THREE.Sphere;
+    userData?: object;
+    parentUserData?: object;
+}
+/**
+ * MergeHelper class is used to merge child objects for a given object
+ * @internal
+ */
+export declare class MergeUtils {
+    static MergeInfo: {
+        removedObjects: number;
+        mergedMeshes: number;
+        mergedLines: number;
+        mergedPoints: number;
+        mergedUnknownTypeObjects: number;
+        elapsedTime: number;
+    };
+    static resetMergeInfo(): void;
+    /**
+     * Merges child objects for given object.
+     * it tries to merge objects in the same level and with the same parent;
+     * @param saveBatchInfo caller can set saveBatchInfo to true, so that s/he can
+     * get the object's original data before merged.
+     * While this takes some extra space, so, we'd like to add a flag here.
+     */
+    static merge(object: THREE.Object3D | DxfObject, saveBatchInfo?: boolean): void;
+    /**
+     * Merges child objects of given object.
+     * If objects' material are the same, they can be merged.
+     */
+    private static mergeInner;
+    /**
+     * @param object parent object or THREE.Object3D[]
+     * @param i index of for object.children[]
+     * @param k index of for object.children[]
+     * @param dict to store merge-able object
+     * @param nonMergeIndexes used in order to improve performance
+     */
+    static tryHandleMergeableObjects(object: THREE.Object3D | THREE.Object3D[] | DxfObject | DxfObject[], i: number, k: number, dict: {
+        [firstIndex: number]: {
+            indexes: number[];
+        };
+    }, nonMergeIndexes: number[]): boolean;
+    /**
+     * TODO: Filters XC etc.
+     * there are cases where entities with xc and without xc are merged together
+     */
+    static isFilteredByOtherFactors(object: THREE.Object3D | DxfObject, levelObject: THREE.Object3D | DxfObject | undefined): boolean;
+    /**
+     * Merges all objects of given object, just leaf children.
+     * If objects' material are the same, they can be merged.
+     * Better to call mergeInner first then deepMerge for a better performance.
+     * return \{ "added": THREE.Object3D[], "removed": THREE.Object3D[] \}
+     */
+    static deepMerge(objects: THREE.Object3D[] | DxfObject[], levelObject?: THREE.Object3D | DxfObject | undefined, bRemovedAndAddedAfterMerge?: boolean, bRemoveEmptyObjectsAfterMerge?: boolean, saveBatchInfo?: boolean): {
+        added: THREE.Object3D[] | DxfObject[];
+        removed: THREE.Object3D[] | DxfObject[];
+    };
+    /**
+     * since we'll move geometry to another merged mesh under a group, below is the structure:
+        - root object
+          - merged objects group
+            - merged object 1
+     * need to consider a geomery's matrix for each level of ancestor
+    */
+    static applyMatrix(copyGeometry: THREE.BufferGeometry, object: THREE.Object3D | DxfObject, levelObject?: THREE.Object3D | DxfObject): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+    /**
+     * Merges geometries for lines
+     */
+    static mergeLineGeometries(geometries: THREE.BufferGeometry[], saveBatchInfo: boolean, isDashedMaterial: boolean, batches?: Batch[]): THREE.BufferGeometry | undefined;
+    private static mergeBufferGeometriesWithLinesToLineSegments;
+    private static mergeBufferAttributesWithLinesToLineSegments;
+    /**
+     * Removes a number from array
+     */
+    private static removeFromArray;
+    /**
+     * Removes object from objects
+     */
+    static removeObjectFromArray(arr: THREE.Object3D[], toBeDeleted: THREE.Object3D): void;
+    /**
+     * Checks if two geometries are mergable.
+     * It requires they have the same type and the same attributes.
+     */
+    static areGeometriesMergeable(g1: THREE.BufferGeometry, g2: THREE.BufferGeometry): boolean;
+    /**
+     * Checks if two objects are mergable.
+     * It requires
+     * - They are with the same masks.
+     * - Their userData.layerName must be the same if there is. This is useful for Dxf.
+     * - They have the same type or the same draw type( Mesh or Line or Point).
+     */
+    static areObjectsMergeable(o1: THREE.Object3D, o2: THREE.Object3D): boolean;
+    /**
+     * Checks if it is a merged object
+     */
+    static isMergedMesh(mesh: THREE.Mesh): boolean;
+    static isFaceIndexInBatch(geometry: THREE.BufferGeometry, batch: Batch, faceIndex: number): boolean;
+    static getBatchByFaceIndex(mesh: THREE.Mesh, faceIndex: number): Batch | undefined;
+    static getBatchByLineIndex(line: THREE.Line, index: number): Batch | undefined;
+    /**
+     * Gets batchId by faceIndex for a merged mesh
+     */
+    static getBatchIdByFaceIndex(mesh: THREE.Mesh, faceIndex: number): number;
+    static getBatchByBatchId(mesh: THREE.Mesh, batchId: number): Batch | undefined;
+    /**
+     * Clones corresponding geometry for given batch.
+     * To do this, we'll clone the geometry so the matrix, material, normal, uv, etc.
+     * will be correct, and we'll remove extra index and position.
+     */
+    static cloneGeometryForBatch(mesh: THREE.Mesh, batch: Batch): THREE.BufferGeometry | undefined;
+}

package/dist/types/core/utils/ObjectUtils.d.ts

@@ -0,0 +1,216 @@
+import * as THREE from "three";
+import { DxfObject } from "../dxf/DxfObject";
+/**
+ * @internal
+ */
+export interface MaterialInfo {
+    uuid: string;
+    material?: THREE.Material;
+    clonedMaterial?: THREE.Material;
+    opacity: number;
+    transparent: boolean;
+    side: THREE.Side;
+}
+/**
+ * Util class for Threejs Object
+ * @internal
+ */
+export declare class ObjectUtils {
+    /**
+     * Clears any styles, including transparency, wireframe mode, filter by floor, etc.
+     * @param object
+     */
+    static resetObjectStyle(object: THREE.Object3D): void;
+    /**
+     * Clears any styles, including transparency, wireframe mode, filter by floor, etc.
+     */
+    static resetObjectStyleById(scene: THREE.Scene, id: number): void;
+    /**
+     * Sets an object's opacity
+     * @returns returns MaterialInfo list in case caller want to revert the opacity
+     */
+    static setObjectOpacity(object: THREE.Object3D, opacity?: number, includeObjectIds?: number[], excludeObjectIds?: number[]): MaterialInfo[];
+    /**
+     * Reverts an object's opacity
+     * @param object the root object
+     */
+    static revertObjectOpacity(object: THREE.Object3D, materialInfoList: MaterialInfo[], includeObjectIds?: number[], excludeObjectIds?: number[]): void;
+    /**
+     * Sets an object's opacity
+     */
+    static setObjectOpacityById(scene: THREE.Scene, id: number, opacity?: number, includeObjectIds?: number[], excludeObjectIds?: number[]): MaterialInfo[];
+    /**
+     * Reverts an object's opacity
+     */
+    static revertObjectOpacityById(scene: THREE.Scene, id: number, materialInfoList: MaterialInfo[], includeObjectIds?: number[], excludeObjectIds?: number[]): void;
+    /**
+     * Applies material to an object, including its children
+     * The originalMaterial will be saved to userData in case user want to revert it
+     */
+    static applyMaterialToObject(object: THREE.Object3D, material: THREE.Material | THREE.Material[], includeObjectIds?: number[], excludeObjectIds?: number[]): void;
+    /**
+     * Revert applied material to an object, including its children
+     */
+    static revertAppliedMaterialToObject(object: THREE.Object3D, includeObjectIds?: number[], excludeObjectIds?: number[]): void;
+    /**
+     * Sets an object's opacity
+     */
+    static applyMaterialToObjectById(scene: THREE.Scene, id: number, material: THREE.Material | THREE.Material[], includeObjectIds?: number[], excludeObjectIds?: number[]): void;
+    /**
+     * Reverts an object's opacity
+     */
+    static revertAppliedMaterialToObjectById(scene: THREE.Scene, id: number, includeObjectIds?: number[], excludeObjectIds?: number[]): void;
+    /**
+     * Applies a default opacity material to an object, including its children
+     */
+    static applyOpacityMaterialToObject(object: THREE.Object3D, includeObjectIds?: number[], excludeObjectIds?: number[]): void;
+    /**
+     * Sets double-sided material to an object, including its children
+     * The originalSide will be saved to userData in case user want to revert it
+     */
+    static setDoubleSidedMaterialToObject(object: THREE.Object3D): void;
+    /**
+     * Revert double-sided material to an object, including its children
+     */
+    static revertDoubleSidedMaterialToObject(object: THREE.Object3D): void;
+    /**
+     * Sets an object to be wireframe mode.
+     * In order to revert wireframe mode, we'll store original material in userData: \{
+     *   materialForWireframe: THREE.Material
+     * \}
+     * It seems wireframe mode have performance degradation, look at here for more info:
+     * https://stackoverflow.com/questions/45917611/shader-wireframe-of-an-object
+     */
+    static setWireframeMode(object: THREE.Object3D): void;
+    /**
+     * Sets an object to be wireframe mode.
+     */
+    static setWireframeModeById(scene: THREE.Scene, id: number): void;
+    /**
+     * Reverts an object to be non-wireframe mode.
+     */
+    static revertWireframeMode(object: THREE.Object3D): void;
+    /**
+     * Reverts an object to be non-wireframe mode.
+     */
+    static revertWireframeModeById(scene: THREE.Scene, id: number): void;
+    /**
+     * Finds objects by name, id, userData, etc.
+     * @param scene
+     * @param targetIds target object ids to find from
+     * @param searchText search text
+     * @param findFirst only find the first
+     */
+    private static findInner;
+    /**
+     * Finds objects by given string
+     */
+    static find(scene: THREE.Scene, searchText: string, targetIds?: number[], findFirst?: boolean): THREE.Object3D[];
+    /**
+     * Finds the first object by given string
+     */
+    static findFirst(scene: THREE.Scene, searchText: string, targetIds?: number[], findFirst?: boolean): THREE.Object3D | undefined;
+    /**
+     * Checks if given string contains floor
+     * @param str string to match, e.g. '5F(xxx)'
+     */
+    private static getFloorsFromString;
+    /**
+     * Matches if a string contains floor string
+     * @param str string to match, e.g. '5F(xxx)'
+     * @param floor '5F', etc.
+     */
+    private static matchFloor;
+    /**
+     * Matches if a string contains one of floor string in floors
+     * @param str string to match, e.g. '5F(xxx)'
+     * @param floor '5F', etc.
+     */
+    private static matchFloors;
+    /**
+     * Distincts/find floors from models, by checking children object.name
+     */
+    static distinctFloors(scene: THREE.Scene, modelId: number[]): string[];
+    /**
+     * Sets object's visible to true if its name, etc. match one of given floor.
+     * This method won't affect other objects that don't match.
+     */
+    static traverseObjectByFloors(scene: THREE.Scene, objectId: number, floors: number[], matchCallback?: (object: THREE.Object3D) => void, unmatchCallback?: (object: THREE.Object3D) => void): never[] | undefined;
+    /**
+     * Sets object belong to given floors to be visible
+     * @param objectId root or parent object id
+     * @param makeUnmatchedInvisible if it should make unmatched object invisible
+     */
+    static setVisibleForFloors(scene: THREE.Scene, objectId: number, floors: number[], makeUnmatchedInvisible?: boolean): void;
+    static revertVisibleForFloors(object: THREE.Object3D): void;
+    static revertVisibleForFloorsById(scene: THREE.Scene, id: number): void;
+    private static getObjectById;
+    /**
+     * Outline default material
+     */
+    private static OUTLINE_MATERIAL;
+    /**
+     * Creates outlines for given object and children
+     */
+    static createOutlines(object: THREE.Object3D, options?: {
+        onlyVisible: boolean;
+        meshOnly: boolean;
+    }, onProgress?: (event: ProgressEvent) => void): Promise<THREE.LineSegments[]>;
+    /**
+     * Recursively removes outlines for given object and children
+     */
+    static removeOutlines(object: THREE.Object3D): void;
+    /**
+     * Checks if an object has outline already
+     * @param checkChildren If it checks children recursively.
+     */
+    static hasOutline(object: THREE.Object3D, checkChildren?: boolean): boolean;
+    /**
+     * Sets outline visiblility for given object and children
+     */
+    static setOutlinesVisibility(object: THREE.Object3D, visible: boolean): void;
+    /**
+     * Creates outline for given geometry
+     */
+    static createOutline(geometry: THREE.BufferGeometry, material?: THREE.LineBasicMaterial, matrix?: THREE.Matrix4): THREE.LineSegments;
+    /**
+     * Clones object
+     * @param object target object to be cloned
+     * @param cloneMaterial if it needs to clone material or not
+     * @returns cloned object
+     */
+    static cloneObject(object: THREE.Object3D, cloneMaterial?: boolean): THREE.Object3D;
+    private static BOX_FACE_MATERIAL;
+    /**
+     * Creates box mesh
+     */
+    static createBox(sizeX: number, sizeY: number, sizeZ: number, faceMaterial?: THREE.Material, withBottom?: boolean): THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>, THREE.Material, THREE.Object3DEventMap>;
+    /**
+     * TODO: Relative to center
+     */
+    static rebaseObjectOnRTC(object: THREE.Object3D): THREE.Object3D;
+    static isEmptyObject(object: THREE.Object3D | DxfObject): boolean;
+    static removeEmptyObjects(object: THREE.Object3D | DxfObject): boolean;
+    /**
+     * From bottom to top, removes child objects first,
+     * and then removes empty parent objects
+     */
+    static removeEmptyObjectsFromRemovingObjects(removingObjects: THREE.Object3D[], levelObject: THREE.Object3D): void;
+    /**
+     * To save memory, object3d shares some variables
+     */
+    static setSharedVariablesOfObject(object: THREE.Object3D): void;
+    /**
+     * Checks if an object is a drawable leaf object
+     */
+    static isLeafObject(obj: THREE.Object3D): boolean;
+    /**
+     * object layers related setting functions
+     */
+    static enableLayerChannels(obj: THREE.Object3D, channels: number[], recursive?: boolean): void;
+    static disableLayerChannels(obj: THREE.Object3D, channels: number[], recursive?: boolean): void;
+    static setLayerChannels(obj: THREE.Object3D, channels: number[], recursive?: boolean): void;
+    static isObjectHittable(obj: THREE.Object3D): boolean;
+    static isObjectSnapable(obj: THREE.Object3D): boolean;
+    static isObjectSelectable(obj: THREE.Object3D): boolean;
+}

package/dist/types/core/utils/PolygonUtils.d.ts

@@ -0,0 +1,9 @@
+import * as THREE from "three";
+/**
+ * @internal
+ */
+export declare class PolygonUtils {
+    static getFaces(points: THREE.Vector3[]): number[];
+    static arePointsCoplanar(points: THREE.Vector3[]): boolean;
+    static isSelfIntersecting(points: THREE.Vector3[]): boolean;
+}

package/dist/types/core/utils/SVGObjectUtils.d.ts

@@ -0,0 +1,22 @@
+import { SVGObject } from "three/examples/jsm/renderers/SVGRenderer.js";
+/**
+ * Default osnap icon size in pixel.
+ */
+export declare const OSnapIconSize = 10;
+/**
+ * OSnap marker type.
+ */
+export declare enum OSnapMarkerType {
+    TripleCross = "TripleCross",
+    Square = "Square",
+    Triangle = "Triangle",
+    CircleWithCross = "CircleWithCross",
+    Cross = "Cross",
+    Perpendicular = "Perpendicular"
+}
+/**
+ * @internal
+ */
+export declare class SVGObjectUtils {
+    static createSVGObject(node: SVGPathElement | SVGTextElement | SVGLineElement): SVGObject;
+}

package/dist/types/core/utils/SceneUtils.d.ts

@@ -0,0 +1,26 @@
+import * as THREE from "three";
+/**
+ * Util methods about Scene
+ * @internal
+ */
+export declare class SceneUtils {
+    /**
+     * Get all visible objects' bounding box in a scene.
+     * @param scene
+     */
+    static getVisibleObjectBoundingBox(scene: THREE.Scene): THREE.Box3;
+    static getObjectsBoundingBox(scene: THREE.Scene, objectIds: number[], sampling?: boolean): THREE.Box3;
+    /**
+     * Box3.expandByObject() doesn't work well in some case.
+     * E.g. when object's position is far away from object's center?
+     * When objects are instanced?
+     * That's why we need a method to find bounding box by object's children!
+     * And, better to do sampling in case there are too many children.
+     */
+    static getBoundingBox(object: THREE.Object3D, sampling?: boolean): THREE.Box3;
+    /**
+     * InstancedMesh is different, we need to get its child meshes in order to get the bounding box
+     */
+    static getInstancedMeshBoundingBox(mesh: THREE.InstancedMesh): THREE.Box3;
+    static getObjectCenter(object: THREE.Object3D, center: THREE.Vector3): void;
+}

package/dist/types/core/utils/SectionUtils.d.ts

@@ -0,0 +1,11 @@
+import * as THREE from "three";
+/**
+ * @internal
+ */
+export declare class SectionUtils {
+    static setMaterialSection(mat: THREE.Material, planes: THREE.Plane[], bAppend?: boolean, bClipIntersection?: boolean): void;
+    static removeSection(object: THREE.Object3D): void;
+    static addSection(object: THREE.Object3D, planes: THREE.Plane[], bAppend?: boolean, bClipIntersection?: boolean): void;
+    static generateSectionPlanesByBox(sectionBox: THREE.Box2): THREE.Plane[];
+    static generateSectionPlanesByPoints(points: THREE.Vector2[], bLeftSideOfForwadDirection?: boolean): THREE.Plane[] | undefined;
+}

package/dist/types/core/utils/SimplifyUtils.d.ts

@@ -0,0 +1,15 @@
+import * as THREE from "three";
+/**
+ * SimplifyUtils class is used to simplify objects' geomery for a given object
+ * @internal
+ */
+export declare class SimplifyUtils {
+    /**
+     * Gets simplified object.
+     */
+    static simplifyGeometry(geometry: THREE.BufferGeometry, simplifyRate: number): THREE.BufferGeometry;
+    /**
+     * Gets number of vertices to remove
+     */
+    private static getNumberOfVerticesToRemove;
+}

package/dist/types/core/utils/TextureUtils.d.ts

@@ -0,0 +1,16 @@
+import * as THREE from "three";
+/**
+ * TextureUtils class
+ * @internal
+ */
+export declare class TextureUtils {
+    /**
+     * Creates an environment texture
+     */
+    static createEnvTexture(pmremGenerator: THREE.PMREMGenerator | undefined, url: string): Promise<THREE.Texture>;
+    /**
+     * Creates default environment texture
+     */
+    static createEnvTextureFromDataArray(pmremGenerator: THREE.PMREMGenerator | undefined, data?: Uint16Array, width?: number, height?: number): Promise<THREE.Texture>;
+    private static readonly HDR_CITY_STREET_64x32;
+}

package/dist/types/core/utils/UVUtils.d.ts

@@ -0,0 +1,21 @@
+import * as THREE from "three";
+export declare class UVUtils {
+    /**
+     * Performs angle-based island detection + PCA projection + rectangle pack
+     * (mimics Blender's Smart UV Project).
+     * @param geometry      Source THREE.BufferGeometry (must be indexed).
+     * @param attribute     Target attribute to apply the generated uvs. E.g., "uv", "uv1".
+     * @param angleLimitDeg Max normal-angle difference to stay in one island.
+     * @param islandMargin  Pixel gap between islands (0-1 UV space).
+     */
+    static generateSmartUv(geometry: THREE.BufferGeometry, attribute?: string, angleLimitDeg?: number, islandMargin?: number): void;
+    /**
+     * Performs angle-based island detection + PCA projection + rectangle pack
+     * (mimics Blender's Smart UV Project).
+     * @param geometry      Source THREE.BufferGeometry (indexed or non-indexed).
+     * @param angleLimitDeg Max normal-angle difference to stay in one island.
+     * @param islandMargin  Pixel gap between islands (0-1 UV space).
+     * @returns             Float32Array(uv) same length as position count.
+     */
+    static smartUvProject(geometry: THREE.BufferGeometry, angleLimitDeg?: number, islandMargin?: number): Float32Array;
+}

package/dist/types/core/utils/UnitConversionUtils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @internal
+ */
+export declare const UnitConversionByMeter: {
+    [key: string]: number;
+};
+/**
+ * @internal
+ */
+export declare const UnitLabels: {
+    [key: string]: string;
+};
+/**
+ * @internal
+ */
+export declare const getUnitStr: (unit: string, power?: number) => string;
+/**
+ * Gets unit
+ * value
+ * sourceUnit
+ * targetUnit
+ * @internal
+ */
+export interface ValueWithUnit {
+    value: number;
+    unit: string;
+}
+/**
+ * @internal
+ */
+export declare const getLengthValueByUnit: (value: number, sourceUnit: string, targetUnit: string, power?: number) => ValueWithUnit;

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

@@ -0,0 +1,26 @@
+export * from "./CancelablePromise";
+export * from "./CommonUtils";
+export * from "./ColorUtils";
+export * from "./CoordinateUtils";
+export * from "./CSS2DObjectUtils";
+export * from "./DecimalPrecisionUtils";
+export * from "./DeviceUtils";
+export * from "./EdgeUtils";
+export * from "./Event";
+export * from "./ExportUtils";
+export * from "./FpsUtils";
+export * from "./GeometryUtils";
+export * from "./LodashUtils";
+export * from "./LogUtils";
+export * from "./MaterialUtils";
+export * from "./MathUtils";
+export * from "./MergeUtils";
+export * from "./ObjectUtils";
+export * from "./PolygonUtils";
+export * from "./SceneUtils";
+export * from "./SectionUtils";
+export * from "./SimplifyUtils";
+export * from "./SVGObjectUtils";
+export * from "./TextureUtils";
+export * from "./UnitConversionUtils";
+export * from "./UVUtils";