@xeokit/xeokit-sdk 2.6.64 → 2.6.66

package/src/plugins/SectionPlanesPlugin/Control.js

@@ -132,15 +132,13 @@ class Control {
         });
 
         const handlers = { };
-        const addAxis = (rgb, axisDirection, hoopDirection) => {
+        const addAxis = (rgb, hoopRot) => {
+            const axisDirection = math.mulVec3Scalar(rgb, -1, math.vec3());
             const material = colorMaterial(rgb);
 
-            const rotateToHorizontal = math.rotationMat4v(270 * math.DEGTORAD, [1, 0, 0], math.identityMat4());
-            const hoopRotation = math.quaternionToRotationMat4(math.vec3PairToQuaternion([ 0, 1, 0 ], hoopDirection), math.identityMat4());
-            const hoopMatrix = math.mulMat4(hoopRotation, rotateToHorizontal, math.identityMat4());
-
+            const hoopMatrix = math.quaternionToRotationMat4(hoopRot, math.identityMat4());
+            math.mulMat4(math.rotationMat4v(Math.PI, [0,1,0], math.mat4()), hoopMatrix, hoopMatrix);
             const scale = math.scaleMat4v([0.6, 0.6, 0.6], math.identityMat4());
-
             const scaledArrowMatrix = (t, matR) => {
                 const matT = math.translateMat4v(t, math.identityMat4());
                 const ret = math.identityMat4();
@@ -209,7 +207,8 @@ class Control {
             }), NO_STATE_INHERIT);
 
 
-            const axisRotation = math.quaternionToRotationMat4(math.vec3PairToQuaternion([ 0, 1, 0 ], axisDirection), math.identityMat4());
+            const axisRotation = math.quaternionToRotationMat4(math.vec3PairToQuaternion([ 0, 1, 0 ], rgb), math.identityMat4());
+            math.mulMat4(math.rotationMat4v(Math.PI, [0,1,0], math.mat4()), axisRotation, axisRotation);
 
             const translatedAxisMatrix = (yOffset) => math.mulMat4(axisRotation, math.translateMat4c(0, yOffset, 0, math.identityMat4()), math.identityMat4());
             const arrowMatrix = translatedAxisMatrix(arrowLength + .1);
@@ -270,8 +269,10 @@ class Control {
                 isObject: false
             }), NO_STATE_INHERIT);
 
