cesium 0.21 → 0.21.1

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

@@ -38,6 +38,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
     var ROTATION_INDEX = Billboard.ROTATION_INDEX;
     var ALIGNED_AXIS_INDEX = Billboard.ALIGNED_AXIS_INDEX;
     var SCALE_BY_DISTANCE_INDEX = Billboard.SCALE_BY_DISTANCE_INDEX;
+    var TRANSLUCENCY_BY_DISTANCE_INDEX = Billboard.TRANSLUCENCY_BY_DISTANCE_INDEX;
     var NUMBER_OF_PROPERTIES = Billboard.NUMBER_OF_PROPERTIES;
 
     // PERFORMANCE_IDEA:  Use vertex compression so we don't run out of
@@ -53,7 +54,8 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         pickColor : 7,  // pickColor and color shared an index because pickColor is only used during
         color : 7,      // the 'pick' pass and 'color' is only used during the 'color' pass.
         rotationAndAlignedAxis : 8,
-        scaleByDistance : 9
+        scaleByDistance : 9,
+        translucencyByDistance : 10
     };
 
     // Identifies to the VertexArrayFacade the attributes that are used only for the pick
@@ -131,6 +133,10 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         this._compiledShaderScaleByDistance = false;
         this._compiledShaderScaleByDistancePick = false;
 
+        this._shaderTranslucencyByDistance = false;
+        this._compiledShaderTranslucencyByDistance = false;
+        this._compiledShaderTranslucencyByDistancePick = false;
+
         this._propertiesChanged = new Uint32Array(NUMBER_OF_PROPERTIES);
 
         this._maxSize = 0.0;
@@ -169,8 +175,8 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
          * billboards.add({ imageIndex: 0, position : new Cartesian3(0.0, 0.0, 1000000.0) }); // up
          * ]);
          */
-        this.modelMatrix = Matrix4.IDENTITY.clone();
-        this._modelMatrix = Matrix4.IDENTITY.clone();
+        this.modelMatrix = Matrix4.clone(Matrix4.IDENTITY);
+        this._modelMatrix = Matrix4.clone(Matrix4.IDENTITY);
 
         this._mode = SceneMode.SCENE3D;
         this._projection = undefined;
@@ -188,7 +194,8 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
                               BufferUsage.STATIC_DRAW, // COLOR_INDEX
                               BufferUsage.STATIC_DRAW, // ROTATION_INDEX
                               BufferUsage.STATIC_DRAW, // ALIGNED_AXIS_INDEX
-                              BufferUsage.STATIC_DRAW  // SCALE_BY_DISTANCE_INDEX
+                              BufferUsage.STATIC_DRAW, // SCALE_BY_DISTANCE_INDEX
+                              BufferUsage.STATIC_DRAW  // TRANSLUCENCY_BY_DISTANCE_INDEX
                           ];
 
         var that = this;
@@ -230,9 +237,9 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
      *   horizontalOrigin : HorizontalOrigin.CENTER,
      *   verticalOrigin : VerticalOrigin.CENTER,
      *   scale : 1.0,
-     *   scaleByDistance : new NearFarScalar(5e6, 1.0, 2e7, 0.0),
      *   imageIndex : 0,
-     *   color : Color.WHITE
+     *   color : Color.WHITE,
+     *   id : undefined
      * });
      *
      * // Example 2:  Specify only the billboard's cartographic position.
@@ -660,6 +667,11 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
             componentsPerAttribute : 4,
             componentDatatype : ComponentDatatype.FLOAT,
             usage : buffersUsage[SCALE_BY_DISTANCE_INDEX]
+        }, {
+            index : attributeIndices.translucencyByDistance,
+            componentsPerAttribute : 4,
+            componentDatatype : ComponentDatatype.FLOAT,
+            usage : buffersUsage[TRANSLUCENCY_BY_DISTANCE_INDEX]
         }], 4 * numberOfBillboards); // 4 vertices per billboard
     }
 
@@ -844,9 +856,9 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         var allPurposeWriters = vafWriters[allPassPurpose];
         var writer = allPurposeWriters[attributeIndices.scaleByDistance];
         var near = 0.0;
