cesium 0.22.0 → 0.23.0

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

@@ -1,5 +1,5 @@
 /*global define*/
-define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/HermiteSpline', 'Core/Math', 'Core/Matrix3', 'Core/OrientationInterpolator', 'Core/Quaternion', 'Scene/PerspectiveFrustum', 'Scene/PerspectiveOffCenterFrustum', 'Scene/SceneMode', 'ThirdParty/Tween'], function(
+define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/HermiteSpline', 'Core/Math', 'Core/Matrix3', 'Core/Quaternion', 'Core/QuaternionSpline', 'Scene/PerspectiveFrustum', 'Scene/PerspectiveOffCenterFrustum', 'Scene/SceneMode', 'ThirdParty/Tween'], function(
         Cartesian2,
         Cartesian3,
         clone,
@@ -9,8 +9,8 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
         HermiteSpline,
         CesiumMath,
         Matrix3,
-        OrientationInterpolator,
         Quaternion,
+        QuaternionSpline,
         PerspectiveFrustum,
         PerspectiveOffCenterFrustum,
         SceneMode,
@@ -69,28 +69,6 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
         return Math.max(dx, dy);
     }
 
-    function createSpline(points) {
-        if (points.length > 2) {
-            return new HermiteSpline(points);
-        }
-
-        // only two points, use linear interpolation
-        var p = points[0];
-        var q = points[1];
-
-        return {
-            getControlPoints : function() {
-                return points;
-            },
-
-            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, result);
-            }
-        };
-    }
-
     function createPath3D(camera, ellipsoid, start, end, duration) {
         // get minimum altitude from which the whole ellipsoid is visible
         var radius = ellipsoid.getMaximumRadius();
@@ -120,28 +98,12 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
         var axis, angle, rotation, middle;
         if (Cartesian3.magnitude(end) > maxStartAlt && dot > 0.75) {
             middle = Cartesian3.add(Cartesian3.multiplyByScalar(Cartesian3.subtract(start, end), 0.5), end);
-
-            points = [{
-                point : start
-            }, {
-                point : middle
-            }, {
-                point : end
-            }];
+            points = [ start, middle, end ];
         } else if (Cartesian3.magnitude(start) > maxStartAlt && dot > 0) {
             middle = Cartesian3.add(Cartesian3.multiplyByScalar(Cartesian3.subtract(start, aboveEnd), 0.5), aboveEnd);
-
-            points = [{
-                point : start
-            }, {
-                point : middle
-            }, {
-                point : end
-            }];
+            points = [ start, middle, end ];
         } else {
-            points = [{
-                point : start
-            }];
+            points = [ start ];
 
             angle = Math.acos(Cartesian3.dot(Cartesian3.normalize(afterStart), Cartesian3.normalize(aboveEnd)));
             axis = Cartesian3.cross(aboveEnd, afterStart);
@@ -153,50 +115,58 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
             var startCondition = angle - increment;
             for ( var i = startCondition; i > 0.0; i = i - increment) {
                 rotation = Matrix3.fromQuaternion(Quaternion.fromAxisAngle(axis, i));
-                points.push({
-                    point : Matrix3.multiplyByVector(rotation, aboveEnd)
-                });
+                points.push(Matrix3.multiplyByVector(rotation, aboveEnd));
             }
 
-            points.push({
-                point : end
-            });
+            points.push(end);
         }
 
+        var times = new Array(points.length);
         var scalar = duration / (points.length - 1);
         for ( var k = 0; k < points.length; ++k) {
-            points[k].time = k * scalar;
+            times[k] = k * scalar;
         }
 
-        return createSpline(points);
+        return new HermiteSpline({
+            points : points,
+            times : times
+        });
     }
+
     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);
