@openglobus/og 0.18.0 → 0.18.2

package/lib/js/control/visibleExtent/VisibleExtent.d.ts

@@ -0,0 +1,5 @@
+export class VisibleExtent extends Control {
+    constructor();
+}
+export function visibleExtent(): VisibleExtent;
+import { Control } from "../Control";

package/{src → lib/js}/control/visibleExtent/VisibleExtent.js

@@ -1,34 +1,26 @@
 import { Slice } from "../../segment/Slice";
 import { Control } from "../Control";
 import * as shaders from "./drawnode";
-
 function rewriteSlice() {
     Slice.prototype.init = function (segment) {
         this.visibleExtentOffsetArr = new Float32Array(this.segment.planet.SLICE_SIZE_4);
     };
-
     Slice.prototype.append = function (layer, material) {
         let n = this.layers.length;
-
         this.layers.push(layer);
-
         this.layerOpacityArr[n] = layer.opacity;
-
         let n4 = n * 4;
-
         let arr = layer.applyMaterial(material);
         this.tileOffsetArr[n4] = arr[0];
         this.tileOffsetArr[n4 + 1] = arr[1];
         this.tileOffsetArr[n4 + 2] = arr[2];
         this.tileOffsetArr[n4 + 3] = arr[3];
-
         arr = this.segment._getLayerExtentOffset(layer);
         this.visibleExtentOffsetArr[n4] = arr[0];
         this.visibleExtentOffsetArr[n4 + 1] = arr[1];
         this.visibleExtentOffsetArr[n4 + 2] = arr[2];
         this.visibleExtentOffsetArr[n4 + 3] = arr[3];
     };
-
     Slice.prototype.clear = function () {
         this.layers = null;
         this.tileOffsetArr = null;
@@ -36,38 +28,29 @@ function rewriteSlice() {
         this.visibleExtentOffsetArr = null;
     };
 }
-
 export class VisibleExtent extends Control {
     constructor() {
         super();
-
         rewriteSlice();
     }
-
     oninit() {
         let h = this.renderer.handler;
-
         h.stop();
-
         h.removeProgram("drawnode_screen_nl");
         h.removeProgram("drawnode_screen_wl");
         h.removeProgram("drawnode_colorPicking");
         h.removeProgram("drawnode_depth");
         h.removeProgram("drawnode_heightPicking");
-
         h.addProgram(shaders.drawnode_screen_nl(), true);
         //h.addProgram(shaders.drawnode_screen_wl(), true);
         h.addProgram(shaders.drawnode_screen_wl_webgl2(), true);
         h.addProgram(shaders.drawnode_colorPicking(), true);
         h.addProgram(shaders.drawnode_depth(), true);
         h.addProgram(shaders.drawnode_heightPicking(), true);
-
         h.start();
-
     }
 }
-
 /**
- * @deprecated 
+ * @deprecated
  */
 export const visibleExtent = () => new VisibleExtent();

package/lib/js/control/visibleExtent/drawnode.d.ts

@@ -0,0 +1,7 @@
+import { Program } from "../../webgl/Program";
+export declare function drawnode_screen_nl(): Program;
+export declare function drawnode_screen_wl(): Program;
+export declare function drawnode_screen_wl_webgl2(): Program;
+export declare function drawnode_colorPicking(): Program;
+export declare function drawnode_heightPicking(): Program;
+export declare function drawnode_depth(): Program;

package/{src/control/visibleExtent/drawnode.ts → lib/js/control/visibleExtent/drawnode.js}

@@ -1,23 +1,17 @@
 import { Program } from "../../webgl/Program";
-
 // REMEMBER!
 // src*(1)+dest*(1-src.alpha)
 // glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 // src*(src.alpha)+dest*(1-src.alpha)
 // glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
 const CORNERS = `const vec2 BOTTOMLEFT = vec2(-0.01);
                 const vec2 TOPRIGHT = vec2(1.01);`;
-
 const NIGHT = `const vec3 nightStep = 10.0 * vec3(0.58, 0.48, 0.25);`;
-
-const INSIDE_BOX =
-    `/* return 1 if v inside the box, return 0 otherwise */
+const INSIDE_BOX = `/* return 1 if v inside the box, return 0 otherwise */
     float insideBox(vec2 v) {
         vec2 s = step(BOTTOMLEFT, v) - step(TOPRIGHT, v);
         return s.x * s.y;
     }`;
-
 export function drawnode_screen_nl() {
     return new Program("drawnode_screen_nl", {
         uniforms: {
@@ -38,7 +32,6 @@ export function drawnode_screen_nl() {
             aVertexPositionLow: "vec3",
             aTextureCoord: "vec2"
         },
-
         vertexShader: `attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
             attribute vec2 aTextureCoord;
@@ -63,7 +56,6 @@ export function drawnode_screen_nl() {
 
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
-
         fragmentShader: `precision highp float;
             uniform vec4 tileOffsetArr[5];
             uniform vec4 visibleExtentOffsetArr[5];
@@ -109,7 +101,6 @@ export function drawnode_screen_nl() {
             }`
     });
 }
