@openglobus/og 0.11.8 → 0.12.0

package/css/og.css

@@ -261,6 +261,8 @@
     text-shadow: 0px 0px 3px #616161;
     padding: 10px;
     pointer-events: none;
+    transform: scale(1.0);
+    transform-origin: top left;
 }
 
     .og-debug-info .og-watch-line {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openglobus/og",
-  "version": "0.11.8",
+  "version": "0.12.0",
   "description": "[OpenGlobus](http://www.openglobus.org/) is a javascript library designed to display interactive 3d maps and planets with map tiles, imagery and vector data, markers and 3d objects. It uses the WebGL technology, open source and completely free.",
   "directories": {
     "example": "./sandbox"

package/src/og/Globe.js

@@ -66,6 +66,7 @@ const PLANET_NAME_PREFIX = "globus_planet_";
  * @param {Number} [options.maxEqualZoomAltitude=15000000.0] - Maximal altitude since segments on the screen bacame the same zoom level
  * @param {Number} [options.minEqualZoomAltitude=10000.0] - Minimal altitude since segments on the screen bacame the same zoom level
  * @param {Number} [options.minEqualZoomCameraSlope=0.8] - Minimal camera slope above te globe where segments on the screen bacame the same zoom level
+ * @param {Number} [options.loadingBatchSize=12] - 
  */
 
 class Globe {
@@ -97,7 +98,16 @@ class Globe {
         }
 
         this.div.appendChild(this._canvas);
-        this.div.classList.add("ogViewport");
+        this.div.classList.add("ogViewport");
+
+        document.addEventListener("visibilitychange", () => {
+            if (document.visibilityState === 'visible') {
+                this.renderer.handler.start();
+                this.renderer && this.renderer.resize();
+            } else {
+                this.renderer.handler.stop();
+            }
+        });
 
         function _disableWheel(e) {
             e.preventDefault();
@@ -120,7 +130,7 @@ class Globe {
          */
         this.renderer = new Renderer(
             new Handler(_canvasId, {
-                pixelRatio: window.devicePixelRatio,
+                pixelRatio: window.devicePixelRatio + 0.15,
                 context: {
                     alpha: false,
                     antialias: false,
@@ -162,7 +172,8 @@ class Globe {
             // TODO:
         } else {
             this.planet = new Planet({
-                name: this._planetName,
+                name: this._planetName,
+                frustums: options.frustums,
                 ellipsoid: options.ellipsoid,
                 maxGridSize: options.maxGridSize,
                 useNightTexture: options.useNightTexture,
@@ -171,7 +182,8 @@ class Globe {
                 maxAltitude: options.maxAltitude || 15000000,
                 maxEqualZoomAltitude: options.maxEqualZoomAltitude,
                 minEqualZoomAltitude: options.minEqualZoomAltitude,
-                minEqualZoomCameraSlope: options.minEqualZoomCameraSlope
+                minEqualZoomCameraSlope: options.minEqualZoomCameraSlope,
+                loadingBatchSize: options.loadingBatchSize
             });
         }
 
@@ -193,8 +205,8 @@ class Globe {
                 options.useEarthNavigation
                     ? new EarthNavigation()
                     : new MouseNavigation({
-                          minSlope: options.minSlope
-                      }),
+                        minSlope: options.minSlope
+                    }),
                 new TouchNavigation(),
                 new EarthCoordinates(),
                 new ScaleControl(),

package/src/og/camera/Camera.js

@@ -98,26 +98,26 @@ class Camera {
          * @protected
          * @type {Vec3}
          */
-        this._u = new Vec3(0.0, 1.0, 0.0); // up x n
+        this._r = new Vec3(1.0, 0.0, 0.0); // up x n
 
         /**
          * Camera up vector.
          * @protected
          * @type {Vec3}
          */
-        this._v = new Vec3(1.0, 0.0, 0.0); // n x u - UP
+        this._u = new Vec3(0.0, 1.0, 0.0); // n x u - UP
 
         /**
          * Camera forward vector.
          * @protected
          * @type {Vec3}
          */
-        this._n = new Vec3(0.0, 0.0, 1.0); // eye - look - FORWARD
+        this._b = new Vec3(0.0, 0.0, 1.0); // eye - look - FORWARD
 
         // Previous frame values
-        this._pu = this._u.clone();
-        this._pv = this._v.clone();
-        this._pn = this._n.clone();
+        this._pu = this._r.clone();
+        this._pv = this._u.clone();
+        this._pn = this._b.clone();
         this._peye = this.eye.clone();
         this.isMoved = false;
 
@@ -173,9 +173,9 @@ class Camera {
     }
 
     checkMoveEnd() {
-        var u = this._u,
-            v = this._v,
-            n = this._n,
+        var u = this._r,
+            v = this._u,
+            n = this._b,
             eye = this.eye;
 
         if (this._peye.equal(eye) && this._pu.equal(u) && this._pv.equal(v) && this._pn.equal(n)) {
@@ -216,27 +216,27 @@ class Camera {
     }
 
     getUp() {
-        return this._v.clone();
+        return this._u.clone();
     }
 
     getDown() {
-        return this._v.negateTo();
+        return this._u.negateTo();
     }
 
     getRight() {
-        return this._u.clone();
+        return this._r.clone();
     }
 
     getLeft() {
-        return this._u.negateTo();
+        return this._r.negateTo();
     }
 
     getForward() {
-        return this._n.negateTo();
+        return this._b.negateTo();
     }
 
     getBackward() {
-        return this._n.clone();
+        return this._b.clone();
     }
 
     /**
@@ -245,9 +245,9 @@ class Camera {
      * @virtual
      */
     update() {
-        var u = this._u,
-            v = this._v,
-            n = this._n,
+        var u = this._r,
+            v = this._u,
+            n = this._b,
             eye = this.eye;
 
         Vec3.doubleToTwoFloat32Array(eye, this.eyeHigh, this.eyeLow);
@@ -321,12 +321,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 < 256 ? 256 : c.clientWidth, c.clientHeight < 256 ? 256 : c.clientHeight) / (angle * math.RADIANS);
         for (let i = 0, len = this.frustums.length; i < len; i++) {
             this.frustums[i].setProjectionMatrix(
                 angle,
@@ -368,15 +363,15 @@ class Camera {
         this.eye.x = eye.x;
         this.eye.y = eye.y;
         this.eye.z = eye.z;
-        look = look || this._n;
-        up = up || this._v;
-        this._n.x = eye.x - look.x;
-        this._n.y = eye.y - look.y;
-        this._n.z = eye.z - look.z;
-        this._u.copy(up.cross(this._n));
-        this._n.normalize();
-        this._u.normalize();
-        this._v.copy(this._n.cross(this._u));
+        look = look || this._b;
+        up = up || this._u;
+        this._b.x = eye.x - look.x;
+        this._b.y = eye.y - look.y;
+        this._b.z = eye.z - look.z;
+        this._r.copy(up.cross(this._b));
+        this._b.normalize();
+        this._r.normalize();
+        this._u.copy(this._b.cross(this._r));
         return this;
     }
 
@@ -384,14 +379,14 @@ class Camera {
      * Sets camera look point
      * @public
      * @param {Vec3} look - Look point
-     * @param {Vec3} [up] - Camera up vector otherwise camera current up vector(this._v)
+     * @param {Vec3} [up] - Camera up vector otherwise camera current up vector(this._u)
      */
     look(look, up) {
-        this._n.set(this.eye.x - look.x, this.eye.y - look.y, this.eye.z - look.z);
-        this._u.copy((up || this._v).cross(this._n));
-        this._n.normalize();
-        this._u.normalize();
-        this._v.copy(this._n.cross(this._u));
+        this._b.set(this.eye.x - look.x, this.eye.y - look.y, this.eye.z - look.z);
+        this._r.copy((up || this._u).cross(this._b));
+        this._b.normalize();
+        this._r.normalize();
+        this._u.copy(this._b.cross(this._r));
     }
 
     /**
@@ -402,9 +397,9 @@ class Camera {
      * @param {number} dn - delta Z
      */
     slide(du, dv, dn) {
-        this.eye.x += du * this._u.x + dv * this._v.x + dn * this._n.x;
-        this.eye.y += du * this._u.y + dv * this._v.y + dn * this._n.y;
-        this.eye.z += du * this._u.z + dv * this._v.z + dn * this._n.z;
+        this.eye.x += du * this._r.x + dv * this._u.x + dn * this._b.x;
+        this.eye.y += du * this._r.y + dv * this._u.y + dn * this._b.y;
+        this.eye.z += du * this._r.z + dv * this._u.z + dn * this._b.z;
     }
 
     /**
@@ -415,16 +410,16 @@ class Camera {
     roll(angle) {
         var cs = Math.cos(math.RADIANS * angle);
         var sn = Math.sin(math.RADIANS * angle);
-        var t = this._u.clone();
-        this._u.set(
-            cs * t.x - sn * this._v.x,
-            cs * t.y - sn * this._v.y,
-            cs * t.z - sn * this._v.z
+        var t = this._r.clone();
+        this._r.set(
+            cs * t.x - sn * this._u.x,
+            cs * t.y - sn * this._u.y,
+            cs * t.z - sn * this._u.z
         );
-        this._v.set(
-            sn * t.x + cs * this._v.x,
-            sn * t.y + cs * this._v.y,
-            sn * t.z + cs * this._v.z
+        this._u.set(
+            sn * t.x + cs * this._u.x,
+            sn * t.y + cs * this._u.y,
+            sn * t.z + cs * this._u.z
         );
     }
 
@@ -436,16 +431,16 @@ class Camera {
     pitch(angle) {
         var cs = Math.cos(math.RADIANS * angle);
         var sn = Math.sin(math.RADIANS * angle);
-        var t = this._n.clone();
-        this._n.set(
-            cs * t.x - sn * this._v.x,
-            cs * t.y - sn * this._v.y,
-            cs * t.z - sn * this._v.z
+        var t = this._b.clone();
+        this._b.set(
+            cs * t.x - sn * this._u.x,
+            cs * t.y - sn * this._u.y,
+            cs * t.z - sn * this._u.z
         );
-        this._v.set(
-            sn * t.x + cs * this._v.x,
-            sn * t.y + cs * this._v.y,
-            sn * t.z + cs * this._v.z
+        this._u.set(
+            sn * t.x + cs * this._u.x,
+            sn * t.y + cs * this._u.y,
+            sn * t.z + cs * this._u.z
         );
     }
 
@@ -457,16 +452,16 @@ class Camera {
     yaw(angle) {
         var cs = Math.cos(math.RADIANS * angle);
         var sn = Math.sin(math.RADIANS * angle);
-        var t = this._u.clone();
-        this._u.set(
-            cs * t.x - sn * this._n.x,
-            cs * t.y - sn * this._n.y,
-            cs * t.z - sn * this._n.z
+        var t = this._r.clone();
+        this._r.set(
+            cs * t.x - sn * this._b.x,
+            cs * t.y - sn * this._b.y,
+            cs * t.z - sn * this._b.z
         );
-        this._n.set(
-            sn * t.x + cs * this._n.x,
-            sn * t.y + cs * this._n.y,
-            sn * t.z + cs * this._n.z
+        this._b.set(
+            sn * t.x + cs * this._b.x,
+            sn * t.y + cs * this._b.y,
+            sn * t.z + cs * this._b.z
         );
     }
 
@@ -485,12 +480,8 @@ class Camera {
         var px = (x - w) / w,
             py = -(y - h) / h;
 
-        var world1 = this.frustums[0]._inverseProjectionViewMatrix
-                .mulVec4(new Vec4(px, py, -1.0, 1.0))
-                .affinity(),
-            world2 = this.frustums[0]._inverseProjectionViewMatrix
-                .mulVec4(new Vec4(px, py, 0.0, 1.0))
-                .affinity();
+        var world1 = this.frustums[0]._inverseProjectionViewMatrix.mulVec4(new Vec4(px, py, -1.0, 1.0)).affinity(),
+            world2 = this.frustums[0]._inverseProjectionViewMatrix.mulVec4(new Vec4(px, py, 0.0, 1.0)).affinity();
 
         return world2.subA(world1).toVec3().normalize();
     }
@@ -520,16 +511,16 @@ class Camera {
         center = center || Vec3.ZERO;
         up = up || Vec3.UP;
 
-        var rot = new Mat4().setRotation(isArc ? this._v : up, angle);
+        var rot = new Mat4().setRotation(isArc ? this._u : up, angle);
         var tr = new Mat4().setIdentity().translate(center);
         var ntr = new Mat4().setIdentity().translate(center.negateTo());
 
         var trm = tr.mul(rot).mul(ntr);
 
         this.eye = trm.mulVec3(this.eye);
-        this._v = rot.mulVec3(this._v).normalize();
         this._u = rot.mulVec3(this._u).normalize();
-        this._n = rot.mulVec3(this._n).normalize();
+        this._r = rot.mulVec3(this._r).normalize();
+        this._b = rot.mulVec3(this._b).normalize();
     }
 
     /**
@@ -551,7 +542,7 @@ class Camera {
      * @param {Vec3} center - Point that the camera rotates around.
      */
     rotateVertical(angle, center) {
-        this.rotateAround(angle, false, center, this._u);
+        this.rotateAround(angle, false, center, this._r);
     }
 
     /**

package/src/og/camera/PlanetCamera.js

@@ -36,20 +36,15 @@ class PlanetCamera extends Camera {
      * @param {Object} [options] - Planet camera options:
      */
     constructor(planet, options) {
-        super(
-            planet.renderer,
-            Object.assign(
-                {},
-                {
-                    frustums: /*[[100, 10000000]]*/[
-                        [1, 100 + 0.075],
-                        [100, 1000 + 0.075],
-                        [1000, 1e6 + 10000],
-                        [1e6, 1e9]
-                    ] //[[1, 1e3 + 100], [1e3, 1e6 + 10000], [1e6, 1e9]]*/
-                },
-                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
+        }
         );
         /**
          * Assigned camera's planet.
@@ -144,7 +139,7 @@ class PlanetCamera extends Camera {
         super.update();
         this.updateGeodeticPosition();
         this.eyeNorm = this.eye.normal();
-        this.slope = this._n.dot(this.eyeNorm);
+        this.slope = this._b.dot(this.eyeNorm);
         this.events.dispatch(this.events.viewchange, this);
     }
 
@@ -387,8 +382,8 @@ class PlanetCamera extends Camera {
         var ground_a = this.planet.ellipsoid.lonLatToCartesian(
             new LonLat(this._lonLat.lon, this._lonLat.lat)
         );
-        var v_a = this._v,
-            n_a = this._n;
+        var v_a = this._u,
+            n_a = this._b;
 
         var lonlat_b = this.planet.ellipsoid.cartesianToLonLat(cartesian);
         var up_b = up || Vec3.UP;
@@ -543,18 +538,18 @@ class PlanetCamera extends Camera {
     }
 
     rotateVertical(angle, center, minSlope = 0) {
-        var rot = new Mat4().setRotation(this._u, angle);
+        var rot = new Mat4().setRotation(this._r, angle);
         var tr = new Mat4().setIdentity().translate(center);
         var ntr = new Mat4().setIdentity().translate(center.negateTo());
         var trm = tr.mul(rot).mul(ntr);
 
         let eye = trm.mulVec3(this.eye);
-        let v = rot.mulVec3(this._v).normalize();
         let u = rot.mulVec3(this._u).normalize();
-        let n = rot.mulVec3(this._n).normalize();
+        let r = rot.mulVec3(this._r).normalize();
+        let b = rot.mulVec3(this._b).normalize();
 
         let eyeNorm = eye.normal();
-        let slope = n.dot(eyeNorm);
+        let slope = b.dot(eyeNorm);
 
         if (minSlope) {
             let dSlope = slope - this.slope;
@@ -562,20 +557,20 @@ class PlanetCamera extends Camera {
             if (slope < minSlope && dSlope < 0) return;
 
             if (
-                (slope > 0.1 && v.dot(eyeNorm) > 0) ||
+                (slope > 0.1 && u.dot(eyeNorm) > 0) ||
                 this.slope <= 0.1 ||
-                this._v.dot(this.eye.normal()) <= 0.0
+                this._u.dot(this.eye.normal()) <= 0.0
             ) {
                 this.eye = eye;
-                this._v = v;
                 this._u = u;
-                this._n = n;
+                this._r = r;
+                this._b = b;
             }
         } else {
             this.eye = eye;
-            this._v = v;
             this._u = u;
-            this._n = n;
+            this._r = r;
+            this._b = b;
         }
     }
 
@@ -592,9 +587,9 @@ class PlanetCamera extends Camera {
             this.planet._normalMapCreator.lock(this._keyLock);
 
             this.eye = this._framesArr[c].eye;
-            this._u = this._framesArr[c].u;
-            this._v = this._framesArr[c].v;
-            this._n = this._framesArr[c].n;
+            this._r = this._framesArr[c].u;
+            this._u = this._framesArr[c].v;
+            this._b = this._framesArr[c].n;
 
             if (this._frameCallback) {
                 this._frameCallback();

package/src/og/control/DebugInfo.js

@@ -93,8 +93,8 @@ class DebugInfo extends Control {
                     frame: () => p.camera.slope.toFixed(3)
                 },
                 {
-                    label: "lodRatio",
-                    frame: () => p._lodRatio.toFixed(3)
+                    label: "lodSize",
+                    frame: () => Math.round(p.lodSize)
                 },
                 {
                     label: "deltaTime/FPS",

package/src/og/control/EarthNavigation.js

@@ -6,6 +6,7 @@ import { Quat } from "../math/Quat.js";
 import { Ray } from "../math/Ray.js";
 import { Vec3 } from "../math/Vec3.js";
 import { Control } from "./Control.js";
+import { Mat4 } from "../math/Mat4.js";
 
 class Touch {
     constructor() {
@@ -29,6 +30,7 @@ class EarthNavigation extends Control {
         super(options);
 
         this.grabbedPoint = new Vec3();
+        this.grabbedDir = new Vec3();
         this.inertia = 0.007;
         this.grabbedSpheroid = new Sphere();
         this.planet = null;
@@ -39,11 +41,11 @@ class EarthNavigation extends Control {
         this.currState = 0;
 
         this.positionState = [
-            { h: 17119745.303455353, max: 0.99, min: -0.99 },
-            { h: 6866011, max: 0.99, min: -0.99 },
-            { h: 3000000, max: 0.99, min: -0.99 },
-            { h: 1000000, max: 0.99, min: -0.99 },
-            { h: 500000, max: 0.99, min: -0.99 }
+            { h: 17119745.303455353, max: 0.98, min: -0.98 },
+            { h: 6866011, max: 0.98, min: -0.98 },
+            { h: 3000000, max: 0.98, min: -0.98 },
+            { h: 1000000, max: 0.98, min: -0.98 },
+            { h: 500000, max: 0.98, min: -0.98 }
         ];
 
         this.touches = [new Touch(), new Touch()];
@@ -163,9 +165,10 @@ class EarthNavigation extends Control {
         }
     }
 
-    onMouseLeftButtonClick() {
+    onMouseLeftButtonClick(e) {
         this.renderer.handler.gl.canvas.classList.add("ogGrabbingPoiner");
         this.grabbedPoint = this.planet.getCartesianFromMouseTerrain(true);
+        this.grabbedDir.copy(e.direction);
         if (this.grabbedPoint) {
             this.grabbedSpheroid.radius = this.grabbedPoint.length();
             this.stopRotation();
@@ -195,24 +198,30 @@ class EarthNavigation extends Control {
             var targetPoint = new Ray(cam.eye, e.direction).hitSphere(this.grabbedSpheroid);
 
             if (targetPoint) {
-                this._a =
-                    Math.acos(this.grabbedPoint.y / this.grabbedSpheroid.radius) -
+
+                this._a = Math.acos(this.grabbedPoint.y / this.grabbedSpheroid.radius) -
                     Math.acos(targetPoint.y / this.grabbedSpheroid.radius);
 
-                this._vRot = Quat.axisAngleToQuat(cam._u, this._a);
+                let rot = this._vRot = Quat.axisAngleToQuat(cam._u, this._a);
+
+                cam.set(rot.mulVec3(cam.eye), Vec3.ZERO, rot.mulVec3(cam.getUp()));
+                //cam.update();
+
                 this._hRot = Quat.getRotationBetweenVectors(
                     new Vec3(targetPoint.x, 0.0, targetPoint.z).normal(),
                     new Vec3(this.grabbedPoint.x, 0.0, this.grabbedPoint.z).normal()
                 );
-                var rot = this._hRot.mul(this._vRot);
 
-                var state = this.positionState[this.currState];
-                var lim = rot.mulVec3(cam.eye).normal().dot(Vec3.UP);
-                if (lim > state.max || lim < state.min) {
-                    rot = Quat.yRotation(rot.getYaw());
-                }
-                cam.set(rot.mulVec3(cam.eye), Vec3.ZERO, Vec3.UP);
-                cam.update();
+                rot = this._hRot;
+
+                //var state = this.positionState[this.currState];
+                //var lim = cam.eye.normal().dot(Vec3.UP);
+
+                //if (lim > state.max || lim < state.min) {
+                //    rot = Quat.yRotation(rot.getYaw());
+                    cam.set(rot.mulVec3(cam.eye), Vec3.ZERO, rot.mulVec3(cam.getUp()));
+                    cam.update();
+                //}
             }
         } else {
             this.scaleRot = 0;

package/src/og/control/MouseNavigation.js

@@ -57,9 +57,9 @@ class MouseNavigation extends Control {
         var steps = [];
 
         var eye = cam.eye.clone(),
-            n = cam._n.clone(),
-            u = cam._u.clone(),
-            v = cam._v.clone();
+            n = cam._b.clone(),
+            u = cam._r.clone(),
+            v = cam._u.clone();
 
         var a = planet.getCartesianFromPixelTerrain(point, true);
 
@@ -265,7 +265,6 @@ class MouseNavigation extends Control {
             this.renderer.handler.canvas.classList.add("ogGrabbingPoiner");
             this.grabbedPoint = this.planet.getCartesianFromMouseTerrain();
             if (this.grabbedPoint) {
-                this.renderer.isActiveBackBuffers = false;
                 this._eye0.copy(this.renderer.activeCamera.eye);
                 this.grabbedSpheroid.radius = this.grabbedPoint.length();
                 this.stopRotation();
@@ -281,7 +280,6 @@ class MouseNavigation extends Control {
     }
 
     onMouseLeftButtonUp(e) {
-        this.renderer.isActiveBackBuffers = true;
         this.renderer.handler.canvas.classList.remove("ogGrabbingPoiner");
         if (e.x === e.prev_x && e.y === e.prev_y) {
             this.scaleRot = 0.0;
@@ -309,9 +307,9 @@ class MouseNavigation extends Control {
                         );
                         var rot = this.qRot;
                         cam.eye = rot.mulVec3(cam.eye);
-                        cam._v = rot.mulVec3(cam._v);
                         cam._u = rot.mulVec3(cam._u);
-                        cam._n = rot.mulVec3(cam._n);
+                        cam._r = rot.mulVec3(cam._r);
+                        cam._b = rot.mulVec3(cam._b);
 
                         cam.checkTerrainCollision();
 
@@ -319,7 +317,7 @@ class MouseNavigation extends Control {
                     }
                 } else {
                     var p0 = this.grabbedPoint,
-                        p1 = Vec3.add(p0, cam._u),
+                        p1 = Vec3.add(p0, cam._r),
                         p2 = Vec3.add(p0, p0.normal());
 
                     var px = new Vec3();
@@ -395,9 +393,9 @@ class MouseNavigation extends Control {
                 }
 
                 cam.eye = sf.eye;
-                cam._v = sf.v;
-                cam._u = sf.u;
-                cam._n = sf.n;
+                cam._u = sf.v;
+                cam._r = sf.u;
+                cam._b = sf.n;
 
                 cam.checkTerrainCollision();
 
@@ -428,9 +426,9 @@ class MouseNavigation extends Control {
                     this.scaleRot = 0.0;
                 }
                 cam.eye = rot.mulVec3(cam.eye);
-                cam._v = rot.mulVec3(cam._v);
                 cam._u = rot.mulVec3(cam._u);
-                cam._n = rot.mulVec3(cam._n);
+                cam._r = rot.mulVec3(cam._r);
+                cam._b = rot.mulVec3(cam._b);
 
                 cam.checkTerrainCollision();
 

package/src/og/control/MouseWheelZoomControl.js

@@ -195,9 +195,9 @@ class MouseWheelZoomControl extends Control {
                 }
 
                 cam.eye = sf.eye;
-                cam._v = sf.v;
-                cam._u = sf.u;
-                cam._n = sf.n;
+                cam._u = sf.v;
+                cam._r = sf.u;
+                cam._b = sf.n;
 
                 cam.checkTerrainCollision();
 
@@ -228,9 +228,9 @@ class MouseWheelZoomControl extends Control {
                     this.scaleRot = 0.0;
                 }
                 cam.eye = rot.mulVec3(cam.eye);
-                cam._v = rot.mulVec3(cam._v);
                 cam._u = rot.mulVec3(cam._u);
-                cam._n = rot.mulVec3(cam._n);
+                cam._r = rot.mulVec3(cam._r);
+                cam._b = rot.mulVec3(cam._b);
 
                 cam.checkTerrainCollision();