+
+    function createOrientations3D(camera, path, endDirection, endUp) {
+        var points = path.points;
+        var orientations = new Array(points.length);
+        orientations[0] = createQuaternion(camera.direction, camera.up);
+
         var point;
         var length = points.length - 1;
         for (var i = 1; i < length; ++i) {
             point = points[i];
-            Cartesian3.normalize(Cartesian3.negate(point.point, direction3D), direction3D);
+            Cartesian3.normalize(Cartesian3.negate(point, direction3D), direction3D);
             Cartesian3.normalize(Cartesian3.cross(direction3D, Cartesian3.UNIT_Z, right3D), right3D);
             Cartesian3.cross(right3D, direction3D, up3D);
-            point.orientation = createQuaternion(direction3D, up3D, quat3D);
+            orientations[i] = createQuaternion(direction3D, up3D, quat3D);
         }
 
         point = points[length];
         if (defined(endDirection) && defined(endUp)) {
-            point.orientation = createQuaternion(endDirection, endUp);
+            orientations[length] = createQuaternion(endDirection, endUp);
         } else {
-            Cartesian3.normalize(Cartesian3.negate(point.point, direction3D), direction3D);
+            Cartesian3.normalize(Cartesian3.negate(point, direction3D), direction3D);
             Cartesian3.normalize(Cartesian3.cross(direction3D, Cartesian3.UNIT_Z, right3D), right3D);
             Cartesian3.cross(right3D, direction3D, up3D);
-            point.orientation = createQuaternion(direction3D, up3D, quat3D);
+            orientations[length] = createQuaternion(direction3D, up3D, quat3D);
         }
 
-        return new OrientationInterpolator(points);
+        return new QuaternionSpline({
+            points : orientations,
+            times : path.times
+        });
     }
 
     function createUpdate3D(frameState, destination, duration, direction, up) {
@@ -204,14 +174,14 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
         var ellipsoid = frameState.scene2D.projection.getEllipsoid();
 
         var path = createPath3D(camera, ellipsoid, camera.position, destination, duration);
-        var orientations = createOrientations3D(camera, path.getControlPoints(), direction, up);
+        var orientations = createOrientations3D(camera, path, direction, up);
 
         var update = function(value) {
             var time = value.time;
             var orientation = orientations.evaluate(time);
             Matrix3.fromQuaternion(orientation, rotMatrix);
 
-            camera.position = path.evaluate(time, camera.position);
+            camera.position = path.evaluate(time);
             camera.right = Matrix3.getRow(rotMatrix, 0, camera.right);
             camera.up = Matrix3.getRow(rotMatrix, 1, camera.up);
             camera.direction = Cartesian3.negate(Matrix3.getRow(rotMatrix, 2, camera.direction), camera.direction);
@@ -244,28 +214,12 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
         var middle;
         if (end.z > maxStartAlt) {
             middle = Cartesian3.add(Cartesian3.multiplyByScalar(Cartesian3.subtract(start, end), 0.5), end);
-
-            points = [{
-                point : start
-            }, {
-                point : middle
-            }, {
-                point : end
-            }];
+            points = [ start, middle, end ];
         } else if (start.z > maxStartAlt) {
             middle = Cartesian3.add(Cartesian3.multiplyByScalar(Cartesian3.subtract(start, aboveEnd), 0.5), aboveEnd);
-
-            points = [{
-                point : start
-            }, {
-                point : middle
-            }, {
-                point : end
-            }];
+            points = [ start, middle, end ];
         } else {
-            points = [{
-                point : start
-            }];
+            points = [ start ];
 
             var v = Cartesian3.subtract(afterStart, aboveEnd);
             var distance = Cartesian3.magnitude(v);
@@ -274,45 +228,49 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
             var increment = incrementPercentage * distance;
             var startCondition = distance - increment;
             for ( var i = startCondition; i > 0.0; i = i - increment) {
-                points.push({
-                    point : Cartesian3.add(Cartesian3.multiplyByScalar(v, i), aboveEnd)
-                });
+                points.push(Cartesian3.add(Cartesian3.multiplyByScalar(v, i), aboveEnd));
             }
 
-            points.push({
-                point : end
-            });
+            points.push(end);
         }
 
+        var times = new Array(points.length);
         var scalar = duration / (points.length - 1);
         for ( var k = 0; k < points.length; ++k) {
-            points[k].time = k * scalar;
+            times[k] = k * scalar;
         }
 
-        return createSpline(points);
+        return new HermiteSpline({
+            points : points,
+            times : times
+        });
     }
 
     var direction2D = Cartesian3.negate(Cartesian3.UNIT_Z);
     var right2D = Cartesian3.normalize(Cartesian3.cross(direction2D, Cartesian3.UNIT_Y));
     var up2D = Cartesian3.cross(right2D, direction2D);
     var quat = createQuaternion(direction2D, up2D);
-    function createOrientations2D(camera, points, endDirection, endUp) {
-        points[0].orientation = createQuaternion(camera.direction, camera.up);
-        var point;
+
+    function createOrientations2D(camera, path, endDirection, endUp) {
+        var points = path.points;
+        var orientations = new Array(points.length);
+        orientations[0] = createQuaternion(camera.direction, camera.up);
+
         var length = points.length - 1;
         for (var i = 1; i < length; ++i) {
-            point = points[i];
-            point.orientation = quat;
+            orientations[i] = quat;
         }
 
-        point = points[length];
         if (defined(endDirection) && defined(endUp)) {
-            point.orientation = createQuaternion(endDirection, endUp);
+            orientations[length] = createQuaternion(endDirection, endUp);
         } else {
-            point.orientation = quat;
+            orientations[length] = quat;
         }
 
-        return new OrientationInterpolator(points);
+        return new QuaternionSpline({
+            points : orientations,
+            times : path.times
+        });
     }
 
     function createUpdateCV(frameState, destination, duration, direction, up) {
@@ -320,7 +278,7 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
         var ellipsoid = frameState.scene2D.projection.getEllipsoid();
 
         var path = createPath2D(camera, ellipsoid, Cartesian3.clone(camera.position), destination, duration);
-        var orientations = createOrientations2D(camera, path.getControlPoints(), direction, up);
+        var orientations = createOrientations2D(camera, path, direction, up);
 
         var update = function(value) {
             var time = value.time;
@@ -344,8 +302,7 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
         start.z = camera.frustum.right - camera.frustum.left;
 
         var path = createPath2D(camera, ellipsoid, start, destination, duration);
-        var points = path.getControlPoints();
-        var orientations = createOrientations2D(camera, points, Cartesian3.negate(Cartesian3.UNIT_Z), up);
+        var orientations = createOrientations2D(camera, path, Cartesian3.negate(Cartesian3.UNIT_Z), up);
 
         var height = camera.position.z;
 
@@ -354,7 +311,7 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
             var orientation = orientations.evaluate(time);
             Matrix3.fromQuaternion(orientation, rotMatrix);
 
-            camera.position = path.evaluate(time, camera.position);
+            camera.position = path.evaluate(time);
             var zoom = camera.position.z;
             camera.position.z = height;
 

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

@@ -1,5 +1,5 @@
 /*global define*/
-define(['Core/buildModuleUrl', 'Core/combine', 'Core/loadImage', 'Core/defaultValue', 'Core/defined', 'Core/destroyObject', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/ComponentDatatype', 'Core/Ellipsoid', 'Core/Extent', 'Core/FeatureDetection', 'Core/GeographicProjection', 'Core/Geometry', 'Core/GeometryAttribute', 'Core/Intersect', 'Core/Math', 'Core/Matrix4', 'Core/Occluder', 'Core/PrimitiveType', 'Core/Transforms', 'Renderer/BufferUsage', 'Renderer/ClearCommand', 'Renderer/CommandLists', 'Renderer/DepthFunction', 'Renderer/DrawCommand', 'Renderer/createShaderSource', 'Scene/CentralBodySurface', 'Scene/CentralBodySurfaceShaderSet', 'Scene/CreditDisplay', 'Scene/EllipsoidTerrainProvider', 'Scene/ImageryLayerCollection', 'Scene/Material', 'Scene/SceneMode', 'Scene/TerrainProvider', 'Scene/ViewportQuad', 'Shaders/CentralBodyFS', 'Shaders/CentralBodyFSDepth', 'Shaders/CentralBodyFSPole', 'Shaders/CentralBodyVS', 'Shaders/CentralBodyVSDepth', 'Shaders/CentralBodyVSPole', 'ThirdParty/when'], function(
+define(['Core/buildModuleUrl', 'Core/combine', 'Core/loadImage', 'Core/defaultValue', 'Core/defined', 'Core/destroyObject', 'Core/BoundingRectangle', 'Core/BoundingSphere', 'Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartographic', 'Core/ComponentDatatype', 'Core/Ellipsoid', 'Core/Extent', 'Core/FeatureDetection', 'Core/GeographicProjection', 'Core/Geometry', 'Core/GeometryAttribute', 'Core/Intersect', 'Core/Math', 'Core/Matrix4', 'Core/Occluder', 'Core/PrimitiveType', 'Core/Transforms', 'Renderer/BufferUsage', 'Renderer/ClearCommand', 'Renderer/CommandLists', 'Renderer/DepthFunction', 'Renderer/DrawCommand', 'Renderer/createShaderSource', 'Scene/CentralBodySurface', 'Scene/CentralBodySurfaceShaderSet', 'Scene/EllipsoidTerrainProvider', 'Scene/ImageryLayerCollection', 'Scene/SceneMode', 'Scene/TerrainProvider', 'Shaders/CentralBodyFS', 'Shaders/CentralBodyFSDepth', 'Shaders/CentralBodyFSPole', 'Shaders/CentralBodyVS', 'Shaders/CentralBodyVSDepth', 'Shaders/CentralBodyVSPole', 'ThirdParty/when'], function(
         buildModuleUrl,
         combine,
         loadImage,
@@ -32,13 +32,10 @@ define(['Core/buildModuleUrl', 'Core/combine', 'Core/loadImage', 'Core/defaultVa
         createShaderSource,
         CentralBodySurface,
         CentralBodySurfaceShaderSet,
-        CreditDisplay,
         EllipsoidTerrainProvider,
         ImageryLayerCollection,
-        Material,
         SceneMode,
         TerrainProvider,
-        ViewportQuad,
         CentralBodyFS,
         CentralBodyFSDepth,
         CentralBodyFSPole,

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

@@ -1,5 +1,5 @@
 /*global define*/
-define(['Core/defaultValue', 'Core/defined', 'Core/destroyObject', 'Core/BoundingSphere', 'Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/FeatureDetection', 'Core/DeveloperError', 'Core/Ellipsoid', 'Core/EllipsoidalOccluder', 'Core/Intersect', 'Core/Matrix4', 'Core/PrimitiveType', 'Core/Queue', 'Core/WebMercatorProjection', 'Renderer/DrawCommand', 'Scene/ImageryLayer', 'Scene/ImageryState', 'Scene/SceneMode', 'Scene/TerrainProvider', 'Scene/TileReplacementQueue', 'Scene/TileState', 'ThirdParty/when'], function(
+define(['Core/defaultValue', 'Core/defined', 'Core/destroyObject', 'Core/BoundingSphere', 'Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/FeatureDetection', 'Core/DeveloperError', 'Core/EllipsoidalOccluder', 'Core/Intersect', 'Core/Matrix4', 'Core/PrimitiveType', 'Core/Queue', 'Core/WebMercatorProjection', 'Renderer/DrawCommand', 'Scene/ImageryLayer', 'Scene/ImageryState', 'Scene/SceneMode', 'Scene/TerrainProvider', 'Scene/TileReplacementQueue', 'Scene/TileState', 'ThirdParty/when'], function(
         defaultValue,
         defined,
         destroyObject,
@@ -9,7 +9,6 @@ define(['Core/defaultValue', 'Core/defined', 'Core/destroyObject', 'Core/Boundin
         Cartesian4,
         FeatureDetection,
         DeveloperError,
-        Ellipsoid,
         EllipsoidalOccluder,
         Intersect,
         Matrix4,

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

@@ -1,10 +1,9 @@
 /*global define*/
-define(['Core/defaultValue', 'Core/defined', 'Core/loadArrayBuffer', 'Core/throttleRequestByServer', 'Core/writeTextToCanvas', 'Core/DeveloperError', 'Core/Event', 'Scene/Credit', 'Scene/GeographicTilingScheme', 'Scene/HeightmapTerrainData', 'Scene/TerrainProvider', 'ThirdParty/when'], function(
+define(['Core/defaultValue', 'Core/defined', 'Core/loadArrayBuffer', 'Core/throttleRequestByServer', 'Core/DeveloperError', 'Core/Event', 'Scene/Credit', 'Scene/GeographicTilingScheme', 'Scene/HeightmapTerrainData', 'Scene/TerrainProvider', 'ThirdParty/when'], function(
         defaultValue,
         defined,
         loadArrayBuffer,
         throttleRequestByServer,
-        writeTextToCanvas,
         DeveloperError,
         Event,
         Credit,

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

@@ -49,8 +49,11 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Color'
         this._pickCommand = new DrawCommand();
         this._commandLists = new CommandLists();
 
+        this._boundingSphere = new BoundingSphere();
+        this._boundingSphereWC = new BoundingSphere();
+
         this._frontFaceColorCommand.primitiveType = PrimitiveType.TRIANGLES;
-        this._frontFaceColorCommand.boundingVolume = new BoundingSphere();
+        this._frontFaceColorCommand.boundingVolume = this._boundingSphereWC;
         this._frontFaceColorCommand.owner = this;
 
         this._backFaceColorCommand.primitiveType = this._frontFaceColorCommand.primitiveType;
@@ -117,6 +120,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Color'
          * sensor.modelMatrix = Transforms.eastNorthUpToFixedFrame(center);
          */
         this.modelMatrix = Matrix4.clone(defaultValue(options.modelMatrix, Matrix4.IDENTITY));
+        this._modelMatrix = new Matrix4();
 
         /**
          * DOC_TBA
@@ -268,7 +272,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Color'
             boundingVolumePositions.push(p);
         }
 
-        BoundingSphere.fromPoints(boundingVolumePositions, customSensorVolume._frontFaceColorCommand.boundingVolume);
+        BoundingSphere.fromPoints(boundingVolumePositions, customSensorVolume._boundingSphere);
 
         return positions;
     }
@@ -423,7 +427,8 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Color'
         }
 
         // Recreate vertex buffer when directions change
-        if ((this._directionsDirty) || (this._bufferUsage !== this.bufferUsage)) {
+        var directionsChanged = this._directionsDirty || (this._bufferUsage !== this.bufferUsage);
+        if (directionsChanged) {
             this._directionsDirty = false;
             this._bufferUsage = this.bufferUsage;
             this._va = this._va && this._va.destroy();
@@ -443,6 +448,15 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Color'
         var pass = frameState.passes;
         this._commandLists.removeAll();
 
+        var modelMatrixChanged = !Matrix4.equals(this.modelMatrix, this._modelMatrix);
+        if (modelMatrixChanged) {
+            Matrix4.clone(this.modelMatrix, this._modelMatrix);
+        }
+
+        if (directionsChanged || modelMatrixChanged) {
+            BoundingSphere.transform(this._boundingSphere, this.modelMatrix, this._boundingSphereWC);
+        }
+
         this._frontFaceColorCommand.modelMatrix = this.modelMatrix;
         this._backFaceColorCommand.modelMatrix = this._frontFaceColorCommand.modelMatrix;
         this._pickCommand.modelMatrix = this._frontFaceColorCommand.modelMatrix;

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

@@ -1,9 +1,8 @@
 /*global define*/
-define(['Core/defaultValue', 'Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine', 'Core/defined', 'Core/DeveloperError', 'Core/destroyObject', 'Core/Matrix4', 'Core/BoundingSphere', 'Core/PrimitiveType', 'Renderer/CullFace', 'Renderer/BlendingState', 'Renderer/BufferUsage', 'Renderer/CommandLists', 'Renderer/DrawCommand', 'Renderer/createShaderSource', 'Scene/Material', 'Scene/SceneMode', 'Shaders/EllipsoidVS', 'Shaders/EllipsoidFS'], function(
+define(['Core/defaultValue', 'Core/BoxGeometry', 'Core/Cartesian3', 'Core/combine', 'Core/defined', 'Core/DeveloperError', 'Core/destroyObject', 'Core/Matrix4', 'Core/BoundingSphere', 'Core/PrimitiveType', 'Renderer/CullFace', 'Renderer/BlendingState', 'Renderer/BufferUsage', 'Renderer/CommandLists', 'Renderer/DrawCommand', 'Renderer/createShaderSource', 'Scene/Material', 'Scene/SceneMode', 'Shaders/EllipsoidVS', 'Shaders/EllipsoidFS'], function(
         defaultValue,
         BoxGeometry,
         Cartesian3,
-        Cartesian4,
         combine,
         defined,
         DeveloperError,
@@ -78,6 +77,7 @@ define(['Core/defaultValue', 'Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartes
          * @see EllipsoidPrimitive#modelMatrix
          */
         this.center = Cartesian3.clone(defaultValue(options.center, Cartesian3.ZERO));
+        this._center = new Cartesian3();
 
         /**
          * The radius of the ellipsoid along the <code>x</code>, <code>y</code>, and <code>z</code> axes in the ellipsoid's model coordinates.
@@ -120,6 +120,7 @@ define(['Core/defaultValue', 'Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartes
          * @see czm_model
          */
         this.modelMatrix = Matrix4.clone(defaultValue(options.modelMatrix, Matrix4.IDENTITY));
+        this._modelMatrix = new Matrix4();
         this._computedModelMatrix = new Matrix4();
 
         /**
@@ -281,6 +282,8 @@ define(['Core/defaultValue', 'Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartes
             this._va = getVertexArray(context);
         }
 
+        var boundingSphereDirty = false;
+
         var radii = this.radii;
         if (!Cartesian3.equals(this._radii, radii)) {
             Cartesian3.clone(radii, this._radii);
@@ -290,11 +293,23 @@ define(['Core/defaultValue', 'Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartes
             r.y = 1.0 / (radii.y * radii.y);
             r.z = 1.0 / (radii.z * radii.z);
 
-            this._boundingSphere.radius = Cartesian3.getMaximumComponent(radii);
+            boundingSphereDirty = true;
         }
 
-        // Translate model coordinates used for rendering such that the origin is the center of the ellipsoid.
-        Matrix4.multiplyByTranslation(this.modelMatrix, this.center, this._computedModelMatrix);
+        if (!Matrix4.equals(this.modelMatrix, this._modelMatrix) || !Cartesian3.equals(this.center, this._center)) {
+            Matrix4.clone(this.modelMatrix, this._modelMatrix);
+            Cartesian3.clone(this.center, this._center);
+
+            // Translate model coordinates used for rendering such that the origin is the center of the ellipsoid.
+            Matrix4.multiplyByTranslation(this.modelMatrix, this.center, this._computedModelMatrix);
+            boundingSphereDirty = true;
+        }
+
+        if (boundingSphereDirty) {
+            Cartesian3.clone(Cartesian3.ZERO, this._boundingSphere.center);
+            this._boundingSphere.radius = Cartesian3.getMaximumComponent(radii);
+            BoundingSphere.transform(this._boundingSphere, this._computedModelMatrix, this._boundingSphere);
+        }
 
         var ellipsoidCommandLists = this._commandLists;
         ellipsoidCommandLists.removeAll();