@x-viewer/core 0.9.0

package/dist/types/core/model/bimtiles/Utils.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from "three";
+/**
+ * Decodes an array (Uint8Array, etc.) to string.
+ */
+export declare function arrayToString(array: ArrayBufferLike): string;
+/**
+ * Gets tileObjectId by tilesetId and userId.
+ * A tileObjectId is a 32-bit float number composed of an 8-bit tilesetId and 24-bit userId.
+ * @param tilesetId A 8-bit number represents model's id, valid value is 0-255.
+ * This means we can support a maximum of 255 bimtiles models.
+ * @param userId A 24-bit number, valid value is 0-16777215 (0xffffff).
+ * This means we can support a maximum of 16777215 primitives ( A familyinstance may have multiple primitives ) in a bimtiles model.
+ */
+export declare function tilesetAndUserId2TileObjectId(tilesetId: number, userId: number): number;
+/**
+ * Gets userId by tileObjectId.
+ */
+export declare function tileObjectId2UserId(tileObjectId: number): number;
+/**
+ * Gets tilesetId from color.
+ * @param rgba Color value between 0 and 255.
+ */
+export declare function color2TilesetId(rgba: number[]): number;
+/**
+ * Gets userId from color.
+ * @param rgba Color value between 0 and 255.
+ */
+export declare function color2UserId(rgba: number[]): number;
+export declare function decodeNormal(normals: THREE.TypedArray): Float32Array;

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

@@ -0,0 +1,6 @@
+export * from "./Constants";
+export * from "./Model";
+export * from "./Model2d";
+export * from "./Model3d";
+export * from "./bimtiles/BimTilesModel";
+export * from "./bimtiles/BimTilesRenderer";

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

@@ -0,0 +1,6 @@
+/**
+ * ThreeJS' raycaster calculates all intersections, thus has a worse performance,
+ * here we add a flag to reduce the number of intersections to improve performance.
+ * @internal
+ */
+export declare const MaxRaycastIntersectionCount = 1;

package/dist/types/core/patches/Line.d.ts

@@ -0,0 +1,2 @@
+import { Line } from "three";
+export { Line };

package/dist/types/core/patches/Mesh.d.ts

@@ -0,0 +1,2 @@
+import { Mesh } from "three";
+export { Mesh };

package/dist/types/core/patches/Points.d.ts

@@ -0,0 +1,2 @@
+import { Points } from "three";
+export { Points };

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

@@ -0,0 +1,4 @@
+export * from "./Line";
+export * from "./Mesh";
+export * from "./Points";
+export * from "./shaders/ShaderChunk";

package/dist/types/core/patches/shaders/ShaderChunk.d.ts

@@ -0,0 +1,2 @@
+import { ShaderChunk } from "three";
+export { ShaderChunk };

