cesium 0.16.0 → 0.17.0

data/app/assets/javascripts/Renderer/VertexArrayFacade.js

@@ -499,11 +499,11 @@ define([
         var allBuffers = this._allBuffers;
 
         for (var i = 0, len = allBuffers.length; i < len; ++i) {
-            subCommit(this, allBuffers[i], offsetInVertices, lengthInVertices);
+            subCommit(allBuffers[i], offsetInVertices, lengthInVertices);
         }
     };
 
-    function subCommit(vertexArrayFacade, buffer, offsetInVertices, lengthInVertices) {
+    function subCommit(buffer, offsetInVertices, lengthInVertices) {
         if (buffer.needsCommit && (buffer.vertexSizeInBytes > 0)) {
             var byteOffset = buffer.vertexSizeInBytes * offsetInVertices;
             var byteLength = buffer.vertexSizeInBytes * lengthInVertices;

data/app/assets/javascripts/Scene/AnimationCollection.js

@@ -35,25 +35,29 @@ define([
             throw new DeveloperError('duration is required.');
         }
 
-        var delayDuration = defaultValue(options.delayDuration, 0);
-        var easingFunction = defaultValue(options.easingFunction, Tween.Easing.Linear.None);
+        if (options.duration !== 0) {
+            var delayDuration = defaultValue(options.delayDuration, 0);
+            var easingFunction = defaultValue(options.easingFunction, Tween.Easing.Linear.None);
+
+            var value = clone(options.startValue);
+            var tween = new Tween.Tween(value);
+            tween.to(options.stopValue, options.duration);
+            tween.delay(delayDuration);
+            tween.easing(easingFunction);
+            if (typeof options.onUpdate === 'function') {
+                tween.onUpdate(function() {
+                    options.onUpdate(value);
+                });
+            }
+            tween.onComplete(defaultValue(options.onComplete, null));
+            tween.start();
 
-        var value = clone(options.startValue);
-        var tween = new Tween.Tween(value);
-        tween.to(options.stopValue, options.duration);
-        tween.delay(delayDuration);
-        tween.easing(easingFunction);
-        if (typeof options.onUpdate === 'function') {
-            tween.onUpdate(function() {
-                options.onUpdate(value);
-            });
+            return {
+                _tween : tween
+            };
+        } else if (typeof options.onComplete === 'function') {
+            options.onComplete();
         }
-        tween.onComplete(defaultValue(options.onComplete, null));
-        tween.start();
-
-        return {
-            _tween : tween
-        };
     };
 
     /**

data/app/assets/javascripts/Scene/ArcGisMapServerImageryProvider.js

@@ -6,7 +6,6 @@ define([
         '../Core/Cartesian2',
         '../Core/DeveloperError',
         '../Core/Event',
-        '../Core/RuntimeError',
         './DiscardMissingTileImagePolicy',
         './GeographicTilingScheme',
         './ImageryProvider',
@@ -20,7 +19,6 @@ define([
         Cartesian2,
         DeveloperError,
         Event,
-        RuntimeError,
         DiscardMissingTileImagePolicy,
         GeographicTilingScheme,
         ImageryProvider,

data/app/assets/javascripts/Scene/Billboard.js

@@ -2,31 +2,25 @@
 define([
         '../Core/defaultValue',
         '../Core/DeveloperError',
-        '../Core/BoundingRectangle',
         '../Core/Color',
         '../Core/Cartesian2',
         '../Core/Cartesian3',
         '../Core/Cartesian4',
-        '../Core/Cartographic',
-        '../Core/Math',
-        '../Core/Matrix4',
         './HorizontalOrigin',
         './VerticalOrigin',
-        './SceneMode'
+        './SceneMode',
+        './SceneTransforms'
     ], function(
         defaultValue,
         DeveloperError,
-        BoundingRectangle,
         Color,
         Cartesian2,
         Cartesian3,
         Cartesian4,
-        Cartographic,
-        CesiumMath,
-        Matrix4,
         HorizontalOrigin,
         VerticalOrigin,
-        SceneMode) {
+        SceneMode,
+        SceneTransforms) {
     "use strict";
 
     var EMPTY_OBJECT = {};
@@ -559,54 +553,21 @@ define([
     };
 
     var tempCartesian4 = new Cartesian4();
-    var tempCartographic = new Cartographic();
     Billboard._computeActualPosition = function(position, frameState, modelMatrix) {
-        var mode = frameState.mode;
-
-        if (mode === SceneMode.SCENE3D) {
+        if (frameState.mode === SceneMode.SCENE3D) {
             return position;
         }
 
         modelMatrix.multiplyByPoint(position, tempCartesian4);
-
-        var projection = frameState.scene2D.projection;
-        var cartographic = projection.getEllipsoid().cartesianToCartographic(tempCartesian4, tempCartographic);
-        if (typeof cartographic === 'undefined') {
-            return undefined;
-        }
-
-        var projectedPosition = projection.project(cartographic);
-        if (mode === SceneMode.MORPHING) {
-            var morphTime = frameState.morphTime;
-            var x = CesiumMath.lerp(projectedPosition.z, tempCartesian4.x, morphTime);
-            var y = CesiumMath.lerp(projectedPosition.x, tempCartesian4.y, morphTime);
-            var z = CesiumMath.lerp(projectedPosition.y, tempCartesian4.z, morphTime);
-            return new Cartesian3(x, y, z);
-        }
-        if (mode === SceneMode.SCENE2D) {
-            return new Cartesian3(0.0, projectedPosition.x, projectedPosition.y);
-        }
-        if (mode === SceneMode.COLUMBUS_VIEW) {
-            return new Cartesian3(projectedPosition.z, projectedPosition.x, projectedPosition.y);
-        }
-        return undefined;
+        return SceneTransforms.computeActualWgs84Position(frameState, tempCartesian4);
     };
 
-    var scratchViewport = new BoundingRectangle();
-    var scratchViewportTransform = new Matrix4();
     Billboard._computeScreenSpacePosition = function(modelMatrix, position, eyeOffset, pixelOffset, context, frameState) {
         // This function is basically a stripped-down JavaScript version of BillboardCollectionVS.glsl
-
         var camera = frameState.camera;
         var view = camera.getViewMatrix();
         var projection = camera.frustum.getProjectionMatrix();
 
-        // Assuming viewport takes up the entire canvas...
-        var canvas = context.getCanvas();
-        scratchViewport.width = canvas.clientWidth;
-        scratchViewport.height = canvas.clientHeight;
-        var viewportTransformation = Matrix4.computeViewportTransformation(scratchViewport, 0.0, 1.0, scratchViewportTransform);
-
         // Model to eye coordinates
         var mv = view.multiply(modelMatrix);
         var positionEC = mv.multiplyByPoint(position);
@@ -617,12 +578,8 @@ define([
         positionEC.y += eyeOffset.y + zEyeOffset.y;
         positionEC.z += zEyeOffset.z;
 
-        // Eye to window coordinates, e.g., czm_eyeToWindowCoordinates
-        var q = projection.multiplyByVector(positionEC); // clip coordinates
-        q.x /= q.w; // normalized device coordinates
-        q.y /= q.w;
-        q.z /= q.w;
-        var positionWC = viewportTransformation.multiplyByPoint(q); // window coordinates
+        var positionCC = projection.multiplyByVector(positionEC); // clip coordinates
+        var positionWC = SceneTransforms.clipToWindowCoordinates(context.getCanvas(), positionCC);
 
         // Apply pixel offset
         var uniformState = context.getUniformState();

data/app/assets/javascripts/Scene/BillboardCollection.js

@@ -2,12 +2,9 @@
 define([
         '../Core/DeveloperError',
         '../Core/Color',
-        '../Core/combine',
         '../Core/destroyObject',
-        '../Core/Math',
         '../Core/Cartesian2',
         '../Core/Cartesian3',
-        '../Core/Cartesian4',
         '../Core/EncodedCartesian3',
         '../Core/Matrix4',
         '../Core/ComponentDatatype',
@@ -27,12 +24,9 @@ define([
     ], function(
         DeveloperError,
         Color,
-        combine,
         destroyObject,
-        CesiumMath,
         Cartesian2,
         Cartesian3,
-        Cartesian4,
         EncodedCartesian3,
         Matrix4,
         ComponentDatatype,

data/app/assets/javascripts/Scene/Camera.js

@@ -6,7 +6,6 @@ define([
         '../Core/Cartesian3',
         '../Core/Cartesian4',
         '../Core/Matrix4',
-        '../Core/Ray',
         './CameraController',
         './PerspectiveFrustum'
     ], function(
@@ -16,7 +15,6 @@ define([
         Cartesian3,
         Cartesian4,
         Matrix4,
-        Ray,
         CameraController,
         PerspectiveFrustum) {
     "use strict";

data/app/assets/javascripts/Scene/CameraController.js

@@ -786,7 +786,12 @@ define([
     var viewExtent3DNorthWest = new Cartesian3();
     var viewExtent3DSouthEast = new Cartesian3();
     var viewExtent3DCenter = new Cartesian3();
-    function viewExtent3D(camera, extent, ellipsoid) {
+    var defaultRF = {direction: new Cartesian3(), right: new Cartesian3(), up: new Cartesian3()};
+    function extentCameraPosition3D (camera, extent, ellipsoid, result, positionOnly) {
+        var cameraRF = camera;
+        if (positionOnly) {
+            cameraRF = defaultRF;
+        }
         var north = extent.north;
         var south = extent.south;
         var east = extent.east;
@@ -817,12 +822,12 @@ define([
         Cartesian3.subtract(northEast, center, northEast);
         Cartesian3.subtract(southWest, center, southWest);
 
-        var direction = ellipsoid.geodeticSurfaceNormal(center, camera.direction);
+        var direction = ellipsoid.geodeticSurfaceNormal(center, cameraRF.direction);
         Cartesian3.negate(direction, direction);
         Cartesian3.normalize(direction, direction);
-        var right = Cartesian3.cross(direction, Cartesian3.UNIT_Z, camera.right);
+        var right = Cartesian3.cross(direction, Cartesian3.UNIT_Z, cameraRF.right);
         Cartesian3.normalize(right, right);
-        var up = Cartesian3.cross(right, direction, camera.up);
+        var up = Cartesian3.cross(right, direction, cameraRF.up);
 
         var height = Math.max(Math.abs(up.dot(northWest)), Math.abs(up.dot(southEast)), Math.abs(up.dot(northEast)), Math.abs(up.dot(southWest)));
         var width = Math.max(Math.abs(right.dot(northWest)), Math.abs(right.dot(southEast)), Math.abs(right.dot(northEast)), Math.abs(right.dot(southWest)));
@@ -833,14 +838,14 @@ define([
 
         var scalar = center.magnitude() + d;
         Cartesian3.normalize(center, center);
-        Cartesian3.multiplyByScalar(center, scalar, camera.position);
+        return Cartesian3.multiplyByScalar(center, scalar, result);
     }
 
     var viewExtentCVCartographic = new Cartographic();
     var viewExtentCVNorthEast = Cartesian4.UNIT_W.clone();
     var viewExtentCVSouthWest = Cartesian4.UNIT_W.clone();
     var viewExtentCVTransform = new Matrix4();
-    function viewExtentColumbusView(camera, extent, projection) {
+    function extentCameraPositionColumbusView(camera, extent, projection, result, positionOnly) {
         var north = extent.north;
         var south = extent.south;
         var east = extent.east;
@@ -867,20 +872,28 @@ define([
 
         var tanPhi = Math.tan(camera.frustum.fovy * 0.5);
         var tanTheta = camera.frustum.aspectRatio * tanPhi;
+        if (typeof result === 'undefined') {
+            result = new Cartesian3();
+        }
 
-        position = camera.position;
-        position.x = (northEast.x - southWest.x) * 0.5 + southWest.x;
-        position.y = (northEast.y - southWest.y) * 0.5 + southWest.y;
-        position.z = Math.max((northEast.x - southWest.x) / tanTheta, (northEast.y - southWest.y) / tanPhi) * 0.5;
+        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;
 
-        var direction = Cartesian3.clone(Cartesian3.UNIT_Z, camera.direction);
-        Cartesian3.negate(direction, direction);
-        var right = Cartesian3.clone(Cartesian3.UNIT_X, camera.right);
-        Cartesian3.cross(right, direction, camera.up);
+        if (!positionOnly) {
+            var direction = Cartesian3.clone(Cartesian3.UNIT_Z, camera.direction);
+            Cartesian3.negate(direction, direction);
+            var right = Cartesian3.clone(Cartesian3.UNIT_X, camera.right);
+            Cartesian3.cross(right, direction, camera.up);
+        }
+
+        return result;
     }
 
     var viewExtent2DCartographic = new Cartographic();
-    function viewExtent2D(camera, extent, projection) {
+    var viewExtent2DNorthEast = new Cartesian3();
+    var viewExtent2DSouthWest = new Cartesian3();
+    function extentCameraPosition2D (camera, extent, projection, result, positionOnly) {
         var north = extent.north;
         var south = extent.south;
         var east = extent.east;
@@ -889,10 +902,10 @@ define([
         var cart = viewExtent2DCartographic;
         cart.longitude = east;
         cart.latitude = north;
-        var northEast = projection.project(cart);
+        var northEast = projection.project(cart, viewExtent2DNorthEast);
         cart.longitude = west;
         cart.latitude = south;
-        var southWest = projection.project(cart);
+        var southWest = projection.project(cart, viewExtent2DSouthWest);
 
         var width = Math.abs(northEast.x - southWest.x) * 0.5;
         var height = Math.abs(northEast.y - southWest.y) * 0.5;
@@ -908,18 +921,57 @@ define([
             right = heightRatio;
         }
 
-        camera.frustum.right = right;
-        camera.frustum.left = -right;
-        camera.frustum.top = top;
-        camera.frustum.bottom = -top;
+        height = Math.max(2.0 * right, 2.0 * top);
 
-        camera.position.x = (northEast.x - southWest.x) * 0.5 + southWest.x;
-        camera.position.y = (northEast.y - southWest.y) * 0.5 + southWest.y;
+        if (typeof result === 'undefined') {
+            result = new Cartesian3();
+        }
+        result.x = (northEast.x - southWest.x) * 0.5 + southWest.x;
+        result.y = (northEast.y - southWest.y) * 0.5 + southWest.y;
+
+        if (positionOnly) {
+            cart = projection.unproject(result, cart);
+            cart.height = height;
+            result = projection.project(cart, result);
+        } else {
+            var frustum = camera.frustum;
+            frustum.right = right;
+            frustum.left = -right;
+            frustum.top = top;
+            frustum.bottom = -top;
+
+            var cameraRight = Cartesian3.clone(Cartesian3.UNIT_X, camera.right);
+            Cartesian3.cross(cameraRight, camera.direction, camera.up);
+        }
 
-        //Orient the camera north.
-        var cameraRight = Cartesian3.clone(Cartesian3.UNIT_X, camera.right);
-        Cartesian3.cross(cameraRight, camera.direction, camera.up);
+        return result;
     }
+    /**
+     * Get the camera position neede to view an extent on an ellipsoid or map
+     * @memberof CameraController
+     *
+     * @param {Extent} extent The extent to view.
+     * @param {Cartesian3} [result] The camera position needed to view the extent
+     *
+     * @returns {Cartesian3} The camera position needed to view the extent
+     *
+     * @exception {DeveloperError} extent is required.
+     */
+    CameraController.prototype.getExtentCameraCoordinates = function(extent, result) {
+        if (typeof extent === 'undefined') {
+            throw new DeveloperError('extent is required');
+        }
+
+        if (this._mode === SceneMode.SCENE3D) {
+            return extentCameraPosition3D(this._camera, extent, this._projection.getEllipsoid(), result, true);
+        } else if (this._mode === SceneMode.COLUMBUS_VIEW) {
+            return extentCameraPositionColumbusView(this._camera, extent, this._projection, result, true);
+        } else if (this._mode === SceneMode.SCENE2D) {
+            return extentCameraPosition2D(this._camera, extent, this._projection, result, true);
+        }
+
+        return undefined;
+    };
 
     /**
      * View an extent on an ellipsoid or map.
@@ -937,11 +989,11 @@ define([
         ellipsoid = defaultValue(ellipsoid, Ellipsoid.WGS84);
 
         if (this._mode === SceneMode.SCENE3D) {
-            viewExtent3D(this._camera, extent, ellipsoid);
+            extentCameraPosition3D(this._camera, extent, ellipsoid, this._camera.position);
         } else if (this._mode === SceneMode.COLUMBUS_VIEW) {
-            viewExtentColumbusView(this._camera, extent, this._projection);
+            extentCameraPositionColumbusView(this._camera, extent, this._projection, this._camera.position);
         } else if (this._mode === SceneMode.SCENE2D) {
-            viewExtent2D(this._camera, extent, this._projection);
+            extentCameraPosition2D(this._camera, extent, this._projection, this._camera.position);
         }
     };
 

data/app/assets/javascripts/Scene/CameraFlightPath.js

@@ -1,36 +1,28 @@
 /*global define*/
 define([
         '../Core/Cartesian3',
-        '../Core/Cartographic',
         '../Core/clone',
         '../Core/defaultValue',
         '../Core/DeveloperError',
-        '../Core/Ellipsoid',
         '../Core/HermiteSpline',
-        '../Core/IntersectionTests',
         '../Core/Math',
         '../Core/Matrix3',
         '../Core/OrientationInterpolator',
         '../Core/Quaternion',
-        '../Core/Ray',
         '../Scene/PerspectiveFrustum',
         '../Scene/PerspectiveOffCenterFrustum',
         '../Scene/SceneMode',
         '../ThirdParty/Tween'
     ], function(
         Cartesian3,
-        Cartographic,
         clone,
         defaultValue,
         DeveloperError,
-        Ellipsoid,
         HermiteSpline,
-        IntersectionTests,
         CesiumMath,
         Matrix3,
         OrientationInterpolator,
         Quaternion,
-        Ray,
         PerspectiveFrustum,
         PerspectiveOffCenterFrustum,
         SceneMode,
@@ -44,13 +36,26 @@ define([
     var CameraFlightPath = {
     };
 
-    function createQuaternion(direction, up) {
-        var right = direction.cross(up);
-        up = right.cross(direction);
-        var viewMat = new Matrix3( right.x,      right.y,      right.z,
-                                   up.x,         up.y,         up.z,
-                                  -direction.x, -direction.y, -direction.z);
-        return Quaternion.fromRotationMatrix(viewMat);
+    var c3destination = new Cartesian3();
+    var rotMatrix = new Matrix3();
+    var viewMat = new Matrix3();
+
+    var cqRight = new Cartesian3();
+    var cqUp = new Cartesian3();
+    function createQuaternion(direction, up, result) {
+        direction.cross(up, cqRight);
+        cqRight.cross(direction, cqUp);
+        viewMat[0] = cqRight.x;
+        viewMat[1] = cqUp.x;
+        viewMat[2] = -direction.x;
+        viewMat[3] = cqRight.y;
+        viewMat[4] = cqUp.y;
+        viewMat[5] = -direction.y;
+        viewMat[6] = cqRight.z;
+        viewMat[7] = cqUp.z;
+        viewMat[8] = -direction.z;
+
+        return Quaternion.fromRotationMatrix(viewMat, result);
     }
 
     function getAltitude(frustum, dx, dy) {
@@ -87,10 +92,10 @@ define([
                 return points;
             },
 
-            evaluate : function(time) {
+            evaluate : function(time, result) {
                 time = CesiumMath.clamp(time, p.time, q.time);
                 var t = (time - p.time) / (q.time - p.time);
-                return Cartesian3.lerp(p.point, q.point, t);
+                return Cartesian3.lerp(p.point, q.point, t, result);
             }
         };
     }
@@ -174,32 +179,30 @@ define([
 
         return createSpline(points);
     }
-
+    var direction3D = new Cartesian3();
+    var right3D = new Cartesian3();
+    var up3D = new Cartesian3();
+    var quat3D = new Quaternion();
     function createOrientations3D(camera, points, endDirection, endUp) {
         points[0].orientation = createQuaternion(camera.direction, camera.up);
-
         var point;
-        var direction;
-        var right;
-        var up;
-
         var length = points.length - 1;
         for (var i = 1; i < length; ++i) {
             point = points[i];
-            direction = point.point.negate().normalize();
-            right = direction.cross(Cartesian3.UNIT_Z).normalize();
-            up = right.cross(direction);
-            point.orientation = createQuaternion(direction, up);
+            point.point.negate(direction3D).normalize(direction3D);
+            direction3D.cross(Cartesian3.UNIT_Z, right3D).normalize(right3D);
+            right3D.cross(direction3D, up3D);
+            point.orientation = createQuaternion(direction3D, up3D, quat3D);
         }
 
         point = points[length];
         if (typeof endDirection !== 'undefined' && typeof endUp !== 'undefined') {
             point.orientation = createQuaternion(endDirection, endUp);
         } else {
-            direction = point.point.negate().normalize();
-            right = direction.cross(Cartesian3.UNIT_Z).normalize();
-            up = right.cross(direction);
-            point.orientation = createQuaternion(direction, up);
+            point.point.negate(direction3D).normalize(direction3D);
+            direction3D.cross(Cartesian3.UNIT_Z, right3D).normalize(right3D);
+            right3D.cross(direction3D, up3D);
+            point.orientation = createQuaternion(direction3D, up3D, quat3D);
         }
 
         return new OrientationInterpolator(points);
@@ -215,12 +218,12 @@ define([
         var update = function(value) {
             var time = value.time;
             var orientation = orientations.evaluate(time);
-            var rotationMatrix = Matrix3.fromQuaternion(orientation);
+            Matrix3.fromQuaternion(orientation, rotMatrix);
 
-            camera.position = path.evaluate(time);
-            camera.right = rotationMatrix.getRow(0);
-            camera.up = rotationMatrix.getRow(1);
-            camera.direction = rotationMatrix.getRow(2).negate();
+            camera.position = path.evaluate(time, camera.position);
+            camera.right = rotMatrix.getRow(0, camera.right);
+            camera.up = rotMatrix.getRow(1, camera.up);
+            camera.direction = rotMatrix.getRow(2, camera.direction).negate(camera.direction);
         };
 
         return update;
@@ -298,31 +301,24 @@ define([
         return createSpline(points);
     }
 
+    var direction2D = Cartesian3.UNIT_Z.negate();
+    var right2D = direction2D.cross(Cartesian3.UNIT_Y).normalize();
+    var up2D = right2D.cross(direction2D);
+    var quat = createQuaternion(direction2D, up2D);
     function createOrientations2D(camera, points, endDirection, endUp) {
         points[0].orientation = createQuaternion(camera.direction, camera.up);
-
         var point;
-        var direction;
-        var right;
-        var up;
-
         var length = points.length - 1;
         for (var i = 1; i < length; ++i) {
             point = points[i];
-            direction = Cartesian3.UNIT_Z.negate();
-            right = direction.cross(Cartesian3.UNIT_Y).normalize();
-            up = right.cross(direction);
-            point.orientation = createQuaternion(direction, up);
+            point.orientation = quat;
         }
 
         point = points[length];
         if (typeof endDirection !== 'undefined' && typeof endUp !== 'undefined') {
             point.orientation = createQuaternion(endDirection, endUp);
         } else {
-            direction = Cartesian3.UNIT_Z.negate();
-            right = direction.cross(Cartesian3.UNIT_Y).normalize();
-            up = right.cross(direction);
-            point.orientation = createQuaternion(direction, up);
+            point.orientation = quat;
         }
 
         return new OrientationInterpolator(points);
@@ -338,12 +334,12 @@ define([
         var update = function(value) {
             var time = value.time;
             var orientation = orientations.evaluate(time);
-            var rotationMatrix = Matrix3.fromQuaternion(orientation);
+            Matrix3.fromQuaternion(orientation, rotMatrix);
 
-            camera.position = path.evaluate(time);
-            camera.right = rotationMatrix.getRow(0);
-            camera.up = rotationMatrix.getRow(1);
-            camera.direction = rotationMatrix.getRow(2).negate();
+            camera.position = path.evaluate(time, camera.position);
+            camera.right = rotMatrix.getRow(0, camera.right);
+            camera.up = rotMatrix.getRow(1, camera.up);
+            camera.direction = rotMatrix.getRow(2, camera.direction).negate(camera.direction);
         };
 
         return update;
@@ -365,15 +361,15 @@ define([
         var update = function(value) {
             var time = value.time;
             var orientation = orientations.evaluate(time);
-            var rotationMatrix = Matrix3.fromQuaternion(orientation);
+            Matrix3.fromQuaternion(orientation, rotMatrix);
 
-            camera.position = path.evaluate(time);
+            camera.position = path.evaluate(time, camera.position);
             var zoom = camera.position.z;
             camera.position.z = height;
 
-            camera.right = rotationMatrix.getRow(0);
-            camera.up = rotationMatrix.getRow(1);
-            camera.direction = rotationMatrix.getRow(2).negate();
+            camera.right = rotMatrix.getRow(0, camera.right);
+            camera.up = rotMatrix.getRow(1, camera.up);
+            camera.direction = rotMatrix.getRow(2, camera.direction).negate(camera.direction);
 
             var frustum = camera.frustum;
             var ratio = frustum.top / frustum.right;
@@ -403,28 +399,37 @@ define([
      *
      * @exception {DeveloperError} frameState is required.
      * @exception {DeveloperError} description.destination is required.
+     * @exception {DeveloperError} frameState.mode cannot be SceneMode.MORPHING
      *
      * @see Scene#getFrameState
-     * @see Scene#getAnimationCollection
-     * @see CameraFlightPath#createAnimationCartographic
+     * @see Scene#getAnimations
      */
     CameraFlightPath.createAnimation = function(frameState, description) {
         description = defaultValue(description, defaultValue.EMPTY_OBJECT);
         var destination = description.destination;
-        var direction = description.direction;
-        var up = description.up;
 
         if (typeof frameState === 'undefined') {
             throw new DeveloperError('frameState is required.');
         }
-
         if (typeof destination === 'undefined') {
             throw new DeveloperError('destination is required.');
         }
+        if (frameState.mode === SceneMode.MORPHING) {
+            throw new DeveloperError('frameState.mode cannot be SceneMode.MORPHING');
+        }
 
+        var direction = description.direction;
+        var up = description.up;
         var duration = defaultValue(description.duration, 3000.0);
         var onComplete = description.onComplete;
 
+        if (Cartesian3.equalsEpsilon(destination, frameState.camera.position, CesiumMath.EPSILON6)) {
+            return {
+                duration : 0,
+                onComplete : description.onComplete
+            };
+        }
+
         var update;
         if (frameState.mode === SceneMode.SCENE3D) {
             update = createUpdate3D(frameState, destination, duration, direction, up);
@@ -453,7 +458,7 @@ define([
      * will happen in the camera's current reference frame.
      *
      * @param {FrameState} frameState The current frame state.
-     * @param {Cartesian3} description.destination The final position of the camera.
+     * @param {Cartographic} description.destination The final position of the camera.
      * @param {Cartesian3} [description.direction] The final direction of the camera. By default, the direction will point towards the center of the frame in 3D and in the negative z direction in Columbus view or 2D.
      * @param {Cartesian3} [description.up] The final up direction. By default, the up direction will point towards local north in 3D and in the positive y direction in Columbus view or 2D.
      * @param {Number} [description.duration=3000] The duration of the animation in milliseconds.
@@ -463,10 +468,10 @@ define([
      *
      * @exception {DeveloperError} frameState is required.
      * @exception {DeveloperError} description.destination is required.
+     * @exception {DeveloperError} frameState.mode cannot be SceneMode.MORPHING
      *
      * @see Scene#getFrameState
-     * @see Scene#getAnimationCollection
-     * @see CameraFlightPath#createAnimationCartographic
+     * @see Scene#getAnimations
      */
     CameraFlightPath.createAnimationCartographic = function(frameState, description) {
         description = defaultValue(description, defaultValue.EMPTY_OBJECT);
@@ -475,22 +480,75 @@ define([
         if (typeof frameState === 'undefined') {
             throw new DeveloperError('frameState is required.');
         }
-
         if (typeof destination === 'undefined') {
             throw new DeveloperError('description.destination is required.');
         }
 
-        var end;
         var projection = frameState.scene2D.projection;
         if (frameState.mode === SceneMode.SCENE3D) {
             var ellipsoid = projection.getEllipsoid();
-            end = ellipsoid.cartographicToCartesian(destination);
+            ellipsoid.cartographicToCartesian(destination, c3destination);
+        } else if (frameState.mode === SceneMode.COLUMBUS_VIEW || frameState.mode === SceneMode.SCENE2D) {
+            projection.project(destination, c3destination);
         } else {
-            end = projection.project(destination);
+            throw new DeveloperError('frameState.mode cannot be SceneMode.MORPHING');
+        }
+
+        if (Cartesian3.equalsEpsilon(c3destination, frameState.camera.position, CesiumMath.EPSILON6)) {
+            return {
+                duration : 0,
+                onComplete : description.onComplete
+            };
         }
 
         var createAnimationDescription = clone(description);
-        createAnimationDescription.destination = end;
+        createAnimationDescription.destination = c3destination;
+        return this.createAnimation(frameState, createAnimationDescription);
+    };
+
+    /**
+     * Creates an animation to fly the camera from it's current position to a position in which the entire extent will be visible. Keep in mind that the animation
+     * will happen in the camera's current reference frame.
+     *
+     * @param {FrameState} frameState The current frame state.
+     * @param {Extent} description.destination The final position of the camera.
+     * @param {Number} [description.duration=3000] The duration of the animation in milliseconds.
+     * @param {Function} [onComplete] The function to execute when the animation has completed.
+     *
+     * @returns {Object} An Object that can be added to an {@link AnimationCollection} for animation.
+     *
+     * @exception {DeveloperError} frameState is required.
+     * @exception {DeveloperError} description.destination is required.
+     * @exception {DeveloperError} frameState.mode cannot be SceneMode.MORPHING
+     *
+     * @see Scene#getFrameState
+     * @see Scene#getAnimations
+     */
+    CameraFlightPath.createAnimationExtent = function(frameState, description) {
+        description = defaultValue(description, defaultValue.EMPTY_OBJECT);
+        var extent = description.destination;
+        if (typeof frameState === 'undefined') {
+            throw new DeveloperError('frameState is required.');
+        }
+        if (typeof extent === 'undefined') {
+            throw new DeveloperError('description.destination is required.');
+        }
+        if (frameState.mode === SceneMode.MORPHING) {
+            throw new DeveloperError('frameState.mode cannot be SceneMode.MORPHING');
+        }
+
+        var createAnimationDescription = clone(description);
+        var camera = frameState.camera;
+        camera.controller.getExtentCameraCoordinates(extent, c3destination);
+
+        if (Cartesian3.equalsEpsilon(c3destination, frameState.camera.position, CesiumMath.EPSILON6)) {
+            return {
+                duration : 0,
+                onComplete : description.onComplete
+            };
+        }
+
+        createAnimationDescription.destination = c3destination;
         return this.createAnimation(frameState, createAnimationDescription);
     };