[core] Transform s/angle/bearing/

31 files changed, 124 insertions, 118 deletions

diff --git a/benchmark/util/tilecover.benchmark.cpp b/benchmark/util/tilecover.benchmark.cpp
index 186de6f216..1b2713d04b 100644
--- a/benchmark/util/tilecover.benchmark.cpp
+++ b/benchmark/util/tilecover.benchmark.cpp
@@ -24,7 +24,7 @@ static void TileCoverPitchedViewport(benchmark::State& state) {
     // slightly offset center so that tile order is better defined
     transform.setLatLng({ 0.1, -0.1 });
     transform.setZoom(8);
-    transform.setAngle(5.0);
+    transform.setBearing(5.0);
     transform.setPitch(40.0 * M_PI / 180.0);
     
     std::size_t length = 0;
diff --git a/include/mbgl/map/camera.hpp b/include/mbgl/map/camera.hpp
index 53b5b590b1..a800e254a0 100644
--- a/include/mbgl/map/camera.hpp
+++ b/include/mbgl/map/camera.hpp
@@ -29,7 +29,7 @@ struct CameraOptions {
 
     /** Bearing, measured in radians counterclockwise from true north. Wrapped
         to [−π rad, π rad). */
-    optional<double> angle;
+    optional<double> bearing;
 
     /** Pitch toward the horizon measured in radians, with 0 rad resulting in a
         two-dimensional map. */
@@ -41,7 +41,7 @@ constexpr bool operator==(const CameraOptions& a, const CameraOptions& b) {
         && a.padding == b.padding
         && a.anchor == b.anchor
         && a.zoom == b.zoom
-        && a.angle == b.angle
+        && a.bearing == b.bearing
         && a.pitch == b.pitch;
 }
 
diff --git a/platform/android/src/map/camera_position.cpp b/platform/android/src/map/camera_position.cpp
index 01ffc6530b..b4d157a236 100644
--- a/platform/android/src/map/camera_position.cpp
+++ b/platform/android/src/map/camera_position.cpp
@@ -13,7 +13,7 @@ jni::Object<CameraPosition> CameraPosition::New(jni::JNIEnv &env, mbgl::CameraOp
 
     // convert bearing, measured in radians counterclockwise from true north.
     // Wrapped to [−π rad, π rad). Android binding from 0 to 360 degrees
-    double bearing_degrees = -options.angle.value_or(0) * util::RAD2DEG;
+    double bearing_degrees = -options.bearing.value_or(0) * util::RAD2DEG;
     while (bearing_degrees > 360) {
         bearing_degrees -= 360;
     }
diff --git a/platform/android/src/native_map_view.cpp b/platform/android/src/native_map_view.cpp
index c648a22893..5aeab6ded8 100755
--- a/platform/android/src/native_map_view.cpp
+++ b/platform/android/src/native_map_view.cpp
@@ -220,10 +220,10 @@ void NativeMapView::moveBy(jni::JNIEnv&, jni::jdouble dx, jni::jdouble dy, jni::
     map->moveBy({dx, dy}, animationOptions);
 }
 
-void NativeMapView::jumpTo(jni::JNIEnv&, jni::jdouble angle, jni::jdouble latitude, jni::jdouble longitude, jni::jdouble pitch, jni::jdouble zoom) {
+void NativeMapView::jumpTo(jni::JNIEnv&, jni::jdouble bearing, jni::jdouble latitude, jni::jdouble longitude, jni::jdouble pitch, jni::jdouble zoom) {
     mbgl::CameraOptions options;
-    if (angle != -1) {
-        options.angle = -angle * util::DEG2RAD;
+    if (bearing != -1) {
+        options.bearing = -bearing * util::DEG2RAD;
     }
     options.center = mbgl::LatLng(latitude, longitude);
     options.padding = insets;
@@ -237,10 +237,10 @@ void NativeMapView::jumpTo(jni::JNIEnv&, jni::jdouble angle, jni::jdouble latitu
     map->jumpTo(options);
 }
 
-void NativeMapView::easeTo(jni::JNIEnv&, jni::jdouble angle, jni::jdouble latitude, jni::jdouble longitude, jni::jlong duration, jni::jdouble pitch, jni::jdouble zoom, jni::jboolean easing) {
+void NativeMapView::easeTo(jni::JNIEnv&, jni::jdouble bearing, jni::jdouble latitude, jni::jdouble longitude, jni::jlong duration, jni::jdouble pitch, jni::jdouble zoom, jni::jboolean easing) {
     mbgl::CameraOptions cameraOptions;
-    if (angle != -1) {
-        cameraOptions.angle = -angle * util::DEG2RAD;
+    if (bearing != -1) {
+        cameraOptions.bearing = -bearing * util::DEG2RAD;
     }
     cameraOptions.center = mbgl::LatLng(latitude, longitude);
     cameraOptions.padding = insets;
@@ -261,10 +261,10 @@ void NativeMapView::easeTo(jni::JNIEnv&, jni::jdouble angle, jni::jdouble latitu
     map->easeTo(cameraOptions, animationOptions);
 }
 
-void NativeMapView::flyTo(jni::JNIEnv&, jni::jdouble angle, jni::jdouble latitude, jni::jdouble longitude, jni::jlong duration, jni::jdouble pitch, jni::jdouble zoom) {
+void NativeMapView::flyTo(jni::JNIEnv&, jni::jdouble bearing, jni::jdouble latitude, jni::jdouble longitude, jni::jlong duration, jni::jdouble pitch, jni::jdouble zoom) {
     mbgl::CameraOptions cameraOptions;
-    if (angle != -1) {
-        cameraOptions.angle = -angle * util::DEG2RAD;
+    if (bearing != -1) {
+        cameraOptions.bearing = -bearing* util::DEG2RAD;
     }
     cameraOptions.center = mbgl::LatLng(latitude, longitude);
     cameraOptions.padding = insets;
@@ -385,7 +385,7 @@ void NativeMapView::setVisibleCoordinateBounds(JNIEnv& env, jni::Array<jni::Obje
     mbgl::CameraOptions cameraOptions = map->cameraForLatLngs(latLngs, mbglInsets);
     if (direction >= 0) {
         // convert from degrees to radians
-        cameraOptions.angle = (-direction * M_PI) / 180;
+        cameraOptions.bearing = (-direction * M_PI) / 180;
     }
 
     mbgl::AnimationOptions animationOptions;
diff --git a/platform/darwin/src/MGLMapSnapshotter.mm b/platform/darwin/src/MGLMapSnapshotter.mm
index d9d16cc5be..76e2fd7768 100644
--- a/platform/darwin/src/MGLMapSnapshotter.mm
+++ b/platform/darwin/src/MGLMapSnapshotter.mm
@@ -493,7 +493,7 @@ const CGFloat MGLSnapshotterMinimumPixelSize = 64;
     if (CLLocationCoordinate2DIsValid(options.camera.centerCoordinate)) {
         cameraOptions.center = MGLLatLngFromLocationCoordinate2D(options.camera.centerCoordinate);
     }
-    cameraOptions.angle = MAX(0, options.camera.heading) * mbgl::util::DEG2RAD;
+    cameraOptions.bearing = MAX(0, options.camera.heading) * mbgl::util::DEG2RAD;
     cameraOptions.zoom = MAX(0, options.zoomLevel);
     cameraOptions.pitch = MAX(0, options.camera.pitch);
     
diff --git a/platform/ios/src/MGLMapView.mm b/platform/ios/src/MGLMapView.mm
index e4906e3688..6b24f332ed 100644
--- a/platform/ios/src/MGLMapView.mm
+++ b/platform/ios/src/MGLMapView.mm
@@ -227,7 +227,7 @@ public:
 @property (nonatomic) MGLUserTrackingState userTrackingState;
 @property (nonatomic) CLLocationManager *locationManager;
 @property (nonatomic) CGFloat scale;
-@property (nonatomic) CGFloat angle;
+@property (nonatomic) CGFloat bearing;
 @property (nonatomic) CGFloat quickZoomStart;
 @property (nonatomic, getter=isDormant) BOOL dormant;
 @property (nonatomic, readonly, getter=isRotationAllowed) BOOL rotationAllowed;
@@ -1500,7 +1500,7 @@ public:
     {
         [self trackGestureEvent:MMEEventGestureRotateStart forRecognizer:rotate];
 
-        self.angle = MGLRadiansFromDegrees(_mbglMap->getBearing()) * -1;
+        self.bearing = MGLRadiansFromDegrees(_mbglMap->getBearing()) * -1;
 
         if (self.userTrackingMode != MGLUserTrackingModeNone)
         {
@@ -1513,7 +1513,7 @@ public:
     }
     else if (rotate.state == UIGestureRecognizerStateChanged)
     {
-        CGFloat newDegrees = MGLDegreesFromRadians(self.angle + rotate.rotation) * -1;
+        CGFloat newDegrees = MGLDegreesFromRadians(self.bearing + rotate.rotation) * -1;
 
         // constrain to +/-30 degrees when merely rotating like Apple does
         //
@@ -1554,7 +1554,7 @@ public:
         CGFloat decelerationRate = self.decelerationRate;
         if (decelerationRate != MGLMapViewDecelerationRateImmediate && fabs(velocity) > 3)
         {
-            CGFloat radians = self.angle + rotate.rotation;
+            CGFloat radians = self.bearing + rotate.rotation;
             CGFloat newRadians = radians + velocity * decelerationRate * 0.1;
             CGFloat newDegrees = MGLDegreesFromRadians(newRadians) * -1;
 
@@ -1866,7 +1866,7 @@ public:
     MGLMapCamera *camera;
     
     mbgl::ScreenCoordinate anchor = mbgl::ScreenCoordinate { anchorPoint.x, anchorPoint.y };
-    currentCameraOptions.angle = degrees * mbgl::util::DEG2RAD;
+    currentCameraOptions.bearing = degrees * mbgl::util::DEG2RAD;
     currentCameraOptions.anchor = anchor;
     camera = [self cameraForCameraOptions:currentCameraOptions];
     
@@ -2294,7 +2294,7 @@ public:
 {
     auto camera = _mbglMap->getStyle().getDefaultCamera();
     CGFloat pitch = *camera.pitch;
-    CLLocationDirection heading = mbgl::util::wrap(*camera.angle, 0., 360.);
+    CLLocationDirection heading = mbgl::util::wrap(*camera.bearing, 0., 360.);
     CLLocationDistance distance = MGLAltitudeForZoomLevel(*camera.zoom, pitch, 0, self.frame.size);
     self.camera = [MGLMapCamera cameraLookingAtCenterCoordinate:MGLLocationCoordinate2DFromLatLng(*camera.center)
                                                    fromDistance:distance
@@ -2920,7 +2920,7 @@ public:
     cameraOptions.zoom = zoomLevel;
     if (direction >= 0)
     {
-        cameraOptions.angle = MGLRadiansFromDegrees(-direction);
+        cameraOptions.bearing = MGLRadiansFromDegrees(-direction);
     }
 
     mbgl::AnimationOptions animationOptions;
@@ -3090,7 +3090,7 @@ public:
     mbgl::CameraOptions cameraOptions = _mbglMap->cameraForLatLngs(latLngs, padding);
     if (direction >= 0)
     {
-        cameraOptions.angle = MGLRadiansFromDegrees(-direction);
+        cameraOptions.bearing = MGLRadiansFromDegrees(-direction);
     }
 
     mbgl::AnimationOptions animationOptions;
@@ -3369,7 +3369,7 @@ public:
 {
     CLLocationCoordinate2D centerCoordinate = MGLLocationCoordinate2DFromLatLng(cameraOptions.center ? *cameraOptions.center : _mbglMap->getLatLng());
     double zoomLevel = cameraOptions.zoom ? *cameraOptions.zoom : self.zoomLevel;
-    CLLocationDirection direction = cameraOptions.angle ? mbgl::util::wrap(-MGLDegreesFromRadians(*cameraOptions.angle), 0., 360.) : self.direction;
+    CLLocationDirection direction = cameraOptions.bearing ? mbgl::util::wrap(-MGLDegreesFromRadians(*cameraOptions.bearing), 0., 360.) : self.direction;
     CGFloat pitch = cameraOptions.pitch ? MGLDegreesFromRadians(*cameraOptions.pitch) : _mbglMap->getPitch();
     CLLocationDistance altitude = MGLAltitudeForZoomLevel(zoomLevel, pitch, centerCoordinate.latitude, self.frame.size);
     return [MGLMapCamera cameraLookingAtCenterCoordinate:centerCoordinate fromDistance:altitude pitch:pitch heading:direction];
@@ -3390,7 +3390,7 @@ public:
                                            self.frame.size);
     if (camera.heading >= 0)
     {
-        options.angle = MGLRadiansFromDegrees(-camera.heading);
+        options.bearing = MGLRadiansFromDegrees(-camera.heading);
     }
     if (camera.pitch >= 0)
     {
diff --git a/platform/macos/src/MGLMapView.mm b/platform/macos/src/MGLMapView.mm
index 154b716377..b25b0f0294 100644
--- a/platform/macos/src/MGLMapView.mm
+++ b/platform/macos/src/MGLMapView.mm
@@ -1217,7 +1217,7 @@ public:
                                            camera.centerCoordinate.latitude,
                                            self.frame.size);
     if (camera.heading >= 0) {
-        options.angle = MGLRadiansFromDegrees(-camera.heading);
+        options.bearing = MGLRadiansFromDegrees(-camera.heading);
     }
     if (camera.pitch >= 0) {
         options.pitch = MGLRadiansFromDegrees(camera.pitch);
@@ -1313,7 +1313,7 @@ public:
 - (MGLMapCamera *)cameraForCameraOptions:(const mbgl::CameraOptions &)cameraOptions {
     CLLocationCoordinate2D centerCoordinate = MGLLocationCoordinate2DFromLatLng(cameraOptions.center ? *cameraOptions.center : _mbglMap->getLatLng());
     double zoomLevel = cameraOptions.zoom ? *cameraOptions.zoom : self.zoomLevel;
-    CLLocationDirection direction = cameraOptions.angle ? mbgl::util::wrap(-MGLDegreesFromRadians(*cameraOptions.angle), 0., 360.) : self.direction;
+    CLLocationDirection direction = cameraOptions.bearing ? mbgl::util::wrap(-MGLDegreesFromRadians(*cameraOptions.bearing), 0., 360.) : self.direction;
     CGFloat pitch = cameraOptions.pitch ? MGLDegreesFromRadians(*cameraOptions.pitch) : _mbglMap->getPitch();
     CLLocationDistance altitude = MGLAltitudeForZoomLevel(zoomLevel, pitch,
                                                           centerCoordinate.latitude,
diff --git a/platform/node/src/node_map.cpp b/platform/node/src/node_map.cpp
index 4bcd1d97bc..da25d5d5e5 100644
--- a/platform/node/src/node_map.cpp
+++ b/platform/node/src/node_map.cpp
@@ -424,7 +424,7 @@ void NodeMap::startRender(NodeMap::RenderOptions options) {
     mbgl::CameraOptions camera;
     camera.center = mbgl::LatLng { options.latitude, options.longitude };
     camera.zoom = options.zoom;
-    camera.angle = -options.bearing * mbgl::util::DEG2RAD;
+    camera.bearing = -options.bearing * mbgl::util::DEG2RAD;
     camera.pitch = options.pitch * mbgl::util::DEG2RAD;
 
     if (map->getAxonometric() != options.axonometric) {
diff --git a/platform/qt/include/qmapboxgl.hpp b/platform/qt/include/qmapboxgl.hpp
index a699b77cec..ce40d8f11e 100644
--- a/platform/qt/include/qmapboxgl.hpp
+++ b/platform/qt/include/qmapboxgl.hpp
@@ -90,7 +90,7 @@ struct Q_MAPBOXGL_EXPORT QMapboxGLCameraOptions {
     QVariant center;  // Coordinate
     QVariant anchor;  // QPointF
     QVariant zoom;    // double
-    QVariant angle;   // double
+    QVariant bearing; // double
     QVariant pitch;   // double
 };
 
diff --git a/platform/qt/src/qmapboxgl.cpp b/platform/qt/src/qmapboxgl.cpp
index cfc64488b7..8beb61a975 100644
--- a/platform/qt/src/qmapboxgl.cpp
+++ b/platform/qt/src/qmapboxgl.cpp
@@ -803,8 +803,8 @@ void QMapboxGL::jumpTo(const QMapboxGLCameraOptions& camera)
     if (camera.zoom.isValid()) {
         mbglCamera.zoom = camera.zoom.value<double>();
     }
-    if (camera.angle.isValid()) {
-        mbglCamera.angle = -camera.angle.value<double>() * mbgl::util::DEG2RAD;
+    if (camera.bearing.isValid()) {
+        mbglCamera.bearing = -camera.bearing.value<double>() * mbgl::util::DEG2RAD;
     }
     if (camera.pitch.isValid()) {
         mbglCamera.pitch = camera.pitch.value<double>() * mbgl::util::DEG2RAD;
diff --git a/src/mbgl/layout/symbol_projection.cpp b/src/mbgl/layout/symbol_projection.cpp
index ef669c6e19..c291c5f5c6 100644
--- a/src/mbgl/layout/symbol_projection.cpp
+++ b/src/mbgl/layout/symbol_projection.cpp
@@ -62,7 +62,7 @@ namespace mbgl {
         if (pitchWithMap) {
             matrix::scale(m, m, 1 / pixelsToTileUnits, 1 / pixelsToTileUnits, 1);
             if (!rotateWithMap) {
-                matrix::rotate_z(m, m, state.getAngle());
+                matrix::rotate_z(m, m, state.getBearing());
             }
         } else {
             matrix::scale(m, m, state.getSize().width / 2.0, -(state.getSize().height / 2.0), 1.0);
@@ -82,7 +82,7 @@ namespace mbgl {
             matrix::multiply(m, m, posMatrix);
             matrix::scale(m, m, pixelsToTileUnits, pixelsToTileUnits, 1);
             if (!rotateWithMap) {
-                matrix::rotate_z(m, m, -state.getAngle());
+                matrix::rotate_z(m, m, -state.getBearing());
             }
         } else {
             matrix::scale(m, m, 1, -1, 1);
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index 923421b54d..433a76e1ca 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -308,7 +308,7 @@ LatLng Map::getLatLng(const EdgeInsets& padding) const {
 void Map::resetPosition(const EdgeInsets& padding) {
     impl->cameraMutated = true;
     CameraOptions camera;
-    camera.angle = 0;
+    camera.bearing = 0;
     camera.pitch = 0;
     camera.center = LatLng(0, 0);
     camera.padding = padding;
@@ -423,8 +423,8 @@ CameraOptions Map::cameraForLatLngs(const std::vector<LatLng>& latLngs, const Ed
     Transform transform(impl->transform.getState());
     
     if (bearing) {
-        double angle = -*bearing * util::DEG2RAD; // Convert to radians
-        transform.setAngle(angle);
+        double bearingAsRadians = -*bearing * util::DEG2RAD; // Convert to radians
+        transform.setBearing(bearingAsRadians);
     }
     if (pitch) {
         double pitchAsRadian = *pitch * util::DEG2RAD; // Convert to radians
@@ -432,7 +432,7 @@ CameraOptions Map::cameraForLatLngs(const std::vector<LatLng>& latLngs, const Ed
     }
     
     CameraOptions options = mbgl::cameraForLatLngs(latLngs, transform, padding);
-    options.angle = transform.getAngle();
+    options.bearing = transform.getBearing();
     options.pitch = transform.getPitch();
     
     return options;
@@ -545,23 +545,23 @@ void Map::setBearing(double degrees, const AnimationOptions& animation) {
 
 void Map::setBearing(double degrees, optional<ScreenCoordinate> anchor, const AnimationOptions& animation) {
     impl->cameraMutated = true;
-    impl->transform.setAngle(-degrees * util::DEG2RAD, anchor, animation);
+    impl->transform.setBearing(-degrees * util::DEG2RAD, anchor, animation);
     impl->onUpdate();
 }
 
 void Map::setBearing(double degrees, const EdgeInsets& padding, const AnimationOptions& animation) {
     impl->cameraMutated = true;
-    impl->transform.setAngle(-degrees * util::DEG2RAD, padding, animation);
+    impl->transform.setBearing(-degrees * util::DEG2RAD, padding, animation);
     impl->onUpdate();
 }
 
 double Map::getBearing() const {
-    return -impl->transform.getAngle() * util::RAD2DEG;
+    return -impl->transform.getBearing() * util::RAD2DEG;
 }
 
 void Map::resetNorth(const AnimationOptions& animation) {
     impl->cameraMutated = true;
-    impl->transform.setAngle(0, animation);
+    impl->transform.setBearing(0, animation);
     impl->onUpdate();
 }
 
diff --git a/src/mbgl/map/transform.cpp b/src/mbgl/map/transform.cpp
index 99dc277882..213204e176 100644
--- a/src/mbgl/map/transform.cpp
+++ b/src/mbgl/map/transform.cpp
@@ -68,7 +68,7 @@ CameraOptions Transform::getCameraOptions(const EdgeInsets& padding) const {
     camera.center = getLatLng(padding);
     camera.padding = padding;
     camera.zoom = getZoom();
-    camera.angle = getAngle();
+    camera.bearing = getBearing();
     camera.pitch = getPitch();
     return camera;
 }
@@ -91,7 +91,7 @@ void Transform::easeTo(const CameraOptions& camera, const AnimationOptions& anim
     const LatLng unwrappedLatLng = camera.center.value_or(getLatLng());
     const LatLng latLng = unwrappedLatLng.wrapped();
     double zoom = camera.zoom.value_or(getZoom());
-    double angle = camera.angle.value_or(getAngle());
+    double bearing = camera.bearing.value_or(getBearing());
     double pitch = camera.pitch.value_or(getPitch());
 
     if (std::isnan(zoom)) {
@@ -122,15 +122,15 @@ void Transform::easeTo(const CameraOptions& camera, const AnimationOptions& anim
     pitch = util::clamp(pitch, state.min_pitch, state.max_pitch);
 
     // Minimize rotation by taking the shorter path around the circle.
-    angle = _normalizeAngle(angle, state.angle);
-    state.angle = _normalizeAngle(state.angle, angle);
+    bearing = _normalizeAngle(bearing, state.getBearing());
+    state.setBearing(_normalizeAngle(state.getBearing(), bearing));
 
     Duration duration = animation.duration ? *animation.duration : Duration::zero();
 
     const double startScale = state.scale;
-    const double startAngle = state.angle;
+    const double startBearing = state.getBearing();
     const double startPitch = state.pitch;
-    state.setTransitionInProgress(latLng != startLatLng || scale != startScale || angle != startAngle);
+    state.setTransitionInProgress(latLng != startLatLng || scale != startScale || bearing != startBearing);
 
     startTransition(camera, animation, [=](double t) {
         Point<double> framePoint = util::interpolate(startPoint, endPoint, t);
@@ -138,8 +138,8 @@ void Transform::easeTo(const CameraOptions& camera, const AnimationOptions& anim
         double frameScale = util::interpolate(startScale, scale, t);
         state.setLatLngZoom(frameLatLng, state.scaleZoom(frameScale));
 
-        if (angle != startAngle) {
-            state.angle = util::wrap(util::interpolate(startAngle, angle, t), -M_PI, M_PI);
+        if (bearing != startBearing) {
+            state.setBearing(util::wrap(util::interpolate(startBearing, bearing, t), -M_PI, M_PI));
         }
         if (pitch != startPitch) {
             state.pitch = util::interpolate(startPitch, pitch, t);
@@ -162,7 +162,7 @@ void Transform::easeTo(const CameraOptions& camera, const AnimationOptions& anim
 void Transform::flyTo(const CameraOptions &camera, const AnimationOptions &animation) {
     const LatLng latLng = camera.center.value_or(getLatLng()).wrapped();
     double zoom = camera.zoom.value_or(getZoom());
-    double angle = camera.angle.value_or(getAngle());
+    double bearing = camera.bearing.value_or(getBearing());
     double pitch = camera.pitch.value_or(getPitch());
 
     if (std::isnan(zoom) || state.size.isEmpty()) {
@@ -185,11 +185,11 @@ void Transform::flyTo(const CameraOptions &camera, const AnimationOptions &anima
     pitch = util::clamp(pitch, state.min_pitch, state.max_pitch);
 
     // Minimize rotation by taking the shorter path around the circle.
-    angle = _normalizeAngle(angle, state.angle);
-    state.angle = _normalizeAngle(state.angle, angle);
+    bearing = _normalizeAngle(bearing, state.getBearing());
+    state.setBearing(_normalizeAngle(state.getBearing(), bearing));
 
     const double startZoom = state.scaleZoom(state.scale);
-    const double startAngle = state.angle;
+    const double startBearing= state.getBearing();
     const double startPitch = state.pitch;
 
     /// w₀: Initial visible span, measured in pixels at the initial scale.
@@ -297,8 +297,8 @@ void Transform::flyTo(const CameraOptions &camera, const AnimationOptions &anima
         LatLng frameLatLng = Projection::unproject(framePoint, startScale);
         state.setLatLngZoom(frameLatLng, frameZoom);
 
-        if (angle != startAngle) {
-            state.angle = util::wrap(util::interpolate(startAngle, angle, k), -M_PI, M_PI);
+        if (bearing != startBearing) {
+            state.setBearing(util::wrap(util::interpolate(startBearing, bearing, k), -M_PI, M_PI));
         }
         if (pitch != startPitch) {
             state.pitch = util::interpolate(startPitch, pitch, k);
@@ -447,30 +447,30 @@ void Transform::rotateBy(const ScreenCoordinate& first, const ScreenCoordinate&
     }
 
     CameraOptions camera;
-    camera.angle = state.angle + util::angle_between(first - center, second - center);
+    camera.bearing = state.getBearing() + util::angle_between(first - center, second - center);
     easeTo(camera, animation);
 }
 
-void Transform::setAngle(double angle, const AnimationOptions& animation) {
-    setAngle(angle, optional<ScreenCoordinate> {}, animation);
+void Transform::setBearing(double bearing, const AnimationOptions& animation) {
+    setBearing(bearing, optional<ScreenCoordinate> {}, animation);
 }
 
-void Transform::setAngle(double angle, optional<ScreenCoordinate> anchor, const AnimationOptions& animation) {
-    if (std::isnan(angle)) return;
+void Transform::setBearing(double bearing, optional<ScreenCoordinate> anchor, const AnimationOptions& animation) {
+    if (std::isnan(bearing)) return;
     CameraOptions camera;
-    camera.angle = angle;
+    camera.bearing = bearing;
     camera.anchor = anchor;
     easeTo(camera, animation);
 }
 
-void Transform::setAngle(double angle, const EdgeInsets& padding, const AnimationOptions& animation) {
+void Transform::setBearing(double bearing, const EdgeInsets& padding, const AnimationOptions& animation) {
     optional<ScreenCoordinate> anchor;
     if (!padding.isFlush()) anchor = getScreenCoordinate(padding);
-    setAngle(angle, anchor, animation);
+    setBearing(bearing, anchor, animation);
 }
 
-double Transform::getAngle() const {
-    return state.angle;
+double Transform::getBearing() const {
+    return state.getBearing();
 }
 
 #pragma mark - Pitch
diff --git a/src/mbgl/map/transform.hpp b/src/mbgl/map/transform.hpp
index 145fc541d0..8155b628e2 100644
--- a/src/mbgl/map/transform.hpp
+++ b/src/mbgl/map/transform.hpp
@@ -82,24 +82,24 @@ public:
     // Angle
 
     void rotateBy(const ScreenCoordinate& first, const ScreenCoordinate& second, const AnimationOptions& = {});
-    /** Sets the angle of rotation.
-        @param angle The new angle of rotation, measured in radians
+    /** Sets the bearing angle.
+        @param angle The new bearing angle, measured in radians
             counterclockwise from true north. */
-    void setAngle(double angle, const AnimationOptions& = {});
-    /** Sets the angle of rotation, keeping the given point fixed within the view.
-        @param angle The new angle of rotation, measured in radians
+    void setBearing(double angle, const AnimationOptions& = {});
+    /** Sets the bearing angle, keeping the given point fixed within the view.
+        @param angle The new bearing angle, measured in radians
             counterclockwise from true north.
         @param anchor A point relative to the top-left corner of the view. */
-    void setAngle(double angle, optional<ScreenCoordinate> anchor, const AnimationOptions& = {});
-    /** Sets the angle of rotation, keeping the center point fixed within the inset view.
-        @param angle The new angle of rotation, measured in radians
+    void setBearing(double bearing, optional<ScreenCoordinate> anchor, const AnimationOptions& = {});
+    /** Sets the bearing angle, keeping the center point fixed within the inset view.
+        @param angle The new bearing angle, measured in radians
             counterclockwise from true north.
         @param padding The viewport padding that affects the fixed center point. */
-    void setAngle(double angle, const EdgeInsets& padding, const AnimationOptions& = {});
-    /** Returns the angle of rotation.
-        @return The angle of rotation, measured in radians counterclockwise from
+    void setBearing(double bearing, const EdgeInsets& padding, const AnimationOptions& = {});
+    /** Returns the bearing angle.
+        @return The bearing angle, measured in radians counterclockwise from
             true north. */
-    double getAngle() const;
+    double getBearing() const;
 
     // Pitch
     /** Sets the pitch angle.
diff --git a/src/mbgl/map/transform_state.cpp b/src/mbgl/map/transform_state.cpp
index c8e4207b82..af5e5aea57 100644
--- a/src/mbgl/map/transform_state.cpp
+++ b/src/mbgl/map/transform_state.cpp
@@ -61,7 +61,7 @@ void TransformState::getProjMatrix(mat4& projMatrix, uint16_t nearZ, bool aligne
         default: matrix::rotate_x(projMatrix, projMatrix, getPitch()); break;
     }
 
-    matrix::rotate_z(projMatrix, projMatrix, getAngle() + getNorthOrientationAngle());
+    matrix::rotate_z(projMatrix, projMatrix, getBearing() + getNorthOrientationAngle());
 
     const double dx = pixel_x() - size.width / 2.0f, dy = pixel_y() - size.height / 2.0f;
     matrix::translate(projMatrix, projMatrix, dx, dy, 0);
@@ -86,10 +86,10 @@ void TransformState::getProjMatrix(mat4& projMatrix, uint16_t nearZ, bool aligne
     // it is always <= 0.5 pixels.
     if (aligned) {
         const float xShift = float(size.width % 2) / 2, yShift = float(size.height % 2) / 2;
-        const double angleCos = std::cos(angle), angleSin = std::sin(angle);
+        const double bearingCos = std::cos(bearing), bearingSin = std::sin(bearing);
         double devNull;
-        const float dxa = -std::modf(dx, &devNull) + angleCos * xShift + angleSin * yShift;
-        const float dya = -std::modf(dy, &devNull) + angleCos * yShift + angleSin * xShift;
+        const float dxa = -std::modf(dx, &devNull) + bearingCos * xShift + bearingSin * yShift;
+        const float dya = -std::modf(dy, &devNull) + bearingCos * yShift + bearingSin * xShift;
         matrix::translate(projMatrix, projMatrix, dxa > 0.5 ? dxa - 1 : dxa, dya > 0.5 ? dya - 1 : dya, 0);
     }
 }
@@ -220,8 +220,12 @@ double TransformState::getMaxPitch() const {
 
 #pragma mark - Rotation
 
-float TransformState::getAngle() const {
-    return angle;
+float TransformState::getBearing() const {
+    return bearing;
+}
+
+void TransformState::setBearing(double bearing_) {
+    bearing = bearing_;
 }
 
 float TransformState::getFieldOfView() const {
diff --git a/src/mbgl/map/transform_state.hpp b/src/mbgl/map/transform_state.hpp
index bba5e425b2..1019f47c30 100644
--- a/src/mbgl/map/transform_state.hpp
+++ b/src/mbgl/map/transform_state.hpp
@@ -62,7 +62,9 @@ public:
     double getMaxPitch() const;
 
     // Rotation
-    float getAngle() const;
+    float getBearing() const;
+    void setBearing(double bearing);
+
     float getFieldOfView() const;
     float getCameraToCenterDistance() const;
     float getPitch() const;
@@ -126,7 +128,7 @@ private:
 
     // map position
     double x = 0, y = 0;
-    double angle = 0;
+    double bearing = 0;
     double scale = 1;
     // This fov value is somewhat arbitrary. The altitude of the camera used
     // to be defined as 1.5 screen heights above the ground, which was an
diff --git a/src/mbgl/programs/fill_extrusion_program.cpp b/src/mbgl/programs/fill_extrusion_program.cpp
index aaf192a843..c1f6a1415b 100644
--- a/src/mbgl/programs/fill_extrusion_program.cpp
+++ b/src/mbgl/programs/fill_extrusion_program.cpp
@@ -21,7 +21,7 @@ std::array<float, 3> lightPosition(const EvaluatedLight& light, const TransformS
     mat3 lightMat;
     matrix::identity(lightMat);
     if (light.get<LightAnchor>() == LightAnchorType::Viewport) {
-        matrix::rotate(lightMat, lightMat, -state.getAngle());
+        matrix::rotate(lightMat, lightMat, -state.getBearing());
     }
     matrix::transformMat3f(lightPos, lightPos, lightMat);
     return lightPos;
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index b433a9d3fa..e1a4bee6cd 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -138,7 +138,7 @@ bool RenderCircleLayer::queryIntersectsFeature(
             queryGeometry,
             evaluated.get<style::CircleTranslate>(),
             evaluated.get<style::CircleTranslateAnchor>(),
-            transformState.getAngle(),
+            transformState.getBearing(),
             pixelsToTileUnits).value_or(queryGeometry);
 
     // Evaluate functions
diff --git a/src/mbgl/renderer/layers/render_custom_layer.cpp b/src/mbgl/renderer/layers/render_custom_layer.cpp
index be9f64d9eb..b77849911a 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.cpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.cpp
@@ -70,7 +70,7 @@ void RenderCustomLayer::render(PaintParameters& paintParameters, RenderSource*)
     parameters.latitude = state.getLatLng().latitude();
     parameters.longitude = state.getLatLng().longitude();
     parameters.zoom = state.getZoom();
-    parameters.bearing = -state.getAngle() * util::RAD2DEG;
+    parameters.bearing = -state.getBearing() * util::RAD2DEG;
     parameters.pitch = state.getPitch();
     parameters.fieldOfView = state.getFieldOfView();
     mat4 projMatrix;
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index d5282c9b0d..34b9542bba 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -206,7 +206,7 @@ bool RenderFillExtrusionLayer::queryIntersectsFeature(
             queryGeometry,
             evaluated.get<style::FillExtrusionTranslate>(),
             evaluated.get<style::FillExtrusionTranslateAnchor>(),
-            transformState.getAngle(),
+            transformState.getBearing(),
             pixelsToTileUnits);
 
     return util::polygonIntersectsMultiPolygon(translatedQueryGeometry.value_or(queryGeometry), feature.getGeometries());
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index c59ca6f906..f51a583614 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -226,7 +226,7 @@ bool RenderFillLayer::queryIntersectsFeature(
             queryGeometry,
             evaluated.get<style::FillTranslate>(),
             evaluated.get<style::FillTranslateAnchor>(),
-            transformState.getAngle(),
+            transformState.getBearing(),
             pixelsToTileUnits);
 
     return util::polygonIntersectsMultiPolygon(translatedQueryGeometry.value_or(queryGeometry), feature.getGeometries());
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
index 411305edf4..f85f171994 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -37,7 +37,7 @@ const std::array<float, 2> RenderHillshadeLayer::getLatRange(const UnwrappedTile
 
 const std::array<float, 2> RenderHillshadeLayer::getLight(const PaintParameters& parameters){
     float azimuthal = evaluated.get<HillshadeIlluminationDirection>() * util::DEG2RAD;
-    if (evaluated.get<HillshadeIlluminationAnchor>() == HillshadeIlluminationAnchorType::Viewport) azimuthal = azimuthal - parameters.state.getAngle();
+    if (evaluated.get<HillshadeIlluminationAnchor>() == HillshadeIlluminationAnchorType::Viewport) azimuthal = azimuthal - parameters.state.getBearing();
     return {{evaluated.get<HillshadeExaggeration>(), azimuthal}};
 }
 
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index 361ad0c76b..b739934efb 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -186,7 +186,7 @@ bool RenderLineLayer::queryIntersectsFeature(
             queryGeometry,
             evaluated.get<style::LineTranslate>(),
             evaluated.get<style::LineTranslateAnchor>(),
-            transformState.getAngle(),
+            transformState.getBearing(),
             pixelsToTileUnits);
 
     // Evaluate function
diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp
index 64790938ef..47ce7527e1 100644
--- a/src/mbgl/renderer/render_tile.cpp
+++ b/src/mbgl/renderer/render_tile.cpp
@@ -23,8 +23,8 @@ mat4 RenderTile::translateVtxMatrix(const mat4& tileMatrix,
     mat4 vtxMatrix;
 
     const float angle = inViewportPixelUnits ?
-        (anchor == TranslateAnchorType::Map ? state.getAngle() : 0) :
-        (anchor == TranslateAnchorType::Viewport ? -state.getAngle() : 0);
+        (anchor == TranslateAnchorType::Map ? state.getBearing() : 0) :
+        (anchor == TranslateAnchorType::Viewport ? -state.getBearing() : 0);
 
     Point<float> translate = util::rotate(Point<float>{ translation[0], translation[1] }, angle);
 
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index fea27403c9..55a692f880 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -337,8 +337,8 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
                 Point<float> pa(a.id.canonical.x, a.id.canonical.y);
                 Point<float> pb(b.id.canonical.x, b.id.canonical.y);
 
-                auto par = util::rotate(pa, parameters.state.getAngle());
-                auto pbr = util::rotate(pb, parameters.state.getAngle());
+                auto par = util::rotate(pa, parameters.state.getBearing());
+                auto pbr = util::rotate(pb, parameters.state.getBearing());
 
                 return std::tie(b.id.canonical.z, par.y, par.x) < std::tie(a.id.canonical.z, pbr.y, pbr.x);
             });
diff --git a/src/mbgl/style/style_impl.cpp b/src/mbgl/style/style_impl.cpp
index 0c7f924917..838fb4bff6 100644
--- a/src/mbgl/style/style_impl.cpp
+++ b/src/mbgl/style/style_impl.cpp
@@ -106,7 +106,7 @@ void Style::Impl::parse(const std::string& json_) {
     name = parser.name;
     defaultCamera.center = parser.latLng;
     defaultCamera.zoom = parser.zoom;
-    defaultCamera.angle = parser.bearing;
+    defaultCamera.bearing = parser.bearing;
     defaultCamera.pitch = parser.pitch;
 
     setLight(std::make_unique<Light>(parser.light));
diff --git a/src/mbgl/text/placement.cpp b/src/mbgl/text/placement.cpp
index fd0710d959..827df83423 100644
--- a/src/mbgl/text/placement.cpp
+++ b/src/mbgl/text/placement.cpp
@@ -334,7 +334,7 @@ void Placement::updateBucketOpacities(SymbolBucket& bucket, std::set<uint32_t>&
     }
 
     bucket.updateOpacity();
-    bucket.sortFeatures(state.getAngle());
+    bucket.sortFeatures(state.getBearing());
     auto retainedData = retainedQueryData.find(bucket.bucketInstanceId);
     if (retainedData != retainedQueryData.end()) {
         retainedData->second.featureSortOrder = bucket.featureSortOrder;
diff --git a/test/map/map.test.cpp b/test/map/map.test.cpp
index 4f7bd2df7b..26dd71a83c 100644
--- a/test/map/map.test.cpp
+++ b/test/map/map.test.cpp
@@ -84,7 +84,7 @@ TEST(Map, LatLngBoundsToCameraWithAngle) {
     CameraOptions virtualCamera = test.map.cameraForLatLngBounds(bounds, {}, 35);
     ASSERT_TRUE(bounds.contains(*virtualCamera.center));
     EXPECT_NEAR(*virtualCamera.zoom, 1.21385, 1e-5);
-    EXPECT_NEAR(virtualCamera.angle.value_or(0), -35 * util::DEG2RAD, 1e-5);
+    EXPECT_NEAR(virtualCamera.bearing.value_or(0), -35 * util::DEG2RAD, 1e-5);
 }
 
 TEST(Map, LatLngBoundsToCameraWithAngleAndPitch) {
@@ -98,7 +98,7 @@ TEST(Map, LatLngBoundsToCameraWithAngleAndPitch) {
     ASSERT_TRUE(bounds.contains(*virtualCamera.center));
     EXPECT_NEAR(*virtualCamera.zoom, 13.66272, 1e-5);
     ASSERT_DOUBLE_EQ(*virtualCamera.pitch, 20 * util::DEG2RAD);
-    EXPECT_NEAR(virtualCamera.angle.value_or(0), -35 * util::DEG2RAD, 1e-5);
+    EXPECT_NEAR(virtualCamera.bearing.value_or(0), -35 * util::DEG2RAD, 1e-5);
 }
 
 TEST(Map, LatLngsToCamera) {
@@ -107,7 +107,7 @@ TEST(Map, LatLngsToCamera) {
     std::vector<LatLng> latLngs{{ 40.712730, 74.005953 }, {15.68169,73.499857}, {30.82678, 83.4082}};
 
     CameraOptions virtualCamera = test.map.cameraForLatLngs(latLngs, {}, 23);
-    EXPECT_NEAR(virtualCamera.angle.value_or(0), -23 * util::DEG2RAD, 1e-5);
+    EXPECT_NEAR(virtualCamera.bearing.value_or(0), -23 * util::DEG2RAD, 1e-5);
     EXPECT_NEAR(virtualCamera.zoom.value_or(0), 2.75434, 1e-5);
     EXPECT_NEAR(virtualCamera.center->latitude(), 28.49288, 1e-5);
     EXPECT_NEAR(virtualCamera.center->longitude(), 74.97437, 1e-5);
@@ -119,7 +119,7 @@ TEST(Map, LatLngsToCameraWithAngleAndPitch) {
     std::vector<LatLng> latLngs{{ 40.712730, 74.005953 }, {15.68169,73.499857}, {30.82678, 83.4082}};
     
     CameraOptions virtualCamera = test.map.cameraForLatLngs(latLngs, {}, 23, 20);
-    EXPECT_NEAR(virtualCamera.angle.value_or(0), -23 * util::DEG2RAD, 1e-5);
+    EXPECT_NEAR(virtualCamera.bearing.value_or(0), -23 * util::DEG2RAD, 1e-5);
     EXPECT_NEAR(virtualCamera.zoom.value_or(0), 3.04378, 1e-5);
     EXPECT_NEAR(virtualCamera.center->latitude(), 28.53718, 1e-5);
     EXPECT_NEAR(virtualCamera.center->longitude(), 74.31746, 1e-5);
diff --git a/test/map/transform.test.cpp b/test/map/transform.test.cpp
index 3e4175116f..e3bae51850 100644
--- a/test/map/transform.test.cpp
+++ b/test/map/transform.test.cpp
@@ -60,20 +60,20 @@ TEST(Transform, InvalidBearing) {
     ASSERT_DOUBLE_EQ(0, transform.getZoom());
 
     transform.setZoom(1);
-    transform.setAngle(2);
+    transform.setBearing(-2.0 * util::DEG2RAD);
 
     ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude());
     ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude());
     ASSERT_DOUBLE_EQ(1, transform.getZoom());
-    ASSERT_DOUBLE_EQ(2, transform.getAngle());
+    ASSERT_DOUBLE_EQ(-2.0 * util::DEG2RAD, transform.getBearing());
 
     const double invalid = std::nan("");
-    transform.setAngle(invalid);
+    transform.setBearing(invalid);
 
     ASSERT_DOUBLE_EQ(0, transform.getLatLng().latitude());
     ASSERT_DOUBLE_EQ(0, transform.getLatLng().longitude());
     ASSERT_DOUBLE_EQ(1, transform.getZoom());
-    ASSERT_DOUBLE_EQ(2, transform.getAngle());
+    ASSERT_DOUBLE_EQ(-2.0 * util::DEG2RAD, transform.getBearing());
 }
 
 TEST(Transform, IntegerZoom) {
@@ -204,7 +204,7 @@ TEST(Transform, Anchor) {
     ASSERT_DOUBLE_EQ(latLng.latitude(), transform.getLatLng().latitude());
     ASSERT_DOUBLE_EQ(latLng.longitude(), transform.getLatLng().longitude());
     ASSERT_DOUBLE_EQ(10, transform.getZoom());
-    ASSERT_DOUBLE_EQ(0, transform.getAngle());
+    ASSERT_DOUBLE_EQ(0, transform.getBearing());
 
     const optional<ScreenCoordinate> invalidAnchorPoint {};
     const ScreenCoordinate anchorPoint = { 150, 150 };
@@ -262,18 +262,18 @@ TEST(Transform, Anchor) {
     ASSERT_NE(latLng.longitude(), transform.getLatLng().longitude());
 
     transform.setLatLngZoom(latLng, 10);
-    transform.setAngle(M_PI_4);
-    ASSERT_NEAR(M_PI_4, transform.getAngle(), 0.000001);
+    transform.setBearing(M_PI_4);
+    ASSERT_NEAR(M_PI_4, transform.getBearing(), 0.000001);
     ASSERT_DOUBLE_EQ(latLng.latitude(), transform.getLatLng().latitude());
     ASSERT_DOUBLE_EQ(latLng.longitude(), transform.getLatLng().longitude());
 
-    transform.setAngle(0, invalidAnchorPoint);
-    ASSERT_DOUBLE_EQ(0, transform.getAngle());
+    transform.setBearing(0, invalidAnchorPoint);
+    ASSERT_DOUBLE_EQ(0, transform.getBearing());
     ASSERT_DOUBLE_EQ(latLng.latitude(), transform.getLatLng().latitude());
     ASSERT_DOUBLE_EQ(latLng.longitude(), transform.getLatLng().longitude());
 
-    transform.setAngle(45 * util::DEG2RAD, anchorPoint);
-    ASSERT_NEAR(45 / util::RAD2DEG, transform.getAngle(), 0.000001);
+    transform.setBearing(-45.0 * util::DEG2RAD, anchorPoint);
+    ASSERT_NEAR(-45.0 / util::RAD2DEG, transform.getBearing(), 0.000001);
     ASSERT_NEAR(anchorLatLng.latitude(), transform.getLatLng().latitude(), 1);
     ASSERT_NEAR(anchorLatLng.longitude(), transform.getLatLng().longitude(), 1);
 
diff --git a/test/style/style.test.cpp b/test/style/style.test.cpp
index f2055c88f8..f2086ebb17 100644
--- a/test/style/style.test.cpp
+++ b/test/style/style.test.cpp
@@ -33,7 +33,7 @@ TEST(Style, Properties) {
     style.loadJSON(R"STYLE({"bearing": 24})STYLE");
     ASSERT_EQ("", style.getName());
     ASSERT_EQ(LatLng {}, *style.getDefaultCamera().center);
-    ASSERT_EQ(24, *style.getDefaultCamera().angle);
+    ASSERT_EQ(24, *style.getDefaultCamera().bearing);
 
     style.loadJSON(R"STYLE({"zoom": 13.3})STYLE");
     ASSERT_EQ("", style.getName());
@@ -47,7 +47,7 @@ TEST(Style, Properties) {
     ASSERT_EQ("", style.getName());
     ASSERT_EQ(LatLng {}, *style.getDefaultCamera().center);
     ASSERT_EQ(0, *style.getDefaultCamera().zoom);
-    ASSERT_EQ(0, *style.getDefaultCamera().angle);
+    ASSERT_EQ(0, *style.getDefaultCamera().bearing);
     ASSERT_EQ(0, *style.getDefaultCamera().pitch);
 }
 
diff --git a/test/util/tile_cover.test.cpp b/test/util/tile_cover.test.cpp
index 72d77450a4..f196f05ca2 100644
--- a/test/util/tile_cover.test.cpp
+++ b/test/util/tile_cover.test.cpp
@@ -36,11 +36,11 @@ TEST(TileCover, Pitch) {
     // slightly offset center so that tile order is better defined
     transform.setLatLng({ 0.1, -0.1 });
     transform.setZoom(2);
-    transform.setAngle(5.0);
-    transform.setPitch(40.0 * M_PI / 180.0);
+    transform.setBearing(-5.0 * util::DEG2RAD);
+    transform.setPitch(40.0 * util::DEG2RAD);
 
     EXPECT_EQ((std::vector<UnwrappedTileID>{
-        { 2, 1, 2 }, { 2, 1, 1 }, { 2, 2, 2 }, { 2, 2, 1 }, { 2, 3, 2 }
+        { 2, 1, 2 }, { 2, 1, 1 }, { 2, 2, 2 }, { 2, 2, 1 }
     }),
               util::tileCover(transform.getState(), 2));
 }