package/dist/types/core/patches/shaders/shaderChunk/common_ex.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n    // When an object is transparent, we'll change its alpha value,\n    // but we should not assign a fixed value because it may already\n    // has an alpha value that is lower than 1.\n    // So, let's multiply a factor.\n    // const float TRANSPARENT_FACTOR = 0.5;\n    // Object color when isolated.\n    // const vec4 ISOLATE_COLOR = vec4(0.5, 0.5, 0.5, 0.2);\n    const vec4 HIGHLIGHT_COLOR = vec4(0.031, 0.906, 0.867, 0.5); // 0x08e8de\n\n    // a value between 1-2, a bigger value results in more significant effect\n    const float HOVER_FACTOR = 1.2;\n\n    // need to make sure the value is the same as in StateType enum.\n    const int StateType_Hidden = 0;\n    const int StateType_Transparent = 1;\n    const int StateType_Highlighted = 2;\n    const int StateType_Hovered = 3;\n\n    /**\n     * Converts a tileObjectId(tilesetId + userId) to color.\n     */\n    vec4 tileObjectId2Color(int id) {\n        int r = id >> 16 & 0xff;\n        int g = id >> 8 & 0xff;\n        int b = id >> 0 & 0xff;\n        int a = id >> 24 & 0xff;\n        return vec4(float(r) / 255.0, float(g) / 255.0, float(b) / 255.0, float(a) / 255.0);\n    }\n\n    // /**\n    //  * Gets tilesetId and userId from a color.\n    //  * (rgb, a) => (userId, tilesetId)\n    //  */\n    // vec2 color2Id(vec4 color) {\n    //     int userId = (int(color.r) << 16) + (int(color.g) << 8)  + (int(color.b) << 0);\n    //     int tilesetId = (int(color.a) << 24);\n    //     return vec2(userId, tilesetId);\n    // }\n\n    /**\n     * Gets userId by tileObjectId.\n     */\n    int tileObjectId2UserId(int tileObjectId) {\n        return tileObjectId & 0x00ffffff;\n    }\n\n    /**\n     * Gets texture color (which contains hidden/transparent/highlight status) form a userId\n     */\n    vec4 getTextureColorByTileObjectId(sampler2D sampler, float textureWidth, float textureHeight, int tileObjectId) {\n        float userId = float(tileObjectId2UserId(tileObjectId));\n        float indexX = mod(userId, textureWidth);\n        float indexY = floor(userId / textureWidth);\n        vec2 texCoord = vec2(indexX / textureWidth, indexY / textureHeight);\n        return texture2D(sampler, texCoord);\n    }\n\n    /**\n     * Gets the flag(0 or 1) from a number by given StateType.\n     * @param num A uint8 number.\n     */\n    bool getFlagByStateType(int num, int state) {\n        // the bit index is the state itself\n        int bitIdx = state;\n        return (num & (0x1 << bitIdx)) != 0;\n    }\n\n    /**\n     * Flags(Hidden/Transparent/Hovered/Highlighted) are in textureColor.r value.\n     */\n    bool getFlagByColor(vec4 textureColor, int state) {\n        // map a color value from 0-1 to range 0-255\n        int num = int(textureColor.r * 255.0);\n        return getFlagByStateType(num, state);\n    }\n\n    /**\n     * Checks if an object is hidden by transparent cloned mesh.\n     */\n    bool isTransparentHidden(vec4 textureColor) {\n        int num = int(textureColor.b * 255.0);\n        return getFlagByStateType(num, StateType_Hidden);\n    }\n\n    /**\n     * Checks if an object is hidden by the \"color\".\n     */\n    bool isHidden(vec4 textureColor) {\n        return getFlagByColor(textureColor, StateType_Hidden);\n    }\n\n    /**\n     * Checks if an object is transparent by the \"color\".\n     */\n    bool isTransparent(vec4 textureColor) {\n        return getFlagByColor(textureColor, StateType_Transparent);\n    }\n\n    /**\n     * Gets opacity value between 0-1.\n     */\n    lowp float getOpacity(vec4 textureColor) {\n        return textureColor.g;\n    }\n\n    /**\n     * Checks if an object is hovered by the \"color\".\n     */\n    bool isHovered(vec4 textureColor) {\n        return getFlagByColor(textureColor, StateType_Hovered);\n    }\n\n    // bool isIsolated(vec4 textureColor) {\n    //     return textureColor.b > 0.5;\n    // }\n\n    /**\n     * Checks if an object is highlighted by the \"color\".\n     */\n    bool isHighlighted(vec4 textureColor) {\n        return getFlagByColor(textureColor, StateType_Highlighted);\n    }\n\n    /**\n     * Changes a color value by some means. Here, we either multiply or devide a HOVER_FACTOR.\n     */\n    float getChangedValueForHoverEffect(float val) {\n        return (val < 0.5) ? (val * HOVER_FACTOR) : (val / HOVER_FACTOR);\n    }\n\n    /**\n     * Gets hovered color by original color.\n     */\n    vec4 getHoveredColor(vec4 color) {\n        color.r = getChangedValueForHoverEffect(color.r);\n        color.g = getChangedValueForHoverEffect(color.g);\n        color.b = getChangedValueForHoverEffect(color.b);\n        return color;\n    }\n\n    // TODO: isHighlighted isOverride isHovered\n";
+export default _default;

package/dist/types/core/patches/shaders/shaderChunk/id_pars_vertex.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n    attribute int tileObjectId;\n    flat varying int vTileObjectId;\n";
+export default _default;

package/dist/types/core/patches/shaders/shaderChunk/id_vertex.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n    vTileObjectId = tileObjectId;\n";
+export default _default;

package/dist/types/core/patches/shaders/shaderChunk/outine_bc_vertex.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n    #ifdef USE_BC_OUTLINE\n        // Restore barycentric coordinates\n        int barycentricX = int(barycentric) & 0x1;\n        int barycentricY = int(barycentric) & 0x2;\n        int barycentricZ = int(barycentric) & 0x4;\n        vBarycentric = vec3(float(barycentricX), float(barycentricY), float(barycentricZ));\n    #endif\n";
+export default _default;

package/dist/types/core/patches/shaders/shaderChunk/outline_bc_fragment.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n        #ifdef USE_BC_OUTLINE\n            vec3 finWireframeColor = outlineColor;\n            vec3 tempColor = gl_FragColor.rgb;\n\n            gl_FragColor.rgb = mix(finWireframeColor, tempColor, edgeFactor3());\n        #endif\n";
+export default _default;

package/dist/types/core/patches/shaders/shaderChunk/outline_bc_pars_fragment.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n    #ifdef USE_BC_OUTLINE\n        varying vec3 vBarycentric;\n        uniform vec3 outlineColor;\n\n        float edgeFactor3() {\n            vec3 d = fwidth(vBarycentric);\n            float minValue = 0.0000001;\n            // make sure d is not 0\n            d = clamp(d, vec3(minValue), vec3(10.0));\n            vec3 a3 = smoothstep(vec3(0.0), d * 0.8, vBarycentric);\n            return min(min(a3.x, a3.y), a3.z);\n        }\n    #endif\n";
+export default _default;

