@xtctwins/tctwins-core 1.0.14 → 1.0.15

package/dist/tctwins-core.cjs.js

@@ -12023,396 +12023,393 @@ const MOUSE_FINDING_TARGET = 2;
  * ````
  */
 class AngleMeasurementsMouseControl extends AngleMeasurementsControl {
+	/**
+	 * Creates a AngleMeasurementsMouseControl bound to the given AngleMeasurementsPlugin.
+	 *
+	 * @param {AngleMeasurementsPlugin} angleMeasurementsPlugin The AngleMeasurementsPlugin to control.
+	 * @param {*} [cfg] Configuration
+	 * @param {PointerLens} [cfg.pointerLens] A PointerLens to use to provide a magnified view of the cursor when snapping is enabled.
+	 * @param {boolean} [cfg.snapping=true] Whether to initially enable snap-to-vertex and snap-to-edge for this AngleMeasurementsMouseControl.
+	 */
+	constructor(angleMeasurementsPlugin, cfg = {}) {
+		super(angleMeasurementsPlugin.viewer.scene);
 
-    /**
-     * Creates a AngleMeasurementsMouseControl bound to the given AngleMeasurementsPlugin.
-     *
-     * @param {AngleMeasurementsPlugin} angleMeasurementsPlugin The AngleMeasurementsPlugin to control.
-     * @param {*} [cfg] Configuration
-     * @param {PointerLens} [cfg.pointerLens] A PointerLens to use to provide a magnified view of the cursor when snapping is enabled.
-     * @param {boolean} [cfg.snapping=true] Whether to initially enable snap-to-vertex and snap-to-edge for this AngleMeasurementsMouseControl.
-     */
-    constructor(angleMeasurementsPlugin, cfg = {}) {
-
-        super(angleMeasurementsPlugin.viewer.scene);
-
-        this.pointerLens = cfg.pointerLens;
-
-        this._active = false;
-        this._mouseState = MOUSE_FINDING_ORIGIN;
-
-        this._currentAngleMeasurement = null;
-
-        // init markerDiv element (think about making its style configurable)
-        this._initMarkerDiv();
+		this.pointerLens = cfg.pointerLens;
 
-        this._onMouseHoverSurface = null;
-        this._onHoverNothing = null;
-        this._onPickedNothing = null;
-        this._onPickedSurface = null;
+		this._active = false;
+		this._mouseState = MOUSE_FINDING_ORIGIN;
 
-        this._onInputMouseDown = null;
-        this._onInputMouseUp = null;
+		this._currentAngleMeasurement = null;
 
-        this._snapping = cfg.snapping !== false;
+		// init markerDiv element (think about making its style configurable)
+		this._initMarkerDiv();
 
-        this._attachPlugin(angleMeasurementsPlugin, cfg);
-    }
+		this._onMouseHoverSurface = null;
+		this._onHoverNothing = null;
+		this._onPickedNothing = null;
+		this._onPickedSurface = null;
 
-    _initMarkerDiv() {
-        const markerDiv = document.createElement('div');
-        markerDiv.setAttribute('id', 'myAngleMeasureMarker');
-        const canvas = this.scene.canvas.canvas;
-        canvas.parentNode.insertBefore(markerDiv, canvas);
+		this._onInputMouseDown = null;
+		this._onInputMouseUp = null;
 
-        markerDiv.style.background = "black";
-        markerDiv.style.border = "2px solid blue";
-        markerDiv.style.borderRadius = "10px";
-        markerDiv.style.width = "5px";
-        markerDiv.style.height = "5px";
-        markerDiv.style.margin = "-200px -200px";
-        markerDiv.style.zIndex = "100";
-        markerDiv.style.position = "absolute";
-        markerDiv.style.pointerEvents = "none";
+		this._snapping = cfg.snapping !== false;
 
-        this.markerDiv = markerDiv;
-    }
+		this._attachPlugin(angleMeasurementsPlugin, cfg);
+	}
 
-    _destroyMarkerDiv() {
-        if (this.markerDiv) {
-            const element = document.getElementById('myAngleMeasureMarker');
-            element.parentNode.removeChild(element);
-            this.markerDiv = null;
-        }
-    }
+	_initMarkerDiv() {
+		const markerDiv = document.createElement("div");
+		markerDiv.setAttribute("id", "myAngleMeasureMarker");
+		const canvas = this.scene.canvas.canvas;
+		canvas.parentNode.insertBefore(markerDiv, canvas);
+
+		markerDiv.style.background = "black";
+		markerDiv.style.border = "2px solid blue";
+		markerDiv.style.borderRadius = "10px";
+		markerDiv.style.width = "5px";
+		markerDiv.style.height = "5px";
+		markerDiv.style.margin = "-200px -200px";
+		markerDiv.style.zIndex = "100";
+		markerDiv.style.position = "absolute";
+		markerDiv.style.pointerEvents = "none";
+
+		this.markerDiv = markerDiv;
+	}
 
-    _attachPlugin(angleMeasurementsPlugin, cfg = {}) {
+	_destroyMarkerDiv() {
+		if (this.markerDiv) {
+			const element = document.getElementById("myAngleMeasureMarker");
+			element.parentNode.removeChild(element);
+			this.markerDiv = null;
+		}
+	}
 
-        /**
-         * The {@link AngleMeasurementsPlugin} that owns this AngleMeasurementsMouseControl.
-         *
-         * @type {AngleMeasurementsPlugin}
-         */
-        this.angleMeasurementsPlugin = angleMeasurementsPlugin;
+	_attachPlugin(angleMeasurementsPlugin, cfg = {}) {
+		/**
+		 * The {@link AngleMeasurementsPlugin} that owns this AngleMeasurementsMouseControl.
+		 *
+		 * @type {AngleMeasurementsPlugin}
+		 */
+		this.angleMeasurementsPlugin = angleMeasurementsPlugin;
 
-        /**
-         * The {@link AngleMeasurementsPlugin} that owns this AngleMeasurementsMouseControl.
-         *
-         * @type {AngleMeasurementsPlugin}
-         */
-        this.plugin = angleMeasurementsPlugin;
-    }
+		/**
+		 * The {@link AngleMeasurementsPlugin} that owns this AngleMeasurementsMouseControl.
+		 *
+		 * @type {AngleMeasurementsPlugin}
+		 */
+		this.plugin = angleMeasurementsPlugin;
+	}
 
-    /**
-     * Gets if this AngleMeasurementsMouseControl is currently active, where it is responding to input.
-     *
-     * @returns {boolean}
-     */
-    get active() {
-        return this._active;
-    }
+	/**
+	 * Gets if this AngleMeasurementsMouseControl is currently active, where it is responding to input.
+	 *
+	 * @returns {boolean}
+	 */
+	get active() {
+		return this._active;
+	}
 
-    /**
-     * Sets whether snap-to-vertex and snap-to-edge are enabled for this AngleMeasurementsMouseControl.
-     *
-     * This is `true` by default.
-     *
-     * Internally, this deactivates then activates the AngleMeasurementsMouseControl when changed, which means that
-     * it will destroy any AngleMeasurements currently under construction, and incurs some overhead, since it unbinds
-     * and rebinds various input handlers.
-     *
-     * @param {boolean} snapping Whether to enable snap-to-vertex and snap-edge for this AngleMeasurementsMouseControl.
-     */
-    set snapping(snapping) {
-        if (snapping !== this._snapping) {
-            this._snapping = snapping;
-            this.deactivate();
-            this.activate();
-        } else {
-            this._snapping = snapping;
-        }
-    }
+	/**
+	 * Sets whether snap-to-vertex and snap-to-edge are enabled for this AngleMeasurementsMouseControl.
+	 *
+	 * This is `true` by default.
+	 *
+	 * Internally, this deactivates then activates the AngleMeasurementsMouseControl when changed, which means that
+	 * it will destroy any AngleMeasurements currently under construction, and incurs some overhead, since it unbinds
+	 * and rebinds various input handlers.
+	 *
+	 * @param {boolean} snapping Whether to enable snap-to-vertex and snap-edge for this AngleMeasurementsMouseControl.
+	 */
+	set snapping(snapping) {
+		if (snapping !== this._snapping) {
+			this._snapping = snapping;
+			this.deactivate();
+			this.activate();
+		} else {
+			this._snapping = snapping;
+		}
+	}
 
-    /**
-     * Gets whether snap-to-vertex and snap-to-edge are enabled for this AngleMeasurementsMouseControl.
-     *
-     * This is `true` by default.
-     *
-     * @returns {boolean} Whether snap-to-vertex and snap-to-edge are enabled for this AngleMeasurementsMouseControl.
-     */
-    get snapping() {
-        return this._snapping;
-    }
+	/**
+	 * Gets whether snap-to-vertex and snap-to-edge are enabled for this AngleMeasurementsMouseControl.
+	 *
+	 * This is `true` by default.
+	 *
+	 * @returns {boolean} Whether snap-to-vertex and snap-to-edge are enabled for this AngleMeasurementsMouseControl.
+	 */
+	get snapping() {
+		return this._snapping;
+	}
 
-    /**
-     * Activates this AngleMeasurementsMouseControl, ready to respond to input.
-     */
-    activate() {
-        if (this._active) {
-            return;
-        }
-        if (!this.markerDiv) {
-            this._initMarkerDiv(); // if the marker is destroyed after deactivation, we recreate it
-        }
-        this.angleMeasurementsPlugin;
-        const scene = this.scene;
-        scene.input;
-        const canvas = scene.canvas.canvas;
-        const clickTolerance = 20;
-        const cameraControl = this.angleMeasurementsPlugin.viewer.cameraControl;
-        const pointerLens = this.pointerLens;
-        let mouseHovering = false;
-        let hoveredEntity = null;
-        let lastMouseCanvasX = 0;
-        let lastMouseCanvasY = 0;
-        const mouseWorldPos = math.vec3();
-        const mouseHoverCanvasPos = math.vec2();
-        this._currentAngleMeasurement = null;
-        this._onMouseHoverSurface = cameraControl.on(
-            this._snapping
-                ? "hoverSnapOrSurface"
-                : "hoverSurface",
-            event => {
-                if (event.snappedToVertex || event.snappedToEdge) {
-                    if (pointerLens) {
-                        pointerLens.visible = true;
-                        pointerLens.canvasPos = event.canvasPos;
-                        pointerLens.snappedCanvasPos = event.snappedCanvasPos || event.canvasPos;
-                        pointerLens.snapped = true;
-                    }
-                    this.markerDiv.style.background = "greenyellow";
-                    this.markerDiv.style.border = "2px solid green";
-                } else {
-                    if (pointerLens) {
-                        pointerLens.visible = true;
-                        pointerLens.canvasPos =  event.canvasPos;
-                        pointerLens.snappedCanvasPos = event.canvasPos;
-                        pointerLens.snapped = false;
-                    }
-                    this.markerDiv.style.background = "pink";
-                    this.markerDiv.style.border = "2px solid red";
-                }
-                const canvasPos = event.snappedCanvasPos || event.canvasPos;
-                mouseHovering = true;
-                hoveredEntity = event.entity;
-                mouseWorldPos.set(event.worldPos);
-                mouseHoverCanvasPos.set(canvasPos);
-                switch (this._mouseState) {
-                    case MOUSE_FINDING_ORIGIN:
-                        const canvasBoundRect = canvas.getBoundingClientRect();
-                        const scrollLeft = window.pageXOffset || document.documentElement.scrollLeft;
-                        const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
-                        const canvasLeftEdge = canvasBoundRect.left + scrollLeft;
-                        const canvasTopEdge = canvasBoundRect.top + scrollTop;
-                        this.markerDiv.style.marginLeft = `${canvasLeftEdge + canvasPos[0] - 5}px`;
-                        this.markerDiv.style.marginTop = `${canvasTopEdge + canvasPos[1] - 5}px`;
-                        break;
-                    case MOUSE_FINDING_CORNER:
-                        if (this._currentAngleMeasurement) {
-                            this._currentAngleMeasurement.originWireVisible = true;
-                            this._currentAngleMeasurement.targetWireVisible = false;
-                            this._currentAngleMeasurement.cornerVisible = true;
-                            this._currentAngleMeasurement.angleVisible = false;
-                            this._currentAngleMeasurement.corner.worldPos = event.worldPos;
-                            this._currentAngleMeasurement.corner.entity = event.entity;
-                        }
-                        this.markerDiv.style.marginLeft = `-10000px`;
-                        this.markerDiv.style.marginTop = `-10000px`;
-                        canvas.style.cursor = "pointer";
-                        break;
-                    case MOUSE_FINDING_TARGET:
-                        if (this._currentAngleMeasurement) {
-                            this._currentAngleMeasurement.targetWireVisible = true;
-                            this._currentAngleMeasurement.targetVisible = true;
-                            this._currentAngleMeasurement.angleVisible = true;
-                            this._currentAngleMeasurement.target.worldPos = event.worldPos;
-                            this._currentAngleMeasurement.target.entity = event.entity;
-                        }
-                        this.markerDiv.style.marginLeft = `-10000px`;
-                        this.markerDiv.style.marginTop = `-10000px`;
-                        canvas.style.cursor = "pointer";
-                        break;
-                }
-            });
-        canvas.addEventListener('mousedown', this._onMouseDown = (e) => {
-            if (e.which !== 1) {
-                return;
-            }
-            lastMouseCanvasX = e.clientX;
-            lastMouseCanvasY = e.clientY;
-        });
-        canvas.addEventListener("mouseup", this._onMouseUp =(e) => {
-            if (e.which !== 1) {
-                return;
-            }
-            if (e.clientX > lastMouseCanvasX + clickTolerance ||
-                e.clientX < lastMouseCanvasX - clickTolerance ||
-                e.clientY > lastMouseCanvasY + clickTolerance ||
-                e.clientY < lastMouseCanvasY - clickTolerance) {
-                return;
-            }
-            switch (this._mouseState) {
-                case MOUSE_FINDING_ORIGIN:
-                    if (mouseHovering) {
-                        this._currentAngleMeasurement = this.angleMeasurementsPlugin.createMeasurement({
-                            id: math.createUUID(),
-                            origin: {
-                                worldPos: mouseWorldPos
-                            },
-                            corner: {
-                                worldPos: mouseWorldPos
-                            },
-                            target: {
-                                worldPos: mouseWorldPos
-                            },
-                            approximate: true
-                        });
-                        this._currentAngleMeasurement.clickable = false;
-                        this._currentAngleMeasurement.originVisible = true;
-                        this._currentAngleMeasurement.originWireVisible = true;
-                        this._currentAngleMeasurement.cornerVisible = false;
-                        this._currentAngleMeasurement.targetWireVisible = false;
-                        this._currentAngleMeasurement.targetVisible = false;
-                        this._currentAngleMeasurement.angleVisible = false;
-                        this._currentAngleMeasurement.origin.entity = hoveredEntity;
-                        this._mouseState = MOUSE_FINDING_CORNER;
-                        this.angleMeasurementsPlugin.fire("measurementStart", this._currentAngleMeasurement);
-                    }
-                    break;
-                case MOUSE_FINDING_CORNER:
-                    if (mouseHovering) {
-                        this._currentAngleMeasurement.targetWireVisible = false;
-                        this._currentAngleMeasurement.targetVisible = true;
-                        this._currentAngleMeasurement.angleVisible = true;
-                        this._currentAngleMeasurement.corner.entity = hoveredEntity;
-                        this._mouseState = MOUSE_FINDING_TARGET;
-                    } else {
-                        if (this._currentAngleMeasurement) {
-                            this._currentAngleMeasurement.destroy();
-                            this._currentAngleMeasurement = null;
-                            hoveredEntity = null;
-                            this._mouseState = MOUSE_FINDING_ORIGIN;
-                            this.angleMeasurementsPlugin.fire("measurementCancel", this._currentAngleMeasurement);
-                        }
-                    }
-                    break;
-                case MOUSE_FINDING_TARGET:
-                    if (mouseHovering) {
-                        this._currentAngleMeasurement.targetVisible = true;
-                        this._currentAngleMeasurement.angleVisible = true;
-                        this._currentAngleMeasurement.target.entity = hoveredEntity;
-                        this._currentAngleMeasurement.clickable = true;
-                        hoveredEntity = null;
-                        this.angleMeasurementsPlugin.fire("measurementEnd", this._currentAngleMeasurement);
-                        this._currentAngleMeasurement = null;
-                        this._mouseState = MOUSE_FINDING_ORIGIN;
-                    } else {
-                        if (this._currentAngleMeasurement) {
-                            this._currentAngleMeasurement.destroy();
-                            this._currentAngleMeasurement = null;
-                            hoveredEntity = null;
-                            this._mouseState = MOUSE_FINDING_ORIGIN;
-                            this.angleMeasurementsPlugin.fire("measurementCancel", this._currentAngleMeasurement);
-                        }
-                    }
-                    break;
-            }
-        });
-        this._onMouseHoverOff = cameraControl.on(
-            this._snapping
-                ? "hoverSnapOrSurfaceOff"
-                : "hoverOff",
-            event => {
-                mouseHovering = false;
-                if (pointerLens) {
-                    pointerLens.visible = true;
-                    pointerLens.pointerPos = event.canvasPos;
-                    pointerLens.snappedCanvasPos = event.snappedCanvasPos || event.canvasPos;
-                    pointerLens.snapped = false;
-                }
-                this.markerDiv.style.marginLeft = `-100px`;
-                this.markerDiv.style.marginTop = `-100px`;
-                if (this._currentAngleMeasurement) {
-                    switch (this._mouseState) {
-                        case MOUSE_FINDING_ORIGIN:
-                            this._currentAngleMeasurement.originVisible = false;
-                            break;
-                        case MOUSE_FINDING_CORNER:
-                            this._currentAngleMeasurement.cornerVisible = false;
-                            this._currentAngleMeasurement.originWireVisible = false;
-                            this._currentAngleMeasurement.targetVisible = false;
-                            this._currentAngleMeasurement.targetWireVisible = false;
-                            this._currentAngleMeasurement.angleVisible = false;
-                            break;
-                        case MOUSE_FINDING_TARGET:
-                            this._currentAngleMeasurement.targetVisible = false;
-                            this._currentAngleMeasurement.targetWireVisible = false;
-                            this._currentAngleMeasurement.angleVisible = false;
-                            break;
-                    }
-                    canvas.style.cursor = "default";
-                }
-            });
-        this._active = true;
-    }
+	/**
+	 * Activates this AngleMeasurementsMouseControl, ready to respond to input.
+	 */
+	activate() {
+		if (this._active) {
+			return;
+		}
+		if (!this.markerDiv) {
+			this._initMarkerDiv(); // if the marker is destroyed after deactivation, we recreate it
+		}
+		this.angleMeasurementsPlugin;
+		const scene = this.scene;
+		scene.input;
+		const canvas = scene.canvas.canvas;
+		const clickTolerance = 20;
+		const cameraControl = this.angleMeasurementsPlugin.viewer.cameraControl;
+		const pointerLens = this.pointerLens;
+		let mouseHovering = false;
+		let hoveredEntity = null;
+		let lastMouseCanvasX = 0;
+		let lastMouseCanvasY = 0;
+		const mouseWorldPos = math.vec3();
+		const mouseHoverCanvasPos = math.vec2();
+		this._currentAngleMeasurement = null;
+		this._onMouseHoverSurface = cameraControl.on(this._snapping ? "hoverSnapOrSurface" : "hoverSurface", (event) => {
+			if (event.snappedToVertex || event.snappedToEdge) {
+				if (pointerLens) {
+					pointerLens.visible = true;
+					pointerLens.canvasPos = event.canvasPos;
+					pointerLens.snappedCanvasPos = event.snappedCanvasPos || event.canvasPos;
+					pointerLens.snapped = true;
+				}
+				this.markerDiv.style.background = "greenyellow";
+				this.markerDiv.style.border = "2px solid green";
+			} else {
+				if (pointerLens) {
+					pointerLens.visible = true;
+					pointerLens.canvasPos = event.canvasPos;
+					pointerLens.snappedCanvasPos = event.canvasPos;
+					pointerLens.snapped = false;
+				}
+				this.markerDiv.style.background = "pink";
+				this.markerDiv.style.border = "2px solid red";
+			}
+			const canvasPos = event.snappedCanvasPos || event.canvasPos;
+			mouseHovering = true;
+			hoveredEntity = event.entity;
+			mouseWorldPos.set(event.worldPos);
+			mouseHoverCanvasPos.set(canvasPos);
+			switch (this._mouseState) {
+				case MOUSE_FINDING_ORIGIN:
+					canvas.getBoundingClientRect();
+					const scrollLeft = window.pageXOffset || document.documentElement.scrollLeft;
+					const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+					const canvasLeftEdge = scrollLeft;
+					const canvasTopEdge = scrollTop;
+					this.markerDiv.style.marginLeft = `${canvasLeftEdge + canvasPos[0] - 5}px`;
+					this.markerDiv.style.marginTop = `${canvasTopEdge + canvasPos[1] - 5}px`;
+					break;
+				case MOUSE_FINDING_CORNER:
+					if (this._currentAngleMeasurement) {
+						this._currentAngleMeasurement.originWireVisible = true;
+						this._currentAngleMeasurement.targetWireVisible = false;
+						this._currentAngleMeasurement.cornerVisible = true;
+						this._currentAngleMeasurement.angleVisible = false;
+						this._currentAngleMeasurement.corner.worldPos = event.worldPos;
+						this._currentAngleMeasurement.corner.entity = event.entity;
+					}
+					this.markerDiv.style.marginLeft = `-10000px`;
+					this.markerDiv.style.marginTop = `-10000px`;
+					canvas.style.cursor = "pointer";
+					break;
+				case MOUSE_FINDING_TARGET:
+					if (this._currentAngleMeasurement) {
+						this._currentAngleMeasurement.targetWireVisible = true;
+						this._currentAngleMeasurement.targetVisible = true;
+						this._currentAngleMeasurement.angleVisible = true;
+						this._currentAngleMeasurement.target.worldPos = event.worldPos;
+						this._currentAngleMeasurement.target.entity = event.entity;
+					}
+					this.markerDiv.style.marginLeft = `-10000px`;
+					this.markerDiv.style.marginTop = `-10000px`;
+					canvas.style.cursor = "pointer";
+					break;
+			}
+		});
+		canvas.addEventListener(
+			"mousedown",
+			(this._onMouseDown = (e) => {
+				if (e.which !== 1) {
+					return;
+				}
+				lastMouseCanvasX = e.clientX;
+				lastMouseCanvasY = e.clientY;
+			})
+		);
+		canvas.addEventListener(
+			"mouseup",
+			(this._onMouseUp = (e) => {
+				if (e.which !== 1) {
+					return;
+				}
+				if (
+					e.clientX > lastMouseCanvasX + clickTolerance ||
+					e.clientX < lastMouseCanvasX - clickTolerance ||
+					e.clientY > lastMouseCanvasY + clickTolerance ||
+					e.clientY < lastMouseCanvasY - clickTolerance
+				) {
+					return;
+				}
+				switch (this._mouseState) {
+					case MOUSE_FINDING_ORIGIN:
+						if (mouseHovering) {
+							this._currentAngleMeasurement = this.angleMeasurementsPlugin.createMeasurement({
+								id: math.createUUID(),
+								origin: {
+									worldPos: mouseWorldPos
+								},
+								corner: {
+									worldPos: mouseWorldPos
+								},
+								target: {
+									worldPos: mouseWorldPos
+								},
+								approximate: true
+							});
+							this._currentAngleMeasurement.clickable = false;
+							this._currentAngleMeasurement.originVisible = true;
+							this._currentAngleMeasurement.originWireVisible = true;
+							this._currentAngleMeasurement.cornerVisible = false;
+							this._currentAngleMeasurement.targetWireVisible = false;
+							this._currentAngleMeasurement.targetVisible = false;
+							this._currentAngleMeasurement.angleVisible = false;
+							this._currentAngleMeasurement.origin.entity = hoveredEntity;
+							this._mouseState = MOUSE_FINDING_CORNER;
+							this.angleMeasurementsPlugin.fire("measurementStart", this._currentAngleMeasurement);
+						}
+						break;
+					case MOUSE_FINDING_CORNER:
+						if (mouseHovering) {
+							this._currentAngleMeasurement.targetWireVisible = false;
+							this._currentAngleMeasurement.targetVisible = true;
+							this._currentAngleMeasurement.angleVisible = true;
+							this._currentAngleMeasurement.corner.entity = hoveredEntity;
+							this._mouseState = MOUSE_FINDING_TARGET;
+						} else {
+							if (this._currentAngleMeasurement) {
+								this._currentAngleMeasurement.destroy();
+								this._currentAngleMeasurement = null;
+								hoveredEntity = null;
+								this._mouseState = MOUSE_FINDING_ORIGIN;
+								this.angleMeasurementsPlugin.fire("measurementCancel", this._currentAngleMeasurement);
+							}
+						}
+						break;
+					case MOUSE_FINDING_TARGET:
+						if (mouseHovering) {
+							this._currentAngleMeasurement.targetVisible = true;
+							this._currentAngleMeasurement.angleVisible = true;
+							this._currentAngleMeasurement.target.entity = hoveredEntity;
+							this._currentAngleMeasurement.clickable = true;
+							hoveredEntity = null;
+							this.angleMeasurementsPlugin.fire("measurementEnd", this._currentAngleMeasurement);
+							this._currentAngleMeasurement = null;
+							this._mouseState = MOUSE_FINDING_ORIGIN;
+						} else {
+							if (this._currentAngleMeasurement) {
+								this._currentAngleMeasurement.destroy();
+								this._currentAngleMeasurement = null;
+								hoveredEntity = null;
+								this._mouseState = MOUSE_FINDING_ORIGIN;
+								this.angleMeasurementsPlugin.fire("measurementCancel", this._currentAngleMeasurement);
+							}
+						}
+						break;
+				}
+			})
+		);
+		this._onMouseHoverOff = cameraControl.on(this._snapping ? "hoverSnapOrSurfaceOff" : "hoverOff", (event) => {
+			mouseHovering = false;
+			if (pointerLens) {
+				pointerLens.visible = true;
+				pointerLens.pointerPos = event.canvasPos;
+				pointerLens.snappedCanvasPos = event.snappedCanvasPos || event.canvasPos;
+				pointerLens.snapped = false;
+			}
+			this.markerDiv.style.marginLeft = `-100px`;
+			this.markerDiv.style.marginTop = `-100px`;
+			if (this._currentAngleMeasurement) {
+				switch (this._mouseState) {
+					case MOUSE_FINDING_ORIGIN:
+						this._currentAngleMeasurement.originVisible = false;
+						break;
+					case MOUSE_FINDING_CORNER:
+						this._currentAngleMeasurement.cornerVisible = false;
+						this._currentAngleMeasurement.originWireVisible = false;
+						this._currentAngleMeasurement.targetVisible = false;
+						this._currentAngleMeasurement.targetWireVisible = false;
+						this._currentAngleMeasurement.angleVisible = false;
+						break;
+					case MOUSE_FINDING_TARGET:
+						this._currentAngleMeasurement.targetVisible = false;
+						this._currentAngleMeasurement.targetWireVisible = false;
+						this._currentAngleMeasurement.angleVisible = false;
+						break;
+				}
+				canvas.style.cursor = "default";
+			}
+		});
+		this._active = true;
+	}
 
-    /**
-     * Deactivates this AngleMeasurementsMouseControl, making it unresponsive to input.
-     *
-     * Destroys any {@link AngleMeasurement} under construction by this AngleMeasurementsMouseControl.
-     */
-    deactivate() {
-        if (!this._active) {
-            return;
-        }
-        if (this.pointerLens) {
-            this.pointerLens.visible = false;
-        }
-        if (this.markerDiv) {
-            this._destroyMarkerDiv();
-        }
-        this.reset();
-        const canvas = this.scene.canvas.canvas;
-        canvas.removeEventListener("mousedown", this._onMouseDown);
-        canvas.removeEventListener("mouseup", this._onMouseUp);
-        const cameraControl = this.angleMeasurementsPlugin.viewer.cameraControl;
-        cameraControl.off(this._onMouseHoverSurface);
-        cameraControl.off(this._onPickedSurface);
-        cameraControl.off(this._onHoverNothing);
-        cameraControl.off(this._onPickedNothing);
-        this._currentAngleMeasurement = null;
-        this._active = false;
-    }
+	/**
+	 * Deactivates this AngleMeasurementsMouseControl, making it unresponsive to input.
+	 *
+	 * Destroys any {@link AngleMeasurement} under construction by this AngleMeasurementsMouseControl.
+	 */
+	deactivate() {
+		if (!this._active) {
+			return;
+		}
+		if (this.pointerLens) {
+			this.pointerLens.visible = false;
+		}
+		if (this.markerDiv) {
+			this._destroyMarkerDiv();
+		}
+		this.reset();
+		const canvas = this.scene.canvas.canvas;
+		canvas.removeEventListener("mousedown", this._onMouseDown);
+		canvas.removeEventListener("mouseup", this._onMouseUp);
+		const cameraControl = this.angleMeasurementsPlugin.viewer.cameraControl;
+		cameraControl.off(this._onMouseHoverSurface);
+		cameraControl.off(this._onPickedSurface);
+		cameraControl.off(this._onHoverNothing);
+		cameraControl.off(this._onPickedNothing);
+		this._currentAngleMeasurement = null;
+		this._active = false;
+	}
 
-    /**
-     * Resets this AngleMeasurementsMouseControl.
-     *
-     * Destroys any {@link AngleMeasurement} under construction by this AngleMeasurementsMouseControl.
-     *
-     * Does nothing if the AngleMeasurementsMouseControl is not active.
-     */
-    reset() {
-        if (!this._active) {
-            return;
-        }
+	/**
+	 * Resets this AngleMeasurementsMouseControl.
+	 *
+	 * Destroys any {@link AngleMeasurement} under construction by this AngleMeasurementsMouseControl.
+	 *
+	 * Does nothing if the AngleMeasurementsMouseControl is not active.
+	 */
+	reset() {
+		if (!this._active) {
+			return;
+		}
 
-        this._destroyMarkerDiv();
-        this._initMarkerDiv();
+		this._destroyMarkerDiv();
+		this._initMarkerDiv();
 
-        if (this._currentAngleMeasurement) {
-            this._currentAngleMeasurement.destroy();
-            this._currentAngleMeasurement = null;
-        }
-        this._mouseState = MOUSE_FINDING_ORIGIN;
-    }
+		if (this._currentAngleMeasurement) {
+			this._currentAngleMeasurement.destroy();
+			this._currentAngleMeasurement = null;
+		}
+		this._mouseState = MOUSE_FINDING_ORIGIN;
+	}
 
-    /**
-     * Destroys this AngleMeasurementsMouseControl.
-     */
-    destroy() {
-        this.deactivate();
-        super.destroy();
-    }
+	/**
+	 * Destroys this AngleMeasurementsMouseControl.
+	 */
+	destroy() {
+		this.deactivate();
+		super.destroy();
+	}
 }
 
 /**
@@ -84718,6 +84715,7 @@ class DistanceMeasurement extends Component {
         this._zAxisVisible = false;
         this._axisEnabled = true;
         this._labelsVisible = false;
+        this._labelsOnWires = false;
         this._clickable = false;
 
         this._originMarker.on("worldPos", (value) => {
@@ -84777,6 +84775,7 @@ class DistanceMeasurement extends Component {
         this.yAxisVisible = cfg.yAxisVisible;
         this.zAxisVisible = cfg.zAxisVisible;
         this.labelsVisible = cfg.labelsVisible;
+        this.labelsOnWires = cfg.labelsOnWires;
     }
 
     _update() {
@@ -84828,7 +84827,7 @@ class DistanceMeasurement extends Component {
 
         if (this._sectionPlanesDirty) {
 
-            if (this._isSliced(this._wp)) {
+            if (this._isSliced(this._originWorld) || this._isSliced(this._targetWorld)) {
                 this._xAxisLabel.setCulled(true);
                 this._yAxisLabel.setCulled(true);
                 this._zAxisLabel.setCulled(true);
@@ -84928,9 +84927,19 @@ class DistanceMeasurement extends Component {
 
                 this._lengthLabel.setPosOnWire(cp[0], cp[1], cp[6], cp[7]);
 
-                this._xAxisLabel.setPosOnWire(cp[0], cp[1], cp[2], cp[3]);
-                this._yAxisLabel.setPosOnWire(cp[2], cp[3], cp[4], cp[5]);
-                this._zAxisLabel.setPosOnWire(cp[4], cp[5], cp[6], cp[7]);
+                if (this.labelsOnWires) {
+                    this._xAxisLabel.setPosOnWire(cp[0], cp[1], cp[2], cp[3]);
+                    this._yAxisLabel.setPosOnWire(cp[2], cp[3], cp[4], cp[5]);
+                    this._zAxisLabel.setPosOnWire(cp[4], cp[5], cp[6], cp[7]);
+                } else {
+                    const labelOffset = 35;
+                    let currentLabelOffset = labelOffset;
+                    this._xAxisLabel.setPosOnWire(cp[0], cp[1] + currentLabelOffset, cp[6], cp[7] + currentLabelOffset);
+                    currentLabelOffset += labelOffset;
+                    this._yAxisLabel.setPosOnWire(cp[0], cp[1] + currentLabelOffset, cp[6], cp[7] + currentLabelOffset);
+                    currentLabelOffset += labelOffset;
+                    this._zAxisLabel.setPosOnWire(cp[0], cp[1] + currentLabelOffset, cp[6], cp[7] + currentLabelOffset);
+                }
 
                 const tilde = this._approximate ? " ~ " : " = ";
 
@@ -84943,9 +84952,15 @@ class DistanceMeasurement extends Component {
 
                 const labelMinAxisLength = this.plugin.labelMinAxisLength;
 
-                this._xAxisLabelCulled = (xAxisCanvasLength < labelMinAxisLength);
-                this._yAxisLabelCulled = (yAxisCanvasLength < labelMinAxisLength);
-                this._zAxisLabelCulled = (zAxisCanvasLength < labelMinAxisLength);
+                if (this.labelsOnWires){
+                    this._xAxisLabelCulled = (xAxisCanvasLength < labelMinAxisLength);
+                    this._yAxisLabelCulled = (yAxisCanvasLength < labelMinAxisLength);
+                    this._zAxisLabelCulled = (zAxisCanvasLength < labelMinAxisLength);
+                } else {
+                    this._xAxisLabelCulled = false;
+                    this._yAxisLabelCulled = false;
+                    this._zAxisLabelCulled = false;
+                }
 
                 if (!this._xAxisLabelCulled) {
                     this._xAxisLabel.setText(tilde + Math.abs((this._targetWorld[0] - this._originWorld[0]) * scale).toFixed(2) + unitAbbrev);
@@ -85346,6 +85361,25 @@ class DistanceMeasurement extends Component {
         return this._labelsVisible;
     }
 
+    /**
+     * Sets if labels should be positioned on the wires.
+     *
+     * @type {Boolean}
+     */
+    set labelsOnWires(value) {
+        value = value !== undefined ? Boolean(value) : this.plugin.defaultLabelsOnWires;
+        this._labelsOnWires = value;
+    }
+
+    /**
+     * Gets if labels should be positioned on the wires.
+     *
+     * @type {Boolean}
+     */
+    get labelsOnWires() {
+        return this._labelsOnWires;
+    }
+
     /**
      * Sets if this DistanceMeasurement appears highlighted.
      * @param highlighted
@@ -85559,361 +85593,375 @@ const MOUSE_FIRST_CLICK_EXPECTED = 0;
  * ````
  */
 class DistanceMeasurementsMouseControl extends DistanceMeasurementsControl {
+	/**
+	 * Creates a DistanceMeasurementsMouseControl bound to the given DistanceMeasurementsPlugin.
+	 *
+	 * @param {DistanceMeasurementsPlugin} distanceMeasurementsPlugin The AngleMeasurementsPlugin to control.
+	 * @param [cfg] Configuration
+	 * @param {PointerLens} [cfg.pointerLens] A PointerLens to use to provide a magnified view of the cursor when snapping is enabled.
+	 * @param {boolean} [cfg.snapping=true] Whether to initially enable snap-to-vertex and snap-to-edge for this DistanceMeasurementsMouseControl.
+	 */
+	constructor(distanceMeasurementsPlugin, cfg = {}) {
+		super(distanceMeasurementsPlugin.viewer.scene);
 
-    /**
-     * Creates a DistanceMeasurementsMouseControl bound to the given DistanceMeasurementsPlugin.
-     *
-     * @param {DistanceMeasurementsPlugin} distanceMeasurementsPlugin The AngleMeasurementsPlugin to control.
-     * @param [cfg] Configuration
-     * @param {PointerLens} [cfg.pointerLens] A PointerLens to use to provide a magnified view of the cursor when snapping is enabled.
-     * @param {boolean} [cfg.snapping=true] Whether to initially enable snap-to-vertex and snap-to-edge for this DistanceMeasurementsMouseControl.
-     */
-    constructor(distanceMeasurementsPlugin, cfg = {}) {
-
-        super(distanceMeasurementsPlugin.viewer.scene);
-
-        this.pointerLens = cfg.pointerLens;
-
-        this._active = false;
-
-        this._currentDistanceMeasurement = null;
-
-        this._currentDistanceMeasurementInitState = {
-            wireVisible: null,
-            axisVisible: null,
-            xAxisVisible: null,
-            yaxisVisible: null,
-            zAxisVisible: null,
-            targetVisible: null,
-        };
-
-        this._initMarkerDiv();
+		this.pointerLens = cfg.pointerLens;
 
-        this._onCameraControlHoverSnapOrSurface = null;
-        this._onCameraControlHoverSnapOrSurfaceOff = null;
-        this._onMouseDown = null;
-        this._onMouseUp = null;
-        this._onCanvasTouchStart = null;
-        this._onCanvasTouchEnd = null;
-        this._snapping = cfg.snapping !== false;
-        this._mouseState = MOUSE_FIRST_CLICK_EXPECTED;
+		this._active = false;
 
-        this._attachPlugin(distanceMeasurementsPlugin, cfg);
-    }
+		this._currentDistanceMeasurement = null;
 
-    _initMarkerDiv() {
-        const markerDiv = document.createElement('div');
-        markerDiv.setAttribute('id', 'myDistanceMarker');
-        const canvas = this.scene.canvas.canvas;
-        canvas.parentNode.insertBefore(markerDiv, canvas);
-        markerDiv.style.background = "black";
-        markerDiv.style.border = "2px solid blue";
-        markerDiv.style.borderRadius = "10px";
-        markerDiv.style.width = "5px";
-        markerDiv.style.height = "5px";
-        markerDiv.style.margin = "-200px -200px";
-        markerDiv.style.zIndex = "100";
-        markerDiv.style.position = "absolute";
-        markerDiv.style.pointerEvents = "none";
+		this._currentDistanceMeasurementInitState = {
+			wireVisible: null,
+			axisVisible: null,
+			xAxisVisible: null,
+			yaxisVisible: null,
+			zAxisVisible: null,
+			targetVisible: null
+		};
 
-        this._markerDiv = markerDiv;
-    }
+		this._initMarkerDiv();
 
-    _destroyMarkerDiv() {
-        if (this._markerDiv) {
-            const element = document.getElementById('myDistanceMarker');
-            element.parentNode.removeChild(element);
-            this._markerDiv = null;
-        }
-    }
+		this._onCameraControlHoverSnapOrSurface = null;
+		this._onCameraControlHoverSnapOrSurfaceOff = null;
+		this._onMouseDown = null;
+		this._onMouseUp = null;
+		this._onCanvasTouchStart = null;
+		this._onCanvasTouchEnd = null;
+		this._snapping = cfg.snapping !== false;
+		this._mouseState = MOUSE_FIRST_CLICK_EXPECTED;
 
-    _attachPlugin(distanceMeasurementsPlugin, cfg = {}) {
+		this._attachPlugin(distanceMeasurementsPlugin, cfg);
+	}
 
-        /**
-         * The {@link DistanceMeasurementsPlugin} that owns this DistanceMeasurementsMouseControl.
-         * @type {DistanceMeasurementsPlugin}
-         */
-        this.distanceMeasurementsPlugin = distanceMeasurementsPlugin;
+	_initMarkerDiv() {
+		const markerDiv = document.createElement("div");
+		markerDiv.setAttribute("id", "myDistanceMarker");
+		const canvas = this.scene.canvas.canvas;
+		canvas.parentNode.insertBefore(markerDiv, canvas);
+		markerDiv.style.background = "black";
+		markerDiv.style.border = "2px solid blue";
+		markerDiv.style.borderRadius = "10px";
+		markerDiv.style.width = "5px";
+		markerDiv.style.height = "5px";
+		markerDiv.style.margin = "-200px -200px";
+		markerDiv.style.zIndex = "100";
+		markerDiv.style.position = "absolute";
+		markerDiv.style.pointerEvents = "none";
+
+		this._markerDiv = markerDiv;
+	}
 
-        /**
-         * The {@link DistanceMeasurementsPlugin} that owns this DistanceMeasurementsMouseControl.
-         * @type {DistanceMeasurementsPlugin}
-         */
-        this.plugin = distanceMeasurementsPlugin;
-    }
+	_destroyMarkerDiv() {
+		if (this._markerDiv) {
+			const element = document.getElementById("myDistanceMarker");
+			element.parentNode.removeChild(element);
+			this._markerDiv = null;
+		}
+	}
 
-    /**
-     * Gets if this DistanceMeasurementsMouseControl is currently active, where it is responding to input.
-     *
-     * @returns {boolean} True if this DistanceMeasurementsMouseControl is active.
-     */
-    get active() {
-        return this._active;
-    }
+	_attachPlugin(distanceMeasurementsPlugin, cfg = {}) {
+		/**
+		 * The {@link DistanceMeasurementsPlugin} that owns this DistanceMeasurementsMouseControl.
+		 * @type {DistanceMeasurementsPlugin}
+		 */
+		this.distanceMeasurementsPlugin = distanceMeasurementsPlugin;
 
-    /**
-     * Sets whether snap-to-vertex and snap-to-edge are enabled for this DistanceMeasurementsMouseControl.
-     *
-     * This is `true` by default.
-     *
-     * Internally, this deactivates then activates the DistanceMeasurementsMouseControl when changed, which means that
-     * it will destroy any DistanceMeasurements currently under construction, and incurs some overhead, since it unbinds
-     * and rebinds various input handlers.
-     *
-     * @param {boolean} snapping Whether to enable snap-to-vertex and snap-edge for this DistanceMeasurementsMouseControl.
-     */
-    set snapping(snapping) {
-        if (snapping !== this._snapping) {
-            this._snapping = snapping;
-            this.deactivate();
-            this.activate();
-        } else {
-            this._snapping = snapping;
-        }
-    }
+		/**
+		 * The {@link DistanceMeasurementsPlugin} that owns this DistanceMeasurementsMouseControl.
+		 * @type {DistanceMeasurementsPlugin}
+		 */
+		this.plugin = distanceMeasurementsPlugin;
+	}
 
-    /**
-     * Gets whether snap-to-vertex and snap-to-edge are enabled for this DistanceMeasurementsMouseControl.
-     *
-     * This is `true` by default.
-     *
-     * @returns {boolean} Whether snap-to-vertex and snap-to-edge are enabled for this DistanceMeasurementsMouseControl.
-     */
-    get snapping() {
-        return this._snapping;
-    }
+	/**
+	 * Gets if this DistanceMeasurementsMouseControl is currently active, where it is responding to input.
+	 *
+	 * @returns {boolean} True if this DistanceMeasurementsMouseControl is active.
+	 */
+	get active() {
+		return this._active;
+	}
 
-    /**
-     * Activates this DistanceMeasurementsMouseControl, ready to respond to input.
-     */
-    activate() {
+	/**
+	 * Sets whether snap-to-vertex and snap-to-edge are enabled for this DistanceMeasurementsMouseControl.
+	 *
+	 * This is `true` by default.
+	 *
+	 * Internally, this deactivates then activates the DistanceMeasurementsMouseControl when changed, which means that
+	 * it will destroy any DistanceMeasurements currently under construction, and incurs some overhead, since it unbinds
+	 * and rebinds various input handlers.
+	 *
+	 * @param {boolean} snapping Whether to enable snap-to-vertex and snap-edge for this DistanceMeasurementsMouseControl.
+	 */
+	set snapping(snapping) {
+		if (snapping !== this._snapping) {
+			this._snapping = snapping;
+			this.deactivate();
+			this.activate();
+		} else {
+			this._snapping = snapping;
+		}
+	}
 
-        if (this._active) {
-            return;
-        }
+	/**
+	 * Gets whether snap-to-vertex and snap-to-edge are enabled for this DistanceMeasurementsMouseControl.
+	 *
+	 * This is `true` by default.
+	 *
+	 * @returns {boolean} Whether snap-to-vertex and snap-to-edge are enabled for this DistanceMeasurementsMouseControl.
+	 */
+	get snapping() {
+		return this._snapping;
+	}
 
-        if (!this._markerDiv) {
-            this._initMarkerDiv();
-        }
+	/**
+	 * Activates this DistanceMeasurementsMouseControl, ready to respond to input.
+	 */
+	activate() {
+		if (this._active) {
+			return;
+		}
 
-        this.fire("activated", true);
+		if (!this._markerDiv) {
+			this._initMarkerDiv();
+		}
 
-        const distanceMeasurementsPlugin = this.distanceMeasurementsPlugin;
-        const scene = this.scene;
-        const cameraControl = distanceMeasurementsPlugin.viewer.cameraControl;
-        const canvas = scene.canvas.canvas;
-        scene.input;
-        let mouseHovering = false;
-        const pointerWorldPos = math.vec3();
-        const pointerCanvasPos = math.vec2();
-        let pointerDownCanvasX;
-        let pointerDownCanvasY;
-        const clickTolerance = 20;
-        let hoveredEntity = null;
-
-        this._mouseState = MOUSE_FIRST_CLICK_EXPECTED;
-
-        this._onCameraControlHoverSnapOrSurface = cameraControl.on(
-            this._snapping
-                ? "hoverSnapOrSurface"
-                : "hoverSurface", event => {
-                const canvasPos = event.snappedCanvasPos || event.canvasPos;
-                mouseHovering = true;
-                pointerWorldPos.set(event.worldPos);
-                pointerCanvasPos.set(event.canvasPos);
-                if (this._mouseState === MOUSE_FIRST_CLICK_EXPECTED) {
-                    
-                    const canvasBoundRect = canvas.getBoundingClientRect();
-                    const scrollLeft = window.pageXOffset || document.documentElement.scrollLeft;
-                    const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
-                    const canvasLeftEdge = canvasBoundRect.left + scrollLeft;
-                    const canvasTopEdge = canvasBoundRect.top + scrollTop;
-                    
-                    this._markerDiv.style.marginLeft = `${canvasLeftEdge + canvasPos[0] - 5}px`;
-                    this._markerDiv.style.marginTop = `${canvasTopEdge + canvasPos[1] - 5}px`;
-                    this._markerDiv.style.background = "pink";
-                    if (event.snappedToVertex || event.snappedToEdge) {
-                        if (this.pointerLens) {
-                            this.pointerLens.visible = true;
-                            this.pointerLens.canvasPos = event.canvasPos;
-                            this.pointerLens.snappedCanvasPos = event.snappedCanvasPos || event.canvasPos;
-                            this.pointerLens.snapped = true;
-                        }
-                        this._markerDiv.style.background = "greenyellow";
-                        this._markerDiv.style.border = "2px solid green";
-                    } else {
-                        if (this.pointerLens) {
-                            this.pointerLens.visible = true;
-                            this.pointerLens.canvasPos =  event.canvasPos;
-                            this.pointerLens.snappedCanvasPos = event.canvasPos;
-                            this.pointerLens.snapped = false;
-                        }
-                        this._markerDiv.style.background = "pink";
-                        this._markerDiv.style.border = "2px solid red";
-                    }
-                    hoveredEntity = event.entity;
-                } else {
-                    this._markerDiv.style.marginLeft = `-10000px`;
-                    this._markerDiv.style.marginTop = `-10000px`;
-                }
-                canvas.style.cursor = "pointer";
-                if (this._currentDistanceMeasurement) {
-                    this._currentDistanceMeasurement.wireVisible = this._currentDistanceMeasurementInitState.wireVisible;
-                    this._currentDistanceMeasurement.axisVisible = this._currentDistanceMeasurementInitState.axisVisible && this.distanceMeasurementsPlugin.defaultAxisVisible;
-                    this._currentDistanceMeasurement.xAxisVisible = this._currentDistanceMeasurementInitState.xAxisVisible && this.distanceMeasurementsPlugin.defaultXAxisVisible;
-                    this._currentDistanceMeasurement.yAxisVisible = this._currentDistanceMeasurementInitState.yAxisVisible && this.distanceMeasurementsPlugin.defaultYAxisVisible;
-                    this._currentDistanceMeasurement.zAxisVisible = this._currentDistanceMeasurementInitState.zAxisVisible && this.distanceMeasurementsPlugin.defaultZAxisVisible;
-                    this._currentDistanceMeasurement.targetVisible = this._currentDistanceMeasurementInitState.targetVisible;
-                    this._currentDistanceMeasurement.target.worldPos = pointerWorldPos.slice();
-                    this._markerDiv.style.marginLeft = `-10000px`;
-                    this._markerDiv.style.marginTop = `-10000px`;
-                }
-            });
+		this.fire("activated", true);
+
+		const distanceMeasurementsPlugin = this.distanceMeasurementsPlugin;
+		const scene = this.scene;
+		const cameraControl = distanceMeasurementsPlugin.viewer.cameraControl;
+		const canvas = scene.canvas.canvas;
+		scene.input;
+		let mouseHovering = false;
+		const pointerWorldPos = math.vec3();
+		const pointerCanvasPos = math.vec2();
+		let pointerDownCanvasX;
+		let pointerDownCanvasY;
+		const clickTolerance = 20;
+		let hoveredEntity = null;
+
+		this._mouseState = MOUSE_FIRST_CLICK_EXPECTED;
+
+		this._onCameraControlHoverSnapOrSurface = cameraControl.on(
+			this._snapping ? "hoverSnapOrSurface" : "hoverSurface",
+			(event) => {
+				const canvasPos = event.snappedCanvasPos || event.canvasPos;
+				mouseHovering = true;
+				pointerWorldPos.set(event.worldPos);
+				pointerCanvasPos.set(event.canvasPos);
+				if (this._mouseState === MOUSE_FIRST_CLICK_EXPECTED) {
+					canvas.getBoundingClientRect();
+					const scrollLeft = window.pageXOffset || document.documentElement.scrollLeft;
+					const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+					const canvasLeftEdge = scrollLeft;
+					const canvasTopEdge = scrollTop;
+
+					this._markerDiv.style.marginLeft = `${canvasLeftEdge + canvasPos[0] - 5}px`;
+					this._markerDiv.style.marginTop = `${canvasTopEdge + canvasPos[1] - 5}px`;
+					this._markerDiv.style.background = "pink";
+					if (event.snappedToVertex || event.snappedToEdge) {
+						if (this.pointerLens) {
+							this.pointerLens.visible = true;
+							this.pointerLens.canvasPos = event.canvasPos;
+							this.pointerLens.snappedCanvasPos = event.snappedCanvasPos || event.canvasPos;
+							this.pointerLens.snapped = true;
+						}
+						this._markerDiv.style.background = "greenyellow";
+						this._markerDiv.style.border = "2px solid green";
+					} else {
+						if (this.pointerLens) {
+							this.pointerLens.visible = true;
+							this.pointerLens.canvasPos = event.canvasPos;
+							this.pointerLens.snappedCanvasPos = event.canvasPos;
+							this.pointerLens.snapped = false;
+						}
+						this._markerDiv.style.background = "pink";
+						this._markerDiv.style.border = "2px solid red";
+					}
+					hoveredEntity = event.entity;
+				} else {
+					this._markerDiv.style.marginLeft = `-10000px`;
+					this._markerDiv.style.marginTop = `-10000px`;
+				}
+				canvas.style.cursor = "pointer";
+				if (this._currentDistanceMeasurement) {
+					this._currentDistanceMeasurement.wireVisible = this._currentDistanceMeasurementInitState.wireVisible;
+					this._currentDistanceMeasurement.axisVisible =
+						this._currentDistanceMeasurementInitState.axisVisible && this.distanceMeasurementsPlugin.defaultAxisVisible;
+					this._currentDistanceMeasurement.xAxisVisible =
+						this._currentDistanceMeasurementInitState.xAxisVisible &&
+						this.distanceMeasurementsPlugin.defaultXAxisVisible;
+					this._currentDistanceMeasurement.yAxisVisible =
+						this._currentDistanceMeasurementInitState.yAxisVisible &&
+						this.distanceMeasurementsPlugin.defaultYAxisVisible;
+					this._currentDistanceMeasurement.zAxisVisible =
+						this._currentDistanceMeasurementInitState.zAxisVisible &&
+						this.distanceMeasurementsPlugin.defaultZAxisVisible;
+					this._currentDistanceMeasurement.targetVisible = this._currentDistanceMeasurementInitState.targetVisible;
+					this._currentDistanceMeasurement.target.worldPos = pointerWorldPos.slice();
+					this._markerDiv.style.marginLeft = `-10000px`;
+					this._markerDiv.style.marginTop = `-10000px`;
+				}
+			}
+		);
 
-        canvas.addEventListener('mousedown', this._onMouseDown = (e) => {
-            if (e.which !== 1) {
-                return;
-            }
-            pointerDownCanvasX = e.clientX;
-            pointerDownCanvasY = e.clientY;
-        });
+		canvas.addEventListener(
+			"mousedown",
+			(this._onMouseDown = (e) => {
+				if (e.which !== 1) {
+					return;
+				}
+				pointerDownCanvasX = e.clientX;
+				pointerDownCanvasY = e.clientY;
+			})
+		);
 
-        canvas.addEventListener("mouseup", this._onMouseUp =(e) => {
-            if (e.which !== 1) {
-                return;
-            }
-            if (e.clientX > pointerDownCanvasX + clickTolerance ||
-                e.clientX < pointerDownCanvasX - clickTolerance ||
-                e.clientY > pointerDownCanvasY + clickTolerance ||
-                e.clientY < pointerDownCanvasY - clickTolerance) {
-                return;
-            }
-            if (this._currentDistanceMeasurement) {
-                if (mouseHovering) {
-                    this._currentDistanceMeasurement.target.entity = hoveredEntity;
-                    hoveredEntity = null;
-                    this._currentDistanceMeasurement.clickable = true;
-                    this.distanceMeasurementsPlugin.fire("measurementEnd", this._currentDistanceMeasurement);
-                    this._currentDistanceMeasurement = null;
-                } else {
-                    this._currentDistanceMeasurement.destroy();
-                    this.distanceMeasurementsPlugin.fire("measurementCancel", this._currentDistanceMeasurement);
-                    this._currentDistanceMeasurement = null;
-                    hoveredEntity = null;
-                }
-            } else {
-                if (mouseHovering) {
-                    this._currentDistanceMeasurement = distanceMeasurementsPlugin.createMeasurement({
-                        id: math.createUUID(),
-                        origin: {
-                            worldPos: pointerWorldPos.slice()
-                        },
-                        target: {
-                            worldPos: pointerWorldPos.slice()
-                        },
-                        approximate: true
-                    });
-                    this._currentDistanceMeasurementInitState.axisVisible = this._currentDistanceMeasurement.axisVisible && this.distanceMeasurementsPlugin.defaultAxisVisible;
-                    this._currentDistanceMeasurementInitState.xAxisVisible = this._currentDistanceMeasurement.xAxisVisible && this.distanceMeasurementsPlugin.defaultXAxisVisible;
-                    this._currentDistanceMeasurementInitState.yAxisVisible = this._currentDistanceMeasurement.yAxisVisible && this.distanceMeasurementsPlugin.defaultYAxisVisible;
-                    this._currentDistanceMeasurementInitState.zAxisVisible = this._currentDistanceMeasurement.zAxisVisible && this.distanceMeasurementsPlugin.defaultZAxisVisible;
-                    this._currentDistanceMeasurementInitState.wireVisible = this._currentDistanceMeasurement.wireVisible;
-                    this._currentDistanceMeasurementInitState.targetVisible = this._currentDistanceMeasurement.targetVisible;
-                    this._currentDistanceMeasurement.clickable = false;
-                    this._currentDistanceMeasurement.origin.entity = hoveredEntity;
-                    hoveredEntity = null;
-                    this.fire("measurementStart", this._currentDistanceMeasurement);
-                }
-            }
-        });
+		canvas.addEventListener(
+			"mouseup",
+			(this._onMouseUp = (e) => {
+				if (e.which !== 1) {
+					return;
+				}
+				if (
+					e.clientX > pointerDownCanvasX + clickTolerance ||
+					e.clientX < pointerDownCanvasX - clickTolerance ||
+					e.clientY > pointerDownCanvasY + clickTolerance ||
+					e.clientY < pointerDownCanvasY - clickTolerance
+				) {
+					return;
+				}
+				if (this._currentDistanceMeasurement) {
+					if (mouseHovering) {
+						this._currentDistanceMeasurement.target.entity = hoveredEntity;
+						hoveredEntity = null;
+						this._currentDistanceMeasurement.clickable = true;
+						this.distanceMeasurementsPlugin.fire("measurementEnd", this._currentDistanceMeasurement);
+						this._currentDistanceMeasurement = null;
+					} else {
+						this._currentDistanceMeasurement.destroy();
+						this.distanceMeasurementsPlugin.fire("measurementCancel", this._currentDistanceMeasurement);
+						this._currentDistanceMeasurement = null;
+						hoveredEntity = null;
+					}
+				} else {
+					if (mouseHovering) {
+						this._currentDistanceMeasurement = distanceMeasurementsPlugin.createMeasurement({
+							id: math.createUUID(),
+							origin: {
+								worldPos: pointerWorldPos.slice()
+							},
+							target: {
+								worldPos: pointerWorldPos.slice()
+							},
+							approximate: true
+						});
+						this._currentDistanceMeasurementInitState.axisVisible =
+							this._currentDistanceMeasurement.axisVisible && this.distanceMeasurementsPlugin.defaultAxisVisible;
+						this._currentDistanceMeasurementInitState.xAxisVisible =
+							this._currentDistanceMeasurement.xAxisVisible && this.distanceMeasurementsPlugin.defaultXAxisVisible;
+						this._currentDistanceMeasurementInitState.yAxisVisible =
+							this._currentDistanceMeasurement.yAxisVisible && this.distanceMeasurementsPlugin.defaultYAxisVisible;
+						this._currentDistanceMeasurementInitState.zAxisVisible =
+							this._currentDistanceMeasurement.zAxisVisible && this.distanceMeasurementsPlugin.defaultZAxisVisible;
+						this._currentDistanceMeasurementInitState.wireVisible = this._currentDistanceMeasurement.wireVisible;
+						this._currentDistanceMeasurementInitState.targetVisible = this._currentDistanceMeasurement.targetVisible;
+						this._currentDistanceMeasurement.clickable = false;
+						this._currentDistanceMeasurement.origin.entity = hoveredEntity;
+						hoveredEntity = null;
+						this.fire("measurementStart", this._currentDistanceMeasurement);
+					}
+				}
+			})
+		);
 
-        this._onCameraControlHoverSnapOrSurfaceOff = cameraControl.on(
-            this._snapping
-                ? "hoverSnapOrSurfaceOff"
-                : "hoverOff", event => {
-            if (this.pointerLens) {
-                this.pointerLens.visible = true;
-                this.pointerLens.canvasPos =  event.canvasPos;
-                this.pointerLens.snappedCanvasPos = event.snappedCanvasPos || event.canvasPos;
-            }
-            mouseHovering = false;
-            this._markerDiv.style.marginLeft = `-100px`;
-            this._markerDiv.style.marginTop = `-100px`;
-            if (this._currentDistanceMeasurement) {
-                this._currentDistanceMeasurement.wireVisible = false;
-                this._currentDistanceMeasurement.targetVisible = false;
-                this._currentDistanceMeasurement.axisVisible = false;
-            }
-            canvas.style.cursor = "default";
-        });
+		this._onCameraControlHoverSnapOrSurfaceOff = cameraControl.on(
+			this._snapping ? "hoverSnapOrSurfaceOff" : "hoverOff",
+			(event) => {
+				if (this.pointerLens) {
+					this.pointerLens.visible = true;
+					this.pointerLens.canvasPos = event.canvasPos;
+					this.pointerLens.snappedCanvasPos = event.snappedCanvasPos || event.canvasPos;
+				}
+				mouseHovering = false;
+				this._markerDiv.style.marginLeft = `-100px`;
+				this._markerDiv.style.marginTop = `-100px`;
+				if (this._currentDistanceMeasurement) {
+					this._currentDistanceMeasurement.wireVisible = false;
+					this._currentDistanceMeasurement.targetVisible = false;
+					this._currentDistanceMeasurement.axisVisible = false;
+				}
+				canvas.style.cursor = "default";
+			}
+		);
 
-        this._active = true;
-    }
+		this._active = true;
+	}
 
-    /**
-     * Deactivates this DistanceMeasurementsMouseControl, making it unresponsive to input.
-     *
-     * Destroys any {@link DistanceMeasurement} under construction by this DistanceMeasurementsMouseControl.
-     */
-    deactivate() {
-        if (!this._active) {
-            return;
-        }
+	/**
+	 * Deactivates this DistanceMeasurementsMouseControl, making it unresponsive to input.
+	 *
+	 * Destroys any {@link DistanceMeasurement} under construction by this DistanceMeasurementsMouseControl.
+	 */
+	deactivate() {
+		if (!this._active) {
+			return;
+		}
 
-        this.fire("activated", false);
+		this.fire("activated", false);
 
-        if (this.pointerLens) {
-            this.pointerLens.visible = false;
-        }
-        if (this._markerDiv) {
-            this._destroyMarkerDiv();
-        }
-        this.reset();
-        const canvas = this.scene.canvas.canvas;
-        canvas.removeEventListener("mousedown", this._onMouseDown);
-        canvas.removeEventListener("mouseup", this._onMouseUp);
-        const cameraControl = this.distanceMeasurementsPlugin.viewer.cameraControl;
-        cameraControl.off(this._onCameraControlHoverSnapOrSurface);
-        cameraControl.off(this._onCameraControlHoverSnapOrSurfaceOff);
-        if (this._currentDistanceMeasurement) {
-            this.distanceMeasurementsPlugin.fire("measurementCancel", this._currentDistanceMeasurement);
-            this._currentDistanceMeasurement.destroy();
-            this._currentDistanceMeasurement = null;
-        }
-        this._active = false;
-    }
+		if (this.pointerLens) {
+			this.pointerLens.visible = false;
+		}
+		if (this._markerDiv) {
+			this._destroyMarkerDiv();
+		}
+		this.reset();
+		const canvas = this.scene.canvas.canvas;
+		canvas.removeEventListener("mousedown", this._onMouseDown);
+		canvas.removeEventListener("mouseup", this._onMouseUp);
+		const cameraControl = this.distanceMeasurementsPlugin.viewer.cameraControl;
+		cameraControl.off(this._onCameraControlHoverSnapOrSurface);
+		cameraControl.off(this._onCameraControlHoverSnapOrSurfaceOff);
+		if (this._currentDistanceMeasurement) {
+			this.distanceMeasurementsPlugin.fire("measurementCancel", this._currentDistanceMeasurement);
+			this._currentDistanceMeasurement.destroy();
+			this._currentDistanceMeasurement = null;
+		}
+		this._active = false;
+	}
 
-    /**
-     * Resets this DistanceMeasurementsMouseControl.
-     *
-     * Destroys any {@link DistanceMeasurement} under construction by this DistanceMeasurementsMouseControl.
-     *
-     * Does nothing if the DistanceMeasurementsMouseControl is not active.
-     */
-    reset() {
-        if (!this._active) {
-            return;
-        }
+	/**
+	 * Resets this DistanceMeasurementsMouseControl.
+	 *
+	 * Destroys any {@link DistanceMeasurement} under construction by this DistanceMeasurementsMouseControl.
+	 *
+	 * Does nothing if the DistanceMeasurementsMouseControl is not active.
+	 */
+	reset() {
+		if (!this._active) {
+			return;
+		}
 
-        this._destroyMarkerDiv();
-        this._initMarkerDiv();
+		this._destroyMarkerDiv();
+		this._initMarkerDiv();
 
-        if (this._currentDistanceMeasurement) {
-            this.distanceMeasurementsPlugin.fire("measurementCancel", this._currentDistanceMeasurement);
-            this._currentDistanceMeasurement.destroy();
-            this._currentDistanceMeasurement = null;
-        }
-    }
+		if (this._currentDistanceMeasurement) {
+			this.distanceMeasurementsPlugin.fire("measurementCancel", this._currentDistanceMeasurement);
+			this._currentDistanceMeasurement.destroy();
+			this._currentDistanceMeasurement = null;
+		}
+	}
 
-    /**
-     * Destroys this DistanceMeasurementsMouseControl.
-     *
-     * Destroys any {@link DistanceMeasurement} under construction by this DistanceMeasurementsMouseControl.
-     */
-    destroy() {
-        this.deactivate();
-        super.destroy();
-    }
+	/**
+	 * Destroys this DistanceMeasurementsMouseControl.
+	 *
+	 * Destroys any {@link DistanceMeasurement} under construction by this DistanceMeasurementsMouseControl.
+	 */
+	destroy() {
+		this.deactivate();
+		super.destroy();
+	}
 }
 
 /**
@@ -92102,371 +92150,379 @@ const tempVec4a$3 = math.vec4();
 const tempVec4b$3 = math.vec4();
 const tempVec4c = math.vec4();
 
-
 /** @private */
 class PivotController {
+	/**
+	 * @private
+	 */
+	constructor(scene, configs) {
+		// Pivot math by: http://www.derschmale.com/
+
+		this._scene = scene;
+		this._configs = configs;
+		this._pivotWorldPos = math.vec3();
+		this._cameraOffset = math.vec3();
+		this._azimuth = 0;
+		this._polar = 0;
+		this._radius = 0;
+		this._pivotPosSet = false; // Initially false, true as soon as _pivotWorldPos has been set to some value
+		this._pivoting = false; // True while pivoting
+		this._shown = false;
+
+		this._pivotSphereEnabled = false;
+		this._pivotSphere = null;
+		this._pivotSphereSize = 1;
+		this._pivotSphereGeometry = null;
+		this._pivotSphereMaterial = null;
+		this._rtcCenter = math.vec3();
+		this._rtcPos = math.vec3();
+
+		this._pivotViewPos = math.vec4();
+		this._pivotProjPos = math.vec4();
+		this._pivotCanvasPos = math.vec2();
+		this._cameraDirty = true;
+
+		this._onViewMatrix = this._scene.camera.on("viewMatrix", () => {
+			this._cameraDirty = true;
+		});
 
-    /**
-     * @private
-     */
-    constructor(scene, configs) {
-
-        // Pivot math by: http://www.derschmale.com/
-
-        this._scene = scene;
-        this._configs = configs;
-        this._pivotWorldPos = math.vec3();
-        this._cameraOffset = math.vec3();
-        this._azimuth = 0;
-        this._polar = 0;
-        this._radius = 0;
-        this._pivotPosSet = false; // Initially false, true as soon as _pivotWorldPos has been set to some value
-        this._pivoting = false; // True while pivoting
-        this._shown = false;
-
-        this._pivotSphereEnabled = false;
-        this._pivotSphere = null;
-        this._pivotSphereSize = 1;
-        this._pivotSphereGeometry = null;
-        this._pivotSphereMaterial = null;
-        this._rtcCenter = math.vec3();
-        this._rtcPos = math.vec3();
-
-        this._pivotViewPos = math.vec4();
-        this._pivotProjPos = math.vec4();
-        this._pivotCanvasPos = math.vec2();
-        this._cameraDirty = true;
-
-        this._onViewMatrix = this._scene.camera.on("viewMatrix", () => {
-            this._cameraDirty = true;
-        });
-
-        this._onProjMatrix = this._scene.camera.on("projMatrix", () => {
-            this._cameraDirty = true;
-        });
-
-        this._onTick = this._scene.on("tick", () => {
-            this.updatePivotElement();
-            this.updatePivotSphere();
-        });
-    }
-
-    createPivotSphere() {
-        const currentPos = this.getPivotPos();
-        const cameraPos = math.vec3();
-        math.decomposeMat4(math.inverseMat4(this._scene.viewer.camera.viewMatrix, math.mat4()), cameraPos, math.vec4(), math.vec3());
-        const length = math.distVec3(cameraPos, currentPos);
-        let radius = (Math.tan(Math.PI / 500) * length) * this._pivotSphereSize;
-
-        if (this._scene.camera.projection == "ortho") {
-            radius /= (this._scene.camera.ortho.scale / 2);
-        }
-
-        worldToRTCPos(currentPos, this._rtcCenter, this._rtcPos);
-        this._pivotSphereGeometry = new VBOGeometry(
-            this._scene,
-            buildSphereGeometry({ radius })
-        );
-        this._pivotSphere = new Mesh(this._scene, {
-            geometry: this._pivotSphereGeometry,
-            material: this._pivotSphereMaterial,
-            pickable: false,
-            position: this._rtcPos,
-            rtcCenter: this._rtcCenter
-        });
-    };
-
-    destroyPivotSphere() {
-        if (this._pivotSphere) {
-            this._pivotSphere.destroy();
-            this._pivotSphere = null;
-        }
-        if (this._pivotSphereGeometry) {
-            this._pivotSphereGeometry.destroy();
-            this._pivotSphereGeometry = null;
-        }
-    }
-
-    updatePivotElement() {
-
-        const camera = this._scene.camera;
-        const canvas = this._scene.canvas;
-
-        if (this._pivoting && this._cameraDirty) {
-
-            math.transformPoint3(camera.viewMatrix, this.getPivotPos(), this._pivotViewPos);
-            this._pivotViewPos[3] = 1;
-            math.transformPoint4(camera.projMatrix, this._pivotViewPos, this._pivotProjPos);
+		this._onProjMatrix = this._scene.camera.on("projMatrix", () => {
+			this._cameraDirty = true;
+		});
 
-            const canvasAABB = canvas.boundary;
-            const canvasWidth = canvasAABB[2];
-            const canvasHeight = canvasAABB[3];
+		this._onTick = this._scene.on("tick", () => {
+			this.updatePivotElement();
+			this.updatePivotSphere();
+		});
+	}
 
-            this._pivotCanvasPos[0] = Math.floor((1 + this._pivotProjPos[0] / this._pivotProjPos[3]) * canvasWidth / 2);
-            this._pivotCanvasPos[1] = Math.floor((1 - this._pivotProjPos[1] / this._pivotProjPos[3]) * canvasHeight / 2);
+	createPivotSphere() {
+		const currentPos = this.getPivotPos();
+		const cameraPos = math.vec3();
+		math.decomposeMat4(
+			math.inverseMat4(this._scene.viewer.camera.viewMatrix, math.mat4()),
+			cameraPos,
+			math.vec4(),
+			math.vec3()
+		);
+		const length = math.distVec3(cameraPos, currentPos);
+		let radius = Math.tan(Math.PI / 500) * length * this._pivotSphereSize;
 
-            // data-textures: avoid to do continuous DOM layout calculations            
-            let canvasBoundingRect = canvas._lastBoundingClientRect;
+		if (this._scene.camera.projection == "ortho") {
+			radius /= this._scene.camera.ortho.scale / 2;
+		}
 
-            if (!canvasBoundingRect || canvas._canvasSizeChanged)
-            {
-                const canvasElem = canvas.canvas;
+		worldToRTCPos(currentPos, this._rtcCenter, this._rtcPos);
+		this._pivotSphereGeometry = new VBOGeometry(this._scene, buildSphereGeometry({ radius }));
+		this._pivotSphere = new Mesh(this._scene, {
+			geometry: this._pivotSphereGeometry,
+			material: this._pivotSphereMaterial,
+			pickable: false,
+			position: this._rtcPos,
+			rtcCenter: this._rtcCenter
+		});
+	}
 
-                canvasBoundingRect = canvas._lastBoundingClientRect = canvasElem.getBoundingClientRect ();
-            }
+	destroyPivotSphere() {
+		if (this._pivotSphere) {
+			this._pivotSphere.destroy();
+			this._pivotSphere = null;
+		}
+		if (this._pivotSphereGeometry) {
+			this._pivotSphereGeometry.destroy();
+			this._pivotSphereGeometry = null;
+		}
+	}
 
-            if (this._pivotElement) {
-                this._pivotElement.style.left = (Math.floor(canvasBoundingRect.left + this._pivotCanvasPos[0]) - (this._pivotElement.clientWidth / 2) + window.scrollX) + "px";
-                this._pivotElement.style.top = (Math.floor(canvasBoundingRect.top + this._pivotCanvasPos[1]) - (this._pivotElement.clientHeight / 2) + window.scrollY) + "px";
-            }
-            this._cameraDirty = false;
-        }
-    }
+	updatePivotElement() {
+		const camera = this._scene.camera;
+		const canvas = this._scene.canvas;
+
+		if (this._pivoting && this._cameraDirty) {
+			math.transformPoint3(camera.viewMatrix, this.getPivotPos(), this._pivotViewPos);
+			this._pivotViewPos[3] = 1;
+			math.transformPoint4(camera.projMatrix, this._pivotViewPos, this._pivotProjPos);
+
+			const canvasAABB = canvas.boundary;
+			const canvasWidth = canvasAABB[2];
+			const canvasHeight = canvasAABB[3];
+
+			this._pivotCanvasPos[0] = Math.floor(((1 + this._pivotProjPos[0] / this._pivotProjPos[3]) * canvasWidth) / 2);
+			this._pivotCanvasPos[1] = Math.floor(((1 - this._pivotProjPos[1] / this._pivotProjPos[3]) * canvasHeight) / 2);
+
+			// data-textures: avoid to do continuous DOM layout calculations
+			let canvasBoundingRect = canvas._lastBoundingClientRect;
+
+			// if (!canvasBoundingRect || canvas._canvasSizeChanged) {
+			const canvasElem = canvas.canvas;
+
+			canvasBoundingRect = canvas._lastBoundingClientRect = canvasElem.getBoundingClientRect();
+			// }
+
+			if (this._pivotElement) {
+				this._pivotElement.style.left =
+					Math.floor(canvasBoundingRect.left + this._pivotCanvasPos[0]) -
+					this._pivotElement.clientWidth / 2 +
+					window.scrollX +
+					"px";
+				this._pivotElement.style.top =
+					Math.floor(canvasBoundingRect.top + this._pivotCanvasPos[1]) -
+					this._pivotElement.clientHeight / 2 +
+					window.scrollY +
+					"px";
+			}
+			this._cameraDirty = false;
+		}
+	}
 
-    updatePivotSphere() {
-        if (this._pivoting && this._pivotSphere) {
-            worldToRTCPos(this.getPivotPos(), this._rtcCenter, this._rtcPos);
-            if(!math.compareVec3(this._rtcPos, this._pivotSphere.position)) {
-                this.destroyPivotSphere();
-                this.createPivotSphere();
-            }
-        }
-    }
-    /**
-     * Sets the HTML DOM element that will represent the pivot position.
-     *
-     * @param pivotElement
-     */
-    setPivotElement(pivotElement) {
-        this._pivotElement = pivotElement;
-    }
+	updatePivotSphere() {
+		if (this._pivoting && this._pivotSphere) {
+			worldToRTCPos(this.getPivotPos(), this._rtcCenter, this._rtcPos);
+			if (!math.compareVec3(this._rtcPos, this._pivotSphere.position)) {
+				this.destroyPivotSphere();
+				this.createPivotSphere();
+			}
+		}
+	}
+	/**
+	 * Sets the HTML DOM element that will represent the pivot position.
+	 *
+	 * @param pivotElement
+	 */
+	setPivotElement(pivotElement) {
+		this._pivotElement = pivotElement;
+	}
 
-    /**
-     * Sets a sphere as the representation of the pivot position.
-     *
-     * @param {Object} [cfg] Sphere configuration.
-     * @param {String} [cfg.size=1] Optional size factor of the sphere. Defaults to 1.
-     * @param {String} [cfg.color=Array] Optional maretial color. Defaults to a red.
-     */
-    enablePivotSphere(cfg = {}) {
-        this.destroyPivotSphere();
-        this._pivotSphereEnabled = true;
-        if (cfg.size) {
-            this._pivotSphereSize = cfg.size;
-        }
-        const color = cfg.color || [1, 0, 0];
-        this._pivotSphereMaterial = new PhongMaterial(this._scene, {
-            emissive: color,
-            ambient: color,
-            specular: [0,0,0],
-            diffuse: [0,0,0],
-        });
-    }
+	/**
+	 * Sets a sphere as the representation of the pivot position.
+	 *
+	 * @param {Object} [cfg] Sphere configuration.
+	 * @param {String} [cfg.size=1] Optional size factor of the sphere. Defaults to 1.
+	 * @param {String} [cfg.color=Array] Optional maretial color. Defaults to a red.
+	 */
+	enablePivotSphere(cfg = {}) {
+		this.destroyPivotSphere();
+		this._pivotSphereEnabled = true;
+		if (cfg.size) {
+			this._pivotSphereSize = cfg.size;
+		}
+		const color = cfg.color || [1, 0, 0];
+		this._pivotSphereMaterial = new PhongMaterial(this._scene, {
+			emissive: color,
+			ambient: color,
+			specular: [0, 0, 0],
+			diffuse: [0, 0, 0]
+		});
+	}
 
-    /**
-     * Remove the sphere as the representation of the pivot position.
-     *
-     */
-    disablePivotSphere() {
-        this.destroyPivotSphere();
-        this._pivotSphereEnabled = false;
-    }
+	/**
+	 * Remove the sphere as the representation of the pivot position.
+	 *
+	 */
+	disablePivotSphere() {
+		this.destroyPivotSphere();
+		this._pivotSphereEnabled = false;
+	}
 
-    /**
-     * Begins pivoting.
-     */
-    startPivot() {
+	/**
+	 * Begins pivoting.
+	 */
+	startPivot() {
+		if (this._cameraLookingDownwards()) {
+			this._pivoting = false;
+			return false;
+		}
 
-        if (this._cameraLookingDownwards()) {
-            this._pivoting = false;
-            return false;
-        }
+		const camera = this._scene.camera;
 
-        const camera = this._scene.camera;
+		let lookat = math.lookAtMat4v(camera.eye, camera.look, camera.worldUp);
+		math.transformPoint3(lookat, this.getPivotPos(), this._cameraOffset);
 
-        let lookat = math.lookAtMat4v(camera.eye, camera.look, camera.worldUp);
-        math.transformPoint3(lookat, this.getPivotPos(), this._cameraOffset);
+		const pivotPos = this.getPivotPos();
+		this._cameraOffset[2] += math.distVec3(camera.eye, pivotPos);
 
-        const pivotPos = this.getPivotPos();
-        this._cameraOffset[2] += math.distVec3(camera.eye, pivotPos);
+		lookat = math.inverseMat4(lookat);
 
-        lookat = math.inverseMat4(lookat);
+		const offset = math.transformVec3(lookat, this._cameraOffset);
+		const diff = math.vec3();
 
-        const offset = math.transformVec3(lookat, this._cameraOffset);
-        const diff = math.vec3();
+		math.subVec3(camera.eye, pivotPos, diff);
+		math.addVec3(diff, offset);
 
-        math.subVec3(camera.eye, pivotPos, diff);
-        math.addVec3(diff, offset);
+		if (camera.zUp) {
+			const t = diff[1];
+			diff[1] = diff[2];
+			diff[2] = t;
+		}
 
-        if (camera.zUp) {
-            const t = diff[1];
-            diff[1] = diff[2];
-            diff[2] = t;
-        }
+		this._radius = math.lenVec3(diff);
+		this._polar = Math.acos(diff[1] / this._radius);
+		this._azimuth = Math.atan2(diff[0], diff[2]);
+		this._pivoting = true;
+	}
 
-        this._radius = math.lenVec3(diff);
-        this._polar = Math.acos(diff[1] / this._radius);
-        this._azimuth = Math.atan2(diff[0], diff[2]);
-        this._pivoting = true;
-    }
+	_cameraLookingDownwards() {
+		// Returns true if angle between camera viewing direction and World-space "up" axis is too small
+		const camera = this._scene.camera;
+		const forwardAxis = math.normalizeVec3(math.subVec3(camera.look, camera.eye, tempVec3a$6));
+		const rightAxis = math.cross3Vec3(forwardAxis, camera.worldUp, tempVec3b$3);
+		let rightAxisLen = math.sqLenVec3(rightAxis);
+		return rightAxisLen <= 0.0001;
+	}
 
-    _cameraLookingDownwards() { // Returns true if angle between camera viewing direction and World-space "up" axis is too small
-        const camera = this._scene.camera;
-        const forwardAxis = math.normalizeVec3(math.subVec3(camera.look, camera.eye, tempVec3a$6));
-        const rightAxis = math.cross3Vec3(forwardAxis, camera.worldUp, tempVec3b$3);
-        let rightAxisLen = math.sqLenVec3(rightAxis);
-        return (rightAxisLen <= 0.0001);
-    }
+	/**
+	 * Returns true if we are currently pivoting.
+	 *
+	 * @returns {Boolean}
+	 */
+	getPivoting() {
+		return this._pivoting;
+	}
 
-    /**
-     * Returns true if we are currently pivoting.
-     *
-     * @returns {Boolean}
-     */
-    getPivoting() {
-        return this._pivoting;
-    }
+	/**
+	 * Sets a 3D World-space position to pivot about.
+	 *
+	 * @param {Number[]} worldPos The new World-space pivot position.
+	 */
+	setPivotPos(worldPos) {
+		this._pivotWorldPos.set(worldPos);
+		this._pivotPosSet = true;
+	}
 
-    /**
-     * Sets a 3D World-space position to pivot about.
-     *
-     * @param {Number[]} worldPos The new World-space pivot position.
-     */
-    setPivotPos(worldPos) {
-        this._pivotWorldPos.set(worldPos);
-        this._pivotPosSet = true;
-    }
+	/**
+	 * Sets the pivot position to the 3D projection of the given 2D canvas coordinates on a sphere centered
+	 * at the viewpoint. The radius of the sphere is configured via {@link CameraControl#smartPivot}.
+	 *
+	 *
+	 * @param canvasPos
+	 */
+	setCanvasPivotPos(canvasPos) {
+		const camera = this._scene.camera;
+		const pivotShereRadius = Math.abs(math.distVec3(this._scene.center, camera.eye));
+		const transposedProjectMat = camera.project.transposedMatrix;
+		const Pt3 = transposedProjectMat.subarray(8, 12);
+		const Pt4 = transposedProjectMat.subarray(12);
+		const D = [0, 0, -1.0, 1];
+		const screenZ = math.dotVec4(D, Pt3) / math.dotVec4(D, Pt4);
+		const worldPos = tempVec4a$3;
+		camera.project.unproject(canvasPos, screenZ, tempVec4b$3, tempVec4c, worldPos);
+		const eyeWorldPosVec = math.normalizeVec3(math.subVec3(worldPos, camera.eye, tempVec3a$6));
+		const posOnSphere = math.addVec3(
+			camera.eye,
+			math.mulVec3Scalar(eyeWorldPosVec, pivotShereRadius, tempVec3b$3),
+			tempVec3c$2
+		);
+		this.setPivotPos(posOnSphere);
+	}
 
-    /**
-     * Sets the pivot position to the 3D projection of the given 2D canvas coordinates on a sphere centered
-     * at the viewpoint. The radius of the sphere is configured via {@link CameraControl#smartPivot}.
-     *
-     *
-     * @param canvasPos
-     */
-    setCanvasPivotPos(canvasPos) {
-        const camera = this._scene.camera;
-        const pivotShereRadius = Math.abs(math.distVec3(this._scene.center, camera.eye));
-        const transposedProjectMat = camera.project.transposedMatrix;
-        const Pt3 = transposedProjectMat.subarray(8, 12);
-        const Pt4 = transposedProjectMat.subarray(12);
-        const D = [0, 0, -1.0, 1];
-        const screenZ = math.dotVec4(D, Pt3) / math.dotVec4(D, Pt4);
-        const worldPos = tempVec4a$3;
-        camera.project.unproject(canvasPos, screenZ, tempVec4b$3, tempVec4c, worldPos);
-        const eyeWorldPosVec = math.normalizeVec3(math.subVec3(worldPos, camera.eye, tempVec3a$6));
-        const posOnSphere = math.addVec3(camera.eye, math.mulVec3Scalar(eyeWorldPosVec, pivotShereRadius, tempVec3b$3), tempVec3c$2);
-        this.setPivotPos(posOnSphere);
-    }
+	/**
+	 * Gets the current position we're pivoting about.
+	 * @returns {Number[]} The current World-space pivot position.
+	 */
+	getPivotPos() {
+		return this._pivotPosSet ? this._pivotWorldPos : this._scene.camera.look; // Avoid pivoting about [0,0,0] by default
+	}
 
-    /**
-     * Gets the current position we're pivoting about.
-     * @returns {Number[]} The current World-space pivot position.
-     */
-    getPivotPos() {
-        return (this._pivotPosSet) ? this._pivotWorldPos : this._scene.camera.look; // Avoid pivoting about [0,0,0] by default
-    }
+	/**
+	 * Continues to pivot.
+	 *
+	 * @param {Number} yawInc Yaw rotation increment.
+	 * @param {Number} pitchInc Pitch rotation increment.
+	 */
+	continuePivot(yawInc, pitchInc) {
+		if (!this._pivoting) {
+			return;
+		}
+		if (yawInc === 0 && pitchInc === 0) {
+			return;
+		}
+		const camera = this._scene.camera;
+		var dx = -yawInc;
+		const dy = -pitchInc;
+		if (camera.worldUp[2] === 1) {
+			dx = -dx;
+		}
+		this._azimuth += -dx * 0.01;
+		this._polar += dy * 0.01;
+		this._polar = math.clamp(this._polar, 0.001, Math.PI - 0.001);
+		const pos = [
+			this._radius * Math.sin(this._polar) * Math.sin(this._azimuth),
+			this._radius * Math.cos(this._polar),
+			this._radius * Math.sin(this._polar) * Math.cos(this._azimuth)
+		];
+		if (camera.worldUp[2] === 1) {
+			const t = pos[1];
+			pos[1] = pos[2];
+			pos[2] = t;
+		}
+		// Preserve the eye->look distance, since in xeokit "look" is the point-of-interest, not the direction vector.
+		const eyeLookLen = math.lenVec3(math.subVec3(camera.look, camera.eye, math.vec3()));
+		const pivotPos = this.getPivotPos();
+		math.addVec3(pos, pivotPos);
+		let lookat = math.lookAtMat4v(pos, pivotPos, camera.worldUp);
+		lookat = math.inverseMat4(lookat);
+		const offset = math.transformVec3(lookat, this._cameraOffset);
+		lookat[12] -= offset[0];
+		lookat[13] -= offset[1];
+		lookat[14] -= offset[2];
+		const zAxis = [lookat[8], lookat[9], lookat[10]];
+		camera.eye = [lookat[12], lookat[13], lookat[14]];
+		math.subVec3(camera.eye, math.mulVec3Scalar(zAxis, eyeLookLen), camera.look);
+		camera.up = [lookat[4], lookat[5], lookat[6]];
+		this.showPivot();
+	}
 
-    /**
-     * Continues to pivot.
-     *
-     * @param {Number} yawInc Yaw rotation increment.
-     * @param {Number} pitchInc Pitch rotation increment.
-     */
-    continuePivot(yawInc, pitchInc) {
-        if (!this._pivoting) {
-            return;
-        }
-        if (yawInc === 0 && pitchInc === 0) {
-            return;
-        }
-        const camera = this._scene.camera;
-        var dx = -yawInc;
-        const dy = -pitchInc;
-        if (camera.worldUp[2] === 1) {
-            dx = -dx;
-        }
-        this._azimuth += -dx * .01;
-        this._polar += dy * .01;
-        this._polar = math.clamp(this._polar, .001, Math.PI - .001);
-        const pos = [
-            this._radius * Math.sin(this._polar) * Math.sin(this._azimuth),
-            this._radius * Math.cos(this._polar),
-            this._radius * Math.sin(this._polar) * Math.cos(this._azimuth)
-        ];
-        if (camera.worldUp[2] === 1) {
-            const t = pos[1];
-            pos[1] = pos[2];
-            pos[2] = t;
-        }
-        // Preserve the eye->look distance, since in xeokit "look" is the point-of-interest, not the direction vector.
-        const eyeLookLen = math.lenVec3(math.subVec3(camera.look, camera.eye, math.vec3()));
-        const pivotPos = this.getPivotPos();
-        math.addVec3(pos, pivotPos);
-        let lookat = math.lookAtMat4v(pos, pivotPos, camera.worldUp);
-        lookat = math.inverseMat4(lookat);
-        const offset = math.transformVec3(lookat, this._cameraOffset);
-        lookat[12] -= offset[0];
-        lookat[13] -= offset[1];
-        lookat[14] -= offset[2];
-        const zAxis = [lookat[8], lookat[9], lookat[10]];
-        camera.eye = [lookat[12], lookat[13], lookat[14]];
-        math.subVec3(camera.eye, math.mulVec3Scalar(zAxis, eyeLookLen), camera.look);
-        camera.up = [lookat[4], lookat[5], lookat[6]];
-        this.showPivot();
-    }
-
-    /**
-     * Shows the pivot position.
-     *
-     * Only works if we set an  HTML DOM element to represent the pivot position.
-     */
-    showPivot() {
-        if (this._shown) {
-            return;
-        }
-        if (this._pivotElement) {
-            this.updatePivotElement();
-            this._pivotElement.style.visibility = "visible";
-        }
-        if (this._pivotSphereEnabled) {
-            this.destroyPivotSphere();
-            this.createPivotSphere();
-        }
-        this._shown = true;
-    }
+	/**
+	 * Shows the pivot position.
+	 *
+	 * Only works if we set an  HTML DOM element to represent the pivot position.
+	 */
+	showPivot() {
+		if (this._shown) {
+			return;
+		}
+		if (this._pivotElement) {
+			this.updatePivotElement();
+			this._pivotElement.style.visibility = "visible";
+		}
+		if (this._pivotSphereEnabled) {
+			this.destroyPivotSphere();
+			this.createPivotSphere();
+		}
+		this._shown = true;
+	}
 
-    /**
-     * Hides the pivot position.
-     *
-     * Only works if we set an  HTML DOM element to represent the pivot position.
-     */
-    hidePivot() {
-        if (!this._shown) {
-            return;
-        }
-        if (this._pivotElement) {
-            this._pivotElement.style.visibility = "hidden";
-        }
-        if (this._pivotSphereEnabled) {
-            this.destroyPivotSphere();
-        }
-        this._shown = false;
-    }
+	/**
+	 * Hides the pivot position.
+	 *
+	 * Only works if we set an  HTML DOM element to represent the pivot position.
+	 */
+	hidePivot() {
+		if (!this._shown) {
+			return;
+		}
+		if (this._pivotElement) {
+			this._pivotElement.style.visibility = "hidden";
+		}
+		if (this._pivotSphereEnabled) {
+			this.destroyPivotSphere();
+		}
+		this._shown = false;
+	}
 
-    /**
-     * Finishes pivoting.
-     */
-    endPivot() {
-        this._pivoting = false;
-    }
+	/**
+	 * Finishes pivoting.
+	 */
+	endPivot() {
+		this._pivoting = false;
+	}
 
-    destroy() {
-        this.destroyPivotSphere();
-        this._scene.camera.off(this._onViewMatrix);
-        this._scene.camera.off(this._onProjMatrix);
-        this._scene.off(this._onTick);
-    }
+	destroy() {
+		this.destroyPivotSphere();
+		this._scene.camera.off(this._onViewMatrix);
+		this._scene.camera.off(this._onProjMatrix);
+		this._scene.off(this._onTick);
+	}
 }
 
 /**
@@ -95063,1270 +95119,1274 @@ const DEFAULT_SNAP_EDGE = true;
  * * ````"azerty"````
  */
 class CameraControl extends Component {
+	/**
+	 * @private
+	 * @constructor
+	 */
+	constructor(owner, cfg = {}) {
+		super(owner, cfg);
 
-    /**
-     * @private
-     * @constructor
-     */
-    constructor(owner, cfg = {}) {
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.PAN_LEFT = 0;
 
-        super(owner, cfg);
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.PAN_RIGHT = 1;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.PAN_LEFT = 0;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.PAN_UP = 2;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.PAN_RIGHT = 1;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.PAN_DOWN = 3;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.PAN_UP = 2;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.PAN_FORWARDS = 4;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.PAN_DOWN = 3;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.PAN_BACKWARDS = 5;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.PAN_FORWARDS = 4;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.ROTATE_X_POS = 6;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.PAN_BACKWARDS = 5;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.ROTATE_X_NEG = 7;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.ROTATE_X_POS = 6;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.ROTATE_Y_POS = 8;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.ROTATE_X_NEG = 7;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.ROTATE_Y_NEG = 9;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.ROTATE_Y_POS = 8;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.DOLLY_FORWARDS = 10;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.ROTATE_Y_NEG = 9;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.DOLLY_BACKWARDS = 11;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.DOLLY_FORWARDS = 10;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.AXIS_VIEW_RIGHT = 12;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.DOLLY_BACKWARDS = 11;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.AXIS_VIEW_BACK = 13;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.AXIS_VIEW_RIGHT = 12;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.AXIS_VIEW_LEFT = 14;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.AXIS_VIEW_BACK = 13;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.AXIS_VIEW_FRONT = 15;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.AXIS_VIEW_LEFT = 14;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.AXIS_VIEW_TOP = 16;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.AXIS_VIEW_FRONT = 15;
+		/**
+		 * Identifies the XX action.
+		 * @final
+		 * @type {Number}
+		 */
+		this.AXIS_VIEW_BOTTOM = 17;
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.AXIS_VIEW_TOP = 16;
+		this._keyMap = {}; // Maps key codes to the above actions
 
-        /**
-         * Identifies the XX action.
-         * @final
-         * @type {Number}
-         */
-        this.AXIS_VIEW_BOTTOM = 17;
+		this.scene.canvas.canvas.oncontextmenu = (e) => {
+			e.preventDefault();
+		};
 
-        this._keyMap = {}; // Maps key codes to the above actions
+		// User-settable CameraControl configurations
 
-        this.scene.canvas.canvas.oncontextmenu = (e) => {
-            e.preventDefault();
-        };
+		this._configs = {
+			// Private
 
-        // User-settable CameraControl configurations
+			longTapTimeout: 600, // Millisecs
+			longTapRadius: 5, // Pixels
 
-        this._configs = {
+			// General
 
-            // Private
+			active: true,
+			keyboardLayout: "qwerty",
+			navMode: "orbit",
+			planView: false,
+			firstPerson: false,
+			followPointer: true,
+			doublePickFlyTo: true,
+			panRightClick: true,
+			showPivot: false,
+			pointerEnabled: true,
+			constrainVertical: false,
+			smartPivot: false,
+			doubleClickTimeFrame: 250,
 
-            longTapTimeout: 600, // Millisecs
-            longTapRadius: 5, // Pixels
+			snapToVertex: DEFAULT_SNAP_VERTEX,
+			snapToEdge: DEFAULT_SNAP_EDGE,
+			snapRadius: DEFAULT_SNAP_PICK_RADIUS,
 
-            // General
+			// Rotation
 
-            active: true,
-            keyboardLayout: "qwerty",
-            navMode: "orbit",
-            planView: false,
-            firstPerson: false,
-            followPointer: true,
-            doublePickFlyTo: true,
-            panRightClick: true,
-            showPivot: false,
-            pointerEnabled: true,
-            constrainVertical: false,
-            smartPivot: false,
-            doubleClickTimeFrame: 250,
-            
-            snapToVertex: DEFAULT_SNAP_VERTEX,
-            snapToEdge: DEFAULT_SNAP_EDGE,
-            snapRadius: DEFAULT_SNAP_PICK_RADIUS,
+			dragRotationRate: 360.0,
+			keyboardRotationRate: 90.0,
+			rotationInertia: 0.0,
 
-            // Rotation
+			// Panning
 
-            dragRotationRate: 360.0,
-            keyboardRotationRate: 90.0,
-            rotationInertia: 0.0,
+			keyboardPanRate: 1.0,
+			touchPanRate: 1.0,
+			panInertia: 0.5,
 
-            // Panning
+			// Dollying
 
-            keyboardPanRate: 1.0,
-            touchPanRate: 1.0,
-            panInertia: 0.5,
+			keyboardDollyRate: 10,
+			mouseWheelDollyRate: 100,
+			touchDollyRate: 0.2,
+			dollyInertia: 0,
+			dollyProximityThreshold: 30.0,
+			dollyMinSpeed: 0.04
+		};
 
-            // Dollying
+		// Current runtime state of the CameraControl
+
+		this._states = {
+			pointerCanvasPos: math.vec2(),
+			mouseover: false,
+			followPointerDirty: true,
+			mouseDownClientX: 0,
+			mouseDownClientY: 0,
+			mouseDownCursorX: 0,
+			mouseDownCursorY: 0,
+			touchStartTime: null,
+			activeTouches: [],
+			tapStartPos: math.vec2(),
+			tapStartTime: -1,
+			lastTapTime: -1,
+			longTouchTimeout: null
+		};
 
-            keyboardDollyRate: 10,
-            mouseWheelDollyRate: 100,
-            touchDollyRate: 0.2,
-            dollyInertia: 0,
-            dollyProximityThreshold: 30.0,
-            dollyMinSpeed: 0.04
-        };
+		// Updates for CameraUpdater to process on next Scene "tick" event
 
-        // Current runtime state of the CameraControl
-
-        this._states = {
-            pointerCanvasPos: math.vec2(),
-            mouseover: false,
-            followPointerDirty: true,
-            mouseDownClientX: 0,
-            mouseDownClientY: 0,
-            mouseDownCursorX: 0,
-            mouseDownCursorY: 0,
-            touchStartTime: null,
-            activeTouches: [],
-            tapStartPos: math.vec2(),
-            tapStartTime: -1,
-            lastTapTime: -1,
-            longTouchTimeout: null
-        };
+		this._updates = {
+			rotateDeltaX: 0,
+			rotateDeltaY: 0,
+			panDeltaX: 0,
+			panDeltaY: 0,
+			panDeltaZ: 0,
+			dollyDelta: 0
+		};
 
-        // Updates for CameraUpdater to process on next Scene "tick" event
+		// Controllers to assist input event handlers with controlling the Camera
 
-        this._updates = {
-            rotateDeltaX: 0,
-            rotateDeltaY: 0,
-            panDeltaX: 0,
-            panDeltaY: 0,
-            panDeltaZ: 0,
-            dollyDelta: 0
-        };
+		const scene = this.scene;
 
-        // Controllers to assist input event handlers with controlling the Camera
+		this._controllers = {
+			cameraControl: this,
+			pickController: new PickController(this, this._configs),
+			pivotController: new PivotController(scene, this._configs),
+			panController: new PanController(scene),
+			cameraFlight: new CameraFlightAnimation(this, {
+				duration: 0.5
+			})
+		};
 
-        const scene = this.scene;
+		// Input event handlers
 
-        this._controllers = {
-            cameraControl: this,
-            pickController: new PickController(this, this._configs),
-            pivotController: new PivotController(scene, this._configs),
-            panController: new PanController(scene),
-            cameraFlight: new CameraFlightAnimation(this, {
-                duration: 0.5
-            })
-        };
+		this._handlers = [
+			new MouseMiscHandler(this.scene, this._controllers, this._configs, this._states, this._updates),
+			new TouchPanRotateAndDollyHandler(this.scene, this._controllers, this._configs, this._states, this._updates),
+			new MousePanRotateDollyHandler(this.scene, this._controllers, this._configs, this._states, this._updates),
+			new KeyboardAxisViewHandler(this.scene, this._controllers, this._configs, this._states, this._updates),
+			new MousePickHandler(this.scene, this._controllers, this._configs, this._states, this._updates),
+			new TouchPickHandler(this.scene, this._controllers, this._configs, this._states, this._updates),
+			new KeyboardPanRotateDollyHandler(this.scene, this._controllers, this._configs, this._states, this._updates)
+		];
 
-        // Input event handlers
+		// Applies scheduled updates to the Camera on each Scene "tick" event
 
-        this._handlers = [
-            new MouseMiscHandler(this.scene, this._controllers, this._configs, this._states, this._updates),
-            new TouchPanRotateAndDollyHandler(this.scene, this._controllers, this._configs, this._states, this._updates),
-            new MousePanRotateDollyHandler(this.scene, this._controllers, this._configs, this._states, this._updates),
-            new KeyboardAxisViewHandler(this.scene, this._controllers, this._configs, this._states, this._updates),
-            new MousePickHandler(this.scene, this._controllers, this._configs, this._states, this._updates),
-            new TouchPickHandler(this.scene, this._controllers, this._configs, this._states, this._updates),
-            new KeyboardPanRotateDollyHandler(this.scene, this._controllers, this._configs, this._states, this._updates)
-        ];
+		this._cameraUpdater = new CameraUpdater(this.scene, this._controllers, this._configs, this._states, this._updates);
 
-        // Applies scheduled updates to the Camera on each Scene "tick" event
+		// Set initial user configurations
 
-        this._cameraUpdater = new CameraUpdater(this.scene, this._controllers, this._configs, this._states, this._updates);
+		this.navMode = cfg.navMode;
+		if (cfg.planView) {
+			this.planView = cfg.planView;
+		}
+		this.constrainVertical = cfg.constrainVertical;
+		if (cfg.keyboardLayout) {
+			this.keyboardLayout = cfg.keyboardLayout; // Deprecated
+		} else {
+			this.keyMap = cfg.keyMap;
+		}
+		this.doublePickFlyTo = cfg.doublePickFlyTo;
+		this.panRightClick = cfg.panRightClick;
+		this.active = cfg.active;
+		this.followPointer = cfg.followPointer;
+		this.rotationInertia = cfg.rotationInertia;
+		this.keyboardPanRate = cfg.keyboardPanRate;
+		this.touchPanRate = cfg.touchPanRate;
+		this.keyboardRotationRate = cfg.keyboardRotationRate;
+		this.dragRotationRate = cfg.dragRotationRate;
+		this.touchDollyRate = cfg.touchDollyRate;
+		this.dollyInertia = cfg.dollyInertia;
+		this.dollyProximityThreshold = cfg.dollyProximityThreshold;
+		this.dollyMinSpeed = cfg.dollyMinSpeed;
+		this.panInertia = cfg.panInertia;
+		this.pointerEnabled = true;
+		this.keyboardDollyRate = cfg.keyboardDollyRate;
+		this.mouseWheelDollyRate = cfg.mouseWheelDollyRate;
+	}
 
-        // Set initial user configurations
+	/**
+	 * Sets custom mappings of keys to ````CameraControl```` actions.
+	 *
+	 * See class docs for usage.
+	 *
+	 * @param {{Number:Number}|String} value Either a set of new key mappings, or a string to select a keyboard layout,
+	 * which causes ````CameraControl```` to use the default key mappings for that layout.
+	 */
+	set keyMap(value) {
+		value = value || "qwerty";
+		if (utils.isString(value)) {
+			const input = this.scene.input;
+			const keyMap = {};
+
+			switch (value) {
+				default:
+					this.error("Unsupported value for 'keyMap': " + value + " defaulting to 'qwerty'");
+				// Intentional fall-through to "qwerty"
+				case "qwerty":
+					keyMap[this.PAN_LEFT] = [input.KEY_A];
+					keyMap[this.PAN_RIGHT] = [input.KEY_D];
+					keyMap[this.PAN_UP] = [input.KEY_Z];
+					keyMap[this.PAN_DOWN] = [input.KEY_X];
+					keyMap[this.PAN_BACKWARDS] = [];
+					keyMap[this.PAN_FORWARDS] = [];
+					keyMap[this.DOLLY_FORWARDS] = [input.KEY_W, input.KEY_ADD];
+					keyMap[this.DOLLY_BACKWARDS] = [input.KEY_S, input.KEY_SUBTRACT];
+					keyMap[this.ROTATE_X_POS] = [input.KEY_DOWN_ARROW];
+					keyMap[this.ROTATE_X_NEG] = [input.KEY_UP_ARROW];
+					keyMap[this.ROTATE_Y_POS] = [input.KEY_Q, input.KEY_LEFT_ARROW];
+					keyMap[this.ROTATE_Y_NEG] = [input.KEY_E, input.KEY_RIGHT_ARROW];
+					keyMap[this.AXIS_VIEW_RIGHT] = [input.KEY_NUM_1];
+					keyMap[this.AXIS_VIEW_BACK] = [input.KEY_NUM_2];
+					keyMap[this.AXIS_VIEW_LEFT] = [input.KEY_NUM_3];
+					keyMap[this.AXIS_VIEW_FRONT] = [input.KEY_NUM_4];
+					keyMap[this.AXIS_VIEW_TOP] = [input.KEY_NUM_5];
+					keyMap[this.AXIS_VIEW_BOTTOM] = [input.KEY_NUM_6];
+					break;
+
+				case "azerty":
+					keyMap[this.PAN_LEFT] = [input.KEY_Q];
+					keyMap[this.PAN_RIGHT] = [input.KEY_D];
+					keyMap[this.PAN_UP] = [input.KEY_W];
+					keyMap[this.PAN_DOWN] = [input.KEY_X];
+					keyMap[this.PAN_BACKWARDS] = [];
+					keyMap[this.PAN_FORWARDS] = [];
+					keyMap[this.DOLLY_FORWARDS] = [input.KEY_Z, input.KEY_ADD];
+					keyMap[this.DOLLY_BACKWARDS] = [input.KEY_S, input.KEY_SUBTRACT];
+					keyMap[this.ROTATE_X_POS] = [input.KEY_DOWN_ARROW];
+					keyMap[this.ROTATE_X_NEG] = [input.KEY_UP_ARROW];
+					keyMap[this.ROTATE_Y_POS] = [input.KEY_A, input.KEY_LEFT_ARROW];
+					keyMap[this.ROTATE_Y_NEG] = [input.KEY_E, input.KEY_RIGHT_ARROW];
+					keyMap[this.AXIS_VIEW_RIGHT] = [input.KEY_NUM_1];
+					keyMap[this.AXIS_VIEW_BACK] = [input.KEY_NUM_2];
+					keyMap[this.AXIS_VIEW_LEFT] = [input.KEY_NUM_3];
+					keyMap[this.AXIS_VIEW_FRONT] = [input.KEY_NUM_4];
+					keyMap[this.AXIS_VIEW_TOP] = [input.KEY_NUM_5];
+					keyMap[this.AXIS_VIEW_BOTTOM] = [input.KEY_NUM_6];
+					break;
+			}
 
-        this.navMode = cfg.navMode;
-        if (cfg.planView) {
-            this.planView = cfg.planView;
-        }
-        this.constrainVertical = cfg.constrainVertical;
-        if (cfg.keyboardLayout) {
-            this.keyboardLayout = cfg.keyboardLayout; // Deprecated
-        } else {
-            this.keyMap = cfg.keyMap;
-        }
-        this.doublePickFlyTo = cfg.doublePickFlyTo;
-        this.panRightClick = cfg.panRightClick;
-        this.active = cfg.active;
-        this.followPointer = cfg.followPointer;
-        this.rotationInertia = cfg.rotationInertia;
-        this.keyboardPanRate = cfg.keyboardPanRate;
-        this.touchPanRate = cfg.touchPanRate;
-        this.keyboardRotationRate = cfg.keyboardRotationRate;
-        this.dragRotationRate = cfg.dragRotationRate;
-        this.touchDollyRate = cfg.touchDollyRate;
-        this.dollyInertia = cfg.dollyInertia;
-        this.dollyProximityThreshold = cfg.dollyProximityThreshold;
-        this.dollyMinSpeed = cfg.dollyMinSpeed;
-        this.panInertia = cfg.panInertia;
-        this.pointerEnabled = true;
-        this.keyboardDollyRate = cfg.keyboardDollyRate;
-        this.mouseWheelDollyRate = cfg.mouseWheelDollyRate;
-    }
+			this._keyMap = keyMap;
+		} else {
+			const keyMap = value;
+			this._keyMap = keyMap;
+		}
+	}
 
-    /**
-     * Sets custom mappings of keys to ````CameraControl```` actions.
-     *
-     * See class docs for usage.
-     *
-     * @param {{Number:Number}|String} value Either a set of new key mappings, or a string to select a keyboard layout,
-     * which causes ````CameraControl```` to use the default key mappings for that layout.
-     */
-    set keyMap(value) {
-        value = value || "qwerty";
-        if (utils.isString(value)) {
-            const input = this.scene.input;
-            const keyMap = {};
+	/**
+	 * Gets custom mappings of keys to {@link CameraControl} actions.
+	 *
+	 * @returns {{Number:Number}} Current key mappings.
+	 */
+	get keyMap() {
+		return this._keyMap;
+	}
 
-            switch (value) {
+	/**
+	 * Returns true if any keys configured for the given action are down.
+	 * @param action
+	 * @param keyDownMap
+	 * @private
+	 */
+	_isKeyDownForAction(action, keyDownMap) {
+		const keys = this._keyMap[action];
+		if (!keys) {
+			return false;
+		}
+		if (!keyDownMap) {
+			keyDownMap = this.scene.input.keyDown;
+		}
+		for (let i = 0, len = keys.length; i < len; i++) {
+			const key = keys[i];
+			if (keyDownMap[key]) {
+				return true;
+			}
+		}
+		return false;
+	}
 
-                default:
-                    this.error("Unsupported value for 'keyMap': " + value + " defaulting to 'qwerty'");
-                // Intentional fall-through to "qwerty"
-                case "qwerty":
-                    keyMap[this.PAN_LEFT] = [input.KEY_A];
-                    keyMap[this.PAN_RIGHT] = [input.KEY_D];
-                    keyMap[this.PAN_UP] = [input.KEY_Z];
-                    keyMap[this.PAN_DOWN] = [input.KEY_X];
-                    keyMap[this.PAN_BACKWARDS] = [];
-                    keyMap[this.PAN_FORWARDS] = [];
-                    keyMap[this.DOLLY_FORWARDS] = [input.KEY_W, input.KEY_ADD];
-                    keyMap[this.DOLLY_BACKWARDS] = [input.KEY_S, input.KEY_SUBTRACT];
-                    keyMap[this.ROTATE_X_POS] = [input.KEY_DOWN_ARROW];
-                    keyMap[this.ROTATE_X_NEG] = [input.KEY_UP_ARROW];
-                    keyMap[this.ROTATE_Y_POS] = [input.KEY_Q, input.KEY_LEFT_ARROW];
-                    keyMap[this.ROTATE_Y_NEG] = [input.KEY_E, input.KEY_RIGHT_ARROW];
-                    keyMap[this.AXIS_VIEW_RIGHT] = [input.KEY_NUM_1];
-                    keyMap[this.AXIS_VIEW_BACK] = [input.KEY_NUM_2];
-                    keyMap[this.AXIS_VIEW_LEFT] = [input.KEY_NUM_3];
-                    keyMap[this.AXIS_VIEW_FRONT] = [input.KEY_NUM_4];
-                    keyMap[this.AXIS_VIEW_TOP] = [input.KEY_NUM_5];
-                    keyMap[this.AXIS_VIEW_BOTTOM] = [input.KEY_NUM_6];
-                    break;
+	/**
+	 * Sets the HTMl element to represent the pivot point when {@link CameraControl#followPointer} is true.
+	 *
+	 * See class comments for an example.
+	 *
+	 * @param {HTMLElement} element HTML element representing the pivot point.
+	 */
+	set pivotElement(element) {
+		this._controllers.pivotController.setPivotElement(element);
+	}
 
-                case "azerty":
-                    keyMap[this.PAN_LEFT] = [input.KEY_Q];
-                    keyMap[this.PAN_RIGHT] = [input.KEY_D];
-                    keyMap[this.PAN_UP] = [input.KEY_W];
-                    keyMap[this.PAN_DOWN] = [input.KEY_X];
-                    keyMap[this.PAN_BACKWARDS] = [];
-                    keyMap[this.PAN_FORWARDS] = [];
-                    keyMap[this.DOLLY_FORWARDS] = [input.KEY_Z, input.KEY_ADD];
-                    keyMap[this.DOLLY_BACKWARDS] = [input.KEY_S, input.KEY_SUBTRACT];
-                    keyMap[this.ROTATE_X_POS] = [input.KEY_DOWN_ARROW];
-                    keyMap[this.ROTATE_X_NEG] = [input.KEY_UP_ARROW];
-                    keyMap[this.ROTATE_Y_POS] = [input.KEY_A, input.KEY_LEFT_ARROW];
-                    keyMap[this.ROTATE_Y_NEG] = [input.KEY_E, input.KEY_RIGHT_ARROW];
-                    keyMap[this.AXIS_VIEW_RIGHT] = [input.KEY_NUM_1];
-                    keyMap[this.AXIS_VIEW_BACK] = [input.KEY_NUM_2];
-                    keyMap[this.AXIS_VIEW_LEFT] = [input.KEY_NUM_3];
-                    keyMap[this.AXIS_VIEW_FRONT] = [input.KEY_NUM_4];
-                    keyMap[this.AXIS_VIEW_TOP] = [input.KEY_NUM_5];
-                    keyMap[this.AXIS_VIEW_BOTTOM] = [input.KEY_NUM_6];
-                    break;
-            }
+	/**
+	 *  Sets if this ````CameraControl```` is active or not.
+	 *
+	 * When inactive, the ````CameraControl```` will not react to input.
+	 *
+	 * Default is ````true````.
+	 *
+	 * @param {Boolean} value Set ````true```` to activate this ````CameraControl````.
+	 */
+	set active(value) {
+		value = value !== false;
+		this._configs.active = value;
+		this._handlers[1]._active = value;
+		this._handlers[5]._active = value;
+	}
 
-            this._keyMap = keyMap;
-        } else {
-            const keyMap = value;
-            this._keyMap = keyMap;
-        }
-    }
+	/**
+	 * Gets if this ````CameraControl```` is active or not.
+	 *
+	 * When inactive, the ````CameraControl```` will not react to input.
+	 *
+	 * Default is ````true````.
+	 *
+	 * @returns {Boolean} Returns ````true```` if this ````CameraControl```` is active.
+	 */
+	get active() {
+		return this._configs.active;
+	}
 
-    /**
-     * Gets custom mappings of keys to {@link CameraControl} actions.
-     *
-     * @returns {{Number:Number}} Current key mappings.
-     */
-    get keyMap() {
-        return this._keyMap;
-    }
+	/**
+	 * Sets whether the pointer snap to vertex.
+	 *
+	 * @param {boolean} snapToVertex
+	 */
+	set snapToVertex(snapToVertex) {
+		this._configs.snapToVertex = !!snapToVertex;
+	}
 
-    /**
-     * Returns true if any keys configured for the given action are down.
-     * @param action
-     * @param keyDownMap
-     * @private
-     */
-    _isKeyDownForAction(action, keyDownMap) {
-        const keys = this._keyMap[action];
-        if (!keys) {
-            return false;
-        }
-        if (!keyDownMap) {
-            keyDownMap = this.scene.input.keyDown;
-        }
-        for (let i = 0, len = keys.length; i < len; i++) {
-            const key = keys[i];
-            if (keyDownMap[key]) {
-                return true;
-            }
-        }
-        return false;
-    }
+	/**
+	 * Gets whether the pointer snap to vertex.
+	 *
+	 * @returns {boolean}
+	 */
+	get snapToVertex() {
+		return this._configs.snapToVertex;
+	}
 
-    /**
-     * Sets the HTMl element to represent the pivot point when {@link CameraControl#followPointer} is true.
-     *
-     * See class comments for an example.
-     *
-     * @param {HTMLElement} element HTML element representing the pivot point.
-     */
-    set pivotElement(element) {
-        this._controllers.pivotController.setPivotElement(element);
-    }
+	/**
+	 * Sets whether the pointer snap to edge.
+	 *
+	 * @param {boolean} snapToEdge
+	 */
+	set snapToEdge(snapToEdge) {
+		this._configs.snapToEdge = !!snapToEdge;
+	}
 
-    /**
-     *  Sets if this ````CameraControl```` is active or not.
-     *
-     * When inactive, the ````CameraControl```` will not react to input.
-     *
-     * Default is ````true````.
-     *
-     * @param {Boolean} value Set ````true```` to activate this ````CameraControl````.
-     */
-    set active(value) {
-        value = value !== false;
-        this._configs.active = value;
-        this._handlers[1]._active = value;
-        this._handlers[5]._active = value;
-    }
+	/**
+	 * Gets whether the pointer snap to edge.
+	 *
+	 * @returns {boolean}
+	 */
+	get snapToEdge() {
+		return this._configs.snapToEdge;
+	}
 
-    /**
-     * Gets if this ````CameraControl```` is active or not.
-     *
-     * When inactive, the ````CameraControl```` will not react to input.
-     *
-     * Default is ````true````.
-     *
-     * @returns {Boolean} Returns ````true```` if this ````CameraControl```` is active.
-     */
-    get active() {
-        return this._configs.active;
-    }
+	/**
+	 * Sets the current snap radius for "hoverSnapOrSurface" events, to specify whether the radius
+	 * within which the pointer snaps to the nearest vertex or the nearest edge.
+	 *
+	 * Default value is 30 pixels.
+	 *
+	 * @param {Number} snapRadius The snap radius.
+	 */
+	set snapRadius(snapRadius) {
+		snapRadius = snapRadius || DEFAULT_SNAP_PICK_RADIUS;
+		this._configs.snapRadius = snapRadius;
+	}
 
-    /**
-     * Sets whether the pointer snap to vertex.
-     *
-     * @param {boolean} snapToVertex
-     */
-    set snapToVertex(snapToVertex) {
-        this._configs.snapToVertex = !!snapToVertex;
-    }
+	/**
+	 * Gets the current snap radius.
+	 *
+	 * @returns {Number} The snap radius.
+	 */
+	get snapRadius() {
+		return this._configs.snapRadius;
+	}
 
-    /**
-     * Gets whether the pointer snap to vertex.
-     *
-     * @returns {boolean}
-     */
-    get snapToVertex() {
-        return this._configs.snapToVertex;
-    }
+	/**
+	 * Sets the current navigation mode.
+	 *
+	 * Accepted values are:
+	 *
+	 * * "orbit" - rotation orbits about the current target or pivot point,
+	 * * "firstPerson" - rotation is about the current eye position,
+	 * * "planView" - rotation is disabled.
+	 *
+	 * See class comments for more info.
+	 *
+	 * @param {String} navMode The navigation mode: "orbit", "firstPerson" or "planView".
+	 */
+	set navMode(navMode) {
+		navMode = navMode || "orbit";
+		if (navMode !== "firstPerson" && navMode !== "orbit" && navMode !== "planView") {
+			this.error(
+				"Unsupported value for navMode: " +
+					navMode +
+					" - supported values are 'orbit', 'firstPerson' and 'planView' - defaulting to 'orbit'"
+			);
+			navMode = "orbit";
+		}
+		this._configs.firstPerson = navMode === "firstPerson";
+		this._configs.planView = navMode === "planView";
+		if (this._configs.firstPerson || this._configs.planView) {
+			this._controllers.pivotController.hidePivot();
+			this._controllers.pivotController.endPivot();
+		}
+		this._configs.navMode = navMode;
+	}
 
-    /**
-     * Sets whether the pointer snap to edge.
-     *
-     * @param {boolean} snapToEdge
-     */
-    set snapToEdge(snapToEdge) {
-        this._configs.snapToEdge = !!snapToEdge;
-    }
+	/**
+	 * Gets the current navigation mode.
+	 *
+	 * @returns {String} The navigation mode: "orbit", "firstPerson" or "planView".
+	 */
+	get navMode() {
+		return this._configs.navMode;
+	}
 
-    /**
-     * Gets whether the pointer snap to edge.
-     *
-     * @returns {boolean}
-     */
-    get snapToEdge() {
-        return this._configs.snapToEdge;
-    }
+	/**
+	 * Sets whether mouse and touch input is enabled.
+	 *
+	 * Default is ````true````.
+	 *
+	 * Disabling mouse and touch input on ````CameraControl```` is useful when we want to temporarily use mouse or
+	 * touch input to interact with some other 3D control, without disturbing the {@link Camera}.
+	 *
+	 * @param {Boolean} value Set ````true```` to enable mouse and touch input.
+	 */
+	set pointerEnabled(value) {
+		this._reset();
+		this._configs.pointerEnabled = !!value;
+	}
 
-    /**
-     * Sets the current snap radius for "hoverSnapOrSurface" events, to specify whether the radius
-     * within which the pointer snaps to the nearest vertex or the nearest edge.
-     *
-     * Default value is 30 pixels.
-     *
-     * @param {Number} snapRadius The snap radius.
-     */
-    set snapRadius(snapRadius) {
-        snapRadius = snapRadius || DEFAULT_SNAP_PICK_RADIUS;
-        this._configs.snapRadius = snapRadius;
-    }
+	_reset() {
+		for (let i = 0, len = this._handlers.length; i < len; i++) {
+			const handler = this._handlers[i];
+			if (handler.reset) {
+				handler.reset();
+			}
+		}
 
-    /**
-     * Gets the current snap radius.
-     *
-     * @returns {Number} The snap radius.
-     */
-    get snapRadius() {
-        return this._configs.snapRadius;
-    }
-    
-    /**
-     * Sets the current navigation mode.
-     *
-     * Accepted values are:
-     *
-     * * "orbit" - rotation orbits about the current target or pivot point,
-     * * "firstPerson" - rotation is about the current eye position,
-     * * "planView" - rotation is disabled.
-     *
-     * See class comments for more info.
-     *
-     * @param {String} navMode The navigation mode: "orbit", "firstPerson" or "planView".
-     */
-    set navMode(navMode) {
-        navMode = navMode || "orbit";
-        if (navMode !== "firstPerson" && navMode !== "orbit" && navMode !== "planView") {
-            this.error("Unsupported value for navMode: " + navMode + " - supported values are 'orbit', 'firstPerson' and 'planView' - defaulting to 'orbit'");
-            navMode = "orbit";
-        }
-        this._configs.firstPerson = (navMode === "firstPerson");
-        this._configs.planView = (navMode === "planView");
-        if (this._configs.firstPerson || this._configs.planView) {
-            this._controllers.pivotController.hidePivot();
-            this._controllers.pivotController.endPivot();
-        }
-        this._configs.navMode = navMode;
-    }
-
-    /**
-     * Gets the current navigation mode.
-     *
-     * @returns {String} The navigation mode: "orbit", "firstPerson" or "planView".
-     */
-    get navMode() {
-        return this._configs.navMode;
-    }
-
-    /**
-     * Sets whether mouse and touch input is enabled.
-     *
-     * Default is ````true````.
-     *
-     * Disabling mouse and touch input on ````CameraControl```` is useful when we want to temporarily use mouse or
-     * touch input to interact with some other 3D control, without disturbing the {@link Camera}.
-     *
-     * @param {Boolean} value Set ````true```` to enable mouse and touch input.
-     */
-    set pointerEnabled(value) {
-        this._reset();
-        this._configs.pointerEnabled = !!value;
-    }
-
-    _reset() {
-        for (let i = 0, len = this._handlers.length; i < len; i++) {
-            const handler = this._handlers[i];
-            if (handler.reset) {
-                handler.reset();
-            }
-        }
-
-        this._updates.panDeltaX = 0;
-        this._updates.panDeltaY = 0;
-        this._updates.rotateDeltaX = 0;
-        this._updates.rotateDeltaY = 0;
-        this._updates.dolyDelta = 0;
-    }
+		this._updates.panDeltaX = 0;
+		this._updates.panDeltaY = 0;
+		this._updates.rotateDeltaX = 0;
+		this._updates.rotateDeltaY = 0;
+		this._updates.dolyDelta = 0;
+	}
 
-    /**
-     * Gets whether mouse and touch input is enabled.
-     *
-     * Default is ````true````.
-     *
-     * Disabling mouse and touch input on ````CameraControl```` is desirable when we want to temporarily use mouse or
-     * touch input to interact with some other 3D control, without interfering with the {@link Camera}.
-     *
-     * @returns {Boolean} Returns ````true```` if mouse and touch input is enabled.
-     */
-    get pointerEnabled() {
-        return this._configs.pointerEnabled;
-    }
+	/**
+	 * Gets whether mouse and touch input is enabled.
+	 *
+	 * Default is ````true````.
+	 *
+	 * Disabling mouse and touch input on ````CameraControl```` is desirable when we want to temporarily use mouse or
+	 * touch input to interact with some other 3D control, without interfering with the {@link Camera}.
+	 *
+	 * @returns {Boolean} Returns ````true```` if mouse and touch input is enabled.
+	 */
+	get pointerEnabled() {
+		return this._configs.pointerEnabled;
+	}
 
-    /**
-     * Sets whether the {@link Camera} follows the mouse/touch pointer.
-     *
-     * In orbiting mode, the Camera will orbit about the pointer, and will dolly to and from the pointer.
-     *
-     * In fly-to mode, the Camera will dolly to and from the pointer, however the World will always rotate about the Camera position.
-     *
-     * In plan-view mode, the Camera will dolly to and from the pointer, however the Camera will not rotate.
-     *
-     * Default is ````true````.
-     *
-     * See class comments for more info.
-     *
-     * @param {Boolean} value Set ````true```` to enable the Camera to follow the pointer.
-     */
-    set followPointer(value) {
-        this._configs.followPointer = (value !== false);
-    }
+	/**
+	 * Sets whether the {@link Camera} follows the mouse/touch pointer.
+	 *
+	 * In orbiting mode, the Camera will orbit about the pointer, and will dolly to and from the pointer.
+	 *
+	 * In fly-to mode, the Camera will dolly to and from the pointer, however the World will always rotate about the Camera position.
+	 *
+	 * In plan-view mode, the Camera will dolly to and from the pointer, however the Camera will not rotate.
+	 *
+	 * Default is ````true````.
+	 *
+	 * See class comments for more info.
+	 *
+	 * @param {Boolean} value Set ````true```` to enable the Camera to follow the pointer.
+	 */
+	set followPointer(value) {
+		this._configs.followPointer = value !== false;
+	}
 
-    /**
-     * Sets whether the {@link Camera} follows the mouse/touch pointer.
-     *
-     * In orbiting mode, the Camera will orbit about the pointer, and will dolly to and from the pointer.
-     *
-     * In fly-to mode, the Camera will dolly to and from the pointer, however the World will always rotate about the Camera position.
-     *
-     * In plan-view mode, the Camera will dolly to and from the pointer, however the Camera will not rotate.
-     *
-     * Default is ````true````.
-     *
-     * See class comments for more info.
-     *
-     * @returns {Boolean} Returns ````true```` if the Camera follows the pointer.
-     */
-    get followPointer() {
-        return this._configs.followPointer;
-    }
+	/**
+	 * Sets whether the {@link Camera} follows the mouse/touch pointer.
+	 *
+	 * In orbiting mode, the Camera will orbit about the pointer, and will dolly to and from the pointer.
+	 *
+	 * In fly-to mode, the Camera will dolly to and from the pointer, however the World will always rotate about the Camera position.
+	 *
+	 * In plan-view mode, the Camera will dolly to and from the pointer, however the Camera will not rotate.
+	 *
+	 * Default is ````true````.
+	 *
+	 * See class comments for more info.
+	 *
+	 * @returns {Boolean} Returns ````true```` if the Camera follows the pointer.
+	 */
+	get followPointer() {
+		return this._configs.followPointer;
+	}
 
-    /**
-     * Sets the current World-space 3D target position.
-     *
-     * Only applies when {@link CameraControl#followPointer} is ````true````.
-     *
-     * @param {Number[]} worldPos The new World-space 3D target position.
-     */
-    set pivotPos(worldPos) {
-        this._controllers.pivotController.setPivotPos(worldPos);
-    }
+	/**
+	 * Sets the current World-space 3D target position.
+	 *
+	 * Only applies when {@link CameraControl#followPointer} is ````true````.
+	 *
+	 * @param {Number[]} worldPos The new World-space 3D target position.
+	 */
+	set pivotPos(worldPos) {
+		this._controllers.pivotController.setPivotPos(worldPos);
+	}
 
-    /**
-     * Gets the current World-space 3D pivot position.
-     *
-     * Only applies when {@link CameraControl#followPointer} is ````true````.
-     *
-     * @return {Number[]} worldPos The current World-space 3D pivot position.
-     */
-    get pivotPos() {
-        return this._controllers.pivotController.getPivotPos();
-    }
+	/**
+	 * Gets the current World-space 3D pivot position.
+	 *
+	 * Only applies when {@link CameraControl#followPointer} is ````true````.
+	 *
+	 * @return {Number[]} worldPos The current World-space 3D pivot position.
+	 */
+	get pivotPos() {
+		return this._controllers.pivotController.getPivotPos();
+	}
 
-    /**
-     * @deprecated
-     * @param {Boolean} value Set ````true```` to enable dolly-to-pointer behaviour.
-     */
-    set dollyToPointer(value) {
-        this.warn("dollyToPointer property is deprecated - replaced with followPointer");
-        this.followPointer = value;
-    }
+	/**
+	 * @deprecated
+	 * @param {Boolean} value Set ````true```` to enable dolly-to-pointer behaviour.
+	 */
+	set dollyToPointer(value) {
+		this.warn("dollyToPointer property is deprecated - replaced with followPointer");
+		this.followPointer = value;
+	}
 
-    /**
-     * @deprecated
-     * @returns {Boolean} Returns ````true```` if dolly-to-pointer behaviour is enabled.
-     */
-    get dollyToPointer() {
-        this.warn("dollyToPointer property is deprecated - replaced with followPointer");
-        return this.followPointer;
-    }
+	/**
+	 * @deprecated
+	 * @returns {Boolean} Returns ````true```` if dolly-to-pointer behaviour is enabled.
+	 */
+	get dollyToPointer() {
+		this.warn("dollyToPointer property is deprecated - replaced with followPointer");
+		return this.followPointer;
+	}
 
-    /**
-     * @deprecated
-     * @param {Boolean} value Set ````true```` to enable dolly-to-pointer behaviour.
-     */
-    set panToPointer(value) {
-        this.warn("panToPointer property is deprecated - replaced with followPointer");
-    }
+	/**
+	 * @deprecated
+	 * @param {Boolean} value Set ````true```` to enable dolly-to-pointer behaviour.
+	 */
+	set panToPointer(value) {
+		this.warn("panToPointer property is deprecated - replaced with followPointer");
+	}
 
-    /**
-     * @deprecated
-     * @returns {Boolean} Returns ````true```` if dolly-to-pointer behaviour is enabled.
-     */
-    get panToPointer() {
-        this.warn("panToPointer property is deprecated - replaced with followPointer");
-        return false;
-    }
+	/**
+	 * @deprecated
+	 * @returns {Boolean} Returns ````true```` if dolly-to-pointer behaviour is enabled.
+	 */
+	get panToPointer() {
+		this.warn("panToPointer property is deprecated - replaced with followPointer");
+		return false;
+	}
 
-    /**
-     * Sets whether this ````CameraControl```` is in plan-view mode.
-     *
-     * When in plan-view mode, rotation is disabled.
-     *
-     * Default is ````false````.
-     *
-     * Deprecated - use {@link CameraControl#navMode} instead.
-     *
-     * @param {Boolean} value Set ````true```` to enable plan-view mode.
-     * @deprecated
-     */
-    set planView(value) {
-        this._configs.planView = !!value;
-        this._configs.firstPerson = false;
-        if (this._configs.planView) {
-            this._controllers.pivotController.hidePivot();
-            this._controllers.pivotController.endPivot();
-        }
-        this.warn("planView property is deprecated - replaced with navMode");
-    }
+	/**
+	 * Sets whether this ````CameraControl```` is in plan-view mode.
+	 *
+	 * When in plan-view mode, rotation is disabled.
+	 *
+	 * Default is ````false````.
+	 *
+	 * Deprecated - use {@link CameraControl#navMode} instead.
+	 *
+	 * @param {Boolean} value Set ````true```` to enable plan-view mode.
+	 * @deprecated
+	 */
+	set planView(value) {
+		this._configs.planView = !!value;
+		this._configs.firstPerson = false;
+		if (this._configs.planView) {
+			this._controllers.pivotController.hidePivot();
+			this._controllers.pivotController.endPivot();
+		}
+		this.warn("planView property is deprecated - replaced with navMode");
+	}
 
-    /**
-     * Gets whether this ````CameraControl```` is in plan-view mode.
-     *
-     * When in plan-view mode, rotation is disabled.
-     *
-     * Default is ````false````.
-     *
-     * Deprecated - use {@link CameraControl#navMode} instead.
-     *
-     * @returns {Boolean} Returns ````true```` if plan-view mode is enabled.
-     * @deprecated
-     */
-    get planView() {
-        this.warn("planView property is deprecated - replaced with navMode");
-        return this._configs.planView;
-    }
+	/**
+	 * Gets whether this ````CameraControl```` is in plan-view mode.
+	 *
+	 * When in plan-view mode, rotation is disabled.
+	 *
+	 * Default is ````false````.
+	 *
+	 * Deprecated - use {@link CameraControl#navMode} instead.
+	 *
+	 * @returns {Boolean} Returns ````true```` if plan-view mode is enabled.
+	 * @deprecated
+	 */
+	get planView() {
+		this.warn("planView property is deprecated - replaced with navMode");
+		return this._configs.planView;
+	}
 
-    /**
-     * Sets whether this ````CameraControl```` is in first-person mode.
-     *
-     * In "first person" mode (disabled by default) the look position rotates about the eye position. Otherwise,  {@link Camera#eye} rotates about {@link Camera#look}.
-     *
-     * Default is ````false````.
-     *
-     * Deprecated - use {@link CameraControl#navMode} instead.
-     *
-     * @param {Boolean} value Set ````true```` to enable first-person mode.
-     * @deprecated
-     */
-    set firstPerson(value) {
-        this.warn("firstPerson property is deprecated - replaced with navMode");
-        this._configs.firstPerson = !!value;
-        this._configs.planView = false;
-        if (this._configs.firstPerson) {
-            this._controllers.pivotController.hidePivot();
-            this._controllers.pivotController.endPivot();
-        }
-    }
+	/**
+	 * Sets whether this ````CameraControl```` is in first-person mode.
+	 *
+	 * In "first person" mode (disabled by default) the look position rotates about the eye position. Otherwise,  {@link Camera#eye} rotates about {@link Camera#look}.
+	 *
+	 * Default is ````false````.
+	 *
+	 * Deprecated - use {@link CameraControl#navMode} instead.
+	 *
+	 * @param {Boolean} value Set ````true```` to enable first-person mode.
+	 * @deprecated
+	 */
+	set firstPerson(value) {
+		this.warn("firstPerson property is deprecated - replaced with navMode");
+		this._configs.firstPerson = !!value;
+		this._configs.planView = false;
+		if (this._configs.firstPerson) {
+			this._controllers.pivotController.hidePivot();
+			this._controllers.pivotController.endPivot();
+		}
+	}
 
-    /**
-     * Gets whether this ````CameraControl```` is in first-person mode.
-     *
-     * In "first person" mode (disabled by default) the look position rotates about the eye position. Otherwise,  {@link Camera#eye} rotates about {@link Camera#look}.
-     *
-     * Default is ````false````.
-     *
-     * Deprecated - use {@link CameraControl#navMode} instead.
-     *
-     * @returns {Boolean} Returns ````true```` if first-person mode is enabled.
-     * @deprecated
-     */
-    get firstPerson() {
-        this.warn("firstPerson property is deprecated - replaced with navMode");
-        return this._configs.firstPerson;
-    }
+	/**
+	 * Gets whether this ````CameraControl```` is in first-person mode.
+	 *
+	 * In "first person" mode (disabled by default) the look position rotates about the eye position. Otherwise,  {@link Camera#eye} rotates about {@link Camera#look}.
+	 *
+	 * Default is ````false````.
+	 *
+	 * Deprecated - use {@link CameraControl#navMode} instead.
+	 *
+	 * @returns {Boolean} Returns ````true```` if first-person mode is enabled.
+	 * @deprecated
+	 */
+	get firstPerson() {
+		this.warn("firstPerson property is deprecated - replaced with navMode");
+		return this._configs.firstPerson;
+	}
 
-    /**
-     * Sets whether to vertically constrain the {@link Camera} position for first-person navigation.
-     *
-     * When set ````true````, this constrains {@link Camera#eye} to its current vertical position.
-     *
-     * Only applies when {@link CameraControl#navMode} is ````"firstPerson"````.
-     *
-     * Default is ````false````.
-     *
-     * @param {Boolean} value Set ````true```` to vertically constrain the Camera.
-     */
-    set constrainVertical(value) {
-        this._configs.constrainVertical = !!value;
-    }
+	/**
+	 * Sets whether to vertically constrain the {@link Camera} position for first-person navigation.
+	 *
+	 * When set ````true````, this constrains {@link Camera#eye} to its current vertical position.
+	 *
+	 * Only applies when {@link CameraControl#navMode} is ````"firstPerson"````.
+	 *
+	 * Default is ````false````.
+	 *
+	 * @param {Boolean} value Set ````true```` to vertically constrain the Camera.
+	 */
+	set constrainVertical(value) {
+		this._configs.constrainVertical = !!value;
+	}
 
-    /**
-     * Gets whether to vertically constrain the {@link Camera} position for first-person navigation.
-     *
-     * When set ````true````, this constrains {@link Camera#eye} to its current vertical position.
-     *
-     * Only applies when {@link CameraControl#navMode} is ````"firstPerson"````.
-     *
-     * Default is ````false````.
-     *
-     * @returns {Boolean} ````true```` when Camera is vertically constrained.
-     */
-    get constrainVertical() {
-        return this._configs.constrainVertical;
-    }
+	/**
+	 * Gets whether to vertically constrain the {@link Camera} position for first-person navigation.
+	 *
+	 * When set ````true````, this constrains {@link Camera#eye} to its current vertical position.
+	 *
+	 * Only applies when {@link CameraControl#navMode} is ````"firstPerson"````.
+	 *
+	 * Default is ````false````.
+	 *
+	 * @returns {Boolean} ````true```` when Camera is vertically constrained.
+	 */
+	get constrainVertical() {
+		return this._configs.constrainVertical;
+	}
 
-    /**
-     * Sets whether double-picking an {@link Entity} causes the {@link Camera} to fly to its boundary.
-     *
-     * Default is ````false````.
-     *
-     * @param {Boolean} value Set ````true```` to enable double-pick-fly-to mode.
-     */
-    set doublePickFlyTo(value) {
-        this._configs.doublePickFlyTo = value !== false;
-    }
+	/**
+	 * Sets whether double-picking an {@link Entity} causes the {@link Camera} to fly to its boundary.
+	 *
+	 * Default is ````false````.
+	 *
+	 * @param {Boolean} value Set ````true```` to enable double-pick-fly-to mode.
+	 */
+	set doublePickFlyTo(value) {
+		this._configs.doublePickFlyTo = value !== false;
+	}
 
-    /**
-     * Gets whether double-picking an {@link Entity} causes the {@link Camera} to fly to its boundary.
-     *
-     * Default is ````false````.
-     *
-     * @returns {Boolean} Returns ````true```` when double-pick-fly-to mode is enabled.
-     */
-    get doublePickFlyTo() {
-        return this._configs.doublePickFlyTo;
-    }
+	/**
+	 * Gets whether double-picking an {@link Entity} causes the {@link Camera} to fly to its boundary.
+	 *
+	 * Default is ````false````.
+	 *
+	 * @returns {Boolean} Returns ````true```` when double-pick-fly-to mode is enabled.
+	 */
+	get doublePickFlyTo() {
+		return this._configs.doublePickFlyTo;
+	}
 
-    /**
-     * Sets whether either right-clicking (true) or middle-clicking (false) pans the {@link Camera}.
-     *
-     * Default is ````true````.
-     *
-     * @param {Boolean} value Set ````false```` to disable pan on right-click.
-     */
-    set panRightClick(value) {
-        this._configs.panRightClick = value !== false;
-    }
+	/**
+	 * Sets whether either right-clicking (true) or middle-clicking (false) pans the {@link Camera}.
+	 *
+	 * Default is ````true````.
+	 *
+	 * @param {Boolean} value Set ````false```` to disable pan on right-click.
+	 */
+	set panRightClick(value) {
+		this._configs.panRightClick = value !== false;
+	}
 
-    /**
-     * Gets whether right-clicking pans the {@link Camera}.
-     *
-     * Default is ````true````.
-     *
-     * @returns {Boolean} Returns ````false```` when pan on right-click is disabled.
-     */
-    get panRightClick() {
-        return this._configs.panRightClick;
-    }
+	/**
+	 * Gets whether right-clicking pans the {@link Camera}.
+	 *
+	 * Default is ````true````.
+	 *
+	 * @returns {Boolean} Returns ````false```` when pan on right-click is disabled.
+	 */
+	get panRightClick() {
+		return this._configs.panRightClick;
+	}
 
-    /**
-     * Sets a factor in range ````[0..1]```` indicating how much the {@link Camera} keeps moving after you finish rotating it.
-     *
-     * A value of ````0.0```` causes it to immediately stop, ````0.5```` causes its movement to decay 50% on each tick,
-     * while ````1.0```` causes no decay, allowing it continue moving, by the current rate of rotation.
-     *
-     * You may choose an inertia of zero when you want be able to precisely rotate the Camera,
-     * without interference from inertia. Zero inertia can also mean that less frames are rendered while
-     * you are rotating the Camera.
-     *
-     * Default is ````0.0````.
-     *
-     * Does not apply when {@link CameraControl#navMode} is ````"planView"````, which disallows rotation.
-     *
-     * @param {Number} rotationInertia New inertial factor.
-     */
-    set rotationInertia(rotationInertia) {
-        this._configs.rotationInertia = (rotationInertia !== undefined && rotationInertia !== null) ? rotationInertia : 0.0;
-    }
+	/**
+	 * Sets a factor in range ````[0..1]```` indicating how much the {@link Camera} keeps moving after you finish rotating it.
+	 *
+	 * A value of ````0.0```` causes it to immediately stop, ````0.5```` causes its movement to decay 50% on each tick,
+	 * while ````1.0```` causes no decay, allowing it continue moving, by the current rate of rotation.
+	 *
+	 * You may choose an inertia of zero when you want be able to precisely rotate the Camera,
+	 * without interference from inertia. Zero inertia can also mean that less frames are rendered while
+	 * you are rotating the Camera.
+	 *
+	 * Default is ````0.0````.
+	 *
+	 * Does not apply when {@link CameraControl#navMode} is ````"planView"````, which disallows rotation.
+	 *
+	 * @param {Number} rotationInertia New inertial factor.
+	 */
+	set rotationInertia(rotationInertia) {
+		this._configs.rotationInertia = rotationInertia !== undefined && rotationInertia !== null ? rotationInertia : 0.0;
+	}
 
-    /**
-     * Gets the rotation inertia factor.
-     *
-     * Default is ````0.0````.
-     *
-     * Does not apply when {@link CameraControl#navMode} is ````"planView"````, which disallows rotation.
-     *
-     * @returns {Number} The inertia factor.
-     */
-    get rotationInertia() {
-        return this._configs.rotationInertia;
-    }
+	/**
+	 * Gets the rotation inertia factor.
+	 *
+	 * Default is ````0.0````.
+	 *
+	 * Does not apply when {@link CameraControl#navMode} is ````"planView"````, which disallows rotation.
+	 *
+	 * @returns {Number} The inertia factor.
+	 */
+	get rotationInertia() {
+		return this._configs.rotationInertia;
+	}
 
-    /**
-     * Sets how much the {@link Camera} pans each second with keyboard input.
-     *
-     * Default is ````5.0````, to pan the Camera ````5.0```` World-space units every second that
-     * a panning key is depressed. See the ````CameraControl```` class documentation for which keys control
-     * panning.
-     *
-     * Panning direction is aligned to our Camera's orientation. When we pan horizontally, we pan
-     * to our left and right, when we pan vertically, we pan upwards and downwards, and when we pan forwards
-     * and backwards, we pan along the direction the Camera is pointing.
-     *
-     * Unlike dollying when {@link followPointer} is ````true````, panning does not follow the pointer.
-     *
-     * @param {Number} keyboardPanRate The new keyboard pan rate.
-     */
-    set keyboardPanRate(keyboardPanRate) {
-        this._configs.keyboardPanRate = (keyboardPanRate !== null && keyboardPanRate !== undefined) ? keyboardPanRate : 5.0;
-    }
+	/**
+	 * Sets how much the {@link Camera} pans each second with keyboard input.
+	 *
+	 * Default is ````5.0````, to pan the Camera ````5.0```` World-space units every second that
+	 * a panning key is depressed. See the ````CameraControl```` class documentation for which keys control
+	 * panning.
+	 *
+	 * Panning direction is aligned to our Camera's orientation. When we pan horizontally, we pan
+	 * to our left and right, when we pan vertically, we pan upwards and downwards, and when we pan forwards
+	 * and backwards, we pan along the direction the Camera is pointing.
+	 *
+	 * Unlike dollying when {@link followPointer} is ````true````, panning does not follow the pointer.
+	 *
+	 * @param {Number} keyboardPanRate The new keyboard pan rate.
+	 */
+	set keyboardPanRate(keyboardPanRate) {
+		this._configs.keyboardPanRate = keyboardPanRate !== null && keyboardPanRate !== undefined ? keyboardPanRate : 5.0;
+	}
 
+	/**
+	 * Sets how fast the camera pans on touch panning
+	 *
+	 * @param {Number} touchPanRate The new touch pan rate.
+	 */
+	set touchPanRate(touchPanRate) {
+		this._configs.touchPanRate = touchPanRate !== null && touchPanRate !== undefined ? touchPanRate : 1.0;
+	}
 
-    /**
-     * Sets how fast the camera pans on touch panning
-     *
-     * @param {Number} touchPanRate The new touch pan rate.
-     */
-    set touchPanRate(touchPanRate) {
-        this._configs.touchPanRate = (touchPanRate !== null && touchPanRate !== undefined) ? touchPanRate : 1.0;
-    }
+	/**
+	 * Gets how fast the {@link Camera} pans on touch panning
+	 *
+	 * Default is ````1.0````.
+	 *
+	 * @returns {Number} The current touch pan rate.
+	 */
+	get touchPanRate() {
+		return this._configs.touchPanRate;
+	}
 
-    /**
-     * Gets how fast the {@link Camera} pans on touch panning
-     *
-     * Default is ````1.0````.
-     *
-     * @returns {Number} The current touch pan rate.
-     */
-    get touchPanRate() {
-        return this._configs.touchPanRate;
-    }
+	/**
+	 * Gets how much the {@link Camera} pans each second with keyboard input.
+	 *
+	 * Default is ````5.0````.
+	 *
+	 * @returns {Number} The current keyboard pan rate.
+	 */
+	get keyboardPanRate() {
+		return this._configs.keyboardPanRate;
+	}
 
-    /**
-     * Gets how much the {@link Camera} pans each second with keyboard input.
-     *
-     * Default is ````5.0````.
-     *
-     * @returns {Number} The current keyboard pan rate.
-     */
-    get keyboardPanRate() {
-        return this._configs.keyboardPanRate;
-    }
+	/**
+	 * Sets how many degrees per second the {@link Camera} rotates/orbits with keyboard input.
+	 *
+	 * Default is ````90.0````, to rotate/orbit the Camera ````90.0```` degrees every second that
+	 * a rotation key is depressed. See the ````CameraControl```` class documentation for which keys control
+	 * rotation/orbit.
+	 *
+	 * @param {Number} keyboardRotationRate The new keyboard rotation rate.
+	 */
+	set keyboardRotationRate(keyboardRotationRate) {
+		this._configs.keyboardRotationRate =
+			keyboardRotationRate !== null && keyboardRotationRate !== undefined ? keyboardRotationRate : 90.0;
+	}
 
-    /**
-     * Sets how many degrees per second the {@link Camera} rotates/orbits with keyboard input.
-     *
-     * Default is ````90.0````, to rotate/orbit the Camera ````90.0```` degrees every second that
-     * a rotation key is depressed. See the ````CameraControl```` class documentation for which keys control
-     * rotation/orbit.
-     *
-     * @param {Number} keyboardRotationRate The new keyboard rotation rate.
-     */
-    set keyboardRotationRate(keyboardRotationRate) {
-        this._configs.keyboardRotationRate = (keyboardRotationRate !== null && keyboardRotationRate !== undefined) ? keyboardRotationRate : 90.0;
-    }
+	/**
+	 * Sets how many degrees per second the {@link Camera} rotates/orbits with keyboard input.
+	 *
+	 * Default is ````90.0````.
+	 *
+	 * @returns {Number} The current keyboard rotation rate.
+	 */
+	get keyboardRotationRate() {
+		return this._configs.keyboardRotationRate;
+	}
 
-    /**
-     * Sets how many degrees per second the {@link Camera} rotates/orbits with keyboard input.
-     *
-     * Default is ````90.0````.
-     *
-     * @returns {Number} The current keyboard rotation rate.
-     */
-    get keyboardRotationRate() {
-        return this._configs.keyboardRotationRate;
-    }
+	/**
+	 * Sets the current drag rotation rate.
+	 *
+	 * This configures how many degrees the {@link Camera} rotates/orbits for a full sweep of the canvas by mouse or touch dragging.
+	 *
+	 * For example, a value of ````360.0```` indicates that the ````Camera```` rotates/orbits ````360.0```` degrees horizontally
+	 * when we sweep the entire width of the canvas.
+	 *
+	 * ````CameraControl```` makes vertical rotation half as sensitive as horizontal rotation, so that we don't tend to
+	 * flip upside-down. Therefore, a value of ````360.0```` rotates/orbits the ````Camera```` through ````180.0```` degrees
+	 * vertically when we sweep the entire height of the canvas.
+	 *
+	 * Default is ````360.0````.
+	 *
+	 * @param {Number} dragRotationRate The new drag rotation rate.
+	 */
+	set dragRotationRate(dragRotationRate) {
+		this._configs.dragRotationRate =
+			dragRotationRate !== null && dragRotationRate !== undefined ? dragRotationRate : 360.0;
+	}
 
-    /**
-     * Sets the current drag rotation rate.
-     *
-     * This configures how many degrees the {@link Camera} rotates/orbits for a full sweep of the canvas by mouse or touch dragging.
-     *
-     * For example, a value of ````360.0```` indicates that the ````Camera```` rotates/orbits ````360.0```` degrees horizontally
-     * when we sweep the entire width of the canvas.
-     *
-     * ````CameraControl```` makes vertical rotation half as sensitive as horizontal rotation, so that we don't tend to
-     * flip upside-down. Therefore, a value of ````360.0```` rotates/orbits the ````Camera```` through ````180.0```` degrees
-     * vertically when we sweep the entire height of the canvas.
-     *
-     * Default is ````360.0````.
-     *
-     * @param {Number} dragRotationRate The new drag rotation rate.
-     */
-    set dragRotationRate(dragRotationRate) {
-        this._configs.dragRotationRate = (dragRotationRate !== null && dragRotationRate !== undefined) ? dragRotationRate : 360.0;
-    }
+	/**
+	 * Gets the current drag rotation rate.
+	 *
+	 * Default is ````360.0````.
+	 *
+	 * @returns {Number} The current drag rotation rate.
+	 */
+	get dragRotationRate() {
+		return this._configs.dragRotationRate;
+	}
 
-    /**
-     * Gets the current drag rotation rate.
-     *
-     * Default is ````360.0````.
-     *
-     * @returns {Number} The current drag rotation rate.
-     */
-    get dragRotationRate() {
-        return this._configs.dragRotationRate;
-    }
+	/**
+	 * Sets how much the {@link Camera} dollys each second with keyboard input.
+	 *
+	 * Default is ````15.0````, to dolly the {@link Camera} ````15.0```` World-space units per second while we hold down
+	 * the ````+```` and ````-```` keys.
+	 *
+	 * @param {Number} keyboardDollyRate The new keyboard dolly rate.
+	 */
+	set keyboardDollyRate(keyboardDollyRate) {
+		this._configs.keyboardDollyRate =
+			keyboardDollyRate !== null && keyboardDollyRate !== undefined ? keyboardDollyRate : 15.0;
+	}
 
-    /**
-     * Sets how much the {@link Camera} dollys each second with keyboard input.
-     *
-     * Default is ````15.0````, to dolly the {@link Camera} ````15.0```` World-space units per second while we hold down
-     * the ````+```` and ````-```` keys.
-     *
-     * @param {Number} keyboardDollyRate The new keyboard dolly rate.
-     */
-    set keyboardDollyRate(keyboardDollyRate) {
-        this._configs.keyboardDollyRate = (keyboardDollyRate !== null && keyboardDollyRate !== undefined) ? keyboardDollyRate : 15.0;
-    }
+	/**
+	 * Gets how much the {@link Camera} dollys each second with keyboard input.
+	 *
+	 * Default is ````15.0````.
+	 *
+	 * @returns {Number} The current keyboard dolly rate.
+	 */
+	get keyboardDollyRate() {
+		return this._configs.keyboardDollyRate;
+	}
 
-    /**
-     * Gets how much the {@link Camera} dollys each second with keyboard input.
-     *
-     * Default is ````15.0````.
-     *
-     * @returns {Number} The current keyboard dolly rate.
-     */
-    get keyboardDollyRate() {
-        return this._configs.keyboardDollyRate;
-    }
+	/**
+	 * Sets how much the {@link Camera} dollys with touch input.
+	 *
+	 * Default is ````0.2````
+	 *
+	 * @param {Number} touchDollyRate The new touch dolly rate.
+	 */
+	set touchDollyRate(touchDollyRate) {
+		this._configs.touchDollyRate = touchDollyRate !== null && touchDollyRate !== undefined ? touchDollyRate : 0.2;
+	}
 
-    /**
-     * Sets how much the {@link Camera} dollys with touch input.
-     *
-     * Default is ````0.2````
-     *
-     * @param {Number} touchDollyRate The new touch dolly rate.
-     */
-    set touchDollyRate(touchDollyRate) {
-        this._configs.touchDollyRate = (touchDollyRate !== null && touchDollyRate !== undefined) ? touchDollyRate : 0.2;
-    }
+	/**
+	 * Gets how much the {@link Camera} dollys each second with touch input.
+	 *
+	 * Default is ````0.2````.
+	 *
+	 * @returns {Number} The current touch dolly rate.
+	 */
+	get touchDollyRate() {
+		return this._configs.touchDollyRate;
+	}
 
-    /**
-     * Gets how much the {@link Camera} dollys each second with touch input.
-     *
-     * Default is ````0.2````.
-     *
-     * @returns {Number} The current touch dolly rate.
-     */
-    get touchDollyRate() {
-        return this._configs.touchDollyRate;
-    }
+	/**
+	 * Sets how much the {@link Camera} dollys each second while the mouse wheel is spinning.
+	 *
+	 * Default is ````100.0````, to dolly the {@link Camera} ````10.0```` World-space units per second as we spin
+	 * the mouse wheel.
+	 *
+	 * @param {Number} mouseWheelDollyRate The new mouse wheel dolly rate.
+	 */
+	set mouseWheelDollyRate(mouseWheelDollyRate) {
+		this._configs.mouseWheelDollyRate =
+			mouseWheelDollyRate !== null && mouseWheelDollyRate !== undefined ? mouseWheelDollyRate : 100.0;
+	}
 
-    /**
-     * Sets how much the {@link Camera} dollys each second while the mouse wheel is spinning.
-     *
-     * Default is ````100.0````, to dolly the {@link Camera} ````10.0```` World-space units per second as we spin
-     * the mouse wheel.
-     *
-     * @param {Number} mouseWheelDollyRate The new mouse wheel dolly rate.
-     */
-    set mouseWheelDollyRate(mouseWheelDollyRate) {
-        this._configs.mouseWheelDollyRate = (mouseWheelDollyRate !== null && mouseWheelDollyRate !== undefined) ? mouseWheelDollyRate : 100.0;
-    }
+	/**
+	 * Gets how much the {@link Camera} dollys each second while the mouse wheel is spinning.
+	 *
+	 * Default is ````100.0````.
+	 *
+	 * @returns {Number} The current mouseWheel dolly rate.
+	 */
+	get mouseWheelDollyRate() {
+		return this._configs.mouseWheelDollyRate;
+	}
 
-    /**
-     * Gets how much the {@link Camera} dollys each second while the mouse wheel is spinning.
-     *
-     * Default is ````100.0````.
-     *
-     * @returns {Number} The current mouseWheel dolly rate.
-     */
-    get mouseWheelDollyRate() {
-        return this._configs.mouseWheelDollyRate;
-    }
+	/**
+	 * Sets the dolly inertia factor.
+	 *
+	 * This factor configures how much the {@link Camera} keeps moving after you finish dollying it.
+	 *
+	 * This factor is a value in range ````[0..1]````. A value of ````0.0```` causes dollying to immediately stop,
+	 * ````0.5```` causes dollying to decay 50% on each animation frame, while ````1.0```` causes no decay, which allows dollying
+	 * to continue until further input stops it.
+	 *
+	 * You might set ````dollyInertia```` to zero when you want be able to precisely position or rotate the Camera,
+	 * without interference from inertia. This also means that xeokit renders less frames while dollying the Camera,
+	 * which can improve rendering performance.
+	 *
+	 * Default is ````0````.
+	 *
+	 * @param {Number} dollyInertia New dolly inertia factor.
+	 */
+	set dollyInertia(dollyInertia) {
+		this._configs.dollyInertia = dollyInertia !== undefined && dollyInertia !== null ? dollyInertia : 0;
+	}
 
-    /**
-     * Sets the dolly inertia factor.
-     *
-     * This factor configures how much the {@link Camera} keeps moving after you finish dollying it.
-     *
-     * This factor is a value in range ````[0..1]````. A value of ````0.0```` causes dollying to immediately stop,
-     * ````0.5```` causes dollying to decay 50% on each animation frame, while ````1.0```` causes no decay, which allows dollying
-     * to continue until further input stops it.
-     *
-     * You might set ````dollyInertia```` to zero when you want be able to precisely position or rotate the Camera,
-     * without interference from inertia. This also means that xeokit renders less frames while dollying the Camera,
-     * which can improve rendering performance.
-     *
-     * Default is ````0````.
-     *
-     * @param {Number} dollyInertia New dolly inertia factor.
-     */
-    set dollyInertia(dollyInertia) {
-        this._configs.dollyInertia = (dollyInertia !== undefined && dollyInertia !== null) ? dollyInertia : 0;
-    }
+	/**
+	 * Gets the dolly inertia factor.
+	 *
+	 * Default is ````0````.
+	 *
+	 * @returns {Number} The current dolly inertia factor.
+	 */
+	get dollyInertia() {
+		return this._configs.dollyInertia;
+	}
 
-    /**
-     * Gets the dolly inertia factor.
-     *
-     * Default is ````0````.
-     *
-     * @returns {Number} The current dolly inertia factor.
-     */
-    get dollyInertia() {
-        return this._configs.dollyInertia;
-    }
+	/**
+	 * Sets the proximity to the closest object below which dolly speed decreases, and above which dolly speed increases.
+	 *
+	 * Default is ````35.0````.
+	 *
+	 * @param {Number} dollyProximityThreshold New dolly proximity threshold.
+	 */
+	set dollyProximityThreshold(dollyProximityThreshold) {
+		this._configs.dollyProximityThreshold =
+			dollyProximityThreshold !== undefined && dollyProximityThreshold !== null ? dollyProximityThreshold : 35.0;
+	}
 
-    /**
-     * Sets the proximity to the closest object below which dolly speed decreases, and above which dolly speed increases.
-     *
-     * Default is ````35.0````.
-     *
-     * @param {Number} dollyProximityThreshold New dolly proximity threshold.
-     */
-    set dollyProximityThreshold(dollyProximityThreshold) {
-        this._configs.dollyProximityThreshold = (dollyProximityThreshold !== undefined && dollyProximityThreshold !== null) ? dollyProximityThreshold : 35.0;
-    }
+	/**
+	 * Gets the proximity to the closest object below which dolly speed decreases, and above which dolly speed increases.
+	 *
+	 * Default is ````35.0````.
+	 *
+	 * @returns {Number} The current dolly proximity threshold.
+	 */
+	get dollyProximityThreshold() {
+		return this._configs.dollyProximityThreshold;
+	}
 
-    /**
-     * Gets the proximity to the closest object below which dolly speed decreases, and above which dolly speed increases.
-     *
-     * Default is ````35.0````.
-     *
-     * @returns {Number} The current dolly proximity threshold.
-     */
-    get dollyProximityThreshold() {
-        return this._configs.dollyProximityThreshold;
-    }
+	/**
+	 * Sets the minimum dolly speed.
+	 *
+	 * Default is ````0.04````.
+	 *
+	 * @param {Number} dollyMinSpeed New dolly minimum speed.
+	 */
+	set dollyMinSpeed(dollyMinSpeed) {
+		this._configs.dollyMinSpeed = dollyMinSpeed !== undefined && dollyMinSpeed !== null ? dollyMinSpeed : 0.04;
+	}
 
-    /**
-     * Sets the minimum dolly speed.
-     *
-     * Default is ````0.04````.
-     *
-     * @param {Number} dollyMinSpeed New dolly minimum speed.
-     */
-    set dollyMinSpeed(dollyMinSpeed) {
-        this._configs.dollyMinSpeed = (dollyMinSpeed !== undefined && dollyMinSpeed !== null) ? dollyMinSpeed : 0.04;
-    }
+	/**
+	 * Gets the minimum dolly speed.
+	 *
+	 * Default is ````0.04````.
+	 *
+	 * @returns {Number} The current minimum dolly speed.
+	 */
+	get dollyMinSpeed() {
+		return this._configs.dollyMinSpeed;
+	}
 
-    /**
-     * Gets the minimum dolly speed.
-     *
-     * Default is ````0.04````.
-     *
-     * @returns {Number} The current minimum dolly speed.
-     */
-    get dollyMinSpeed() {
-        return this._configs.dollyMinSpeed;
-    }
+	/**
+	 * Sets the pan inertia factor.
+	 *
+	 * This factor configures how much the {@link Camera} keeps moving after you finish panning it.
+	 *
+	 * This factor is a value in range ````[0..1]````. A value of ````0.0```` causes panning to immediately stop,
+	 * ````0.5```` causes panning to decay 50% on each animation frame, while ````1.0```` causes no decay, which allows panning
+	 * to continue until further input stops it.
+	 *
+	 * You might set ````panInertia```` to zero when you want be able to precisely position or rotate the Camera,
+	 * without interference from inertia. This also means that xeokit renders less frames while panning the Camera,
+	 * wich can improve rendering performance.
+	 *
+	 * Default is ````0.5````.
+	 *
+	 * @param {Number} panInertia New pan inertia factor.
+	 */
+	set panInertia(panInertia) {
+		this._configs.panInertia = panInertia !== undefined && panInertia !== null ? panInertia : 0.5;
+	}
 
-    /**
-     * Sets the pan inertia factor.
-     *
-     * This factor configures how much the {@link Camera} keeps moving after you finish panning it.
-     *
-     * This factor is a value in range ````[0..1]````. A value of ````0.0```` causes panning to immediately stop,
-     * ````0.5```` causes panning to decay 50% on each animation frame, while ````1.0```` causes no decay, which allows panning
-     * to continue until further input stops it.
-     *
-     * You might set ````panInertia```` to zero when you want be able to precisely position or rotate the Camera,
-     * without interference from inertia. This also means that xeokit renders less frames while panning the Camera,
-     * wich can improve rendering performance.
-     *
-     * Default is ````0.5````.
-     *
-     * @param {Number} panInertia New pan inertia factor.
-     */
-    set panInertia(panInertia) {
-        this._configs.panInertia = (panInertia !== undefined && panInertia !== null) ? panInertia : 0.5;
-    }
+	/**
+	 * Gets the pan inertia factor.
+	 *
+	 * Default is ````0.5````.
+	 *
+	 * @returns {Number} The current pan inertia factor.
+	 */
+	get panInertia() {
+		return this._configs.panInertia;
+	}
 
-    /**
-     * Gets the pan inertia factor.
-     *
-     * Default is ````0.5````.
-     *
-     * @returns {Number} The current pan inertia factor.
-     */
-    get panInertia() {
-        return this._configs.panInertia;
-    }
+	/**
+	 * Sets the keyboard layout.
+	 *
+	 * Supported layouts are:
+	 *
+	 * * ````"qwerty"```` (default)
+	 * * ````"azerty"````
+	 *
+	 * @deprecated
+	 * @param {String} value Selects the keyboard layout.
+	 */
+	set keyboardLayout(value) {
+		// this.warn("keyboardLayout property is deprecated - use keyMap property instead");
+		value = value || "qwerty";
+		if (value !== "qwerty" && value !== "azerty") {
+			this.error("Unsupported value for keyboardLayout - defaulting to 'qwerty'");
+			value = "qwerty";
+		}
+		this._configs.keyboardLayout = value;
+		this.keyMap = this._configs.keyboardLayout;
+	}
 
-    /**
-     * Sets the keyboard layout.
-     *
-     * Supported layouts are:
-     *
-     * * ````"qwerty"```` (default)
-     * * ````"azerty"````
-     *
-     * @deprecated
-     * @param {String} value Selects the keyboard layout.
-     */
-    set keyboardLayout(value) {
-        // this.warn("keyboardLayout property is deprecated - use keyMap property instead");
-        value = value || "qwerty";
-        if (value !== "qwerty" && value !== "azerty") {
-            this.error("Unsupported value for keyboardLayout - defaulting to 'qwerty'");
-            value = "qwerty";
-        }
-        this._configs.keyboardLayout = value;
-        this.keyMap = this._configs.keyboardLayout;
-    }
+	/**
+	 * Gets the keyboard layout.
+	 *
+	 * Supported layouts are:
+	 *
+	 * * ````"qwerty"```` (default)
+	 * * ````"azerty"````
+	 *
+	 * @deprecated
+	 * @returns {String} The current keyboard layout.
+	 */
+	get keyboardLayout() {
+		return this._configs.keyboardLayout;
+	}
 
-    /**
-     * Gets the keyboard layout.
-     *
-     * Supported layouts are:
-     *
-     * * ````"qwerty"```` (default)
-     * * ````"azerty"````
-     *
-     * @deprecated
-     * @returns {String} The current keyboard layout.
-     */
-    get keyboardLayout() {
-        return this._configs.keyboardLayout;
-    }
+	/**
+	 * Sets a sphere as the representation of the pivot position.
+	 *
+	 * @param {Object} [cfg] Sphere configuration.
+	 * @param {String} [cfg.size=1] Optional size factor of the sphere. Defaults to 1.
+	 * @param {String} [cfg.material=PhongMaterial] Optional size factor of the sphere. Defaults to a red opaque material.
+	 */
+	enablePivotSphere(cfg = {}) {
+		this._controllers.pivotController.enablePivotSphere(cfg);
+	}
 
-    /**
-     * Sets a sphere as the representation of the pivot position.
-     *
-     * @param {Object} [cfg] Sphere configuration.
-     * @param {String} [cfg.size=1] Optional size factor of the sphere. Defaults to 1.
-     * @param {String} [cfg.material=PhongMaterial] Optional size factor of the sphere. Defaults to a red opaque material.
-     */
-    enablePivotSphere(cfg = {}) {
-        this._controllers.pivotController.enablePivotSphere(cfg);
-    }
+	/**
+	 * Remove the sphere as the representation of the pivot position.
+	 *
+	 */
+	disablePivotSphere() {
+		this._controllers.pivotController.disablePivotSphere();
+	}
 
-    /**
-     * Remove the sphere as the representation of the pivot position.
-     *
-     */
-    disablePivotSphere() {
-        this._controllers.pivotController.disablePivotSphere();
-    }
-    
-    /**
-     * Sets whether smart default pivoting is enabled.
-     *
-     * When ````true````, we'll pivot by default about the 3D position of the mouse/touch pointer on an
-     * imaginary sphere that's centered at {@link Camera#eye} and sized to the {@link Scene} boundary.
-     *
-     * When ````false````, we'll pivot by default about {@link Camera#look}.
-     *
-     * Default is ````false````.
-     *
-     * @param {Boolean} enabled Set ````true```` to pivot by default about the selected point on the virtual sphere, or ````false```` to pivot by default about {@link Camera#look}.
-     */
-    set smartPivot(enabled) {
-        this._configs.smartPivot = (enabled !== false);
-    }
+	/**
+	 * Sets whether smart default pivoting is enabled.
+	 *
+	 * When ````true````, we'll pivot by default about the 3D position of the mouse/touch pointer on an
+	 * imaginary sphere that's centered at {@link Camera#eye} and sized to the {@link Scene} boundary.
+	 *
+	 * When ````false````, we'll pivot by default about {@link Camera#look}.
+	 *
+	 * Default is ````false````.
+	 *
+	 * @param {Boolean} enabled Set ````true```` to pivot by default about the selected point on the virtual sphere, or ````false```` to pivot by default about {@link Camera#look}.
+	 */
+	set smartPivot(enabled) {
+		this._configs.smartPivot = enabled !== false;
+	}
 
-    /**
-     * Gets whether smart default pivoting is enabled.
-     *
-     * When ````true````, we'll pivot by default about the 3D position of the mouse/touch pointer on an
-     * imaginary sphere that's centered at {@link Camera#eye} and sized to the {@link Scene} boundary.
-     *
-     * When ````false````, we'll pivot by default about {@link Camera#look}.
-     *
-     * Default is ````false````.
-     *
-     * @returns {Boolean} Returns ````true```` when pivoting by default about the selected point on the virtual sphere, or ````false```` when pivoting by default about {@link Camera#look}.
-     */
-    get smartPivot() {
-        return this._configs.smartPivot;
-    }
+	/**
+	 * Gets whether smart default pivoting is enabled.
+	 *
+	 * When ````true````, we'll pivot by default about the 3D position of the mouse/touch pointer on an
+	 * imaginary sphere that's centered at {@link Camera#eye} and sized to the {@link Scene} boundary.
+	 *
+	 * When ````false````, we'll pivot by default about {@link Camera#look}.
+	 *
+	 * Default is ````false````.
+	 *
+	 * @returns {Boolean} Returns ````true```` when pivoting by default about the selected point on the virtual sphere, or ````false```` when pivoting by default about {@link Camera#look}.
+	 */
+	get smartPivot() {
+		return this._configs.smartPivot;
+	}
 
-    /**
-     * Sets the double click time frame length in milliseconds.
-     * 
-     * If two mouse click events occur within this time frame, it is considered a double click. 
-     * 
-     * Default is ````250````
-     * 
-     * @param {Number} value New double click time frame.
-     */
-    set doubleClickTimeFrame(value) {
-        this._configs.doubleClickTimeFrame = (value !== undefined && value !== null) ? value : 250;
-    }
+	/**
+	 * Sets the double click time frame length in milliseconds.
+	 *
+	 * If two mouse click events occur within this time frame, it is considered a double click.
+	 *
+	 * Default is ````250````
+	 *
+	 * @param {Number} value New double click time frame.
+	 */
+	set doubleClickTimeFrame(value) {
+		this._configs.doubleClickTimeFrame = value !== undefined && value !== null ? value : 250;
+	}
 
-    /**
-     * Gets the double click time frame length in milliseconds.
-     *  
-     * Default is ````250````
-     * 
-     * @param {Number} value Current double click time frame.
-     */
-    get doubleClickTimeFrame() {
-        return this._configs.doubleClickTimeFrame;
-    }
+	/**
+	 * Gets the double click time frame length in milliseconds.
+	 *
+	 * Default is ````250````
+	 *
+	 * @param {Number} value Current double click time frame.
+	 */
+	get doubleClickTimeFrame() {
+		return this._configs.doubleClickTimeFrame;
+	}
 
-    /**
-     * Destroys this ````CameraControl````.
-     * @private
-     */
-    destroy() {
-        this._destroyHandlers();
-        this._destroyControllers();
-        this._cameraUpdater.destroy();
-        super.destroy();
-    }
+	/**
+	 * Destroys this ````CameraControl````.
+	 * @private
+	 */
+	destroy() {
+		this._destroyHandlers();
+		this._destroyControllers();
+		this._cameraUpdater.destroy();
+		super.destroy();
+	}
 
-    _destroyHandlers() {
-        for (let i = 0, len = this._handlers.length; i < len; i++) {
-            const handler = this._handlers[i];
-            if (handler.destroy) {
-                handler.destroy();
-            }
-        }
-    }
+	_destroyHandlers() {
+		for (let i = 0, len = this._handlers.length; i < len; i++) {
+			const handler = this._handlers[i];
+			if (handler.destroy) {
+				handler.destroy();
+			}
+		}
+	}
 
-    _destroyControllers() {
-        for (let i = 0, len = this._controllers.length; i < len; i++) {
-            const controller = this._controllers[i];
-            if (controller.destroy) {
-                controller.destroy();
-            }
-        }
-    }
+	_destroyControllers() {
+		for (let i = 0, len = this._controllers.length; i < len; i++) {
+			const controller = this._controllers[i];
+			if (controller.destroy) {
+				controller.destroy();
+			}
+		}
+	}
 }
 
 /**