/*global define*/
define(['Core/defined', 'Core/destroyObject', 'Core/Cartesian2', 'Core/Cartesian3', 'Core/Cartesian4', 'Core/Cartographic', 'Core/DeveloperError', 'Core/Ellipsoid', 'Core/KeyboardEventModifier', 'Core/FAR', 'Core/IntersectionTests', 'Core/Math', 'Core/Matrix4', 'Core/Ray', 'Core/Transforms', 'Scene/AnimationCollection', 'Scene/CameraEventAggregator', 'Scene/CameraEventType', 'Scene/CameraColumbusViewMode', 'Scene/SceneMode'], function(
defined,
destroyObject,
Cartesian2,
Cartesian3,
Cartesian4,
Cartographic,
DeveloperError,
Ellipsoid,
KeyboardEventModifier,
FAR,
IntersectionTests,
CesiumMath,
Matrix4,
Ray,
Transforms,
AnimationCollection,
CameraEventAggregator,
CameraEventType,
CameraColumbusViewMode,
SceneMode) {
"use strict";
/**
* Modifies the camera position and orientation based on mouse input to a canvas.
* @alias ScreenSpaceCameraController
* @constructor
*
* @param {HTMLCanvasElement} canvas The canvas to listen for events.
* @param {CameraController} cameraController The camera controller used to modify the camera.
*
* @exception {DeveloperError} canvas is required.
* @exception {DeveloperError} cameraController is required.
*/
var ScreenSpaceCameraController = function(canvas, cameraController) {
//>>includeStart('debug', pragmas.debug);
if (!defined(canvas)) {
throw new DeveloperError('canvas is required.');
}
if (!defined(cameraController)) {
throw new DeveloperError('cameraController is required.');
}
//>>includeEnd('debug');
/**
* If true, inputs are allowed conditionally with the flags enableTranslate, enableZoom,
* enableRotate, enableTilt, and enableLook. If false, all inputs are disabled.
*
* NOTE: This setting is for temporary use cases, such as camera flights and
* drag-selection of regions (see Picking demo). It is typically set to false at the
* start of such events, and set true on completion. To keep inputs disabled
* past the end of camera flights, you must use the other booleans (enableTranslate,
* enableZoom, enableRotate, enableTilt, and enableLook).
* @type {Boolean}
* @default true
*/
this.enableInputs = true;
/**
* If true, allows the user to pan around the map. If false, the camera stays locked at the current position.
* This flag only applies in 2D and Columbus view modes.
* @type {Boolean}
* @default true
*/
this.enableTranslate = true;
/**
* If true, allows the user to zoom in and out. If false, the camera is locked to the current distance from the ellipsoid.
* @type {Boolean}
* @default true
*/
this.enableZoom = true;
/**
* If true, allows the user to rotate the camera. If false, the camera is locked to the current heading.
* This flag only applies in 2D and 3D.
* @type {Boolean}
* @default true
*/
this.enableRotate = true;
/**
* If true, allows the user to tilt the camera. If false, the camera is locked to the current heading.
* This flag only applies in 3D and Columbus view.
* @type {Boolean}
* @default true
*/
this.enableTilt = true;
/**
* If true, allows the user to use free-look. If false, the camera view direction can only be changed through translating
* or rotating. This flag only applies in 3D and Columbus view modes.
* @type {Boolean}
* @default true
*/
this.enableLook = true;
/**
* A parameter in the range <code>[0, 1)</code> used to determine how long
* the camera will continue to spin because of inertia.
* With value of zero, the camera will have no inertia.
* @type {Number}
* @default 0.9
*/
this.inertiaSpin = 0.9;
/**
* A parameter in the range <code>[0, 1)</code> used to determine how long
* the camera will continue to translate because of inertia.
* With value of zero, the camera will have no inertia.
* @type {Number}
* @default 0.9
*/
this.inertiaTranslate = 0.9;
/**
* A parameter in the range <code>[0, 1)</code> used to determine how long
* the camera will continue to zoom because of inertia.
* With value of zero, the camera will have no inertia.
* @type {Number}
* @default 0.8
*/
this.inertiaZoom = 0.8;
/**
* A parameter in the range <code>[0, 1)</code> used to limit the range
* of various user inputs to a percentage of the window width/height per animation frame.
* This helps keep the camera under control in low-frame-rate situations.
* @type {Number}
* @default 0.1
*/
this.maximumMovementRatio = 0.1;
/**
* Sets the behavior in Columbus view.
* @type {CameraColumbusViewMode}
* @default {@link CameraColumbusViewMode.FREE}
*/
this.columbusViewMode = CameraColumbusViewMode.FREE;
/**
* Sets the duration, in milliseconds, of the bounce back animations in 2D and Columbus view. The default value is 3000.
* @type {Number}
* @default 3000.0
*/
this.bounceAnimationTime = 3000.0;
/**
* The minimum magnitude, in meters, of the camera position when zooming. Defaults to 20.0.
* @type {Number}
* @default 20.0
*/
this.minimumZoomDistance = 20.0;
/**
* The maximum magnitude, in meters, of the camera position when zooming. Defaults to positive infinity.
* @type {Number}
* @default {@link Number.POSITIVE_INFINITY}
*/
this.maximumZoomDistance = Number.POSITIVE_INFINITY;
/**
* The input that allows the user to pan around the map. This only applies in 2D and Columbus view modes.
* <p>
* The type came be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
* and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
* or an array of any of the preceding.
* </p>
* @type {CameraEventType|Array|undefined}
* @default {@link CameraEventType.LEFT_DRAG}
*/
this.translateEventTypes = CameraEventType.LEFT_DRAG;
/**
* The input that allows the user to zoom in/out.
* <p>
* The type came be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
* and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
* or an array of any of the preceding.
* </p>
* @type {CameraEventType|Array|undefined}
* @default [{@link CameraEventType.RIGHT_DRAG}, {@link CameraEventType.WHEEL}, {@link CameraEventType.PINCH}]
*/
this.zoomEventTypes = [CameraEventType.RIGHT_DRAG, CameraEventType.WHEEL, CameraEventType.PINCH];
/**
* The input that allows the user to rotate around the globe or another object. This only applies in 3D and Columbus view modes.
* <p>
* The type came be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
* and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
* or an array of any of the preceding.
* </p>
* @type {CameraEventType|Array|undefined}
* @default {@link CameraEventType.LEFT_DRAG}
*/
this.rotateEventTypes = CameraEventType.LEFT_DRAG;
/**
* The input that allows the user to tilt in 3D and Columbus view or twist in 2D.
* <p>
* The type came be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
* and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
* or an array of any of the preceding.
* </p>
* @type {CameraEventType|Array|undefined}
* @default [{@link CameraEventType.MIDDLE_DRAG}, {@link CameraEventType.PINCH}, {
* eventType : {@link CameraEventType.LEFT_DRAG},
* modifier : {@link KeyboardEventModifier.CTRL}
* }]
*/
this.tiltEventTypes = [CameraEventType.MIDDLE_DRAG, CameraEventType.PINCH, {
eventType : CameraEventType.LEFT_DRAG,
modifier : KeyboardEventModifier.CTRL
}];
/**
* The input that allows the user to change the direction the camera is viewing. This only applies in 3D and Columbus view modes.
* <p>
* The type came be a {@link CameraEventType}, <code>undefined</code>, an object with <code>eventType</code>
* and <code>modifier</code> properties with types <code>CameraEventType</code> and {@link KeyboardEventModifier},
* or an array of any of the preceding.
* </p>
* @type {CameraEventType|Array|undefined}
* @default { eventType : {@link CameraEventType.LEFT_DRAG}, modifier : {@link KeyboardEventModifier.SHIFT} }
*/
this.lookEventTypes = {
eventType : CameraEventType.LEFT_DRAG,
modifier : KeyboardEventModifier.SHIFT
};
this._canvas = canvas;
this._cameraController = cameraController;
this._ellipsoid = Ellipsoid.WGS84;
this._aggregator = new CameraEventAggregator(canvas);
this._lastInertiaSpinMovement = undefined;
this._lastInertiaZoomMovement = undefined;
this._lastInertiaTranslateMovement = undefined;
this._lastInertiaWheelZoomMovement = undefined;
this._lastInertiaTiltMovement = undefined;
this._animationCollection = new AnimationCollection();
this._animation = undefined;
this._horizontalRotationAxis = undefined;
// Constants, Make any of these public?
var radius = this._ellipsoid.getMaximumRadius();
this._zoomFactor = 5.0;
this._rotateFactor = 1.0 / radius;
this._rotateRateRangeAdjustment = radius;
this._maximumRotateRate = 1.77;
this._minimumRotateRate = 1.0 / 5000.0;
this._translateFactor = 1.0;
this._minimumZoomRate = 20.0;
this._maximumZoomRate = FAR;
};
/**
* Gets the ellipsoid. The ellipsoid is used to determine the size of the map in 2D and Columbus view
* as well as how fast to rotate the camera based on the distance to its surface.
* @returns {Ellipsoid} The ellipsoid.
*/
ScreenSpaceCameraController.prototype.getEllipsoid = function() {
return this._ellipsoid;
};
/**
* Sets the ellipsoid. The ellipsoid is used to determine the size of the map in 2D and Columbus view
* as well as how fast to rotate the camera based on the distance to its surface.
* @param {Ellipsoid} [ellipsoid=WGS84] The ellipsoid.
*/
ScreenSpaceCameraController.prototype.setEllipsoid = function(ellipsoid) {
ellipsoid = ellipsoid || Ellipsoid.WGS84;
var radius = ellipsoid.getMaximumRadius();
this._ellipsoid = ellipsoid;
this._rotateFactor = 1.0 / radius;
this._rotateRateRangeAdjustment = radius;
};
function decay(time, coefficient) {
if (time < 0) {
return 0.0;
}
var tau = (1.0 - coefficient) * 25.0;
return Math.exp(-tau * time);
}
function sameMousePosition(movement) {
return Cartesian2.equalsEpsilon(movement.startPosition, movement.endPosition, CesiumMath.EPSILON14);
}
// If the time between mouse down and mouse up is not between
// these thresholds, the camera will not move with inertia.
// This value is probably dependent on the browser and/or the
// hardware. Should be investigated further.
var inertiaMaxClickTimeThreshold = 0.4;
function maintainInertia(aggregator, type, modifier, decayCoef, action, object, lastMovementName) {
var movementState = object[lastMovementName];
if (!defined(movementState)) {
movementState = object[lastMovementName] = {
startPosition : new Cartesian2(),
endPosition : new Cartesian2(),
motion : new Cartesian2(),
active : false
};
}
var ts = aggregator.getButtonPressTime(type, modifier);
var tr = aggregator.getButtonReleaseTime(type, modifier);
var threshold = ts && tr && ((tr.getTime() - ts.getTime()) / 1000.0);
var now = new Date();
var fromNow = tr && ((now.getTime() - tr.getTime()) / 1000.0);
if (ts && tr && threshold < inertiaMaxClickTimeThreshold) {
var d = decay(fromNow, decayCoef);
if (!movementState.active) {
var lastMovement = aggregator.getLastMovement(type, modifier);
if (!defined(lastMovement) || sameMousePosition(lastMovement)) {
return;
}
movementState.motion.x = (lastMovement.endPosition.x - lastMovement.startPosition.x) * 0.5;
movementState.motion.y = (lastMovement.endPosition.y - lastMovement.startPosition.y) * 0.5;
Cartesian2.clone(lastMovement.startPosition, movementState.startPosition);
Cartesian2.multiplyByScalar(movementState.motion, d, movementState.endPosition);
Cartesian2.add(movementState.startPosition, movementState.endPosition, movementState.endPosition);
movementState.active = true;
} else {
Cartesian2.clone(movementState.endPosition, movementState.startPosition);
Cartesian2.multiplyByScalar(movementState.motion, d, movementState.endPosition);
Cartesian2.add(movementState.startPosition, movementState.endPosition, movementState.endPosition);
Cartesian3.clone(Cartesian2.ZERO, movementState.motion);
}
// If value from the decreasing exponential function is close to zero,
// the end coordinates may be NaN.
if (isNaN(movementState.endPosition.x) || isNaN(movementState.endPosition.y) || sameMousePosition(movementState)) {
movementState.active = false;
return;
}
if (!aggregator.isButtonDown(type, modifier)) {
action(object, movementState);
}
} else {
movementState.active = false;
}
}
var scratchEventTypeArray = [];
function reactToInput(controller, enabled, eventTypes, action, inertiaConstant, inertiaStateName) {
if (!defined(eventTypes)) {
return;
}
var aggregator = controller._aggregator;
if (!Array.isArray(eventTypes)) {
scratchEventTypeArray[0] = eventTypes;
eventTypes = scratchEventTypeArray;
}
var length = eventTypes.length;
for (var i = 0; i < length; ++i) {
var eventType = eventTypes[i];
var type = defined(eventType.eventType) ? eventType.eventType : eventType;
var modifier = eventType.modifier;
var movement = aggregator.isMoving(type, modifier) && aggregator.getMovement(type, modifier);
if (controller.enableInputs && enabled) {
if (movement) {
action(controller, movement);
} else if (inertiaConstant < 1.0) {
maintainInertia(aggregator, type, modifier, inertiaConstant, action, controller, inertiaStateName);
}
}
}
}
function handleZoom(object, movement, zoomFactor, distanceMeasure, unitPositionDotDirection) {
var percentage = 1.0;
if (defined(unitPositionDotDirection)) {
percentage = CesiumMath.clamp(Math.abs(unitPositionDotDirection), 0.25, 1.0);
}
// distanceMeasure should be the height above the ellipsoid.
// The zoomRate slows as it approaches the surface and stops minimumZoomDistance above it.
var minHeight = object.minimumZoomDistance * percentage;
var maxHeight = object.maximumZoomDistance;
var minDistance = distanceMeasure - minHeight;
var zoomRate = zoomFactor * minDistance;
zoomRate = CesiumMath.clamp(zoomRate, object._minimumZoomRate, object._maximumZoomRate);
var diff = movement.endPosition.y - movement.startPosition.y;
var rangeWindowRatio = diff / object._canvas.clientHeight;
rangeWindowRatio = Math.min(rangeWindowRatio, object.maximumMovementRatio);
var distance = zoomRate * rangeWindowRatio;
if (distance > 0.0 && Math.abs(distanceMeasure - minHeight) < 1.0) {
return;
}
if (distance < 0.0 && Math.abs(distanceMeasure - maxHeight) < 1.0) {
return;
}
if (distanceMeasure - distance < minHeight) {
distance = distanceMeasure - minHeight - 1.0;
} else if (distanceMeasure - distance > maxHeight) {
distance = distanceMeasure - maxHeight;
}
object._cameraController.zoomIn(distance);
}
var translate2DStart = new Ray();
var translate2DEnd = new Ray();
var scratchTranslateP0 = new Cartesian3();
var scratchTranslateP1 = new Cartesian3();
function translate2D(controller, movement) {
var cameraController = controller._cameraController;
var start = cameraController.getPickRay(movement.startPosition, translate2DStart).origin;
var end = cameraController.getPickRay(movement.endPosition, translate2DEnd).origin;
var position = cameraController._camera.position;
var p0 = Cartesian3.subtract(start, position, scratchTranslateP0);
var p1 = Cartesian3.subtract(end, position, scratchTranslateP1);
var direction = Cartesian3.subtract(p0, p1, scratchTranslateP0);
var distance = Cartesian3.magnitude(direction);
Cartesian3.normalize(direction, direction);
cameraController.move(direction, distance);
}
function zoom2D(controller, movement) {
if (defined(movement.distance)) {
movement = movement.distance;
}
handleZoom(controller, movement, controller._zoomFactor, controller._cameraController.getMagnitude());
}
var twist2DStart = new Cartesian2();
var twist2DEnd = new Cartesian2();
function twist2D(controller, movement) {
if (defined(movement.angleAndHeight)) {
singleAxisTwist2D(controller, movement.angleAndHeight);
return;
}
var width = controller._canvas.clientWidth;
var height = controller._canvas.clientHeight;
var start = twist2DStart;
start.x = (2.0 / width) * movement.startPosition.x - 1.0;
start.y = (2.0 / height) * (height - movement.startPosition.y) - 1.0;
Cartesian2.normalize(start, start);
var end = twist2DEnd;
end.x = (2.0 / width) * movement.endPosition.x - 1.0;
end.y = (2.0 / height) * (height - movement.endPosition.y) - 1.0;
Cartesian2.normalize(end, end);
var startTheta = Math.acos(start.x);
if (start.y < 0) {
startTheta = CesiumMath.TWO_PI - startTheta;
}
var endTheta = Math.acos(end.x);
if (end.y < 0) {
endTheta = CesiumMath.TWO_PI - endTheta;
}
var theta = endTheta - startTheta;
controller._cameraController.twistRight(theta);
}
function singleAxisTwist2D(controller, movement) {
var rotateRate = controller._rotateFactor * controller._rotateRateRangeAdjustment;
if (rotateRate > controller._maximumRotateRate) {
rotateRate = controller._maximumRotateRate;
}
if (rotateRate < controller._minimumRotateRate) {
rotateRate = controller._minimumRotateRate;
}
var phiWindowRatio = (movement.endPosition.x - movement.startPosition.x) / controller._canvas.clientWidth;
phiWindowRatio = Math.min(phiWindowRatio, controller.maximumMovementRatio);
var deltaPhi = rotateRate * phiWindowRatio * Math.PI * 4.0;
controller._cameraController.twistRight(deltaPhi);
}
function update2D(controller) {
if (controller._aggregator.anyButtonDown()) {
controller._animationCollection.removeAll();
}
reactToInput(controller, controller.enableTranslate, controller.translateEventTypes, translate2D, controller.inertiaTranslate, '_lastInertiaTranslateMovement');
reactToInput(controller, controller.enableZoom, controller.zoomEventTypes, zoom2D, controller.inertiaZoom, '_lastInertiaZoomMovement');
reactToInput(controller, controller.enableRotate, controller.tiltEventTypes, twist2D, controller.inertiaSpin, '_lastInertiaTiltMovement');
if (!controller._aggregator.anyButtonDown() &&
(!defined(controller._lastInertiaZoomMovement) || !controller._lastInertiaZoomMovement.active) &&
(!defined(controller._lastInertiaTranslateMovement) || !controller._lastInertiaTranslateMovement.active) &&
!controller._animationCollection.contains(controller._animation)) {
var animation = controller._cameraController.createCorrectPositionAnimation(controller.bounceAnimationTime);
if (defined(animation)) {
controller._animation = controller._animationCollection.add(animation);
}
}
controller._animationCollection.update();
}
var translateCVStartRay = new Ray();
var translateCVEndRay = new Ray();
var translateCVStartPos = new Cartesian3();
var translateCVEndPos = new Cartesian3();
var translatCVDifference = new Cartesian3();
function translateCV(controller, movement) {
var cameraController = controller._cameraController;
var startRay = cameraController.getPickRay(movement.startPosition, translateCVStartRay);
var endRay = cameraController.getPickRay(movement.endPosition, translateCVEndRay);
var normal = Cartesian3.UNIT_X;
var position = startRay.origin;
var direction = startRay.direction;
var scalar = -Cartesian3.dot(normal, position) / Cartesian3.dot(normal, direction);
var startPlanePos = Cartesian3.multiplyByScalar(direction, scalar, translateCVStartPos);
Cartesian3.add(position, startPlanePos, startPlanePos);
position = endRay.origin;
direction = endRay.direction;
scalar = -Cartesian3.dot(normal, position) / Cartesian3.dot(normal, direction);
var endPlanePos = Cartesian3.multiplyByScalar(direction, scalar, translateCVEndPos);
Cartesian3.add(position, endPlanePos, endPlanePos);
var diff = Cartesian3.subtract(startPlanePos, endPlanePos, translatCVDifference);
var temp = diff.x;
diff.x = diff.y;
diff.y = diff.z;
diff.z = temp;
var mag = Cartesian3.magnitude(diff);
if (mag > CesiumMath.EPSILON6) {
Cartesian3.normalize(diff, diff);
cameraController.move(diff, mag);
}
}
var rotateCVWindowPos = new Cartesian2();
var rotateCVWindowRay = new Ray();
var rotateCVCenter = new Cartesian3();
var rotateTransform = new Matrix4();
function rotateCV(controller, movement) {
if (defined(movement.angleAndHeight)) {
movement = movement.angleAndHeight;
}
var windowPosition = rotateCVWindowPos;
windowPosition.x = controller._canvas.clientWidth / 2;
windowPosition.y = controller._canvas.clientHeight / 2;
var ray = controller._cameraController.getPickRay(windowPosition, rotateCVWindowRay);
var normal = Cartesian3.UNIT_X;
var position = ray.origin;
var direction = ray.direction;
var scalar = -Cartesian3.dot(normal, position) / Cartesian3.dot(normal, direction);
var center = Cartesian3.multiplyByScalar(direction, scalar, rotateCVCenter);
Cartesian3.add(position, center, center);
var transform = Matrix4.fromTranslation(center, rotateTransform);
var oldEllipsoid = controller._ellipsoid;
controller.setEllipsoid(Ellipsoid.UNIT_SPHERE);
rotate3D(controller, movement, transform, Cartesian3.UNIT_Z);
controller.setEllipsoid(oldEllipsoid);
}
var zoomCVWindowPos = new Cartesian2();
var zoomCVWindowRay = new Ray();
function zoomCV(controller, movement) {
if (defined(movement.distance)) {
movement = movement.distance;
}
var windowPosition = zoomCVWindowPos;
windowPosition.x = controller._canvas.clientWidth / 2;
windowPosition.y = controller._canvas.clientHeight / 2;
var ray = controller._cameraController.getPickRay(windowPosition, zoomCVWindowRay);
var normal = Cartesian3.UNIT_X;
var position = ray.origin;
var direction = ray.direction;
var scalar = -Cartesian3.dot(normal, position) / Cartesian3.dot(normal, direction);
handleZoom(controller, movement, controller._zoomFactor, scalar);
}
function updateCV(controller) {
if (controller.columbusViewMode === CameraColumbusViewMode.LOCKED) {
reactToInput(controller, controller.enableRotate, controller.rotateEventTypes, rotate3D, controller.inertiaSpin, '_lastInertiaSpinMovement');
reactToInput(controller, controller.enableZoom, controller.zoomEventTypes, zoom3D, controller.inertiaZoom, '_lastInertiaZoomMovement');
} else {
if (controller._aggregator.anyButtonDown()) {
controller._animationCollection.removeAll();
}
reactToInput(controller, controller.enableTilt, controller.tiltEventTypes, rotateCV, controller.inertiaSpin, '_lastInertiaTiltMovement');
reactToInput(controller, controller.enableTranslate, controller.translateEventTypes, translateCV, controller.inertiaTranslate, '_lastInertiaTranslateMovement');
reactToInput(controller, controller.enableZoom, controller.zoomEventTypes, zoomCV, controller.inertiaZoom, '_lastInertiaZoomMovement');
reactToInput(controller, controller.enableLook, controller.lookEventTypes, look3D);
if (!controller._aggregator.anyButtonDown() && (!defined(controller._lastInertiaZoomMovement) || !controller._lastInertiaZoomMovement.active) &&
(!defined(controller._lastInertiaTranslateMovement) || !controller._lastInertiaTranslateMovement.active) &&
!controller._animationCollection.contains(controller._animation)) {
var animation = controller._cameraController.createCorrectPositionAnimation(controller.bounceAnimationTime);
if (defined(animation)) {
controller._animation = controller._animationCollection.add(animation);
}
}
controller._animationCollection.update();
}
}
var spin3DPick = new Cartesian3();
function spin3D(controller, movement) {
if (defined(controller._cameraController.pickEllipsoid(movement.startPosition, controller._ellipsoid, spin3DPick))) {
pan3D(controller, movement);
} else {
rotate3D(controller, movement);
}
}
var rotate3DRestrictedDirection = Cartesian3.clone(Cartesian3.ZERO);
var rotate3DScratchCartesian3 = new Cartesian3();
var rotate3DNegateScratch = new Cartesian3();
var rotate3DInverseMatrixScratch = new Matrix4();
function rotate3D(controller, movement, transform, constrainedAxis, restrictedAngle) {
var cameraController = controller._cameraController;
var oldAxis = cameraController.constrainedAxis;
if (defined(constrainedAxis)) {
cameraController.constrainedAxis = constrainedAxis;
}
// CAMERA TODO: remove access to camera, fixes a problem in Columbus view
//var rho = cameraController.getMagnitude();
var rho = Cartesian3.magnitude(cameraController._camera.position);
var rotateRate = controller._rotateFactor * (rho - controller._rotateRateRangeAdjustment);
if (rotateRate > controller._maximumRotateRate) {
rotateRate = controller._maximumRotateRate;
}
if (rotateRate < controller._minimumRotateRate) {
rotateRate = controller._minimumRotateRate;
}
var phiWindowRatio = (movement.startPosition.x - movement.endPosition.x) / controller._canvas.clientWidth;
var thetaWindowRatio = (movement.startPosition.y - movement.endPosition.y) / controller._canvas.clientHeight;
phiWindowRatio = Math.min(phiWindowRatio, controller.maximumMovementRatio);
thetaWindowRatio = Math.min(thetaWindowRatio, controller.maximumMovementRatio);
var deltaPhi = rotateRate * phiWindowRatio * Math.PI * 2.0;
var deltaTheta = rotateRate * thetaWindowRatio * Math.PI;
if (defined(cameraController.constrainedAxis) && !defined(transform)) {
var camera = cameraController._camera;
var positionNormal = Cartesian3.normalize(camera.position, rotate3DScratchCartesian3);
var northParallel = Cartesian3.equalsEpsilon(positionNormal, cameraController.constrainedAxis, CesiumMath.EPSILON2);
var southParallel = Cartesian3.equalsEpsilon(positionNormal, Cartesian3.negate(cameraController.constrainedAxis, rotate3DNegateScratch), CesiumMath.EPSILON2);
if (!northParallel && !southParallel) {
var up;
if (Cartesian3.dot(camera.position, camera.direction) + 1 < CesiumMath.EPSILON4) {
up = camera.up;
} else {
up = camera.direction;
}
var east;
if (Cartesian3.equalsEpsilon(cameraController.constrainedAxis, positionNormal, CesiumMath.EPSILON2)) {
east = camera.right;
} else {
east = Cartesian3.cross(cameraController.constrainedAxis, positionNormal, rotate3DScratchCartesian3);
Cartesian3.normalize(east, east);
}
var rDotE = Cartesian3.dot(camera.right, east);
var signRDotE = (CesiumMath.sign(rDotE) < 0.0) ? -1.0 : 1.0;
rDotE = Math.abs(rDotE);
var uDotA = Cartesian3.dot(up, cameraController.constrainedAxis);
var uDotE = Cartesian3.dot(up, east);
var signInnerSum = ((uDotA > 0.0 && uDotE > 0.0) || (uDotA < 0.0 && uDotE < 0.0)) ? -1.0 : 1.0;
uDotA = Math.abs(uDotA);
var originalDeltaTheta = deltaTheta;
deltaTheta = signRDotE * (deltaTheta * uDotA - signInnerSum * deltaPhi * (1.0 - rDotE));
deltaPhi = signRDotE * (deltaPhi * rDotE + signInnerSum * originalDeltaTheta * (1.0 - uDotA));
}
}
cameraController.rotateRight(deltaPhi, transform);
cameraController.rotateUp(deltaTheta, transform);
if (defined(restrictedAngle)) {
var direction = Cartesian3.clone(cameraController._camera.directionWC, rotate3DRestrictedDirection);
var invTransform = Matrix4.inverseTransformation(transform, rotate3DInverseMatrixScratch);
direction = Matrix4.multiplyByPointAsVector(invTransform, direction, direction);
var dot = -Cartesian3.dot(direction, constrainedAxis);
var angle = Math.acos(dot);
if (angle > restrictedAngle) {
angle -= restrictedAngle;
cameraController.rotateUp(-angle, transform);
}
}
cameraController.constrainedAxis = oldAxis;
}
var pan3DP0 = Cartesian4.clone(Cartesian4.UNIT_W);
var pan3DP1 = Cartesian4.clone(Cartesian4.UNIT_W);
var pan3DTemp0 = new Cartesian3();
var pan3DTemp1 = new Cartesian3();
var pan3DTemp2 = new Cartesian3();
var pan3DTemp3 = new Cartesian3();
function pan3D(controller, movement) {
var cameraController = controller._cameraController;
var p0 = cameraController.pickEllipsoid(movement.startPosition, controller._ellipsoid, pan3DP0);
var p1 = cameraController.pickEllipsoid(movement.endPosition, controller._ellipsoid, pan3DP1);
if (!defined(p0) || !defined(p1)) {
return;
}
// CAMERA TODO: remove access to camera
p0 = cameraController._camera.worldToCameraCoordinates(p0, p0);
p1 = cameraController._camera.worldToCameraCoordinates(p1, p1);
if (!defined(cameraController.constrainedAxis)) {
Cartesian3.normalize(p0, p0);
Cartesian3.normalize(p1, p1);
var dot = Cartesian3.dot(p0, p1);
var axis = Cartesian3.cross(p0, p1, pan3DTemp0);
if (dot < 1.0 && !Cartesian3.equalsEpsilon(axis, Cartesian3.ZERO, CesiumMath.EPSILON14)) { // dot is in [0, 1]
var angle = Math.acos(dot);
cameraController.rotate(axis, angle);
}
} else {
var basis0 = cameraController.constrainedAxis;
var basis1 = Cartesian3.mostOrthogonalAxis(basis0, pan3DTemp0);
Cartesian3.cross(basis1, basis0, basis1);
Cartesian3.normalize(basis1, basis1);
var basis2 = Cartesian3.cross(basis0, basis1, pan3DTemp1);
var startRho = Cartesian3.magnitude(p0);
var startDot = Cartesian3.dot(basis0, p0);
var startTheta = Math.acos(startDot / startRho);
var startRej = Cartesian3.multiplyByScalar(basis0, startDot, pan3DTemp2);
Cartesian3.subtract(p0, startRej, startRej);
Cartesian3.normalize(startRej, startRej);
var endRho = Cartesian3.magnitude(p1);
var endDot = Cartesian3.dot(basis0, p1);
var endTheta = Math.acos(endDot / endRho);
var endRej = Cartesian3.multiplyByScalar(basis0, endDot, pan3DTemp3);
Cartesian3.subtract(p1, endRej, endRej);
Cartesian3.normalize(endRej, endRej);
var startPhi = Math.acos(Cartesian3.dot(startRej, basis1));
if (Cartesian3.dot(startRej, basis2) < 0) {
startPhi = CesiumMath.TWO_PI - startPhi;
}
var endPhi = Math.acos(Cartesian3.dot(endRej, basis1));
if (Cartesian3.dot(endRej, basis2) < 0) {
endPhi = CesiumMath.TWO_PI - endPhi;
}
var deltaPhi = startPhi - endPhi;
var east;
if (Cartesian3.equalsEpsilon(basis0, cameraController._camera.position, CesiumMath.EPSILON2)) {
east = cameraController._camera.right;
} else {
east = Cartesian3.cross(basis0, cameraController._camera.position, pan3DTemp0);
}
var planeNormal = Cartesian3.cross(basis0, east, pan3DTemp0);
var side0 = Cartesian3.dot(planeNormal, Cartesian3.subtract(p0, basis0, pan3DTemp1));
var side1 = Cartesian3.dot(planeNormal, Cartesian3.subtract(p1, basis0, pan3DTemp1));
var deltaTheta;
if (side0 > 0 && side1 > 0) {
deltaTheta = endTheta - startTheta;
} else if (side0 > 0 && side1 <= 0) {
if (Cartesian3.dot(cameraController._camera.position, basis0) > 0) {
deltaTheta = -startTheta - endTheta;
} else {
deltaTheta = startTheta + endTheta;
}
} else {
deltaTheta = startTheta - endTheta;
}
cameraController.rotateRight(deltaPhi);
cameraController.rotateUp(deltaTheta);
}
}
var zoom3DUnitPosition = new Cartesian3();
function zoom3D(controller, movement) {
if (defined(movement.distance)) {
movement = movement.distance;
}
// CAMERA TODO: remove access to camera
var camera = controller._cameraController._camera;
var ellipsoid = controller._ellipsoid;
var height = ellipsoid.cartesianToCartographic(camera.position).height;
var unitPosition = Cartesian3.normalize(camera.position, zoom3DUnitPosition);
handleZoom(controller, movement, controller._zoomFactor, height, Cartesian3.dot(unitPosition, camera.direction));
}
var tilt3DWindowPos = new Cartesian2();
var tilt3DRay = new Ray();
var tilt3DCart = new Cartographic();
var tilt3DCenter = Cartesian4.clone(Cartesian4.UNIT_W);
var tilt3DTransform = new Matrix4();
function tilt3D(controller, movement) {
if (defined(movement.angleAndHeight)) {
movement = movement.angleAndHeight;
}
var cameraController = controller._cameraController;
var ellipsoid = controller._ellipsoid;
var minHeight = controller.minimumZoomDistance * 0.25;
var height = ellipsoid.cartesianToCartographic(controller._cameraController._camera.position).height;
if (height - minHeight - 1.0 < CesiumMath.EPSILON3 &&
movement.endPosition.y - movement.startPosition.y < 0) {
return;
}
var windowPosition = tilt3DWindowPos;
windowPosition.x = controller._canvas.clientWidth / 2;
windowPosition.y = controller._canvas.clientHeight / 2;
var ray = cameraController.getPickRay(windowPosition, tilt3DRay);
var center;
var intersection = IntersectionTests.rayEllipsoid(ray, ellipsoid);
if (defined(intersection)) {
center = ray.getPoint(intersection.start, tilt3DCenter);
} else {
var grazingAltitudeLocation = IntersectionTests.grazingAltitudeLocation(ray, ellipsoid);
if (!defined(grazingAltitudeLocation)) {
return;
}
var grazingAltitudeCart = ellipsoid.cartesianToCartographic(grazingAltitudeLocation, tilt3DCart);
grazingAltitudeCart.height = 0.0;
center = ellipsoid.cartographicToCartesian(grazingAltitudeCart, tilt3DCenter);
}
// CAMERA TODO: Remove the need for camera access
var camera = cameraController._camera;
center = camera.worldToCameraCoordinates(center, center);
var transform = Transforms.eastNorthUpToFixedFrame(center, ellipsoid, tilt3DTransform);
var oldEllipsoid = controller._ellipsoid;
controller.setEllipsoid(Ellipsoid.UNIT_SPHERE);
var angle = (minHeight * 0.25) / Cartesian3.distance(center, camera.position);
rotate3D(controller, movement, transform, Cartesian3.UNIT_Z, CesiumMath.PI_OVER_TWO - angle);
controller.setEllipsoid(oldEllipsoid);
}
var look3DStartPos = new Cartesian2();
var look3DEndPos = new Cartesian2();
var look3DStartRay = new Ray();
var look3DEndRay = new Ray();
function look3D(controller, movement) {
var cameraController = controller._cameraController;
var startPos = look3DStartPos;
startPos.x = movement.startPosition.x;
startPos.y = 0.0;
var endPos = look3DEndPos;
endPos.x = movement.endPosition.x;
endPos.y = 0.0;
var start = cameraController.getPickRay(startPos, look3DStartRay).direction;
var end = cameraController.getPickRay(endPos, look3DEndRay).direction;
var angle = 0.0;
var dot = Cartesian3.dot(start, end);
if (dot < 1.0) { // dot is in [0, 1]
angle = Math.acos(dot);
}
angle = (movement.startPosition.x > movement.endPosition.x) ? -angle : angle;
var rotationAxis = controller._horizontalRotationAxis;
if (defined(rotationAxis)) {
cameraController.look(rotationAxis, angle);
} else {
cameraController.lookLeft(angle);
}
startPos.x = 0.0;
startPos.y = movement.startPosition.y;
endPos.x = 0.0;
endPos.y = movement.endPosition.y;
start = cameraController.getPickRay(startPos, look3DStartRay).direction;
end = cameraController.getPickRay(endPos, look3DEndRay).direction;
angle = 0.0;
dot = Cartesian3.dot(start, end);
if (dot < 1.0) { // dot is in [0, 1]
angle = Math.acos(dot);
}
angle = (movement.startPosition.y > movement.endPosition.y) ? -angle : angle;
cameraController.lookUp(angle);
}
function update3D(controller) {
reactToInput(controller, controller.enableRotate, controller.rotateEventTypes, spin3D, controller.inertiaSpin, '_lastInertiaSpinMovement');
reactToInput(controller, controller.enableZoom, controller.zoomEventTypes, zoom3D, controller.inertiaZoom, '_lastInertiaZoomMovement');
reactToInput(controller, controller.enableTilt, controller.tiltEventTypes, tilt3D, controller.inertiaSpin, '_lastInertiaTiltMovement');
reactToInput(controller, controller.enableLook, controller.lookEventTypes, look3D);
}
/**
* @private
*/
ScreenSpaceCameraController.prototype.update = function(mode) {
if (mode === SceneMode.SCENE2D) {
update2D(this);
} else if (mode === SceneMode.COLUMBUS_VIEW) {
this._horizontalRotationAxis = Cartesian3.UNIT_Z;
updateCV(this);
} else if (mode === SceneMode.SCENE3D) {
this._horizontalRotationAxis = undefined;
update3D(this);
}
this._aggregator.reset();
};
/**
* Returns true if this object was destroyed; otherwise, false.
* <br /><br />
* If this object was destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
*
* @memberof ScreenSpaceCameraController
*
* @returns {Boolean} <code>true</code> if this object was destroyed; otherwise, <code>false</code>.
*
* @see ScreenSpaceCameraController#destroy
*/
ScreenSpaceCameraController.prototype.isDestroyed = function() {
return false;
};
/**
* Removes mouse listeners held by this object.
* <br /><br />
* Once an object is destroyed, it should not be used; calling any function other than
* <code>isDestroyed</code> will result in a {@link DeveloperError} exception. Therefore,
* assign the return value (<code>undefined</code>) to the object as done in the example.
*
* @memberof ScreenSpaceCameraController
*
* @returns {undefined}
*
* @exception {DeveloperError} This object was destroyed, i.e., destroy() was called.
*
* @see ScreenSpaceCameraController#isDestroyed
*
* @example
* controller = controller && controller.destroy();
*/
ScreenSpaceCameraController.prototype.destroy = function() {
this._animationCollection.removeAll();
this._spinHandler = this._spinHandler && this._spinHandler.destroy();
this._translateHandler = this._translateHandler && this._translateHandler.destroy();
this._lookHandler = this._lookHandler && this._lookHandler.destroy();
this._rotateHandler = this._rotateHandler && this._rotateHandler.destroy();
this._zoomHandler = this._zoomHandler && this._zoomHandler.destroy();
this._zoomWheelHandler = this._zoomWheelHandler && this._zoomWheelHandler.destroy();
this._pinchHandler = this._pinchHandler && this._pinchHandler.destroy();
return destroyObject(this);
};
return ScreenSpaceCameraController;
});