cesium 0.23.0 → 0.24.0

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

@@ -384,10 +384,12 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
         this.look(this._camera.direction, -amount);
     };
 
-    var appendTransformPosition = Cartesian4.clone(Cartesian4.UNIT_W);
-    var appendTransformUp = Cartesian4.clone(Cartesian4.ZERO);
-    var appendTransformRight = Cartesian4.clone(Cartesian4.ZERO);
-    var appendTransformDirection = Cartesian4.clone(Cartesian4.ZERO);
+    var appendTransformPosition = new Cartesian3();
+    var appendTransformUp = new Cartesian3();
+    var appendTransformRight = new Cartesian3();
+    var appendTransformDirection = new Cartesian3();
+    var appendTransformMatrix = new Matrix4();
+
     function appendTransform(controller, transform) {
         var camera = controller._camera;
         var oldTransform;
@@ -398,21 +400,22 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
             var direction = Cartesian3.clone(camera.directionWC, appendTransformDirection);
 
             oldTransform = camera.transform;
-            camera.transform = Matrix4.multiply(transform, oldTransform);
+            camera.transform = Matrix4.multiplyTransformation(transform, oldTransform, appendTransformMatrix);
 
             var invTransform = camera.inverseTransform;
-            Cartesian3.clone(Matrix4.multiplyByVector(invTransform, position, position), camera.position);
-            Cartesian3.clone(Matrix4.multiplyByVector(invTransform, up, up), camera.up);
-            Cartesian3.clone(Matrix4.multiplyByVector(invTransform, right, right), camera.right);
-            Cartesian3.clone(Matrix4.multiplyByVector(invTransform, direction, direction), camera.direction);
+            Matrix4.multiplyByPoint(invTransform, position, camera.position);
+            Matrix4.multiplyByPointAsVector(invTransform, up, camera.up);
+            Matrix4.multiplyByPointAsVector(invTransform, right, camera.right);
+            Matrix4.multiplyByPointAsVector(invTransform, direction, camera.direction);
         }
         return oldTransform;
     }
 
-    var revertTransformPosition = Cartesian4.clone(Cartesian4.UNIT_W);
-    var revertTransformUp = Cartesian4.clone(Cartesian4.ZERO);
-    var revertTransformRight = Cartesian4.clone(Cartesian4.ZERO);
-    var revertTransformDirection = Cartesian4.clone(Cartesian4.ZERO);
+    var revertTransformPosition = new Cartesian3();
+    var revertTransformUp = new Cartesian3();
+    var revertTransformRight = new Cartesian3();
+    var revertTransformDirection = new Cartesian3();
+
     function revertTransform(controller, transform) {
         if (defined(transform)) {
             var camera = controller._camera;
@@ -424,10 +427,10 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
             camera.transform = transform;
             transform = camera.inverseTransform;
 
-            position = Cartesian3.clone(Matrix4.multiplyByVector(transform, position, position), camera.position);
-            up = Cartesian3.clone(Matrix4.multiplyByVector(transform, up, up), camera.up);
-            right = Cartesian3.clone(Matrix4.multiplyByVector(transform, right, right), camera.right);
-            direction = Cartesian3.clone(Matrix4.multiplyByVector(transform, direction, direction), camera.direction);
+            Matrix4.multiplyByPoint(transform, position, camera.position);
+            Matrix4.multiplyByPointAsVector(transform, up, camera.up);
+            Matrix4.multiplyByPointAsVector(transform, right, camera.right);
+            Matrix4.multiplyByPointAsVector(transform, direction, camera.direction);
         }
     }
 
@@ -511,6 +514,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
     var rotateVertScratchP = new Cartesian3();
     var rotateVertScratchA = new Cartesian3();
     var rotateVertScratchTan = new Cartesian3();
