cesium 0.23.0 → 0.24.0

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

@@ -1,5 +1,5 @@
 /*global define*/
-define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue', 'Core/destroyObject', 'Core/Cartesian2', 'Core/Cartesian3', 'Core/EncodedCartesian3', 'Core/Matrix4', 'Core/ComponentDatatype', 'Core/IndexDatatype', 'Core/PrimitiveType', 'Core/BoundingSphere', 'Renderer/BlendingState', 'Renderer/BufferUsage', 'Renderer/CommandLists', 'Renderer/DrawCommand', 'Renderer/VertexArrayFacade', 'Renderer/createShaderSource', 'Scene/SceneMode', 'Scene/Billboard', 'Scene/HorizontalOrigin', 'Shaders/BillboardCollectionVS', 'Shaders/BillboardCollectionFS'], function(
+define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue', 'Core/destroyObject', 'Core/Cartesian2', 'Core/Cartesian3', 'Core/EncodedCartesian3', 'Core/Matrix4', 'Core/ComponentDatatype', 'Core/IndexDatatype', 'Core/PrimitiveType', 'Core/BoundingSphere', 'Renderer/BlendingState', 'Renderer/BufferUsage', 'Renderer/DrawCommand', 'Renderer/Pass', 'Renderer/VertexArrayFacade', 'Renderer/createShaderSource', 'Scene/SceneMode', 'Scene/Billboard', 'Scene/HorizontalOrigin', 'Shaders/BillboardCollectionVS', 'Shaders/BillboardCollectionFS'], function(
         defined,
         DeveloperError,
         Color,
@@ -15,8 +15,8 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         BoundingSphere,
         BlendingState,
         BufferUsage,
-        CommandLists,
         DrawCommand,
+        Pass,
         VertexArrayFacade,
         createShaderSource,
         SceneMode,
@@ -39,6 +39,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
     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 PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX = Billboard.PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX;
     var NUMBER_OF_PROPERTIES = Billboard.NUMBER_OF_PROPERTIES;
 
     // PERFORMANCE_IDEA:  Use vertex compression so we don't run out of
@@ -46,7 +47,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
     var attributeIndices = {
         positionHigh : 0,
         positionLow : 1,
-        pixelOffset : 2,
+        pixelOffsetAndTranslate : 2,
         eyeOffsetAndScale : 3,
         textureCoordinatesAndImageSize : 4,
         originAndShow : 5,
@@ -55,7 +56,8 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         color : 7,      // the 'pick' pass and 'color' is only used during the 'color' pass.
         rotationAndAlignedAxis : 8,
         scaleByDistance : 9,
-        translucencyByDistance : 10
+        translucencyByDistance : 10,
+        pixelOffsetScaleByDistance : 11
     };
 
     // Identifies to the VertexArrayFacade the attributes that are used only for the pick
@@ -63,7 +65,6 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
     var allPassPurpose = 'all';
     var colorPassPurpose = 'color';
     var pickPassPurpose = 'pick';
