Orthographic projection in 3D and Columbus view

Apps/Sandcastle/gallery/development/Shadows.html

@@ -525,7 +525,7 @@
     var frustumSize = 55.0;
     var frustumNear = 1.0;
     var frustumFar = 400.0;
-    var frustum = new Cesium.OrthographicFrustum();
+    var frustum = new Cesium.OrthographicOffCenterFrustum();
     frustum.left = -frustumSize;
     frustum.right = frustumSize;
     frustum.bottom = -frustumSize;

Source/Renderer/AutomaticUniforms.js

@@ -530,17 +530,6 @@ define([
             }
         }),
 
-        /**
-         * @private
-         */
-        czm_inverseProjectionOIT : new AutomaticUniform({
-            size : 1,
-            datatype : WebGLConstants.FLOAT_MAT4,
-            getValue : function(uniformState) {
-                return uniformState.inverseProjectionOIT;
-            }
-        }),
-
         /**
          * An automatic GLSL uniform representing a 4x4 projection transformation matrix with the far plane at infinity,
          * that transforms eye coordinates to clip coordinates.  Clip coordinates is the

Source/Renderer/UniformState.js

@@ -13,6 +13,7 @@ define([
         '../Core/Matrix4',
         '../Core/Simon1994PlanetaryPositions',
         '../Core/Transforms',
+        '../Scene/OrthographicFrustum',
         '../Scene/SceneMode'
     ], function(
         BoundingRectangle,
@@ -28,6 +29,7 @@ define([
         Matrix4,
         Simon1994PlanetaryPositions,
         Transforms,
+        OrthographicFrustum,
         SceneMode) {
     'use strict';
 
@@ -80,9 +82,6 @@ define([
         this._inverseProjectionDirty = true;
         this._inverseProjection = new Matrix4();
 
-        this._inverseProjectionOITDirty = true;
-        this._inverseProjectionOIT = new Matrix4();
-
         this._modelViewDirty = true;
         this._modelView = new Matrix4();
 
@@ -147,6 +146,7 @@ define([
         this._frustum2DWidth = 0.0;
         this._eyeHeight2D = new Cartesian2();
         this._resolutionScale = 1.0;
+        this._orthographicIn3D = false;
 
         this._fogDensity = undefined;
 
@@ -393,17 +393,6 @@ define([
             }
         },
 
-        /**
-         * @memberof UniformState.prototype
-         * @private
-         */
-        inverseProjectionOIT : {
-            get : function() {
-                cleanInverseProjectionOIT(this);
-                return this._inverseProjectionOIT;
-            }
-        },
-
         /**
          * @memberof UniformState.prototype
          * @type {Matrix4}
@@ -834,7 +823,6 @@ define([
         Matrix4.clone(matrix, uniformState._projection);
 
         uniformState._inverseProjectionDirty = true;
-        uniformState._inverseProjectionOITDirty = true;
         uniformState._viewProjectionDirty = true;
         uniformState._inverseViewProjectionDirty = true;
         uniformState._modelViewProjectionDirty = true;
@@ -896,6 +884,8 @@ define([
         this._entireFrustum.x = camera.frustum.near;
         this._entireFrustum.y = camera.frustum.far;
         this.updateFrustum(camera.frustum);
+
+        this._orthographicIn3D = this._mode !== SceneMode.SCENE2D && camera.frustum instanceof OrthographicFrustum;
     };
 
     /**
@@ -987,18 +977,10 @@ define([
         if (uniformState._inverseProjectionDirty) {
             uniformState._inverseProjectionDirty = false;
 
-            Matrix4.inverse(uniformState._projection, uniformState._inverseProjection);
-        }
-    }
-
-    function cleanInverseProjectionOIT(uniformState) {
-        if (uniformState._inverseProjectionOITDirty) {
-            uniformState._inverseProjectionOITDirty = false;
-
-            if (uniformState._mode !== SceneMode.SCENE2D && uniformState._mode !== SceneMode.MORPHING) {
-                Matrix4.inverse(uniformState._projection, uniformState._inverseProjectionOIT);
+            if (uniformState._mode !== SceneMode.SCENE2D && uniformState._mode !== SceneMode.MORPHING && !uniformState._orthographicIn3D) {
+                Matrix4.inverse(uniformState._projection, uniformState._inverseProjection);
             } else {
-                Matrix4.clone(Matrix4.IDENTITY, uniformState._inverseProjectionOIT);
+                Matrix4.clone(Matrix4.ZERO, uniformState._inverseProjection);
             }
         }
     }

Source/Scene/Camera.js

@@ -26,6 +26,8 @@ define([
         '../Core/Transforms',
         './CameraFlightPath',
         './MapMode2D',
+        './OrthographicFrustum',
+        './OrthographicOffCenterFrustum',
         './PerspectiveFrustum',
         './SceneMode'
     ], function(
@@ -55,6 +57,8 @@ define([
         Transforms,
         CameraFlightPath,
         MapMode2D,
+        OrthographicFrustum,
+        OrthographicOffCenterFrustum,
         PerspectiveFrustum,
         SceneMode) {
     'use strict';
@@ -898,6 +902,13 @@ define([
         if (!defined(mode)) {
             throw new DeveloperError('mode is required.');
         }
+        if (mode === SceneMode.SCENE2D && !(this.frustum instanceof OrthographicOffCenterFrustum)) {
+            throw new DeveloperError('An OrthographicOffCenterFrustum is required in 2D.');
+        }
+        if ((mode === SceneMode.SCENE3D || mode === SceneMode.COLUMBUS_VIEW) &&
+            (!(this.frustum instanceof PerspectiveFrustum) && !(this.frustum instanceof OrthographicFrustum))) {
+            throw new DeveloperError('A PerspectiveFrustum or OrthographicFrustum is required in 3D and Columbus view');
+        }
         //>>includeEnd('debug');
 
         var updateFrustum = false;
@@ -958,6 +969,42 @@ define([
         updateMembers(this);
     };
 
+    var scratchAdjustOrtghographicFrustumMousePosition = new Cartesian2();
+    var pickGlobeScratchRay = new Ray();
+    var scratchRayIntersection = new Cartesian3();
+
+    Camera.prototype._adjustOrthographicFrustum = function() {
+        if (!(this.frustum instanceof OrthographicFrustum)) {
+            return;
+        }
+
+        if (!Matrix4.equals(Matrix4.IDENTITY, this.transform)) {
+            this.frustum.width = Cartesian3.magnitude(this.position);
+            return;
+        }
+
+        var scene = this._scene;
+        var globe = scene._globe;
+        var rayIntersection;
+
+        if (defined(globe)) {
+            var mousePosition = scratchAdjustOrtghographicFrustumMousePosition;
+            mousePosition.x = scene.drawingBufferWidth / 2.0;
+            mousePosition.y = scene.drawingBufferHeight / 2.0;
+
+            var ray = this.getPickRay(mousePosition, pickGlobeScratchRay);
+            rayIntersection = globe.pick(ray, scene, scratchRayIntersection);
+            if (defined(rayIntersection)) {
+                this.frustum.width = Cartesian3.distance(rayIntersection, this.positionWC);
+            }
+        }
+
+        if (!defined(globe) || (!defined(rayIntersection))) {
+            var distance = this.positionCartographic.height;
+            this.frustum.width = distance;
+        }
+    };
+
     var scratchSetViewCartesian = new Cartesian3();
     var scratchSetViewTransform1 = new Matrix4();
     var scratchSetViewTransform2 = new Matrix4();
@@ -981,6 +1028,8 @@ define([
         Cartesian3.cross(camera.direction, camera.up, camera.right);
 
         camera._setTransform(currentTransform);
+
+        camera._adjustOrthographicFrustum();
     }
 
     function setViewCV(camera, position,hpr, convert) {
@@ -1005,6 +1054,8 @@ define([
         Cartesian3.cross(camera.direction, camera.up, camera.right);
 
         camera._setTransform(currentTransform);
+
+        camera._adjustOrthographicFrustum();
     }
 
     function setView2D(camera, position, hpr, convert) {
@@ -1973,6 +2024,8 @@ define([
         Cartesian3.normalize(this.right, this.right);
         Cartesian3.cross(this.right, this.direction, this.up);
         Cartesian3.normalize(this.up, this.up);
+
+        this._adjustOrthographicFrustum();
     };
 
     var viewRectangle3DCartographic1 = new Cartographic();
@@ -2080,38 +2133,58 @@ define([
         Cartesian3.normalize(right, right);
         var up = Cartesian3.cross(right, direction, cameraRF.up);
 
-        var tanPhi = Math.tan(camera.frustum.fovy * 0.5);
-        var tanTheta = camera.frustum.aspectRatio * tanPhi;
+        var d;
+        if (camera.frustum instanceof OrthographicFrustum) {
+            var width = Math.max(Cartesian3.distance(northEast, northWest), Cartesian3.distance(southEast, southWest));
+            var height = Math.max(Cartesian3.distance(northEast, southEast), Cartesian3.distance(northWest, southWest));
+
+            var rightScalar;
+            var topScalar;
+            var ratio = camera.frustum._offCenterFrustum.right / camera.frustum._offCenterFrustum.top;
+            var heightRatio = height * ratio;
+            if (width > heightRatio) {
+                rightScalar = width;
+                topScalar = rightScalar / ratio;
+            } else {
+                topScalar = height;
+                rightScalar = heightRatio;
+            }
 
-        var d = Math.max(
-            computeD(direction, up, northWest, tanPhi),
-            computeD(direction, up, southEast, tanPhi),
-            computeD(direction, up, northEast, tanPhi),
-            computeD(direction, up, southWest, tanPhi),
-            computeD(direction, up, northCenter, tanPhi),
-            computeD(direction, up, southCenter, tanPhi),
-            computeD(direction, right, northWest, tanTheta),
-            computeD(direction, right, southEast, tanTheta),
-            computeD(direction, right, northEast, tanTheta),
-            computeD(direction, right, southWest, tanTheta),
-            computeD(direction, right, northCenter, tanTheta),
-            computeD(direction, right, southCenter, tanTheta));
-
-        // If the rectangle crosses the equator, compute D at the equator, too, because that's the
-        // widest part of the rectangle when projected onto the globe.
-        if (south < 0 && north > 0) {
-            var equatorCartographic = viewRectangle3DCartographic1;
-            equatorCartographic.longitude = west;
-            equatorCartographic.latitude = 0.0;
-            equatorCartographic.height = 0.0;
-            var equatorPosition = ellipsoid.cartographicToCartesian(equatorCartographic, viewRectangle3DEquator);
-            Cartesian3.subtract(equatorPosition, center, equatorPosition);
-            d = Math.max(d, computeD(direction, up, equatorPosition, tanPhi), computeD(direction, right, equatorPosition, tanTheta));
-
-            equatorCartographic.longitude = east;
-            equatorPosition = ellipsoid.cartographicToCartesian(equatorCartographic, viewRectangle3DEquator);
-            Cartesian3.subtract(equatorPosition, center, equatorPosition);
-            d = Math.max(d, computeD(direction, up, equatorPosition, tanPhi), computeD(direction, right, equatorPosition, tanTheta));
+            d = Math.max(rightScalar, topScalar);
+        } else {
+            var tanPhi = Math.tan(camera.frustum.fovy * 0.5);
+            var tanTheta = camera.frustum.aspectRatio * tanPhi;
+
+            d = Math.max(
+                computeD(direction, up, northWest, tanPhi),
+                computeD(direction, up, southEast, tanPhi),
+                computeD(direction, up, northEast, tanPhi),
+                computeD(direction, up, southWest, tanPhi),
+                computeD(direction, up, northCenter, tanPhi),
+                computeD(direction, up, southCenter, tanPhi),
+                computeD(direction, right, northWest, tanTheta),
+                computeD(direction, right, southEast, tanTheta),
+                computeD(direction, right, northEast, tanTheta),
+                computeD(direction, right, southWest, tanTheta),
+                computeD(direction, right, northCenter, tanTheta),
+                computeD(direction, right, southCenter, tanTheta));
+
+            // If the rectangle crosses the equator, compute D at the equator, too, because that's the
+            // widest part of the rectangle when projected onto the globe.
+            if (south < 0 && north > 0) {
+                var equatorCartographic = viewRectangle3DCartographic1;
+                equatorCartographic.longitude = west;
+                equatorCartographic.latitude = 0.0;
+                equatorCartographic.height = 0.0;
+                var equatorPosition = ellipsoid.cartographicToCartesian(equatorCartographic, viewRectangle3DEquator);
+                Cartesian3.subtract(equatorPosition, center, equatorPosition);
+                d = Math.max(d, computeD(direction, up, equatorPosition, tanPhi), computeD(direction, right, equatorPosition, tanTheta));
+
+                equatorCartographic.longitude = east;
+                equatorPosition = ellipsoid.cartographicToCartesian(equatorCartographic, viewRectangle3DEquator);
+                Cartesian3.subtract(equatorPosition, center, equatorPosition);
+                d = Math.max(d, computeD(direction, up, equatorPosition, tanPhi), computeD(direction, right, equatorPosition, tanTheta));
+            }
         }
 
         return Cartesian3.add(center, Cartesian3.multiplyByScalar(direction, -d, viewRectangle3DEquator), result);
@@ -2141,12 +2214,18 @@ define([
         Matrix4.multiplyByPoint(transform, southWest, southWest);
         Matrix4.multiplyByPoint(invTransform, southWest, southWest);
 
-        var tanPhi = Math.tan(camera.frustum.fovy * 0.5);
-        var tanTheta = camera.frustum.aspectRatio * tanPhi;
-
         result.x = (northEast.x - southWest.x) * 0.5 + southWest.x;
         result.y = (northEast.y - southWest.y) * 0.5 + southWest.y;
-        result.z = Math.max((northEast.x - southWest.x) / tanTheta, (northEast.y - southWest.y) / tanPhi) * 0.5;
+
+        if (defined(camera.frustum.fovy)) {
+            var tanPhi = Math.tan(camera.frustum.fovy * 0.5);
+            var tanTheta = camera.frustum.aspectRatio * tanPhi;
+            result.z = Math.max((northEast.x - southWest.x) / tanTheta, (northEast.y - southWest.y) / tanPhi) * 0.5;
+        } else {
+            var width = northEast.x - southWest.x;
+            var height = northEast.y - southWest.y;
+            result.z = Math.max(width, height);
+        }
 
         return result;
     }
@@ -2339,10 +2418,14 @@ define([
         var width = canvas.clientWidth;
         var height = canvas.clientHeight;
 
+        var frustum = camera.frustum;
+        if (!defined(frustum.top)) {
+            frustum = frustum._offCenterFrustum;
+        }
         var x = (2.0 / width) * windowPosition.x - 1.0;
-        x *= (camera.frustum.right - camera.frustum.left) * 0.5;
+        x *= (frustum.right - frustum.left) * 0.5;
         var y = (2.0 / height) * (height - windowPosition.y) - 1.0;
-        y *= (camera.frustum.top - camera.frustum.bottom) * 0.5;
+        y *= (frustum.top - frustum.bottom) * 0.5;
 
         var origin = result.origin;
         Cartesian3.clone(camera.position, origin);
@@ -2354,6 +2437,10 @@ define([
 
         Cartesian3.clone(camera.directionWC, result.direction);
 
+        if (camera._mode === SceneMode.COLUMBUS_VIEW) {
+            Cartesian3.fromElements(result.origin.z, result.origin.x, result.origin.y, result.origin);
+        }
+
         return result;
     }
 
@@ -2675,6 +2762,9 @@ define([
 
     function distanceToBoundingSphere2D(camera, radius) {
         var frustum = camera.frustum;
+        if (!defined(frustum.top)) {
+            frustum = frustum._offCenterFrustum;
+        }
 
         var right, top;
         var ratio = frustum.right / frustum.top;
@@ -2703,8 +2793,10 @@ define([
             var radius = boundingSphere.radius;
             if (radius === 0.0) {
                 offset.range = MINIMUM_ZOOM;
+            } else if (camera.frustum instanceof OrthographicFrustum || camera._mode === SceneMode.SCENE2D) {
+                offset.range = distanceToBoundingSphere2D(camera, radius);
             } else {
-                offset.range = camera._mode === SceneMode.SCENE2D ? distanceToBoundingSphere2D(camera, radius) : distanceToBoundingSphere3D(camera, radius);
+                offset.range = distanceToBoundingSphere3D(camera, radius);
             }
         }