import { BoundingSphere } from "../../Source/Cesium.js";
|
import { Cartesian2 } from "../../Source/Cesium.js";
|
import { Cartesian3 } from "../../Source/Cesium.js";
|
import { Cartesian4 } from "../../Source/Cesium.js";
|
import { Cartographic } from "../../Source/Cesium.js";
|
import { defaultValue } from "../../Source/Cesium.js";
|
import { Ellipsoid } from "../../Source/Cesium.js";
|
import { GeographicProjection } from "../../Source/Cesium.js";
|
import { HeadingPitchRange } from "../../Source/Cesium.js";
|
import { Math as CesiumMath } from "../../Source/Cesium.js";
|
import { Matrix3 } from "../../Source/Cesium.js";
|
import { Matrix4 } from "../../Source/Cesium.js";
|
import { OrthographicFrustum } from "../../Source/Cesium.js";
|
import { OrthographicOffCenterFrustum } from "../../Source/Cesium.js";
|
import { PerspectiveFrustum } from "../../Source/Cesium.js";
|
import { Rectangle } from "../../Source/Cesium.js";
|
import { Transforms } from "../../Source/Cesium.js";
|
import { WebMercatorProjection } from "../../Source/Cesium.js";
|
import { Camera } from "../../Source/Cesium.js";
|
import { CameraFlightPath } from "../../Source/Cesium.js";
|
import { MapMode2D } from "../../Source/Cesium.js";
|
import { SceneMode } from "../../Source/Cesium.js";
|
import { TweenCollection } from "../../Source/Cesium.js";
|
|
describe("Scene/Camera", function () {
|
var scene;
|
var camera;
|
|
var position;
|
var up;
|
var dir;
|
var right;
|
|
var moveAmount = 3.0;
|
var turnAmount = CesiumMath.PI_OVER_TWO;
|
var rotateAmount = CesiumMath.PI_OVER_TWO;
|
var zoomAmount = 1.0;
|
|
function FakeScene(projection) {
|
this.canvas = {
|
clientWidth: 512,
|
clientHeight: 384,
|
};
|
this.drawingBufferWidth = 1024;
|
this.drawingBufferHeight = 768;
|
this.mapProjection = defaultValue(projection, new GeographicProjection());
|
this.tweens = new TweenCollection();
|
this.screenSpaceCameraController = {
|
minimumZoomDistance: 0,
|
maximumZoomDistance: 5906376272000.0, // distance from the Sun to Pluto in meters.
|
};
|
this.camera = undefined;
|
this.preloadFlightCamera = undefined;
|
this.context = {
|
drawingBufferWidth: 1024,
|
drawingBufferHeight: 768,
|
};
|
this.mapMode2D = MapMode2D.INFINITE_2D;
|
}
|
|
beforeEach(function () {
|
position = Cartesian3.clone(Cartesian3.UNIT_Z);
|
up = Cartesian3.clone(Cartesian3.UNIT_Y);
|
dir = Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3());
|
right = Cartesian3.cross(dir, up, new Cartesian3());
|
|
scene = new FakeScene();
|
|
camera = new Camera(scene);
|
camera.position = Cartesian3.clone(position);
|
camera.up = Cartesian3.clone(up);
|
camera.direction = Cartesian3.clone(dir);
|
camera.right = Cartesian3.clone(right);
|
|
camera.minimumZoomDistance = 0.0;
|
|
scene.camera = camera;
|
scene.preloadFlightCamera = Camera.clone(camera);
|
camera._scene = scene;
|
scene.mapMode2D = MapMode2D.INFINITE_2D;
|
});
|
|
it("constructor throws an exception when there is no canvas", function () {
|
expect(function () {
|
return new Camera();
|
}).toThrowDeveloperError();
|
});
|
|
it("get view matrix", function () {
|
var viewMatrix = camera.viewMatrix;
|
var position = camera.position;
|
var up = camera.up;
|
var dir = camera.direction;
|
var right = camera.right;
|
var rotation = new Matrix4(
|
right.x,
|
right.y,
|
right.z,
|
0.0,
|
up.x,
|
up.y,
|
up.z,
|
0.0,
|
-dir.x,
|
-dir.y,
|
-dir.z,
|
0.0,
|
0.0,
|
0.0,
|
0.0,
|
1.0
|
);
|
var translation = new Matrix4(
|
1.0,
|
0.0,
|
0.0,
|
-position.x,
|
0.0,
|
1.0,
|
0.0,
|
-position.y,
|
0.0,
|
0.0,
|
1.0,
|
-position.z,
|
0.0,
|
0.0,
|
0.0,
|
1.0
|
);
|
var expected = Matrix4.multiply(rotation, translation, new Matrix4());
|
expect(viewMatrix).toEqual(expected);
|
});
|
|
it("get inverse view matrix", function () {
|
var expected = Matrix4.inverse(camera.viewMatrix, new Matrix4());
|
expect(expected).toEqualEpsilon(
|
camera.inverseViewMatrix,
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("get inverse transform", function () {
|
camera._setTransform(
|
new Matrix4(
|
5.0,
|
0.0,
|
0.0,
|
1.0,
|
0.0,
|
5.0,
|
0.0,
|
2.0,
|
0.0,
|
0.0,
|
5.0,
|
3.0,
|
0.0,
|
0.0,
|
0.0,
|
1.0
|
)
|
);
|
var expected = Matrix4.inverseTransformation(
|
camera.transform,
|
new Matrix4()
|
);
|
expect(expected).toEqual(camera.inverseTransform);
|
});
|
|
it("Computes orthonormal direction, up, and right vectors", function () {
|
camera.direction = new Cartesian3(
|
-0.32297853365047874,
|
0.9461560708446421,
|
0.021761351171635013
|
);
|
camera.up = new Cartesian3(
|
0.9327219113001013,
|
0.31839266745173644,
|
-2.9874778345595487e-10
|
);
|
camera.right = new Cartesian3(
|
0.0069286549295528715,
|
-0.020297288960790985,
|
0.9853344956450351
|
);
|
|
expect(Cartesian3.magnitude(camera.right)).not.toEqualEpsilon(
|
1.0,
|
CesiumMath.EPSILON8
|
);
|
expect(Cartesian3.magnitude(camera.up)).not.toEqualEpsilon(
|
1.0,
|
CesiumMath.EPSILON8
|
);
|
|
// Trigger updateMembers which normalizes the axes
|
var viewMatrix = camera.viewMatrix;
|
expect(Cartesian3.magnitude(camera.right)).toEqualEpsilon(
|
1.0,
|
CesiumMath.EPSILON8
|
);
|
expect(Cartesian3.magnitude(camera.up)).toEqualEpsilon(
|
1.0,
|
CesiumMath.EPSILON8
|
);
|
|
var inverseAffine = Matrix4.inverseTransformation(
|
viewMatrix,
|
new Matrix4()
|
);
|
var inverse = Matrix4.inverse(viewMatrix, new Matrix4());
|
expect(inverseAffine).toEqualEpsilon(inverse, CesiumMath.EPSILON8);
|
});
|
|
it("get heading is undefined when morphing", function () {
|
camera._mode = SceneMode.MORPHING;
|
expect(camera.heading).not.toBeDefined();
|
});
|
|
it("get heading in 2D", function () {
|
camera._mode = SceneMode.SCENE2D;
|
|
var positionWC = Cartesian3.clone(camera.positionWC);
|
var position = Cartesian3.clone(camera.position);
|
var direction = Cartesian3.clone(camera.direction);
|
var up = Cartesian3.clone(camera.up);
|
var right = Cartesian3.clone(camera.right);
|
|
var heading =
|
CesiumMath.TWO_PI - Math.atan2(camera.right.y, camera.right.x);
|
expect(camera.heading).toEqual(heading);
|
|
expect(camera.positionWC).toEqualEpsilon(positionWC, CesiumMath.EPSILON8);
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON8);
|
expect(camera.direction).toEqualEpsilon(direction, CesiumMath.EPSILON8);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON8);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON8);
|
});
|
|
it("get heading in CV", function () {
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
|
var positionWC = Cartesian3.clone(camera.positionWC);
|
var position = Cartesian3.clone(camera.position);
|
var direction = Cartesian3.clone(camera.direction);
|
var up = Cartesian3.clone(camera.up);
|
var right = Cartesian3.clone(camera.right);
|
|
var heading =
|
CesiumMath.TWO_PI - Math.atan2(camera.right.y, camera.right.x);
|
expect(camera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON8);
|
|
expect(camera.positionWC).toEqualEpsilon(positionWC, CesiumMath.EPSILON8);
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON8);
|
expect(camera.direction).toEqualEpsilon(direction, CesiumMath.EPSILON8);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON8);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON8);
|
});
|
|
it("get heading in 3D", function () {
|
camera._mode = SceneMode.SCENE3D;
|
|
var ellipsoid = Ellipsoid.WGS84;
|
var toFixedFrame = Transforms.eastNorthUpToFixedFrame(
|
camera.position,
|
ellipsoid
|
);
|
var transform = Matrix4.getMatrix3(toFixedFrame, new Matrix3());
|
Matrix3.transpose(transform, transform);
|
|
var right = Matrix3.multiplyByVector(
|
transform,
|
camera.right,
|
new Cartesian3()
|
);
|
var heading =
|
CesiumMath.TWO_PI - CesiumMath.zeroToTwoPi(Math.atan2(right.y, right.x));
|
|
var positionWC = Cartesian3.clone(camera.positionWC);
|
var position = Cartesian3.clone(camera.position);
|
var direction = Cartesian3.clone(camera.direction);
|
var up = Cartesian3.clone(camera.up);
|
right = Cartesian3.clone(camera.right);
|
|
expect(camera.heading).toEqual(heading);
|
|
expect(camera.positionWC).toEqualEpsilon(positionWC, CesiumMath.EPSILON8);
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON8);
|
expect(camera.direction).toEqualEpsilon(direction, CesiumMath.EPSILON8);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON8);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON8);
|
});
|
|
it("sets heading in 2D when the map can be rotated", function () {
|
scene.mapMode2D = MapMode2D.ROTATE;
|
camera._mode = SceneMode.SCENE2D;
|
|
var heading = camera.heading;
|
var positionCartographic = camera.positionCartographic;
|
|
var newHeading = CesiumMath.toRadians(45.0);
|
camera.setView({
|
orientation: {
|
heading: newHeading,
|
},
|
});
|
|
expect(camera.positionCartographic).toEqual(positionCartographic);
|
expect(camera.heading).not.toEqual(heading);
|
expect(camera.heading).toEqualEpsilon(newHeading, CesiumMath.EPSILON14);
|
});
|
|
it("does not set heading in 2D for infinite scrolling mode", function () {
|
camera._mode = SceneMode.SCENE2D;
|
|
var heading = camera.heading;
|
var positionCartographic = camera.positionCartographic;
|
|
var newHeading = CesiumMath.toRadians(45.0);
|
camera.setView({
|
orientation: {
|
heading: newHeading,
|
},
|
});
|
|
expect(camera.positionCartographic).toEqual(positionCartographic);
|
expect(camera.heading).toEqual(heading);
|
});
|
|
it("set heading in CV", function () {
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
|
camera.position = Cartesian3.fromDegrees(-72.0, 40.0, 100000.0);
|
camera.direction = Cartesian3.negate(
|
Cartesian3.normalize(camera.position, new Cartesian3()),
|
new Cartesian3()
|
);
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var heading = camera.heading;
|
var positionCartographic = camera.positionCartographic;
|
|
var newHeading = CesiumMath.toRadians(45.0);
|
camera.setView({
|
orientation: {
|
heading: newHeading,
|
},
|
});
|
|
expect(camera.positionCartographic).toEqual(positionCartographic);
|
expect(camera.heading).not.toEqual(heading);
|
expect(camera.heading).toEqualEpsilon(newHeading, CesiumMath.EPSILON4);
|
});
|
|
it("set heading in 3D", function () {
|
camera._mode = SceneMode.SCENE3D;
|
|
camera.position = Cartesian3.clone(Cartesian3.UNIT_X);
|
camera.direction = Cartesian3.negate(Cartesian3.UNIT_X, new Cartesian3());
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var heading = camera.heading;
|
var newHeading = CesiumMath.toRadians(45.0);
|
camera.setView({
|
orientation: {
|
heading: newHeading,
|
},
|
});
|
|
expect(camera.heading).not.toEqual(heading);
|
expect(camera.heading).toEqualEpsilon(newHeading, CesiumMath.EPSILON14);
|
});
|
|
it("set heading in 3D (2)", function () {
|
camera._mode = SceneMode.SCENE3D;
|
|
camera.position = Cartesian3.fromDegrees(136.0, -24.0, 4500000.0);
|
Cartesian3.negate(camera.position, camera.direction);
|
Cartesian3.normalize(camera.direction, camera.direction);
|
Cartesian3.clone(Cartesian3.UNIT_Z, camera.up);
|
Cartesian3.cross(camera.direction, camera.up, camera.right);
|
Cartesian3.cross(camera.right, camera.direction, camera.up);
|
|
var positionCartographic = camera.positionCartographic;
|
|
camera.setView({
|
orientation: {
|
heading: CesiumMath.PI,
|
},
|
});
|
|
expect(camera.positionCartographic).toEqual(positionCartographic);
|
expect(camera.heading).toEqualEpsilon(CesiumMath.PI, CesiumMath.EPSILON8);
|
expect(camera.up.z).toBeLessThan(0.0);
|
|
camera.setView({
|
orientation: {
|
heading: CesiumMath.TWO_PI,
|
},
|
});
|
|
expect(camera.positionCartographic).toEqual(positionCartographic);
|
expect(camera.heading).toEqualEpsilon(
|
CesiumMath.TWO_PI,
|
CesiumMath.EPSILON8
|
);
|
expect(camera.up.z).toBeGreaterThan(0.0);
|
});
|
|
it("pitch is undefined when mode is not 3D or Columbus view", function () {
|
camera._mode = SceneMode.MORPHING;
|
expect(camera.pitch).not.toBeDefined();
|
});
|
|
it("get pitch in CV", function () {
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
|
camera.position = Cartesian3.fromDegrees(0.0, 0.0, 100000.0);
|
camera.direction = Cartesian3.negate(
|
Cartesian3.normalize(camera.position, new Cartesian3()),
|
new Cartesian3()
|
);
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var positionWC = Cartesian3.clone(camera.positionWC);
|
var position = Cartesian3.clone(camera.position);
|
var direction = Cartesian3.clone(camera.direction);
|
var up = Cartesian3.clone(camera.up);
|
var right = Cartesian3.clone(camera.right);
|
|
var pitch = CesiumMath.PI_OVER_TWO - Math.acos(-camera.direction.z);
|
expect(camera.pitch).toEqualEpsilon(pitch, CesiumMath.EPSILON6);
|
|
expect(camera.positionWC).toEqualEpsilon(positionWC, CesiumMath.EPSILON8);
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON8);
|
expect(camera.direction).toEqualEpsilon(direction, CesiumMath.EPSILON8);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON8);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON8);
|
});
|
|
it("get pitch in 3D", function () {
|
camera._mode = SceneMode.SCENE3D;
|
|
var direction = Cartesian3.normalize(camera.position, new Cartesian3());
|
Cartesian3.negate(direction, direction);
|
var pitch =
|
CesiumMath.PI_OVER_TWO -
|
Math.acos(-Cartesian3.dot(camera.direction, direction));
|
|
var positionWC = Cartesian3.clone(camera.positionWC);
|
var position = Cartesian3.clone(camera.position);
|
direction = Cartesian3.clone(camera.direction);
|
var up = Cartesian3.clone(camera.up);
|
var right = Cartesian3.clone(camera.right);
|
|
expect(camera.pitch).toEqual(pitch);
|
|
expect(camera.positionWC).toEqualEpsilon(positionWC, CesiumMath.EPSILON8);
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON8);
|
expect(camera.direction).toEqualEpsilon(direction, CesiumMath.EPSILON8);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON8);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON8);
|
});
|
|
it("set pitch in CV", function () {
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
|
camera.position = Cartesian3.fromDegrees(-72.0, 40.0, 100000.0);
|
camera.direction = Cartesian3.negate(
|
Cartesian3.normalize(camera.position, new Cartesian3()),
|
new Cartesian3()
|
);
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var pitch = camera.pitch;
|
var positionCartographic = camera.positionCartographic;
|
|
var newPitch = CesiumMath.toRadians(45.0);
|
camera.setView({
|
orientation: {
|
pitch: newPitch,
|
},
|
});
|
|
expect(camera.positionCartographic).toEqual(positionCartographic);
|
expect(camera.pitch).not.toEqual(pitch);
|
expect(camera.pitch).toEqualEpsilon(newPitch, CesiumMath.EPSILON4);
|
});
|
|
it("set pitch in 3D", function () {
|
camera._mode = SceneMode.SCENE3D;
|
|
camera.position = Cartesian3.fromDegrees(-72.0, 40.0, 100000.0);
|
camera.direction = Cartesian3.negate(Cartesian3.UNIT_X, new Cartesian3());
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var pitch = camera.pitch;
|
var positionCartographic = camera.positionCartographic;
|
|
var newPitch = CesiumMath.toRadians(45.0);
|
camera.setView({
|
orientation: {
|
pitch: newPitch,
|
},
|
});
|
|
expect(camera.positionCartographic).toEqual(positionCartographic);
|
expect(camera.pitch).not.toEqual(pitch);
|
expect(camera.pitch).toEqualEpsilon(newPitch, CesiumMath.EPSILON14);
|
});
|
|
it("get roll in CV", function () {
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
|
camera.position = Cartesian3.fromDegrees(0.0, 0.0, 100000.0);
|
camera.direction = Cartesian3.negate(
|
Cartesian3.normalize(camera.position, new Cartesian3()),
|
new Cartesian3()
|
);
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
camera.look(camera.direction, CesiumMath.toRadians(45.0));
|
|
var positionWC = Cartesian3.clone(camera.positionWC);
|
var position = Cartesian3.clone(camera.position);
|
var direction = Cartesian3.clone(camera.direction);
|
var up = Cartesian3.clone(camera.up);
|
var right = Cartesian3.clone(camera.right);
|
|
var roll = CesiumMath.zeroToTwoPi(-CesiumMath.toRadians(45.0));
|
expect(camera.roll).toEqualEpsilon(roll, CesiumMath.EPSILON6);
|
|
expect(camera.positionWC).toEqualEpsilon(positionWC, CesiumMath.EPSILON8);
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON8);
|
expect(camera.direction).toEqualEpsilon(direction, CesiumMath.EPSILON8);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON8);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON8);
|
});
|
|
it("get roll in 3D", function () {
|
camera._mode = SceneMode.SCENE3D;
|
|
var ellipsoid = Ellipsoid.WGS84;
|
camera.position = Cartesian3.clone(Cartesian3.UNIT_X);
|
Cartesian3.multiplyByScalar(
|
camera.position,
|
ellipsoid.maximumRadius + 100.0,
|
camera.position
|
);
|
camera.direction = new Cartesian3(-1.0, 0.0, 1.0);
|
Cartesian3.normalize(camera.direction, camera.direction);
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
Cartesian3.UNIT_Z,
|
new Cartesian3()
|
);
|
Cartesian3.normalize(camera.right, camera.right);
|
camera.up = Cartesian3.cross(
|
camera.right,
|
camera.direction,
|
new Cartesian3()
|
);
|
|
var toFixedFrame = Transforms.eastNorthUpToFixedFrame(
|
camera.position,
|
ellipsoid
|
);
|
var transform = Matrix4.getMatrix3(toFixedFrame, new Matrix3());
|
Matrix3.transpose(transform, transform);
|
|
var right = Matrix3.multiplyByVector(
|
transform,
|
camera.right,
|
new Cartesian3()
|
);
|
var roll = CesiumMath.TWO_PI - Math.atan2(right.z, right.x);
|
|
var positionWC = Cartesian3.clone(camera.positionWC);
|
var position = Cartesian3.clone(camera.position);
|
var direction = Cartesian3.clone(camera.direction);
|
var up = Cartesian3.clone(camera.up);
|
right = Cartesian3.clone(camera.right);
|
|
expect(camera.roll).toEqual(roll);
|
|
expect(camera.positionWC).toEqualEpsilon(positionWC, CesiumMath.EPSILON8);
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON8);
|
expect(camera.direction).toEqualEpsilon(direction, CesiumMath.EPSILON8);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON8);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON8);
|
});
|
|
it("get roll returns correct value past 90 degrees", function () {
|
var roll = CesiumMath.toRadians(110.0);
|
camera.setView({
|
destination: Cartesian3.fromDegrees(-72.0, 40.0, 20.0),
|
orientation: {
|
heading: 0.0,
|
pitch: 0.0,
|
roll: roll,
|
},
|
});
|
|
expect(camera.roll).toEqualEpsilon(roll, CesiumMath.EPSILON14);
|
});
|
|
it("set roll in CV", function () {
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
|
camera.position = Cartesian3.fromDegrees(-72.0, 40.0, 100000.0);
|
camera.direction = Cartesian3.clone(Cartesian3.UNIT_Y);
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var roll = camera.roll;
|
var positionCartographic = camera.positionCartographic;
|
|
var newRoll = CesiumMath.PI_OVER_FOUR;
|
camera.setView({
|
orientation: {
|
pitch: camera.pitch,
|
roll: newRoll,
|
heading: camera.heading,
|
},
|
});
|
|
expect(camera.positionCartographic).toEqual(positionCartographic);
|
expect(camera.roll).not.toEqual(roll);
|
expect(camera.roll).toEqualEpsilon(newRoll, CesiumMath.EPSILON6);
|
});
|
|
it("set roll in 3D", function () {
|
camera._mode = SceneMode.SCENE3D;
|
|
camera.position = Cartesian3.fromDegrees(-72.0, 40.0, 100000.0);
|
camera.direction = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_X);
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var roll = camera.roll;
|
var positionCartographic = Cartographic.clone(camera.positionCartographic);
|
|
var newRoll = CesiumMath.PI_OVER_FOUR;
|
camera.setView({
|
orientation: {
|
pitch: camera.pitch,
|
roll: newRoll,
|
heading: camera.heading,
|
},
|
});
|
|
expect(camera.positionCartographic).toEqual(positionCartographic);
|
expect(camera.roll).not.toEqual(roll);
|
expect(camera.roll).toEqualEpsilon(newRoll, CesiumMath.EPSILON6);
|
});
|
|
it("update throws without mode", function () {
|
expect(function () {
|
camera.update();
|
}).toThrowDeveloperError();
|
});
|
|
it("update throws with frustum not supported in given mode", function () {
|
camera.frustum = new PerspectiveFrustum();
|
expect(function () {
|
camera.update(SceneMode.SCENE2D);
|
}).toThrowDeveloperError();
|
|
camera.frustum = new OrthographicOffCenterFrustum();
|
expect(function () {
|
camera.update(SceneMode.SCENE3D);
|
}).toThrowDeveloperError();
|
expect(function () {
|
camera.update(SceneMode.COLUMBUS_VIEW);
|
}).toThrowDeveloperError();
|
});
|
|
it("setView with cartesian in 2D", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var projection = new GeographicProjection(ellipsoid);
|
var maxRadii = ellipsoid.maximumRadius;
|
|
camera._mode = SceneMode.SCENE2D;
|
camera._projection = projection;
|
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.right = maxRadii * Math.PI;
|
frustum.left = -frustum.right;
|
frustum.top =
|
frustum.right * (scene.drawingBufferHeight / scene.drawingBufferWidth);
|
frustum.bottom = -frustum.top;
|
frustum.near = 0.01 * maxRadii;
|
frustum.far = 60.0 * maxRadii;
|
camera.frustum = frustum;
|
|
var ratio = frustum.top / frustum.right;
|
var cartesian = Cartesian3.fromDegrees(-75.0, 42.0, 100.0);
|
camera.setView({
|
destination: cartesian,
|
});
|
|
var cart = ellipsoid.cartesianToCartographic(cartesian);
|
expect(camera.positionCartographic).toEqualEpsilon(
|
cart,
|
CesiumMath.EPSILON6
|
);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3()),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.up).toEqualEpsilon(Cartesian3.UNIT_Y, CesiumMath.EPSILON6);
|
expect(camera.right).toEqualEpsilon(Cartesian3.UNIT_X, CesiumMath.EPSILON6);
|
expect(frustum.right - frustum.left).toEqualEpsilon(
|
cart.height,
|
CesiumMath.EPSILON6
|
);
|
expect(frustum.top / frustum.right).toEqual(ratio);
|
});
|
|
it("setView with cartesian in Columbus View", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var projection = new GeographicProjection(ellipsoid);
|
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
camera._projection = projection;
|
|
var cartesian = Cartesian3.fromDegrees(-75.0, 42.0, 100.0);
|
camera.setView({
|
destination: cartesian,
|
});
|
|
var cart = ellipsoid.cartesianToCartographic(cartesian);
|
expect(camera.positionCartographic).toEqualEpsilon(
|
cart,
|
CesiumMath.EPSILON11
|
);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3()),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.up).toEqualEpsilon(Cartesian3.UNIT_Y, CesiumMath.EPSILON6);
|
expect(camera.right).toEqualEpsilon(Cartesian3.UNIT_X, CesiumMath.EPSILON6);
|
});
|
|
it("setView with cartesian in 3D", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var projection = new GeographicProjection(ellipsoid);
|
|
camera._mode = SceneMode.SCENE3D;
|
camera._projection = projection;
|
|
var cartesian = Cartesian3.fromDegrees(-75.0, 0.0, 100.0);
|
camera.setView({
|
destination: cartesian,
|
});
|
|
expect(camera.positionCartographic).toEqualEpsilon(
|
ellipsoid.cartesianToCartographic(cartesian),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.normalize(
|
Cartesian3.negate(camera.position, new Cartesian3()),
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.up).toEqualEpsilon(Cartesian3.UNIT_Z, CesiumMath.EPSILON6);
|
expect(camera.right).toEqualEpsilon(
|
Cartesian3.cross(camera.direction, camera.up, new Cartesian3()),
|
CesiumMath.EPSILON6
|
);
|
});
|
|
it("setView with cartesian in Columbus View and orthographic frustum", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var projection = new GeographicProjection(ellipsoid);
|
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
camera._projection = projection;
|
|
camera.frustum = new OrthographicFrustum();
|
camera.frustum.aspectRatio =
|
scene.drawingBufferWidth / scene.drawingBufferHeight;
|
camera.frustum.width = camera.positionCartographic.height;
|
|
var cartesian = Cartesian3.fromDegrees(-75.0, 42.0, 100.0);
|
camera.setView({
|
destination: cartesian,
|
});
|
|
var cart = ellipsoid.cartesianToCartographic(cartesian);
|
expect(camera.positionCartographic).toEqualEpsilon(
|
cart,
|
CesiumMath.EPSILON11
|
);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3()),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.up).toEqualEpsilon(Cartesian3.UNIT_Y, CesiumMath.EPSILON6);
|
expect(camera.right).toEqualEpsilon(Cartesian3.UNIT_X, CesiumMath.EPSILON6);
|
expect(camera.frustum.width).toEqual(cart.height);
|
});
|
|
it("setView with cartesian in 3D and orthographic frustum", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var projection = new GeographicProjection(ellipsoid);
|
|
camera._mode = SceneMode.SCENE3D;
|
camera._projection = projection;
|
|
camera.frustum = new OrthographicFrustum();
|
camera.frustum.aspectRatio =
|
scene.drawingBufferWidth / scene.drawingBufferHeight;
|
camera.frustum.width = camera.positionCartographic.height;
|
|
var cartesian = Cartesian3.fromDegrees(-75.0, 0.0, 100.0);
|
camera.setView({
|
destination: cartesian,
|
});
|
|
var cart = ellipsoid.cartesianToCartographic(cartesian);
|
expect(camera.positionCartographic).toEqualEpsilon(
|
cart,
|
CesiumMath.EPSILON6
|
);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.normalize(
|
Cartesian3.negate(camera.position, new Cartesian3()),
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.up).toEqualEpsilon(Cartesian3.UNIT_Z, CesiumMath.EPSILON6);
|
expect(camera.right).toEqualEpsilon(
|
Cartesian3.cross(camera.direction, camera.up, new Cartesian3()),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.frustum.width).toEqual(cart.height);
|
});
|
|
it("setView right rotation order", function () {
|
var position = Cartesian3.fromDegrees(-117.16, 32.71, 0.0);
|
var heading = CesiumMath.toRadians(180.0);
|
var pitch = CesiumMath.toRadians(0.0);
|
var roll = CesiumMath.toRadians(45.0);
|
|
camera.setView({
|
destination: position,
|
orientation: {
|
heading: heading,
|
pitch: pitch,
|
roll: roll,
|
},
|
});
|
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON6);
|
expect(camera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(camera.pitch).toEqualEpsilon(pitch, CesiumMath.EPSILON6);
|
expect(camera.roll).toEqualEpsilon(roll, CesiumMath.EPSILON6);
|
});
|
|
it("setView (1)", function () {
|
var position = Cartesian3.fromDegrees(-117.16, 32.71, 0.0);
|
var heading = CesiumMath.toRadians(45.0);
|
var pitch = CesiumMath.toRadians(-50.0);
|
var roll = CesiumMath.toRadians(45.0);
|
|
camera.setView({
|
destination: position,
|
orientation: {
|
heading: heading,
|
pitch: pitch,
|
roll: roll,
|
},
|
});
|
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON6);
|
expect(camera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(camera.pitch).toEqualEpsilon(pitch, CesiumMath.EPSILON6);
|
expect(camera.roll).toEqualEpsilon(roll, CesiumMath.EPSILON6);
|
|
heading = CesiumMath.toRadians(200.0);
|
|
camera.setView({
|
orientation: {
|
pitch: camera.pitch,
|
roll: camera.roll,
|
heading: heading,
|
},
|
});
|
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON6);
|
expect(camera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(camera.pitch).toEqualEpsilon(pitch, CesiumMath.EPSILON6);
|
expect(camera.roll).toEqualEpsilon(roll, CesiumMath.EPSILON6);
|
});
|
|
it("setView (2)", function () {
|
var position = Cartesian3.fromDegrees(-117.16, 32.71, 0.0);
|
var heading = CesiumMath.toRadians(45.0);
|
var pitch = CesiumMath.toRadians(50.0);
|
var roll = CesiumMath.toRadians(45.0);
|
|
camera.setView({
|
destination: position,
|
orientation: {
|
heading: heading,
|
pitch: pitch,
|
roll: roll,
|
},
|
});
|
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON6);
|
expect(camera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(camera.pitch).toEqualEpsilon(pitch, CesiumMath.EPSILON6);
|
expect(camera.roll).toEqualEpsilon(roll, CesiumMath.EPSILON6);
|
|
pitch = CesiumMath.toRadians(-50.0);
|
|
camera.setView({
|
orientation: {
|
pitch: pitch,
|
roll: camera.roll,
|
heading: camera.heading,
|
},
|
});
|
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON6);
|
expect(camera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(camera.pitch).toEqualEpsilon(pitch, CesiumMath.EPSILON6);
|
expect(camera.roll).toEqualEpsilon(roll, CesiumMath.EPSILON6);
|
});
|
|
it("setView (3)", function () {
|
var position = Cartesian3.fromDegrees(-117.16, 32.71, 0.0);
|
var heading = CesiumMath.toRadians(45.0);
|
var pitch = CesiumMath.toRadians(50.0);
|
var roll = CesiumMath.toRadians(45.0);
|
|
camera.setView({
|
destination: position,
|
orientation: {
|
heading: heading,
|
pitch: pitch,
|
roll: roll,
|
},
|
});
|
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON6);
|
expect(camera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(camera.pitch).toEqualEpsilon(pitch, CesiumMath.EPSILON6);
|
expect(camera.roll).toEqualEpsilon(roll, CesiumMath.EPSILON6);
|
|
roll = CesiumMath.toRadians(200.0);
|
|
camera.setView({
|
orientation: {
|
roll: roll,
|
heading: camera.heading,
|
pitch: camera.pitch,
|
},
|
});
|
|
expect(camera.position).toEqualEpsilon(position, CesiumMath.EPSILON6);
|
expect(camera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(camera.pitch).toEqualEpsilon(pitch, CesiumMath.EPSILON6);
|
expect(camera.roll).toEqualEpsilon(roll, CesiumMath.EPSILON6);
|
});
|
|
it("setView with direction, up", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var direction = Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3());
|
var up = Cartesian3.clone(Cartesian3.UNIT_Y);
|
|
var options = {
|
destination: Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
orientation: {
|
direction: direction,
|
up: up,
|
},
|
duration: 0.001,
|
};
|
camera.setView(options);
|
|
expect(camera.direction).toEqualEpsilon(direction, CesiumMath.EPSILON6);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON6);
|
});
|
|
it("worldToCameraCoordinates throws without cartesian", function () {
|
expect(function () {
|
camera.worldToCameraCoordinates();
|
}).toThrowDeveloperError();
|
});
|
|
it("worldToCameraCoordinates transforms to the cameras reference frame", function () {
|
camera._setTransform(
|
new Matrix4(
|
0.0,
|
0.0,
|
1.0,
|
0.0,
|
1.0,
|
0.0,
|
0.0,
|
0.0,
|
0.0,
|
1.0,
|
0.0,
|
0.0,
|
0.0,
|
0.0,
|
0.0,
|
1.0
|
)
|
);
|
expect(camera.worldToCameraCoordinates(Cartesian4.UNIT_X)).toEqual(
|
Cartesian4.UNIT_Z
|
);
|
});
|
|
it("worldToCameraCoordinatesPoint throws without cartesian", function () {
|
expect(function () {
|
camera.worldToCameraCoordinatesPoint();
|
}).toThrowDeveloperError();
|
});
|
|
it("worldToCameraCoordinatesPoint transforms to the cameras reference frame", function () {
|
camera._setTransform(
|
new Matrix4(
|
0.0,
|
0.0,
|
1.0,
|
10.0,
|
1.0,
|
0.0,
|
0.0,
|
20.0,
|
0.0,
|
1.0,
|
0.0,
|
30.0,
|
0.0,
|
0.0,
|
0.0,
|
1.0
|
)
|
);
|
var expected = Cartesian3.add(
|
Matrix4.getColumn(camera.inverseTransform, 3, new Cartesian4()),
|
Cartesian3.UNIT_Z,
|
new Cartesian3()
|
);
|
expect(camera.worldToCameraCoordinatesPoint(Cartesian3.UNIT_X)).toEqual(
|
expected
|
);
|
});
|
|
it("worldToCameraCoordinatesVector throws without cartesian", function () {
|
expect(function () {
|
camera.worldToCameraCoordinatesVector();
|
}).toThrowDeveloperError();
|
});
|
|
it("worldToCameraCoordinatesVector transforms to the cameras reference frame", function () {
|
camera._setTransform(
|
new Matrix4(
|
0.0,
|
0.0,
|
1.0,
|
10.0,
|
1.0,
|
0.0,
|
0.0,
|
20.0,
|
0.0,
|
1.0,
|
0.0,
|
30.0,
|
0.0,
|
0.0,
|
0.0,
|
1.0
|
)
|
);
|
expect(camera.worldToCameraCoordinatesVector(Cartesian3.UNIT_X)).toEqual(
|
Cartesian3.UNIT_Z
|
);
|
});
|
|
it("cameraToWorldCoordinates throws without cartesian", function () {
|
expect(function () {
|
camera.cameraToWorldCoordinates();
|
}).toThrowDeveloperError();
|
});
|
|
it("cameraToWorldCoordinates transforms from the cameras reference frame", function () {
|
camera._setTransform(
|
new Matrix4(
|
0.0,
|
0.0,
|
1.0,
|
0.0,
|
1.0,
|
0.0,
|
0.0,
|
0.0,
|
0.0,
|
1.0,
|
0.0,
|
0.0,
|
0.0,
|
0.0,
|
0.0,
|
1.0
|
)
|
);
|
expect(camera.cameraToWorldCoordinates(Cartesian4.UNIT_Z)).toEqual(
|
Cartesian4.UNIT_X
|
);
|
});
|
|
it("cameraToWorldCoordinatesPoint throws without cartesian", function () {
|
expect(function () {
|
camera.cameraToWorldCoordinatesPoint();
|
}).toThrowDeveloperError();
|
});
|
|
it("cameraToWorldCoordinatesPoint transforms from the cameras reference frame", function () {
|
camera._setTransform(
|
new Matrix4(
|
0.0,
|
0.0,
|
1.0,
|
10.0,
|
1.0,
|
0.0,
|
0.0,
|
20.0,
|
0.0,
|
1.0,
|
0.0,
|
30.0,
|
0.0,
|
0.0,
|
0.0,
|
1.0
|
)
|
);
|
var expected = Cartesian3.add(
|
Cartesian3.UNIT_X,
|
Matrix4.getColumn(camera.transform, 3, new Cartesian4()),
|
new Cartesian3()
|
);
|
expect(camera.cameraToWorldCoordinatesPoint(Cartesian3.UNIT_Z)).toEqual(
|
expected
|
);
|
});
|
|
it("cameraToWorldCoordinatesVector throws without cartesian", function () {
|
expect(function () {
|
camera.cameraToWorldCoordinatesVector();
|
}).toThrowDeveloperError();
|
});
|
|
it("cameraToWorldCoordinatesVector transforms from the cameras reference frame", function () {
|
camera._setTransform(
|
new Matrix4(
|
0.0,
|
0.0,
|
1.0,
|
10.0,
|
1.0,
|
0.0,
|
0.0,
|
20.0,
|
0.0,
|
1.0,
|
0.0,
|
30.0,
|
0.0,
|
0.0,
|
0.0,
|
1.0
|
)
|
);
|
expect(camera.cameraToWorldCoordinatesVector(Cartesian3.UNIT_Z)).toEqual(
|
Cartesian3.UNIT_X
|
);
|
});
|
|
it("move throws without an axis", function () {
|
expect(function () {
|
expect(camera.move());
|
}).toThrowDeveloperError();
|
});
|
|
it("moves", function () {
|
var direction = Cartesian3.normalize(
|
new Cartesian3(1.0, 1.0, 0.0),
|
new Cartesian3()
|
);
|
camera.move(direction, moveAmount);
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(direction.x * moveAmount, direction.y * moveAmount, 1.0),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqual(up);
|
expect(camera.direction).toEqual(dir);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("moves up", function () {
|
camera.moveUp(moveAmount);
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(0.0, moveAmount, 1.0),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqual(up);
|
expect(camera.direction).toEqual(dir);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("moves down", function () {
|
camera.moveDown(moveAmount);
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(0.0, -moveAmount, 1.0),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqual(up);
|
expect(camera.direction).toEqual(dir);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("moves right", function () {
|
camera.moveRight(moveAmount);
|
expect(camera.position).toEqual(
|
new Cartesian3(moveAmount, 0.0, 1.0),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqual(up);
|
expect(camera.direction).toEqual(dir);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("moves left", function () {
|
camera.moveLeft(moveAmount);
|
expect(camera.position).toEqual(
|
new Cartesian3(-moveAmount, 0.0, 1.0),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqual(up);
|
expect(camera.direction).toEqual(dir);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("moves forward", function () {
|
camera.moveForward(moveAmount);
|
expect(camera.position).toEqual(
|
new Cartesian3(0.0, 0.0, 1.0 - moveAmount),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqual(up);
|
expect(camera.direction).toEqual(dir);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("moves backward", function () {
|
camera.moveBackward(moveAmount);
|
expect(camera.position).toEqual(
|
new Cartesian3(0.0, 0.0, 1.0 + moveAmount),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqual(up);
|
expect(camera.direction).toEqual(dir);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("moves forward in 2D mode zooms in camera instead of moving it", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
var oldCamera = Camera.clone(camera);
|
|
camera.moveForward(moveAmount);
|
|
// want to be at prev location bc moveBackward in 2D uses zoom2D which only adjusts frustum
|
expect(camera.position).toEqual(oldCamera.position, CesiumMath.EPSILON10);
|
expect(camera.frustum).not.toEqual(oldCamera.frustum);
|
|
expect(camera.up).toEqual(up);
|
expect(camera.direction).toEqual(dir);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("moves backward in 2D mode zooms out camera instead of moving it", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
var oldCamera = Camera.clone(camera);
|
|
camera.moveBackward(moveAmount);
|
|
// want to be at prev location bc moveBackward in 2D uses zoom2D which only adjusts frustum
|
expect(camera.position).toEqual(oldCamera.position, CesiumMath.EPSILON10);
|
expect(camera.frustum).not.toEqual(oldCamera.frustum);
|
expect(camera.up).toEqual(up);
|
expect(camera.direction).toEqual(dir);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("move clamps position in 2D", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
|
var max = scene.mapProjection.project(
|
new Cartographic(Math.PI, CesiumMath.toRadians(85.05112878))
|
);
|
var factor = 1000.0;
|
var dx = max.x * factor;
|
var dy = max.y * factor;
|
|
camera.moveUp(dy);
|
camera.moveRight(dx);
|
expect(camera.position.x).toBeLessThan(dx);
|
expect(camera.position.y).toBeLessThan(dy);
|
|
camera.moveDown(dy);
|
camera.moveLeft(dx);
|
expect(camera.position.x).toBeGreaterThan(-dx);
|
expect(camera.position.y).toBeGreaterThan(-dy);
|
});
|
|
it("look throws without an axis", function () {
|
expect(function () {
|
expect(camera.look());
|
}).toThrowDeveloperError();
|
});
|
|
it("looks", function () {
|
camera.look(Cartesian3.UNIT_X, CesiumMath.PI);
|
expect(camera.position).toEqual(position);
|
expect(camera.right).toEqual(right);
|
expect(camera.up).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Y, new Cartesian3()),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.UNIT_Z,
|
CesiumMath.EPSILON10
|
);
|
});
|
|
it("looks left", function () {
|
camera.lookLeft(turnAmount);
|
expect(camera.position).toEqual(position);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(right, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.right).toEqualEpsilon(dir, CesiumMath.EPSILON15);
|
});
|
|
it("looks right", function () {
|
camera.lookRight(turnAmount);
|
expect(camera.position).toEqual(position);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(right, CesiumMath.EPSILON15);
|
expect(camera.right).toEqualEpsilon(
|
Cartesian3.negate(dir, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("looks up", function () {
|
camera.lookUp(turnAmount);
|
expect(camera.position).toEqual(position);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(up, CesiumMath.EPSILON15);
|
expect(camera.up).toEqualEpsilon(
|
Cartesian3.negate(dir, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("looks down", function () {
|
camera.lookDown(turnAmount);
|
expect(camera.position).toEqual(position);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(up, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.up).toEqualEpsilon(dir, CesiumMath.EPSILON15);
|
});
|
|
it("looks left in 2D mode does not modify the camera at all", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
var oldCamera = Camera.clone(camera);
|
|
camera.lookLeft(turnAmount);
|
|
// dont want camera look vector to rotate at all in 2D
|
expect(camera.position).toEqual(oldCamera.position);
|
expect(camera.up).toEqualEpsilon(oldCamera.up, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(
|
oldCamera.direction,
|
CesiumMath.EPSILON15
|
);
|
expect(camera.right).toEqualEpsilon(oldCamera.right, CesiumMath.EPSILON15);
|
});
|
|
it("looks right in 2D mode does not modify the camera at all", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
var oldCamera = Camera.clone(camera);
|
|
camera.lookRight(turnAmount);
|
|
// dont want camera look vector to rotate at all in 2D
|
expect(camera.position).toEqual(oldCamera.position);
|
expect(camera.up).toEqualEpsilon(oldCamera.up, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(
|
oldCamera.direction,
|
CesiumMath.EPSILON15
|
);
|
expect(camera.right).toEqualEpsilon(oldCamera.right, CesiumMath.EPSILON15);
|
});
|
|
it("looks up in 2D mode does not modify the camera at all", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
var oldCamera = Camera.clone(camera);
|
|
camera.lookUp(turnAmount);
|
|
// dont want camera look vector to rotate at all in 2D
|
expect(camera.position).toEqual(oldCamera.position);
|
expect(camera.up).toEqualEpsilon(oldCamera.up, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(
|
oldCamera.direction,
|
CesiumMath.EPSILON15
|
);
|
expect(camera.right).toEqualEpsilon(oldCamera.right, CesiumMath.EPSILON15);
|
});
|
|
it("looks down in 2D mode does not modify the camera at all", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
var oldCamera = Camera.clone(camera);
|
|
camera.lookDown(turnAmount);
|
|
// dont want camera look vector to rotate at all in 2D
|
expect(camera.position).toEqual(oldCamera.position);
|
expect(camera.up).toEqualEpsilon(oldCamera.up, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(
|
oldCamera.direction,
|
CesiumMath.EPSILON15
|
);
|
expect(camera.right).toEqualEpsilon(oldCamera.right, CesiumMath.EPSILON15);
|
});
|
|
it("twists left", function () {
|
camera.twistLeft(CesiumMath.PI_OVER_TWO);
|
expect(camera.position).toEqual(position);
|
expect(camera.direction).toEqualEpsilon(dir, CesiumMath.EPSILON15);
|
expect(camera.up).toEqualEpsilon(
|
Cartesian3.negate(right, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.right).toEqualEpsilon(up, CesiumMath.EPSILON15);
|
});
|
|
it("twists right", function () {
|
camera.twistRight(CesiumMath.PI_OVER_TWO);
|
expect(camera.position).toEqual(position);
|
expect(camera.direction).toEqualEpsilon(dir, CesiumMath.EPSILON15);
|
expect(camera.up).toEqualEpsilon(right, CesiumMath.EPSILON14);
|
expect(camera.right).toEqualEpsilon(
|
Cartesian3.negate(up, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("rotate throws without an axis", function () {
|
expect(function () {
|
expect(camera.rotate());
|
}).toThrowDeveloperError();
|
});
|
|
it("rotates up", function () {
|
camera.rotateUp(rotateAmount);
|
expect(camera.up).toEqualEpsilon(
|
Cartesian3.negate(dir, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.direction).toEqualEpsilon(up, CesiumMath.EPSILON15);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON15);
|
expect(camera.position).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Y, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("rotates up with constrained axis 0", function () {
|
camera.constrainedAxis = Cartesian3.UNIT_Y;
|
camera.rotateUp(rotateAmount);
|
expect(camera.up).toEqualEpsilon(
|
Cartesian3.negate(dir, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.direction).toEqualEpsilon(up, CesiumMath.EPSILON15);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON15);
|
expect(camera.position).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Y, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("rotates up with constrained axis 1", function () {
|
camera.up = Cartesian3.negate(dir, new Cartesian3());
|
camera.direction = right;
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
camera.constrainedAxis = Cartesian3.UNIT_Y;
|
camera.rotateUp(rotateAmount);
|
expect(camera.up).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Y, new Cartesian3()),
|
CesiumMath.EPSILON14
|
);
|
expect(camera.direction).toEqualEpsilon(right, CesiumMath.EPSILON15);
|
expect(camera.right).toEqualEpsilon(dir, CesiumMath.EPSILON15);
|
expect(camera.position).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Y, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("rotates down", function () {
|
camera.rotateDown(rotateAmount);
|
expect(camera.up).toEqualEpsilon(dir, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(up, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON15);
|
expect(camera.position).toEqualEpsilon(
|
Cartesian3.UNIT_Y,
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("rotates down with constrained axis 0 ", function () {
|
camera.constrainedAxis = Cartesian3.UNIT_Y;
|
camera.rotateDown(rotateAmount);
|
expect(camera.up).toEqualEpsilon(dir, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(up, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON15);
|
expect(camera.position).toEqualEpsilon(
|
Cartesian3.UNIT_Y,
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("rotates down with constrained axis 1", function () {
|
camera.up = Cartesian3.negate(dir, new Cartesian3());
|
camera.direction = right;
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
camera.constrainedAxis = Cartesian3.UNIT_Y;
|
camera.rotateDown(rotateAmount);
|
expect(camera.up).toEqualEpsilon(Cartesian3.UNIT_Y, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(right, CesiumMath.EPSILON15);
|
expect(camera.right).toEqualEpsilon(
|
Cartesian3.negate(dir, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.position).toEqualEpsilon(
|
Cartesian3.UNIT_Y,
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("rotates left", function () {
|
camera.rotateLeft(rotateAmount);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(right, CesiumMath.EPSILON15);
|
expect(camera.right).toEqualEpsilon(
|
Cartesian3.negate(dir, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.position).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_X, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("rotates left with contrained axis", function () {
|
camera.constrainedAxis = Cartesian3.UNIT_Z;
|
camera.rotateLeft(rotateAmount);
|
expect(camera.up).toEqualEpsilon(Cartesian3.UNIT_X, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.right).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Y, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.position).toEqualEpsilon(
|
Cartesian3.UNIT_Z,
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("rotates right", function () {
|
camera.rotateRight(rotateAmount);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON15);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(right, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.right).toEqualEpsilon(dir, CesiumMath.EPSILON15);
|
expect(camera.position).toEqualEpsilon(
|
Cartesian3.UNIT_X,
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("rotates right with contrained axis", function () {
|
camera.constrainedAxis = Cartesian3.UNIT_Z;
|
camera.rotateRight(rotateAmount);
|
expect(camera.up).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_X, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.right).toEqualEpsilon(
|
Cartesian3.UNIT_Y,
|
CesiumMath.EPSILON15
|
);
|
expect(camera.position).toEqualEpsilon(
|
Cartesian3.UNIT_Z,
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("rotates", function () {
|
var axis = Cartesian3.normalize(
|
new Cartesian3(
|
Math.cos(CesiumMath.PI_OVER_FOUR),
|
Math.sin(CesiumMath.PI_OVER_FOUR),
|
0.0
|
),
|
new Cartesian3()
|
);
|
var angle = CesiumMath.PI_OVER_TWO;
|
camera.rotate(axis, angle);
|
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(-axis.x, axis.y, 0.0),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(
|
Cartesian3.normalize(camera.position, new Cartesian3()),
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.right).toEqualEpsilon(
|
Cartesian3.normalize(new Cartesian3(0.5, 0.5, axis.x), new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
expect(camera.up).toEqualEpsilon(
|
Cartesian3.cross(camera.right, camera.direction, new Cartesian3()),
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("rotate past constrained axis stops at constained axis", function () {
|
camera.constrainedAxis = Cartesian3.UNIT_Y;
|
camera.rotateUp(Math.PI);
|
expect(camera.up).toEqualEpsilon(
|
Cartesian3.negate(dir, new Cartesian3()),
|
CesiumMath.EPSILON4
|
);
|
expect(camera.direction).toEqualEpsilon(up, CesiumMath.EPSILON4);
|
expect(camera.right).toEqualEpsilon(right, CesiumMath.EPSILON4);
|
expect(camera.position).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Y, new Cartesian3()),
|
CesiumMath.EPSILON4
|
);
|
});
|
|
it("zooms out 2D", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
|
camera.zoomOut(zoomAmount);
|
expect(camera.frustum.right).toEqualEpsilon(2.5, CesiumMath.EPSILON10);
|
expect(camera.frustum.left).toEqual(-2.5, CesiumMath.EPSILON10);
|
expect(camera.frustum.top).toEqual(1.25, CesiumMath.EPSILON10);
|
expect(camera.frustum.bottom).toEqual(-1.25, CesiumMath.EPSILON10);
|
});
|
|
it("zooms out 2D when frustrum has greater height than width", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -1.0;
|
frustum.right = 1.0;
|
frustum.top = 2.0;
|
frustum.bottom = -2.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
|
camera.zoomOut(zoomAmount);
|
expect(camera.frustum.right).toEqualEpsilon(1.25, CesiumMath.EPSILON10);
|
expect(camera.frustum.left).toEqual(-1.25, CesiumMath.EPSILON10);
|
expect(camera.frustum.top).toEqual(2.5, CesiumMath.EPSILON10);
|
expect(camera.frustum.bottom).toEqual(-2.5, CesiumMath.EPSILON10);
|
});
|
|
it("zooms in 2D", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
|
camera.zoomIn(zoomAmount);
|
expect(camera.frustum.right).toEqualEpsilon(1.5, CesiumMath.EPSILON10);
|
expect(camera.frustum.left).toEqual(-1.5, CesiumMath.EPSILON10);
|
expect(camera.frustum.top).toEqual(0.75, CesiumMath.EPSILON10);
|
expect(camera.frustum.bottom).toEqual(-0.75, CesiumMath.EPSILON10);
|
});
|
|
it("zooms in 2D when frustrum has greater height than width", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -1.0;
|
frustum.right = 1.0;
|
frustum.top = 2.0;
|
frustum.bottom = -2.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
|
camera.zoomIn(zoomAmount);
|
expect(camera.frustum.right).toEqualEpsilon(0.75, CesiumMath.EPSILON10);
|
expect(camera.frustum.left).toEqual(-0.75, CesiumMath.EPSILON10);
|
expect(camera.frustum.top).toEqual(1.5, CesiumMath.EPSILON10);
|
expect(camera.frustum.bottom).toEqual(-1.5, CesiumMath.EPSILON10);
|
});
|
|
it("clamps zoom out in 2D", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
|
var max = scene.mapProjection.project(
|
new Cartographic(Math.PI, CesiumMath.toRadians(85.05112878))
|
);
|
var factor = 1000.0;
|
var dx = max.x * factor;
|
var ratio = frustum.top / frustum.right;
|
|
camera.zoomOut(dx);
|
expect(frustum.right).toBeLessThan(dx);
|
expect(frustum.left).toBeGreaterThan(-dx);
|
expect(frustum.top).toEqual(frustum.right * ratio);
|
expect(frustum.bottom).toEqual(-frustum.top);
|
});
|
|
it("clamps zoom in in 2D", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
|
var max = scene.mapProjection.project(
|
new Cartographic(Math.PI, CesiumMath.toRadians(85.05112878))
|
);
|
var factor = 1000.0;
|
var dx = max.x * factor;
|
|
camera.zoomIn(dx * 2.0);
|
expect(frustum.right).toEqual(1.0);
|
expect(frustum.left).toEqual(-1.0);
|
});
|
|
it("zooms in 3D", function () {
|
camera.zoomIn(zoomAmount);
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(0.0, 0.0, 1.0 - zoomAmount),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqual(up);
|
expect(camera.direction).toEqual(dir);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("zooms out in 3D", function () {
|
camera.zoomOut(zoomAmount);
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(0.0, 0.0, 1.0 + zoomAmount),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqual(up);
|
expect(camera.direction).toEqual(dir);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("zooms in throws with undefined OrthogrphicFrustum properties 2D", function () {
|
camera._mode = SceneMode.SCENE2D;
|
camera.frustum = new OrthographicOffCenterFrustum();
|
expect(function () {
|
camera.zoomIn(zoomAmount);
|
}).toThrowDeveloperError();
|
});
|
|
it("lookAt", function () {
|
var target = Cartesian3.fromDegrees(0.0, 0.0);
|
var offset = new Cartesian3(0.0, -1.0, 0.0);
|
|
var tempCamera = Camera.clone(camera);
|
tempCamera.lookAt(target, offset);
|
|
expect(tempCamera.position).toEqualEpsilon(offset, CesiumMath.EPSILON11);
|
expect(tempCamera.direction).toEqualEpsilon(
|
Cartesian3.negate(
|
Cartesian3.normalize(offset, new Cartesian3()),
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.right).toEqualEpsilon(
|
Cartesian3.cross(
|
tempCamera.direction,
|
Cartesian3.UNIT_Z,
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.up).toEqualEpsilon(
|
Cartesian3.cross(
|
tempCamera.right,
|
tempCamera.direction,
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
|
expect(1.0 - Cartesian3.magnitude(tempCamera.direction)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
expect(1.0 - Cartesian3.magnitude(tempCamera.up)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
expect(1.0 - Cartesian3.magnitude(tempCamera.right)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
});
|
|
it("lookAt with heading, pitch and range", function () {
|
var target = Cartesian3.fromDegrees(0.0, 0.0);
|
var heading = CesiumMath.toRadians(45.0);
|
var pitch = CesiumMath.toRadians(-45.0);
|
var range = 2.0;
|
|
var tempCamera = Camera.clone(camera);
|
tempCamera.lookAt(target, new HeadingPitchRange(heading, pitch, range));
|
|
tempCamera.lookAtTransform(Matrix4.IDENTITY);
|
|
expect(Cartesian3.distance(tempCamera.position, target)).toEqualEpsilon(
|
range,
|
CesiumMath.EPSILON6
|
);
|
expect(tempCamera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(tempCamera.pitch).toEqualEpsilon(pitch, CesiumMath.EPSILON6);
|
|
expect(1.0 - Cartesian3.magnitude(tempCamera.direction)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
expect(1.0 - Cartesian3.magnitude(tempCamera.up)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
expect(1.0 - Cartesian3.magnitude(tempCamera.right)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
});
|
|
it("lookAt when target is zero", function () {
|
var target = Cartesian3.clone(Cartesian3.ZERO);
|
var offset = new Cartesian3(0.0, -1.0, 0.0);
|
|
var tempCamera = Camera.clone(camera);
|
tempCamera.lookAt(target, offset);
|
|
expect(tempCamera.position).toEqualEpsilon(offset, CesiumMath.EPSILON11);
|
expect(tempCamera.direction).toEqualEpsilon(
|
Cartesian3.negate(
|
Cartesian3.normalize(offset, new Cartesian3()),
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.right).toEqualEpsilon(
|
Cartesian3.cross(
|
tempCamera.direction,
|
Cartesian3.UNIT_Z,
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.up).toEqualEpsilon(
|
Cartesian3.cross(
|
tempCamera.right,
|
tempCamera.direction,
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
});
|
|
it("lookAt when target and camera are zero", function () {
|
var target = Cartesian3.clone(Cartesian3.ZERO);
|
var offset = new Cartesian3(0.0, -1.0, 0.0);
|
|
var tempCamera = Camera.clone(camera);
|
tempCamera.position = Cartesian3.clone(Cartesian3.ZERO);
|
tempCamera.lookAt(target, offset);
|
|
expect(tempCamera.position).toEqualEpsilon(offset, CesiumMath.EPSILON11);
|
expect(tempCamera.direction).toEqualEpsilon(
|
Cartesian3.negate(
|
Cartesian3.normalize(offset, new Cartesian3()),
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.right).toEqualEpsilon(
|
Cartesian3.cross(
|
tempCamera.direction,
|
Cartesian3.UNIT_Z,
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.up).toEqualEpsilon(
|
Cartesian3.cross(
|
tempCamera.right,
|
tempCamera.direction,
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
});
|
|
it("lookAt throws with no target parameter", function () {
|
expect(function () {
|
camera.lookAt(undefined, Cartesian3.ZERO);
|
}).toThrowDeveloperError();
|
});
|
|
it("lookAt throws with no offset parameter", function () {
|
expect(function () {
|
camera.lookAt(Cartesian3.ZERO, undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("lookAt in 2D mode", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
|
var tempCamera = Camera.clone(camera);
|
tempCamera.frustum = frustum;
|
tempCamera.update(SceneMode.SCENE2D);
|
|
var target = Cartesian3.fromDegrees(0.0, 0.0);
|
var offset = new Cartesian3(10000.0, 10000.0, 30000.0);
|
tempCamera.lookAt(target, offset);
|
|
expect(Cartesian2.clone(tempCamera.position)).toEqual(Cartesian2.ZERO);
|
expect(tempCamera.direction).toEqual(
|
Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3())
|
);
|
expect(tempCamera.up).toEqualEpsilon(
|
Cartesian3.normalize(
|
Cartesian3.fromElements(-offset.x, -offset.y, 0.0),
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.right).toEqualEpsilon(
|
Cartesian3.cross(tempCamera.direction, tempCamera.up, new Cartesian3()),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.frustum.right).toEqual(
|
Cartesian3.magnitude(offset) * 0.5
|
);
|
expect(tempCamera.frustum.left).toEqual(
|
-Cartesian3.magnitude(offset) * 0.5
|
);
|
});
|
|
it("lookAt in 2D mode with heading, pitch and range", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
|
var tempCamera = Camera.clone(camera);
|
tempCamera.frustum = frustum;
|
tempCamera.update(SceneMode.SCENE2D);
|
|
var target = Cartesian3.fromDegrees(0.0, 0.0);
|
var heading = CesiumMath.toRadians(90.0);
|
var pitch = CesiumMath.toRadians(-45.0);
|
var range = 2.0;
|
|
tempCamera.lookAt(target, new HeadingPitchRange(heading, pitch, range));
|
|
expect(Cartesian2.clone(tempCamera.position)).toEqual(Cartesian2.ZERO);
|
|
tempCamera.lookAtTransform(Matrix4.IDENTITY);
|
expect(tempCamera.direction).toEqual(
|
Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3())
|
);
|
expect(tempCamera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(tempCamera.frustum.right).toEqual(range * 0.5);
|
expect(tempCamera.frustum.left).toEqual(-range * 0.5);
|
});
|
|
it("lookAt throws when morphing", function () {
|
camera.update(SceneMode.MORPHING);
|
|
expect(function () {
|
camera.lookAt(Cartesian3.ZERO, Cartesian3.UNIT_X);
|
}).toThrowDeveloperError();
|
});
|
|
it("lookAtTransform", function () {
|
var target = new Cartesian3(-1.0, -1.0, 0.0);
|
var offset = new Cartesian3(1.0, 1.0, 0.0);
|
var transform = Transforms.eastNorthUpToFixedFrame(
|
target,
|
Ellipsoid.UNIT_SPHERE
|
);
|
|
var tempCamera = Camera.clone(camera);
|
tempCamera.lookAtTransform(transform, offset);
|
|
expect(tempCamera.position).toEqualEpsilon(offset, CesiumMath.EPSILON11);
|
expect(tempCamera.direction).toEqualEpsilon(
|
Cartesian3.negate(
|
Cartesian3.normalize(offset, new Cartesian3()),
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.right).toEqualEpsilon(
|
Cartesian3.cross(
|
tempCamera.direction,
|
Cartesian3.UNIT_Z,
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.up).toEqualEpsilon(
|
Cartesian3.cross(
|
tempCamera.right,
|
tempCamera.direction,
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
|
expect(1.0 - Cartesian3.magnitude(tempCamera.direction)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
expect(1.0 - Cartesian3.magnitude(tempCamera.up)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
expect(1.0 - Cartesian3.magnitude(tempCamera.right)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
});
|
|
it("lookAtTransform with no offset parameter", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var cartOrigin = Cartographic.fromDegrees(-75.59777, 40.03883);
|
var origin = ellipsoid.cartographicToCartesian(cartOrigin);
|
var transform = Transforms.eastNorthUpToFixedFrame(origin);
|
|
var height = 1000.0;
|
cartOrigin.height = height;
|
|
camera.position = ellipsoid.cartographicToCartesian(cartOrigin);
|
camera.direction = Cartesian3.negate(
|
Cartesian3.fromCartesian4(
|
Matrix4.getColumn(transform, 2, new Cartesian4())
|
),
|
new Cartesian3()
|
);
|
camera.up = Cartesian3.fromCartesian4(
|
Matrix4.getColumn(transform, 1, new Cartesian4(), new Matrix4())
|
);
|
camera.right = Cartesian3.fromCartesian4(
|
Matrix4.getColumn(transform, 0, new Cartesian4())
|
);
|
|
camera.lookAtTransform(transform);
|
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(0.0, 0.0, height),
|
CesiumMath.EPSILON9
|
);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3()),
|
CesiumMath.EPSILON9
|
);
|
expect(camera.up).toEqualEpsilon(Cartesian3.UNIT_Y, CesiumMath.EPSILON9);
|
expect(camera.right).toEqualEpsilon(Cartesian3.UNIT_X, CesiumMath.EPSILON9);
|
});
|
|
it("lookAtTransform with heading, pitch and range", function () {
|
var target = Cartesian3.fromDegrees(0.0, 0.0);
|
var heading = CesiumMath.toRadians(45.0);
|
var pitch = CesiumMath.toRadians(-45.0);
|
var range = 2.0;
|
var transform = Transforms.eastNorthUpToFixedFrame(target);
|
|
var tempCamera = Camera.clone(camera);
|
tempCamera.lookAtTransform(
|
transform,
|
new HeadingPitchRange(heading, pitch, range)
|
);
|
|
tempCamera.lookAtTransform(Matrix4.IDENTITY);
|
|
expect(Cartesian3.distance(tempCamera.position, target)).toEqualEpsilon(
|
range,
|
CesiumMath.EPSILON6
|
);
|
expect(tempCamera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(tempCamera.pitch).toEqualEpsilon(pitch, CesiumMath.EPSILON6);
|
|
expect(1.0 - Cartesian3.magnitude(tempCamera.direction)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
expect(1.0 - Cartesian3.magnitude(tempCamera.up)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
expect(1.0 - Cartesian3.magnitude(tempCamera.right)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
});
|
|
it("lookAtTransform throws with no transform parameter", function () {
|
expect(function () {
|
camera.lookAtTransform(undefined, Cartesian3.ZERO);
|
}).toThrowDeveloperError();
|
});
|
|
it("lookAtTransform in 2D mode", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
|
var tempCamera = Camera.clone(camera);
|
tempCamera.frustum = frustum;
|
tempCamera.update(SceneMode.SCENE2D);
|
|
var transform = Transforms.eastNorthUpToFixedFrame(
|
Cartesian3.fromDegrees(0.0, 0.0)
|
);
|
var offset = new Cartesian3(10000.0, 10000.0, 30000.0);
|
tempCamera.lookAtTransform(transform, offset);
|
|
expect(Cartesian2.clone(tempCamera.position)).toEqual(Cartesian2.ZERO);
|
expect(tempCamera.direction).toEqual(
|
Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3())
|
);
|
expect(tempCamera.up).toEqualEpsilon(
|
Cartesian3.normalize(
|
Cartesian3.fromElements(-offset.x, -offset.y, 0.0),
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.right).toEqualEpsilon(
|
Cartesian3.cross(tempCamera.direction, tempCamera.up, new Cartesian3()),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.frustum.right).toEqual(
|
Cartesian3.magnitude(offset) * 0.5
|
);
|
expect(tempCamera.frustum.left).toEqual(
|
-Cartesian3.magnitude(offset) * 0.5
|
);
|
});
|
|
it("lookAtTransform in 2D mode with heading, pitch and range", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
|
var tempCamera = Camera.clone(camera);
|
tempCamera.frustum = frustum;
|
tempCamera.update(SceneMode.SCENE2D);
|
|
var target = Cartesian3.fromDegrees(0.0, 0.0);
|
var heading = CesiumMath.toRadians(90.0);
|
var pitch = CesiumMath.toRadians(-45.0);
|
var range = 2.0;
|
var transform = Transforms.eastNorthUpToFixedFrame(target);
|
|
tempCamera.lookAtTransform(
|
transform,
|
new HeadingPitchRange(heading, pitch, range)
|
);
|
|
expect(Cartesian2.clone(tempCamera.position)).toEqual(Cartesian2.ZERO);
|
|
tempCamera.lookAtTransform(Matrix4.IDENTITY);
|
expect(tempCamera.direction).toEqual(
|
Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3())
|
);
|
expect(tempCamera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(tempCamera.frustum.right).toEqual(range * 0.5);
|
expect(tempCamera.frustum.left).toEqual(-range * 0.5);
|
});
|
|
it("lookAtTransform in 3D with orthographic projection", function () {
|
var target = new Cartesian3(-1.0, -1.0, 0.0);
|
var offset = new Cartesian3(1.0, 1.0, 0.0);
|
var transform = Transforms.eastNorthUpToFixedFrame(
|
target,
|
Ellipsoid.UNIT_SPHERE
|
);
|
|
var tempCamera = Camera.clone(camera);
|
tempCamera.frustum = new OrthographicFrustum();
|
tempCamera.frustum.aspectRatio =
|
scene.drawingBufferWidth / scene.drawingBufferHeight;
|
tempCamera.frustum.width = tempCamera.positionCartographic.height;
|
|
tempCamera.lookAtTransform(transform, offset);
|
|
expect(tempCamera.position).toEqualEpsilon(offset, CesiumMath.EPSILON11);
|
expect(tempCamera.direction).toEqualEpsilon(
|
Cartesian3.negate(
|
Cartesian3.normalize(offset, new Cartesian3()),
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.right).toEqualEpsilon(
|
Cartesian3.cross(
|
tempCamera.direction,
|
Cartesian3.UNIT_Z,
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
expect(tempCamera.up).toEqualEpsilon(
|
Cartesian3.cross(
|
tempCamera.right,
|
tempCamera.direction,
|
new Cartesian3()
|
),
|
CesiumMath.EPSILON11
|
);
|
|
expect(1.0 - Cartesian3.magnitude(tempCamera.direction)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
expect(1.0 - Cartesian3.magnitude(tempCamera.up)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
expect(1.0 - Cartesian3.magnitude(tempCamera.right)).toBeLessThan(
|
CesiumMath.EPSILON14
|
);
|
|
expect(tempCamera.frustum.width).toEqual(
|
Cartesian3.magnitude(tempCamera.position)
|
);
|
});
|
|
it("lookAtTransform throws when morphing", function () {
|
camera.update(SceneMode.MORPHING);
|
|
expect(function () {
|
camera.lookAtTransform(Matrix4.IDENTITY, Cartesian3.UNIT_X);
|
}).toThrowDeveloperError();
|
});
|
|
it("setView rectangle in 3D (1)", function () {
|
var rectangle = new Rectangle(
|
-Math.PI,
|
-CesiumMath.PI_OVER_TWO,
|
Math.PI,
|
CesiumMath.PI_OVER_TWO
|
);
|
camera.setView({ destination: rectangle });
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(14680290.639204923, 0.0, 0.0),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_X, new Cartesian3()),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqualEpsilon(Cartesian3.UNIT_Z, CesiumMath.EPSILON10);
|
expect(camera.right).toEqualEpsilon(
|
Cartesian3.UNIT_Y,
|
CesiumMath.EPSILON10
|
);
|
});
|
|
it("setView rectangle in 3D (2)", function () {
|
var rectangle = new Rectangle(
|
CesiumMath.toRadians(21.25),
|
CesiumMath.toRadians(41.23),
|
CesiumMath.toRadians(21.51),
|
CesiumMath.toRadians(41.38)
|
);
|
camera.setView({ destination: rectangle });
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(4481555.454147325, 1754498.0086281248, 4200627.581953675),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.direction).toEqualEpsilon(
|
new Cartesian3(
|
-0.6995046749050446,
|
-0.27385124912628594,
|
-0.6600747708691498
|
),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqualEpsilon(
|
new Cartesian3(
|
-0.6146504879783901,
|
-0.2406314209863035,
|
0.7511999047271233
|
),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.right).toEqualEpsilon(
|
new Cartesian3(-0.36455176232452213, 0.9311831251617939, 0),
|
CesiumMath.EPSILON10
|
);
|
});
|
|
it("setView rectangle in 3D (3)", function () {
|
var rectangle = new Rectangle(
|
CesiumMath.toRadians(90.0),
|
CesiumMath.toRadians(-50.0),
|
CesiumMath.toRadians(157.0),
|
CesiumMath.toRadians(0.0)
|
);
|
camera.setView({ destination: rectangle });
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(-6017603.25625715, 9091606.78076493, -5075070.862292178),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.direction).toEqualEpsilon(
|
new Cartesian3(
|
0.49978034145251155,
|
-0.7550857289433265,
|
0.42434084442077485
|
),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqualEpsilon(
|
new Cartesian3(
|
-0.2342094064143758,
|
0.35385181388649406,
|
0.905502538790623
|
),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.right).toEqualEpsilon(
|
new Cartesian3(-0.8338858220671682, -0.5519369853120581, 0),
|
CesiumMath.EPSILON10
|
);
|
});
|
|
it("setView rectangle in 3D (4)", function () {
|
var rectangle = new Rectangle(
|
CesiumMath.toRadians(90.0),
|
CesiumMath.toRadians(-62.0),
|
CesiumMath.toRadians(174.0),
|
CesiumMath.toRadians(-4.0)
|
);
|
camera.setView({ destination: rectangle });
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(-7307919.685704952, 8116267.060310548, -7085995.891547672),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.direction).toEqualEpsilon(
|
new Cartesian3(
|
0.5602119862713765,
|
-0.6221784429103113,
|
0.5468605998017956
|
),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqualEpsilon(
|
new Cartesian3(
|
-0.3659211647391443,
|
0.40639662500016843,
|
0.8372236764356468
|
),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.right).toEqualEpsilon(
|
new Cartesian3(-0.7431448254773944, -0.6691306063588581, 0),
|
CesiumMath.EPSILON10
|
);
|
});
|
|
it("views rectangle in 3D across IDL", function () {
|
var rectangle = new Rectangle(
|
0.1,
|
-CesiumMath.PI_OVER_TWO,
|
-0.1,
|
CesiumMath.PI_OVER_TWO
|
);
|
camera.setView({ destination: rectangle });
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(-14680290.639204923, 0.0, 0.0),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.direction).toEqualEpsilon(
|
Cartesian3.UNIT_X,
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqualEpsilon(Cartesian3.UNIT_Z, CesiumMath.EPSILON10);
|
expect(camera.right).toEqualEpsilon(
|
Cartesian3.negate(Cartesian3.UNIT_Y, new Cartesian3()),
|
CesiumMath.EPSILON10
|
);
|
});
|
|
it("setView rectangle in 2D with larger longitude", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.left = -10.0;
|
frustum.right = 10.0;
|
frustum.bottom = -10.0;
|
frustum.top = 10.0;
|
frustum.near = 1.0;
|
frustum.far = 21.0;
|
camera.frustum = frustum;
|
|
var rectangle = new Rectangle(
|
-CesiumMath.PI_OVER_TWO,
|
-CesiumMath.PI_OVER_FOUR,
|
CesiumMath.PI_OVER_TWO,
|
CesiumMath.PI_OVER_FOUR
|
);
|
var projection = new GeographicProjection();
|
var edge = projection.project(
|
new Cartographic(CesiumMath.PI_OVER_TWO, CesiumMath.PI_OVER_FOUR)
|
);
|
var expected = Math.max(edge.x, edge.y);
|
|
camera._mode = SceneMode.SCENE2D;
|
camera._projection = projection;
|
camera.setView({ destination: rectangle });
|
|
expect(camera.position.x).toEqual(0);
|
expect(camera.position.y).toEqual(0);
|
expect(frustum.right - expected <= CesiumMath.EPSILON14).toEqual(true);
|
expect(frustum.left + expected <= CesiumMath.EPSILON14).toEqual(true);
|
expect(frustum.top - expected <= CesiumMath.EPSILON14).toEqual(true);
|
expect(frustum.bottom + expected <= CesiumMath.EPSILON14).toEqual(true);
|
});
|
|
it("setView rectangle in 2D with larger latitude", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.left = -10.0;
|
frustum.right = 10.0;
|
frustum.bottom = -10.0;
|
frustum.top = 10.0;
|
frustum.near = 1.0;
|
frustum.far = 21.0;
|
camera.frustum = frustum;
|
|
var rectangle = new Rectangle(
|
-CesiumMath.PI_OVER_FOUR,
|
-CesiumMath.PI_OVER_TWO,
|
CesiumMath.PI_OVER_FOUR,
|
CesiumMath.PI_OVER_TWO
|
);
|
var projection = new GeographicProjection();
|
var edge = projection.project(
|
new Cartographic(CesiumMath.PI_OVER_FOUR, CesiumMath.PI_OVER_TWO)
|
);
|
var expected = Math.max(edge.x, edge.y);
|
|
camera._mode = SceneMode.SCENE2D;
|
camera._projection = projection;
|
camera.setView({ destination: rectangle });
|
|
expect(camera.position.x).toEqual(0);
|
expect(camera.position.y).toEqual(0);
|
expect(frustum.right - expected <= CesiumMath.EPSILON14).toEqual(true);
|
expect(frustum.left + expected <= CesiumMath.EPSILON14).toEqual(true);
|
expect(frustum.top - expected <= CesiumMath.EPSILON14).toEqual(true);
|
expect(frustum.bottom + expected <= CesiumMath.EPSILON14).toEqual(true);
|
});
|
|
it("setView rectangle in Columbus View", function () {
|
var rectangle = new Rectangle(
|
-CesiumMath.PI_OVER_TWO,
|
-CesiumMath.PI_OVER_TWO,
|
CesiumMath.PI_OVER_TWO,
|
CesiumMath.PI_OVER_TWO
|
);
|
var projection = new GeographicProjection();
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
camera._projection = projection;
|
camera.setView({ destination: rectangle });
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(0.0, 0.0, 23137321.67119748),
|
CesiumMath.EPSILON8
|
);
|
expect(camera.direction).toEqualEpsilon(
|
new Cartesian3(0.0, 0.0, -1.0),
|
CesiumMath.EPSILON2
|
);
|
expect(camera.up).toEqualEpsilon(
|
new Cartesian3(0.0, 1.0, 0.0),
|
CesiumMath.EPSILON2
|
);
|
expect(camera.right).toEqualEpsilon(
|
new Cartesian3(1.0, 0.0, 0.0),
|
CesiumMath.EPSILON10
|
);
|
});
|
|
it("setView rectangle in 3D with orthographic frustum", function () {
|
camera.setView({
|
destination: Cartesian3.fromDegrees(-75.0, 42.0, 100.0),
|
});
|
|
camera.frustum = new OrthographicFrustum();
|
camera.frustum.aspectRatio = 1135 / 630;
|
camera.frustum.width = camera.positionCartographic.height;
|
|
// force update of off-center frustum
|
expect(camera.frustum.projectionMatrix).toBeDefined();
|
|
var rectangle = new Rectangle(
|
CesiumMath.toRadians(21.25),
|
CesiumMath.toRadians(41.23),
|
CesiumMath.toRadians(21.51),
|
CesiumMath.toRadians(41.38)
|
);
|
|
var projection = new GeographicProjection();
|
camera._mode = SceneMode.SCENE3D;
|
camera._projection = projection;
|
camera.setView({ destination: rectangle });
|
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(4489090.849577177, 1757448.0638960265, 4207738.07588144),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.direction).toEqualEpsilon(
|
new Cartesian3(
|
-0.6995012374560863,
|
-0.2738499033887593,
|
-0.6600789719506079
|
),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqualEpsilon(
|
new Cartesian3(
|
-0.6146543999545513,
|
-0.2406329524979527,
|
0.7511962132416727
|
),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.right).toEqualEpsilon(
|
new Cartesian3(-0.36455176232452197, 0.931183125161794, 0.0),
|
CesiumMath.EPSILON10
|
);
|
});
|
|
it("setView rectangle in Columbus view with orthographic frustum", function () {
|
camera.setView({
|
destination: Cartesian3.fromDegrees(-75.0, 42.0, 100.0),
|
});
|
|
camera.frustum = new OrthographicFrustum();
|
camera.frustum.aspectRatio = 1135 / 630;
|
camera.frustum.width = camera.positionCartographic.height;
|
|
// force update of off-center frustum
|
expect(camera.frustum.projectionMatrix).toBeDefined();
|
|
var rectangle = new Rectangle(
|
CesiumMath.toRadians(21.25),
|
CesiumMath.toRadians(41.23),
|
CesiumMath.toRadians(21.51),
|
CesiumMath.toRadians(41.38)
|
);
|
|
var projection = new GeographicProjection();
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
camera._projection = projection;
|
camera.setView({ destination: rectangle });
|
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(2380010.713160189, 4598051.567216165, 28943.06760625122),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.direction).toEqualEpsilon(
|
new Cartesian3(0.0, 0.0, -1.0),
|
CesiumMath.EPSILON10
|
);
|
expect(camera.up).toEqualEpsilon(Cartesian3.UNIT_Y, CesiumMath.EPSILON10);
|
expect(camera.right).toEqualEpsilon(
|
Cartesian3.UNIT_X,
|
CesiumMath.EPSILON10
|
);
|
});
|
|
it("getRectangleCameraCoordinates throws without rectangle", function () {
|
expect(function () {
|
camera.getRectangleCameraCoordinates();
|
}).toThrowDeveloperError();
|
});
|
|
it("getRectangleCameraCoordinates rectangle in 3D", function () {
|
var rectangle = new Rectangle(
|
-Math.PI,
|
-CesiumMath.PI_OVER_TWO,
|
Math.PI,
|
CesiumMath.PI_OVER_TWO
|
);
|
var position = Cartesian3.clone(camera.position);
|
var direction = Cartesian3.clone(camera.direction);
|
var up = Cartesian3.clone(camera.up);
|
var right = Cartesian3.clone(camera.right);
|
camera._mode = SceneMode.SCENE3D;
|
camera.getRectangleCameraCoordinates(rectangle, position);
|
expect(position).toEqualEpsilon(
|
new Cartesian3(14680290.639204923, 0.0, 0.0),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.direction).toEqual(direction);
|
expect(camera.up).toEqual(up);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("gets coordinates for rectangle in 3D across IDL", function () {
|
var rectangle = new Rectangle(
|
0.1,
|
-CesiumMath.PI_OVER_TWO,
|
-0.1,
|
CesiumMath.PI_OVER_TWO
|
);
|
var position = new Cartesian3();
|
var direction = Cartesian3.clone(camera.direction);
|
var up = Cartesian3.clone(camera.up);
|
var right = Cartesian3.clone(camera.right);
|
camera._mode = SceneMode.SCENE3D;
|
position = camera.getRectangleCameraCoordinates(rectangle);
|
expect(position).toEqualEpsilon(
|
new Cartesian3(-14680290.639204923, 0.0, 0.0),
|
CesiumMath.EPSILON6
|
);
|
expect(camera.direction).toEqual(direction);
|
expect(camera.up).toEqual(up);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("views rectangle in 2D with larger latitude", function () {
|
var rectangle = new Rectangle(
|
-CesiumMath.PI_OVER_FOUR,
|
-CesiumMath.PI_OVER_TWO,
|
CesiumMath.PI_OVER_FOUR,
|
CesiumMath.PI_OVER_TWO
|
);
|
var projection = new GeographicProjection();
|
var cam = new Camera(scene);
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.right = 1.0;
|
frustum.left = -1.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
cam.frustum = frustum;
|
var z = cam.position.z;
|
|
cam._mode = SceneMode.SCENE2D;
|
cam._projection = projection;
|
camera.position = cam.getRectangleCameraCoordinates(rectangle);
|
|
expect(camera.position.x).toEqual(0);
|
expect(camera.position.y).toEqual(0);
|
expect(camera.position.z).not.toEqual(z);
|
|
expect(cam.frustum.left).toEqual(-1.0);
|
expect(cam.frustum.far).toEqual(2.0);
|
});
|
|
it("gets coordinates for rectangle in Columbus View", function () {
|
var rectangle = new Rectangle(
|
-CesiumMath.PI_OVER_TWO,
|
-CesiumMath.PI_OVER_TWO,
|
CesiumMath.PI_OVER_TWO,
|
CesiumMath.PI_OVER_TWO
|
);
|
var projection = new GeographicProjection();
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
camera._projection = projection;
|
var direction = Cartesian3.clone(camera.direction);
|
var up = Cartesian3.clone(camera.up);
|
var right = Cartesian3.clone(camera.right);
|
camera.position = camera.getRectangleCameraCoordinates(rectangle);
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(0.0, 0.0, 23137321.67119748),
|
CesiumMath.EPSILON8
|
);
|
expect(camera.direction).toEqual(direction);
|
expect(camera.up).toEqual(up);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("get rectangle coordinate returns camera position if scene mode is morphing", function () {
|
var rectangle = new Rectangle(
|
-CesiumMath.PI_OVER_TWO,
|
-CesiumMath.PI_OVER_TWO,
|
CesiumMath.PI_OVER_TWO,
|
CesiumMath.PI_OVER_TWO
|
);
|
var projection = new GeographicProjection();
|
camera._mode = SceneMode.MORPHING;
|
camera._projection = projection;
|
var position = Cartesian3.clone(camera.position);
|
var direction = Cartesian3.clone(camera.direction);
|
var up = Cartesian3.clone(camera.up);
|
var right = Cartesian3.clone(camera.right);
|
camera.getRectangleCameraCoordinates(rectangle, camera.position);
|
expect(camera.position).toEqual(position);
|
expect(camera.direction).toEqual(direction);
|
expect(camera.up).toEqual(up);
|
expect(camera.right).toEqual(right);
|
});
|
|
it("pick ellipsoid throws without a position", function () {
|
expect(function () {
|
camera.pickEllipsoid();
|
}).toThrowDeveloperError();
|
});
|
|
it("pick ellipsoid returns undefined if height is 0", function () {
|
scene.canvas.clientHeight = 0;
|
expect(camera.pickEllipsoid(Cartesian2.ZERO)).toBeUndefined();
|
});
|
|
it("pick ellipsoid returns undefined if width is 0", function () {
|
scene.canvas.clientWidth = 0;
|
expect(camera.pickEllipsoid(Cartesian2.ZERO)).toBeUndefined();
|
});
|
|
it("pick ellipsoid", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var maxRadii = ellipsoid.maximumRadius;
|
|
camera.position = Cartesian3.multiplyByScalar(
|
Cartesian3.UNIT_X,
|
2.0 * maxRadii,
|
new Cartesian3()
|
);
|
camera.direction = Cartesian3.normalize(
|
Cartesian3.negate(camera.position, new Cartesian3()),
|
new Cartesian3()
|
);
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var frustum = new PerspectiveFrustum();
|
frustum.fov = CesiumMath.toRadians(60.0);
|
frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
|
frustum.near = 100;
|
frustum.far = 60.0 * maxRadii;
|
camera.frustum = frustum;
|
|
var windowCoord = new Cartesian2(
|
scene.canvas.clientWidth * 0.5,
|
scene.canvas.clientHeight * 0.5
|
);
|
var p = camera.pickEllipsoid(windowCoord, ellipsoid);
|
var c = ellipsoid.cartesianToCartographic(p);
|
expect(c).toEqual(new Cartographic(0.0, 0.0, 0.0));
|
|
p = camera.pickEllipsoid(Cartesian2.ZERO, ellipsoid);
|
expect(p).toBeUndefined();
|
});
|
|
it("pickEllipsoid works near the surface", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var minRadii = ellipsoid.minimumRadius;
|
|
// Ten meters above the surface at the north pole, looking down.
|
camera.position = new Cartesian3(0.0, 0.0, minRadii + 10.0);
|
camera.direction = new Cartesian3(0.0, 0.0, -1.0);
|
camera.up = new Cartesian3(1.0, 0.0, 0.0);
|
camera.right = new Cartesian3(0.0, 1.0, 0.0);
|
|
var p = camera.pickEllipsoid(Cartesian2.ZERO, ellipsoid);
|
expect(p.z).toEqualEpsilon(minRadii, 1e-4);
|
});
|
|
it("pick map in 2D", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var projection = new GeographicProjection(ellipsoid);
|
var maxRadii = ellipsoid.maximumRadius;
|
|
camera.position = new Cartesian3(0.0, 0.0, 2.0 * maxRadii);
|
camera.direction = Cartesian3.normalize(
|
Cartesian3.negate(camera.position, new Cartesian3()),
|
new Cartesian3()
|
);
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Y);
|
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.right = maxRadii * Math.PI;
|
frustum.left = -frustum.right;
|
frustum.top =
|
frustum.right * (scene.drawingBufferHeight / scene.drawingBufferWidth);
|
frustum.bottom = -frustum.top;
|
frustum.near = 0.01 * maxRadii;
|
frustum.far = 60.0 * maxRadii;
|
camera.frustum = frustum;
|
|
camera._mode = SceneMode.SCENE2D;
|
camera._projection = projection;
|
|
var windowCoord = new Cartesian2(
|
scene.canvas.clientWidth * 0.5,
|
scene.canvas.clientHeight * 0.5
|
);
|
var p = camera.pickEllipsoid(windowCoord);
|
var c = ellipsoid.cartesianToCartographic(p);
|
expect(c).toEqual(new Cartographic(0.0, 0.0, 0.0));
|
});
|
|
it("pick rotated map in 2D", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var projection = new GeographicProjection(ellipsoid);
|
var maxRadii = ellipsoid.maximumRadius;
|
|
camera.position = new Cartesian3(0.0, 0.0, 2.0 * maxRadii);
|
camera.direction = Cartesian3.normalize(
|
Cartesian3.negate(camera.position, new Cartesian3()),
|
new Cartesian3()
|
);
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Y);
|
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.right = maxRadii * Math.PI;
|
frustum.left = -frustum.right;
|
frustum.top =
|
frustum.right * (scene.drawingBufferHeight / scene.drawingBufferWidth);
|
frustum.bottom = -frustum.top;
|
frustum.near = 0.01 * maxRadii;
|
frustum.far = 60.0 * maxRadii;
|
camera.frustum = frustum;
|
|
camera._mode = SceneMode.SCENE2D;
|
camera._projection = projection;
|
|
var windowCoord = new Cartesian2(
|
scene.canvas.clientWidth * 0.5,
|
scene.canvas.clientHeight * 0.5 + 1.0
|
);
|
var p = camera.pickEllipsoid(windowCoord);
|
var c = ellipsoid.cartesianToCartographic(p);
|
expect(c.longitude).toEqual(0.0);
|
expect(c.latitude).toBeLessThan(0.0);
|
|
camera.up = Cartesian3.negate(Cartesian3.UNIT_X, new Cartesian3());
|
camera.right = Cartesian3.clone(Cartesian3.UNIT_Y);
|
|
p = camera.pickEllipsoid(windowCoord);
|
c = ellipsoid.cartesianToCartographic(p);
|
expect(c.latitude).toEqual(0.0);
|
expect(c.longitude).toBeGreaterThan(0.0);
|
});
|
|
it("pick map in columbus view", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var maxRadii = ellipsoid.maximumRadius;
|
|
camera.position = Cartesian3.multiplyByScalar(
|
Cartesian3.normalize(new Cartesian3(0.0, -1.0, 1.0), new Cartesian3()),
|
5.0 * maxRadii,
|
new Cartesian3()
|
);
|
camera.direction = Cartesian3.normalize(
|
Cartesian3.subtract(Cartesian3.ZERO, camera.position, new Cartesian3()),
|
new Cartesian3()
|
);
|
camera.right = Cartesian3.normalize(
|
Cartesian3.cross(camera.direction, Cartesian3.UNIT_Z, new Cartesian3()),
|
new Cartesian3()
|
);
|
camera.up = Cartesian3.cross(
|
camera.right,
|
camera.direction,
|
new Cartesian3()
|
);
|
|
var frustum = new PerspectiveFrustum();
|
frustum.fov = CesiumMath.toRadians(60.0);
|
frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
|
frustum.near = 0.01 * maxRadii;
|
frustum.far = 60.0 * maxRadii;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.COLUMBUS_VIEW);
|
|
var windowCoord = new Cartesian2(
|
scene.canvas.clientWidth * 0.5,
|
scene.canvas.clientHeight * 0.5
|
);
|
var p = camera.pickEllipsoid(windowCoord);
|
var c = ellipsoid.cartesianToCartographic(p);
|
expect(c).toEqual(new Cartographic(0.0, 0.0, 0.0));
|
|
p = camera.pickEllipsoid(Cartesian2.ZERO);
|
expect(p).toBeUndefined();
|
});
|
|
it("pick map in morph", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var maxRadii = ellipsoid.maximumRadius;
|
|
camera.position = Cartesian3.multiplyByScalar(
|
Cartesian3.UNIT_X,
|
2.0 * maxRadii,
|
new Cartesian3()
|
);
|
camera.direction = Cartesian3.normalize(
|
Cartesian3.negate(camera.position, new Cartesian3()),
|
new Cartesian3()
|
);
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var frustum = new PerspectiveFrustum();
|
frustum.fov = CesiumMath.toRadians(60.0);
|
frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
|
frustum.near = 100;
|
frustum.far = 60.0 * maxRadii;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.MORPHING);
|
|
var windowCoord = new Cartesian2(
|
scene.canvas.clientWidth * 0.5,
|
scene.canvas.clientHeight * 0.5
|
);
|
var p = camera.pickEllipsoid(windowCoord);
|
expect(p).toBeUndefined();
|
});
|
|
it("get pick ray throws without a position", function () {
|
expect(function () {
|
camera.getPickRay();
|
}).toThrowDeveloperError();
|
});
|
|
it("get pick ray perspective", function () {
|
var windowCoord = new Cartesian2(
|
scene.canvas.clientWidth / 2,
|
scene.canvas.clientHeight
|
);
|
var ray = camera.getPickRay(windowCoord);
|
|
var windowHeight =
|
camera.frustum.near * Math.tan(camera.frustum.fovy * 0.5);
|
var expectedDirection = Cartesian3.normalize(
|
new Cartesian3(0.0, -windowHeight, -1.0),
|
new Cartesian3()
|
);
|
expect(ray.origin).toEqual(camera.position);
|
expect(ray.direction).toEqualEpsilon(
|
expectedDirection,
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("get pick ray orthographic in 2D", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.left = -10.0;
|
frustum.right = 10.0;
|
frustum.bottom = -10.0;
|
frustum.top = 10.0;
|
frustum.near = 1.0;
|
frustum.far = 21.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
|
var windowCoord = new Cartesian2(
|
(3.0 / 5.0) * scene.canvas.clientWidth,
|
(1.0 - 3.0 / 5.0) * scene.canvas.clientHeight
|
);
|
var ray = camera.getPickRay(windowCoord);
|
|
var cameraPosition = camera.position;
|
var expectedPosition = new Cartesian3(
|
cameraPosition.z,
|
cameraPosition.x + 2.0,
|
cameraPosition.y + 2.0
|
);
|
expect(ray.origin).toEqualEpsilon(expectedPosition, CesiumMath.EPSILON14);
|
expect(ray.direction).toEqual(camera.directionWC);
|
});
|
|
it("get pick ray orthographic in 3D", function () {
|
var frustum = new OrthographicFrustum();
|
frustum.aspectRatio = 1.0;
|
frustum.width = 20.0;
|
frustum.near = 1.0;
|
frustum.far = 21.0;
|
camera.frustum = frustum;
|
|
// force off center frustum to update
|
expect(frustum.projectionMatrix).toBeDefined();
|
|
camera.update(SceneMode.SCENE3D);
|
|
var windowCoord = new Cartesian2(
|
(3.0 / 5.0) * scene.canvas.clientWidth,
|
(1.0 - 3.0 / 5.0) * scene.canvas.clientHeight
|
);
|
var ray = camera.getPickRay(windowCoord);
|
|
var cameraPosition = camera.position;
|
var expectedPosition = new Cartesian3(
|
cameraPosition.x + 2.0,
|
cameraPosition.y + 2,
|
cameraPosition.z
|
);
|
expect(ray.origin).toEqualEpsilon(expectedPosition, CesiumMath.EPSILON14);
|
expect(ray.direction).toEqual(camera.directionWC);
|
});
|
|
it("get pick ray orthographic in Columbus view", function () {
|
var frustum = new OrthographicFrustum();
|
frustum.aspectRatio = 1.0;
|
frustum.width = 20.0;
|
frustum.near = 1.0;
|
frustum.far = 21.0;
|
camera.frustum = frustum;
|
|
// force off center frustum to update
|
expect(frustum.projectionMatrix).toBeDefined();
|
|
camera.update(SceneMode.COLUMBUS_VIEW);
|
|
var windowCoord = new Cartesian2(
|
(3.0 / 5.0) * scene.canvas.clientWidth,
|
(1.0 - 3.0 / 5.0) * scene.canvas.clientHeight
|
);
|
var ray = camera.getPickRay(windowCoord);
|
|
var cameraPosition = camera.position;
|
var expectedPosition = new Cartesian3(
|
cameraPosition.z,
|
cameraPosition.x + 2.0,
|
cameraPosition.y + 2
|
);
|
expect(ray.origin).toEqualEpsilon(expectedPosition, CesiumMath.EPSILON14);
|
expect(ray.direction).toEqual(camera.directionWC);
|
});
|
|
it("gets magnitude in 2D", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var projection = new GeographicProjection(ellipsoid);
|
var maxRadii = ellipsoid.maximumRadius;
|
|
camera._mode = SceneMode.SCENE2D;
|
camera._projection = projection;
|
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.right = maxRadii * Math.PI;
|
frustum.left = -frustum.right;
|
frustum.top =
|
frustum.right * (scene.drawingBufferHeight / scene.drawingBufferWidth);
|
frustum.bottom = -frustum.top;
|
frustum.near = 0.01 * maxRadii;
|
frustum.far = 60.0 * maxRadii;
|
camera.frustum = frustum;
|
|
expect(camera.getMagnitude()).toEqual(frustum.right - frustum.left);
|
});
|
|
it("gets magnitude in Columbus view", function () {
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
expect(camera.getMagnitude()).toEqual(camera.position.z);
|
});
|
|
it("gets magnitude in 3D", function () {
|
expect(camera.getMagnitude()).toEqual(
|
Cartesian3.magnitude(camera.position)
|
);
|
});
|
|
it("create animation throws without a duration", function () {
|
expect(function () {
|
camera.createCorrectPositionTween();
|
}).toThrowDeveloperError();
|
});
|
|
it("does not animate in 3D", function () {
|
expect(camera.createCorrectPositionTween(0.05)).not.toBeDefined();
|
});
|
|
it("does not animate in 2D", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.near = 1.0;
|
frustum.far = 2.0;
|
frustum.left = -2.0;
|
frustum.right = 2.0;
|
frustum.top = 1.0;
|
frustum.bottom = -1.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
|
var max = scene.mapProjection.project(
|
new Cartographic(Math.PI, CesiumMath.PI_OVER_TWO)
|
);
|
var factor = 1000.0;
|
var dx = max.x * factor;
|
var dy = max.y * factor;
|
|
camera.moveUp(dy);
|
camera.moveRight(dx);
|
|
expect(camera.createCorrectPositionTween(0.05)).not.toBeDefined();
|
});
|
|
it("animates position to visible map in Columbus view", function () {
|
var maxRadii = Ellipsoid.WGS84.maximumRadius;
|
var frustum = new PerspectiveFrustum();
|
frustum.fov = CesiumMath.toRadians(60.0);
|
frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
|
frustum.near = 100;
|
frustum.far = 60.0 * maxRadii;
|
camera.frustum = frustum;
|
camera.position = Cartesian3.multiplyByScalar(
|
Cartesian3.UNIT_Z,
|
maxRadii * 5.0,
|
new Cartesian3()
|
);
|
|
camera.update(SceneMode.COLUMBUS_VIEW);
|
|
var max = scene.mapProjection.project(
|
new Cartographic(Math.PI, CesiumMath.PI_OVER_TWO)
|
);
|
var factor = 1000.0;
|
var dx = max.x * factor;
|
var dy = max.y * factor;
|
var tweens = new TweenCollection();
|
|
camera.moveUp(dy);
|
camera.moveRight(dx);
|
|
var correctAnimation = camera.createCorrectPositionTween(0.05);
|
expect(correctAnimation).toBeDefined();
|
var animation = tweens.add(correctAnimation);
|
while (tweens.contains(animation)) {
|
tweens.update();
|
}
|
|
expect(camera.position.x).toEqualEpsilon(max.x, CesiumMath.EPSILON6);
|
expect(camera.position.y).toEqualEpsilon(max.y, CesiumMath.EPSILON6);
|
|
camera.moveDown(dy);
|
camera.moveLeft(dx);
|
|
correctAnimation = camera.createCorrectPositionTween(0.05);
|
expect(correctAnimation).toBeDefined();
|
animation = tweens.add(correctAnimation);
|
while (tweens.contains(animation)) {
|
tweens.update();
|
}
|
|
expect(camera.position.x).toEqualEpsilon(-max.x, CesiumMath.EPSILON6);
|
expect(camera.position.y).toEqualEpsilon(-max.y, CesiumMath.EPSILON6);
|
});
|
|
it("animates position to visible map in Columbus view with web mercator projection", function () {
|
var projection = new WebMercatorProjection();
|
var mercatorCamera = new Camera(new FakeScene(projection));
|
mercatorCamera.position = Cartesian3.clone(position);
|
mercatorCamera.up = Cartesian3.clone(up);
|
mercatorCamera.direction = Cartesian3.clone(dir);
|
mercatorCamera.right = Cartesian3.clone(right);
|
mercatorCamera.minimumZoomDistance = 0.0;
|
mercatorCamera.update(SceneMode.COLUMBUS_VIEW);
|
|
var maxRadii = Ellipsoid.WGS84.maximumRadius;
|
var frustum = new PerspectiveFrustum();
|
frustum.fov = CesiumMath.toRadians(60.0);
|
frustum.aspectRatio = scene.drawingBufferWidth / scene.drawingBufferHeight;
|
frustum.near = 100;
|
frustum.far = 60.0 * maxRadii;
|
mercatorCamera.frustum = frustum;
|
mercatorCamera.position = Cartesian3.multiplyByScalar(
|
Cartesian3.UNIT_Z,
|
maxRadii * 5.0,
|
new Cartesian3()
|
);
|
|
var max = projection.project(
|
new Cartographic(Math.PI, CesiumMath.PI_OVER_TWO)
|
);
|
var factor = 1000.0;
|
var dx = max.x * factor;
|
var dy = max.y * factor;
|
var tweens = new TweenCollection();
|
|
mercatorCamera.moveUp(dy);
|
mercatorCamera.moveRight(dx);
|
|
var correctAnimation = mercatorCamera.createCorrectPositionTween(0.05);
|
expect(correctAnimation).toBeDefined();
|
var animation = tweens.add(correctAnimation);
|
while (tweens.contains(animation)) {
|
tweens.update();
|
}
|
|
expect(mercatorCamera.position.x).toEqualEpsilon(
|
max.x,
|
CesiumMath.EPSILON6
|
);
|
expect(mercatorCamera.position.y).toEqualEpsilon(
|
max.y,
|
CesiumMath.EPSILON6
|
);
|
|
mercatorCamera.moveDown(dy);
|
mercatorCamera.moveLeft(dx);
|
|
correctAnimation = mercatorCamera.createCorrectPositionTween(0.05);
|
expect(correctAnimation).toBeDefined();
|
animation = tweens.add(correctAnimation);
|
while (tweens.contains(animation)) {
|
tweens.update();
|
}
|
|
expect(mercatorCamera.position.x).toEqualEpsilon(
|
-max.x,
|
CesiumMath.EPSILON6
|
);
|
expect(mercatorCamera.position.y).toEqualEpsilon(
|
-max.y,
|
CesiumMath.EPSILON6
|
);
|
});
|
|
it("flyTo uses CameraFlightPath", function () {
|
spyOn(CameraFlightPath, "createTween").and.returnValue({
|
startObject: {},
|
stopObject: {},
|
duration: 0.001,
|
});
|
|
var options = {
|
destination: Cartesian3.fromDegrees(-117.16, 32.71, 15000.0),
|
orientation: {
|
heading: 0,
|
pitch: 1,
|
roll: 2,
|
},
|
duration: 3,
|
complete: function () {},
|
cancel: function () {},
|
endTransform: new Matrix4(),
|
convert: true,
|
maximumHeight: 100,
|
pitchAdjustHeight: 101,
|
flyOverLongitude: 1,
|
flyOverLongitudeWeight: 20,
|
easingFunction: function () {},
|
};
|
camera.flyTo(options);
|
|
var args = CameraFlightPath.createTween.calls.argsFor(0);
|
var passedOptions = args[1];
|
|
expect(CameraFlightPath.createTween).toHaveBeenCalled();
|
expect(args[0]).toBe(scene);
|
expect(passedOptions.destination).toBe(options.destination);
|
expect(passedOptions.heading).toBe(options.orientation.heading);
|
expect(passedOptions.pitch).toBe(options.orientation.pitch);
|
expect(passedOptions.roll).toBe(options.orientation.roll);
|
expect(typeof passedOptions.complete).toBe("function"); //complete function is wrapped by camera.
|
expect(passedOptions.cancel).toBe(options.cancel);
|
expect(passedOptions.endTransform).toBe(options.endTransform);
|
expect(passedOptions.convert).toBe(options.convert);
|
expect(passedOptions.maximumHeight).toBe(options.maximumHeight);
|
expect(passedOptions.easingFunction).toBe(options.easingFunction);
|
expect(passedOptions.pitchAdjustHeight).toBe(options.pitchAdjustHeight);
|
expect(passedOptions.flyOverLongitude).toBe(options.flyOverLongitude);
|
expect(passedOptions.flyOverLongitudeWeight).toBe(
|
options.flyOverLongitudeWeight
|
);
|
});
|
|
it("can cancel a flight", function () {
|
spyOn(CameraFlightPath, "createTween").and.returnValue({
|
startObject: {},
|
stopObject: {},
|
duration: 0.001,
|
complete: jasmine.createSpy("complete"),
|
cancelTween: jasmine.createSpy("cancelTween"),
|
});
|
|
var options = {
|
destination: Cartesian3.fromDegrees(-117.16, 32.71, 15000.0),
|
};
|
camera.flyTo(options);
|
|
expect(camera._currentFlight).toBeDefined();
|
|
var createdTween = camera._currentFlight;
|
spyOn(createdTween, "cancelTween");
|
camera.cancelFlight();
|
|
expect(createdTween.cancelTween).toHaveBeenCalled();
|
expect(createdTween.complete).not.toHaveBeenCalled();
|
expect(camera._currentFlight).toBeUndefined();
|
});
|
|
it("can complete a flight", function () {
|
spyOn(CameraFlightPath, "createTween").and.returnValue({
|
startObject: {},
|
stopObject: {},
|
duration: 0.001,
|
complete: jasmine.createSpy("complete"),
|
cancelTween: jasmine.createSpy("cancelTween"),
|
});
|
|
spyOn(camera, "setView");
|
|
var options = {
|
destination: Cartesian3.fromDegrees(-117.16, 32.71, 15000.0),
|
orientation: {
|
heading: 1,
|
pitch: 2,
|
roll: 3,
|
},
|
};
|
camera.flyTo(options);
|
|
expect(camera._currentFlight).toBeDefined();
|
|
var createdTween = camera._currentFlight;
|
spyOn(createdTween, "cancelTween");
|
camera.completeFlight();
|
|
expect(createdTween.cancelTween).toHaveBeenCalled();
|
expect(createdTween.complete).toHaveBeenCalled();
|
expect(camera._currentFlight).toBeUndefined();
|
expect(camera.setView).toHaveBeenCalledWith(options);
|
});
|
|
it("flyTo with heading, pitch and roll", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var heading = CesiumMath.toRadians(180.0);
|
var pitch = 0.0;
|
var roll = CesiumMath.toRadians(45.0);
|
|
var options = {
|
destination: Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
orientation: {
|
heading: heading,
|
pitch: pitch,
|
roll: roll,
|
},
|
duration: 0.0,
|
};
|
camera.flyTo(options);
|
|
expect(camera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(camera.pitch).toEqualEpsilon(pitch, CesiumMath.EPSILON6);
|
expect(camera.roll).toEqualEpsilon(roll, CesiumMath.EPSILON6);
|
});
|
|
it("flyTo with direction, up", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var direction = Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3());
|
var up = Cartesian3.clone(Cartesian3.UNIT_Y);
|
|
var options = {
|
destination: Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
orientation: {
|
direction: direction,
|
up: up,
|
},
|
duration: 0.0,
|
};
|
camera.flyTo(options);
|
|
expect(camera.direction).toEqualEpsilon(direction, CesiumMath.EPSILON6);
|
expect(camera.up).toEqualEpsilon(up, CesiumMath.EPSILON6);
|
});
|
|
it("flyHome works in 3D", function () {
|
camera._mode = SceneMode.SCENE3D;
|
|
var destination = Cartesian3.fromDegrees(30, 20, 1000);
|
camera.setView({
|
destination: destination,
|
});
|
camera.flyHome(0);
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(
|
2515865.110478756,
|
-19109892.759980734,
|
13550929.353715947
|
),
|
CesiumMath.EPSILON8
|
);
|
expect(camera.direction).toEqualEpsilon(
|
new Cartesian3(
|
-0.10654051334260287,
|
0.8092555423939248,
|
-0.5777149696185906
|
),
|
CesiumMath.EPSILON8
|
);
|
expect(camera.up).toEqualEpsilon(
|
new Cartesian3(
|
-0.07540693517283716,
|
0.5727725379670786,
|
0.8162385765685121
|
),
|
CesiumMath.EPSILON8
|
);
|
});
|
|
it("flyHome works in 2D", function () {
|
camera._mode = SceneMode.SCENE2D;
|
|
var destination = Cartesian3.fromDegrees(30, 20, 1000);
|
camera.setView({
|
destination: destination,
|
});
|
camera.flyHome(0);
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(-9183857.990445068, 3896182.1777645755, 1.0),
|
CesiumMath.EPSILON8
|
);
|
expect(camera.direction).toEqualEpsilon(
|
new Cartesian3(0, 0, -1),
|
CesiumMath.EPSILON8
|
);
|
expect(camera.up).toEqualEpsilon(Cartesian3.UNIT_Y, CesiumMath.EPSILON8);
|
});
|
|
it("flyHome works in CV", function () {
|
var sq2Over2 = Math.sqrt(2) * 0.5;
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
|
var destination = Cartesian3.fromDegrees(30, 20, 1000);
|
camera.setView({
|
destination: destination,
|
});
|
camera.flyHome(0);
|
expect(camera.position).toEqualEpsilon(
|
new Cartesian3(0, -22550119.620184112, 22550119.62018411),
|
CesiumMath.EPSILON8
|
);
|
expect(camera.direction).toEqualEpsilon(
|
new Cartesian3(0, sq2Over2, -sq2Over2),
|
CesiumMath.EPSILON8
|
);
|
expect(camera.up).toEqualEpsilon(
|
new Cartesian3(0, sq2Over2, sq2Over2),
|
CesiumMath.EPSILON8
|
);
|
});
|
|
it("viewBoundingSphere", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var sphere = new BoundingSphere(
|
Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
10000.0
|
);
|
camera.viewBoundingSphere(sphere);
|
camera._setTransform(Matrix4.IDENTITY);
|
|
var distance = Cartesian3.distance(camera.position, sphere.center);
|
expect(distance).toBeGreaterThan(sphere.radius);
|
expect(distance).toBeLessThan(sphere.radius * 3.0);
|
});
|
|
it("viewBoundingSphere with offset", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var heading = CesiumMath.toRadians(45.0);
|
var pitch = CesiumMath.toRadians(-45.0);
|
var range = 15.0;
|
|
var sphere = new BoundingSphere(
|
Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
10.0
|
);
|
camera.viewBoundingSphere(
|
sphere,
|
new HeadingPitchRange(heading, pitch, range)
|
);
|
camera._setTransform(Matrix4.IDENTITY);
|
|
var distance = Cartesian3.distance(camera.position, sphere.center);
|
expect(distance).toEqualEpsilon(range, CesiumMath.EPSILON10);
|
expect(camera.heading).toEqualEpsilon(heading, CesiumMath.EPSILON6);
|
expect(camera.pitch).toEqualEpsilon(pitch, CesiumMath.EPSILON5);
|
});
|
|
it("viewBoundingSphere does not modify offset.range when it is zero", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var heading = CesiumMath.toRadians(45.0);
|
var pitch = CesiumMath.toRadians(-45.0);
|
var range = 0.0;
|
var offset = new HeadingPitchRange(heading, pitch, range);
|
|
var sphere = new BoundingSphere(
|
Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
10.0
|
);
|
camera.viewBoundingSphere(sphere, offset);
|
camera._setTransform(Matrix4.IDENTITY);
|
|
expect(offset.heading).toEqual(CesiumMath.toRadians(45.0));
|
expect(offset.pitch).toEqual(CesiumMath.toRadians(-45.0));
|
expect(offset.range).toEqual(0.0);
|
});
|
|
it("viewBoundingSphere in 2D", function () {
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.left = -10.0;
|
frustum.right = 10.0;
|
frustum.bottom = -10.0;
|
frustum.top = 10.0;
|
frustum.near = 1.0;
|
frustum.far = 21.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE2D);
|
|
var sphere = new BoundingSphere(
|
Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
10000.0
|
);
|
camera.viewBoundingSphere(sphere);
|
camera._setTransform(Matrix4.IDENTITY);
|
|
var distance = frustum.right - frustum.left;
|
expect(distance).toBeGreaterThan(sphere.radius);
|
expect(distance).toBeLessThan(sphere.radius * 3.0);
|
});
|
|
it("viewBoundingSphere in 3D with orthographic", function () {
|
var frustum = new OrthographicFrustum();
|
frustum.aspectRatio = 1.0;
|
frustum.width = 20.0;
|
frustum.near = 1.0;
|
frustum.far = 21.0;
|
camera.frustum = frustum;
|
|
camera.update(SceneMode.SCENE3D);
|
|
// force off center update
|
expect(frustum.projectionMatrix).toBeDefined();
|
|
var sphere = new BoundingSphere(
|
Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
10000.0
|
);
|
camera.viewBoundingSphere(sphere);
|
camera._setTransform(Matrix4.IDENTITY);
|
|
var distance = frustum.width;
|
expect(distance).toBeGreaterThan(sphere.radius);
|
expect(distance).toBeLessThan(sphere.radius * 3.0);
|
});
|
|
it("viewBoundingSphere throws when morphing", function () {
|
camera._mode = SceneMode.MORPHING;
|
|
expect(function () {
|
camera.viewBoundingSphere(new BoundingSphere());
|
}).toThrowDeveloperError();
|
});
|
|
it("viewBoundingSphere throws without bounding sphere", function () {
|
camera._mode = SceneMode.MORPHING;
|
|
expect(function () {
|
camera.viewBoundingSphere(undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("flyToBoundingSphere uses CameraFlightPath", function () {
|
spyOn(CameraFlightPath, "createTween").and.returnValue({
|
startObject: {},
|
stopObject: {},
|
duration: 0.0,
|
});
|
|
var sphere = new BoundingSphere(
|
Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
100000.0
|
);
|
camera.flyToBoundingSphere(sphere);
|
|
expect(CameraFlightPath.createTween).toHaveBeenCalled();
|
});
|
|
it("flyToBoundingSphere uses CameraFlightPath", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var sphere = new BoundingSphere(
|
Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
10000.0
|
);
|
camera.flyToBoundingSphere(sphere, {
|
duration: 0.0,
|
});
|
|
var distance = Cartesian3.distance(camera.position, sphere.center);
|
expect(distance).toBeGreaterThan(sphere.radius);
|
expect(distance).toBeLessThan(sphere.radius * 3.0);
|
});
|
|
it("flyToBoundingSphere does not zoom closer than minimumZoomDistance", function () {
|
scene.mode = SceneMode.SCENE3D;
|
var minValue = 1000;
|
scene.screenSpaceCameraController.minimumZoomDistance = minValue;
|
|
var sphere = new BoundingSphere(
|
Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
10.0
|
);
|
|
camera.flyToBoundingSphere(sphere, {
|
duration: 0.0,
|
});
|
|
var distance = Cartesian3.distance(camera.position, sphere.center);
|
expect(CesiumMath.equalsEpsilon(distance, minValue, 0.1)).toBe(true);
|
});
|
|
it("flyToBoundingSphere does not zoom further than maximumZoomDistance", function () {
|
scene.mode = SceneMode.SCENE3D;
|
var maxValue = 10000;
|
scene.screenSpaceCameraController.maximumZoomDistance = maxValue;
|
|
var sphere = new BoundingSphere(
|
Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
100000
|
);
|
|
camera.flyToBoundingSphere(sphere, {
|
duration: 0.0,
|
});
|
|
var distance = Cartesian3.distance(camera.position, sphere.center);
|
expect(CesiumMath.equalsEpsilon(distance, maxValue, 0.1)).toBe(true);
|
});
|
|
it("flyToBoundingSphere does not modify options.offset range if it is zero ", function () {
|
scene.mode = SceneMode.SCENE3D;
|
var options = {
|
offset: new HeadingPitchRange(0.0, -1.5, 0.0),
|
};
|
|
var sphere = new BoundingSphere(
|
Cartesian3.fromDegrees(-117.16, 32.71, 0.0),
|
100000.0
|
);
|
camera.flyToBoundingSphere(sphere, options);
|
|
expect(options.offset.heading).toEqual(0.0);
|
expect(options.offset.pitch).toEqual(-1.5);
|
expect(options.offset.range).toEqual(0.0);
|
});
|
|
it("distanceToBoundingSphere", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var sphere = new BoundingSphere(Cartesian3.ZERO, 0.5);
|
var distance = camera.distanceToBoundingSphere(sphere);
|
expect(distance).toEqual(0.5);
|
});
|
|
it("distanceToBoundingSphere throws when there is no bounding sphere", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
expect(function () {
|
camera.distanceToBoundingSphere();
|
}).toThrowDeveloperError();
|
});
|
|
it("getPixelSize", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var oldPixelRatio = scene.pixelRatio;
|
scene.pixelRatio = 1.0;
|
|
var sphere = new BoundingSphere(Cartesian3.ZERO, 0.5);
|
var context = scene.context;
|
var drawingBufferWidth = context.drawingBufferWidth;
|
var drawingBufferHeight = context.drawingBufferHeight;
|
|
// Compute expected pixel size
|
var distance = camera.distanceToBoundingSphere(sphere);
|
var pixelDimensions = camera.frustum.getPixelDimensions(
|
drawingBufferWidth,
|
drawingBufferHeight,
|
distance,
|
scene.pixelRatio,
|
new Cartesian2()
|
);
|
var expectedPixelSize = Math.max(pixelDimensions.x, pixelDimensions.y);
|
|
var pixelSize = camera.getPixelSize(
|
sphere,
|
drawingBufferWidth,
|
drawingBufferHeight
|
);
|
expect(pixelSize).toEqual(expectedPixelSize);
|
|
scene.pixelRatio = oldPixelRatio;
|
});
|
|
it("getPixelSize throws when there is no bounding sphere", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
expect(function () {
|
camera.getPixelSize();
|
}).toThrowDeveloperError();
|
});
|
|
it("getPixelSize throws when there is no drawing buffer width", function () {
|
scene.mode = SceneMode.SCENE3D;
|
var sphere = new BoundingSphere(Cartesian3.ZERO, 0.5);
|
|
expect(function () {
|
camera.getPixelSize(sphere);
|
}).toThrowDeveloperError();
|
});
|
|
it("getPixelSize throws when there is no drawing buffer height", function () {
|
scene.mode = SceneMode.SCENE3D;
|
var sphere = new BoundingSphere(Cartesian3.ZERO, 0.5);
|
|
expect(function () {
|
camera.getPixelSize(sphere, 10);
|
}).toThrowDeveloperError();
|
});
|
|
it("computeViewRectangle when zoomed in", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var position = Cartesian3.clone(Cartesian3.UNIT_X);
|
Cartesian3.multiplyByScalar(position, 7000000, position);
|
|
camera.position = position;
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.direction = Cartesian3.negate(Cartesian3.UNIT_X, new Cartesian3());
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var correctResult = new Rectangle(
|
-0.05789100547374969,
|
-0.04365869998457809,
|
0.05789100547374969,
|
0.04365869998457809
|
);
|
|
var rect = camera.computeViewRectangle();
|
expect(rect).toEqualEpsilon(correctResult, CesiumMath.EPSILON10);
|
});
|
|
it("computeViewRectangle when zoomed in to pole", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var position = Cartesian3.clone(Cartesian3.UNIT_Z);
|
Cartesian3.multiplyByScalar(position, 7000000, position);
|
camera.position = position;
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Y);
|
camera.direction = Cartesian3.negate(Cartesian3.UNIT_Z, new Cartesian3());
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var correctResult = new Rectangle(
|
-CesiumMath.PI,
|
1.4961779388065022,
|
CesiumMath.PI,
|
CesiumMath.PI_OVER_TWO
|
);
|
|
var rect = camera.computeViewRectangle();
|
expect(rect).toEqual(correctResult);
|
});
|
|
it("computeViewRectangle when zoomed in to IDL", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var position = Cartesian3.negate(Cartesian3.UNIT_X, new Cartesian3());
|
Cartesian3.multiplyByScalar(position, 7000000, position);
|
camera.position = position;
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.direction = Cartesian3.clone(Cartesian3.UNIT_X, new Cartesian3());
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var correctResult = new Rectangle(
|
3.0837016481160435,
|
-0.04365869998457809,
|
-3.0837016481160435,
|
0.04365869998457809
|
);
|
|
var rect = camera.computeViewRectangle();
|
expect(rect).toEqualEpsilon(correctResult, CesiumMath.EPSILON10);
|
});
|
|
it("computeViewRectangle when zoomed out", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var position = Cartesian3.clone(Cartesian3.UNIT_X);
|
Cartesian3.multiplyByScalar(position, 25000000, position);
|
|
camera.position = position;
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.direction = Cartesian3.negate(Cartesian3.UNIT_X, new Cartesian3());
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var rect = camera.computeViewRectangle();
|
expect(rect).toEqual(Rectangle.MAX_VALUE);
|
});
|
|
it("computeViewRectangle when globe isn't visible", function () {
|
scene.mode = SceneMode.SCENE3D;
|
|
var position = Cartesian3.clone(Cartesian3.UNIT_X);
|
Cartesian3.multiplyByScalar(position, 7000000, position);
|
|
camera.position = position;
|
camera.up = Cartesian3.clone(Cartesian3.UNIT_Z);
|
camera.direction = Cartesian3.clone(Cartesian3.UNIT_X);
|
camera.right = Cartesian3.cross(
|
camera.direction,
|
camera.up,
|
new Cartesian3()
|
);
|
|
var rect = camera.computeViewRectangle();
|
expect(rect).not.toBeDefined();
|
});
|
|
it("flyTo rectangle in 2D", function () {
|
var tweenSpy = spyOn(CameraFlightPath, "createTween").and.returnValue({});
|
spyOn(scene.tweens, "add");
|
|
camera._mode = SceneMode.SCENE2D;
|
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.left = -10.0;
|
frustum.right = 10.0;
|
frustum.bottom = -10.0;
|
frustum.top = 10.0;
|
frustum.near = 1.0;
|
frustum.far = 21.0;
|
camera.frustum = frustum;
|
|
var west = 0.3323436621771766;
|
var south = 0.8292930502744068;
|
var east = 0.3325710961342694;
|
var north = 0.8297059734014236;
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var expectedDestination = camera.getRectangleCameraCoordinates(rectangle);
|
camera.flyTo({ destination: rectangle });
|
|
expect(
|
tweenSpy.calls
|
.mostRecent()
|
.args[1].destination.equalsEpsilon(expectedDestination, 0.1)
|
).toBe(true);
|
});
|
|
it("flyTo rectangle in CV", function () {
|
var tweenSpy = spyOn(CameraFlightPath, "createTween").and.returnValue({});
|
spyOn(scene.tweens, "add");
|
|
camera._mode = SceneMode.COLUMBUS_VIEW;
|
|
var west = 0.3323436621771766;
|
var south = 0.8292930502744068;
|
var east = 0.3325710961342694;
|
var north = 0.8297059734014236;
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var expectedDestination = camera.getRectangleCameraCoordinates(rectangle);
|
camera.flyTo({ destination: rectangle });
|
|
expect(
|
tweenSpy.calls
|
.mostRecent()
|
.args[1].destination.equalsEpsilon(expectedDestination, 0.1)
|
).toBe(true);
|
});
|
|
it("flyTo rectangle in 3D", function () {
|
var tweenSpy = spyOn(CameraFlightPath, "createTween").and.returnValue({});
|
spyOn(scene.tweens, "add");
|
|
camera._mode = SceneMode.SCENE3D;
|
|
var west = 0.3323436621771766;
|
var south = 0.8292930502744068;
|
var east = 0.3325710961342694;
|
var north = 0.8297059734014236;
|
var rectangle = new Rectangle(west, south, east, north);
|
|
var expectedDestination = camera.getRectangleCameraCoordinates(rectangle);
|
camera.flyTo({ destination: rectangle });
|
|
expect(
|
tweenSpy.calls
|
.mostRecent()
|
.args[1].destination.equalsEpsilon(expectedDestination, 0.1)
|
).toBe(true);
|
});
|
|
it("flyTo does not zoom closer than minimumZoomDistance", function () {
|
var tweenSpy = spyOn(CameraFlightPath, "createTween").and.returnValue({});
|
spyOn(scene.tweens, "add");
|
|
scene.mode = SceneMode.SCENE3D;
|
scene.screenSpaceCameraController.minimumZoomDistance = 1000;
|
scene.screenSpaceCameraController.maximumZoomDistance = 10000;
|
|
var sourceDestination = Cartesian3.fromDegrees(-117.16, 32.71, 100);
|
var expectedDestination = Cartesian3.clone(sourceDestination);
|
expectedDestination.z = Cartesian3.fromDegrees(-117.16, 32.71, 1000).z;
|
|
camera.flyTo({ destination: sourceDestination });
|
|
expect(
|
tweenSpy.calls
|
.mostRecent()
|
.args[1].destination.equalsEpsilon(expectedDestination, 0.1)
|
).toBe(true);
|
});
|
|
it("flyTo does not zoom further than maximumZoomDistance", function () {
|
var tweenSpy = spyOn(CameraFlightPath, "createTween").and.returnValue({});
|
spyOn(scene.tweens, "add");
|
|
scene.mode = SceneMode.SCENE3D;
|
scene.screenSpaceCameraController.minimumZoomDistance = 1000;
|
scene.screenSpaceCameraController.maximumZoomDistance = 10000;
|
|
var sourceDestination = Cartesian3.fromDegrees(-117.16, 32.71, 100000);
|
var expectedDestination = Cartesian3.clone(sourceDestination);
|
expectedDestination.z = Cartesian3.fromDegrees(-117.16, 32.71, 10000).z;
|
|
camera.flyTo({ destination: sourceDestination });
|
|
expect(
|
tweenSpy.calls
|
.mostRecent()
|
.args[1].destination.equalsEpsilon(expectedDestination, 0.1)
|
).toBe(true);
|
});
|
|
it("flyTo zooms in between minimumZoomDistance and maximumZoomDistance", function () {
|
var tweenSpy = spyOn(CameraFlightPath, "createTween").and.returnValue({});
|
spyOn(scene.tweens, "add");
|
|
scene.mode = SceneMode.SCENE3D;
|
scene.screenSpaceCameraController.minimumZoomDistance = 1000;
|
scene.screenSpaceCameraController.maximumZoomDistance = 10000;
|
|
var sourceDestination = Cartesian3.fromDegrees(-117.16, 32.71, 5000);
|
var expectedDestination = Cartesian3.clone(sourceDestination);
|
|
camera.flyTo({ destination: sourceDestination });
|
|
expect(
|
tweenSpy.calls
|
.mostRecent()
|
.args[1].destination.equalsEpsilon(expectedDestination, 0.1)
|
).toBe(true);
|
});
|
|
it("_currentFlight is not set for a flight that doesn't go anywhere", function () {
|
var complete = jasmine.createSpy("complete");
|
spyOn(CameraFlightPath, "createTween").and.returnValue({
|
complete: complete,
|
duration: 0,
|
});
|
spyOn(scene.tweens, "add");
|
|
camera.flyTo({
|
complete: complete,
|
destination: Cartesian3.fromDegrees(-117.16, 32.71, 5000),
|
});
|
expect(complete).toHaveBeenCalled();
|
expect(camera._currentFlight).toBeUndefined();
|
});
|
|
it("switches projections", function () {
|
expect(camera.frustum).toBeInstanceOf(PerspectiveFrustum);
|
camera.switchToOrthographicFrustum();
|
expect(camera.frustum).toBeInstanceOf(OrthographicFrustum);
|
camera.switchToPerspectiveFrustum();
|
expect(camera.frustum).toBeInstanceOf(PerspectiveFrustum);
|
});
|
|
it("does not switch projection in 2D", function () {
|
var ellipsoid = Ellipsoid.WGS84;
|
var projection = new GeographicProjection(ellipsoid);
|
var maxRadii = ellipsoid.maximumRadius;
|
|
camera._mode = SceneMode.SCENE2D;
|
camera._projection = projection;
|
|
var frustum = new OrthographicOffCenterFrustum();
|
frustum.right = maxRadii * Math.PI;
|
frustum.left = -frustum.right;
|
frustum.top =
|
frustum.right * (scene.drawingBufferHeight / scene.drawingBufferWidth);
|
frustum.bottom = -frustum.top;
|
frustum.near = 0.01 * maxRadii;
|
frustum.far = 60.0 * maxRadii;
|
camera.frustum = frustum;
|
|
expect(camera.frustum).toBeInstanceOf(OrthographicOffCenterFrustum);
|
camera.switchToOrthographicFrustum();
|
expect(camera.frustum).toBeInstanceOf(OrthographicOffCenterFrustum);
|
camera.switchToPerspectiveFrustum();
|
expect(camera.frustum).toBeInstanceOf(OrthographicOffCenterFrustum);
|
});
|
|
it("normalizes WC members", function () {
|
var transform = Matrix4.fromScale(new Cartesian3(2, 2, 2));
|
camera.lookAtTransform(transform);
|
expect(Cartesian3.magnitude(camera.directionWC)).toEqualEpsilon(
|
1.0,
|
CesiumMath.EPSILON15
|
);
|
expect(Cartesian3.magnitude(camera.rightWC)).toEqualEpsilon(
|
1.0,
|
CesiumMath.EPSILON15
|
);
|
expect(Cartesian3.magnitude(camera.upWC)).toEqualEpsilon(
|
1.0,
|
CesiumMath.EPSILON15
|
);
|
});
|
|
it("get camera deltas", function () {
|
camera._updateCameraChanged();
|
expect(camera.positionWCDeltaMagnitude).toEqual(0);
|
expect(camera.positionWCDeltaMagnitudeLastFrame).toEqual(0);
|
|
camera.moveUp(moveAmount);
|
|
camera._updateCameraChanged();
|
expect(camera.positionWCDeltaMagnitude).toEqualEpsilon(
|
moveAmount,
|
CesiumMath.EPSILON10
|
);
|
expect(camera.positionWCDeltaMagnitudeLastFrame).toEqual(0);
|
|
camera._updateCameraChanged();
|
expect(camera.positionWCDeltaMagnitude).toEqual(0);
|
expect(camera.positionWCDeltaMagnitudeLastFrame).toEqualEpsilon(
|
moveAmount,
|
CesiumMath.EPSILON10
|
);
|
});
|
});
|