package/dist/types/core/patches/shaders/shaderChunk/outline_bc_pars_vertex.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n    #ifdef USE_BC_OUTLINE \n        attribute float barycentric;\n        varying vec3 vBarycentric;\n    #endif\n";
+export default _default;

package/dist/types/core/patches/shaders/shaderChunk/state_fragment.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n    vec4 textureColor = getTextureColorByTileObjectId(uStateTexture, uTextureWidth, uTextureHeight, vTileObjectId);\n    // if (uHoverId == tileObjectId) {\n    //     gl_FragColor = uHoverColor;\n    // }\n    // if(uIsIsolating) {\n    //     // hide others\n    //     if (!isIsolated(textureColor)) {\n    //         // transparent others\n    //         if (uTransparentOthersForIsolation) {\n    //             gl_FragColor = vec4(0.9, 0.9, 0.9, 0.3);\n    //         } else {\n    //             // hide others when isolating.\n    //             discard;\n    //         }\n    //     }\n    // } else {\n        // TODO: Status priority and mutual exclusion\n        if (isHidden(textureColor)) {\n            discard;\n        }\n        // If entity is transparent just discard, draw in transparent material\n        if (isTransparent(textureColor)) {\n            discard;\n        }\n        if (isHighlighted(textureColor)) {\n            discard;\n        }\n        if (isHovered(textureColor)) {\n            gl_FragColor = getHoveredColor(diffuseColor);\n            return;\n        }\n        // TODO:custom color\n        // if (isOverride(textureColor)) {\n        //     gl_FragColor = vec4(0.5, 0.5, 0.5, 0.8);\n        // }\n    // }\n";
+export default _default;

package/dist/types/core/patches/shaders/shaderChunk/state_highlight_fragment.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n    vec4 textureColor = getTextureColorByTileObjectId(uStateTexture, uTextureWidth, uTextureHeight, vTileObjectId);\n    // State priority (high to low):\n    // - Hidden\n    // - Transparent\n    // - Highlighted: A transparent object should not highlighted in the same time!\n    // - Hovered\n    if (isHidden(textureColor)) {\n        discard;\n    } else if (isTransparent(textureColor)) {\n        lowp float opacity = getOpacity(textureColor);\n        diffuseColor.a *= opacity;\n        gl_FragColor = diffuseColor;\n        return;\n    } else if (isHighlighted(textureColor)) {\n        gl_FragColor = HIGHLIGHT_COLOR;\n        return;\n    }\n";
+export default _default;

package/dist/types/core/patches/shaders/shaderChunk/state_pars_fragment.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n    flat varying int vTileObjectId;\n    uniform float uTextureWidth;\n    uniform float uTextureHeight;\n    uniform sampler2D uStateTexture;\n    // uniform vec4 uHoverColor;\n    // uniform int uHoverId;\n    // uniform bool uIsIsolating;\n    // uniform bool uTransparentOthersForIsolation;\n";
+export default _default;

package/dist/types/core/patches/shaders/shaderChunk/state_transparent_fragment.glsl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "\n    vec4 textureColor = getTextureColorByTileObjectId(uStateTexture, uTextureWidth, uTextureHeight, vTileObjectId);\n    // State priority (high to low):\n    // - Hidden\n    // - Transparent\n    // - Highlighted: A transparent object should not highlighted in the same time!\n    // - Hovered\n    if (isTransparentHidden(textureColor)) {\n        discard;\n    } else if (isTransparent(textureColor)) {\n        lowp float opacity = getOpacity(textureColor);\n        diffuseColor.a *= opacity;\n        gl_FragColor = diffuseColor;\n        return;\n    } else if (isHighlighted(textureColor)) {\n        gl_FragColor = HIGHLIGHT_COLOR;\n        return;\n    }\n";
+export default _default;

package/dist/types/core/patches/shaders/shaderLib/pick_ex.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const vertex = "\n    #include <clipping_planes_pars_vertex>\n\n    attribute int tileObjectId;\n    flat varying int vTileObjectId;\n    #include <common_ex>\n    void main() {\n\n        vec4 mvPosition = vec4(position, 1.0);\n        #include <clipping_planes_vertex>\n        vTileObjectId = tileObjectId;\n\n        #ifdef USE_INSTANCING\n            mvPosition = instanceMatrix * mvPosition;\n        #endif\n        gl_Position = projectionMatrix * modelViewMatrix * mvPosition;\n    }\n";
+export declare const fragment = "\n    #include <clipping_planes_pars_fragment>\n\n    flat varying int vTileObjectId;\n    uniform sampler2D uStateTexture;\n    uniform float uTextureWidth;\n    uniform float uTextureHeight;\n    // uniform bool uIsIsolating;\n    #include <common_ex>\n    void main() {\n        #include <clipping_planes_fragment>\n        vec4 textureColor = getTextureColorByTileObjectId(uStateTexture, uTextureWidth, uTextureHeight, vTileObjectId);\n        // If is isolating, other objects(which is hidden or transparent) are not pickable.\n        // if (uIsIsolating && !isIsolated(textureColor)) {\n        //     discard;\n        // }\n        // if an object is hidden, it is not pickable\n        if (isHidden(textureColor)) {\n            discard;\n        }\n        // if an object is transparent, it is not pickable\n        if (isTransparent(textureColor)) {\n            discard;\n        }\n\n        gl_FragColor = tileObjectId2Color(vTileObjectId);\n    }\n";