-    var emptyArray = [];
 
     /**
      * A renderable collection of billboards.  Billboards are viewport-aligned
@@ -111,7 +112,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
      *   imageIndex : 1
      * });
      *
-     * @demo <a href="http://cesium.agi.com/Cesium/Apps/Sandcastle/index.html?src=Billboards.html">Cesium Sandcastle Billboard Demo</a>
+     * @demo <a href="http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Billboards.html">Cesium Sandcastle Billboard Demo</a>
      */
     var BillboardCollection = function(options) {
         options = defaultValue(options, defaultValue.EMPTY_OBJECT);
@@ -142,6 +143,10 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         this._compiledShaderTranslucencyByDistance = false;
         this._compiledShaderTranslucencyByDistancePick = false;
 
+        this._shaderPixelOffsetScaleByDistance = false;
+        this._compiledShaderPixelOffsetScaleByDistance = false;
+        this._compiledShaderPixelOffsetScaleByDistancePick = false;
+
         this._propertiesChanged = new Uint32Array(NUMBER_OF_PROPERTIES);
 
         this._maxSize = 0.0;
@@ -158,7 +163,6 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
 
         this._colorCommands = [];
         this._pickCommands = [];
-        this._commandLists = new CommandLists();
 
         /**
          * The 4x4 transformation matrix that transforms each billboard in this collection from model to world coordinates.
@@ -214,7 +218,8 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
                               BufferUsage.STATIC_DRAW, // ROTATION_INDEX
                               BufferUsage.STATIC_DRAW, // ALIGNED_AXIS_INDEX
                               BufferUsage.STATIC_DRAW, // SCALE_BY_DISTANCE_INDEX
-                              BufferUsage.STATIC_DRAW  // TRANSLUCENCY_BY_DISTANCE_INDEX
+                              BufferUsage.STATIC_DRAW, // TRANSLUCENCY_BY_DISTANCE_INDEX
+                              BufferUsage.STATIC_DRAW  // PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX
                           ];
 
         var that = this;
@@ -637,8 +642,8 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
             componentDatatype : ComponentDatatype.FLOAT,
             usage : buffersUsage[POSITION_INDEX]
         }, {
-            index : attributeIndices.pixelOffset,
-            componentsPerAttribute : 2,
+            index : attributeIndices.pixelOffsetAndTranslate,
+            componentsPerAttribute : 4,
             componentDatatype : ComponentDatatype.FLOAT,
             usage : buffersUsage[PIXEL_OFFSET_INDEX]
         }, {
@@ -691,6 +696,11 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
             componentsPerAttribute : 4,
             componentDatatype : ComponentDatatype.FLOAT,
             usage : buffersUsage[TRANSLUCENCY_BY_DISTANCE_INDEX]
+        }, {
+            index : attributeIndices.pixelOffsetScaleByDistance,
+            componentsPerAttribute : 4,
+            componentDatatype : ComponentDatatype.FLOAT,
+            usage : buffersUsage[PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX]
         }], 4 * numberOfBillboards); // 4 vertices per billboard
     }
 
@@ -730,17 +740,18 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         positionLowWriter(i + 3, low.x, low.y, low.z);
     }
 
-    function writePixelOffset(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard) {
+    function writePixelOffsetAndTranslate(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard) {
         var i = billboard._index * 4;
         var pixelOffset = billboard.getPixelOffset();
-        billboardCollection._maxPixelOffset = Math.max(billboardCollection._maxPixelOffset, pixelOffset.x, pixelOffset.y);
-
+        var translate = billboard._translate;
+        billboardCollection._maxPixelOffset = Math.max(billboardCollection._maxPixelOffset, pixelOffset.x + translate.x, pixelOffset.y + translate.y);
         var allPurposeWriters = vafWriters[allPassPurpose];
-        var writer = allPurposeWriters[attributeIndices.pixelOffset];
-        writer(i + 0, pixelOffset.x, pixelOffset.y);
-        writer(i + 1, pixelOffset.x, pixelOffset.y);
-        writer(i + 2, pixelOffset.x, pixelOffset.y);
-        writer(i + 3, pixelOffset.x, pixelOffset.y);
+
+        var writer = allPurposeWriters[attributeIndices.pixelOffsetAndTranslate];
+        writer(i + 0, pixelOffset.x, pixelOffset.y, translate.x, translate.y);
+        writer(i + 1, pixelOffset.x, pixelOffset.y, translate.x, translate.y);
+        writer(i + 2, pixelOffset.x, pixelOffset.y, translate.x, translate.y);
+        writer(i + 3, pixelOffset.x, pixelOffset.y, translate.x, translate.y);
     }
 
     function writeEyeOffsetAndScale(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard) {
@@ -929,9 +940,38 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         writer(i + 3, near, nearValue, far, farValue);
     }
 
+    function writePixelOffsetScaleByDistance(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard) {
+        var i = billboard._index * 4;
+        var allPurposeWriters = vafWriters[allPassPurpose];
+        var writer = allPurposeWriters[attributeIndices.pixelOffsetScaleByDistance];
+        var near = 0.0;
+        var nearValue = 1.0;
+        var far = 1.0;
+        var farValue = 1.0;
+
+        var pixelOffsetScale = billboard.getPixelOffsetScaleByDistance();
+        if (defined(pixelOffsetScale)) {
+            near = pixelOffsetScale.near;
+            nearValue = pixelOffsetScale.nearValue;
+            far = pixelOffsetScale.far;
+            farValue = pixelOffsetScale.farValue;
+
+            if (nearValue !== 1.0 || farValue !== 1.0) {
+                // pixelOffsetScale by distance calculation in shader need not be enabled
+                // until a billboard with near and far !== 1.0 is found
+                billboardCollection._shaderPixelOffsetScaleByDistance = 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);
+        writePixelOffsetAndTranslate(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
         writeEyeOffsetAndScale(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
         writePickColor(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
         writeColor(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
@@ -940,6 +980,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         writeRotationAndAlignedAxis(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
         writeScaleByDistance(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
         writeTranslucencyByDistance(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
+        writePixelOffsetScaleByDistance(billboardCollection, context, textureAtlasCoordinates, vafWriters, billboard);
     }
 
     function recomputeActualPositions(billboardCollection, billboards, length, frameState, modelMatrix, recomputeBoundingVolume) {
@@ -1102,7 +1143,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
                 }
 
                 if (properties[PIXEL_OFFSET_INDEX]) {
-                    writers.push(writePixelOffset);
+                    writers.push(writePixelOffsetAndTranslate);
                 }
 
                 if (properties[EYE_OFFSET_INDEX] || properties[SCALE_INDEX]) {
@@ -1133,6 +1174,10 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
                     writers.push(writeTranslucencyByDistance);
                 }
 
+                if (properties[PIXEL_OFFSET_SCALE_BY_DISTANCE_INDEX]) {
+                    writers.push(writePixelOffsetScaleByDistance);
+                }
+
                 vafWriters = this._vaf.writers;
 
                 if ((billboardsToUpdateLength / billboardsLength) > 0.1) {
@@ -1196,13 +1241,9 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
         var vaLength;
         var command;
         var j;
-        var commandLists = this._commandLists;
-        commandLists.opaqueList = emptyArray;
-        commandLists.pickList.opaqueList = emptyArray;
 
-        if (pass.color) {
+        if (pass.render) {
             var colorList = this._colorCommands;
-            commandLists.opaqueList = colorList;
 
             if (!defined(this._rs)) {
                 this._rs = context.createRenderState({
@@ -1216,13 +1257,15 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
             if (!defined(this._sp) ||
                     (this._shaderRotation && !this._compiledShaderRotation) ||
                     (this._shaderScaleByDistance && !this._compiledShaderScaleByDistance) ||
-                    (this._shaderTranslucencyByDistance && !this._compiledShaderTranslucencyByDistance)) {
+                    (this._shaderTranslucencyByDistance && !this._compiledShaderTranslucencyByDistance) ||
+                    (this._shaderPixelOffsetScaleByDistance && !this._compiledShaderPixelOffsetScaleByDistance)) {
                 this._sp = context.getShaderCache().replaceShaderProgram(
                     this._sp,
                     createShaderSource({
                         defines : [this._shaderRotation ? 'ROTATION' : '',
                                    this._shaderScaleByDistance ? 'EYE_DISTANCE_SCALING' : '',
-                                   this._shaderTranslucencyByDistance ? 'EYE_DISTANCE_TRANSLUCENCY' : ''],
+                                   this._shaderTranslucencyByDistance ? 'EYE_DISTANCE_TRANSLUCENCY' : '',
+                                   this._shaderPixelOffsetScaleByDistance ? 'EYE_DISTANCE_PIXEL_OFFSET' : ''],
                         sources : [BillboardCollectionVS]
                     }),
                     BillboardCollectionFS,
@@ -1230,6 +1273,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
                 this._compiledShaderRotation = this._shaderRotation;
                 this._compiledShaderScaleByDistance = this._shaderScaleByDistance;
                 this._compiledShaderTranslucencyByDistance = this._shaderTranslucencyByDistance;
+                this._compiledShaderPixelOffsetScaleByDistance = this._shaderPixelOffsetScaleByDistance;
             }
 
             va = this._vaf.vaByPurpose[colorPassPurpose];
@@ -1250,26 +1294,31 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
                 command.uniformMap = this._uniforms;
                 command.vertexArray = va[j].va;
                 command.renderState = this._rs;
+                command.pass = Pass.OPAQUE;
                 command.owner = this;
                 command.debugShowBoundingVolume = this.debugShowBoundingVolume;
+
+                commandList.push(command);
             }
         }
 
+
         if (picking) {
             var pickList = this._pickCommands;
-            commandLists.pickList.opaqueList = pickList;
 
             if (!defined(this._spPick) ||
                     (this._shaderRotation && !this._compiledShaderRotationPick) ||
                     (this._shaderScaleByDistance && !this._compiledShaderScaleByDistancePick) ||
-                    (this._shaderTranslucencyByDistance && !this._compiledShaderTranslucencyByDistancePick)) {
+                    (this._shaderTranslucencyByDistance && !this._compiledShaderTranslucencyByDistancePick) ||
+                    (this._shaderPixelOffsetScaleByDistance && !this._compiledShaderPixelOffsetScaleByDistancePick)) {
                 this._spPick = context.getShaderCache().replaceShaderProgram(
                     this._spPick,
                     createShaderSource({
                         defines : ['RENDER_FOR_PICK',
                                    this._shaderRotation ? 'ROTATION' : '',
                                    this._shaderScaleByDistance ? 'EYE_DISTANCE_SCALING' : '',
-                                   this._shaderTranslucencyByDistance ? 'EYE_DISTANCE_TRANSLUCENCY' : ''],
+                                   this._shaderTranslucencyByDistance ? 'EYE_DISTANCE_TRANSLUCENCY' : '',
+                                   this._shaderPixelOffsetScaleByDistance ? 'EYE_DISTANCE_PIXEL_OFFSET' : ''],
                         sources : [BillboardCollectionVS]
                     }),
                     createShaderSource({
@@ -1280,6 +1329,7 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
                 this._compiledShaderRotationPick = this._shaderRotation;
                 this._compiledShaderScaleByDistancePick = this._shaderScaleByDistance;
                 this._compiledShaderTranslucencyByDistancePick = this._shaderTranslucencyByDistance;
+                this._compiledShaderPixelOffsetScaleByDistancePick = this._shaderPixelOffsetScaleByDistance;
             }
 
             va = this._vaf.vaByPurpose[pickPassPurpose];
@@ -1300,12 +1350,11 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
                 command.uniformMap = this._uniforms;
                 command.vertexArray = va[j].va;
                 command.renderState = this._rs;
+                command.pass = Pass.OPAQUE;
                 command.owner = this;
-            }
-        }
 
-        if (!commandLists.empty()) {
-            commandList.push(commandLists);
+                commandList.push(command);
+            }
         }
     };
 
@@ -1365,4 +1414,4 @@ define(['Core/defined', 'Core/DeveloperError', 'Core/Color', 'Core/defaultValue'
     };
 
     return BillboardCollection;
-});
+});

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

@@ -34,13 +34,13 @@ define(['Core/defined', 'Core/defineProperties', 'Core/DeveloperError', 'Core/Ma
      * var camera = new Camera(context);
      * camera.position = new Cartesian3();
      * camera.direction = Cartesian3.negate(Cartesian3.UNIT_Z);
-     * camera.up = Cartesian3.UNIT_Y;
+     * camera.up = Cartesian3.clone(Cartesian3.UNIT_Y);
      * camera.frustum.fovy = CesiumMath.PI_OVER_THREE;
      * camera.frustum.near = 1.0;
      * camera.frustum.far = 2.0;
      *
-     * @demo <a href="http://cesium.agi.com/Cesium/Apps/Sandcastle/index.html?src=Camera.html">Cesium Sandcastle Camera Demo</a>
-     * @demo <a href="http://cesium.agi.com/Cesium/Apps/Sandcastle/index.html?src=Camera.html">Sandcastle Example</a> from the <a href="http://cesium.agi.com/2013/02/13/Cesium-Camera-Tutorial/">Camera Tutorial</a>
+     * @demo <a href="http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Camera.html">Cesium Sandcastle Camera Demo</a>
+     * @demo <a href="http://cesiumjs.org/Cesium/Apps/Sandcastle/index.html?src=Camera.html">Sandcastle Example</a> from the <a href="http://cesiumjs.org/2013/02/13/Cesium-Camera-Tutorial/">Camera Tutorial</a>
      */
     var Camera = function(context) {
         if (!defined(context)) {
@@ -57,7 +57,7 @@ define(['Core/defined', 'Core/defineProperties', 'Core/DeveloperError', 'Core/Ma
          * @see Camera#inverseTransform
          */
         this.transform = Matrix4.clone(Matrix4.IDENTITY);
-        this._transform = Matrix4.clone(this.transform);
+        this._transform = Matrix4.clone(Matrix4.IDENTITY);
         this._invTransform = Matrix4.clone(Matrix4.IDENTITY);
 
         var maxRadii = Ellipsoid.WGS84.getMaximumRadius();
@@ -68,20 +68,20 @@ define(['Core/defined', 'Core/defineProperties', 'Core/DeveloperError', 'Core/Ma
          *
          * @type {Cartesian3}
          */
-        this.position = Cartesian3.clone(position);
-        this._position = position;
-        this._positionWC = position;
+        this.position = position;
+        this._position = Cartesian3.clone(position);
+        this._positionWC = Cartesian3.clone(position);
 
-        var direction = Cartesian3.normalize(Cartesian3.subtract(Cartesian3.ZERO, position));
+        var direction = Cartesian3.normalize(Cartesian3.negate(position));
 
         /**
          * The view direction of the camera.
          *
          * @type {Cartesian3}
          */
-        this.direction = Cartesian3.clone(direction);
-        this._direction = direction;
-        this._directionWC = direction;
+        this.direction = direction;
+        this._direction = Cartesian3.clone(direction);
+        this._directionWC = Cartesian3.clone(direction);
 
         var right = Cartesian3.normalize(Cartesian3.cross(direction, Cartesian3.UNIT_Z));
         var up = Cartesian3.cross(right, direction);
@@ -91,9 +91,9 @@ define(['Core/defined', 'Core/defineProperties', 'Core/DeveloperError', 'Core/Ma
          *
          * @type {Cartesian3}
          */
-        this.up = Cartesian3.clone(up);
-        this._up = up;
-        this._upWC = up;
+        this.up = up;
+        this._up = Cartesian3.clone(up);
+        this._upWC = Cartesian3.clone(up);
 
         right = Cartesian3.cross(direction, up);
 
@@ -102,9 +102,9 @@ define(['Core/defined', 'Core/defineProperties', 'Core/DeveloperError', 'Core/Ma
          *
          * @type {Cartesian3}
          */
-        this.right = Cartesian3.clone(right);
-        this._right = right;
-        this._rightWC = right;
+        this.right = right;
+        this._right = Cartesian3.clone(right);
+        this._rightWC = Cartesian3.clone(right);
 
         /**
          * The region of space in view.
@@ -128,8 +128,8 @@ define(['Core/defined', 'Core/defineProperties', 'Core/DeveloperError', 'Core/Ma
          */
         this.controller = new CameraController(this);
 
-        this._viewMatrix = undefined;
-        this._invViewMatrix = undefined;
+        this._viewMatrix = new Matrix4();
+        this._invViewMatrix = new Matrix4();
         updateViewMatrix(this);
 
         this._context = context;
@@ -141,79 +141,94 @@ define(['Core/defined', 'Core/defineProperties', 'Core/DeveloperError', 'Core/Ma
         var d = camera._direction;
         var e = camera._position;
 
-        var viewMatrix = new Matrix4( r.x,  r.y,  r.z, -Cartesian3.dot(r, e),
-                                      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 = Matrix4.multiply(viewMatrix, camera._invTransform);
-        camera._invViewMatrix = Matrix4.inverseTransformation(camera._viewMatrix);
+        var viewMatrix = camera._viewMatrix;
+        viewMatrix[0] = r.x;
+        viewMatrix[1] = u.x;
+        viewMatrix[2] = -d.x;
+        viewMatrix[3] = 0.0;
+        viewMatrix[4] = r.y;
+        viewMatrix[5] = u.y;
+        viewMatrix[6] = -d.y;
+        viewMatrix[7] = 0.0;
+        viewMatrix[8] = r.z;
+        viewMatrix[9] = u.z;
+        viewMatrix[10] = -d.z;
+        viewMatrix[11] = 0.0;
+        viewMatrix[12] = -Cartesian3.dot(r, e);
+        viewMatrix[13] = -Cartesian3.dot(u, e);
+        viewMatrix[14] = Cartesian3.dot(d, e);
+        viewMatrix[15] = 1.0;
+
+        Matrix4.multiply(viewMatrix, camera._invTransform, camera._viewMatrix);
+        Matrix4.inverseTransformation(camera._viewMatrix, camera._invViewMatrix);
     }
 
+    var scratchCartesian = new Cartesian3();
+
     function update(camera) {
         var position = camera._position;
         var positionChanged = !Cartesian3.equals(position, camera.position);
         if (positionChanged) {
-            position = camera._position = Cartesian3.clone(camera.position);
+            position = Cartesian3.clone(camera.position, camera._position);
         }
 
         var direction = camera._direction;
         var directionChanged = !Cartesian3.equals(direction, camera.direction);
         if (directionChanged) {
-            direction = camera._direction = Cartesian3.clone(camera.direction);
+            direction = Cartesian3.clone(camera.direction, camera._direction);
         }
 
         var up = camera._up;
         var upChanged = !Cartesian3.equals(up, camera.up);
         if (upChanged) {
-            up = camera._up = Cartesian3.clone(camera.up);
+            up = Cartesian3.clone(camera.up, camera._up);
         }
 
         var right = camera._right;
         var rightChanged = !Cartesian3.equals(right, camera.right);
         if (rightChanged) {
-            right = camera._right = Cartesian3.clone(camera.right);
+            right = Cartesian3.clone(camera.right, camera._right);
         }
 
         var transform = camera._transform;
         var transformChanged = !Matrix4.equals(transform, camera.transform);
         if (transformChanged) {
-            transform = camera._transform = Matrix4.clone(camera.transform);
-
-            camera._invTransform = Matrix4.inverseTransformation(camera._transform);
+            transform = Matrix4.clone(camera.transform, camera._transform);
+            Matrix4.inverseTransformation(camera._transform, camera._invTransform);
         }
 
         if (positionChanged || transformChanged) {
-            camera._positionWC = Cartesian3.fromCartesian4(Matrix4.multiplyByPoint(transform, position), camera._positionWC);
+            camera._positionWC = Matrix4.multiplyByPoint(transform, position, camera._positionWC);
         }
 
         if (directionChanged || upChanged || rightChanged) {
-            var det = Cartesian3.dot(direction, Cartesian3.cross(up, right));
+            var det = Cartesian3.dot(direction, Cartesian3.cross(up, right, scratchCartesian));
             if (Math.abs(1.0 - det) > CesiumMath.EPSILON2) {
                 //orthonormalize axes
-                direction = camera._direction = Cartesian3.normalize(direction);
-                camera.direction = Cartesian3.clone(direction);
+                direction = Cartesian3.normalize(direction, camera._direction);
+                Cartesian3.clone(direction, camera.direction);
 
                 var invUpMag = 1.0 / Cartesian3.magnitudeSquared(up);
                 var scalar = Cartesian3.dot(up, direction) * invUpMag;
-                var w0 = Cartesian3.multiplyByScalar(direction, scalar);
-                up = camera._up = Cartesian3.normalize(Cartesian3.subtract(up, w0));
-                camera.up = Cartesian3.clone(up);
+                var w0 = Cartesian3.multiplyByScalar(direction, scalar, scratchCartesian);
+                up = Cartesian3.normalize(Cartesian3.subtract(up, w0, camera._up), camera._up);
+                Cartesian3.clone(up, camera.up);
 
-                right = camera._right = Cartesian3.cross(direction, up);
-                camera.right = Cartesian3.clone(right);
+                right = Cartesian3.cross(direction, up, camera._right);
+                Cartesian3.clone(right, camera.right);
             }
         }
 
         if (directionChanged || transformChanged) {
-            camera._directionWC = Cartesian3.fromCartesian4(Matrix4.multiplyByVector(transform, new Cartesian4(direction.x, direction.y, direction.z, 0.0)));
+            camera._directionWC = Matrix4.multiplyByPointAsVector(transform, direction, camera._directionWC);
         }
 
         if (upChanged || transformChanged) {
-            camera._upWC = Cartesian3.fromCartesian4(Matrix4.multiplyByVector(transform, new Cartesian4(up.x, up.y, up.z, 0.0)));
+            camera._upWC = Matrix4.multiplyByPointAsVector(transform, up, camera._upWC);
         }
 
         if (rightChanged || transformChanged) {
-            camera._rightWC = Cartesian3.fromCartesian4(Matrix4.multiplyByVector(transform, new Cartesian4(right.x, right.y, right.z, 0.0)));
+            camera._rightWC = Matrix4.multiplyByPointAsVector(transform, right, camera._rightWC);
         }
 
         if (positionChanged || directionChanged || upChanged || rightChanged || transformChanged) {