@x-viewer/core 0.9.0

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

@@ -0,0 +1,81 @@
+import * as THREE from "three";
+import type { EventInfo, IPointerEvent } from "../../core/input-manager/InputManager";
+/**
+ * @internal
+ * Some concepts:
+ *
+ * 1. Screen coordinate:
+ * (0, 0)
+ * ----------------------> x
+ * |                   |
+ * |                   |
+ * |                   |
+ * |                   |
+ * |___________________|
+ * y                   (1024, 768) e.g.
+ *
+ * 2. Normalized screen coordinate:
+ * (0, 0)
+ * ----------------------> x
+ * |                   |
+ * |                   |
+ * |                   |
+ * |                   |
+ * |___________________|
+ * y                   (1, 1)
+ *
+ * 3. NDC: Normalized Device Coordinates
+ *             ^ y       (1, 1)
+ *             |
+ * (-1, 0)     |(0, 0)   (1, 0)
+ * ----------------------> x
+ *             |
+ *             |
+ * (-1, -1)
+ *
+ * 4. World Coordinates
+ *      ^ y
+ *      |
+ *      |     / x
+ *      |   /
+ *      | /
+ * ---------------> z
+ *   (0, 0)
+ */
+export declare class CoordinateUtils {
+    /**
+     * Gets screen coordinate by pointer event.
+     */
+    static getScreenCoordinateByEvent(event: IPointerEvent | EventInfo | MouseEvent | PointerEvent, container: HTMLElement): THREE.Vector2;
+    /**
+     * Gets screen coordinate by touch event.
+     */
+    static getScreenCoordinateByTouchEvent(event: TouchEvent, container: HTMLElement): THREE.Vector2;
+    /**
+     * Converts world to screen coordinate.
+     */
+    static world2Screen(vector: THREE.Vector3, camera: THREE.Camera, container: HTMLElement): THREE.Vector2;
+    /**
+     * Converts a bbox under world coordinate to screen coordinate.
+     */
+    static worldBBox2Screen(bbox: THREE.Box3, camera: THREE.Camera, container: HTMLElement): THREE.Box2;
+    /**
+     * Converts screen to world coordinate.
+     */
+    static screen2World(vector: THREE.Vector2, camera: THREE.Camera, container: HTMLElement): THREE.Vector3;
+    /**
+     * Converts screen point to NDC coordinate.
+     * @description {en} Normalized screen coordinate: bottom-left(-1, -1), top-right(1, 1).
+     * @description {zh} 标准化屏幕坐标：左下角(-1, -1), 右上角(1, 1)。
+     * @description {en} World coordinate to normalized screen coordinate(0-1).
+     * @description {zh} 世界坐标转标准化屏幕坐标（0-1）。
+     */
+    static screen2Ndc(vector: THREE.Vector2, camera: THREE.Camera, container: HTMLElement): THREE.Vector2;
+    /**
+     * @description {en} Normalized screen coordinate: top-left(0, 0), bottom-right(1, 1).
+     * @description {zh} 标准化屏幕坐标：左上角(0, 0), 右下角(1, 1)。
+     * @description {en} World coordinate to normalized screen coordinate(0-1).
+     * @description {zh} 世界坐标转标准化屏幕坐标（0-1）。
+     */
+    static world2NormalizedScreen(worldCoord: THREE.Vector2 | THREE.Vector3, camera: THREE.Camera, container: HTMLElement): THREE.Vector2;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * @internal
+ */
+export declare const DecimalPrecisionRange: {
+    [key: string]: number;
+};
+/**
+ * @internal
+ */
+export declare const showPrecisionValue: (value: number, precistionType: number) => string;

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

@@ -0,0 +1,15 @@
+/**
+ * Device util class
+ * @internal
+ */
+export declare class DeviceUtils {
+    /**
+     * Checks if it is opened in touch screen device, like iphone, ipad, etc.
+     */
+    static isTouchScreenDevice(): boolean;
+    static printDeviceInfo(): void;
+    static isMobile: boolean;
+    static creatReactNativeCanvas(context: WebGLRenderingContext | WebGL2RenderingContext | CanvasRenderingContext2D): HTMLCanvasElement;
+    static isBrowser: boolean;
+    static isNode: boolean;
+}

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

@@ -0,0 +1,14 @@
+import * as THREE from "three";
+export declare class EdgeUtils {
+    /**
+     * reference to buildEdgeIndices from xeokit
+     */
+    static buildEdge(positions: Float32Array, indices: Uint32Array | Uint16Array | Uint8Array, edgeThreshold?: number): Uint16Array | Uint32Array;
+    /**
+     * Calculate the barycentric coordinates of each vertex of the geometry
+     * TODO: Temporarily do not handle the following cases.
+     * - When there is no solution, it is necessary to expand the vertices
+     * The algorithm also has performance issues!
+     */
+    static buildBarycentrics(geometry: THREE.BufferGeometry): boolean;
+}

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

@@ -0,0 +1,33 @@
+export type Handler<T = any> = (val: T) => void;
+/**
+ * @internal
+ */
+export declare class Event<Events extends Record<string, any> = {}> {
+    private map;
+    /**
+     * @internal
+     */
+    addEventListener<EventName extends keyof Events>(name: EventName, handler: Handler<Events[EventName]>): void;
+    /**
+     * @internal
+     */
+    dispatchEvent<EventName extends keyof Events>(name: EventName, value?: Events[EventName]): void;
+    /**
+     * Checks if there is a listener
+     * @internal
+     */
+    hasEventListener<EventName extends keyof Events>(name: EventName): boolean;
+    /**
+     * Removes all event listeners
+     * @internal
+     */
+    removeEventListener(): void;
+    /**
+     * @internal
+     */
+    removeEventListener<EventName extends keyof Events>(name: EventName): void;
+    /**
+     * @internal
+     */
+    removeEventListener<EventName extends keyof Events>(name: EventName, handler: Handler<Events[EventName]>): void;
+}

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

@@ -0,0 +1,61 @@
+import * as THREE from "three";
+import type { DRACOExporterOptions } from "three/examples/jsm/exporters/DRACOExporter";
+import type { GLTFExporterOptions } from "three/examples/jsm/exporters/GLTFExporter";
+/**
+ * @internal
+ */
+export declare class ExportUtils {
+    static EXTENSION_GLTF: string;
+    static EXTENSION_GLB: string;
+    static EXTENSION_OBJ: string;
+    static EXTENSION_DRACO: string;
+    static EXTENSION_JSON: string;
+    static EXTENSION_STL: string;
+    private static downloadLink;
+    /**
+     * Exports given object to gltf file
+     */
+    static exportToGltf(input: THREE.Object3D, filename: string): void;
+    /**
+     * Exports given object to glb file
+     */
+    static exportToGlb(input: THREE.Object3D, filename: string): void;
+    /**
+     * Exports given object to gltf/glb file
+     * @param input given object
+     * @param filename filename without path, nor extension
+     * @param options
+     */
+    static exportToGltfOrGlb(input: THREE.Object3D, filename: string, options?: GLTFExporterOptions): void;
+    /**
+     * Exports given object to obj file
+     */
+    static exportToObj(input: THREE.Object3D, filename: string): void;
+    /**
+     * Exports given object to draco(drc) file
+     */
+    static exportToDraco(input: THREE.Mesh, filename: string, options?: DRACOExporterOptions): void;
+    /**
+     * Exports given object to stl file
+     */
+    static exportToStl(input: THREE.Object3D, filename: string, binary?: boolean): void;
+    /**
+     * Exports to threejs json
+     * @param input
+     * @param filename
+     */
+    static exportToThreeJsJson(input: THREE.Object3D, filename: string): void;
+    /**
+     * Saves blob as file
+     */
+    static save(blob: Blob, filename: string): void;
+    static saveArrayBuffer(buffer: ArrayBuffer, filename: string): void;
+    static saveJson(json: object, filename: string): void;
+    static saveJsonString(jsonString: string, filename: string): void;
+    static saveString(str: string, filename: string): void;
+    static saveDataView(dataView: DataView, filename: string): void;
+    /**
+     * Adds extention if missing
+     */
+    private static addExtention;
+}

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

@@ -0,0 +1,13 @@
+/**
+ * @internal
+ */
+export declare class FpsUtils {
+    private prevTime;
+    private beginTime;
+    private frames;
+    fps: number;
+    constructor();
+    begin(): void;
+    end(): number;
+    update(): void;
+}

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

@@ -0,0 +1,78 @@
+import * as THREE from "three";
+/**
+ * @internal
+ */
+export interface ILine {
+    start: THREE.Vector3;
+    end: THREE.Vector3;
+}
+/**
+ * GeometryUtils class
+ * @internal
+ */
+export declare class GeometryUtils {
+    /**
+     * Compares two materials
+     */
+    static geometriesEqual(g1: THREE.BufferGeometry, g2: THREE.BufferGeometry): boolean;
+    /**
+     * Checks if two types equal each other.
+     * This method requires type T defined 'equals' method.
+     */
+    private static equal;
+    private static attributesEqual;
+    private static bufferAttributesEqual;
+    /**
+     * Converts InterleavedBufferAttribute to BufferAttribute, because mergeGeometries doesn't support InterleavedBufferAttribute.
+     * If it is supported by Three.js one day, we should remove this method.
+     */
+    static tryConvertInterleavedBufferAttributes(geometry: THREE.BufferGeometry): void;
+    /**
+     * Determines if the 2d point is inside the polygon
+     */
+    static isPointInPolygon(point: THREE.Vector2, polygon: THREE.Vector2[], includeOnSide?: boolean): boolean;
+    static caculateGeometryCenter(geometry: THREE.BufferGeometry): THREE.Vector3 | null;
+    static isConvex(polygon: THREE.Vector2[]): boolean;
+    static areLineSegmentsIntersecting(line1: ILine, line2: ILine): boolean;
+    /**
+     * Tries to get intersection point of two line segments.
+     * Returns undefined in case two line segments don't intersect with each other.
+     */
+    static getLineSegmentsIntersectingPoint(line1: ILine, line2: ILine): THREE.Vector3 | null | undefined;
+    static isPointOnLineSegment(point: THREE.Vector3, line: ILine, epsilon?: number): boolean;
+    static isPointOnLineSegments(point: THREE.Vector3, lines: THREE.Vector3[], epsilon?: number): boolean;
+    /**
+     * Checks if we should rebase points in case their values are big, and do rebase if necessary
+     */
+    static checkAndRebasePositionsOnRTC(positions: THREE.Vector3[] | THREE.Vector2[], offset: THREE.Vector3): boolean;
+    /**
+     * Checks if we should rebase a point in case its value is too large
+     */
+    static shouldRebasePositionOnRTC(vector: THREE.Vector3 | THREE.Vector2): boolean;
+    /**
+     * Calculates surface area
+     */
+    static calculateSurfaceArea(geometry: THREE.BufferGeometry): number;
+    /**
+     * Converts indexes of type line_strip to line
+     * for merge
+     */
+    static convertLineStripToLine(geometry: THREE.BufferGeometry, bLoop?: boolean): void;
+    /**
+     * Convert an indexed geometry to a non-indexed geometry. Can be used for dashed line style.
+     */
+    static convertGeometryWithIndexedToNonIndexed(geometry: THREE.BufferGeometry): THREE.BufferGeometry;
+    static createGeometryAttributeByIndex(attribute: THREE.BufferAttribute, indexBuffer: THREE.BufferAttribute): THREE.BufferAttribute;
+    /**
+     * Gets start/end point of a line segment by given index
+     */
+    static getLineEndPointsByIndex(line: THREE.Line, index: number): THREE.Vector3[];
+    static arePolygonsIntersect(polygon1: THREE.Vector2[], polygon2: THREE.Vector2[]): boolean;
+    static getLineLineIntersectionPoint(a: THREE.Vector2, b: THREE.Vector2, c: THREE.Vector2, d: THREE.Vector2, epsilon?: number): THREE.Vector2 | undefined;
+    static getOffsetPoint(a: THREE.Vector2, b: THREE.Vector2, offset: number): THREE.Vector2;
+    static convertSimpleWidthLineToMeshGeometry(points: THREE.Vector2[], width: number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | undefined;
+    static convertWidthLineToMeshGeometry(points: THREE.Vector2[], width: number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | undefined;
+    static releaseGeometryManually(geometry: THREE.BufferGeometry): void;
+    static getAdjacentNonRepeatPoints(points: THREE.Vector3[], epsilon?: number): THREE.Vector3[];
+    static mergeBBoxes(bboxes: THREE.Box3[]): THREE.Box3[];
+}

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

@@ -0,0 +1,208 @@
+/**
+ * Creates a shallow clone of an object or array.
+ *
+ * For primitive values, returns the value as-is. For objects and arrays,
+ * creates a new instance with the same properties or elements.
+ *
+ * @template T - The type of the object to clone.
+ * @param {T} obj - The object to clone.
+ * @returns {T} A shallow clone of the object.
+ *
+ * @example
+ * ```typescript
+ * import { clone } from "./LodashUtils"
+ *
+ * const original = { a: 1, b: 2 }
+ * const cloned = clone(original)
+ * cloned.a = 3
+ * console.log(original.a) // 1 (unchanged)
+ * console.log(cloned.a)   // 3
+ *
+ * const arr = [1, 2, 3]
+ * const clonedArr = clone(arr) // [1, 2, 3]
+ * ```
+ */
+export declare function clone<T>(obj: T): T;
+/**
+ * Assigns own enumerable properties of source objects to the destination object
+ * for all destination properties that resolve to undefined.
+ *
+ * This function fills in undefined properties in an object with the first value
+ * present in any of the source objects. Source objects are applied from left to right.
+ *
+ * @param {Record<string, unknown>} obj - The destination object.
+ * @param {...Record<string, unknown>[]} sources - The source objects.
+ * @returns {Record<string, unknown>} The destination object.
+ *
+ * @example
+ * ```typescript
+ * import { defaults } from "./LodashUtils"
+ *
+ * const object = { a: 1 }
+ * const result = defaults(object, { b: 2 }, { a: 3, c: 3 })
+ * console.log(result) // { a: 1, b: 2, c: 3 }
+ *
+ * // undefined properties are filled in
+ * const partial = { a: 1, b: undefined }
+ * defaults(partial, { b: 2, c: 3 })
+ * console.log(partial) // { a: 1, b: 2, c: 3 }
+ * ```
+ */
+export declare function defaults(obj: Record<string, unknown>, ...sources: Record<string, unknown>[]): Record<string, unknown>;
+/**
+ * Checks if path is a direct property of object.
+ *
+ * This function checks whether the specified property exists directly on the object
+ * (not inherited from its prototype chain).
+ *
+ * @param {Record<string, unknown>} obj - The object to query.
+ * @param {string} path - The path to check.
+ * @returns {boolean} Returns true if path exists, else false.
+ *
+ * @example
+ * ```typescript
+ * import { has } from "./LodashUtils"
+ *
+ * const object = { a: 1, b: 2 }
+ * has(object, "a")        // true
+ * has(object, "c")        // false
+ * has(object, "toString") // false (inherited property)
+ * ```
+ */
+export declare function has(obj: Record<string, unknown>, path: string): boolean;
+/**
+ * Checks if value is an empty object, collection, map, or set.
+ *
+ * Values are considered empty if they are:
+ * - null or undefined
+ * - Arrays or strings with length 0
+ * - Maps or Sets with size 0
+ * - Objects with no enumerable properties
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {boolean} Returns true if value is empty, else false.
+ *
+ * @example
+ * ```typescript
+ * import { isEmpty } from "./LodashUtils"
+ *
+ * isEmpty(null)           // true
+ * isEmpty(undefined)      // true
+ * isEmpty("")             // true
+ * isEmpty([])             // true
+ * isEmpty({})             // true
+ * isEmpty(new Map())      // true
+ * isEmpty(new Set())      // true
+ * isEmpty("hello")        // false
+ * isEmpty([1, 2, 3])      // false
+ * isEmpty({ a: 1 })       // false
+ * ```
+ */
+export declare function isEmpty(value: unknown): boolean;
+/**
+ * Performs a deep comparison between two values to determine if they are equivalent.
+ *
+ * This function recursively compares objects and arrays, checking that all nested
+ * properties and elements are equal. Handles null/undefined values, primitive types,
+ * arrays, and plain objects.
+ *
+ * @param {unknown} value - The value to compare.
+ * @param {unknown} other - The other value to compare.
+ * @returns {boolean} Returns true if the values are equivalent, else false.
+ *
+ * @example
+ * ```typescript
+ * import { isEqual } from "./LodashUtils"
+ *
+ * isEqual(1, 1)                    // true
+ * isEqual("hello", "hello")        // true
+ * isEqual([1, 2], [1, 2])         // true
+ * isEqual({ a: 1 }, { a: 1 })     // true
+ * isEqual([1, 2], [2, 1])         // false
+ * isEqual({ a: 1 }, { a: 2 })     // false
+ *
+ * // Deep comparison
+ * const obj1 = { a: { b: 1 } }
+ * const obj2 = { a: { b: 1 } }
+ * isEqual(obj1, obj2)              // true
+ * ```
+ */
+export declare function isEqual(value: unknown, other: unknown): boolean;
+/**
+ * Copies all enumerable own properties from one or more source objects to a target object.
+ * @param target The destination object.
+ * @param sources The source objects.
+ * @returns Returns the modified target object.
+ */
+export declare function assign<T extends Record<string, any>>(target: T, ...sources: Partial<T>[]): T;
+/**
+ *
+ */
+export declare function get<T = unknown>(obj: unknown, path: string | string[], defaultValue?: T): T;
+/**
+ *
+ */
+export declare function includes<T>(collection: T[] | string | Record<string, T>, value: T, fromIndex?: number): boolean;
+/**
+ * Iterates over elements of `collection` and invokes `iteratee` for each element.
+ * @param collection The collection to iterate over (array or object).
+ * @param iteratee   The function invoked per iteration.
+ */
+export declare function forEach<T>(collection: T[] | Record<string, T>, iteratee: (value: T, key: string | number, collection: any) => void): void;
+/**
+ * Creates an array of values by running each element in collection thru iteratee.
+ * @param collection The collection to iterate over.
+ * @param iteratee The function invoked per iteration.
+ * @returns Returns the new mapped array.
+ */
+export declare function map<T, U>(collection: T[] | Record<string, T>, iteratee: (value: T, key: string | number, collection: any) => U): U[];
+/**
+ * Recursively merges own and inherited enumerable string keyed properties of source
+ * objects into the destination object. Source properties that resolve to undefined
+ * are skipped if a destination value exists.
+ * @param target The destination object.
+ * @param sources The source objects.
+ * @returns Returns the destination object.
+ */
+export declare function merge<T extends Record<string, any>>(target: T, ...sources: Partial<T>[]): T;
+/**
+ * Merges `defaults` into `obj` (shallow clone) and returns the result.
+ * Properties in `obj` overwrite those in `defaults`.
+ * @param obj - Target object (can be empty)
+ * @param defaults - Default values
+ * @returns New object with merged values
+ */
+export declare const output: <T extends Record<string, unknown>>(obj: Partial<T>, defaults: T) => T;
+/**
+ * Creates a new array concatenating the input arrays and/or values.
+ * @param arrays Arrays and/or values to concatenate.
+ * @returns Returns the new concatenated array.
+ */
+export declare function concat<T>(...arrays: (T[] | T)[]): T[];
+/**
+ * Iterates over all enumerable properties (own + inherited) of an object.
+ * Behaviour matches Lodash `forIn`.
+ * @param obj - Object to iterate
+ * @param fn - Function to execute for each property (value, key, object)
+ */
+export declare const forIn: <T extends Record<string, unknown>>(obj: T, fn: (value: T[keyof T], key: string, object: T) => void) => void;
+/**
+ * Returns an array of the object's own enumerable property keys.
+ * @param obj - Any object
+ * @returns Array of keys
+ */
+export declare const keys: <T extends Record<string, unknown>>(obj: T) => string[];
+/**
+ * Returns the first `n` elements of an array.
+ * @param arr - Source array
+ * @param n - Number of elements to take (default: 1)
+ * @returns New array containing the taken elements
+ */
+export declare const take: <T>(arr: T[], n?: number) => T[];
+/**
+ * Returns the last `n` elements of an array.
+ * @param arr - Source array
+ * @param n - Number of elements to take (default: 1)
+ * @returns New array containing the taken elements
+ */
+export declare const takeRight: <T>(arr: T[], n?: number) => T[];

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

@@ -0,0 +1,29 @@
+import * as loglevel from "loglevel";
+export declare const log: {
+    default: loglevel.RootLogger;
+    noConflict(): any;
+    getLogger(name: string | symbol): loglevel.Logger;
+    getLoggers(): {
+        [name: string]: loglevel.Logger;
+    };
+    levels: loglevel.LogLevel;
+    methodFactory: loglevel.MethodFactory;
+    trace(...msg: any[]): void;
+    debug(...msg: any[]): void;
+    log(...msg: any[]): void;
+    info(...msg: any[]): void;
+    warn(...msg: any[]): void;
+    error(...msg: any[]): void;
+    setLevel(level: loglevel.LogLevelDesc, persist?: boolean | undefined): void;
+    getLevel(): 0 | 1 | 2 | 3 | 4 | 5;
+    setDefaultLevel(level: loglevel.LogLevelDesc): void;
+    resetLevel(): void;
+    enableAll(persist?: boolean | undefined): void;
+    disableAll(persist?: boolean | undefined): void;
+    rebuild(): void;
+};
+/**
+ * Sets log level.
+ * Note that, we limit user to set only some of the levels.
+ */
+export declare const setLogLevel: (level: string) => void;

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

@@ -0,0 +1,40 @@
+import * as THREE from "three";
+/**
+ * MaterialUtils class
+ * @internal
+ */
+export declare class MaterialUtils {
+    /**
+     * Compares two materials
+     */
+    static materialEquals(m1: THREE.Material, m2: THREE.Material): boolean;
+    /**
+     * Compares two materials, which could be material or material array
+     */
+    static materialsEquals(m1: THREE.Material | THREE.Material[], m2: THREE.Material | THREE.Material[]): boolean;
+    /**
+     * Compares two colors
+     */
+    static colorEquals(c1: THREE.Color, c2: THREE.Color): boolean;
+    static clonedHighlightMaterials(mesh: THREE.Mesh | THREE.Line | THREE.Points, options?: {
+        depthTest?: boolean;
+        highlightColor?: THREE.Color;
+        opacity?: number;
+    }): THREE.Material | THREE.Material[] | undefined;
+    static clonedHighlightMaterial(material: THREE.Material, options?: {
+        depthTest?: boolean;
+        highlightColor?: THREE.Color;
+        opacity?: number;
+    }): THREE.Material;
+    /**
+     * Clone given material(s)
+     */
+    static cloneMaterial(material: THREE.Material | THREE.Material[]): THREE.Material | THREE.Material[];
+    static getMaterialColor(material: THREE.Material | THREE.Material[]): THREE.Color;
+    static setMaterialColor(material: THREE.Material | THREE.Material[], color: THREE.Color): void;
+    static setMaterialOpacity(material: THREE.Material | THREE.Material[], opacity: number): void;
+    /**
+     * Clone object's materials
+     */
+    static cloneMaterials(object: THREE.Object3D): void;
+}

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

@@ -0,0 +1,41 @@
+import * as THREE from "three";
+/**
+ * @internal
+ */
+export declare class MathUtils {
+    static roundNumber(value: number, n: number): number;
+    static floorNumber(value: number, n: number): number;
+    static areNumbersEqual(a: number, b: number, epsilon?: number): boolean;
+    static areVector2sEqual(a: THREE.Vector2, b: THREE.Vector2, epsilon?: number): boolean;
+    static areVector3sEqual(a: THREE.Vector3, b: THREE.Vector3, epsilon?: number): boolean;
+    static areNumbersClose(a: number, b: number, ref_tol?: number, abs_tol?: number): boolean;
+    static areVector2sClose(point1: THREE.Vector2, point2: THREE.Vector2, ref_tol?: number, abs_tol?: number): boolean;
+    static areVectorsClose(point1: THREE.Vector3, point2: THREE.Vector3, ref_tol?: number, abs_tol?: number): boolean;
+    static getArcAngleSpanInRadian(startAngle: number, endAngle: number): number;
+    static getIntegerPartLength(num: number): number;
+    static getRelativeEps(num: number, epsilon?: number): number;
+    static getVector2RelativeEps(vec: THREE.Vector2, epsilon?: number): number;
+    static getControlPointByTwoPoints(p1: THREE.Vector2, p2: THREE.Vector2): THREE.Vector2;
+    static convertPointFromUEToGltf(point: THREE.Vector3): THREE.Vector3;
+    static convertPointFromGltfToUE(point: THREE.Vector3): THREE.Vector3;
+    static convertPointFromUEToRevit(point: THREE.Vector3): THREE.Vector3;
+    static convertPointFromRevitToUE(point: THREE.Vector3): THREE.Vector3;
+    static getBox(point1: THREE.Vector3, point2: THREE.Vector3): number[];
+    static getCenter(box: THREE.Box3): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    static convertBoxFromGltfToUE(box: THREE.Box3): number[];
+    static convertBoxFromUEToGltf(box: THREE.Box3): number[];
+    static convertBoxFromRevitToUE(box: THREE.Box3): number[];
+    static convertBoxFromUEToRevit(box: THREE.Box3): number[];
+    static clamp(value: number, min: number, max: number): number;
+    static getLookAtMatrix(eye: THREE.Vector3, target: THREE.Vector3, up: THREE.Vector3): number[];
+    static getLocationFromMatrix(matrix: THREE.Matrix4): THREE.Vector3;
+    static toDegrees(radians: number): number;
+    static toRadians(degrees: number): number;
+    static signNotZero(v: number): 1 | -1;
+    static fromSnorm(value: number, maxRange: number): number;
+    static OctDecode(vec2: THREE.Vector2, vec3: THREE.Vector3, maxRange: number): void;
+}