package/dist/types/core/patches/shaders/shaderLib/standard_ex.glsl.d.ts

@@ -0,0 +1,2 @@
+export declare const vertex = "\n#define STANDARD\n\nvarying vec3 vViewPosition;\n\n#ifdef USE_TRANSMISSION\n\n\tvarying vec3 vWorldPosition;\n\n#endif\n\n#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <normal_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n\n#include <outline_bc_pars_vertex>\n\nvoid main() {\n\n\t#include <uv_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\n    #include <outline_bc_vertex>\n\n\t#include <beginnormal_vertex>\n\t#include <morphnormal_vertex>\n\t#include <skinbase_vertex>\n\t#include <skinnormal_vertex>\n\t#include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t#include <project_vertex>\n\t#include <logdepthbuf_vertex>\n\t#include <clipping_planes_vertex>\n\n\tvViewPosition = - mvPosition.xyz;\n\n\t#include <worldpos_vertex>\n\t#include <shadowmap_vertex>\n\t#include <fog_vertex>\n\n#ifdef USE_TRANSMISSION\n\n\tvWorldPosition = worldPosition.xyz;\n\n#endif\n}\n";
+export declare const fragment = "\n#define STANDARD\n\n#ifdef PHYSICAL\n\t#define IOR\n\t#define USE_SPECULAR\n#endif\n\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\n\n#ifdef IOR\n\tuniform float ior;\n#endif\n\n#ifdef USE_SPECULAR\n\tuniform float specularIntensity;\n\tuniform vec3 specularColor;\n\n\t#ifdef USE_SPECULAR_COLORMAP\n\t\tuniform sampler2D specularColorMap;\n\t#endif\n\n\t#ifdef USE_SPECULAR_INTENSITYMAP\n\t\tuniform sampler2D specularIntensityMap;\n\t#endif\n#endif\n\n#ifdef USE_CLEARCOAT\n\tuniform float clearcoat;\n\tuniform float clearcoatRoughness;\n#endif\n\n#ifdef USE_IRIDESCENCE\n\tuniform float iridescence;\n\tuniform float iridescenceIOR;\n\tuniform float iridescenceThicknessMinimum;\n\tuniform float iridescenceThicknessMaximum;\n#endif\n\n#ifdef USE_SHEEN\n\tuniform vec3 sheenColor;\n\tuniform float sheenRoughness;\n\n\t#ifdef USE_SHEEN_COLORMAP\n\t\tuniform sampler2D sheenColorMap;\n\t#endif\n\n\t#ifdef USE_SHEEN_ROUGHNESSMAP\n\t\tuniform sampler2D sheenRoughnessMap;\n\t#endif\n#endif\n\n#ifdef USE_ANISOTROPY\n\tuniform vec2 anisotropyVector;\n\n\t#ifdef USE_ANISOTROPYMAP\n\t\tuniform sampler2D anisotropyMap;\n\t#endif\n#endif\n\nvarying vec3 vViewPosition;\n\n#include <common>\n#include <packing>\n#include <dithering_pars_fragment>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <alphatest_pars_fragment>\n#include <alphahash_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <iridescence_fragment>\n#include <cube_uv_reflection_fragment>\n#include <envmap_common_pars_fragment>\n#include <envmap_physical_pars_fragment>\n#include <fog_pars_fragment>\n#include <lights_pars_begin>\n#include <normal_pars_fragment>\n#include <lights_physical_pars_fragment>\n#include <transmission_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <clearcoat_pars_fragment>\n#include <iridescence_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\n\n#include <outline_bc_pars_fragment>\n\nvoid main() {\n\n\t#include <clipping_planes_fragment>\n\n\tvec4 diffuseColor = vec4(diffuse, opacity);\n\tReflectedLight reflectedLight = ReflectedLight(vec3(0.0), vec3(0.0), vec3(0.0), vec3(0.0));\n\tvec3 totalEmissiveRadiance = emissive;\n\n\t#include <logdepthbuf_fragment>\n\t#include <map_fragment>\n\t#include <color_fragment>\n\t#include <alphamap_fragment>\n\t#include <alphatest_fragment>\n\t#include <alphahash_fragment>\n\t#include <roughnessmap_fragment>\n\t#include <metalnessmap_fragment>\n\t#include <normal_fragment_begin>\n\t#include <normal_fragment_maps>\n\t#include <clearcoat_normal_fragment_begin>\n\t#include <clearcoat_normal_fragment_maps>\n\t#include <emissivemap_fragment>\n\n\t// accumulation\n\t#include <lights_physical_fragment>\n\t#include <lights_fragment_begin>\n\t#include <lights_fragment_maps>\n\t#include <lights_fragment_end>\n\n\t// modulation\n\t#include <aomap_fragment>\n\n\tvec3 totalDiffuse = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse;\n\tvec3 totalSpecular = reflectedLight.directSpecular + reflectedLight.indirectSpecular;\n\n\t#include <transmission_fragment>\n\n\tvec3 outgoingLight = totalDiffuse + totalSpecular + totalEmissiveRadiance;\n\n\t#ifdef USE_SHEEN\n\n\t\t// Sheen energy compensation approximation calculation can be found at the end of\n\t\t// https://drive.google.com/file/d/1T0D1VSyR4AllqIJTQAraEIzjlb5h4FKH/view?usp=sharing\n\t\tfloat sheenEnergyComp = 1.0 - 0.157 * max3(material.sheenColor);\n\n\t\toutgoingLight = outgoingLight * sheenEnergyComp + sheenSpecular;\n\n\t#endif\n\n\t#ifdef USE_CLEARCOAT\n\n\t\tfloat dotNVcc = saturate(dot(geometry.clearcoatNormal, geometry.viewDir));\n\n\t\tvec3 Fcc = F_Schlick(material.clearcoatF0, material.clearcoatF90, dotNVcc);\n\n\t\toutgoingLight = outgoingLight * (1.0 - material.clearcoat * Fcc) + clearcoatSpecular * material.clearcoat;\n\n\t#endif\n\n\t#include <opaque_fragment>\n\t#include <tonemapping_fragment>\n\t#include <colorspace_fragment>\n\t#include <fog_fragment>\n\t#include <premultiplied_alpha_fragment>\n\t#include <dithering_fragment>\n\n    #include <outline_bc_fragment>\n}\n";