-        var nearValue = 0.0;
-        var far = 0.0;
-        var farValue = 0.0;
+        var nearValue = 1.0;
+        var far = 1.0;
+        var farValue = 1.0;
 
         var scale = billboard.getScaleByDistance();
         if (defined(scale)) {
@@ -868,6 +880,35 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         writer(i + 3, near, nearValue, far, farValue);
     }
 
+    function writeTranslucencyByDistance(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard) {
+        var i = billboard._index * 4;
+        var allPurposeWriters = vafWriters[allPassPurpose];
+        var writer = allPurposeWriters[attributeIndices.translucencyByDistance];
+        var near = 0.0;
+        var nearValue = 1.0;
+        var far = 1.0;
+        var farValue = 1.0;
+
+        var translucency = billboard.getTranslucencyByDistance();
+        if (defined(translucency)) {
+            near = translucency.near;
+            nearValue = translucency.nearValue;
+            far = translucency.far;
+            farValue = translucency.farValue;
+
+            if (nearValue !== 1.0 || farValue !== 1.0) {
+                // translucency by distance calculation in shader need not be enabled
+                // until a billboard with near and far !== 1.0 is found
+                billboardCollection._shaderTranslucencyByDistance = true;
+            }
+        }
+
+        writer(i + 0, near, nearValue, far, farValue);
+        writer(i + 1, near, nearValue, far, farValue);
+        writer(i + 2, near, nearValue, far, farValue);
+        writer(i + 3, near, nearValue, far, farValue);
+    }
+
     function writeBillboard(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard) {
         writePosition(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
         writePixelOffset(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
@@ -878,6 +919,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         writeTextureCoordinatesAndImageSize(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
         writeRotationAndAlignedAxis(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
         writeScaleByDistance(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
+        writeTranslucencyByDistance(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
     }
 
     function recomputeActualPositions(billboardCollection, billboards, length, frameState, modelMatrix, recomputeBoundingVolume) {
@@ -920,11 +962,11 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         if (billboardCollection._mode !== mode ||
             billboardCollection._projection !== projection ||
             mode !== SceneMode.SCENE3D &&
-            !modelMatrix.equals(billboardCollection.modelMatrix)) {
+            !Matrix4.equals(modelMatrix, billboardCollection.modelMatrix)) {
 
             billboardCollection._mode = mode;
             billboardCollection._projection = projection;
-            billboardCollection.modelMatrix.clone(modelMatrix);
+            Matrix4.clone(billboardCollection.modelMatrix, modelMatrix);
             billboardCollection._createVertexArray = true;
 
             if (mode === SceneMode.SCENE3D || mode === SceneMode.SCENE2D || mode === SceneMode.COLUMBUS_VIEW) {
@@ -1066,6 +1108,10 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
                     writers.push(writeScaleByDistance);
                 }
 
+                if (properties[TRANSLUCENCY_BY_DISTANCE_INDEX]) {
+                    writers.push(writeTranslucencyByDistance);
+                }
+
                 vafWriters = this._vaf.writers;
 
                 if ((billboardsToUpdateLength / billboardsLength) > 0.1) {
@@ -1140,19 +1186,23 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
                 });
             }
 
-            if (!defined(this._sp) || (this._shaderRotation && !this._compiledShaderRotation) ||
-                    (this._shaderScaleByDistance && !this._compiledShaderScaleByDistance)) {
+            if (!defined(this._sp) ||
+                    (this._shaderRotation && !this._compiledShaderRotation) ||
+                    (this._shaderScaleByDistance && !this._compiledShaderScaleByDistance) ||
+                    (this._shaderTranslucencyByDistance && !this._compiledShaderTranslucencyByDistance)) {
                 this._sp = context.getShaderCache().replaceShaderProgram(
                     this._sp,
                     createShaderSource({
                         defines : [this._shaderRotation ? 'ROTATION' : '',
-                                   this._shaderScaleByDistance ? 'EYE_DISTANCE_SCALING' : ''],
+                                   this._shaderScaleByDistance ? 'EYE_DISTANCE_SCALING' : '',
+                                   this._shaderTranslucencyByDistance ? 'EYE_DISTANCE_TRANSLUCENCY' : ''],
                         sources : [BillboardCollectionVS]
                     }),
                     BillboardCollectionFS,
                     attributeIndices);
                 this._compiledShaderRotation = this._shaderRotation;
                 this._compiledShaderScaleByDistance = this._shaderScaleByDistance;
+                this._compiledShaderTranslucencyByDistance = this._shaderTranslucencyByDistance;
             }
 
             va = this._vaf.vaByPurpose[colorPassPurpose];
@@ -1182,13 +1232,15 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
 
             if (!defined(this._spPick) ||
                     (this._shaderRotation && !this._compiledShaderRotationPick) ||
-                    (this._shaderScaleByDistance && !this._compiledShaderScaleByDistancePick)) {
+                    (this._shaderScaleByDistance && !this._compiledShaderScaleByDistancePick) ||
+                    (this._shaderTranslucencyByDistance && !this._compiledShaderTranslucencyByDistancePick)) {
                 this._spPick = context.getShaderCache().replaceShaderProgram(
                     this._spPick,
                     createShaderSource({
                         defines : ['RENDER_FOR_PICK',
                                    this._shaderRotation ? 'ROTATION' : '',
-                                   this._shaderScaleByDistance ? 'EYE_DISTANCE_SCALING' : ''],
+                                   this._shaderScaleByDistance ? 'EYE_DISTANCE_SCALING' : '',
+                                   this._shaderTranslucencyByDistance ? 'EYE_DISTANCE_TRANSLUCENCY' : ''],
                         sources : [BillboardCollectionVS]
                     }),
                     createShaderSource({
@@ -1198,6 +1250,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
                     attributeIndices);
                 this._compiledShaderRotationPick = this._shaderRotation;
                 this._compiledShaderScaleByDistancePick = this._shaderScaleByDistance;
+                this._compiledShaderTranslucencyByDistancePick = this._shaderTranslucencyByDistance;
             }
 
             va = this._vaf.vaByPurpose[pickPassPurpose];

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

@@ -145,8 +145,8 @@ define(['Core/defined', 'Core/defineProperties', 'Core/DeveloperError', 'Core/Ma
                                       u.x,  u.y,  u.z, -Cartesian3.dot(u, e),
                                      -d.x, -d.y, -d.z,  Cartesian3.dot(d, e),
                                       0.0,  0.0,  0.0,      1.0);
-        camera._viewMatrix = viewMatrix.multiply(camera._invTransform);
-        camera._invViewMatrix = camera._viewMatrix.inverseTransformation();
+        camera._viewMatrix = Matrix4.multiply(viewMatrix, camera._invTransform);
+        camera._invViewMatrix = Matrix4.inverseTransformation(camera._viewMatrix);
     }
 
     function update(camera) {
@@ -179,11 +179,11 @@ define(['Core/defined', 'Core/defineProperties', 'Core/DeveloperError', 'Core/Ma
         if (transformChanged) {
             transform = camera._transform = Matrix4.clone(camera.transform);
 
-            camera._invTransform = camera._transform.inverseTransformation();
+            camera._invTransform = Matrix4.inverseTransformation(camera._transform);
         }
 
         if (positionChanged || transformChanged) {
-            camera._positionWC = Cartesian3.fromCartesian4(transform.multiplyByPoint(position), camera._positionWC);
+            camera._positionWC = Cartesian3.fromCartesian4(Matrix4.multiplyByPoint(transform, position), camera._positionWC);
         }
 
         if (directionChanged || upChanged || rightChanged) {
@@ -205,15 +205,15 @@ define(['Core/defined', 'Core/defineProperties', 'Core/DeveloperError', 'Core/Ma
         }
 
         if (directionChanged || transformChanged) {
-            camera._directionWC = Cartesian3.fromCartesian4(transform.multiplyByVector(new Cartesian4(direction.x, direction.y, direction.z, 0.0)));
+            camera._directionWC = Cartesian3.fromCartesian4(Matrix4.multiplyByVector(transform, new Cartesian4(direction.x, direction.y, direction.z, 0.0)));
         }
 
         if (upChanged || transformChanged) {
-            camera._upWC = Cartesian3.fromCartesian4(transform.multiplyByVector(new Cartesian4(up.x, up.y, up.z, 0.0)));
+            camera._upWC = Cartesian3.fromCartesian4(Matrix4.multiplyByVector(transform, new Cartesian4(up.x, up.y, up.z, 0.0)));
         }
 
         if (rightChanged || transformChanged) {
-            camera._rightWC = Cartesian3.fromCartesian4(transform.multiplyByVector(new Cartesian4(right.x, right.y, right.z, 0.0)));
+            camera._rightWC = Cartesian3.fromCartesian4(Matrix4.multiplyByVector(transform, new Cartesian4(right.x, right.y, right.z, 0.0)));
         }
 
         if (positionChanged || directionChanged || upChanged || rightChanged || transformChanged) {

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

@@ -1,5 +1,5 @@
 /*global define*/
-define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/Cartographic', 'Core/DeveloperError', 'Core/Ellipsoid', 'Core/GeographicProjection', 'Core/IntersectionTests', 'Core/Math', 'Core/Matrix3', 'Core/Matrix4', 'Core/Quaternion', 'Core/Ray', 'Scene/SceneMode', 'ThirdParty/Tween'], function(
+define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/Cartographic', 'Core/DeveloperError', 'Core/Ellipsoid', 'Core/GeographicProjection', 'Core/IntersectionTests', 'Core/Math', 'Core/Matrix3', 'Core/Matrix4', 'Core/Quaternion', 'Core/Ray', 'Core/Transforms', 'Scene/SceneMode', 'ThirdParty/Tween'], function(
         defaultValue,
         defined,
         defineProperties,
@@ -16,6 +16,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
         Matrix4,
         Quaternion,
         Ray,
+        Transforms,
         SceneMode,
         Tween) {
     "use strict";
@@ -343,7 +344,8 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
         }
 
         var turnAngle = defaultValue(angle, this.defaultLookAmount);
-        var rotation = Matrix3.fromQuaternion(Quaternion.fromAxisAngle(axis, turnAngle, lookScratchQuaternion), lookScratchMatrix);
+        var quaternion = Quaternion.fromAxisAngle(axis, -turnAngle, lookScratchQuaternion);
+        var rotation = Matrix3.fromQuaternion(quaternion, lookScratchMatrix);
 
         var direction = this._camera.direction;
         var up = this._camera.up;
@@ -396,7 +398,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
             var direction = Cartesian3.clone(camera.directionWC, appendTransformDirection);
 
             oldTransform = camera.transform;
-            camera.transform = transform.multiply(oldTransform);
+            camera.transform = Matrix4.multiply(transform, oldTransform);
 
             var invTransform = camera.inverseTransform;
             Cartesian3.clone(Matrix4.multiplyByVector(invTransform, position, position), camera.position);
@@ -462,7 +464,8 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
         var camera = this._camera;
 
         var turnAngle = defaultValue(angle, this.defaultRotateAmount);
-        var rotation = Matrix3.fromQuaternion(Quaternion.fromAxisAngle(axis, turnAngle, rotateScratchQuaternion), rotateScratchMatrix);
+        var quaternion = Quaternion.fromAxisAngle(axis, -turnAngle, rotateScratchQuaternion);
+        var rotation = Matrix3.fromQuaternion(quaternion, rotateScratchMatrix);
 
         var oldTransform = appendTransform(this, transform);
         Matrix3.multiplyByVector(rotation, camera.position, camera.position);
@@ -736,12 +739,20 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
         return Math.atan2(camera.right.y, camera.right.x);
     }
 
-    var scratchHeadingCartesian4 = new Cartesian4();
+    var scratchHeadingMatrix4 = new Matrix4();
+    var scratchHeadingMatrix3 = new Matrix3();
+    var scratchHeadingCartesian3 = new Cartesian3();
 
     function getHeading3D(controller) {
         var camera = controller._camera;
-        var z = Matrix4.multiplyByVector(camera.viewMatrix, Cartesian4.UNIT_Z, scratchHeadingCartesian4);
-        return CesiumMath.PI_OVER_TWO - Math.atan2(z.y, z.x);
+
+        var ellipsoid = controller._projection.getEllipsoid();
+        var toFixedFrame = Transforms.eastNorthUpToFixedFrame(camera.position, ellipsoid, scratchHeadingMatrix4);
+        var transform = Matrix4.getRotation(toFixedFrame, scratchHeadingMatrix3);
+        Matrix3.transpose(transform, transform);
+
+        var right = Matrix3.multiplyByVector(transform, camera.right, scratchHeadingCartesian3);
+        return Math.atan2(right.y, right.x);
     }
 
     function setHeading2D(controller, angle) {
@@ -968,7 +979,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
         var west = extent.west;
 
         var transform = Matrix4.clone(camera.transform, viewExtentCVTransform);
-        transform.setColumn(3, Cartesian4.UNIT_W);
+        Matrix4.setColumn(transform, 3, Cartesian4.UNIT_W);
         var invTransform = camera.inverseTransform;
 
         var cart = viewExtentCVCartographic;
@@ -1350,7 +1361,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
         var updateCV = function(value) {
             var interp = Cartesian3.lerp(position, newPosition, value.time);
             var pos = new Cartesian4(interp.x, interp.y, interp.z, 1.0);
-            camera.position = Cartesian3.fromCartesian4(camera.inverseTransform.multiplyByVector(pos));
+            camera.position = Cartesian3.fromCartesian4(Matrix4.multiplyByVector(camera.inverseTransform, pos));
         };
 
         return {
@@ -1371,14 +1382,14 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
         var position = camera.position;
         var direction = camera.direction;
 
-        var normal = Cartesian3.fromCartesian4(camera.inverseTransform.multiplyByVector(Cartesian4.UNIT_X));
+        var normal = Cartesian3.fromCartesian4(Matrix4.multiplyByVector(camera.inverseTransform, Cartesian4.UNIT_X));
         var scalar = -Cartesian3.dot(normal, position) / Cartesian3.dot(normal, direction);
         var center = Cartesian3.add(position, Cartesian3.multiplyByScalar(direction, scalar));
         center = new Cartesian4(center.x, center.y, center.z, 1.0);
-        var centerWC = camera.transform.multiplyByVector(center);
+        var centerWC = Matrix4.multiplyByVector(camera.transform, center);
 
         var cameraPosition = new Cartesian4(camera.position.x, camera.position.y, camera.position.z, 1.0);
-        var positionWC = camera.transform.multiplyByVector(cameraPosition);
+        var positionWC = Matrix4.multiplyByVector(camera.transform, cameraPosition);
 
         var tanPhi = Math.tan(controller._camera.frustum.fovy * 0.5);
         var tanTheta = controller._camera.frustum.aspectRatio * tanPhi;

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

@@ -144,7 +144,7 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
             }];
 
             angle = Math.acos(Cartesian3.dot(Cartesian3.normalize(afterStart), Cartesian3.normalize(aboveEnd)));
-            axis = Cartesian3.cross(afterStart, aboveEnd);
+            axis = Cartesian3.cross(aboveEnd, afterStart);
             if (Cartesian3.equalsEpsilon(axis, Cartesian3.ZERO, CesiumMath.EPSILON6)) {
                 axis = Cartesian3.UNIT_Z;
             }
@@ -154,7 +154,7 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
             for ( var i = startCondition; i > 0.0; i = i - increment) {
                 rotation = Matrix3.fromQuaternion(Quaternion.fromAxisAngle(axis, i));
                 points.push({
-                    point : rotation.multiplyByVector(aboveEnd)
+                    point : Matrix3.multiplyByVector(rotation, aboveEnd)
                 });
             }
 
@@ -212,9 +212,9 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
             Matrix3.fromQuaternion(orientation, rotMatrix);
 
             camera.position = path.evaluate(time, camera.position);
-            camera.right = rotMatrix.getRow(0, camera.right);
-            camera.up = rotMatrix.getRow(1, camera.up);
-            camera.direction = Cartesian3.negate(rotMatrix.getRow(2, camera.direction), camera.direction);
+            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);
         };
 
         return update;
@@ -328,9 +328,9 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
             Matrix3.fromQuaternion(orientation, rotMatrix);
 
             camera.position = path.evaluate(time, camera.position);
-            camera.right = rotMatrix.getRow(0, camera.right);
-            camera.up = rotMatrix.getRow(1, camera.up);
-            camera.direction = Cartesian3.negate(rotMatrix.getRow(2, camera.direction), camera.direction);
+            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);
         };
 
         return update;
@@ -358,9 +358,9 @@ define(['Core/Cartesian2', 'Core/Cartesian3', 'Core/clone', 'Core/defaultValue',
             var zoom = camera.position.z;
             camera.position.z = height;
 
-            camera.right = rotMatrix.getRow(0, camera.right);
-            camera.up = rotMatrix.getRow(1, camera.up);
-            camera.direction = Cartesian3.negate(rotMatrix.getRow(2, camera.direction), camera.direction);
+            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);
 
             var frustum = camera.frustum;
             var ratio = frustum.top / frustum.right;

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

@@ -849,7 +849,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/destroyObject', 'Core/Boundin
                 centerEye.w = 1.0;
 
                 Matrix4.multiplyByVector(viewMatrix, centerEye, centerEye);
-                viewMatrix.setColumn(3, centerEye, modifiedModelViewScratch);
+                Matrix4.setColumn(viewMatrix, 3, centerEye, modifiedModelViewScratch);
 
                 var tileImageryCollection = tile.imagery;
                 var imageryIndex = 0;

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

@@ -181,6 +181,18 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Color'
          */
         this.intersectionWidth = defaultValue(options.intersectionWidth, 5.0);
 
+        /**
+         * User-defined object returned when the sensors is picked.
+         *
+         * @type Object
+         *
+         * @default undefined
+         *
+         * @see Scene#pick
+         */
+        this.id = options.id;
+        this._id = undefined;
+
         var that = this;
         this._uniforms = {
             u_showThroughEllipsoid : function() {
@@ -444,9 +456,12 @@ define(['Core/defaultValue', 'Core/defined', 'Core/DeveloperError', 'Core/Color'
         if (pass.pick) {
             var pickCommand = this._pickCommand;
 
-            if (!defined(this._pickId)) {
+            if (!defined(this._pickId) || (this._id !== this.id)) {
+                this._id = this.id;
+                this._pickId = this._pickId && this._pickId.destroy();
                 this._pickId = context.createPickId({
-                    primitive : this._pickIdThis
+                    primitive : this._pickIdThis,
+                    id : this.id
                 });
             }
 

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

@@ -1,5 +1,6 @@
 /*global define*/
-define(['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/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(
+        defaultValue,
         BoxGeometry,
         Cartesian3,
         Cartesian4,
@@ -35,13 +36,20 @@ define(['Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine'
      * @alias EllipsoidPrimitive
      * @constructor
      *
+     * @param {Cartesian3} [options.center=Cartesian3.ZERO] The center of the ellipsoid in the ellipsoid's model coordinates.
+     * @param {Cartesian3} [options.radii=undefined] The radius of the ellipsoid along the <code>x</code>, <code>y</code>, and <code>z</code> axes in the ellipsoid's model coordinates.
+     * @param {Matrix4} [options.modelMatrix=Matrix4.IDENTITY] The 4x4 transformation matrix that transforms the ellipsoid from model to world coordinates.
+     * @param {Boolean} [options.show=true] Determines if this primitive will be shown.
+     * @param {Material} [options.material=Material.ColorType] The surface appearance of the primitive.
+     * @param {Object} [options.id=undefined] A user-defined object to return when the instance is picked with {@link Scene#pick}
+     *
      * @example
      * // 1. Create a sphere using the ellipsoid primitive
-     * var e = new EllipsoidPrimitive();
-     * e.center = ellipsoid.cartographicToCartesian(
-     *   Cartographic.fromDegrees(-75.0, 40.0, 500000.0));
-     * e.radii = new Cartesian3(500000.0, 500000.0, 500000.0);
-     * primitives.add(e);
+     * primitives.add(new EllipsoidPrimitive({
+     *   center : ellipsoid.cartographicToCartesian(
+     *     Cartographic.fromDegrees(-75.0, 40.0, 500000.0)),
+     *   radii : new Cartesian3(500000.0, 500000.0, 500000.0)
+     * }));
      *
      * @example
      * // 2. Create a tall ellipsoid in an east-north-up reference frame
@@ -54,7 +62,9 @@ define(['Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine'
      *
      * @demo <a href="http://cesium.agi.com/Cesium/Apps/Sandcastle/index.html?src=Volumes.html">Cesium Sandcastle Volumes Demo</a>
      */
-    var EllipsoidPrimitive = function() {
+    var EllipsoidPrimitive = function(options) {
+        options = defaultValue(options, defaultValue.EMPTY_OBJECT);
+
         /**
          * The center of the ellipsoid in the ellipsoid's model coordinates.
          * <p>
@@ -66,7 +76,7 @@ define(['Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine'
          *
          * @see EllipsoidPrimitive#modelMatrix
          */
-        this.center = Cartesian3.clone(Cartesian3.ZERO);
+        this.center = Cartesian3.clone(defaultValue(options.center, Cartesian3.ZERO));
 
         /**
          * The radius of the ellipsoid along the <code>x</code>, <code>y</code>, and <code>z</code> axes in the ellipsoid's model coordinates.
@@ -84,7 +94,7 @@ define(['Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine'
          *
          * @see EllipsoidPrimitive#modelMatrix
          */
-        this.radii = undefined;
+        this.radii = Cartesian3.clone(options.radii);
         this._radii = new Cartesian3();
 
         this._oneOverEllipsoidRadiiSquared = new Cartesian3();
@@ -110,8 +120,8 @@ define(['Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine'
          * @see Transforms.eastNorthUpToFixedFrame
          * @see czm_model
          */
-        this.modelMatrix = Matrix4.IDENTITY.clone();
-        this._computedModelMatrix = Matrix4.IDENTITY.clone();
+        this.modelMatrix = Matrix4.clone(defaultValue(options.modelMatrix, Matrix4.IDENTITY));
+        this._computedModelMatrix = new Matrix4();
 
         /**
          * Determines if the ellipsoid primitive will be shown.
@@ -119,7 +129,7 @@ define(['Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine'
          * @type {Boolean}
          * @default true
          */
-        this.show = true;
+        this.show = defaultValue(options.show, true);
 
         /**
          * The surface appearance of the ellipsoid.  This can be one of several built-in {@link Material} objects or a custom material, scripted with
@@ -140,9 +150,31 @@ define(['Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine'
          *
          * @see <a href='https://github.com/AnalyticalGraphicsInc/cesium/wiki/Fabric'>Fabric</a>
          */
-        this.material = Material.fromType(Material.ColorType);
+        this.material = defaultValue(options.material, Material.fromType(Material.ColorType));
         this._material = undefined;
 
+        /**
+         * User-defined object returned when the ellipsoid is picked.
+         *
+         * @type Object
+         *
+         * @default undefined
+         *
+         * @see Scene#pick
+         */
+        this.id = options.id;
+        this._id = undefined;
+
+        /**
+         * @private
+         */
+        this.onlySunLighting = defaultValue(options.onlySunLighting, false);
+        this._onlySunLighting = false;
+
+        this._owner = options._owner;
+        this._executeInClosestFrustum = defaultValue(options._executeInClosestFrustum, true);
+        this._writeDepth = defaultValue(options._writeDepth, false);
+
         this._sp = undefined;
         this._rs = undefined;
         this._va = undefined;
@@ -224,10 +256,15 @@ define(['Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine'
                 },
                 // Do not write depth since the depth for the bounding box is
                 // wrong; it is not the true of the ray casted ellipsoid.
-                // Once WebGL has the extension for writing gl_FragDepth,
-                // we can write the correct depth.  For now, most ellipsoids
-                // will be translucent so we don't want to write depth anyway.
-                depthMask : false,
+                // For now, most ellipsoids will be translucent so we don't want
+                // to write depth anyway.
+                //
+                // For ellipsoids that we know are opaque and the EXT_frag_depth
+                // extension is available, we can set _writeDepth to true. This is
+                // a workaround and should be updated when we know which primitives
+                // are translucent.
+                // See the road map: https://github.com/AnalyticalGraphicsInc/cesium/wiki/Data-Driven-Renderer-Details
+                depthMask : this._writeDepth && context.getFragmentDepth(),
                 blending : BlendingState.ALPHA_BLEND
             });
         }
@@ -258,12 +295,21 @@ define(['Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine'
         this._material = this.material;
         this._material.update(context);
 
+        var lightingChanged = this.onlySunLighting !== this._onlySunLighting;
+        this._onlySunLighting = this.onlySunLighting;
+
         if (frameState.passes.color) {
             var colorCommand = this._colorCommand;
 
             // Recompile shader when material changes
-            if (materialChanged) {
-                var colorFS = createShaderSource({ sources : [this.material.shaderSource, EllipsoidFS] });
+            if (materialChanged || lightingChanged) {
+                var colorFS = createShaderSource({
+                    defines : [
+                        this.onlySunLighting ? 'ONLY_SUN_LIGHTING' : '',
+                        (this._writeDepth && context.getFragmentDepth()) ? 'WRITE_DEPTH' : ''
+                    ],
+                    sources : [this.material.shaderSource, EllipsoidFS] }
+                );
 
                 this._sp = context.getShaderCache().replaceShaderProgram(this._sp, EllipsoidVS, colorFS, attributeIndices);
 
@@ -272,7 +318,8 @@ define(['Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine'
                 colorCommand.renderState = this._rs;
                 colorCommand.shaderProgram = this._sp;
                 colorCommand.uniformMap = combine([this._uniforms, this.material._uniforms], false, false);
-                colorCommand.executeInClosestFrustum = true;
+                colorCommand.executeInClosestFrustum = this._executeInClosestFrustum;
+                colorCommand.owner = defaultValue(this._owner, this);
             }
 
             colorCommand.boundingVolume = this._boundingSphere;
@@ -284,15 +331,22 @@ define(['Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine'
         if (frameState.passes.pick) {
             var pickCommand = this._pickCommand;
 
-            if (!defined(this._pickId)) {
+            if (!defined(this._pickId) || (this._id !== this.id)) {
+                this._id = this.id;
+                this._pickId = this._pickId && this._pickId.destroy();
                 this._pickId = context.createPickId({
-                    primitive : this
+                    primitive : this,
+                    id : this.id
                 });
             }
 
             // Recompile shader when material changes
-            if (materialChanged || !defined(this._pickSP)) {
+            if (materialChanged || lightingChanged || !defined(this._pickSP)) {
                 var pickFS = createShaderSource({
+                    defines : [
+                        this.onlySunLighting ? 'ONLY_SUN_LIGHTING' : '',
+                        (this._writeDepth && context.getFragmentDepth()) ? 'WRITE_DEPTH' : ''
+                    ],
                     sources : [this.material.shaderSource, EllipsoidFS],
                     pickColorQualifier : 'uniform'
                 });
@@ -304,7 +358,8 @@ define(['Core/BoxGeometry', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/combine'
                 pickCommand.renderState = this._rs;
                 pickCommand.shaderProgram = this._pickSP;
                 pickCommand.uniformMap = combine([this._uniforms, this._pickUniforms, this.material._uniforms], false, false);
-                pickCommand.executeInClosestFrustum = true;
+                pickCommand.executeInClosestFrustum = this._executeInClosestFrustum;
+                pickCommand.owner = defaultValue(this._owner, this);
             }
 
             pickCommand.boundingVolume = this._boundingSphere;