cesium 0.14.0 → 0.15.0

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

@@ -143,6 +143,19 @@ define([
         throw new DeveloperError('This type should not be instantiated directly.');
     };
 
+    /**
+     * Gets the proxy used by this provider.
+     *
+     * @memberof ImageryProvider
+     *
+     * @returns {Proxy} The proxy.
+     *
+     * @see DefaultProxy
+     */
+    ImageryProvider.prototype.getProxy = function() {
+        throw new DeveloperError('This type should not be instantiated directly.');
+    };
+
     /**
      * Requests the image for a given tile.  This function should
      * not be called before {@link ImageryProvider#isReady} returns true.

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

@@ -57,6 +57,7 @@ define([
         this._font = defaultValue(description.font, '30px sans-serif');
         this._fillColor = Color.clone(defaultValue(description.fillColor, Color.WHITE));
         this._outlineColor = Color.clone(defaultValue(description.outlineColor, Color.BLACK));
+        this._outlineWidth = defaultValue(description.outlineWidth, 1.0);
         this._style = defaultValue(description.style, LabelStyle.FILL);
         this._verticalOrigin = defaultValue(description.verticalOrigin, VerticalOrigin.BOTTOM);
         this._horizontalOrigin = defaultValue(description.horizontalOrigin, HorizontalOrigin.LEFT);
@@ -323,6 +324,43 @@ define([
         }
     };
 
+    /**
+     * Gets the outline width of this label.
+     *
+     * @memberof Label
+     *
+     * @see Label#setOutlineWidth
+     * @see <a href='http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#fill-and-stroke-styles'>HTML canvas 2D context fill and stroke styles</a>
+     */
+    Label.prototype.getOutlineWidth = function() {
+        return this._outlineWidth;
+    };
+
+    /**
+     * Sets the outline width of this label.
+     *
+     * @memberof Label
+     *
+     * @param {Number} value The outline width.
+     *
+     * @exception {DeveloperError} value is required.
+     *
+     * @see Label#getOutlineWidth
+     * @see Label#setFillColor
+     * @see Label#setFont
+     * @see <a href='http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#fill-and-stroke-styles'>HTML canvas 2D context fill and stroke styles</a>
+     */
+    Label.prototype.setOutlineWidth = function(value) {
+        if (typeof value === 'undefined') {
+            throw new DeveloperError('value is required.');
+        }
+
+        if (this._outlineWidth !== value) {
+            this._outlineWidth = value;
+            rebindAllGlyphs(this);
+        }
+    };
+
     /**
      * Gets the style of this label.
      *
@@ -632,24 +670,25 @@ define([
      *
      * @memberof Label
      *
-     * @param {UniformState} uniformState The same state object passed to {@link LabelCollection#update}.
+     * @param {Context} context The context.
      * @param {FrameState} frameState The same state object passed to {@link LabelCollection#update}.
      *
      * @return {Cartesian2} The screen-space position of the label.
      *
-     * @exception {DeveloperError} uniformState is required.
+     * @exception {DeveloperError} context is required.
      * @exception {DeveloperError} frameState is required.
      *
      * @see Label#setEyeOffset
      * @see Label#setPixelOffset
      *
      * @example
-     * console.log(l.computeScreenSpacePosition(scene.getUniformState(), scene.getFrameState()).toString());
+     * console.log(l.computeScreenSpacePosition(scene.getContext(), scene.getFrameState()).toString());
      */
-    Label.prototype.computeScreenSpacePosition = function(uniformState, frameState) {
-        if (typeof uniformState === 'undefined') {
-            throw new DeveloperError('uniformState is required.');
+    Label.prototype.computeScreenSpacePosition = function(context, frameState) {
+        if (typeof context === 'undefined') {
+            throw new DeveloperError('context is required.');
         }
+
         if (typeof frameState === 'undefined') {
             throw new DeveloperError('frameState is required.');
         }
@@ -658,7 +697,7 @@ define([
         var modelMatrix = labelCollection.modelMatrix;
         var actualPosition = Billboard._computeActualPosition(this._position, frameState, labelCollection.morphTime, modelMatrix);
 
-        return Billboard._computeScreenSpacePosition(modelMatrix, actualPosition, this._eyeOffset, this._pixelOffset, labelCollection.clampToPixel, uniformState);
+        return Billboard._computeScreenSpacePosition(modelMatrix, actualPosition, this._eyeOffset, this._pixelOffset, context, frameState);
     };
 
     /**
@@ -703,4 +742,4 @@ define([
     };
 
     return Label;
-});
+});

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

@@ -67,10 +67,11 @@ define([
 
     // reusable object for calling writeTextToCanvas
     var writeTextToCanvasParameters = {};
-    function createGlyphCanvas(character, font, fillColor, outlineColor, style, verticalOrigin) {
+    function createGlyphCanvas(character, font, fillColor, outlineColor, outlineWidth, style, verticalOrigin) {
         writeTextToCanvasParameters.font = font;
         writeTextToCanvasParameters.fillColor = fillColor;
         writeTextToCanvasParameters.strokeColor = outlineColor;
+        writeTextToCanvasParameters.strokeWidth = outlineWidth;
 
         if (verticalOrigin === VerticalOrigin.BOTTOM) {
             writeTextToCanvasParameters.textBaseline = 'bottom';
@@ -132,6 +133,7 @@ define([
             var font = label._font;
             var fillColor = label._fillColor;
             var outlineColor = label._outlineColor;
+            var outlineWidth = label._outlineWidth;
             var style = label._style;
             var verticalOrigin = label._verticalOrigin;
 
@@ -142,13 +144,14 @@ define([
                                      font,
                                      fillColor.toString(),
                                      outlineColor.toString(),
+                                     outlineWidth,
                                      style.toString(),
                                      verticalOrigin.toString()
                                     ]);
 
             var glyphTextureInfo = glyphTextureCache[id];
             if (typeof glyphTextureInfo === 'undefined') {
-                var canvas = createGlyphCanvas(character, font, fillColor, outlineColor, style, verticalOrigin);
+                var canvas = createGlyphCanvas(character, font, fillColor, outlineColor, outlineWidth, style, verticalOrigin);
                 var index = -1;
                 if (canvas.width > 0 && canvas.height > 0) {
                     index = textureAtlas.addImage(canvas);
@@ -272,6 +275,7 @@ define([
         for ( var i = 0, len = glyphs.length; i < len; ++i) {
             unbindGlyph(labelCollection, glyphs[i]);
         }
+        label._labelCollection = undefined;
         destroyObject(label);
     }
 
@@ -361,15 +365,6 @@ define([
          */
         this.modelMatrix = Matrix4.IDENTITY.clone();
 
-        /**
-         * If true, aligns all text to a pixel in screen space,
-         * providing crisper text at the cost of jumpier motion.
-         * Defaults to true.
-         *
-         * @type Boolean
-         */
-        this.clampToPixel = true;
-
         /**
          * The current morph transition time between 2D/Columbus View and 3D,
          * with 0.0 being 2D or Columbus View and 1.0 being 3D.
@@ -463,17 +458,14 @@ define([
      * labels.remove(l);  // Returns true
      */
     LabelCollection.prototype.remove = function(label) {
-        if (typeof label === 'undefined') {
-            return false;
-        }
-
-        if (label._labelCollection === this) {
-            this._labels.splice(this._labels.indexOf(label), 1);
-            destroyLabel(this, label);
-
-            return true;
+        if (typeof label !== 'undefined' && label._labelCollection === this) {
+            var index = this._labels.indexOf(label);
+            if (index !== -1) {
+                this._labels.splice(index, 1);
+                destroyLabel(this, label);
+                return true;
+            }
         }
-
         return false;
     };
 
@@ -596,7 +588,6 @@ define([
 
         billboardCollection.modelMatrix = this.modelMatrix;
         billboardCollection.morphTime = this.morphTime;
-        billboardCollection.clampToPixel = this.clampToPixel;
 
         var rebindAllGlyphsInAllLabels = false;
         if (++this._frameCount % 100 === 0) {

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

@@ -25,6 +25,7 @@ define([
         '../Shaders/Materials/FacetMaterial',
         '../Shaders/Materials/FresnelMaterial',
         '../Shaders/Materials/GrassMaterial',
+        '../Shaders/Materials/GridMaterial',
         '../Shaders/Materials/NormalMapMaterial',
         '../Shaders/Materials/ReflectionMaterial',
         '../Shaders/Materials/RefractionMaterial',
@@ -60,6 +61,7 @@ define([
         FacetMaterial,
         FresnelMaterial,
         GrassMaterial,
+        GridMaterial,
         NormalMapMaterial,
         ReflectionMaterial,
         RefractionMaterial,
@@ -202,6 +204,13 @@ define([
      *      <li><code>dirtColor</code>:  rgba color object for the dirt's color. </li>
      *      <li><code>patchiness</code>:  Number that controls the size of the color patches in the grass.</li>
      *  </ul>
+     *  <li>Grid</li>
+     *  <ul>
+     *      <li><code>color</code>:  rgba color object for the whole material.</li>
+     *      <li><code>cellAlpha</code>: Alpha value for the cells between grid lines.  This will be combined with color.alpha.</li>
+     *      <li><code>lineCount</code>:  Object with x and y values specifying the number of columns and rows respectively.</li>
+     *      <li><code>lineThickness</code>:  Object with x and y values specifying the thickness of grid lines (in pixels where available).</li>
+     *  </ul>
      *  <li>Stripe</li>
      *  <ul>
      *      <li><code>horizontal</code>:  Boolean that determines if the stripes are horizontal or vertical.</li>
@@ -344,8 +353,9 @@ define([
         this._context = undefined;
         this._strict = undefined;
         this._template = undefined;
+        this._count = undefined;
 
-        initializeMaterial(description, 0, this);
+        initializeMaterial(description, this);
         Object.defineProperty(this, 'type', {
             value : this.type,
             writable : false
@@ -428,16 +438,17 @@ define([
         }
         for ( var material in materials) {
             if (materials.hasOwnProperty(material)) {
-                material.destroy();
+                materials[material].destroy();
             }
         }
         return destroyObject(this);
     };
 
-    function initializeMaterial(description, count, result) {
+    function initializeMaterial(description, result) {
         description = defaultValue(description, {});
         result._context = description.context;
         result._strict = defaultValue(description.strict, false);
+        result._count = defaultValue(description.count, 0);
         result._template = defaultValue(description.fabric, {});
         result._template.uniforms = defaultValue(result._template.uniforms, {});
         result._template.materials = defaultValue(result._template.materials, {});
@@ -465,9 +476,8 @@ define([
         }
 
         createMethodDefinition(result);
-        count = createUniforms(result, count);
-        count = createSubMaterials(result, count);
-        return count;
+        createUniforms(result);
+        createSubMaterials(result);
     }
 
     function checkForValidProperties(object, properties, result, throwNotFound) {
@@ -545,19 +555,18 @@ define([
         }
     }
 
-    function createUniforms(material, count) {
+    function createUniforms(material) {
         var uniforms = material._template.uniforms;
         for ( var uniformId in uniforms) {
             if (uniforms.hasOwnProperty(uniformId)) {
-                count = createUniform(material, uniformId, count);
+                createUniform(material, uniformId);
             }
         }
-        return count;
     }
 
     // Writes uniform declarations to the shader file and connects uniform values with
     // corresponding material properties through the returnUniforms function.
-    function createUniform(material, uniformId, count) {
+    function createUniform(material, uniformId) {
         var strict = material._strict;
         var materialUniforms = material._template.uniforms;
         var uniformValue = materialUniforms[uniformId];
@@ -594,7 +603,7 @@ define([
                 material.shaderSource = uniformPhrase + material.shaderSource;
             }
 
-            var newUniformId = uniformId + '_' + count++;
+            var newUniformId = uniformId + '_' + material._count++;
             if (replaceToken(material, uniformId, newUniformId) === 1 && strict) {
                 throw new DeveloperError('strict: shader source does not use uniform \'' + uniformId + '\'.');
             }
@@ -602,8 +611,6 @@ define([
             material.uniforms[uniformId] = uniformValue;
             material._uniforms[newUniformId] = returnUniform(material, uniformId, uniformType);
         }
-
-        return count;
     }
 
     // Checks for updates to material values to refresh the uniforms.
@@ -686,26 +693,27 @@ define([
     }
 
     // Create all sub-materials by combining source and uniforms together.
-    function createSubMaterials(material, count) {
+    function createSubMaterials(material) {
         var context = material._context;
         var strict = material._strict;
         var subMaterialTemplates = material._template.materials;
         for ( var subMaterialId in subMaterialTemplates) {
             if (subMaterialTemplates.hasOwnProperty(subMaterialId)) {
                 // Construct the sub-material.
-                var subMaterial = {};
-                count = initializeMaterial({
+                var subMaterial = new Material({
                     context : context,
                     strict : strict,
-                    fabric : subMaterialTemplates[subMaterialId]
-                }, count, subMaterial);
+                    fabric : subMaterialTemplates[subMaterialId],
+                    count : material._count
+                });
 
+                material._count = subMaterial._count;
                 material._uniforms = combine([material._uniforms, subMaterial._uniforms]);
                 material.materials[subMaterialId] = subMaterial;
 
                 // Make the material's czm_getMaterial unique by appending the sub-material type.
                 var originalMethodName = 'czm_getMaterial';
-                var newMethodName = originalMethodName + '_' + count++;
+                var newMethodName = originalMethodName + '_' + material._count++;
                 replaceToken(subMaterial, originalMethodName, newMethodName);
                 material.shaderSource = subMaterial.shaderSource + material.shaderSource;
 
@@ -716,7 +724,6 @@ define([
                 }
             }
         }
-        return count;
     }
 
     // Used for searching or replacing a token in a material's shader source with something else.
@@ -1057,6 +1064,18 @@ define([
         source : GrassMaterial
     });
 
+    Material.GridType = 'Grid';
+    Material._materialCache.addMaterial(Material.GridType, {
+        type : Material.GridType,
+        uniforms : {
+            color : new Color(0.0, 1.0, 0.0, 1.0),
+            cellAlpha : 0.1,
+            lineCount : new Cartesian2(8.0, 8.0),
+            lineThickness : new Cartesian2(1.0, 1.0)
+        },
+        source : GridMaterial
+    });
+
     Material.StripeType = 'Stripe';
     Material._materialCache.addMaterial(Material.StripeType, {
         type : Material.StripeType,

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

@@ -103,6 +103,19 @@ define([
         return this._url;
     };
 
+    /**
+     * Gets the proxy used by this provider.
+     *
+     * @memberof OpenStreetMapImageryProvider
+     *
+     * @returns {Proxy} The proxy.
+     *
+     * @see DefaultProxy
+     */
+    OpenStreetMapImageryProvider.prototype.getProxy = function() {
+        return this._proxy;
+    };
+
     /**
      * Gets the width of each tile, in pixels.  This function should
      * not be called before {@link OpenStreetMapImageryProvider#isReady} returns true.

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

@@ -406,14 +406,12 @@ define([
                     polyline = polylinesToUpdate[i];
                     var changedProperties = polyline._propertiesChanged;
                     if (changedProperties[POSITION_INDEX]) {
-                        if (intersectsIDL(polyline)) {
-                            var newSegments = polyline._createSegments(this.modelMatrix);
-                            if (polyline._segmentsLengthChanged(newSegments)) {
-                                createVertexArrays = true;
-                                break;
-                            }
-                            polyline._setSegments(newSegments);
+                        var newSegments = polyline._createSegments(this.modelMatrix);
+                        if (polyline._segmentsLengthChanged(newSegments)) {
+                            createVertexArrays = true;
+                            break;
                         }
+                        polyline._setSegments(newSegments);
                     }
                 }
             }

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

@@ -1,7 +1,9 @@
 /*global define*/
 define([
         '../Core/destroyObject',
+        '../Core/DeveloperError',
         '../Core/Math',
+        '../Core/Event',
         '../Core/ScreenSpaceEventHandler',
         '../Core/ScreenSpaceEventType',
         '../Core/Ellipsoid',
@@ -16,7 +18,9 @@ define([
         './SceneMode'
     ], function(
         destroyObject,
+        DeveloperError,
         CesiumMath,
+        Event,
         ScreenSpaceEventHandler,
         ScreenSpaceEventType,
         Ellipsoid,
@@ -32,12 +36,50 @@ define([
     "use strict";
 
     /**
-     * DOC_TBA
-     *
+     * Transitions the scene among available modes. The transitions can
+     * either be instantaneous or animated.
      * @alias SceneTransitioner
      * @constructor
+     *
+     * @param {Scene} scene The scene to be transitioned.
+     * @param {Ellipsoid} [ellipsoid=Ellipsoid.WGS84] The ellipsoid to be transitioned.
+     *
+     * @exception {DeveloperError} scene is required.
+     *
+     * @see Scene
+     * @see SceneMode
      */
     var SceneTransitioner = function(scene, ellipsoid) {
+        if (typeof scene === 'undefined') {
+            throw new DeveloperError('scene is required.');
+        }
+
+        /**
+         * Gets or sets the amount of time, in milliseconds, for
+         * transition animations to complete.
+         * @type {Number}
+         */
+        this.morphDuration = 2000;
+
+        /**
+         * Gets or sets whether or not to instantly complete the
+         * transition animation on user input.
+         * @type {Boolean}
+         */
+        this.completeMorphOnUserInput = true;
+
+        /**
+         * Gets the event fired at the beginning of a transition.
+         * @type {Event}
+         */
+        this.onTransitionStart = new Event();
+
+        /**
+         * Gets the event fired at the completion of a transition.
+         * @type {Event}
+         */
+        this.onTransitionComplete = new Event();
+
         this._scene = scene;
         this._ellipsoid = ellipsoid || Ellipsoid.WGS84;
         var canvas = scene.getCanvas();
@@ -54,9 +96,9 @@ define([
         frustum.top = frustum.right * (canvas.clientHeight / canvas.clientWidth);
         frustum.bottom = -frustum.top;
 
-        var transform = new Matrix4(0.0, 0.0, 1.0, 0.0,
-                                    1.0, 0.0, 0.0, 0.0,
-                                    0.0, 1.0, 0.0, 0.0,
+        var transform = new Matrix4(0.0, 0.0, 1.0, 0.0, //
+                                    1.0, 0.0, 0.0, 0.0, //
+                                    0.0, 1.0, 0.0, 0.0, //
                                     0.0, 0.0, 0.0, 1.0);
 
         this._camera2D = {
@@ -99,241 +141,203 @@ define([
         this._currentAnimations = [];
         this._morphHandler = undefined;
         this._morphCancelled = false;
+        this._completeMorph = undefined;
+    };
 
-        /**
-         * DOC_TBA
-         * @type {Number}
-         */
-        this.morphDuration2D = 3000;
-
-        /**
-         * DOC_TBA
-         * @type {Number}
-         */
-        this.morphDuration3D = 3000;
-
-        /**
-         * DOC_TBA
-         * @type {Number}
-         */
-        this.morphDurationColumbusView = 3000;
-
-        /**
-         * DOC_TBA
-         * @type {Boolean}
-         */
-        this.endMorphOnMouseInput = true;
+    /**
+     * @memberof SceneTransitioner
+     * @returns {Scene} The scene to be transitioned.
+     */
+    SceneTransitioner.prototype.getScene = function() {
+        return this._scene;
     };
 
-    //immediately set the morph time of all objects in the scene
-    function setMorphTime(scene, morphTime) {
-        scene.morphTime = morphTime;
+    /**
+     * @memberof SceneTransitioner
+     * @returns {Ellipsoid} The ellipsoid to be transitioned.
+     */
+    SceneTransitioner.prototype.getEllipsoid = function() {
+        return this._ellipsoid;
+    };
 
-        var primitives = scene.getPrimitives();
-        for ( var i = 0, len = primitives.getLength(); i < len; i++) {
-            var primitive = primitives.get(i);
-            if (typeof primitive.morphTime !== 'undefined') {
-                primitive.morphTime = morphTime;
-            }
+    /**
+     * Instantly transitions the scene to 2D.
+     * @memberof SceneTransitioner
+     */
+    SceneTransitioner.prototype.to2D = function() {
+        if (typeof this._completeMorph !== 'undefined') {
+            this._completeMorph();
         }
 
-        var centralBody = primitives.getCentralBody();
-        centralBody.morphTime = morphTime;
-
-        if (typeof scene.skyBox !== 'undefined') {
-            scene.skyBox.morphTime = morphTime;
+        this._previousMode = this._scene.mode;
+        if (this._previousMode !== SceneMode.SCENE2D) {
+            this.onTransitionStart.raiseEvent(this, this._previousMode, SceneMode.SCENE2D, false);
+            complete2DCallback(this);
         }
+    };
 
-        if (typeof scene.skyAtmosphere !== 'undefined') {
-            scene.skyAtmosphere.morphTime = morphTime;
+    /**
+     * Instantly transitions the scene to Columbus View.
+     * @memberof SceneTransitioner
+     */
+    SceneTransitioner.prototype.toColumbusView = function() {
+        if (typeof this._completeMorph !== 'undefined') {
+            this._completeMorph();
         }
-    }
 
-    //in the future the animations will be more complicated
-    function addMorphTimeAnimations(transitioner, scene, start, stop, duration, onComplete) {
-        //for now, all objects morph at the same rate
-        var template = {
-            duration : duration,
-            easingFunction : Tween.Easing.Quartic.Out
-        };
+        var scene = this._scene;
+        this._previousMode = scene.mode;
 
-        var primitives = scene.getPrimitives();
-        var sceneAnimations = scene.getAnimations();
-        var animation;
-        for ( var i = 0, len = primitives.getLength(); i < len; i++) {
-            var primitive = primitives.get(i);
-            if (typeof primitive.morphTime !== 'undefined') {
-                animation = sceneAnimations.addProperty(primitive, 'morphTime', start, stop, template);
-                transitioner._currentAnimations.push(animation);
-            }
+        if (this._previousMode !== SceneMode.COLUMBUS_VIEW) {
+            this.onTransitionStart.raiseEvent(this, this._previousMode, SceneMode.COLUMBUS_VIEW, false);
+            completeColumbusViewCallback(this);
         }
+    };
 
-        var centralBody = primitives.getCentralBody();
-        animation = sceneAnimations.addProperty(centralBody, 'morphTime', start, stop, template);
-        transitioner._currentAnimations.push(animation);
-
-        if (typeof scene.skyBox !== 'undefined') {
-            animation = sceneAnimations.addProperty(scene.skyBox, 'morphTime', start, stop, template);
-            transitioner._currentAnimations.push(animation);
+    /**
+     * Instantly transitions the scene to 3D.
+     * @memberof SceneTransitioner
+     */
+    SceneTransitioner.prototype.to3D = function() {
+        if (typeof this._completeMorph !== 'undefined') {
+            this._completeMorph();
         }
 
-        if (typeof scene.skyAtmosphere !== 'undefined') {
-            animation = sceneAnimations.addProperty(scene.skyAtmosphere, 'morphTime', start, stop, template);
-            transitioner._currentAnimations.push(animation);
-        }
+        var scene = this._scene;
+        this._previousMode = scene.mode;
 
-        if (typeof onComplete !== 'undefined') {
-            template.onComplete = function() {
-                onComplete.call(transitioner);
-            };
+        if (scene.mode !== SceneMode.SCENE3D) {
+            this.onTransitionStart.raiseEvent(this, this._previousMode, SceneMode.SCENE3D, false);
+            complete3DCallback(this);
         }
+    };
 
-        animation = sceneAnimations.addProperty(scene, 'morphTime', start, stop, template);
-        transitioner._currentAnimations.push(animation);
-    }
-
-    function updateFrustums(transitioner) {
-        var scene = transitioner._scene;
-
-        var canvas = scene.getCanvas();
-        var ratio = canvas.clientHeight / canvas.clientWidth;
-
-        var frustum = transitioner._camera2D.frustum;
-        frustum.top = frustum.right * ratio;
-        frustum.bottom = -frustum.top;
-
-        ratio = 1.0 / ratio;
-
-        frustum = transitioner._cameraCV.frustum;
-        frustum.aspectRatio = ratio;
-
-        frustum = transitioner._camera3D.frustum;
-        frustum.aspectRatio = ratio;
-
-        var camera = scene.getCamera();
-        switch (scene.mode) {
-        case SceneMode.SCENE3D:
-            camera.frustum = transitioner._camera3D.frustum.clone();
-            break;
-        case SceneMode.COLUMBUS_VIEW:
-            camera.frustum = transitioner._cameraCV.frustum.clone();
-            break;
-        case SceneMode.SCENE2D:
-            camera.frustum = transitioner._camera2D.frustum.clone();
-            break;
+    /**
+     * Instantly completes an active transition.
+     * @memberof SceneTransitioner
+     *
+     * @exception {DeveloperError} completeMorph can only be called during a transition.
+     */
+    SceneTransitioner.prototype.completeMorph = function() {
+        if (typeof this._completeMorph === 'undefined') {
+            throw new DeveloperError('completeMorph can only be called while morphing');
         }
-    }
+        this._completeMorph();
+    };
 
     /**
-     * DOC_TBA
+     * Asynchronously transitions the scene to 2D.
      * @memberof SceneTransitioner
      */
-    SceneTransitioner.prototype.to2D = function() {
-        var scene = this._scene;
-
-        if (scene.mode !== SceneMode.SCENE2D) {
-            scene.mode = SceneMode.SCENE2D;
-            setMorphTime(scene, 0.0);
+    SceneTransitioner.prototype.morphTo2D = function() {
+        if (typeof this._completeMorph !== 'undefined') {
+            this._completeMorph();
+        }
 
-            this._destroyMorphHandler();
+        var currentMode = this._scene.mode;
+        if (currentMode === SceneMode.SCENE2D || currentMode === SceneMode.MORPHING) {
+            return;
+        }
+        this.onTransitionStart.raiseEvent(this, currentMode, SceneMode.SCENE2D, true);
+        this._previousMode = SceneMode.MORPHING;
 
-            updateFrustums(this);
-            var camera = scene.getCamera();
-            camera.transform = this._camera2D.transform.clone();
+        updateFrustums(this);
+        this._scene.mode = SceneMode.MORPHING;
+        createMorphHandler(this, complete2DCallback);
 
-            // TODO: Match incoming columbus-view or 3D position
-            camera.position = this._camera2D.position.clone();
-            camera.direction = this._camera2D.direction.clone();
-            camera.up = this._camera2D.up.clone();
+        if (currentMode === SceneMode.COLUMBUS_VIEW) {
+            morphFromColumbusViewTo2D(this, this.morphDuration, complete2DCallback);
+        } else {
+            morphFrom3DTo2D(this, this.morphDuration, complete2DCallback);
         }
     };
 
     /**
-     * DOC_TBA
+     * Asynchronously transitions the scene to Columbus View.
      * @memberof SceneTransitioner
      */
-    SceneTransitioner.prototype.toColumbusView = function() {
-        var scene = this._scene;
-        var previousMode = scene.mode;
-
-        if (scene.mode !== SceneMode.COLUMBUS_VIEW) {
-            scene.mode = SceneMode.COLUMBUS_VIEW;
-            setMorphTime(scene, 0.0);
-
-            this._destroyMorphHandler();
+    SceneTransitioner.prototype.morphToColumbusView = function() {
+        if (typeof this._completeMorph !== 'undefined') {
+            this._completeMorph();
+        }
 
-            updateFrustums(this);
-            var camera = scene.getCamera();
-            camera.transform = this._cameraCV.transform.clone();
+        var currentMode = this._scene.mode;
+        if (currentMode === SceneMode.COLUMBUS_VIEW || currentMode === SceneMode.MORPHING) {
+            return;
+        }
+        this.onTransitionStart.raiseEvent(this, currentMode, SceneMode.COLUMBUS_VIEW, true);
+        this._previousMode = SceneMode.MORPHING;
 
-            if (previousMode !== SceneMode.MORPHING || this._morphCancelled) {
-                this._morphCancelled = false;
+        updateFrustums(this);
+        this._scene.mode = SceneMode.MORPHING;
+        createMorphHandler(this, completeColumbusViewCallback);
 
-                // TODO: Match incoming 2D or 3D position
-                camera.position = this._cameraCV.position.clone();
-                camera.direction = this._cameraCV.direction.clone();
-                camera.up = this._cameraCV.up.clone();
-                camera.right = camera.direction.cross(camera.up);
-            }
+        if (currentMode === SceneMode.SCENE2D) {
+            morphFrom2DToColumbusView(this, this.morphDuration, completeColumbusViewCallback);
+        } else {
+            morphFrom3DToColumbusView(this, this.morphDuration, this._cameraCV, completeColumbusViewCallback);
         }
     };
 
     /**
-     * DOC_TBA
+     * Asynchronously transitions the scene to 3D.
      * @memberof SceneTransitioner
      */
-    SceneTransitioner.prototype.to3D = function() {
-        var scene = this._scene;
-        var previousMode = scene.mode;
-
-        if (scene.mode !== SceneMode.SCENE3D) {
-            scene.mode = SceneMode.SCENE3D;
-            setMorphTime(scene, 1.0);
+    SceneTransitioner.prototype.morphTo3D = function() {
+        if (typeof this._completeMorph !== 'undefined') {
+            this._completeMorph();
+        }
 
-            this._destroyMorphHandler();
+        var scene = this._scene;
+        this._previousMode = scene.mode;
 
-            updateFrustums(this);
-            var camera = scene.getCamera();
-            camera.transform = Matrix4.IDENTITY.clone();
+        if (this._previousMode === SceneMode.SCENE3D || this._previousMode === SceneMode.MORPHING) {
+            return;
+        }
+        this.onTransitionStart.raiseEvent(this, this._previousMode, SceneMode.SCENE3D, true);
+        this._previousMode = SceneMode.MORPHING;
 
-            if (previousMode !== SceneMode.MORPHING || this._morphCancelled) {
-                this._morphCancelled = false;
+        updateFrustums(this);
+        scene.mode = SceneMode.MORPHING;
+        createMorphHandler(this, complete3DCallback);
 
-                // TODO: Match incoming columbus-view or 2D position
-                camera.position = this._camera3D.position.clone();
-                camera.direction = this._camera3D.direction.clone();
-                camera.up = this._camera3D.up.clone();
-            }
+        if (this._previousMode === SceneMode.SCENE2D) {
+            morphFrom2DTo3D(this, this.morphDuration, complete3DCallback);
+        } else {
+            morphFromColumbusViewTo3D(this, this.morphDuration, complete3DCallback);
         }
     };
 
-    SceneTransitioner.prototype._createMorphHandler = function(endMorphFunction) {
-        var that = this;
-
-        if (this.endMorphOnMouseInput) {
-            this._morphHandler = new ScreenSpaceEventHandler(this._scene.getCanvas());
-
-            var cancelMorph = function() {
-                that._morphCancelled = true;
-                endMorphFunction.call(that);
-            };
-            this._morphHandler.setInputAction(cancelMorph, ScreenSpaceEventType.LEFT_DOWN);
-            this._morphHandler.setInputAction(cancelMorph, ScreenSpaceEventType.MIDDLE_DOWN);
-            this._morphHandler.setInputAction(cancelMorph, ScreenSpaceEventType.RIGHT_DOWN);
-            this._morphHandler.setInputAction(cancelMorph, ScreenSpaceEventType.WHEEL);
-        }
+    /**
+     * Returns true if this object was destroyed; otherwise, false.
+     * <br /><br />
+     * If this object was destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
+     * @memberof SceneTransitioner
+     *
+     * @return {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
+     */
+    SceneTransitioner.prototype.isDestroyed = function() {
+        return false;
     };
 
-    SceneTransitioner.prototype._destroyMorphHandler = function() {
-        var animations = this._scene.getAnimations();
-        for ( var i = 0; i < this._currentAnimations.length; ++i) {
-            animations.remove(this._currentAnimations[i]);
-        }
-        this._currentAnimations.length = 0;
-        this._morphHandler = this._morphHandler && this._morphHandler.destroy();
+    /**
+     * Once an object is destroyed, it should not be used; calling any function other than
+     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
+     * assign the return value (<code>undefined</code>) to the object as done in the example.
+     * @memberof SceneTransitioner
+     *
+     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
+     *
+     * @example
+     * transitioner = transitioner && transitioner.destroy();
+     */
+    SceneTransitioner.prototype.destroy = function() {
+        destroyMorphHandler(this);
+        return destroyObject(this);
     };
 
-    SceneTransitioner.prototype._changeCameraTransform = function(camera, transform) {
+    function setCameraTransform(camera, transform) {
         var pos = new Cartesian4(camera.position.x, camera.position.y, camera.position.z, 1.0);
         var dir = new Cartesian4(camera.direction.x, camera.direction.y, camera.direction.z, 0.0);
         var up = new Cartesian4(camera.up.x, camera.up.y, camera.up.z, 0.0);
@@ -345,17 +349,93 @@ define([
         camera.direction = Cartesian3.fromCartesian4(frame.multiplyByVector(dir));
         camera.up = Cartesian3.fromCartesian4(frame.multiplyByVector(up));
         camera.right = camera.direction.cross(camera.up);
-    };
+    }
+
+    function createMorphHandler(transitioner, completeMorphFunction) {
+        if (transitioner.completeMorphOnUserInput) {
+            transitioner._morphHandler = new ScreenSpaceEventHandler(transitioner._scene.getCanvas());
 
-    SceneTransitioner.prototype._columbusViewMorph = function(startPosition, endPosition, time) {
+            var completeMorph = function() {
+                transitioner._morphCancelled = true;
+                completeMorphFunction(transitioner);
+            };
+
+            transitioner._completeMorph = completeMorph;
+            transitioner._morphHandler.setInputAction(completeMorph, ScreenSpaceEventType.LEFT_DOWN);
+            transitioner._morphHandler.setInputAction(completeMorph, ScreenSpaceEventType.MIDDLE_DOWN);
+            transitioner._morphHandler.setInputAction(completeMorph, ScreenSpaceEventType.RIGHT_DOWN);
+            transitioner._morphHandler.setInputAction(completeMorph, ScreenSpaceEventType.WHEEL);
+        }
+    }
+
+    function destroyMorphHandler(transitioner) {
+        var animations = transitioner._scene.getAnimations();
+        for ( var i = 0; i < transitioner._currentAnimations.length; ++i) {
+            animations.remove(transitioner._currentAnimations[i]);
+        }
+        transitioner._currentAnimations.length = 0;
+        transitioner._morphHandler = transitioner._morphHandler && transitioner._morphHandler.destroy();
+    }
+
+    function morphFromColumbusViewTo3D(transitioner, duration, onComplete) {
+        var scene = transitioner._scene;
+
+        var camera = scene.getCamera();
+        setCameraTransform(camera, Matrix4.IDENTITY);
+
+        var startPos = camera.position;
+        var startDir = camera.direction;
+        var startUp = camera.up;
+
+        var maxRadii = transitioner._ellipsoid.getMaximumRadius();
+        var endPos = transitioner._ellipsoid.cartographicToCartesian(new Cartographic(0.0, 0.0, 10.0));
+        endPos = endPos.normalize().multiplyByScalar(2.0 * maxRadii);
+        var endDir = Cartesian3.ZERO.subtract(endPos).normalize();
+        var endRight = endDir.cross(Cartesian3.UNIT_Z).normalize();
+        var endUp = endRight.cross(endDir);
+
+        var update = function(value) {
+            camera.position = columbusViewMorph(startPos, endPos, value.time);
+            camera.direction = columbusViewMorph(startDir, endDir, value.time);
+            camera.up = columbusViewMorph(startUp, endUp, value.time);
+            camera.right = camera.direction.cross(camera.up);
+        };
+
+        var animation = scene.getAnimations().add({
+            duration : duration,
+            easingFunction : Tween.Easing.Quartic.Out,
+            startValue : {
+                time : 0.0
+            },
+            stopValue : {
+                time : 1.0
+            },
+            onUpdate : update
+        });
+        transitioner._currentAnimations.push(animation);
+
+        addMorphTimeAnimations(transitioner, scene, 0.0, 1.0, duration, onComplete);
+    }
+
+    function morphFrom2DTo3D(transitioner, duration, onComplete) {
+        duration = duration * 0.5;
+
+        var camera = transitioner._scene.getCamera();
+
+        morphOrthographicToPerspective(transitioner, duration, function() {
+            camera.frustum = transitioner._cameraCV.frustum.clone();
+            camera.transform = transitioner._cameraCV.transform.clone();
+            morphFromColumbusViewTo3D(transitioner, duration, onComplete);
+        });
+    }
+
+    function columbusViewMorph(startPosition, endPosition, time) {
         // Just linear for now.
         return startPosition.lerp(endPosition, time);
-    };
-
-    SceneTransitioner.prototype._scenePerspectiveToOrthographic = function(duration, onComplete) {
-        var that = this;
+    }
 
-        var scene = this._scene;
+    function morphPerspectiveToOrthographic(transitioner, duration, onComplete) {
+        var scene = transitioner._scene;
         var camera = scene.getCamera();
 
         var startPos = camera.position;
@@ -382,38 +462,36 @@ define([
             },
             onUpdate : update,
             onComplete : function() {
-                camera.frustum = that._camera2D.frustum.clone();
-                onComplete.call(that);
+                camera.frustum = transitioner._camera2D.frustum.clone();
+                onComplete(transitioner);
             }
         });
-        this._currentAnimations.push(animation);
-    };
-
-    SceneTransitioner.prototype._sceneCVTo2D = function(duration, onComplete) {
-        var that = this;
+        transitioner._currentAnimations.push(animation);
+    }
 
-        var scene = this._scene;
+    function morphFromColumbusViewTo2D(transitioner, duration, onComplete) {
+        var scene = transitioner._scene;
         var camera = scene.getCamera();
-        var maxRadii = this._ellipsoid.getMaximumRadius();
+        var maxRadii = transitioner._ellipsoid.getMaximumRadius();
 
-        this._changeCameraTransform(camera, this._cameraCV.transform);
+        setCameraTransform(camera, transitioner._cameraCV.transform);
 
         var startPos = camera.position.clone();
         var startDir = camera.direction.clone();
         var startUp = camera.up.clone();
 
-        var tanPhi = Math.tan(this._cameraCV.frustum.fovy * 0.5);
-        var tanTheta = this._cameraCV.frustum.aspectRatio * tanPhi;
+        var tanPhi = Math.tan(transitioner._cameraCV.frustum.fovy * 0.5);
+        var tanTheta = transitioner._cameraCV.frustum.aspectRatio * tanPhi;
         var d = (maxRadii * Math.PI) / tanTheta;
 
-        var endPos = this._camera2D.position.normalize().multiplyByScalar(d);
-        var endDir = that._camera2D.direction.clone();
-        var endUp = that._camera2D.up.clone();
+        var endPos = transitioner._camera2D.position.normalize().multiplyByScalar(d);
+        var endDir = transitioner._camera2D.direction.clone();
+        var endUp = transitioner._camera2D.up.clone();
 
         var updateCV = function(value) {
-            camera.position = that._columbusViewMorph(startPos, endPos, value.time);
-            camera.direction = that._columbusViewMorph(startDir, endDir, value.time);
-            camera.up = that._columbusViewMorph(startUp, endUp, value.time);
+            camera.position = columbusViewMorph(startPos, endPos, value.time);
+            camera.direction = columbusViewMorph(startDir, endDir, value.time);
+            camera.up = columbusViewMorph(startUp, endUp, value.time);
             camera.right = camera.direction.cross(camera.up);
         };
 
@@ -429,56 +507,54 @@ define([
             },
             onUpdate : updateCV,
             onComplete : function() {
-                that._scenePerspectiveToOrthographic(duration, onComplete);
+                morphPerspectiveToOrthographic(transitioner, duration, onComplete);
             }
         });
-        this._currentAnimations.push(animation);
-    };
+        transitioner._currentAnimations.push(animation);
+    }
 
-    SceneTransitioner.prototype._scene3DTo2D = function(duration, onComplete) {
+    function morphFrom3DTo2D(transitioner, duration, onComplete) {
         duration = duration * 0.5;
 
-        var maxRadii = this._ellipsoid.getMaximumRadius();
+        var maxRadii = transitioner._ellipsoid.getMaximumRadius();
 
-        var tanPhi = Math.tan(this._camera3D.frustum.fovy * 0.5);
-        var tanTheta = this._camera3D.frustum.aspectRatio * tanPhi;
+        var tanPhi = Math.tan(transitioner._camera3D.frustum.fovy * 0.5);
+        var tanTheta = transitioner._camera3D.frustum.aspectRatio * tanPhi;
         var d = (maxRadii * Math.PI) / tanTheta;
 
         var camera3DTo2D = {};
-        camera3DTo2D.position = this._camera2D.position.normalize().multiplyByScalar(d);
-        camera3DTo2D.direction = this._camera2D.direction.clone();
-        camera3DTo2D.up = this._camera2D.up.clone();
+        camera3DTo2D.position = transitioner._camera2D.position.normalize().multiplyByScalar(d);
+        camera3DTo2D.direction = transitioner._camera2D.direction.clone();
+        camera3DTo2D.up = transitioner._camera2D.up.clone();
 
         var complete = function() {
-            this._scenePerspectiveToOrthographic(duration, onComplete);
+            morphPerspectiveToOrthographic(transitioner, duration, onComplete);
         };
-        this._scene3DToCV(duration, camera3DTo2D, complete);
-    };
-
-    SceneTransitioner.prototype._sceneOrthographicToPerspective = function(duration, onComplete) {
-        var that = this;
+        morphFrom3DToColumbusView(transitioner, duration, camera3DTo2D, complete);
+    }
 
-        var scene = this._scene;
+    function morphOrthographicToPerspective(transitioner, duration, onComplete) {
+        var scene = transitioner._scene;
         var camera = scene.getCamera();
-        var maxRadii = this._ellipsoid.getMaximumRadius();
+        var maxRadii = transitioner._ellipsoid.getMaximumRadius();
 
-        var tanPhi = Math.tan(this._cameraCV.frustum.fovy * 0.5);
-        var tanTheta = this._cameraCV.frustum.aspectRatio * tanPhi;
+        var tanPhi = Math.tan(transitioner._cameraCV.frustum.fovy * 0.5);
+        var tanTheta = transitioner._cameraCV.frustum.aspectRatio * tanPhi;
         var d = (maxRadii * Math.PI) / tanTheta;
-        var endPos2D = this._camera2D.position.normalize().multiplyByScalar(d);
+        var endPos2D = transitioner._camera2D.position.normalize().multiplyByScalar(d);
 
         var top = camera.frustum.top;
         var bottom = camera.frustum.bottom;
         var right = camera.frustum.right;
         var left = camera.frustum.left;
 
-        var frustum2D = this._camera2D.frustum;
-        var frustumCV = this._cameraCV.frustum;
+        var frustum2D = transitioner._camera2D.frustum;
+        var frustumCV = transitioner._cameraCV.frustum;
 
         var startPos = camera.position.clone();
 
         var update2D = function(value) {
-            camera.position = that._columbusViewMorph(startPos, endPos2D, value.time);
+            camera.position = columbusViewMorph(startPos, endPos2D, value.time);
             camera.frustum.top = CesiumMath.lerp(top, frustum2D.top, value.time);
             camera.frustum.bottom = CesiumMath.lerp(bottom, frustum2D.bottom, value.time);
             camera.frustum.right = CesiumMath.lerp(right, frustum2D.right, value.time);
@@ -502,7 +578,7 @@ define([
                 // a perspective projection, nothing needs to be animated.
                 camera.position = endPos2D;
                 camera.frustum = frustumCV.clone();
-                onComplete.call(that);
+                onComplete(transitioner);
                 return;
             }
         }
@@ -519,16 +595,14 @@ define([
             onUpdate : update2D,
             onComplete : function() {
                 camera.frustum = frustumCV.clone();
-                onComplete.call(that);
+                onComplete(transitioner);
             }
         });
-        this._currentAnimations.push(animation);
-    };
-
-    SceneTransitioner.prototype._scene2DToCV = function(duration, onComplete) {
-        var that = this;
+        transitioner._currentAnimations.push(animation);
+    }
 
-        var scene = this._scene;
+    function morphFrom2DToColumbusView(transitioner, duration, onComplete) {
+        var scene = transitioner._scene;
         var camera = scene.getCamera();
 
         duration = duration * 0.5;
@@ -538,14 +612,14 @@ define([
             var startDir = camera.direction.clone();
             var startUp = camera.up.clone();
 
-            var endPos = that._cameraCV.position.clone();
-            var endDir = that._cameraCV.direction.clone();
-            var endUp = that._cameraCV.up.clone();
+            var endPos = transitioner._cameraCV.position.clone();
+            var endDir = transitioner._cameraCV.direction.clone();
+            var endUp = transitioner._cameraCV.up.clone();
 
             var updateCV = function(value) {
-                camera.position = that._columbusViewMorph(startPos, endPos, value.time);
-                camera.direction = that._columbusViewMorph(startDir, endDir, value.time);
-                camera.up = that._columbusViewMorph(startUp, endUp, value.time);
+                camera.position = columbusViewMorph(startPos, endPos, value.time);
+                camera.direction = columbusViewMorph(startDir, endDir, value.time);
+                camera.up = columbusViewMorph(startUp, endUp, value.time);
                 camera.right = camera.direction.cross(camera.up);
             };
 
@@ -560,23 +634,21 @@ define([
                 },
                 onUpdate : updateCV,
                 onComplete : function() {
-                    onComplete.call(that);
+                    onComplete(transitioner);
                 }
             });
 
-            that._currentAnimations.push(animation);
+            transitioner._currentAnimations.push(animation);
         };
 
-        this._sceneOrthographicToPerspective(duration, completeFrustumChange);
-    };
-
-    SceneTransitioner.prototype._scene3DToCV = function(duration, endCamera, onComplete) {
-        var that = this;
+        morphOrthographicToPerspective(transitioner, duration, completeFrustumChange);
+    }
 
-        var scene = this._scene;
+    function morphFrom3DToColumbusView(transitioner, duration, endCamera, onComplete) {
+        var scene = transitioner._scene;
 
         var camera = scene.getCamera();
-        this._changeCameraTransform(camera, this._cameraCV.transform);
+        setCameraTransform(camera, transitioner._cameraCV.transform);
 
         var startPos = camera.position.clone();
         var startDir = camera.direction.clone();
@@ -587,9 +659,9 @@ define([
         var endUp = endCamera.up.clone();
 
         var update = function(value) {
-            camera.position = that._columbusViewMorph(startPos, endPos, value.time);
-            camera.direction = that._columbusViewMorph(startDir, endDir, value.time);
-            camera.up = that._columbusViewMorph(startUp, endUp, value.time);
+            camera.position = columbusViewMorph(startPos, endPos, value.time);
+            camera.direction = columbusViewMorph(startDir, endDir, value.time);
+            camera.up = columbusViewMorph(startUp, endUp, value.time);
             camera.right = camera.direction.cross(camera.up);
         };
 
@@ -609,168 +681,182 @@ define([
                 camera.up = endUp;
             }
         });
-        this._currentAnimations.push(animation);
+        transitioner._currentAnimations.push(animation);
 
-        addMorphTimeAnimations(this, scene, 1.0, 0.0, duration, onComplete);
-    };
+        addMorphTimeAnimations(transitioner, scene, 1.0, 0.0, duration, onComplete);
+    }
 
-    SceneTransitioner.prototype._scene2DTo3D = function(duration, onComplete) {
-        duration = duration * 0.5;
+    //immediately set the morph time of all objects in the scene
+    function setMorphTime(scene, morphTime) {
+        scene.morphTime = morphTime;
 
-        var camera = this._scene.getCamera();
+        var primitives = scene.getPrimitives();
+        for ( var i = 0, len = primitives.getLength(); i < len; i++) {
+            var primitive = primitives.get(i);
+            if (typeof primitive.morphTime !== 'undefined') {
+                primitive.morphTime = morphTime;
+            }
+        }
 
-        this._sceneOrthographicToPerspective(duration, function() {
-            camera.frustum = this._cameraCV.frustum.clone();
-            camera.transform = this._cameraCV.transform.clone();
-            this._sceneCVTo3D(duration, onComplete);
-        });
-    };
+        var centralBody = primitives.getCentralBody();
+        centralBody.morphTime = morphTime;
 
-    SceneTransitioner.prototype._sceneCVTo3D = function(duration, onComplete) {
-        var scene = this._scene;
+        if (typeof scene.skyBox !== 'undefined') {
+            scene.skyBox.morphTime = morphTime;
+        }
 
-        var that = this;
+        if (typeof scene.skyAtmosphere !== 'undefined') {
+            scene.skyAtmosphere.morphTime = morphTime;
+        }
+    }
 
-        var camera = scene.getCamera();
-        this._changeCameraTransform(camera, Matrix4.IDENTITY);
+    //in the future the animations will be more complicated
+    function addMorphTimeAnimations(transitioner, scene, start, stop, duration, onComplete) {
+        //for now, all objects morph at the same rate
+        var template = {
+            duration : duration,
+            easingFunction : Tween.Easing.Quartic.Out
+        };
 
-        var startPos = camera.position;
-        var startDir = camera.direction;
-        var startUp = camera.up;
+        var primitives = scene.getPrimitives();
+        var sceneAnimations = scene.getAnimations();
+        var animation;
+        for ( var i = 0, len = primitives.getLength(); i < len; i++) {
+            var primitive = primitives.get(i);
+            if (typeof primitive.morphTime !== 'undefined') {
+                animation = sceneAnimations.addProperty(primitive, 'morphTime', start, stop, template);
+                transitioner._currentAnimations.push(animation);
+            }
+        }
 
-        var maxRadii = this._ellipsoid.getMaximumRadius();
-        var endPos = this._ellipsoid.cartographicToCartesian(new Cartographic(0.0, 0.0, 10.0));
-        endPos = endPos.normalize().multiplyByScalar(2.0 * maxRadii);
-        var endDir = Cartesian3.ZERO.subtract(endPos).normalize();
-        var endRight = endDir.cross(Cartesian3.UNIT_Z).normalize();
-        var endUp = endRight.cross(endDir);
+        var centralBody = primitives.getCentralBody();
+        animation = sceneAnimations.addProperty(centralBody, 'morphTime', start, stop, template);
+        transitioner._currentAnimations.push(animation);
 
-        var update = function(value) {
-            camera.position = that._columbusViewMorph(startPos, endPos, value.time);
-            camera.direction = that._columbusViewMorph(startDir, endDir, value.time);
-            camera.up = that._columbusViewMorph(startUp, endUp, value.time);
-            camera.right = camera.direction.cross(camera.up);
-        };
+        if (typeof scene.skyBox !== 'undefined') {
+            animation = sceneAnimations.addProperty(scene.skyBox, 'morphTime', start, stop, template);
+            transitioner._currentAnimations.push(animation);
+        }
 
-        var animation = scene.getAnimations().add({
-            duration : duration,
-            easingFunction : Tween.Easing.Quartic.Out,
-            startValue : {
-                time : 0.0
-            },
-            stopValue : {
-                time : 1.0
-            },
-            onUpdate : update
-        });
-        this._currentAnimations.push(animation);
+        if (typeof scene.skyAtmosphere !== 'undefined') {
+            animation = sceneAnimations.addProperty(scene.skyAtmosphere, 'morphTime', start, stop, template);
+            transitioner._currentAnimations.push(animation);
+        }
 
-        addMorphTimeAnimations(this, scene, 0.0, 1.0, duration, onComplete);
-    };
+        if (typeof onComplete !== 'undefined') {
+            template.onComplete = function() {
+                onComplete(transitioner);
+            };
+        }
 
-    /**
-     * DOC_TBA
-     * @memberof SceneTransitioner
-     */
-    SceneTransitioner.prototype.morphTo2D = function() {
-        var previousMode = this._scene.mode;
+        animation = sceneAnimations.addProperty(scene, 'morphTime', start, stop, template);
+        transitioner._currentAnimations.push(animation);
+    }
 
-        if (previousMode === SceneMode.SCENE2D || previousMode === SceneMode.MORPHING) {
-            return;
-        }
+    function updateFrustums(transitioner) {
+        var scene = transitioner._scene;
 
-        updateFrustums(this);
-        this._scene.mode = SceneMode.MORPHING;
-        this._createMorphHandler(this.to2D);
+        var canvas = scene.getCanvas();
+        var ratio = canvas.clientHeight / canvas.clientWidth;
 
-        if (previousMode === SceneMode.COLUMBUS_VIEW) {
-            this._sceneCVTo2D(this.morphDuration2D, this.to2D);
-        } else {
-            this._scene3DTo2D(this.morphDuration2D, this.to2D);
-        }
-    };
+        var frustum = transitioner._camera2D.frustum;
+        frustum.top = frustum.right * ratio;
+        frustum.bottom = -frustum.top;
 
-    /**
-     * DOC_TBA
-     * @memberof SceneTransitioner
-     */
-    SceneTransitioner.prototype.morphToColumbusView = function() {
-        var previousMode = this._scene.mode;
+        ratio = 1.0 / ratio;
 
-        if (previousMode === SceneMode.COLUMBUS_VIEW || previousMode === SceneMode.MORPHING) {
-            return;
-        }
+        frustum = transitioner._cameraCV.frustum;
+        frustum.aspectRatio = ratio;
 
-        updateFrustums(this);
-        this._scene.mode = SceneMode.MORPHING;
-        this._createMorphHandler(this.toColumbusView);
+        frustum = transitioner._camera3D.frustum;
+        frustum.aspectRatio = ratio;
 
-        if (previousMode === SceneMode.SCENE2D) {
-            this._scene2DToCV(this.morphDurationColumbusView, this.toColumbusView);
-        } else {
-            this._scene3DToCV(this.morphDurationColumbusView, this._cameraCV, this.toColumbusView);
+        var camera = scene.getCamera();
+        switch (scene.mode) {
+        case SceneMode.SCENE3D:
+            camera.frustum = transitioner._camera3D.frustum.clone();
+            break;
+        case SceneMode.COLUMBUS_VIEW:
+            camera.frustum = transitioner._cameraCV.frustum.clone();
+            break;
+        case SceneMode.SCENE2D:
+            camera.frustum = transitioner._camera2D.frustum.clone();
+            break;
         }
-    };
+    }
 
-    /**
-     * DOC_TBA
-     * @memberof SceneTransitioner
-     */
-    SceneTransitioner.prototype.morphTo3D = function() {
-        var scene = this._scene;
-        var previousMode = scene.mode;
+    function complete3DCallback(transitioner) {
+        var scene = transitioner._scene;
+        scene.mode = SceneMode.SCENE3D;
+        setMorphTime(scene, 1.0);
 
-        if (previousMode === SceneMode.SCENE3D || previousMode === SceneMode.MORPHING) {
-            return;
-        }
+        destroyMorphHandler(transitioner);
 
-        updateFrustums(this);
-        scene.mode = SceneMode.MORPHING;
-        this._createMorphHandler(this.to3D);
+        updateFrustums(transitioner);
+        var camera = scene.getCamera();
+        camera.transform = Matrix4.IDENTITY.clone();
 
-        if (previousMode === SceneMode.SCENE2D) {
-            this._scene2DTo3D(this.morphDuration3D, this.to3D);
-        } else {
-            this._sceneCVTo3D(this.morphDuration3D, this.to3D);
+        if (transitioner._previousMode !== SceneMode.MORPHING || transitioner._morphCancelled) {
+            transitioner._morphCancelled = false;
+
+            // TODO: Match incoming columbus-view or 2D position
+            camera.position = transitioner._camera3D.position.clone();
+            camera.direction = transitioner._camera3D.direction.clone();
+            camera.up = transitioner._camera3D.up.clone();
         }
-    };
 
-    /**
-     * Returns true if this object was destroyed; otherwise, false.
-     * <br /><br />
-     * If this object was destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
-     *
-     * @memberof SceneTransitioner
-     *
-     * @return {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
-     *
-     * @see SceneTransitioner#destroy
-     */
-    SceneTransitioner.prototype.isDestroyed = function() {
-        return false;
-    };
+        var wasMorphing = typeof transitioner._completeMorph !== 'undefined';
+        transitioner._completeMorph = undefined;
+        transitioner.onTransitionComplete.raiseEvent(transitioner, transitioner._previousMode, SceneMode.SCENE3D, wasMorphing);
+    }
 
-    /**
-     * Once an object is destroyed, it should not be used; calling any function other than
-     * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.  Therefore,
-     * assign the return value (<code>undefined</code>) to the object as done in the example.
-     *
-     * @memberof SceneTransitioner
-     *
-     * @return {undefined}
-     *
-     * @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
-     *
-     * @see SceneTransitioner#isDestroyed
-     *
-     * @example
-     * transitioner = transitioner && transitioner.destroy();
-     */
-    SceneTransitioner.prototype.destroy = function() {
-        this._destroyMorphHandler();
-        return destroyObject(this);
-    };
+    function complete2DCallback(transitioner) {
+        var scene = transitioner._scene;
+
+        scene.mode = SceneMode.SCENE2D;
+        setMorphTime(scene, 0.0);
+
+        destroyMorphHandler(transitioner);
+
+        updateFrustums(transitioner);
+        var camera = scene.getCamera();
+        camera.transform = transitioner._camera2D.transform.clone();
+
+        // TODO: Match incoming columbus-view or 3D position
+        camera.position = transitioner._camera2D.position.clone();
+        camera.direction = transitioner._camera2D.direction.clone();
+        camera.up = transitioner._camera2D.up.clone();
+
+        var wasMorphing = typeof transitioner._completeMorph !== 'undefined';
+        transitioner._completeMorph = undefined;
+        transitioner.onTransitionComplete.raiseEvent(transitioner, transitioner._previousMode, SceneMode.SCENE2D, wasMorphing);
+    }
+
+    function completeColumbusViewCallback(transitioner) {
+        var scene = transitioner._scene;
+        scene.mode = SceneMode.COLUMBUS_VIEW;
+        setMorphTime(scene, 0.0);
+
+        destroyMorphHandler(transitioner);
+
+        updateFrustums(transitioner);
+        var camera = scene.getCamera();
+        camera.transform = transitioner._cameraCV.transform.clone();
+
+        if (transitioner._previousModeMode !== SceneMode.MORPHING || transitioner._morphCancelled) {
+            transitioner._morphCancelled = false;
+
+            // TODO: Match incoming 2D or 3D position
+            camera.position = transitioner._cameraCV.position.clone();
+            camera.direction = transitioner._cameraCV.direction.clone();
+            camera.up = transitioner._cameraCV.up.clone();
+            camera.right = camera.direction.cross(camera.up);
+        }
+
+        var wasMorphing = typeof transitioner._completeMorph !== 'undefined';
+        transitioner._completeMorph = undefined;
+        transitioner.onTransitionComplete.raiseEvent(transitioner, transitioner._previousMode, SceneMode.COLUMBUS_VIEW, wasMorphing);
+    }
 
     return SceneTransitioner;
 });