package/dist/types/core/pick/PickManager.d.ts

@@ -0,0 +1,52 @@
+import * as THREE from "three";
+import { TileObject } from "../model";
+import type { BaseViewer } from "../../core/viewers";
+export declare class PickManager {
+    private readonly CLEAR_COLOR;
+    private readonly CLEAR_COLOR_ALPHA;
+    private readonly EMPTY_MODEL_ID;
+    private viewer;
+    private raycaster;
+    private pickingTexture;
+    constructor(viewer: BaseViewer);
+    get scene(): THREE.Scene<THREE.Object3DEventMap>;
+    get camera(): THREE.OrthographicCamera;
+    get renderer(): THREE.WebGLRenderer;
+    get overlayRender(): import("..").CanvasRender;
+    get viewerContainer(): HTMLElement;
+    getRaycaster(): THREE.Raycaster;
+    /**
+     * Picks objects by NDC coordinate.
+     */
+    pickObjectsByNdc(ndcCoord: THREE.Vector2, objects: THREE.Object3D[], layerChannels?: number[]): THREE.Intersection[];
+    /**
+     * Picks the closest object by mouse position.
+     */
+    pickObject(mousePosition: THREE.Vector2, objects: THREE.Object3D[], layerChannels?: number[]): THREE.Intersection | undefined;
+    /**
+     * Picks objects by mouse position.
+     */
+    pickObjects(mousePosition: THREE.Vector2, objects: THREE.Object3D[], layerChannels?: number[]): THREE.Intersection[];
+    /**
+     * Picks a drawable by world position.
+     */
+    pickDrawable(worldPosition: THREE.Vector3): import("..").Drawable<Record<string, unknown>>[];
+    /**
+     * Picks an object by mouse position.
+     */
+    pick(mousePosition: THREE.Vector2, pickScene: THREE.Scene): TileObject | undefined;
+    /**
+     * Sets raycaster's layer channels.
+     */
+    private setLayerChannels;
+    /**
+     *
+     * @param mousePosition
+     * @param width
+     * @param height
+     * @param pickScene
+     * @returns
+     * @description pick rect area buffer
+     */
+    private pickBuffer;
+}

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

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

package/dist/types/core/scene/SceneManager.d.ts