-
 export function drawnode_screen_wl() {
     return new Program("drawnode_screen_wl", {
         uniforms: {
@@ -118,10 +109,8 @@ export function drawnode_screen_wl() {
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
             height: "float",
-
             uGlobalTextureCoord: "vec4",
             uNormalMapBias: "vec3",
-
             samplerCount: "int",
             tileOffsetArr: "vec4",
             visibleExtentOffsetArr: "vec4",
@@ -142,7 +131,6 @@ export function drawnode_screen_wl() {
             aVertexPositionLow: "vec3",
             aTextureCoord: "vec2"
         },
-
         vertexShader: `attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
             attribute vec2 aTextureCoord;
@@ -177,7 +165,6 @@ export function drawnode_screen_wl() {
                 vTextureCoord.zw = uNormalMapBias.z * ( aTextureCoord + uNormalMapBias.xy );
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
-
         fragmentShader: `precision highp float;
 
             #define MAX_POINT_LIGHTS 1
@@ -270,7 +257,6 @@ export function drawnode_screen_wl() {
             }`
     });
 }
-
 export function drawnode_screen_wl_webgl2() {
     return new Program("drawnode_screen_wl", {
         uniforms: {
@@ -279,10 +265,8 @@ export function drawnode_screen_wl_webgl2() {
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
             height: "float",
-
             uGlobalTextureCoord: "vec4",
             uNormalMapBias: "vec3",
-
             samplerCount: "int",
             tileOffsetArr: "vec4",
             visibleExtentOffsetArr: "vec4",
@@ -303,7 +287,6 @@ export function drawnode_screen_wl_webgl2() {
             aVertexPositionLow: "vec3",
             aTextureCoord: "vec2"
         },
-
         vertexShader: `#version 300 es
 
             in vec3 aVertexPositionHigh;
@@ -340,7 +323,6 @@ export function drawnode_screen_wl_webgl2() {
                 vTextureCoord.zw = uNormalMapBias.z * ( aTextureCoord + uNormalMapBias.xy );
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
-
         fragmentShader: `#version 300 es
 
             precision highp float;
@@ -450,7 +432,6 @@ export function drawnode_screen_wl_webgl2() {
             }`
     });
 }
-
 export function drawnode_colorPicking() {
     return new Program("drawnode_colorPicking", {
         uniforms: {
@@ -471,7 +452,6 @@ export function drawnode_colorPicking() {
             aVertexPositionLow: "vec3",
             aTextureCoord: "vec2"
         },
-
         vertexShader: `attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
             attribute vec2 aTextureCoord;
@@ -496,7 +476,6 @@ export function drawnode_colorPicking() {
                 vTextureCoord = aTextureCoord;
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
-
         fragmentShader: `precision highp float;
             uniform vec4 tileOffsetArr[5];
             uniform vec4 visibleExtentOffsetArr[5];
@@ -550,7 +529,6 @@ export function drawnode_colorPicking() {
             }`
     });
 }
-
 export function drawnode_heightPicking() {
     return new Program("drawnode_heightPicking", {
         uniforms: {
@@ -570,7 +548,6 @@ export function drawnode_heightPicking() {
             aVertexPositionLow: "vec3",
             aTextureCoord: "vec2"
         },
-
         vertexShader: `attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
             attribute vec2 aTextureCoord;
@@ -599,7 +576,6 @@ export function drawnode_heightPicking() {
                 vTextureCoord = aTextureCoord;
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
-
         fragmentShader: `precision highp float;
             uniform sampler2D defaultTexture;
             uniform vec4 tileOffsetArr[5];
@@ -650,7 +626,6 @@ export function drawnode_heightPicking() {
             }`
     });
 }
-
 export function drawnode_depth() {
     return new Program("drawnode_depth", {
         uniforms: {
@@ -671,7 +646,6 @@ export function drawnode_depth() {
             aVertexPositionLow: "vec3",
             aTextureCoord: "vec2"
         },
-
         vertexShader: `#version 300 es
             in vec3 aVertexPositionHigh;
             in vec3 aVertexPositionLow;
@@ -699,7 +673,6 @@ export function drawnode_depth() {
                 vTextureCoord = aTextureCoord;
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
-
         fragmentShader: `#version 300 es
             precision highp float;
             uniform sampler2D defaultTexture;

package/lib/js/ellipsoid/Ellipsoid.d.ts

@@ -0,0 +1,187 @@
+import { LonLat } from "../LonLat";
+import { Quat } from "../math/Quat";
+import { Vec3 } from "../math/Vec3";
+export interface IInverseResult {
+    distance: number;
+    initialAzimuth: number;
+    finalAzimuth: number;
+}
+export interface IDirectResult {
+    destination: LonLat;
+    finalAzimuth: number;
+}
+/**
+ * Class represents a plant ellipsoid.
+ * @class
+ * @param {number} equatorialSize - Equatorial ellipsoid size.
+ * @param {number} polarSize - Polar ellipsoid size.
+ */
+declare class Ellipsoid {
+    /**
+     * Equatorial size
+     * @type {number}
+     * @protected
+     */
+    protected _a: number;
+    /**
+     * Polar size
+     * @type {number}
+     * @protected
+     */
+    protected _b: number;
+    protected _flattening: number;
+    protected _f: number;
+    protected _a2: number;
+    protected _b2: number;
+    protected _e: number;
+    protected _e2: number;
+    protected _e22: number;
+    protected _k: number;
+    protected _k2: number;
+    protected _radii: Vec3;
+    protected _radii2: Vec3;
+    protected _invRadii: Vec3;
+    _invRadii2: Vec3;
+    constructor(equatorialSize?: number, polarSize?: number);
+    /**
+     * Returns the distance travelling from ‘this’ point to destination point along a rhumb line.
+     * @param   {LonLat} startLonLat coordinates.
+     * @param   {LonLat} endLonLat coordinates
+     * @returns {number} Distance in m between this point and destination point (same units as radius).
+     */
+    rhumbDistanceTo(startLonLat: LonLat, endLonLat: LonLat): number;
+    /**
+     * Returns the point at given fraction between two points on the great circle.
+     * @param   {LonLat} lonLat1 - Longitude/Latitude of source point.
+     * @param   {LonLat} lonLat2 - Longitude/Latitude of destination point.
+     * @param   {number} fraction - Fraction between the two points (0 = source point, 1 = destination point).
+     * @returns {LonLat} Intermediate point between points.
+     */
+    getIntermediatePointOnGreatCircle(lonLat1: LonLat, lonLat2: LonLat, fraction: number): LonLat;
+    /**
+     * REMOVE ASAP after
+     * @param lonLat1
+     * @param lonLat2
+     * @returns {number}
+     */
+    static getBearing(lonLat1: LonLat, lonLat2: LonLat): number;
+    getFlattening(): number;
+    /**
+     * Gets ellipsoid equatorial size.
+     * @public
+     * @returns {number} -
+     */
+    getEquatorialSize(): number;
+    get equatorialSize(): number;
+    get equatorialSizeSqr(): number;
+    /**
+     * Gets ellipsoid polar size.
+     * @public
+     * @returns {number} -
+     */
+    getPolarSize(): number;
+    get polarSize(): number;
+    get polarSizeSqr(): number;
+    /**
+     * Calculate cartesian coordinates by its ECEF geodetic coordinates.
+     * @public
+     * @param {LonLat} lonlat - Geodetic coordinates.
+     * @returns {Vec3} -
+     */
+    lonLatToCartesian(lonlat: LonLat): Vec3;
+    /**
+     * Calculate cartesian coordinates by its ECEF geodetic coordinates.
+     * @public
+     * @param {LonLat} lonlat - Geodetic coordinates.
+     * @param {Vec3} res - Output variable reference.
+     * @returns {Vec3} -
+     */
+    lonLatToCartesianRes(lonlat: LonLat, res: Vec3): Vec3;
+    /**
+     * Gets cartesian ECEF from Wgs84 geodetic coordinates.
+     * @public
+     * @param {Number} lon - Longitude.
+     * @param {Number} lat - Latitude.
+     * @param {Number} height - Height.
+     * @param {Vec3} res - Output result variable.
+     * @returns {Vec3} -
+     */
+    geodeticToCartesian(lon: number, lat: number, height?: number, res?: Vec3): Vec3;
+    /**
+     * Gets Wgs84 geodetic coordinates from cartesian ECEF.
+     * @public
+     * @param {Vec3} p - Cartesian coordinates.
+     * @returns {LonLat} -
+     */
+    projToSurface(p: Vec3): Vec3;
+    /**
+     * Converts 3d cartesian coordinates to geodetic
+     * @param {Vec3} cart - Cartesian coordinates
+     * @returns {LonLat} - Geodetic coordinates
+     */
+    cartesianToLonLat(cart: Vec3): LonLat;
+    /**
+     * Converts 3d cartesian coordinates to geodetic
+     * @param {Vec3} cart - Cartesian coordinates
+     * @param {LonLat} res - Link geodetic coordinates variable
+     * @returns {LonLat} - Geodetic coordinates
+     */
+    cartesianToLonLatRes(cart: Vec3, res?: LonLat): LonLat;
+    /**
+     * Gets ellipsoid surface normal.
+     * @public
+     * @param {Vec3} coord - Spatial coordinates.
+     * @return {Vec3} -
+     */
+    getSurfaceNormal3v(coord: Vec3): Vec3;
+    getGreatCircleDistance(lonLat1: LonLat, lonLat2: LonLat): number;
+    /**
+     * Calculates the destination point given start point lat / lon, azimuth(deg) and distance (m).
+     * Source: http://movable-type.co.uk/scripts/latlong-vincenty-direct.html and optimized / cleaned up by Mathias Bynens <http://mathiasbynens.be/>
+     * Based on the Vincenty direct formula by T. Vincenty, “Direct and Inverse Solutions of Geodesics on the Ellipsoid with application of nested equations”, Survey Review, vol XXII no 176, 1975 <http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf>
+     * @param {LonLat} lonLat - Origin coordinates
+     * @param {number} azimuth - View azimuth in degrees
+     * @param {number} dist - Distance to the destination point coordinates in meters
+     * @returns {LonLat} - Destination point coordinates
+     */
+    getGreatCircleDestination(lonLat: LonLat, azimuth: number, dist: number): LonLat;
+    inverse(lonLat1: LonLat, lonLat2: LonLat): IInverseResult;
+    /**
+     * Calculates the destination point given start point lat / lon, azimuth(deg) and distance (m).
+     * Source: http://movable-type.co.uk/scripts/latlong-vincenty-direct.html and optimized / cleaned up by Mathias Bynens <http://mathiasbynens.be/>
+     * Based on the Vincenty direct formula by T. Vincenty, “Direct and Inverse Solutions of Geodesics on the Ellipsoid with application of nested equations”, Survey Review, vol XXII no 176, 1975 <http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf>
+     * @param {LonLat} lonLat - Origin coordinates
+     * @param {number} azimuth - View azimuth in degrees
+     * @param {number} dist - Distance to the destination point coordinates in meters
+     * @returns {LonLat} - Destination point coordinates
+     */
+    direct(lonLat: LonLat, azimuth: number, dist: number): IDirectResult;
+    /**
+     * Returns cartesian coordinates of the intersection of a ray and an ellipsoid.
+     * If the ray doesn't hit ellipsoid returns null.
+     * @public
+     * @param {Vec3} origin - Ray origin point.
+     * @param {Vec3} direction - Ray direction.
+     * @returns {Vec3} -
+     */
+    hitRay(origin: Vec3, direction: Vec3): Vec3 | undefined;
+    getNorthFrameRotation(cartesian: Vec3): Quat;
+    /**
+     * @todo this is not precise function, needs to be replaced or removed
+     * @param lonLat1
+     * @param bearing
+     * @param distance
+     * @returns {LonLat}
+     */
+    getBearingDestination(lonLat1: LonLat, bearing?: number, distance?: number): LonLat;
+    /**
+     * Returns the point at given fraction between two points on the great circle.
+     * @param   {LonLat} lonLat1 - Longitude/Latitude of source point.
+     * @param   {LonLat} lonLat2 - Longitude/Latitude of destination point.
+     * @param   {number} fraction - Fraction between the two points (0 = source point, 1 = destination point).
+     * @returns {LonLat} Intermediate point between points.
+     */
+    static getIntermediatePointOnGreatCircle(lonLat1: LonLat, lonLat2: LonLat, fraction: number): LonLat;
+    static getRhumbBearing(lonLat1: LonLat, lonLat2: LonLat): number;
+}
+export { Ellipsoid };