@openglobus/og 0.15.4 → 0.15.5

package/src/og/segment/Segment.js

@@ -254,11 +254,10 @@ class Segment {
      * @public
      * @param {Entity} entity - Entity.
      * @param {Vec3} res - Point coordinates.
-     * @param {Vec3} [normal] - Terrain point normal.
      * @returns {Vec3} -
      */
-    getEntityTerrainPoint(entity, res, normal) {
-        return this.getTerrainPoint(entity._cartesian, entity._lonlatMerc, res, normal);
+    getEntityTerrainPoint(entity, res) {
+        return this.getTerrainPoint(entity._cartesian, entity._lonlatMerc, res);
     }
 
     isEntityInside(e) {
@@ -274,80 +273,74 @@ class Segment {
      * @param {Vec3} [normal] - Terrain point normal.
      * @returns {number} -
      */
-    getTerrainPoint(xyz, insideSegmentPosition, res, normal) {
-        var verts = this.tempVertices;
+    getTerrainPoint(xyz, insideSegmentPosition, res) {
+        let verts = this.tempVertices;
 
-        _ray.set(xyz, xyz.negateTo());
+        if (verts && verts.length) {
+            let norm = this.planet.ellipsoid.getSurfaceNormal3v(xyz);
+            _ray.set(xyz, norm.negateTo());
 
-        if (verts) {
-            var ne = this._extent.northEast,
+            let ne = this._extent.northEast,
                 sw = this._extent.southWest,
                 size = Math.sqrt(verts.length / 3) - 1;
 
-            var xmax = ne.lon,
+            let xmax = ne.lon,
                 ymax = ne.lat,
                 xmin = sw.lon,
                 ymin = sw.lat,
                 x = insideSegmentPosition.lon,
                 y = insideSegmentPosition.lat;
 
-            var sxn = xmax - xmin,
+            let sxn = xmax - xmin,
                 syn = ymax - ymin;
 
-            var qx = sxn / size,
+            let qx = sxn / size,
                 qy = syn / size;
 
-            var xn = x - xmin,
+            let xn = x - xmin,
                 yn = y - ymin;
 
-            var indX = Math.floor(xn / qx),
+            let indX = Math.floor(xn / qx),
                 indY = Math.floor(size - yn / qy);
 
-            if (verts && verts.length) {
-                var ind_v0 = ((size + 1) * indY + indX) * 3;
-                var ind_v2 = ((size + 1) * (indY + 1) + indX) * 3;
+            let ind_v0 = ((size + 1) * indY + indX) * 3;
+            let ind_v2 = ((size + 1) * (indY + 1) + indX) * 3;
 
-                _v0.set(verts[ind_v0], verts[ind_v0 + 1], verts[ind_v0 + 2]);
-                _v1.set(verts[ind_v0 + 3], verts[ind_v0 + 4], verts[ind_v0 + 5]);
-                _v2.set(verts[ind_v2], verts[ind_v2 + 1], verts[ind_v2 + 2]);
+            _v0.set(verts[ind_v0], verts[ind_v0 + 1], verts[ind_v0 + 2]);
+            _v1.set(verts[ind_v0 + 3], verts[ind_v0 + 4], verts[ind_v0 + 5]);
+            _v2.set(verts[ind_v2], verts[ind_v2 + 1], verts[ind_v2 + 2]);
 
-                let d = _ray.hitTriangle(_v0, _v1, _v2, res, normal);
+            let d = _ray.hitTriangle(_v0, _v1, _v2, res);
 
+            if (d === Ray.INSIDE) {
+                return xyz.distance(res);
+            } else if (d === Ray.AWAY) {
+                _rayEx.set(xyz, norm);
+                let d = _rayEx.hitTriangle(_v0, _v1, _v2, res);
                 if (d === Ray.INSIDE) {
-                    return xyz.distance(res);
-                } else if (d === Ray.AWAY) {
-                    _rayEx.set(xyz, this.planet.ellipsoid.getSurfaceNormal3v(xyz));
-                    let d = _rayEx.hitTriangle(_v0, _v1, _v2, res, normal);
-                    if (d === Ray.INSIDE) {
-                        return -xyz.distance(res);
-                    }
+                    return -xyz.distance(res);
                 }
+            }
 
-                _v3.set(verts[ind_v2 + 3], verts[ind_v2 + 4], verts[ind_v2 + 5]);
+            _v3.set(verts[ind_v2 + 3], verts[ind_v2 + 4], verts[ind_v2 + 5]);
 
-                d = _ray.hitTriangle(_v1, _v3, _v2, res, normal);
+            d = _ray.hitTriangle(_v1, _v3, _v2, res);
+            if (d === Ray.INSIDE) {
+                return xyz.distance(res);
+            } else if (d === Ray.AWAY) {
+                _rayEx.set(xyz, norm);
+                let d = _rayEx.hitTriangle(_v1, _v3, _v2, res);
                 if (d === Ray.INSIDE) {
-                    return xyz.distance(res);
-                } else if (d === Ray.AWAY) {
-                    _rayEx.set(xyz, this.planet.ellipsoid.getSurfaceNormal3v(xyz));
-                    let d = _rayEx.hitTriangle(_v1, _v3, _v2, res, normal);
-                    if (d === Ray.INSIDE) {
-                        return -xyz.distance(res);
-                    }
-                }
-
-                if (d === Ray.AWAY) {
                     return -xyz.distance(res);
                 }
+            }
 
-                return xyz.distance(res);
+            if (d === Ray.AWAY) {
+                return -xyz.distance(res);
             }
 
-            res.copy(this.planet.ellipsoid.hitRay(_ray.origin, _ray.direction));
-            normal && normal.copy(xyz.normal());
             return xyz.distance(res);
         } else {
-            normal && normal.copy(xyz.normal());
             return xyz.distance(this.planet.ellipsoid.hitRay(_ray.origin, _ray.direction));
         }
     }
@@ -1597,7 +1590,7 @@ class Segment {
             shu = sh.uniforms;
 
         var currHeight;
-        if (layerSlice.length) {
+        if (layerSlice && layerSlice.length) {
             currHeight = layerSlice[0]._height;
         } else {
             currHeight = 0;

package/types/LonLat.d.ts

@@ -29,6 +29,14 @@ export class LonLat {
      * @returns {LonLat} -
      */
     static forwardMercator(lon: number, lat: number, height?: number): LonLat;
+    /**
+     * Converts degrees to mercator coordinates.
+     * @static
+     * @param {LonLat} lonLat - Input geodetic degree coordinates
+     * @param {LonLat} res - Output mercator coordinates
+     * @returns {LonLat} - Output mercator coordinates
+     */
+    static forwardMercatorRes(lonLat: LonLat, res: LonLat): LonLat;
     /**
      * Converts mercator to degrees coordinates.
      * @static

package/types/camera/PlanetCamera.d.ts

@@ -215,7 +215,7 @@ export class PlanetCamera extends Camera {
      * @public
      */
     public checkFly(): void;
-    checkTerrainCollision(): void;
+    checkTerrainCollision(): Vec3;
     getSurfaceVisibleDistance(d: any): number;
     getHeading(): number;
     isVisible(poi: any): boolean;

package/types/ellipsoid/Ellipsoid.d.ts

@@ -118,7 +118,19 @@ export class Ellipsoid {
      * @returns {LonLat} -
      */
     public projToSurface(p: Vec3): LonLat;
-    cartesianToLonLat(cart: any): LonLat;
+    /**
+     * Converts 3d cartesian coordinates to geodetic
+     * @param {Vec3} cart - Cartesian coordiantes
+     * @returns {LonLat} - Geodetic coordinates
+     */
+    cartesianToLonLat(cart: Vec3): LonLat;
+    /**
+     * Converts 3d cartesian coordinates to geodetic
+     * @param {Vec3} cart - Cartesian coordiantes
+     * @param {LonLat} res - Link geodetic coordinates variable
+     * @returns {LonLat} - Geodetic coordinates
+     */
+    cartesianToLonLatRes(cart: Vec3, res: LonLat): LonLat;
     /**
      * Gets ellipsoid surface normal.
      * @public

package/types/layer/XYZ.d.ts

@@ -33,7 +33,7 @@ export class XYZ extends Layer {
      * @param {string} name - Layer name.
      * @param {*} options
      */
-    constructor(name: string, options: any);
+    constructor(name: string, options?: any);
     /**
      * Tile url source template.
      * @public

package/types/segment/Segment.d.ts

@@ -163,10 +163,9 @@ export class Segment {
      * @public
      * @param {Entity} entity - Entity.
      * @param {Vec3} res - Point coordinates.
-     * @param {Vec3} [normal] - Terrain point normal.
      * @returns {Vec3} -
      */
-    public getEntityTerrainPoint(entity: Entity, res: Vec3, normal?: Vec3): Vec3;
+    public getEntityTerrainPoint(entity: Entity, res: Vec3): Vec3;
     isEntityInside(e: any): boolean;
     /**
      * Returns distance from object to terrain coordinates and terrain point that calculates out in the res parameter.
@@ -177,7 +176,7 @@ export class Segment {
      * @param {Vec3} [normal] - Terrain point normal.
      * @returns {number} -
      */
-    public getTerrainPoint(xyz: Vec3, insideSegmentPosition: LonLat, res?: Vec3, normal?: Vec3): number;
+    public getTerrainPoint(xyz: Vec3, insideSegmentPosition: LonLat, res?: Vec3): number;
     /**
      * Project wgs86 to segment native projection.
      * @public