@@ -0,0 +1,48 @@
+import * as THREE from "three";
+import { Model } from "../../core/model";
+import type { BaseViewer } from "../../core/viewers/BaseViewer";
+export declare class SceneManager {
+    private viewer;
+    scene: THREE.Scene;
+    renderer: THREE.WebGLRenderer;
+    private pmremGenerator?;
+    private lights?;
+    private modelGroup;
+    constructor(viewer: BaseViewer);
+    private initLights;
+    private initPMREMGenerator;
+    get maxFragmentUniforms(): number;
+    addModel(model: Model): void;
+    removeModel(model: Model): void;
+    /**
+     * Get the root Three.js objects of all loaded models.
+     */
+    getModelsRoot(): THREE.Group;
+    enableShadow(enable: boolean): void;
+    enableClipping(enable: boolean): void;
+    setClipPlanes(planes: THREE.Plane[]): void;
+    enableLights(enable: boolean): void;
+    debugLights(enable: boolean): void;
+    setBackground(background: THREE.Color | THREE.CubeTexture | THREE.Texture | null): void;
+    get directionalLight(): THREE.DirectionalLight;
+    get ambientLight(): THREE.Object3D<THREE.Object3DEventMap> | undefined;
+    get hemisphereLight(): THREE.Object3D<THREE.Object3DEventMap> | undefined;
+    get lightHelpers(): THREE.Object3D<THREE.Object3DEventMap> | undefined;
+    get directionalLightHelper(): THREE.DirectionalLightHelper;
+    get cameraHelper(): THREE.CameraHelper;
+    setEnvironmentFromData(data?: Uint16Array): Promise<void>;
+    setEnvironment(hdrUrl: string): Promise<void>;
+    resize(): void;
+    getRaycastableObjects(): THREE.Object3D<THREE.Object3DEventMap>[];
+    tryAdjustDirectionalLight(): void;
+    /**
+     * @internal
+     */
+    updateDirectionalLight(): void;
+    private updateDirectionalLightShadow;
+    /**
+     * @internal
+     */
+    showDirectionalLightHelper(visible: boolean): void;
+    destroy(): void;
+}

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

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

package/dist/types/core/shp-js/BitView.d.ts

@@ -0,0 +1,12 @@
+export declare class BitView {
+    buffer: any;
+    u8: any;
+    constructor(buf: any);
+    getBit(idx: any): number;
+    setBit(idx: any, val: any): void;
+    getInt12(idx: any): number;
+    setInt12(idx: any, val: any): void;
+    getInt6(idx: any): number;
+    setInt6(idx: any, val: any): void;
+    test(): BitView;
+}

package/dist/types/core/shp-js/SHPLoader.d.ts

@@ -0,0 +1,12 @@
+import * as THREE from "three";
+/**
+ * ArcGIS SHP file loader
+ */
+export declare class SHPLoader {
+    load(url: string, onLoad: (object: THREE.Object3D) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): Promise<void>;
+    /**
+     *
+     * @param percent a number between [0, 100]
+     */
+    private updateProgress;
+}

package/dist/types/core/shp-js/Shp.d.ts

@@ -0,0 +1,10 @@
+export declare enum SHP {
+    NULL = 0,
+    POINT = 1,
+    POLYLINE = 3,
+    POLYGON = 5
+}
+export declare class SHPParser {
+    parse(arrayBuffer: any): any;
+    parseShape(dv: any, idx: any, length: any): any;
+}

package/dist/types/core/shp-js/ShpThree.d.ts

@@ -0,0 +1,23 @@
+import * as THREE from "three";
+/**
+ * Three.js extensions for SHP parser.
+ * Code is converted from JS to TS based on: https://github.com/kig/shp.js/
+ */
+export declare class ShpThree {
+    readonly LINE_MATERIAL: THREE.LineBasicMaterial;
+    readonly MESH_MATERIAL: THREE.MeshBasicMaterial;
+    /**
+     *
+     * @param shp
+     * @param spherize is spherize or not. This only works well for the sameple shp for now!
+     */
+    createModel(shp: any): THREE.Object3D;
+    loadCompressed(deltaEncoded: any): THREE.Object3D<THREE.Object3DEventMap>;
+    compress(shp: any): ArrayBuffer;
+    deltaEncode(arr: any): ArrayBuffer;
+    deltaEncode6(arr: any): ArrayBuffer;
+    storeDeltas(byteLen: any, polys: any): ArrayBuffer;
+    deltaDecode(buf: any): number[];
+    storeDeltas6(byteLen: any, polys: any): ArrayBuffer;
+    deltaDecode6(buf: any): number[];
+}

package/dist/types/core/shp-js/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./BitView";
+export * from "./SHPLoader";
+export * from "./Shp";
+export * from "./ShpThree";

package/dist/types/core/text-texture/TextTexture.d.ts

