@openglobus/og 0.11.2 → 0.11.7

package/src/og/bv/Sphere.js

@@ -2,24 +2,23 @@
  * @module og/bv/Sphere
  */
 
-'use strict';
+"use strict";
 
-import { Vec3 } from '../math/Vec3.js';
+import { Vec3 } from "../math/Vec3.js";
 
 /**
  * Bounding sphere class.
  * @class
  * @param {Number} [radius] - Bounding sphere radius.
- * @param {og.Vec3} [center] - Bounding sphere coordiantes.
+ * @param {Vec3} [center] - Bounding sphere coordiantes.
  */
 class Sphere {
     /**
-     * 
-     * @param {number} radius 
-     * @param {Vec3} center 
+     *
+     * @param {number} radius
+     * @param {Vec3} center
      */
     constructor(radius, center) {
-
         /**
          * Sphere radius.
          * @public
@@ -30,7 +29,7 @@ class Sphere {
         /**
          * Sphere coordiantes.
          * @public
-         * @type {og.Vec3}
+         * @type {Vec3}
          */
         this.center = center ? center.clone() : new Vec3();
     }
@@ -41,14 +40,18 @@ class Sphere {
      */
     setFromBounds(bounds) {
         let m = new Vec3(bounds[0], bounds[1], bounds[2]);
-        this.center.set(m.x + (bounds[3] - m.x) * 0.5, m.y + (bounds[3] - m.y) * 0.5, m.z + (bounds[5] - m.z) * 0.5);
+        this.center.set(
+            m.x + (bounds[3] - m.x) * 0.5,
+            m.y + (bounds[3] - m.y) * 0.5,
+            m.z + (bounds[5] - m.z) * 0.5
+        );
         this.radius = this.center.distance(m);
     }
 
     /**
      * Sets bounding sphere coordiantes by ellipsoid geodetic extend.
-     * @param {og.Ellipsoid} ellipsoid - Ellipsoid.
-     * @param {og.Extent} extent - Geodetic extent.
+     * @param {Ellipsoid} ellipsoid - Ellipsoid.
+     * @param {Extent} extent - Geodetic extent.
      */
     setFromExtent(ellipsoid, extent) {
         this.setFromBounds(extent.getCartesianBounds(ellipsoid));

package/src/og/camera/Camera.js

@@ -12,52 +12,56 @@ import { Mat4 } from "../math/Mat4.js";
 /**
  * Camera class.
  * @class
- * @param {og.Renderer} [renderer] - Renderer uses the camera instance.
+ * @param {Renderer} [renderer] - Renderer uses the camera instance.
  * @param {Object} [options] - Camera options:
  * @param {Object} [options.name] - Camera name.
  * @param {number} [options.viewAngle=38] - Camera angle of view. Default is 30.0
  * @param {number} [options.near=1] - Camera near plane distance. Default is 1.0
  * @param {number} [options.far=og.math.MAX] - Camera far plane distance. Deafult is og.math.MAX
- * @param {og.Vec3} [options.eye=[0,0,0]] - Camera eye position. Default (0,0,0)
- * @param {og.Vec3} [options.look=[0,0,0]] - Camera look position. Default (0,0,0)
- * @param {og.Vec3} [options.up=[0,1,0]] - Camera eye position. Default (0,1,0)
+ * @param {Vec3} [options.eye=[0,0,0]] - Camera eye position. Default (0,0,0)
+ * @param {Vec3} [options.look=[0,0,0]] - Camera look position. Default (0,0,0)
+ * @param {Vec3} [options.up=[0,1,0]] - Camera eye position. Default (0,1,0)
  *
  * @fires og.Camera#viewchange
  */
 class Camera {
+    /**
+     * @param {Renderer} [renderer] - Renderer uses the camera instance.
+     * @param {Object} [options] - Camera options:
+     */
     constructor(renderer, options) {
         /**
          * Assigned renderer
          * @public
-         * @type {og.Renderer}
+         * @type {Renderer}
          */
         this.renderer = renderer;
 
         /**
          * Camera events handler
          * @public
-         * @type {og.Events}
+         * @type {Events}
          */
         this.events = new Events(EVENT_NAMES, this);
 
         /**
          * Camera position.
          * @public
-         * @type {og.Vec3}
+         * @type {Vec3}
          */
         this.eye = new Vec3();
 
         /**
          * Camera RTE high position
          * @public
-         * @type {og.Vec3}
+         * @type {Vec3}
          */
         this.eyeHigh = new Float32Array(3);
 
         /**
          * Camera RTE low position
          * @public
-         * @type {og.Vec3}
+         * @type {Vec3}
          */
         this.eyeLow = new Float32Array(3);
 
@@ -78,35 +82,35 @@ class Camera {
         /**
          * Camera normal matrix.
          * @protected
-         * @type {og.Mat3}
+         * @type {Mat3}
          */
         this._normalMatrix = new Mat3();
 
         /**
          * Camera view matrix.
          * @protected
-         * @type {og.Mat4}
+         * @type {Mat4}
          */
         this._viewMatrix = new Mat4();
 
         /**
          * Camera right vector.
          * @protected
-         * @type {og.Vec3}
+         * @type {Vec3}
          */
         this._u = new Vec3(0.0, 1.0, 0.0); // up x n
 
         /**
          * Camera up vector.
          * @protected
-         * @type {og.Vec3}
+         * @type {Vec3}
          */
         this._v = new Vec3(1.0, 0.0, 0.0); // n x u - UP
 
         /**
          * Camera forward vector.
          * @protected
-         * @type {og.Vec3}
+         * @type {Vec3}
          */
         this._n = new Vec3(0.0, 0.0, 1.0); // eye - look - FORWARD
 
@@ -115,7 +119,7 @@ class Camera {
         this._pv = this._v.clone();
         this._pn = this._n.clone();
         this._peye = this.eye.clone();
-        this._moved = false;
+        this.isMoved = false;
 
         this._tanViewAngle_hrad = 0.0;
         this._tanViewAngle_hradOneByHeight = 0.0;
@@ -174,20 +178,13 @@ class Camera {
             n = this._n,
             eye = this.eye;
 
-        if (this.events.moveend.handlers.length) {
-            if (
-                this._peye.equal(eye) &&
-                this._pu.equal(u) &&
-                this._pv.equal(v) &&
-                this._pn.equal(n)
-            ) {
-                if (this._moved) {
-                    this.events.dispatch(this.events.moveend, this);
-                }
-                this._moved = false;
-            } else {
-                this._moved = true;
+        if (this._peye.equal(eye) && this._pu.equal(u) && this._pv.equal(v) && this._pn.equal(n)) {
+            if (this.isMoved) {
+                this.events.dispatch(this.events.moveend, this);
             }
+            this.isMoved = false;
+        } else {
+            this.isMoved = true;
         }
 
         this._pu.copy(u);
@@ -199,14 +196,14 @@ class Camera {
     /**
      * Camera initialization.
      * @public
-     * @param {og.Renderer} renderer - OpenGlobus renderer object.
+     * @param {Renderer} renderer - OpenGlobus renderer object.
      * @param {Object} [options] - Camera options:
      * @param {number} [options.viewAngle] - Camera angle of view. Default is 30.0
      * @param {number} [options.near] - Camera near plane distance. Default is 1.0
      * @param {number} [options.far] - Camera far plane distance. Deafult is og.math.MAX
-     * @param {og.Vec3} [options.eye] - Camera eye position. Default (0,0,0)
-     * @param {og.Vec3} [options.look] - Camera look position. Default (0,0,0)
-     * @param {og.Vec3} [options.up] - Camera eye position. Default (0,1,0)
+     * @param {Vec3} [options.eye] - Camera eye position. Default (0,0,0)
+     * @param {Vec3} [options.look] - Camera look position. Default (0,0,0)
+     * @param {Vec3} [options.up] - Camera eye position. Default (0,1,0)
      */
     _init(options) {
         this._setProj(this._viewAngle, this._aspect);
@@ -362,10 +359,10 @@ class Camera {
     /**
      * Sets camera to eye position
      * @public
-     * @param {og.Vec3} eye - Camera position
-     * @param {og.Vec3} look - Look point
-     * @param {og.Vec3} up - Camera up vector
-     * @returns {og.Camera} - This camera
+     * @param {Vec3} eye - Camera position
+     * @param {Vec3} look - Look point
+     * @param {Vec3} up - Camera up vector
+     * @returns {Camera} - This camera
      */
     set(eye, look, up) {
         this.eye.x = eye.x;
@@ -386,8 +383,8 @@ class Camera {
     /**
      * Sets camera look point
      * @public
-     * @param {og.Vec3} look - Look point
-     * @param {og.Vec3} [up] - Camera up vector otherwise camera current up vector(this._v)
+     * @param {Vec3} look - Look point
+     * @param {Vec3} [up] - Camera up vector otherwise camera current up vector(this._v)
      */
     look(look, up) {
         this._n.set(this.eye.x - look.x, this.eye.y - look.y, this.eye.z - look.z);
@@ -478,7 +475,7 @@ class Camera {
      * @public
      * @param {number} x - Scren X coordinate
      * @param {number} y - Scren Y coordinate
-     * @returns {og.Vec3} - Direction vector
+     * @returns {Vec3} - Direction vector
      */
     unproject(x, y) {
         var c = this.renderer.handler.canvas,
@@ -501,8 +498,8 @@ class Camera {
     /**
      * Gets projected 3d point to the 2d screen coordiantes
      * @public
-     * @param {og.Vec3} v - Cartesian 3d coordiantes
-     * @returns {og.Vec2} - Screen point coordinates
+     * @param {Vec3} v - Cartesian 3d coordiantes
+     * @returns {Vec2} - Screen point coordinates
      */
     project(v) {
         var r = this.frustums[0]._projectionViewMatrix.mulVec4(v.toVec4()),
@@ -516,8 +513,8 @@ class Camera {
      * @param {number} angle - Rotation angle in radians
      * @param {boolean} isArc - If true camera up vector gets from current up vector every frame,
      * otherwise up is always input parameter.
-     * @param {og.Vec3} center - Point that the camera rotates around
-     * @param {og.math.Vecto3} [up] - Camera up vector
+     * @param {Vec3} center - Point that the camera rotates around
+     * @param {Vecto3} [up] - Camera up vector
      */
     rotateAround(angle, isArc, center, up) {
         center = center || Vec3.ZERO;
@@ -541,8 +538,8 @@ class Camera {
      * @param {number} angle - Rotation angle in radians.
      * @param {boolaen} isArc - If true camera up vector gets from current up vector every frame,
      * otherwise up is always input parameter.
-     * @param {og.Vec3} center - Point that the camera rotates around.
-     * @param {og.Vec3} [up] - Camera up vector.
+     * @param {Vec3} center - Point that the camera rotates around.
+     * @param {Vec3} [up] - Camera up vector.
      */
     rotateHorizontal(angle, isArc, center, up) {
         this.rotateAround(angle, isArc, center, up);
@@ -551,7 +548,7 @@ class Camera {
     /**
      * Rotates camera around center point by vecrtical.
      * @param {number} angle - Rotation angle in radians.
-     * @param {og.Vec3} center - Point that the camera rotates around.
+     * @param {Vec3} center - Point that the camera rotates around.
      */
     rotateVertical(angle, center) {
         this.rotateAround(angle, false, center, this._u);
@@ -560,8 +557,8 @@ class Camera {
     /**
      * Gets 3d size factor. Uses in LOD distance calculation.
      * @public
-     * @param {og.Vec3} p - Far point.
-     * @param {og.Vec3} r - Far point.
+     * @param {Vec3} p - Far point.
+     * @param {Vec3} r - Far point.
      * @returns {number} - Size factor.
      */
     projectedSize(p, r) {
@@ -571,7 +568,7 @@ class Camera {
     /**
      * Returns normal matrix.
      * @public
-     * @returns {og.Mat3} - Normal matrix.
+     * @returns {Mat3} - Normal matrix.
      */
     getNormalMatrix() {
         return this._normalMatrix._m;
@@ -580,7 +577,7 @@ class Camera {
     /**
      * Returns model matrix.
      * @public
-     * @returns {og.Mat4} - View matrix.
+     * @returns {Mat4} - View matrix.
      */
     getViewMatrix() {
         return this._viewMatrix._m;
@@ -601,7 +598,7 @@ class Camera {
     /**
      * Returns projection matrix.
      * @public
-     * @returns {og.Mat4} - Projection matrix.
+     * @returns {Mat4} - Projection matrix.
      */
     getProjectionMatrix() {
         return this.frustum._projectionMatrix._m;
@@ -610,7 +607,7 @@ class Camera {
     /**
      * Returns projection and model matrix product.
      * @public
-     * @return {og.Mat4} - Projection-view matrix.
+     * @return {Mat4} - Projection-view matrix.
      */
     getProjectionViewMatrix() {
         return this.frustum._projectionViewMatrix._m;
@@ -619,7 +616,7 @@ class Camera {
     /**
      * Returns inverse projection and model matrix product.
      * @public
-     * @returns {og.Mat4} - Inversed projection-view matrix.
+     * @returns {Mat4} - Inversed projection-view matrix.
      */
     getInverseProjectionViewMatrix() {
         return this.frustum._inverseProjectionViewMatrix._m;
@@ -628,7 +625,7 @@ class Camera {
     /**
      * Returns inverse projection matrix.
      * @public
-     * @returns {og.Mat4} - Inversed projection-view matrix.
+     * @returns {Mat4} - Inversed projection-view matrix.
      */
     getInverseProjectionMatrix() {
         return this.frustum._inverseProjectionMatrix._m;

package/src/og/camera/Frustum.js

@@ -1,6 +1,6 @@
-'use strict';
+"use strict";
 
-import { Mat4 } from '../math/Mat4.js';
+import { Mat4 } from "../math/Mat4.js";
 
 function planeNormalize(plane) {
     var t = 1.0 / Math.sqrt(plane[0] * plane[0] + plane[1] * plane[1] + plane[2] * plane[2]);
@@ -15,6 +15,9 @@ function planeNormalize(plane) {
  * @class
  */
 class Frustum {
+    /**
+     * @param {*} options
+     */
     constructor(options = {}) {
         /**
          * Frustum planes.
@@ -29,28 +32,28 @@ class Frustum {
         /**
          * Camera projection matrix.
          * @protected
-         * @type {og.Mat4}
+         * @type {Mat4}
          */
         this._projectionMatrix = new Mat4();
 
         /**
          * Camera inverse projection matrix.
          * @protected
-         * @type {og.Mat4}
+         * @type {Mat4}
          */
         this._inverseProjectionMatrix = new Mat4();
 
         /**
          * Product of projection and view matrices.
          * @protected
-         * @type {og.Mat4}
+         * @type {Mat4}
          */
         this._projectionViewMatrix = new Mat4();
 
         /**
          * Inverse projectionView Matrix.
          * @protected
-         * @type {og.Mat4}
+         * @type {Mat4}
          */
         this._inverseProjectionViewMatrix = new Mat4();
 
@@ -85,7 +88,8 @@ class Frustum {
          */
         this.far = 0.0;
 
-        this._cameraFrustumIndex = options.cameraFrustumIndex != undefined ? options.cameraFrustumIndex : -1;
+        this._cameraFrustumIndex =
+            options.cameraFrustumIndex != undefined ? options.cameraFrustumIndex : -1;
 
         this.setProjectionMatrix(
             options.fov || 30.0,
@@ -140,15 +144,21 @@ class Frustum {
      * @param {number} far - Far camera distance.
      */
     setProjectionMatrix(angle, aspect, near, far) {
-
-        this.top = near * Math.tan(angle * Math.PI / 360);
+        this.top = near * Math.tan((angle * Math.PI) / 360);
         this.bottom = -this.top;
         this.right = this.top * aspect;
         this.left = -this.right;
         this.near = near;
         this.far = far;
 
-        this._projectionMatrix.setPerspective(this.left, this.right, this.bottom, this.top, near, far);
+        this._projectionMatrix.setPerspective(
+            this.left,
+            this.right,
+            this.bottom,
+            this.top,
+            near,
+            far
+        );
         this._projectionMatrix.inverseTo(this._inverseProjectionMatrix);
     }
 
@@ -158,7 +168,6 @@ class Frustum {
      * @param {Mat4} projectionView - projectionView matrix.
      */
     setViewMatrix(viewMatrix) {
-
         this._projectionViewMatrix = this._projectionMatrix.mul(viewMatrix);
         this._projectionViewMatrix.inverseTo(this._inverseProjectionViewMatrix);
 
@@ -210,7 +219,7 @@ class Frustum {
     /**
      * Returns true if a point in the frustum.
      * @public
-     * @param {og.Vec3} point - Cartesian point.
+     * @param {Vec3} point - Cartesian point.
      * @returns {boolean} -
      */
     containsPoint(point) {
@@ -227,7 +236,7 @@ class Frustum {
     /**
      * Returns true if the frustum contains a bonding sphere, but bottom plane exclude.
      * @public
-     * @param {og.bv.Sphere} sphere - Bounding sphere.
+     * @param {Sphere} sphere - Bounding sphere.
      * @returns {boolean} -
      */
     containsSphereBottomExc(sphere) {
@@ -251,7 +260,7 @@ class Frustum {
     /**
      * Returns true if the frustum contains a bonding sphere.
      * @public
-     * @param {og.bv.Sphere} sphere - Bounding sphere.
+     * @param {Sphere} sphere - Bounding sphere.
      * @returns {boolean} -
      */
     containsSphere(sphere) {
@@ -287,15 +296,17 @@ class Frustum {
     /**
      * Returns true if the frustum contains a bounding box.
      * @public
-     * @param {og.bv.Box} box - Bounding box.
+     * @param {Box} box - Bounding box.
      * @returns {boolean} -
      */
     containsBox(box) {
-        var result = true, cout, cin;
+        var result = true,
+            cout,
+            cin;
 
         for (var i = 0; i < 6; i++) {
-
-            cout = 0; cin = 0;
+            cout = 0;
+            cin = 0;
 
             for (var k = 0; k < 8 && (cin === 0 || cout === 0); k++) {
                 var d = box.vertices[k].dotArr(this._f[i]) + this._f[i][3];

package/src/og/camera/PlanetCamera.js

@@ -17,8 +17,8 @@ import { Mat4 } from "../math/Mat4.js";
 /**
  * Planet camera.
  * @class
- * @extends {og.Camera}
- * @param {og.RenderNode} planet - Planet render node.
+ * @extends {Camera}
+ * @param {RenderNode} planet - Planet render node.
  * @param {Object} [options] - Planet camera options:
  * @param {Object} [options.name] - Camera name.
  * @param {number} [options.viewAngle=37] - Camera angle of view. Default is 35.0
@@ -26,18 +26,22 @@ import { Mat4 } from "../math/Mat4.js";
  * @param {number} [options.far] - Camera far plane distance. Deafult is og.math.MAX
  * @param {number} [options.minAltitude] - Minimal altitude for the camera. Deafult is 1
  * @param {number} [options.maxAltitude] - Maximal altitude for the camera. Deafult is 20000000
- * @param {og.Vec3} [options.eye] - Camera eye position. Default (0,0,0)
- * @param {og.Vec3} [options.look] - Camera look position. Default (0,0,0)
- * @param {og.Vec3} [options.up] - Camera eye position. Default (0,1,0)
+ * @param {Vec3} [options.eye] - Camera eye position. Default (0,0,0)
+ * @param {Vec3} [options.look] - Camera look position. Default (0,0,0)
+ * @param {Vec3} [options.up] - Camera eye position. Default (0,1,0)
  */
 class PlanetCamera extends Camera {
+    /**
+     * @param {RenderNode} planet - Planet render node.
+     * @param {Object} [options] - Planet camera options:
+     */
     constructor(planet, options) {
         super(
             planet.renderer,
             Object.assign(
                 {},
                 {
-                    frustums: /*[[100, 10000000]]*/ [
+                    frustums: /*[[100, 10000000]]*/[
                         [1, 100 + 0.075],
                         [100, 1000 + 0.075],
                         [1000, 1e6 + 10000],
@@ -50,7 +54,7 @@ class PlanetCamera extends Camera {
         /**
          * Assigned camera's planet.
          * @public
-         * @type {og.scene.Planet}
+         * @type {Planet}
          */
         this.planet = planet;
 
@@ -92,14 +96,14 @@ class PlanetCamera extends Camera {
         /**
          * Cartesian coordinates on the terrain.
          * @protected
-         * @type {og.Vec3}
+         * @type {Vec3}
          */
         this._terrainPoint = new Vec3();
 
         /**
          * Quad node that camera flies over.
          * @protected
-         * @type {og.quadTree.Node}
+         * @type {quadTree.Node}
          */
         this._insideSegment = null;
 
@@ -178,7 +182,7 @@ class PlanetCamera extends Camera {
      * @public
      * @param {LonLat} lonlat - New camera and camera view position.
      * @param {LonLat} [lookLonLat] - Look up coordinates.
-     * @param {og.Vec3} [up] - Camera UP vector. Default (0,1,0)
+     * @param {Vec3} [up] - Camera UP vector. Default (0,1,0)
      */
     setLonLat(lonlat, lookLonLat, up) {
         this.stopFlying();
@@ -211,9 +215,9 @@ class PlanetCamera extends Camera {
     /**
      * Gets position by viewable extent.
      * @public
-     * @param {og.Extent} extent - Viewable extent.
+     * @param {Extent} extent - Viewable extent.
      * @param {Number} height - Camera height
-     * @returns {og.Vec3}
+     * @returns {Vec3}
      */
     getExtentPosition(extent, height) {
         var north = extent.getNorth();
@@ -281,7 +285,7 @@ class PlanetCamera extends Camera {
     /**
      * View current extent.
      * @public
-     * @param {og.Extent} extent - Current extent.
+     * @param {Extent} extent - Current extent.
      */
     viewExtent(extent, height) {
         this.stopFlying();
@@ -292,8 +296,8 @@ class PlanetCamera extends Camera {
     /**
      * Flies to the current extent.
      * @public
-     * @param {og.Extent} extent - Current extent.
-     * @param {og.Vec3} [up] - Camera UP in the end of flying. Default - (0,1,0)
+     * @param {Extent} extent - Current extent.
+     * @param {Vec3} [up] - Camera UP in the end of flying. Default - (0,1,0)
      * @param {Number} [ampl] - Altitude amplitude factor.
      * @param {cameraCallback} [completeCallback] - Callback that calls after flying when flying is finished.
      * @param {cameraCallback} [startCallback] - Callback that calls befor the flying begins.
@@ -356,9 +360,9 @@ class PlanetCamera extends Camera {
     /**
      * Flies to the cartesian coordinates.
      * @public
-     * @param {og.Vec3} cartesian - Finish cartesian coordinates.
-     * @param {og.Vec3} [look] - Camera LOOK in the end of flying. Default - (0,0,0)
-     * @param {og.Vec3} [up] - Camera UP vector in the end of flying. Default - (0,1,0)
+     * @param {Vec3} cartesian - Finish cartesian coordinates.
+     * @param {Vec3} [look] - Camera LOOK in the end of flying. Default - (0,0,0)
+     * @param {Vec3} [up] - Camera UP vector in the end of flying. Default - (0,1,0)
      * @param {Number} [ampl=1.0] - Altitude amplitude factor.
      * @param {cameraCallback} [completeCallback] - Callback that calls after flying when flying is finished.
      * @param {cameraCallback} [startCallback] - Callback that calls befor the flying begins.
@@ -453,8 +457,8 @@ class PlanetCamera extends Camera {
      * Flies to the geo coordiantes.
      * @public
      * @param {LonLat} lonlat - Finish coordinates.
-     * @param {og.Vec3} [look] - Camera LOOK in the end of flying. Default - (0,0,0)
-     * @param {og.Vec3} [up] - Camera UP vector in the end of flying. Default - (0,1,0)
+     * @param {Vec3} [look] - Camera LOOK in the end of flying. Default - (0,0,0)
+     * @param {Vec3} [up] - Camera UP vector in the end of flying. Default - (0,1,0)
      * @param {Number} [ampl] - Altitude amplitude factor.
      * @param {cameraCallback} [completeCallback] - Callback that calls after flying when flying is finished.
      * @param {cameraCallback} [startCallback] - Callback that calls befor the flying begins.
@@ -632,15 +636,20 @@ class PlanetCamera extends Camera {
     getHeading() {
         let u = this.eye.normal();
         let f = Vec3.proj_b_to_plane(
-                this.slope >= 0.97 ? this.getUp() : this.getForward(),
-                u
-            ).normalize(),
+            this.slope >= 0.97 ? this.getUp() : this.getForward(),
+            u
+        ).normalize(),
             n = Vec3.proj_b_to_plane(Vec3.UP, u).normalize();
         let res = Math.sign(u.dot(f.cross(n))) * Math.acos(f.dot(n)) * math.DEGREES;
         if (res < 0.0) {
             return 360.0 + res;
         }
         return res;
+    }
+
+    isVisible(poi) {
+        let e = this.eye.length();
+        return this.eye.distance(poi) < Math.sqrt(e * e - this.planet.ellipsoid._a2);
     }
 }
 

package/src/og/control/CompassButton.js

@@ -82,10 +82,14 @@ let svg = `<?xml version="1.0" encoding="UTF-8" standalone="no"?>
 /**
  * Planet compass button
  * @class
- * @extends {og.control.Control}
+ * @extends {Control}
  * @params {Object} [options] - Control options.
  */
 class CompassButton extends Control {
+    /**
+     *
+     * @params {Object} [options] - Control options.
+     */
     constructor(options) {
         super(options);