@openglobus/og 0.14.10 → 0.15.1

package/src/og/Object3d.js

@@ -3,6 +3,7 @@
 
 import { htmlColorToFloat32Array } from './utils/shared.js';
 import { Vec3 } from './math/Vec3.js';
+import { MIN, MAX } from './math.js';
 
 function getColor(color) {
     if (color instanceof Array) {
@@ -18,7 +19,19 @@ class Object3d {
 
         this._name = data.name || "noname";
         this._vertices = data.vertices || [];
-        this._texCoords = [];
+        this._numVertices = this._vertices.length / 3;
+        this._texCoords = data.texCoords || new Array(2 * this._numVertices);
+
+        if (data.center) {
+            Object3d.centering(this._vertices);
+        }
+
+        /**
+         * Image src.
+         * @protected
+         * @type {string}
+         */
+        this._src = data.src || null;
 
         this.color = getColor(data.color);
 
@@ -26,18 +39,45 @@ class Object3d {
             Object3d.scale(this._vertices, data.scale);
         }
 
-        if (data.indexes) {
-            this._indexes = data.indexes || [];
+        if (data.indices) {
+            this._indices = data.indices || [];
             this._normals = data.normals || [];
         } else {
             this._normals = Object3d.getNormals(this._vertices);
-            this._indexes = new Array(this._vertices.length);
-            for (let i = 0, len = this._indexes.length; i < len; i++) {
-                this._indexes[i] = i;
+            this._indices = new Array(this._vertices.length);
+            for (let i = 0, len = this._indices.length; i < len; i++) {
+                this._indices[i] = i;
             }
         }
     }
 
+    static centering(verts) {
+        let min_x = MAX, min_y = MAX, min_z = MAX, max_x = MIN, max_y = MIN, max_z = MIN;
+        for (let i = 0, len = verts.length; i < len; i += 3) {
+            let x = verts[i], y = verts[i + 1], z = verts[i + 2];
+            if (x < min_x) min_x = x;
+            if (y < min_y) min_y = y;
+            if (z < min_z) min_z = z;
+            if (x > max_x) max_x = x;
+            if (y > max_y) max_y = y;
+            if (z > max_z) max_z = z;
+        }
+
+        let c_x = min_x + (max_x - min_x) * 0.5;
+        let c_y = min_y + (max_y - min_y) * 0.5;
+        let c_z = min_z + (max_z - min_z) * 0.5;
+
+        for (let i = 0, len = verts.length; i < len; i += 3) {
+            verts[i] -= c_x;
+            verts[i + 1] -= c_y;
+            verts[i + 2] -= c_z;
+        }
+    }
+
+    get src() {
+        return this._src;
+    }
+
     get name() {
         return this._name;
     }
@@ -50,8 +90,16 @@ class Object3d {
         return this._normals;
     }
 
-    get indexes() {
-        return this._indexes;
+    get indices() {
+        return this._indices;
+    }
+
+    get texCoords() {
+        return this._texCoords;
+    }
+
+    get numVertices() {
+        return this._numVertices;
     }
 
     static scale(vertices, s) {
@@ -61,13 +109,10 @@ class Object3d {
     }
 
     static centroid(vertices) {
-        let minX = 1000.0, minY = 1000.0, minZ = 1000.0,
-            maxX = -1000.0, maxY = -1000.0, maxZ = -1000.0;
+        let minX = 1000.0, minY = 1000.0, minZ = 1000.0, maxX = -1000.0, maxY = -1000.0, maxZ = -1000.0;
 
         for (let i = 0; i < vertices.length; i += 3) {
-            let x = vertices[i],
-                y = vertices[i + 1],
-                z = vertices[i + 2];
+            let x = vertices[i], y = vertices[i + 1], z = vertices[i + 2];
             if (x < minX) minX = x;
             if (y < minY) minY = y;
             if (z < minZ) minZ = z;
@@ -76,11 +121,7 @@ class Object3d {
             if (z > maxZ) maxZ = z;
         }
 
-        return [
-            minX + (maxX - minX) * 0.5,
-            minY + (maxY - minY) * 0.5,
-            minZ + (maxZ - minZ) * 0.5
-        ];
+        return [minX + (maxX - minX) * 0.5, minY + (maxY - minY) * 0.5, minZ + (maxZ - minZ) * 0.5];
     }
 
     static translate(vertices, v) {
@@ -96,26 +137,11 @@ class Object3d {
 
         for (var i = 0; i < vertices.length; i += 9) {
 
-            let t03 = i,
-                t13 = i + 3,
-                t23 = i + 6,
-                v0_x = vertices[t03],
-                v0_y = vertices[t03 + 1],
-                v0_z = vertices[t03 + 2],
-                v1_x = vertices[t13],
-                v1_y = vertices[t13 + 1],
-                v1_z = vertices[t13 + 2],
-                v2_x = vertices[t23],
-                v2_y = vertices[t23 + 1],
-                v2_z = vertices[t23 + 2],
-                vv0_x = v1_x - v0_x,
-                vv0_y = v1_y - v0_y,
-                vv0_z = v1_z - v0_z,
-                vv1_x = v2_x - v0_x,
-                vv1_y = v2_y - v0_y,
-                vv1_z = v2_z - v0_z,
-                n_x = vv0_y * vv1_z - vv0_z * vv1_y,
-                n_y = vv0_z * vv1_x - vv0_x * vv1_z,
+            let t03 = i, t13 = i + 3, t23 = i + 6, v0_x = vertices[t03], v0_y = vertices[t03 + 1],
+                v0_z = vertices[t03 + 2], v1_x = vertices[t13], v1_y = vertices[t13 + 1], v1_z = vertices[t13 + 2],
+                v2_x = vertices[t23], v2_y = vertices[t23 + 1], v2_z = vertices[t23 + 2], vv0_x = v1_x - v0_x,
+                vv0_y = v1_y - v0_y, vv0_z = v1_z - v0_z, vv1_x = v2_x - v0_x, vv1_y = v2_y - v0_y, vv1_z = v2_z - v0_z,
+                n_x = vv0_y * vv1_z - vv0_z * vv1_y, n_y = vv0_z * vv1_x - vv0_x * vv1_z,
                 n_z = vv0_x * vv1_y - vv0_y * vv1_x;
 
             let l = Math.sqrt(n_x * n_x + n_y * n_y + n_z * n_z);
@@ -142,9 +168,7 @@ class Object3d {
 
     static createSphere(lonBands = 16, latBands = 16, radius = 1.0, offsetX = 0, offsetY = 0, offsetZ = 0) {
 
-        let vertices = [],
-            indexes = [],
-            normals = [];
+        let vertices = [], indices = [], normals = [];
 
         for (let latNumber = 0; latNumber <= latBands; latNumber++) {
             var theta = latNumber * Math.PI / latBands;
@@ -176,31 +200,26 @@ class Object3d {
                 var first = (latNumber * (lonBands + 1)) + longNumber;
                 var second = first + lonBands + 1;
 
-                indexes.push(first);
-                indexes.push(first + 1);
-                indexes.push(second);
+                indices.push(first);
+                indices.push(first + 1);
+                indices.push(second);
 
-                indexes.push(second);
-                indexes.push(first + 1);
-                indexes.push(second + 1);
+                indices.push(second);
+                indices.push(first + 1);
+                indices.push(second + 1);
             }
         }
 
         return new Object3d({
-            'vertices': vertices,
-            'normals': normals,
-            'indexes': indexes
+            'vertices': vertices, 'normals': normals, 'indices': indices
         });
     }
 
     static createDisc(radius = 1.0, height = 0.0, radialSegments = 8, isTop = true, startIndex = 0, offsetX = 0, offsetY, offsetZ = 0) {
 
-        let vertices = [],
-            indexes = [],
-            normals = [];
+        let vertices = [], indices = [], normals = [];
 
-        let thetaStart = 0.0,
-            thetaLength = Math.PI * 2;
+        let thetaStart = 0.0, thetaLength = Math.PI * 2;
 
         let sign = (isTop === true) ? 1.0 : -1.0;
 
@@ -231,30 +250,24 @@ class Object3d {
         }
 
         for (let x = 0; x < radialSegments; x++) {
-            let c = centerIndexStart + x,
-                i = centerIndexEnd + x;
+            let c = centerIndexStart + x, i = centerIndexEnd + x;
             if (isTop === true) {
-                indexes.push(i, i + 1, c);
+                indices.push(i, i + 1, c);
             } else {
-                indexes.push(i + 1, i, c);
+                indices.push(i + 1, i, c);
             }
         }
 
         return new Object3d({
-            'vertices': vertices,
-            'normals': normals,
-            'indexes': indexes
+            'vertices': vertices, 'normals': normals, 'indices': indices
         });
     }
 
     static createCylinder(radiusTop = 1.0, radiusBottom = 1.0, height = 1.0, radialSegments = 32, heightSegments = 1.0, isTop = true, isBottom = true, offsetX = 0, offsetY = 0, offsetZ = 0) {
 
-        let vertices = [],
-            indexes = [],
-            normals = [];
+        let vertices = [], indices = [], normals = [];
 
-        let thetaStart = 0.0,
-            thetaLength = Math.PI * 2;
+        let thetaStart = 0.0, thetaLength = Math.PI * 2;
 
         let index = 0;
         let indexArray = [];
@@ -277,8 +290,7 @@ class Object3d {
 
                 let theta = u * thetaLength + thetaStart;
 
-                let sinTheta = Math.sin(theta),
-                    cosTheta = Math.cos(theta);
+                let sinTheta = Math.sin(theta), cosTheta = Math.cos(theta);
 
                 vertices.push(radius * sinTheta + offsetX, -v * height + height + offsetY, radius * cosTheta + offsetZ);
 
@@ -295,13 +307,11 @@ class Object3d {
         for (let x = 0; x < radialSegments; x++) {
             for (let y = 0; y < heightSegments; y++) {
 
-                let a = indexArray[y][x],
-                    b = indexArray[y + 1][x],
-                    c = indexArray[y + 1][x + 1],
+                let a = indexArray[y][x], b = indexArray[y + 1][x], c = indexArray[y + 1][x + 1],
                     d = indexArray[y][x + 1];
 
-                indexes.push(a, b, d);
-                indexes.push(b, c, d);
+                indices.push(a, b, d);
+                indices.push(b, c, d);
             }
         }
 
@@ -309,107 +319,56 @@ class Object3d {
             let cap = Object3d.createDisc(radiusTop, height, radialSegments, true, index, offsetX, offsetY, offsetZ);
             vertices.push(...cap.vertices);
             normals.push(...cap.normals);
-            indexes.push(...cap.indexes);
+            indices.push(...cap.indices);
         }
 
         if (radiusBottom !== 0.0 && isBottom) {
             let cap = Object3d.createDisc(radiusBottom, 0, radialSegments, false, index + (isTop ? (1 + 2 * radialSegments) : 0), offsetX, offsetY, offsetZ);
             vertices.push(...cap.vertices);
             normals.push(...cap.normals);
-            indexes.push(...cap.indexes);
+            indices.push(...cap.indices);
         }
 
         return new Object3d({
-            'vertices': vertices,
-            'normals': normals,
-            'indexes': indexes
+            'vertices': vertices, 'normals': normals, 'indices': indices
         });
     }
 
     static createCube(length = 1, height = 1, depth = 1, xOffset = 0, yOffset = 0, zOffset = 0) {
-        let l = length * 0.5 + xOffset,
-            h = height * 0.5 + yOffset,
-            d = depth * 0.5 + zOffset;
+        let l = length * 0.5 + xOffset, h = height * 0.5 + yOffset, d = depth * 0.5 + zOffset;
 
         return new Object3d({
-            vertices: [
-                //bottom
-                -l, -h, d,
-                l, -h, -d,
-                l, -h, d,
-                -l, -h, d,
-                -l, -h, -d,
-                l, -h, -d,
+            vertices: [//bottom
+                -l, -h, d, l, -h, -d, l, -h, d, -l, -h, d, -l, -h, -d, l, -h, -d,
 
                 //top
-                -l, h, d,
-                l, h, d,
-                l, h, -d,
-                -l, h, d,
-                l, h, -d,
-                -l, h, -d,
+                -l, h, d, l, h, d, l, h, -d, -l, h, d, l, h, -d, -l, h, -d,
 
                 //front
-                -l, -h, d,
-                l, -h, d,
-                -l, h, d,
-                -l, h, d,
-                l, -h, d,
-                l, h, d,
+                -l, -h, d, l, -h, d, -l, h, d, -l, h, d, l, -h, d, l, h, d,
 
                 //back
-                -l, -h, -d,
-                -l, h, -d,
-                l, -h, -d,
-                -l, h, -d,
-                l, h, -d,
-                l, -h, -d,
+                -l, -h, -d, -l, h, -d, l, -h, -d, -l, h, -d, l, h, -d, l, -h, -d,
 
                 //left
-                l, -h, d,
-                l, -h, -d,
-                l, h, d,
-                l, h, d,
-                l, -h, -d,
-                l, h, -d,
+                l, -h, d, l, -h, -d, l, h, d, l, h, d, l, -h, -d, l, h, -d,
 
                 //right
-                -l, -h, d,
-                -l, h, d,
-                -l, -h, -d,
-                -l, h, d,
-                -l, h, -d,
-                -l, -h, -d
-            ]
+                -l, -h, d, -l, h, d, -l, -h, -d, -l, h, d, -l, h, -d, -l, -h, -d]
         });
     }
 
     static createArrow(back = 0.0, height = 2.1, front = -15) {
         return new Object3d({
-            vertices: [
-                0, height, 0,
-                7, 0, 6,
-                0, 0, front,
-
-                0, 0, back,
-                7, 0, 6,
-                0, height, 0,
-
-                -7, 0, 6,
-                0, 0, back,
-                0, height, 0,
-
-                -7, 0, 6,
-                0, height, 0,
-                0, 0, front,
-
-                -7, 0, 6,
-                0, 0, front,
-                0, 0, back,
-                0, 0, back,
-                0, 0, front,
-                7, 0, 6
-            ]
+            vertices: [0, height, 0, 7, 0, 6, 0, 0, front,
+
+                0, 0, back, 7, 0, 6, 0, height, 0,
+
+                -7, 0, 6, 0, 0, back, 0, height, 0,
+
+                -7, 0, 6, 0, height, 0, 0, 0, front,
+
+                -7, 0, 6, 0, 0, front, 0, 0, back, 0, 0, back, 0, 0, front, 7, 0, 6]
         });
     }
 }

package/src/og/camera/Camera.js

@@ -15,7 +15,7 @@ import { Mat4 } from "../math/Mat4.js";
  * @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.viewAngle=47] - Camera angle of view. Default is 47.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 {Vec3} [options.eye=[0,0,0]] - Camera eye position. Default (0,0,0)
@@ -77,21 +77,21 @@ class Camera {
          * @protected
          * @type {Number}
          */
-        this._viewAngle = options.viewAngle || 38.0;
+        this._viewAngle = options.viewAngle || 47.0;
 
         /**
-         * Camera normal matrix.
+         * Camera view matrix.
          * @protected
-         * @type {Mat3}
+         * @type {Mat4}
          */
-        this._normalMatrix = new Mat3();
+        this._viewMatrix = new Mat4();
 
         /**
-         * Camera view matrix.
+         * Camera normal matrix.
          * @protected
-         * @type {Mat4}
+         * @type {Mat3}
          */
-        this._viewMatrix = new Mat4();
+        this._normalMatrix = new Mat3();
 
         /**
          * Camera right vector.
@@ -119,7 +119,7 @@ class Camera {
         this._pv = this._u.clone();
         this._pn = this._b.clone();
         this._peye = this.eye.clone();
-        this.isMoved = false;
+        this.isMoving = false;
 
         this._tanViewAngle_hrad = 0.0;
         this._tanViewAngle_hradOneByHeight = 0.0;
@@ -167,7 +167,9 @@ class Camera {
 
         this.FARTHEST_FRUSTUM_INDEX = this.frustums.length - 1;
 
-        this._currentFrustum = 0;
+        this.currentFrustumIndex = 0;
+
+        this.isFirstPass = false;
 
         renderer && this._init(options);
     }
@@ -179,12 +181,12 @@ class Camera {
             eye = this.eye;
 
         if (this._peye.equal(eye) && this._pu.equal(u) && this._pv.equal(v) && this._pn.equal(n)) {
-            if (this.isMoved) {
+            if (this.isMoving) {
                 this.events.dispatch(this.events.moveend, this);
             }
-            this.isMoved = false;
+            this.isMoving = false;
         } else {
-            this.isMoved = true;
+            this.isMoving = true;
         }
 
         this._pu.copy(u);
@@ -198,7 +200,7 @@ class Camera {
      * @public
      * @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.viewAngle] - Camera angle of view.
      * @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 {Vec3} [options.eye] - Camera eye position. Default (0,0,0)
@@ -271,7 +273,8 @@ class Camera {
             1.0
         ]);
 
-        this._normalMatrix = this._viewMatrix.toMatrix3(); // this._viewMatrix.toInverseMatrix3().transposeTo();
+        // do not cleanup, someday it will be using
+        //this._normalMatrix = this._viewMatrix.toMatrix3(); // this._viewMatrix.toInverseMatrix3().transposeTo();
 
         for (let i = 0, len = this.frustums.length; i < len; i++) {
             this.frustums[i].setViewMatrix(this._viewMatrix);
@@ -321,7 +324,7 @@ class Camera {
         this._tanViewAngle_hradOneByHeight =
             this._tanViewAngle_hrad * this.renderer.handler._oneByHeight;
         var c = this.renderer.handler.canvas;
-        this._projSizeConst = Math.min(c.clientWidth < 256 ? 256 : c.clientWidth, c.clientHeight < 256 ? 256 : c.clientHeight) / (angle * math.RADIANS);
+        this._projSizeConst = Math.min(c.clientWidth < 512 ? 512 : c.clientWidth, c.clientHeight < 512 ? 512 : c.clientHeight) / (angle * math.RADIANS);
         for (let i = 0, len = this.frustums.length; i < len; i++) {
             this.frustums[i].setProjectionMatrix(
                 angle,
@@ -557,33 +560,34 @@ class Camera {
     }
 
     /**
-     * Returns normal matrix.
+     * Returns model matrix.
      * @public
-     * @returns {Mat3} - Normal matrix.
+     * @returns {Mat4} - View matrix.
      */
-    getNormalMatrix() {
-        return this._normalMatrix._m;
+    getViewMatrix() {
+        return this._viewMatrix._m;
     }
 
     /**
-     * Returns model matrix.
+     * Returns normal matrix.
      * @public
-     * @returns {Mat4} - View matrix.
+     * @returns {Mat3} - Normal matrix.
      */
-    getViewMatrix() {
-        return this._viewMatrix._m;
+    getNormalMatrix() {
+        return this._normalMatrix._m;
     }
 
     setCurrentFrustum(k) {
-        this._currentFrustum = k;
+        this.currentFrustumIndex = k;
+        this.isFirstPass = k === this.FARTHEST_FRUSTUM_INDEX;
     }
 
     getCurrentFrustum() {
-        return this._currentFrustum;
+        return this.currentFrustumIndex;
     }
 
     get frustum() {
-        return this.frustums[this._currentFrustum];
+        return this.frustums[this.currentFrustumIndex];
     }
 
     /**

package/src/og/camera/PlanetCamera.js

@@ -21,7 +21,7 @@ import { Mat4 } from "../math/Mat4.js";
  * @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
+ * @param {number} [options.viewAngle] - Camera angle of view.
  * @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 {number} [options.minAltitude] - Minimal altitude for the camera. Deafult is 5
@@ -37,14 +37,14 @@ class PlanetCamera extends Camera {
      */
     constructor(planet, options) {
         super(planet.renderer, {
-            frustums: [
-                [1, 100 + 0.075],
-                [100, 1000 + 0.075],
-                [1000, 1e6 + 10000],
-                [1e6, 1e9]
-            ], //[[1, 1e3 + 100], [1e3, 1e6 + 10000], [1e6, 1e9]]*/
-            ...options
-        }
+                frustums: [
+                    [1, 100 + 0.075],
+                    [100, 1000 + 0.075],
+                    [1000, 1e6 + 10000],
+                    [1e6, 1e9]
+                ], //[[1, 1e3 + 100], [1e3, 1e6 + 10000], [1e6, 1e9]]*/
+                ...options
+            }
         );
         /**
          * Assigned camera's planet.
@@ -120,6 +120,11 @@ class PlanetCamera extends Camera {
         this._numFrames = 50;
         this._completeCallback = null;
         this._flying = false;
+        this._checkTerrainCollision = true;
+    }
+
+    setTerrainCollisionActivity(isActive) {
+        this._checkTerrainCollision = isActive;
     }
 
     /**
@@ -363,7 +368,10 @@ class PlanetCamera extends Camera {
      * @param {cameraCallback} [startCallback] - Callback that calls befor the flying begins.
      * @param [frameCallback]
      */
-    flyCartesian(cartesian, look = Vec3.ZERO, up = Vec3.UP, ampl = 1.0, completeCallback = () => { }, startCallback = () => { }, frameCallback = () => { }) {
+    flyCartesian(cartesian, look = Vec3.ZERO, up = Vec3.UP, ampl = 1.0, completeCallback = () => {
+    }, startCallback = () => {
+    }, frameCallback = () => {
+    }) {
 
         this.stopFlying();
 
@@ -620,7 +628,7 @@ class PlanetCamera extends Camera {
                 this._insideSegmentPosition,
                 this._terrainPoint
             );
-            if (this._terrainAltitude < this.minAltitude) {
+            if (this._terrainAltitude < this.minAltitude && this._checkTerrainCollision) {
                 this.setAltitude(this.minAltitude);
             }
         }
@@ -634,9 +642,9 @@ 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) {