+    var rotateVertScratchNegate = new Cartesian3();
     function rotateVertical(controller, angle, transform) {
         var camera = controller._camera;
         var oldTransform = appendTransform(controller, transform);
@@ -519,7 +523,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
         var p = Cartesian3.normalize(position, rotateVertScratchP);
         if (defined(controller.constrainedAxis)) {
             var northParallel = Cartesian3.equalsEpsilon(p, controller.constrainedAxis, CesiumMath.EPSILON2);
-            var southParallel = Cartesian3.equalsEpsilon(p, Cartesian3.negate(controller.constrainedAxis), CesiumMath.EPSILON2);
+            var southParallel = Cartesian3.equalsEpsilon(p, Cartesian3.negate(controller.constrainedAxis, rotateVertScratchNegate), CesiumMath.EPSILON2);
             if ((!northParallel && !southParallel)) {
                 var constrainedAxis = Cartesian3.normalize(controller.constrainedAxis, rotateVertScratchA);
 
@@ -529,7 +533,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
                     angle = angleToAxis;
                 }
 
-                dot = Cartesian3.dot(p, Cartesian3.negate(constrainedAxis));
+                dot = Cartesian3.dot(p, Cartesian3.negate(constrainedAxis, rotateVertScratchNegate));
                 angleToAxis = Math.acos(dot);
                 if (angle < 0 && -angle > angleToAxis) {
                     angle = -angleToAxis;
@@ -969,33 +973,27 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
     }
 
     var viewExtentCVCartographic = new Cartographic();
-    var viewExtentCVNorthEast = Cartesian4.clone(Cartesian4.UNIT_W);
-    var viewExtentCVSouthWest = Cartesian4.clone(Cartesian4.UNIT_W);
-    var viewExtentCVTransform = new Matrix4();
+    var viewExtentCVNorthEast = new Cartesian3();
+    var viewExtentCVSouthWest = new Cartesian3();
     function extentCameraPositionColumbusView(camera, extent, projection, result, positionOnly) {
         var north = extent.north;
         var south = extent.south;
         var east = extent.east;
         var west = extent.west;
-
-        var transform = Matrix4.clone(camera.transform, viewExtentCVTransform);
-        Matrix4.setColumn(transform, 3, Cartesian4.UNIT_W);
         var invTransform = camera.inverseTransform;
 
         var cart = viewExtentCVCartographic;
         cart.longitude = east;
         cart.latitude = north;
-        var position = projection.project(cart);
-        var northEast = Cartesian3.clone(position, viewExtentCVNorthEast);
-        Matrix4.multiplyByVector(transform, northEast, northEast);
-        Matrix4.multiplyByVector(invTransform, northEast, northEast);
+        var northEast = projection.project(cart, viewExtentCVNorthEast);
+        Matrix4.multiplyByPoint(camera.transform, northEast, northEast);
+        Matrix4.multiplyByPoint(invTransform, northEast, northEast);
 
         cart.longitude = west;
         cart.latitude = south;
-        position = projection.project(cart);
-        var southWest = Cartesian3.clone(position, viewExtentCVSouthWest);
-        Matrix4.multiplyByVector(transform, southWest, southWest);
-        Matrix4.multiplyByVector(invTransform, southWest, southWest);
+        var southWest = projection.project(cart, viewExtentCVSouthWest);
+        Matrix4.multiplyByPoint(camera.transform, southWest, southWest);
+        Matrix4.multiplyByPoint(invTransform, southWest, southWest);
 
         var tanPhi = Math.tan(camera.frustum.fovy * 0.5);
         var tanTheta = camera.frustum.aspectRatio * tanPhi;
@@ -1360,8 +1358,7 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
         var camera = controller._camera;
         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(Matrix4.multiplyByVector(camera.inverseTransform, pos));
+            camera.position = Matrix4.multiplyByPoint(camera.inverseTransform, interp, camera.position);
         };
 
         return {
@@ -1377,23 +1374,25 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
         };
     }
 
+    var normalScratch = new Cartesian3();
+    var centerScratch = new Cartesian3();
+    var posScratch = new Cartesian3();
+    var scratchCartesian3 = new Cartesian3();
     function createAnimationCV(controller, duration) {
         var camera = controller._camera;
         var position = camera.position;
         var direction = camera.direction;
 
-        var normal = Cartesian3.fromCartesian4(Matrix4.multiplyByVector(camera.inverseTransform, Cartesian4.UNIT_X));
+        var normal = Matrix4.multiplyByPointAsVector(camera.inverseTransform, Cartesian3.UNIT_X, normalScratch);
         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 = Matrix4.multiplyByVector(camera.transform, center);
+        var center = Cartesian3.add(position, Cartesian3.multiplyByScalar(direction, scalar, centerScratch), centerScratch);
+        center = Matrix4.multiplyByPoint(camera.transform, center, center);
 
-        var cameraPosition = new Cartesian4(camera.position.x, camera.position.y, camera.position.z, 1.0);
-        var positionWC = Matrix4.multiplyByVector(camera.transform, cameraPosition);
+        position = Matrix4.multiplyByPoint(camera.transform, camera.position, posScratch);
 
         var tanPhi = Math.tan(controller._camera.frustum.fovy * 0.5);
         var tanTheta = controller._camera.frustum.aspectRatio * tanPhi;
-        var distToC = Cartesian3.magnitude(Cartesian3.subtract(positionWC, centerWC));
+        var distToC = Cartesian3.magnitude(Cartesian3.subtract(position, center, scratchCartesian3));
         var dWidth = tanTheta * distToC;
         var dHeight = tanPhi * distToC;
 
@@ -1403,11 +1402,11 @@ define(['Core/defaultValue', 'Core/defined', 'Core/defineProperties', 'Core/Cart
         var maxX = Math.max(dWidth - mapWidth, mapWidth);
         var maxY = Math.max(dHeight - mapHeight, mapHeight);
 
-        if (positionWC.z < -maxX || positionWC.z > maxX || positionWC.y < -maxY || positionWC.y > maxY) {
-            var translateX = centerWC.y < -maxX || centerWC.y > maxX;
-            var translateY = centerWC.z < -maxY || centerWC.z > maxY;
+        if (position.z < -maxX || position.z > maxX || position.y < -maxY || position.y > maxY) {
+            var translateX = center.y < -maxX || center.y > maxX;
+            var translateY = center.z < -maxY || center.z > maxY;
             if (translateX || translateY) {
-                return createAnimationTemplateCV(controller, Cartesian3.fromCartesian4(positionWC), Cartesian3.fromCartesian4(centerWC), maxX, maxY, duration);
+                return createAnimationTemplateCV(controller, position, center, maxX, maxY, duration);
             }
         }
 

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

@@ -1,223 +1,421 @@
 /*global define*/
-define(['Core/defined', 'Core/DeveloperError', 'Core/destroyObject', 'Core/Math', 'Core/ScreenSpaceEventHandler', 'Core/ScreenSpaceEventType', 'Core/Cartesian2', 'Scene/CameraEventType'], function(
+define(['Core/defined', 'Core/defaultValue', 'Core/DeveloperError', 'Core/destroyObject', 'Core/Math', 'Core/ScreenSpaceEventHandler', 'Core/ScreenSpaceEventType', 'Core/Cartesian2', 'Core/KeyboardEventModifier', 'Scene/CameraEventType'], function(
         defined,
+        defaultValue,
         DeveloperError,
         destroyObject,
         CesiumMath,
         ScreenSpaceEventHandler,
         ScreenSpaceEventType,
         Cartesian2,
+        KeyboardEventModifier,
         CameraEventType) {
     "use strict";
 
+    function getKey(type, modifier) {
+        var key = type.name;
+        if (defined(modifier)) {
+            key += '+' + modifier.name;
+        }
+        return key;
+    }
+
+    function clonePinchMovement(pinchMovement, result) {
+        Cartesian2.clone(pinchMovement.distance.startPosition, result.distance.startPosition);
+        Cartesian2.clone(pinchMovement.distance.endPosition, result.distance.endPosition);
+
+        Cartesian2.clone(pinchMovement.angleAndHeight.startPosition, result.angleAndHeight.startPosition);
+        Cartesian2.clone(pinchMovement.angleAndHeight.endPosition, result.angleAndHeight.endPosition);
+    }
+
+    function listenToPinch(aggregator, modifier, canvas) {
+        var key = getKey(CameraEventType.PINCH, modifier);
+
+        var update = aggregator._update;
+        var isDown = aggregator._isDown;
+        var pressTime = aggregator._pressTime;
+        var releaseTime = aggregator._releaseTime;
+
+        update[key] = true;
+        isDown[key] = false;
+
+        var movement = aggregator._movement[key];
+        if (!defined(movement)) {
+            movement = aggregator._movement[key] = {};
+        }
+
+        movement.distance = {
+            startPosition : new Cartesian2(),
+            endPosition : new Cartesian2()
+        };
+        movement.angleAndHeight = {
+            startPosition : new Cartesian2(),
+            endPosition : new Cartesian2()
+        };
+        movement.prevAngle = 0.0;
+
+        aggregator._eventHandler.setInputAction(function() {
+            aggregator._buttonsDown++;
+            isDown[key] = true;
+            pressTime[key] = new Date();
+        }, ScreenSpaceEventType.PINCH_START, modifier);
+
+        aggregator._eventHandler.setInputAction(function() {
+            aggregator._buttonsDown = Math.max(aggregator._buttonsDown - 1, 0);
+            isDown[key] = false;
+            releaseTime[key] = new Date();
+        }, ScreenSpaceEventType.PINCH_END, modifier);
+
+        aggregator._eventHandler.setInputAction(function(mouseMovement) {
+            if (isDown[key]) {
+                // Aggregate several input events into a single animation frame.
+                if (!update[key]) {
+                    Cartesian2.clone(mouseMovement.distance.endPosition, movement.distance.endPosition);
+                    Cartesian2.clone(mouseMovement.angleAndHeight.endPosition, movement.angleAndHeight.endPosition);
+                } else {
+                    clonePinchMovement(mouseMovement, movement);
+                    update[key] = false;
+                    movement.prevAngle = movement.angleAndHeight.startPosition.x;
+                }
+                // Make sure our aggregation of angles does not "flip" over 360 degrees.
+                var angle = movement.angleAndHeight.endPosition.x;
+                var prevAngle = movement.prevAngle;
+                var TwoPI = Math.PI * 2;
+                while (angle >= (prevAngle + Math.PI)) {
+                    angle -= TwoPI;
+                }
+                while (angle < (prevAngle - Math.PI)) {
+                    angle += TwoPI;
+                }
+                movement.angleAndHeight.endPosition.x = -angle * canvas.clientWidth / 12;
+                movement.angleAndHeight.startPosition.x = -prevAngle * canvas.clientWidth / 12;
+            }
+        }, ScreenSpaceEventType.PINCH_MOVE, modifier);
+    }
+
+    function listenToWheel(aggregator, modifier) {
+        var key = getKey(CameraEventType.WHEEL, modifier);
+
+        var update = aggregator._update;
+        update[key] = true;
+
+        var movement = aggregator._movement[key];
+        if(!defined(movement)) {
+            movement = aggregator._movement[key] = {};
+        }
+
+        movement.startPosition = new Cartesian2();
+        movement.endPosition = new Cartesian2();
+
+        aggregator._eventHandler.setInputAction(function(delta) {
+            // TODO: magic numbers
+            var arcLength = 15.0 * CesiumMath.toRadians(delta);
+            if (!update[key]) {
+                movement.endPosition.y = movement.endPosition.y + arcLength;
+            } else {
+                Cartesian2.clone(Cartesian2.ZERO, movement.startPosition);
+                movement.endPosition.x = 0.0;
+                movement.endPosition.y = arcLength;
+                update[key] = false;
+            }
+        }, ScreenSpaceEventType.WHEEL, modifier);
+    }
+
+    function listenMouseButtonDownUp(aggregator, modifier, type) {
+        var key = getKey(type, modifier);
+
+        var isDown = aggregator._isDown;
+        var pressTime = aggregator._pressTime;
+        var releaseTime = aggregator._releaseTime;
+
+        isDown[key] = false;
+
+        var lastMovement = aggregator._lastMovement[key];
+        if (!defined(lastMovement)) {
+            lastMovement = aggregator._lastMovement[key] = {
+                startPosition : new Cartesian2(),
+                endPosition : new Cartesian2(),
+                valid : false
+            };
+        }
+
+        var down;
+        var up;
+        if (type === CameraEventType.LEFT_DRAG) {
+            down = ScreenSpaceEventType.LEFT_DOWN;
+            up = ScreenSpaceEventType.LEFT_UP;
+        } else if (type === CameraEventType.RIGHT_DRAG) {
+            down = ScreenSpaceEventType.RIGHT_DOWN;
+            up = ScreenSpaceEventType.RIGHT_UP;
+        } else if (type === CameraEventType.MIDDLE_DRAG) {
+            down = ScreenSpaceEventType.MIDDLE_DOWN;
+            up = ScreenSpaceEventType.MIDDLE_UP;
+        }
+
+        aggregator._eventHandler.setInputAction(function() {
+            aggregator._buttonsDown++;
+            lastMovement.valid = false;
+            isDown[key] = true;
+            pressTime[key] = new Date();
+        }, down, modifier);
+
+        aggregator._eventHandler.setInputAction(function() {
+            aggregator._buttonsDown = Math.max(aggregator._buttonsDown - 1, 0);
+            isDown[key] = false;
+            releaseTime[key] = new Date();
+        }, up, modifier);
+    }
+
+    function cloneMouseMovement(mouseMovement, result) {
+        Cartesian2.clone(mouseMovement.startPosition, result.startPosition);
+        Cartesian2.clone(mouseMovement.endPosition, result.endPosition);
+    }
+
+    function listenMouseMove(aggregator, modifier) {
+        var update = aggregator._update;
+        var movement = aggregator._movement;
+        var lastMovement = aggregator._lastMovement;
+        var isDown = aggregator._isDown;
+
+        for ( var typeName in CameraEventType) {
+            if (CameraEventType.hasOwnProperty(typeName)) {
+                var type = CameraEventType[typeName];
+                if (defined(type.name)) {
+                    var key = getKey(type, modifier);
+                    update[key] = true;
+
+                    if (!defined(aggregator._lastMovement[key])) {
+                        aggregator._lastMovement[key] = {
+                            startPosition : new Cartesian2(),
+                            endPosition : new Cartesian2(),
+                            valid : false
+                        };
+                    }
+
+                    if (!defined(aggregator._movement[key])) {
+                        aggregator._movement[key] = {
+                            startPosition : new Cartesian2(),
+                            endPosition : new Cartesian2()
+                        };
+                    }
+                }
+            }
+        }
+
+        aggregator._eventHandler.setInputAction(function(mouseMovement) {
+            for ( var typeName in CameraEventType) {
+                if (CameraEventType.hasOwnProperty(typeName)) {
+                    var type = CameraEventType[typeName];
+                    if (defined(type.name)) {
+                        var key = getKey(type, modifier);
+                        if (isDown[key]) {
+                            if (!update[key]) {
+                                Cartesian2.clone(mouseMovement.endPosition, movement[key].endPosition);
+                            } else {
+                                cloneMouseMovement(movement[key], lastMovement[key]);
+                                lastMovement[key].valid = true;
+                                cloneMouseMovement(mouseMovement, movement[key]);
+                                update[key] = false;
+                            }
+                        }
+                    }
+                }
+            }
+        }, ScreenSpaceEventType.MOUSE_MOVE, modifier);
+    }
+
     /**
-     * DOC_TBA
+     * Aggregates input events. For example, suppose the following inputs are received between frames:
+     * left mouse button down, mouse move, mouse move, left mouse button up. These events will be aggregated into
+     * one event with a start and end position of the mouse.
      *
      * @alias CameraEventAggregator
+     * @constructor
      *
      * @param {HTMLCanvasElement} canvas DOC_TBA
-     * @param {CameraEventType} moveType DOC_TBA
-     * @param {KeyboardEventModifier} moveModifier DOC_TBA
      *
      * @exception {DeveloperError} canvas is required.
-     * @exception {DeveloperError} moveType is required.
-     *
-     * @constructor
      *
      * @see ScreenSpaceEventHandler
      */
-    var CameraEventAggregator = function(canvas, moveType, moveModifier) {
+    var CameraEventAggregator = function(canvas) {
         if (!defined(canvas)) {
-            throw new DeveloperError('description.canvas is required.');
-        }
-
-        if (!defined(moveType)) {
-            throw new DeveloperError('moveType is required.');
+            throw new DeveloperError('canvas is required.');
         }
 
         this._eventHandler = new ScreenSpaceEventHandler(canvas);
 
-        this._update = true;
-        this._movement = undefined;
-        this._lastMovement = undefined;
-        this._isDown = false;
-        this._pressTime = undefined;
-        this._releaseTime = undefined;
-
-        var that = this;
-
-        if (moveType === CameraEventType.PINCH) {
-
-            this._eventHandler.setInputAction(function(movement) {
-                //that._lastMovement = null;
-                that._isDown = true;
-                that._pressTime = new Date();
-            }, ScreenSpaceEventType.PINCH_START, moveModifier);
-
-            this._eventHandler.setInputAction(function(movement) {
-                that._isDown = false;
-                that._releaseTime = new Date();
-            }, ScreenSpaceEventType.PINCH_END, moveModifier);
-
-            this._eventHandler.setInputAction(function(movement) {
-                if (that._isDown) {
-                    // Aggregate several input events into a single animation frame.
-                    if (!that._update) {
-                        that._movement.distance.endPosition = Cartesian2.clone(movement.distance.endPosition);
-                        that._movement.angleAndHeight.endPosition = Cartesian2.clone(movement.angleAndHeight.endPosition);
-                    } else {
-                        //that._lastMovement = that._movement;
-                        that._movement = movement;
-                        that._update = false;
-                        that._movement.prevAngle = that._movement.angleAndHeight.startPosition.x;
-                    }
-                    // Make sure our aggregation of angles does not "flip" over 360 degrees.
-                    var angle = that._movement.angleAndHeight.endPosition.x;
-                    var prevAngle = that._movement.prevAngle;
-                    var TwoPI = Math.PI * 2;
-                    while (angle >= (prevAngle + Math.PI)) {
-                        angle -= TwoPI;
-                    }
-                    while (angle < (prevAngle - Math.PI)) {
-                        angle += TwoPI;
-                    }
-                    that._movement.angleAndHeight.endPosition.x = -angle * canvas.clientWidth / 12;
-                    that._movement.angleAndHeight.startPosition.x = -prevAngle * canvas.clientWidth / 12;
-                }
-            }, ScreenSpaceEventType.PINCH_MOVE, moveModifier);
+        this._update = {};
+        this._movement = {};
+        this._lastMovement = {};
+        this._isDown = {};
+        this._pressTime = {};
+        this._releaseTime = {};
 
-        } else if (moveType === CameraEventType.WHEEL) {
+        this._buttonsDown = 0;
 
-            this._eventHandler.setInputAction(function(delta) {
-                // TODO: magic numbers
-                var arcLength = 2 * CesiumMath.toRadians(delta);
-                if (!that._update) {
-                    that._movement.endPosition.y = that._movement.endPosition.y + arcLength;
-                } else {
-                    that._movement = {
-                        startPosition : new Cartesian2(),
-                        endPosition : new Cartesian2(0.0, arcLength),
-                        motion : new Cartesian2()
-                    };
-                    that._lastMovement = that._movement; // This looks unusual, but its needed for wheel inertia.
-                    that._update = false;
-                }
-                that._pressTime = new Date();
-                that._releaseTime = new Date(that._pressTime.getTime() + Math.abs(arcLength) * 5.0);
-            }, ScreenSpaceEventType.WHEEL, moveModifier);
-
-        } else {  // General mouse buttons
-
-            var down;
-            var up;
-            if (moveType === CameraEventType.LEFT_DRAG) {
-                down = ScreenSpaceEventType.LEFT_DOWN;
-                up = ScreenSpaceEventType.LEFT_UP;
-            } else if (moveType === CameraEventType.RIGHT_DRAG) {
-                down = ScreenSpaceEventType.RIGHT_DOWN;
-                up = ScreenSpaceEventType.RIGHT_UP;
-            } else if (moveType === CameraEventType.MIDDLE_DRAG) {
-                down = ScreenSpaceEventType.MIDDLE_DOWN;
-                up = ScreenSpaceEventType.MIDDLE_UP;
-            } else {
-                this._eventHandler = this._eventHandler && this._eventHandler.destroy();
-                throw new DeveloperError('moveType must be of type CameraEventType.');
-            }
+        listenToWheel(this, undefined);
+        listenToPinch(this, undefined, canvas);
+        listenMouseButtonDownUp(this, undefined, CameraEventType.LEFT_DRAG);
+        listenMouseButtonDownUp(this, undefined, CameraEventType.RIGHT_DRAG);
+        listenMouseButtonDownUp(this, undefined, CameraEventType.MIDDLE_DRAG);
+        listenMouseMove(this, undefined);
 
-            this._eventHandler.setInputAction(function(movement) {
-                that._lastMovement = null;
-                that._isDown = true;
-                that._pressTime = new Date();
-            }, down, moveModifier);
-
-            this._eventHandler.setInputAction(function(movement) {
-                that._isDown = false;
-                that._releaseTime = new Date();
-            }, up, moveModifier);
-
-            this._eventHandler.setInputAction(function(movement) {
-                if (that._isDown) {
-                    if (!that._update) {
-                        that._movement.endPosition = Cartesian2.clone(movement.endPosition);
-                    } else {
-                        that._lastMovement = that._movement;
-                        that._movement = movement;
-                        that._update = false;
-                    }
+        for ( var modifierName in KeyboardEventModifier) {
+            if (KeyboardEventModifier.hasOwnProperty(modifierName)) {
+                var modifier = KeyboardEventModifier[modifierName];
+                if (defined(modifier.name)) {
+                    listenToWheel(this, modifier);
+                    listenToPinch(this, modifier, canvas);
+                    listenMouseButtonDownUp(this, modifier, CameraEventType.LEFT_DRAG);
+                    listenMouseButtonDownUp(this, modifier, CameraEventType.RIGHT_DRAG);
+                    listenMouseButtonDownUp(this, modifier, CameraEventType.MIDDLE_DRAG);
+                    listenMouseMove(this, modifier);
                 }
-            }, ScreenSpaceEventType.MOUSE_MOVE, moveModifier);
+            }
         }
     };
 
     /**
-     * DOC_TBA
-     *
+     * Gets if a mouse button down or touch has started and has been moved.
      * @memberof CameraEventAggregator
      *
-     * @returns {Boolean} DOC_TBA
+     * @param {CameraEventType} type The camera event type.
+     * @param {KeyboardEventModifier} [modifier] The keyboard modifier.
+     * @returns {Boolean} Returns <code>true</code> if a mouse button down or touch has started and has been moved; otherwise, <code>false</code>
+     *
+     * @exception {DeveloperError} type is required.
      */
-    CameraEventAggregator.prototype.isMoving = function() {
-        return !this._update;
+    CameraEventAggregator.prototype.isMoving = function(type, modifier) {
+        if (!defined(type)) {
+            throw new DeveloperError('type is required.');
+        }
+
+        var key = getKey(type, modifier);
+        return !this._update[key];
     };
 
     /**
-     * DOC_TBA
-     *
+     * Gets the aggregated start and end position of the current event.
      * @memberof CameraEventAggregator
      *
-     * @returns {Object} DOC_TBA
+     * @param {CameraEventType} type The camera event type.
+     * @param {KeyboardEventModifier} [modifier] The keyboard modifier.
+     * @returns {Object} An object with two {@link Cartesian2} properties: <code>startPosition</code> and <code>endPosition</code>.
+     *
+     * @exception {DeveloperError} type is required.
      */
-    CameraEventAggregator.prototype.getMovement = function() {
-        var movement = this._movement;
-        this._update = true;
+    CameraEventAggregator.prototype.getMovement = function(type, modifier) {
+        if (!defined(type)) {
+            throw new DeveloperError('type is required.');
+        }
+
+        var key = getKey(type, modifier);
+        var movement = this._movement[key];
         return movement;
     };
 
     /**
-     * DOC_TBA
-     *
+     * Gets the start and end position of the last move event (not the aggregated event).
      * @memberof CameraEventAggregator
      *
-     * @returns {Object} DOC_TBA
+     * @param {CameraEventType} type The camera event type.
+     * @param {KeyboardEventModifier} [modifier] The keyboard modifier.
+     * @returns {Object|undefined} An object with two {@link Cartesian2} properties: <code>startPosition</code> and <code>endPosition</code> or <code>undefined</code>.
+     *
+     * @exception {DeveloperError} type is required.
      */
-    CameraEventAggregator.prototype.getLastMovement = function() {
-        return this._lastMovement;
+    CameraEventAggregator.prototype.getLastMovement = function(type, modifier) {
+        if (!defined(type)) {
+            throw new DeveloperError('type is required.');
+        }
+
+        var key = getKey(type, modifier);
+        var lastMovement = this._lastMovement[key];
+        if (lastMovement.valid) {
+            return lastMovement;
+        }
+
+        return undefined;
     };
 
     /**
-     * DOC_TBA
-     *
+     * Gets whether the mouse button is down or a touch has started.
      * @memberof CameraEventAggregator
      *
-     * @returns {Boolean} DOC_TBA
+     * @param {CameraEventType} type The camera event type.
+     * @param {KeyboardEventModifier} [modifier] The keyboard modifier.
+     * @returns {Boolean} Whether the mouse button is down or a touch has started.
      *
+     * @exception {DeveloperError} type is required.
      */
-    CameraEventAggregator.prototype.isButtonDown = function() {
-        return this._isDown;
+    CameraEventAggregator.prototype.isButtonDown = function(type, modifier) {
+        if (!defined(type)) {
+            throw new DeveloperError('type is required.');
+        }
+
+        var key = getKey(type, modifier);
+        return this._isDown[key];
     };
 
     /**
-     * DOC_TBA
+     * Gets whether any mouse button is down or a touch has started.
+     * @memberof CameraEventAggregator
      *
+     * @returns {Boolean} Whether any mouse button is down or a touch has started.
+     */
+    CameraEventAggregator.prototype.anyButtonDown = function() {
+        return this._buttonsDown > 0;
+    };
+
+    /**
+     * Gets the time the button was pressed or the touch was started.
      * @memberof CameraEventAggregator
      *
-     * @returns {Date} DOC_TBA
+     * @param {CameraEventType} type The camera event type.
+     * @param {KeyboardEventModifier} [modifier] The keyboard modifier.
+     * @returns {Date} The time the button was pressed or the touch was started.
      *
+     * @exception {DeveloperError} type is required.
      */
-    CameraEventAggregator.prototype.getButtonPressTime = function() {
-        return this._pressTime;
+    CameraEventAggregator.prototype.getButtonPressTime = function(type, modifier) {
+        if (!defined(type)) {
+            throw new DeveloperError('type is required.');
+        }
+
+        var key = getKey(type, modifier);
+        return this._pressTime[key];
     };
 
     /**
-     * DOC_TBA
-     *
+     * Gets the time the button was released or the touch was ended.
      * @memberof CameraEventAggregator
      *
-     * @returns {Date} DOC_TBA
+     * @param {CameraEventType} type The camera event type.
+     * @param {KeyboardEventModifier} [modifier] The keyboard modifier.
+     * @returns {Date} The time the button was released or the touch was ended.
      *
+     * @exception {DeveloperError} type is required.
+     */
+    CameraEventAggregator.prototype.getButtonReleaseTime = function(type, modifier) {
+        if (!defined(type)) {
+            throw new DeveloperError('type is required.');
+        }
+
+        var key = getKey(type, modifier);
+        return this._releaseTime[key];
+    };
+
+    /**
+     * Signals that all of the events have been handled and the aggregator should be reset to handle new events.
+     * @memberof CameraEventAgregator
      */
-    CameraEventAggregator.prototype.getButtonReleaseTime = function() {
-        return this._releaseTime;
+    CameraEventAggregator.prototype.reset = function() {
+        for ( var name in this._update) {
+            if (this._update.hasOwnProperty(name)) {
+                this._update[name] = true;
+            }
+        }
     };
 
     /**