@@ -0,0 +1,45 @@
+import * as THREE from "three";
+export interface TextTextureConfig {
+    text?: string;
+    color?: string;
+    alignment?: string;
+    backgroundColor?: number;
+    fontFamily?: string;
+    /**
+     * With fontSize 18 it generates a 64x64 image, 20 generates 128x128 one.
+     */
+    fontSize?: number;
+    fontStyle?: string;
+    fontVariant?: string;
+    fontWeight?: string;
+    lineGap?: number;
+    padding?: number;
+    strokeColor?: string;
+    strokeWidth?: number;
+}
+export declare function toCssFont(family: string, size: number, style: string, variant: string, weight: string): string;
+export declare class TextTexture extends THREE.Texture {
+    private readonly canvas;
+    readonly textTexture = true;
+    private needsRedraw;
+    private contentOffset;
+    private lineOffset;
+    private _width;
+    private _height;
+    private lines;
+    private font;
+    private pixelRatio;
+    cfg: Required<TextTextureConfig>;
+    constructor(cfg: TextTextureConfig, canvas?: HTMLCanvasElement);
+    private getContentWidth;
+    private initDraw;
+    private getDrawPosition;
+    private draw;
+    private getDrawingBufferWidth;
+    private getDrawingBufferHeight;
+    private computeOptimalPixelRatio;
+    redrew(): void;
+    setPixelRatio(value: number): void;
+    setOptimalPixelRatio(object: THREE.Object3D, renderer: THREE.WebGLRenderer, camera: THREE.PerspectiveCamera | THREE.OrthographicCamera): void;
+    updateConfig(cfg: TextTextureConfig): void;
+}

package/dist/types/core/text-texture/index.d.ts

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

package/dist/types/core/undo/Command.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class Command {
+    protected name: string;
+    constructor(name: string);
+    abstract undo(): boolean;
+    abstract redo(): boolean;
+}

package/dist/types/core/undo/UndoManager.d.ts