+            const localToWorldVec = (localVec, worldVec) => math.vec3ApplyQuaternion(rootNode.quaternion, localVec, worldVec);
+
             const closestPointOnAxis = (function() {
-                const worldAxis = math.vec4();
+                const worldAxis = math.vec3();
                 const org = math.vec3();
                 const dir = math.vec3();
                 return (canvasPos, dst) => {
@@ -306,22 +307,39 @@ class Control {
                         if (closestPointOnAxis(canvasPos, tempVec3)) {
                             math.subVec3(tempVec3, initOffset, tempVec3);
                             setPos(tempVec3);
-                            if (self._sectionPlane) {
-                                self._sectionPlane.pos = tempVec3;
+                            if (this._sectionPlane) {
+                                this._sectionPlane.pos = tempVec3;
                             }
                         }
                     });
                 }
             };
 
-            const lastCanvasPos = math.vec2();
             handlers[rotateHandle.id] = {
                 setActivated: a => hoop.visible = a,
                 initDragAction: (initCanvasPos) => {
-                    lastCanvasPos.set(initCanvasPos);
+                    const rotationFromCanvasPos = (function() {
+                        const planeCanvasPos = camera.projectWorldPos(pos);
+                        localToWorldVec(rgb, tempVec3);
+                        math.transformVec3(camera.normalMatrix, tempVec3, tempVec3);
+                        const axisCoeff = Math.sign(tempVec3[2]);
+                        return (canvasPos) => {
+                            const dx = canvasPos[0] - planeCanvasPos[0];
+                            const dy = canvasPos[1] - planeCanvasPos[1];
+                            return axisCoeff * Math.atan2(-dy, dx);
+                        };
+                    })();
+
+                    let lastRotation = rotationFromCanvasPos(initCanvasPos);
+
                     return canvasPos => {
-                        dragRotateSectionPlane(rgb, lastCanvasPos, canvasPos);
-                        lastCanvasPos.set(canvasPos);
+                        const rotation = rotationFromCanvasPos(canvasPos);
+                        rootNode.rotate(rgb, (rotation - lastRotation) * 180 / Math.PI);
+                        if (this._sectionPlane) {
+                            ignoreNextSectionPlaneDirUpdate = true;
+                            this._sectionPlane.quaternion = rootNode.quaternion;
+                        }
+                        lastRotation = rotation;
                     };
                 }
             };
@@ -433,9 +451,9 @@ class Control {
             //
             //----------------------------------------------------------------------------------------------------------
 
-            addAxis([1,0,0], [ 1,  0,  0 ], [ 1, 0,  0 ]),
-            addAxis([0,1,0], [ 0, -1,  0 ], [ 0, 1,  0 ]),
-            addAxis([0,0,1], [ 0,  0, -1 ], [ 0, 0, -1 ])
+            addAxis([1,0,0], math.vec3PairToQuaternion([1,0,0], [0,0,1])),
+            addAxis([0,1,0], math.eulerToQuaternion([90,0,0], "XYZ")),
+            addAxis([0,0,1], math.identityQuaternion())
         ];
 
         const cleanups = [ ];
@@ -457,114 +475,6 @@ class Control {
             cleanups.push(() => scene.off(onSceneTick));
         }
 
-        const getClickCoordsWithinElement = (event, canvasPos) => {
-            if (!event) {
-                event = window.event;
-                canvasPos[0] = event.x;
-                canvasPos[1] = event.y;
-            } else {
-                const element = event.target;
-                const rect = element.getBoundingClientRect();
-                canvasPos[0] = event.clientX - rect.left;
-                canvasPos[1] = event.clientY - rect.top;
-            }
-        };
-
-        const localToWorldVec = (function () {
-            const mat = math.mat4();
-            return function (localVec, worldVec) {
-                math.quaternionToMat4(rootNode.quaternion, mat);
-                math.transformVec3(mat, localVec, worldVec);
-                math.normalizeVec3(worldVec);
-                return worldVec;
-            };
-        })();
-
-        const getTranslationPlane = (worldAxis, planeNormal) => {
-            const absX = Math.abs(worldAxis[0]);
-            if (absX > Math.abs(worldAxis[1]) && absX > Math.abs(worldAxis[2])) {
-                math.cross3Vec3(worldAxis, [0, 1, 0], planeNormal);
-            } else {
-                math.cross3Vec3(worldAxis, [1, 0, 0], planeNormal);
-            }
-            math.cross3Vec3(planeNormal, worldAxis, planeNormal);
-            math.normalizeVec3(planeNormal);
-        };
-
-        const self = this;
-        var dragRotateSectionPlane = (function () {
-            const p1 = math.vec4();
-            const p2 = math.vec4();
-            const c = math.vec4();
-            const worldAxis = math.vec4();
-            const dir = math.vec3();
-            const mat = math.mat4();
-            const planeNormal = math.vec3();
-            return function (baseAxis, fromMouse, toMouse) {
-                localToWorldVec(baseAxis, worldAxis);
-                const hasData = getPointerPlaneIntersect(fromMouse, worldAxis, p1) && getPointerPlaneIntersect(toMouse, worldAxis, p2);
-                if (!hasData) { // Find intersections with view plane and project down to origin
-                    getTranslationPlane(worldAxis, planeNormal);
-                    getPointerPlaneIntersect(fromMouse, planeNormal, p1, 1); // Ensure plane moves closer to camera so angles become workable
-                    getPointerPlaneIntersect(toMouse, planeNormal, p2, 1);
-                    var dot = math.dotVec3(p1, worldAxis);
-                    p1[0] -= dot * worldAxis[0];
-                    p1[1] -= dot * worldAxis[1];
-                    p1[2] -= dot * worldAxis[2];
-                    dot = math.dotVec3(p2, worldAxis);
-                    p2[0] -= dot * worldAxis[0];
-                    p2[1] -= dot * worldAxis[1];
-                    p2[2] -= dot * worldAxis[2];
-                }
-                math.normalizeVec3(p1);
-                math.normalizeVec3(p2);
-                dot = math.dotVec3(p1, p2);
-                dot = math.clamp(dot, -1.0, 1.0); // Rounding errors cause dot to exceed allowed range
-                var incDegrees = Math.acos(dot) * math.RADTODEG;
-                math.cross3Vec3(p1, p2, c);
-                if (math.dotVec3(c, worldAxis) < 0.0) {
-                    incDegrees = -incDegrees;
-                }
-                rootNode.rotate(baseAxis, incDegrees);
-
-                if (self._sectionPlane) {
-                    math.quaternionToMat4(rootNode.quaternion, mat);  // << ---
-                    math.transformVec3(mat, [0, 0, 1], dir);
-                    ignoreNextSectionPlaneDirUpdate = true;
-                    self._sectionPlane.dir = dir;
-                }
-            };
-        })();
-
-        var getPointerPlaneIntersect = (function () {
-            const dir = math.vec4([0, 0, 0, 1]);
-            const matrix = math.mat4();
-            return function (mouse, axis, dest, offset) {
-                offset = offset || 0;
-                dir[0] = mouse[0] / canvas.width * 2.0 - 1.0;
-                dir[1] = -(mouse[1] / canvas.height * 2.0 - 1.0);
-                dir[2] = 0.0;
-                dir[3] = 1.0;
-                math.mulMat4(camera.projMatrix, camera.viewMatrix, matrix); // Unproject norm device coords to view coords
-                math.inverseMat4(matrix);
-                math.transformVec4(matrix, dir, dir);
-                math.mulVec4Scalar(dir, 1.0 / dir[3]); // This is now point A on the ray in world space
-                var rayO = camera.eye; // The direction
-                math.subVec4(dir, rayO, dir);
-                const origin = self._sectionPlane.pos; // Plane origin:
-                var d = -math.dotVec3(origin, axis) - offset;
-                var dot = math.dotVec3(axis, dir);
-                if (Math.abs(dot) > 0.005) {
-                    var t = -(math.dotVec3(axis, rayO) + d) / dot;
-                    math.mulVec3Scalar(dir, t, dest);
-                    math.addVec3(dest, rayO);
-                    math.subVec3(dest, origin, dest);
-                    return true;
-                }
-                return false;
-            };
-        })();
-
         {
             let deactivateActive = null;
             let currentDrag = null;
@@ -681,7 +591,7 @@ class Control {
             this.id = sectionPlane.id;
             this._sectionPlane = sectionPlane;
             const setPosFromSectionPlane = () => setPos(sectionPlane.pos);
-            const setDirFromSectionPlane = () => rootNode.quaternion = math.vec3PairToQuaternion(zeroVec, sectionPlane.dir, quat);
+            const setDirFromSectionPlane = () => rootNode.quaternion = sectionPlane.quaternion;
             setPosFromSectionPlane();
             setDirFromSectionPlane();
             const onSectionPlanePos = sectionPlane.on("pos", setPosFromSectionPlane);

package/src/plugins/TreeViewPlugin/TreeViewPlugin.js

@@ -1,5 +1,5 @@
-import {Plugin} from "../../viewer/Plugin.js";
-import {RenderService} from "./RenderService.js";
+import { Plugin } from "../../viewer/Plugin.js";
+import { RenderService } from "./RenderService.js";
 
 const treeViews = [];
 
@@ -363,6 +363,8 @@ export class TreeViewPlugin extends Plugin {
      * @param {RenderService} [cfg.renderService] Optional {@link RenderService} to use. Defaults to the {@link TreeViewPlugin}'s default {@link RenderService}.
      * @param {Boolean} [cfg.showIndeterminate=false] When true, will show indeterminate state for checkboxes when some but not all child nodes are checked
      * @param {Boolean} [cfg.showProjectNode=false] When true, will show top level project node when hierarchy is set to "storeys"
+     * @param {Function} [cfg.elevationSortFunction] Optional function to replace the default elevation sort function. The function should take two nodes and return -1, 0 or 1. 
+     * @param {Function} [cfg.defaultSortFunction] Optional function to replace the default sort function. The function should take two nodes and return -1, 0 or 1.
      */
     constructor(viewer, cfg = {}) {
 
@@ -416,6 +418,8 @@ export class TreeViewPlugin extends Plugin {
         this._renderService = cfg.renderService || new RenderService();
         this._showIndeterminate = cfg.showIndeterminate ?? false;
         this._showProjectNode = cfg.showProjectNode ?? false;
+        this._elevationSortFunction = cfg.elevationSortFunction ?? undefined;
+        this._defaultSortFunction = cfg.defaultSortFunction ?? undefined;
 
         if (!this._renderService) {
             throw new Error('TreeViewPlugin: no render service set');
@@ -1229,9 +1233,11 @@ export class TreeViewPlugin extends Plugin {
         }
         const firstChild = children[0];
         if ((this._hierarchy === "storeys" || this._hierarchy === "containment") &&  firstChild.type === "IfcBuildingStorey") {
-            children.sort(this._getSpatialSortFunc());
+            if (this._elevationSortFunction) children.sort(this._elevationSortFunction);
+            else children.sort(this._getSpatialSortFunc());
         } else {
-            children.sort(this._alphaSortFunc);
+            if (this._defaultSortFunction) children.sort(this._defaultSortFunction)
+            else children.sort(this._alphaSortFunc);
         }
         for (let i = 0, len = children.length; i < len; i++) {
             const node = children[i];

package/src/plugins/lib/html/MenuEvent.js

@@ -1,6 +1,7 @@
 import { os } from "../../../viewer/utils/os.js";
 
-export function addContextMenuListener(elem, callback) {
+//failCallback will be called when the press is not long enough to considered a long press
+export function addContextMenuListener(elem, callback, failCallback = () => {}) {
     if (!elem || !callback) return;
 
     let timeout = null;
@@ -54,6 +55,7 @@ export function addContextMenuListener(elem, callback) {
     const touchEndHandler = (event) => {
         event.preventDefault();
         if (timeout) {
+            failCallback(event);
             clearTimeout(timeout);
             timeout = null;
         }

package/src/viewer/scene/model/SceneModel.js

@@ -1563,6 +1563,7 @@ export class SceneModel extends Component {
     set matrix(value) {
         this._matrix.set(value || DEFAULT_MATRIX);
         math.decomposeMat4(this._matrix, this._position, this._quaternion, this._scale);
+        math.quaternionToEuler(this._quaternion, "XYZ", this._rotation);
         this._matrixDirty = false;
         this._setWorldMatrixDirty();
         this._sceneModelDirty();

package/src/viewer/scene/model/dtx/triangles/DTXTrianglesLayer.js

@@ -1122,8 +1122,7 @@ export class DTXTrianglesLayer {
                 worldPos[2] = positions[i + 2];
                 worldPos[3] = 1.0;
                 math.decompressPosition(worldPos, positionsDecodeMatrix);
-                math.transformPoint4(this.model.worldMatrix, worldPos, worldPos);
-                math.transformPoint4(this.model.worldMatrix, worldPos, worldPos);
+                math.mulMat4v4(this.model.worldMatrix, worldPos, worldPos);
                 worldPos[0] += offsetX;
                 worldPos[1] += offsetY;
                 worldPos[2] += offsetZ;

package/src/viewer/scene/model/vbo/batching/triangles/renderers/TrianglesColorRenderer.js

@@ -221,7 +221,10 @@ export class TrianglesColorRenderer extends TrianglesBatchingRenderer {
         }
 
         if (scene.logarithmicDepthBufferEnabled) {
-            src.push("    gl_FragDepth = isPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;");
+            src.push("    float dx = dFdx(vFragDepth);")
+            src.push("    float dy = dFdy(vFragDepth);")
+            src.push("    float diff = sqrt(dx*dx+dy*dy);");
+            src.push("    gl_FragDepth = isPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth + diff ) * logDepthBufFC * 0.5;");
         }
 
         if (this._withSAO) {

package/src/viewer/scene/model/vbo/instancing/lines/VBOInstancingLinesLayer.js

@@ -497,7 +497,7 @@ class VBOInstancingLinesLayer {
 
         let pickFlag = (visible && !culled && pickable) ? RENDER_PASSES.PICK : RENDER_PASSES.NOT_RENDERED;
 
-        const clippableFlag = !!(flags & ENTITY_FLAGS.CLIPPABLE) ? 255 : 0;
+        const clippableFlag = !!(flags & ENTITY_FLAGS.CLIPPABLE) ? 1 : 0;
 
         let vertFlag = 0;
         vertFlag |= colorFlag;

package/src/viewer/scene/model/vbo/instancing/triangles/renderers/TrianglesColorRenderer.js

@@ -234,7 +234,10 @@ class TrianglesColorRenderer extends TrianglesInstancingRenderer {
         }
 
         if (scene.logarithmicDepthBufferEnabled) {
-            src.push("    gl_FragDepth = isPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth ) * logDepthBufFC * 0.5;");
+            src.push("    float dx = dFdx(vFragDepth);")
+            src.push("    float dy = dFdy(vFragDepth);")
+            src.push("    float diff = sqrt(dx*dx+dy*dy);");
+            src.push("    gl_FragDepth = isPerspective == 0.0 ? gl_FragCoord.z : log2( vFragDepth + diff ) * logDepthBufFC * 0.5;");
         }
 
         // Doing SAO blend in the main solid fill draw shader just so that edge lines can be drawn over the top

package/src/viewer/scene/sectionPlane/SectionPlane.js

@@ -3,6 +3,11 @@ import {RenderState} from '../webgl/RenderState.js';
 import {math} from "../math/math.js";
 
 const tempVec3a = math.vec3();
+const tempVec3b = math.vec3();
+const tempVec4a = math.vec4();
+const front = math.vec3([0,  0, -1]);
+const back  = math.vec3([0,  0,  1]);
+const up    = math.vec3([0,  1,  0]);
 
 /**
  *  @desc An arbitrarily-aligned World-space clipping plane.
@@ -74,6 +79,8 @@ class SectionPlane extends Component {
         this._state = new RenderState({
             active: true,
             pos: math.vec3(),
+            quaternion: math.vec4(),
+            roll: 0,
             dir: math.vec3(),
             dist: 0
         });
@@ -135,6 +142,59 @@ class SectionPlane extends Component {
         return this._state.pos;
     }
 
+    /**
+     * Sets the quaternion of this SectionPlane's plane.
+     *
+     * Default value is ````[0, -1, 0, 0]````.
+     *
+     * @param {Number[]} value New quaternion.
+     */
+    set quaternion(value) {
+        this._state.quaternion.set(value || [0, 0, 0, -1]);
+        math.vec3ApplyQuaternion(this._state.quaternion, back, this._state.dir);
+        const quatUp = math.vec3ApplyQuaternion(this._state.quaternion, up, tempVec3a);
+        const dirOnlyQ = math.vec3PairToQuaternion(back, this._state.dir, tempVec4a);
+        const dirOnlyUp = math.vec3ApplyQuaternion(dirOnlyQ, up, tempVec3b);
+        const angle = Math.acos(Math.min(1, math.dotVec3(quatUp, dirOnlyUp)));
+        const sign = Math.sign(math.dotVec3(this._state.dir, math.cross3Vec3(quatUp, dirOnlyUp, tempVec3b)));
+        this._state.roll = sign * angle;
+        this._onDirUpdated();
+    }
+
+    /**
+     * Gets the quaternion of this SectionPlane's plane.
+     *
+     * Default value is ````[0, -1, 0, 0]````.
+     *
+     * @returns {Number[]} value Current quaternion.
+     */
+    get quaternion() {
+        return this._state.quaternion;
+    }
+
+    /**
+     * Sets the roll of this SectionPlane's plane.
+     *
+     * Default value is ````0````.
+     *
+     * @param {Number[]} value New roll.
+     */
+    set roll(value) {
+        this._state.roll = value || 0;
+        this._onDirRollUpdated();
+    }
+
+    /**
+     * Gets the roll of this SectionPlane's plane.
+     *
+     * Default value is ````0````.
+     *
+     * @returns {Number[]} value Current roll.
+     */
+    get roll() {
+        return this._state.roll;
+    }
+
     /**
      * Sets the direction of this SectionPlane's plane.
      *
@@ -143,7 +203,25 @@ class SectionPlane extends Component {
      * @param {Number[]} value New direction.
      */
     set dir(value) {
-        this._state.dir.set(value || [0, 0, -1]);
+        this._state.dir.set(value || front);
+        this._onDirRollUpdated();
+    }
+
+    _onDirRollUpdated() {
+        math.vec3PairToQuaternion(back, this._state.dir, this._state.quaternion);
+
+        tempVec4a[0] = 0;
+        tempVec4a[1] = 0;
+        tempVec4a[2] = -1;
+        tempVec4a[3] = this._state.roll;
+        math.angleAxisToQuaternion(tempVec4a, tempVec4a);
+
+        math.mulQuaternions(this._state.quaternion, tempVec4a, this._state.quaternion);
+
+        this._onDirUpdated();
+    }
+
+    _onDirUpdated() {
         this._state.dist = (-math.dotVec3(this._state.pos, this._state.dir));
         this.glRedraw();
         this.fire("dir", this._state.dir);

package/src/viewer/scene/webgl/Renderer.js

@@ -935,6 +935,9 @@ const Renderer = function (scene, options) {
                 pickProjMatrix = scene.camera.projMatrix;
                 projection     = scene.camera.projection;
 
+                nearAndFar[0] = scene.camera.project.near;
+                nearAndFar[1] = scene.camera.project.far;
+
                 pickResult.canvasPos = params.canvasPos;
 
             } else {
@@ -948,6 +951,9 @@ const Renderer = function (scene, options) {
                     pickProjMatrix = scene.camera.projMatrix;
                     projection     = scene.camera.projection;
 
+                    nearAndFar[0] = scene.camera.project.near;
+                    nearAndFar[1] = scene.camera.project.far;
+
                 } else {
 
                     worldRayOrigin.set(params.origin || [0, 0, 0]);
@@ -967,6 +973,9 @@ const Renderer = function (scene, options) {
                     pickProjMatrix = scene.camera.ortho.matrix;
                     projection     = "ortho";
 
+                    nearAndFar[0] = scene.camera.ortho.near;
+                    nearAndFar[1] = scene.camera.ortho.far;
+
                     pickResult.origin = worldRayOrigin;
                     pickResult.direction = worldRayDir;
                 }
@@ -1021,9 +1030,6 @@ const Renderer = function (scene, options) {
 
                     if (pickable.canPickWorldPos && pickable.canPickWorldPos()) {
 
-                        nearAndFar[0] = scene.camera.project.near;
-                        nearAndFar[1] = scene.camera.project.far;
-
                         gpuPickWorldPos(pickBuffer, pickable, canvasPos, pickViewMatrix, pickProjMatrix, nearAndFar, pickResult);
 
                         if (params.pickSurfaceNormal !== false) {

package/types/extras/PointerCircle/PointerCircle.d.ts

@@ -0,0 +1,50 @@
+import {Viewer} from "../../viewer";
+
+/**
+ * A PointerCircle shows a circle, centered at the position of the
+ * mouse or touch pointer.
+ */
+export class PointerCircle {
+    /**
+     * Constructs a new PointerCircle.
+     * @param {Viewer} viewer The Viewer
+     * @param {Object} [cfg] PointerCircle configuration.
+     * @param {boolean} [cfg.active=true] Whether PointerCircle is active. The PointerCircle can only be shown when this is `true` (default).
+     */
+    constructor(viewer: Viewer, cfg?: {
+        active?: boolean;
+    });
+
+    /**
+     * Show the circle at the given canvas coordinates and begin shrinking it.
+     */
+    start(circlePos: number[]): void;
+
+    /**
+     * Stop the shrinking circle and hide it.
+     */
+    stop(): void;
+
+    /**
+     * Sets the zoom factor for the lens.
+     *
+     * This is `2` by default.
+     *
+     * @param {number} durationMs
+     */
+    set durationMs(durationMs: number);
+
+    /**
+     * Gets the zoom factor for the lens.
+     *
+     * This is `2` by default.
+     *
+     * @returns {number} Number
+     */
+    get durationMs(): number;
+
+    /**
+     * Destroys this PointerCircle.
+     */
+    destroy(): void;
+}

package/types/extras/PointerCircle/index.d.ts

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

package/types/plugins/AngleMeasurementsPlugin/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./AngleMeasurementsPlugin";
 export * from "./AngleMeasurementsControl";
-export * from "./AngleMeasurementsMouseControl";
+export * from "./AngleMeasurementsMouseControl";
+export * from "./AngleMeasurementsTouchControl";

package/types/plugins/CityJSONLoaderPlugin/CityJSONLoaderPlugin.d.ts

@@ -10,6 +10,10 @@ export declare interface ICityJSONDefaultDataSource {
    * @param {Function} error Callback fired on error.
    */
   getCityJSON(src: string | number, ok: (json: any)=> void, error: (e: Error)=> void): void;
+
+  get cacheBuster(): boolean;
+
+  set cacheBuster(value: boolean);
 }
 
 export declare type CityJSONLoaderPluginConfiguration = {