@@ -0,0 +1,24 @@
+import { Command } from "./Command";
+type CommandData = Command | Command[];
+/**
+ * Undo/redo manager.
+ */
+export declare class UndoManager {
+    private history;
+    private step;
+    private maxCount;
+    private isBatchCommand;
+    private batchCommands;
+    constructor(maxCount?: number);
+    addCommand(command: Command): void;
+    startTransaction(): void;
+    endTransaction(): void;
+    undo(): boolean;
+    redo(): boolean;
+    getCommands(): CommandData[];
+    canUndo(): boolean;
+    canRedo(): boolean;
+    clear(): void;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,2 @@
+export * from "./UndoManager";
+export * from "./Command";

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

@@ -0,0 +1,14 @@
+import { CSS2DObject } from "three/examples/jsm/renderers/CSS2DRenderer.js";
+export declare class CSS2DObjectUtils {
+    /**
+     * Creates CSS2DObject with HTMLElement
+     */
+    static createCSS2DObject(element: HTMLElement): CSS2DObject;
+    static createDefaultHotpoint(size?: number): CSS2DObject;
+    static createHotpoint(html?: string): CSS2DObject;
+    static createLabel(label: string, cssClass?: string): CSS2DObject;
+    /**
+     * Recursively find "dataset.objectId" of a HTMLElement
+     */
+    static tryFindObjectId(element: HTMLElement): number | undefined;
+}

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

@@ -0,0 +1,6 @@
+export declare class CancelablePromise {
+    promise: Promise<unknown>;
+    private cancelReject?;
+    constructor(promise: Promise<unknown>);
+    cancel(): void;
+}

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

@@ -0,0 +1,25 @@
+export declare class ColorUtils {
+    static color2rgba(style: string): [number, number, number, number];
+    /**
+     * Converts float color array in format "[0.0, 1.0, 0.0, 1.0]" to css color "rgba(0, 255, 0, 1.0)".
+     */
+    static floatArray2CssColor(rgba: number[]): string;
+    /**
+     * Converts color string in format "rgba(255, 255, 255, 1)" to float number array.
+     */
+    static cssColor2FloatArray(colorStr: string): number[];
+    /**
+     * Converts rgb or rgba to hex number.
+     * E.g., [0.0, 1.0, 0.0] to 0x00ff00
+     * @param rgba Color value is between 0 and 1.
+     */
+    static floatArray2Hex(rgba: number[]): number;
+    /**
+     * Converts color value from float(0.0-1.0) to int (0-255)
+     */
+    private static float2Int;
+    /**
+     * Converts color value from int (0-255) to float(0.0-1.0)
+     */
+    private static int2Float;
+}

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

@@ -0,0 +1,141 @@
+import * as THREE from "three";
+import { IconClass } from "../Configs";
+/**
+ * @internal
+ */
+export declare class CommonUtils {
+    /**
+     * Checks full screen mode
+     */
+    static isFullScreen(): boolean;
+    /**
+     * Enters full screen mode
+     */
+    static fullScreen(element?: HTMLElement): void;
+    /**
+     * Exits full screen mode
+     */
+    static exitFullscreen(): void;
+    /**
+     * Displays a pointer marker in a period of time.
+     * @param duration display time in ms. 0/null/undefined means always display.
+     */
+    /**
+     * Join strings
+     * @param args
+     * @returns
+     */
+    static joinStrings(...args: string[]): string;
+    /**
+     * Converts a number to a string with proper fraction digits
+     */
+    static numberToString(num: number): string;
+    /**
+     * Converts a byte number to proper units(Kilobyte, Megabyte, Gigabyte, etc.)
+     * @param num
+     */
+    static byteCountToString(num: number): string;
+    static hexToBase64(hexstring: string): string;
+    /**
+     * Converts vector to a string with proper fraction digits
+     */
+    static vectorToString(vec: THREE.Vector2 | THREE.Vector3 | number[]): string;
+    /**
+     * Converts number array to THREE.Vector2
+     */
+    static arrayToVector2(arr: number[] | THREE.Vector2 | undefined): THREE.Vector2 | undefined;
+    /**
+     * Converts number array to THREE.Vector3
+     * If length of arr is 2, will assign z value to 0
+     */
+    static arrayToVector3(arr: number[] | THREE.Vector3 | undefined): THREE.Vector3 | undefined;
+    /**
+     * Converts number array to THREE.Euler
+     */
+    static arrayToEuler(arr: number[] | THREE.Euler | undefined): THREE.Euler | undefined;
+    /**
+     * Converts number array to THREE.Vector3
+     */
+    static arrayOrObjectToVector3(arrOrObj: number[] | THREE.Vector3 | undefined): THREE.Vector3 | undefined;
+    static isVectorValid(vec: THREE.Vector2 | THREE.Vector3): boolean;
+    static isBoxValid(box: THREE.Box2 | THREE.Box3): boolean;
+    static isMatrixValid(matrix: THREE.Matrix4): boolean;
+    static guid(): string;
+    /**
+     * Expands given box by a scale factor
+     */
+    static expandBoxByScale(box: THREE.Box3, scale: number): void;
+    /**
+     * Expands given box by a min size
+     */
+    static expandBoxByMinSize(box: THREE.Box3, minSize: number): void;
+    /**
+     * Generate random integers in the range [min, max]
+     */
+    static generateRandomInt(min: number, max: number): number;
+    /**
+     * Round to N decimal places
+     */
+    static roundNumber(value: number, n: number): number;
+    /**
+     * Converts a decimal number or string to a hexadecimal color string.
+     * @param decimal Decimal number or string
+     */
+    static convertDecimalToHex(decimal: number | string): string;
+    /**
+     * Converts a canvas to an image
+     * @param canvas
+     */
+    static canvasToImage(canvas: HTMLCanvasElement): Promise<HTMLImageElement>;
+    /**
+     * Takes screenshot to given rendering context and return base64 string in png/jpeg format.
+     * @param bbox If valid, takes screenshot of a sub image with given bounding box in screen coordinate.
+     */
+    static renderingContextToImage(context: CanvasRenderingContext2D, bbox?: THREE.Box2, type?: string, quality?: number): string;
+    /**
+     * Prints memory usage
+     */
+    static printMemory(title: string): void;
+    static printGpuInfo(webgl: WebGLRenderingContext): void;
+    static getExtension(url: string): string;
+    static isBinaryFile(url: string): boolean;
+    static isGzip(data: Uint8Array): boolean;
+    /**
+     * Sleep a while
+     */
+    static sleep(ms: number): Promise<void>;
+    private static twinklingObjectIds;
+    /**
+     * Twinkle the object several times
+     */
+    static twinkle(obj: THREE.Object3D, ms?: number): Promise<void>;
+    /**
+     * Gets a function to update progress.
+     * @param onProgress onProgress callback.
+     */
+    static getUpdateProgressFunc(onProgress?: (e: ProgressEvent) => void): (progress: number) => void;
+    /**
+     * Gets an async function to update progress.
+     * The reason to use async function is, in order to give UI thread chance to update the progress!
+     * @param onProgress onProgress callback.
+     */
+    static getUpdateProgressFuncAsync(onProgress?: (e: ProgressEvent) => void): (progress: number) => Promise<void>;
+    /**
+     * Gets an async function to update progress for a for/while loop.
+     * @param total Total number of a for/while loop.
+     * @param onProgress onProgress callback.
+     */
+    static getUpdateProgressFuncForLoop(total: number, onProgress?: (e: ProgressEvent) => void): (i: number) => Promise<void>;
+    /**
+     * Gets a function to update sub progress, which has a progress range limitation according to its parent progress.
+     * @param min Min range number between 0-100
+     * @param max Max range number between 0-100
+     * @param onProgress onProgress callback.
+     * @returns
+     */
+    static getUpdateSubProgressFunc(min: number, max: number, onProgress?: (e: ProgressEvent) => void): (e: ProgressEvent) => void;
+}
+/**
+ * @internal
+ */
+export declare const setIcon: (classList: DOMTokenList, iconClass: IconClass, active: boolean) => void;