[core] Use geometry.hpp's point

41 files changed, 263 insertions, 366 deletions

diff --git a/.mason b/.mason
-Subproject 2d75da369d1ebc7c5dd4139cde8941074366524
+Subproject 79234f915fa159f027c6c268ff2e5ececdb9c51
diff --git a/include/mbgl/util/geo.hpp b/include/mbgl/util/geo.hpp
index cb9cb71fc5..6aecea33fb 100644
--- a/include/mbgl/util/geo.hpp
+++ b/include/mbgl/util/geo.hpp
@@ -2,16 +2,18 @@
 #define MBGL_UTIL_GEO
 
 #include <mbgl/math/wrap.hpp>
-#include <mbgl/util/vec.hpp>
 #include <mbgl/util/constants.hpp>
 
+#include <mapbox/geometry/point.hpp>
+#include <mapbox/geometry/point_arithmetic.hpp>
+
 #include <cmath>
 
 namespace mbgl {
 
 class TileID;
 
-using ScreenCoordinate = vec2<double>;
+using ScreenCoordinate = mapbox::geometry::point<double>;
 
 class LatLng {
 public:
diff --git a/platform/android/scripts/configure.sh b/platform/android/scripts/configure.sh
index 30913aaf92..9470563517 100644
--- a/platform/android/scripts/configure.sh
+++ b/platform/android/scripts/configure.sh
@@ -8,7 +8,7 @@ SQLITE_VERSION=3.9.1
 ZLIB_VERSION=system
 NUNICODE_VERSION=1.6
 LIBZIP_VERSION=0.11.2
-GEOMETRY_VERSION=0.1.0
+GEOMETRY_VERSION=0.2.0
 GEOJSONVT_VERSION=4.1.2
 VARIANT_VERSION=1.1.0
 RAPIDJSON_VERSION=1.0.2
diff --git a/platform/ios/ios.xcodeproj/project.pbxproj b/platform/ios/ios.xcodeproj/project.pbxproj
index f97263f2cd..8265f1c2d8 100644
--- a/platform/ios/ios.xcodeproj/project.pbxproj
+++ b/platform/ios/ios.xcodeproj/project.pbxproj
@@ -1549,6 +1549,10 @@
 				INFOPLIST_FILE = test/Info.plist;
 				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
+				OTHER_CPLUSPLUSFLAGS = (
+					"$(OTHER_CFLAGS)",
+					"$(geometry_cflags)",
+				);
 				PRODUCT_BUNDLE_IDENTIFIER = com.mapbox.test;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 			};
@@ -1562,6 +1566,10 @@
 				INFOPLIST_FILE = test/Info.plist;
 				IPHONEOS_DEPLOYMENT_TARGET = 8.0;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks @loader_path/Frameworks";
+				OTHER_CPLUSPLUSFLAGS = (
+					"$(OTHER_CFLAGS)",
+					"$(geometry_cflags)",
+				);
 				PRODUCT_BUNDLE_IDENTIFIER = com.mapbox.test;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 			};
diff --git a/platform/ios/scripts/configure.sh b/platform/ios/scripts/configure.sh
index c92e58c7d2..796564095d 100644
--- a/platform/ios/scripts/configure.sh
+++ b/platform/ios/scripts/configure.sh
@@ -4,7 +4,7 @@ PROTOZERO_VERSION=1.3.0
 BOOST_VERSION=1.60.0
 SQLITE_VERSION=system
 ZLIB_VERSION=system
-GEOMETRY_VERSION=0.1.0
+GEOMETRY_VERSION=0.2.0
 GEOJSONVT_VERSION=4.1.2
 VARIANT_VERSION=1.1.0
 RAPIDJSON_VERSION=1.0.2
diff --git a/platform/linux/scripts/configure.sh b/platform/linux/scripts/configure.sh
index 5f7edf7f8a..a55545434e 100644
--- a/platform/linux/scripts/configure.sh
+++ b/platform/linux/scripts/configure.sh
@@ -11,7 +11,7 @@ SQLITE_VERSION=3.9.1
 LIBUV_VERSION=1.7.5
 ZLIB_VERSION=system
 NUNICODE_VERSION=1.6
-GEOMETRY_VERSION=0.1.0
+GEOMETRY_VERSION=0.2.0
 GEOJSONVT_VERSION=4.1.2
 VARIANT_VERSION=1.1.0
 RAPIDJSON_VERSION=1.0.2
diff --git a/platform/osx/osx.xcodeproj/project.pbxproj b/platform/osx/osx.xcodeproj/project.pbxproj
index 61c028bf8f..0f462d498d 100644
--- a/platform/osx/osx.xcodeproj/project.pbxproj
+++ b/platform/osx/osx.xcodeproj/project.pbxproj
@@ -1005,6 +1005,10 @@
 				HEADER_SEARCH_PATHS = ../../include;
 				INFOPLIST_FILE = test/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks";
+				OTHER_CPLUSPLUSFLAGS = (
+					"$(OTHER_CFLAGS)",
+					"$(geometry_cflags)",
+				);
 				PRODUCT_BUNDLE_IDENTIFIER = com.mapbox.test;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 			};
@@ -1018,6 +1022,10 @@
 				HEADER_SEARCH_PATHS = ../../include;
 				INFOPLIST_FILE = test/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/../Frameworks @loader_path/../Frameworks";
+				OTHER_CPLUSPLUSFLAGS = (
+					"$(OTHER_CFLAGS)",
+					"$(geometry_cflags)",
+				);
 				PRODUCT_BUNDLE_IDENTIFIER = com.mapbox.test;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 			};
diff --git a/platform/osx/scripts/configure.sh b/platform/osx/scripts/configure.sh
index 44e0c618e9..8a5c457b73 100644
--- a/platform/osx/scripts/configure.sh
+++ b/platform/osx/scripts/configure.sh
@@ -7,7 +7,7 @@ GLFW_VERSION=3.1.2
 SQLITE_VERSION=3.9.1
 ZLIB_VERSION=system
 NUNICODE_VERSION=1.6
-GEOMETRY_VERSION=0.1.0
+GEOMETRY_VERSION=0.2.0
 GEOJSONVT_VERSION=4.1.2
 VARIANT_VERSION=1.1.0
 RAPIDJSON_VERSION=1.0.2
diff --git a/platform/qt/scripts/configure.sh b/platform/qt/scripts/configure.sh
index b1ff652f38..d956100d4e 100644
--- a/platform/qt/scripts/configure.sh
+++ b/platform/qt/scripts/configure.sh
@@ -2,7 +2,7 @@
 
 PROTOZERO_VERSION=1.3.0
 BOOST_VERSION=1.60.0
-GEOMETRY_VERSION=0.1.0
+GEOMETRY_VERSION=0.2.0
 GEOJSONVT_VERSION=4.1.2
 GTEST_VERSION=1.7.0
 LIBJPEG_TURBO_VERSION=1.4.2
diff --git a/platform/qt/src/qmapboxgl.cpp b/platform/qt/src/qmapboxgl.cpp
index 990997bb60..633223488e 100644
--- a/platform/qt/src/qmapboxgl.cpp
+++ b/platform/qt/src/qmapboxgl.cpp
@@ -10,7 +10,6 @@
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/geo.hpp>
 #include <mbgl/util/traits.hpp>
-#include <mbgl/util/vec.hpp>
 
 #include <QCoreApplication>
 #include <QImage>
@@ -497,7 +496,7 @@ void QMapboxGL::addAnnotationIcon(const QString &name, const QImage &sprite)
 
 QPointF QMapboxGL::pixelForCoordinate(const Coordinate &coordinate_) const
 {
-    const mbgl::vec2<double> pixel =
+    const mbgl::ScreenCoordinate pixel =
         d_ptr->mapObj->pixelForLatLng(mbgl::LatLng { coordinate_.first, coordinate_.second });
 
     return QPointF(pixel.x, pixel.y);
diff --git a/src/mbgl/annotation/point_annotation_impl.cpp b/src/mbgl/annotation/point_annotation_impl.cpp
index d3f0bce0a2..888a806b5b 100644
--- a/src/mbgl/annotation/point_annotation_impl.cpp
+++ b/src/mbgl/annotation/point_annotation_impl.cpp
@@ -21,15 +21,15 @@ void PointAnnotationImpl::updateLayer(const TileID& tileID, AnnotationTileLayer&
     const double x = point.position.longitude / util::DEGREES_MAX + 0.5;
     const double y = 0.5 - 0.25 * std::log((1.0 + sine) / (1.0 - sine)) / M_PI;
 
-    vec2<double> projected(x, y);
+    Point<double> projected(x, y);
     projected *= std::pow(2, tileID.z);
     projected.x = std::fmod(projected.x, 1);
     projected.y = std::fmod(projected.y, 1);
-    projected *= GeometryTileFeature::defaultExtent;
+    projected *= double(GeometryTileFeature::defaultExtent);
 
     layer.features.emplace_back(
         std::make_shared<const AnnotationTileFeature>(FeatureType::Point,
-                                                      GeometryCollection {{ {{ GeometryCoordinate { projected } }} }},
+                                                      GeometryCollection {{ {{ convertPoint<int16_t>(projected) }} }},
                                                       featureProperties));
 }
 
diff --git a/src/mbgl/geometry/anchor.hpp b/src/mbgl/geometry/anchor.hpp
index 49979cc15a..0dd252216a 100644
--- a/src/mbgl/geometry/anchor.hpp
+++ b/src/mbgl/geometry/anchor.hpp
@@ -1,21 +1,22 @@
 #ifndef MBGL_GEOMETRY_ANCHOR
 #define MBGL_GEOMETRY_ANCHOR
 
+#include <mbgl/util/geometry.hpp>
+
 #include <vector>
 
 namespace mbgl {
 
 struct Anchor {
-    float x = 0.0f;
-    float y = 0.0f;
+    Point<float> point;
     float angle = 0.0f;
     float scale = 0.0f;
     int segment = -1;
 
     explicit Anchor(float x_, float y_, float angle_, float scale_)
-        : x(x_), y(y_), angle(angle_), scale(scale_) {}
+        : point(x_, y_), angle(angle_), scale(scale_) {}
     explicit Anchor(float x_, float y_, float angle_, float scale_, int segment_)
-        : x(x_), y(y_), angle(angle_), scale(scale_), segment(segment_) {}
+        : point(x_, y_), angle(angle_), scale(scale_), segment(segment_) {}
 
 };
 
diff --git a/src/mbgl/layer/line_layer.cpp b/src/mbgl/layer/line_layer.cpp
index e99a0d69f1..3671b207a0 100644
--- a/src/mbgl/layer/line_layer.cpp
+++ b/src/mbgl/layer/line_layer.cpp
@@ -102,30 +102,30 @@ float LineLayer::getLineWidth() const {
     }
 }
 
-optional<GeometryCollection> offsetLine(const GeometryCollection& rings, const float offset) {
+optional<GeometryCollection> offsetLine(const GeometryCollection& rings, const double offset) {
     if (offset == 0) return {};
 
     GeometryCollection newRings;
-    vec2<double> zero(0, 0);
-    for (auto& ring : rings) {
+    Point<double> zero(0, 0);
+    for (const auto& ring : rings) {
         newRings.emplace_back();
         auto& newRing = newRings.back();
 
         for (auto i = ring.begin(); i != ring.end(); i++) {
             auto& p = *i;
 
-            auto aToB = i == ring.begin() ?
+            Point<double> aToB = i == ring.begin() ?
                 zero :
-                util::perp(util::unit(vec2<double>(p - *(i - 1))));
-            auto bToC = i + 1 == ring.end() ?
+                util::perp(util::unit(convertPoint<double>(p - *(i - 1))));
+            Point<double> bToC = i + 1 == ring.end() ?
                 zero :
-                util::perp(util::unit(vec2<double>(*(i + 1) - p)));
-            auto extrude = util::unit(aToB + bToC);
+                util::perp(util::unit(convertPoint<double>(*(i + 1) - p)));
+            Point<double> extrude = util::unit(aToB + bToC);
 
             const double cosHalfAngle = extrude.x * bToC.x + extrude.y * bToC.y;
             extrude *= (1.0 / cosHalfAngle);
 
-            newRing.push_back((extrude * offset) + p);
+            newRing.push_back(convertPoint<int16_t>(extrude * offset) + p);
         }
     }
 
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index a1dd9b6a77..0747606fc6 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -525,7 +525,7 @@ CameraOptions Map::cameraForLatLngs(const std::vector<LatLng>& latLngs, optional
         };
         centerPixel = centerPixel + paddedNEPixel - paddedSWPixel;
     }
-    centerPixel /= 2;
+    centerPixel /= 2.0;
 
     // CameraOptions origin is at the top-left corner.
     centerPixel.y = viewportHeight - centerPixel.y;
diff --git a/src/mbgl/map/transform.cpp b/src/mbgl/map/transform.cpp
index 06cde18c6e..69a644c7d9 100644
--- a/src/mbgl/map/transform.cpp
+++ b/src/mbgl/map/transform.cpp
@@ -343,8 +343,6 @@ void Transform::flyTo(const CameraOptions &camera, const AnimationOptions &anima
 #pragma mark - Position
 
 void Transform::moveBy(const ScreenCoordinate& offset, const Duration& duration) {
-    if (!offset) return;
-
     ScreenCoordinate centerOffset = {
         offset.x,
         -offset.y,
@@ -477,10 +475,6 @@ void Transform::setMaxZoom(const double maxZoom) {
 #pragma mark - Angle
 
 void Transform::rotateBy(const ScreenCoordinate& first, const ScreenCoordinate& second, const Duration& duration) {
-    if (!first || !second) {
-        return;
-    }
-
     ScreenCoordinate center = getScreenCoordinate();
     const ScreenCoordinate offset = first - center;
     const double distance = std::sqrt(std::pow(2, offset.x) + std::pow(2, offset.y));
@@ -493,13 +487,9 @@ void Transform::rotateBy(const ScreenCoordinate& first, const ScreenCoordinate&
         center.x = first.x + std::cos(rotateAngle) * heightOffset;
         center.y = first.y + std::sin(rotateAngle) * heightOffset;
     }
-
-    const ScreenCoordinate newFirst = first - center;
-    const ScreenCoordinate newSecond = second - center;
-    const double ang = state.angle + util::angle_between(newFirst.x, newFirst.y, newSecond.x, newSecond.y);
     
     CameraOptions camera;
-    camera.angle = ang;
+    camera.angle = state.angle + util::angle_between(first - center, second - center);
     easeTo(camera, duration);
 }
 
@@ -581,7 +571,7 @@ void Transform::startTransition(const CameraOptions& camera,
     // Associate the anchor, if given, with a coordinate.
     optional<ScreenCoordinate> anchor = camera.anchor;
     LatLng anchorLatLng;
-    if (anchor && *anchor) {
+    if (anchor) {
         anchor->y = state.getHeight() - anchor->y;
         anchorLatLng = state.screenCoordinateToLatLng(*anchor);
     }
@@ -599,7 +589,7 @@ void Transform::startTransition(const CameraOptions& camera,
             result = frame(ease.solve(t, 0.001));
         }
         
-        if (anchor && *anchor) state.moveLatLng(anchorLatLng, *anchor);
+        if (anchor) state.moveLatLng(anchorLatLng, *anchor);
         
         // At t = 1.0, a DidChangeAnimated notification should be sent from finish().
         if (t < 1.0) {
@@ -657,8 +647,6 @@ void Transform::setGestureInProgress(bool inProgress) {
 #pragma mark Conversion and projection
 
 ScreenCoordinate Transform::latLngToScreenCoordinate(const LatLng& latLng) const {
-    if (!latLng) return ScreenCoordinate::null();
-
     // If the center and point longitudes are not in the same side of the
     // antimeridian, we unwrap the point longitude so it would be seen if
     // e.g. the next antimeridian side is visible.
@@ -670,8 +658,6 @@ ScreenCoordinate Transform::latLngToScreenCoordinate(const LatLng& latLng) const
 }
 
 LatLng Transform::screenCoordinateToLatLng(const ScreenCoordinate& point) const {
-    if (!point) return LatLng::null();
-
     ScreenCoordinate flippedPoint = point;
     flippedPoint.y = state.height - flippedPoint.y;
     return state.screenCoordinateToLatLng(flippedPoint).wrapped();
diff --git a/src/mbgl/map/transform_state.cpp b/src/mbgl/map/transform_state.cpp
index cac80ff0bc..4c96abcd13 100644
--- a/src/mbgl/map/transform_state.cpp
+++ b/src/mbgl/map/transform_state.cpp
@@ -223,10 +223,10 @@ double TransformState::worldSize() const {
 
 ScreenCoordinate TransformState::latLngToScreenCoordinate(const LatLng& latLng) const {
     mat4 mat = coordinatePointMatrix(getZoom());
-    vec4<double> p;
-    vec4<double> c = { lngX(latLng.longitude) / util::tileSize, latY(latLng.latitude) / util::tileSize, 0, 1 };
+    vec4 p;
+    vec4 c = {{ lngX(latLng.longitude) / util::tileSize, latY(latLng.latitude) / util::tileSize, 0, 1 }};
     matrix::transformMat4(p, c, mat);
-    return { p.x / p.w, height - p.y / p.w };
+    return { p[0] / p[3], height - p[1] / p[3] };
 }
 
 LatLng TransformState::screenCoordinateToLatLng(const ScreenCoordinate& point, LatLng::WrapMode wrapMode) const {
@@ -244,21 +244,21 @@ LatLng TransformState::screenCoordinateToLatLng(const ScreenCoordinate& point, L
     // unproject two points to get a line and then find the point on that
     // line with z=0
 
-    vec4<double> coord0;
-    vec4<double> coord1;
-    vec4<double> point0 = { point.x, flippedY, 0, 1 };
-    vec4<double> point1 = { point.x, flippedY, 1, 1 };
+    vec4 coord0;
+    vec4 coord1;
+    vec4 point0 = {{ point.x, flippedY, 0, 1 }};
+    vec4 point1 = {{ point.x, flippedY, 1, 1 }};
     matrix::transformMat4(coord0, point0, inverted);
     matrix::transformMat4(coord1, point1, inverted);
 
-    double w0 = coord0.w;
-    double w1 = coord1.w;
-    double x0 = coord0.x / w0;
-    double x1 = coord1.x / w1;
-    double y0 = coord0.y / w0;
-    double y1 = coord1.y / w1;
-    double z0 = coord0.z / w0;
-    double z1 = coord1.z / w1;
+    double w0 = coord0[3];
+    double w1 = coord1[3];
+    double x0 = coord0[0] / w0;
+    double x1 = coord1[0] / w1;
+    double y0 = coord0[1] / w0;
+    double y1 = coord1[1] / w1;
+    double z0 = coord0[2] / w0;
+    double z1 = coord1[2] / w1;
 
     double t = z0 == z1 ? 0 : (targetZ - z0) / (z1 - z0);
     return {
@@ -312,13 +312,11 @@ void TransformState::constrain(double& scale_, double& x_, double& y_) const {
 }
 
 void TransformState::moveLatLng(const LatLng& latLng, const ScreenCoordinate& anchor) {
-    if (!latLng || !anchor) return;
-
-    auto latLngToTileCoord = [&](const LatLng& ll) -> vec2<double> {
+    auto latLngToTileCoord = [&](const LatLng& ll) -> Point<double> {
         return { lngX(ll.longitude), latY(ll.latitude) };
     };
 
-    auto tileCoordToLatLng = [&](const vec2<double> coord) -> LatLng {
+    auto tileCoordToLatLng = [&](const Point<double> coord) -> LatLng {
         return { yLat(coord.y, worldSize()), xLng(coord.x, worldSize()) };
     };
 
diff --git a/src/mbgl/map/transform_state.hpp b/src/mbgl/map/transform_state.hpp
index ef3a5dfefd..37b52f9606 100644
--- a/src/mbgl/map/transform_state.hpp
+++ b/src/mbgl/map/transform_state.hpp
@@ -4,7 +4,6 @@
 #include <mbgl/map/mode.hpp>
 #include <mbgl/util/geo.hpp>
 #include <mbgl/util/constants.hpp>
-#include <mbgl/util/vec.hpp>
 #include <mbgl/util/mat4.hpp>
 
 #include <cstdint>
diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp
index 0819524b96..fdbb291457 100644
--- a/src/mbgl/renderer/line_bucket.cpp
+++ b/src/mbgl/renderer/line_bucket.cpp
@@ -85,16 +85,18 @@ void LineBucket::addGeometry(const GeometryCoordinates& vertices) {
 
     double distance = 0;
     bool startOfLine = true;
-    GeometryCoordinate currentVertex = GeometryCoordinate::null(), prevVertex = GeometryCoordinate::null(),
-               nextVertex = GeometryCoordinate::null();
-    vec2<double> prevNormal = vec2<double>::null(), nextNormal = vec2<double>::null();
+    optional<GeometryCoordinate> currentVertex;
+    optional<GeometryCoordinate> prevVertex;
+    optional<GeometryCoordinate> nextVertex;
+    optional<Point<double>> prevNormal;
+    optional<Point<double>> nextNormal;
 
     // the last three vertices added
     e1 = e2 = e3 = -1;
 
     if (closed) {
         currentVertex = vertices[len - 2];
-        nextNormal = util::perp(util::unit(vec2<double>(firstVertex - currentVertex)));
+        nextNormal = util::perp(util::unit(convertPoint<double>(firstVertex - *currentVertex)));
     }
 
     const GLint startVertex = vertexBuffer.index();
@@ -109,19 +111,19 @@ void LineBucket::addGeometry(const GeometryCoordinates& vertices) {
             nextVertex = vertices[i + 1];
         } else {
             // there is no next vertex
-            nextVertex = GeometryCoordinate::null();
+            nextVertex = {};
         }
 
         // if two consecutive vertices exist, skip the current one
-        if (nextVertex && vertices[i] == nextVertex) {
+        if (nextVertex && vertices[i] == *nextVertex) {
             continue;
         }
 
         if (nextNormal) {
-            prevNormal = nextNormal;
+            prevNormal = *nextNormal;
         }
         if (currentVertex) {
-            prevVertex = currentVertex;
+            prevVertex = *currentVertex;
         }
 
         currentVertex = vertices[i];
@@ -129,18 +131,18 @@ void LineBucket::addGeometry(const GeometryCoordinates& vertices) {
         // Calculate the normal towards the next vertex in this line. In case
         // there is no next vertex, pretend that the line is continuing straight,
         // meaning that we are just using the previous normal.
-        nextNormal = nextVertex ? util::perp(util::unit(vec2<double>(nextVertex - currentVertex)))
+        nextNormal = nextVertex ? util::perp(util::unit(convertPoint<double>(*nextVertex - *currentVertex)))
                                 : prevNormal;
 
         // If we still don't have a previous normal, this is the beginning of a
         // non-closed line, so we're doing a straight "join".
         if (!prevNormal) {
-            prevNormal = nextNormal;
+            prevNormal = *nextNormal;
         }
 
         // Determine the normal of the join extrusion. It is the angle bisector
         // of the segments between the previous line and the next line.
-        vec2<double> joinNormal = util::unit(prevNormal + nextNormal);
+        Point<double> joinNormal = util::unit(*prevNormal + *nextNormal);
 
         /*  joinNormal     prevNormal
          *             ↖      ↑
@@ -155,17 +157,17 @@ void LineBucket::addGeometry(const GeometryCoordinates& vertices) {
         // Calculate the length of the miter (the ratio of the miter to the width).
         // Find the cosine of the angle between the next and join normals
         // using dot product. The inverse of that is the miter length.
-        const float cosHalfAngle = joinNormal.x * nextNormal.x + joinNormal.y * nextNormal.y;
-        const float miterLength = cosHalfAngle != 0 ? 1 / cosHalfAngle: 1;
+        const double cosHalfAngle = joinNormal.x * nextNormal->x + joinNormal.y * nextNormal->y;
+        const double miterLength = cosHalfAngle != 0 ? 1 / cosHalfAngle: 1;
 
         const bool isSharpCorner = cosHalfAngle < COS_HALF_SHARP_CORNER && prevVertex && nextVertex;
 
         if (isSharpCorner && i > 0) {
-            const double prevSegmentLength = util::dist<double>(currentVertex, prevVertex);
+            const double prevSegmentLength = util::dist<double>(*currentVertex, *prevVertex);
             if (prevSegmentLength > 2.0 * sharpCornerOffset) {
-                GeometryCoordinate newPrevVertex = currentVertex - (util::round(vec2<double>(currentVertex - prevVertex) * (sharpCornerOffset / prevSegmentLength)));
-                distance += util::dist<double>(newPrevVertex, prevVertex);
-                addCurrentVertex(newPrevVertex, distance, prevNormal, 0, 0, false, startVertex, triangleStore);
+                GeometryCoordinate newPrevVertex = *currentVertex - convertPoint<int16_t>(util::round(convertPoint<double>(*currentVertex - *prevVertex) * (sharpCornerOffset / prevSegmentLength)));
+                distance += util::dist<double>(newPrevVertex, *prevVertex);
+                addCurrentVertex(newPrevVertex, distance, *prevNormal, 0, 0, false, startVertex, triangleStore);
                 prevVertex = newPrevVertex;
             }
         }
@@ -205,11 +207,11 @@ void LineBucket::addGeometry(const GeometryCoordinates& vertices) {
 
         // Calculate how far along the line the currentVertex is
         if (prevVertex)
-            distance += util::dist<double>(currentVertex, prevVertex);
+            distance += util::dist<double>(*currentVertex, *prevVertex);
 
         if (middleVertex && currentJoin == LineJoinType::Miter) {
             joinNormal = joinNormal * miterLength;
-            addCurrentVertex(currentVertex, distance, joinNormal, 0, 0, false, startVertex,
+            addCurrentVertex(*currentVertex, distance, joinNormal, 0, 0, false, startVertex,
                              triangleStore);
 
         } else if (middleVertex && currentJoin == LineJoinType::FlipBevel) {
@@ -217,21 +219,21 @@ void LineBucket::addGeometry(const GeometryCoordinates& vertices) {
 
             if (miterLength > 100) {
                 // Almost parallel lines
-                joinNormal = nextNormal;
+                joinNormal = *nextNormal;
             } else {
-                const float direction = prevNormal.x * nextNormal.y - prevNormal.y * nextNormal.x > 0 ? -1 : 1;
-                const float bevelLength = miterLength * util::mag(prevNormal + nextNormal) /
-                                          util::mag(prevNormal - nextNormal);
+                const double direction = prevNormal->x * nextNormal->y - prevNormal->y * nextNormal->x > 0 ? -1 : 1;
+                const double bevelLength = miterLength * util::mag(*prevNormal + *nextNormal) /
+                                          util::mag(*prevNormal - *nextNormal);
                 joinNormal = util::perp(joinNormal) * bevelLength * direction;
             }
 
-            addCurrentVertex(currentVertex, distance, joinNormal, 0, 0, false, startVertex,
+            addCurrentVertex(*currentVertex, distance, joinNormal, 0, 0, false, startVertex,
                              triangleStore);
 
-            addCurrentVertex(currentVertex, distance, joinNormal * -1.0, 0, 0, false, startVertex,
+            addCurrentVertex(*currentVertex, distance, joinNormal * -1.0, 0, 0, false, startVertex,
                              triangleStore);
         } else if (middleVertex && (currentJoin == LineJoinType::Bevel || currentJoin == LineJoinType::FakeRound)) {
-            const bool lineTurnsLeft = (prevNormal.x * nextNormal.y - prevNormal.y * nextNormal.x) > 0;
+            const bool lineTurnsLeft = (prevNormal->x * nextNormal->y - prevNormal->y * nextNormal->x) > 0;
             const float offset = -std::sqrt(miterLength * miterLength - 1);
             float offsetA;
             float offsetB;
@@ -246,7 +248,7 @@ void LineBucket::addGeometry(const GeometryCoordinates& vertices) {
 
             // Close previous segement with bevel
             if (!startOfLine) {
-                addCurrentVertex(currentVertex, distance, prevNormal, offsetA, offsetB, false,
+                addCurrentVertex(*currentVertex, distance, *prevNormal, offsetA, offsetB, false,
                                  startVertex, triangleStore);
             }
 
@@ -261,41 +263,41 @@ void LineBucket::addGeometry(const GeometryCoordinates& vertices) {
                 const int n = std::floor((0.5 - (cosHalfAngle - 0.5)) * 8);
 
                 for (int m = 0; m < n; m++) {
-                    auto approxFractionalJoinNormal = util::unit(nextNormal * ((m + 1.0f) / (n + 1.0f)) + prevNormal);
-                    addPieSliceVertex(currentVertex, distance, approxFractionalJoinNormal, lineTurnsLeft, startVertex, triangleStore);
+                    auto approxFractionalJoinNormal = util::unit(*nextNormal * ((m + 1.0) / (n + 1.0)) + *prevNormal);
+                    addPieSliceVertex(*currentVertex, distance, approxFractionalJoinNormal, lineTurnsLeft, startVertex, triangleStore);
                 }
 
-                addPieSliceVertex(currentVertex, distance, joinNormal, lineTurnsLeft, startVertex, triangleStore);
+                addPieSliceVertex(*currentVertex, distance, joinNormal, lineTurnsLeft, startVertex, triangleStore);
 
                 for (int k = n - 1; k >= 0; k--) {
-                    auto approxFractionalJoinNormal = util::unit(prevNormal * ((k + 1.0f) / (n + 1.0f)) + nextNormal);
-                    addPieSliceVertex(currentVertex, distance, approxFractionalJoinNormal, lineTurnsLeft, startVertex, triangleStore);
+                    auto approxFractionalJoinNormal = util::unit(*prevNormal * ((k + 1.0) / (n + 1.0)) + *nextNormal);
+                    addPieSliceVertex(*currentVertex, distance, approxFractionalJoinNormal, lineTurnsLeft, startVertex, triangleStore);
                 }
             }
 
             // Start next segment
             if (nextVertex) {
-                addCurrentVertex(currentVertex, distance, nextNormal, -offsetA, -offsetB,
+                addCurrentVertex(*currentVertex, distance, *nextNormal, -offsetA, -offsetB,
                                  false, startVertex, triangleStore);
             }
 
         } else if (!middleVertex && currentCap == LineCapType::Butt) {
             if (!startOfLine) {
                 // Close previous segment with a butt
-                addCurrentVertex(currentVertex, distance, prevNormal, 0, 0, false,
+                addCurrentVertex(*currentVertex, distance, *prevNormal, 0, 0, false,
                                  startVertex, triangleStore);
             }
 
             // Start next segment with a butt
             if (nextVertex) {
-                addCurrentVertex(currentVertex, distance, nextNormal, 0, 0, false,
+                addCurrentVertex(*currentVertex, distance, *nextNormal, 0, 0, false,
                                  startVertex, triangleStore);
             }
 
         } else if (!middleVertex && currentCap == LineCapType::Square) {
             if (!startOfLine) {
                 // Close previous segment with a square cap
-                addCurrentVertex(currentVertex, distance, prevNormal, 1, 1, false,
+                addCurrentVertex(*currentVertex, distance, *prevNormal, 1, 1, false,
                                  startVertex, triangleStore);
 
                 // The segment is done. Unset vertices to disconnect segments.
@@ -304,18 +306,18 @@ void LineBucket::addGeometry(const GeometryCoordinates& vertices) {
 
             // Start next segment
             if (nextVertex) {
-                addCurrentVertex(currentVertex, distance, nextNormal, -1, -1, false,
+                addCurrentVertex(*currentVertex, distance, *nextNormal, -1, -1, false,
                                  startVertex, triangleStore);
             }
 
         } else if (middleVertex ? currentJoin == LineJoinType::Round : currentCap == LineCapType::Round) {
             if (!startOfLine) {
                 // Close previous segment with a butt
-                addCurrentVertex(currentVertex, distance, prevNormal, 0, 0, false,
+                addCurrentVertex(*currentVertex, distance, *prevNormal, 0, 0, false,
                                  startVertex, triangleStore);
 
                 // Add round cap or linejoin at end of segment
-                addCurrentVertex(currentVertex, distance, prevNormal, 1, 1, true, startVertex,
+                addCurrentVertex(*currentVertex, distance, *prevNormal, 1, 1, true, startVertex,
                                  triangleStore);
 
                 // The segment is done. Unset vertices to disconnect segments.
@@ -325,20 +327,20 @@ void LineBucket::addGeometry(const GeometryCoordinates& vertices) {
             // Start next segment with a butt
             if (nextVertex) {
                 // Add round cap before first segment
-                addCurrentVertex(currentVertex, distance, nextNormal, -1, -1, true,
+                addCurrentVertex(*currentVertex, distance, *nextNormal, -1, -1, true,
                                  startVertex, triangleStore);
 
-                addCurrentVertex(currentVertex, distance, nextNormal, 0, 0, false,
+                addCurrentVertex(*currentVertex, distance, *nextNormal, 0, 0, false,
                                  startVertex, triangleStore);
             }
         }
 
         if (isSharpCorner && i < len - 1) {
-            const double nextSegmentLength = util::dist<double>(currentVertex, nextVertex);
+            const double nextSegmentLength = util::dist<double>(*currentVertex, *nextVertex);
             if (nextSegmentLength > 2 * sharpCornerOffset) {
-                GeometryCoordinate newCurrentVertex = currentVertex + util::round(vec2<double>(nextVertex - currentVertex) * (sharpCornerOffset / nextSegmentLength));
-                distance += util::dist<double>(newCurrentVertex, currentVertex);
-                addCurrentVertex(newCurrentVertex, distance, nextNormal, 0, 0, false, startVertex, triangleStore);
+                GeometryCoordinate newCurrentVertex = *currentVertex + convertPoint<int16_t>(util::round(convertPoint<double>(*nextVertex - *currentVertex) * (sharpCornerOffset / nextSegmentLength)));
+                distance += util::dist<double>(newCurrentVertex, *currentVertex);
+                addCurrentVertex(newCurrentVertex, distance, *nextNormal, 0, 0, false, startVertex, triangleStore);
                 currentVertex = newCurrentVertex;
             }
         }
@@ -371,15 +373,15 @@ void LineBucket::addGeometry(const GeometryCoordinates& vertices) {
 
 void LineBucket::addCurrentVertex(const GeometryCoordinate& currentVertex,
                                   double &distance,
-                                  const vec2<double>& normal,
-                                  float endLeft,
-                                  float endRight,
+                                  const Point<double>& normal,
+                                  double endLeft,
+                                  double endRight,
                                   bool round,
                                   GLint startVertex,
                                   std::vector<TriangleElement>& triangleStore) {
     int8_t tx = round ? 1 : 0;
 
-    vec2<double> extrude = normal;
+    Point<double> extrude = normal;
     if (endLeft)
         extrude = extrude - (util::perp(normal) * endLeft);
     e3 = vertexBuffer.add(currentVertex.x, currentVertex.y, extrude.x, extrude.y, tx, 0, endLeft, distance * LINE_DISTANCE_SCALE)
@@ -413,13 +415,13 @@ void LineBucket::addCurrentVertex(const GeometryCoordinate& currentVertex,
 
 void LineBucket::addPieSliceVertex(const GeometryCoordinate& currentVertex,
                                    double distance,
-                                   const vec2<double>& extrude,
+                                   const Point<double>& extrude,
                                    bool lineTurnsLeft,
                                    GLint startVertex,
                                   std::vector<TriangleElement>& triangleStore) {
     int8_t ty = lineTurnsLeft;
 
-    auto flippedExtrude = extrude * (lineTurnsLeft ? -1 : 1);
+    Point<double> flippedExtrude = extrude * (lineTurnsLeft ? -1.0 : 1.0);
     e3 = vertexBuffer.add(currentVertex.x, currentVertex.y, flippedExtrude.x, flippedExtrude.y, 0, ty, 0, distance * LINE_DISTANCE_SCALE)
          - startVertex;
     if (e1 >= 0 && e2 >= 0) {
diff --git a/src/mbgl/renderer/line_bucket.hpp b/src/mbgl/renderer/line_bucket.hpp
index d6dd1b5567..9c7ec3d93e 100644
--- a/src/mbgl/renderer/line_bucket.hpp
+++ b/src/mbgl/renderer/line_bucket.hpp
@@ -6,7 +6,6 @@
 #include <mbgl/geometry/vao.hpp>
 #include <mbgl/geometry/elements_buffer.hpp>
 #include <mbgl/geometry/line_buffer.hpp>
-#include <mbgl/util/vec.hpp>
 #include <mbgl/layer/line_layer.hpp>
 
 #include <vector>
@@ -45,10 +44,10 @@ private:
         uint16_t a, b, c;
     };
     void addCurrentVertex(const GeometryCoordinate& currentVertex, double& distance,
-            const vec2<double>& normal, float endLeft, float endRight, bool round,
+            const Point<double>& normal, double endLeft, double endRight, bool round,
             GLint startVertex, std::vector<LineBucket::TriangleElement>& triangleStore);
     void addPieSliceVertex(const GeometryCoordinate& currentVertex, double distance,
-            const vec2<double>& extrude, bool lineTurnsLeft, GLint startVertex,
+            const Point<double>& extrude, bool lineTurnsLeft, GLint startVertex,
             std::vector<TriangleElement>& triangleStore);
 
 public:
diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp
index 55138363fe..b0930890d4 100644
--- a/src/mbgl/renderer/symbol_bucket.cpp
+++ b/src/mbgl/renderer/symbol_bucket.cpp
@@ -38,8 +38,7 @@ SymbolInstance::SymbolInstance(Anchor& anchor, const GeometryCoordinates& line,
         const float textBoxScale, const float textPadding, const float textAlongLine,
         const float iconBoxScale, const float iconPadding, const float iconAlongLine,
         const GlyphPositions& face, const IndexedSubfeature& indexedFeature) :
-    x(anchor.x),
-    y(anchor.y),
+    point(anchor.point),
     index(index_),
     hasText(shapedText),
     hasIcon(shapedIcon),
@@ -265,7 +264,7 @@ void SymbolBucket::addFeatures(uintptr_t tileUID,
                 /* verticalAlign */ verticalAlign,
                 /* justify */ justify,
                 /* spacing: ems */ layout.textLetterSpacing * 24,
-                /* translate */ vec2<float>(layout.textOffset.value[0], layout.textOffset.value[1]));
+                /* translate */ Point<float>(layout.textOffset.value[0], layout.textOffset.value[1]));
 
             // Add the glyphs we need for this label to the glyph atlas.
             if (shapedText) {
@@ -346,7 +345,7 @@ void SymbolBucket::addFeature(const GeometryCollection &lines,
                 }
             }
 
-            const bool inside = !(anchor.x < 0 || anchor.x > util::EXTENT || anchor.y < 0 || anchor.y > util::EXTENT);
+            const bool inside = !(anchor.point.x < 0 || anchor.point.x > util::EXTENT || anchor.point.y < 0 || anchor.point.y > util::EXTENT);
 
             if (avoidEdges && !inside) continue;
 
@@ -377,7 +376,7 @@ bool SymbolBucket::anchorIsTooClose(const std::u32string &text, const float repe
     } else {
         auto otherAnchors = compareText.find(text)->second;
         for (Anchor &otherAnchor : otherAnchors) {
-            if (util::dist<float>(anchor, otherAnchor) < repeatDistance) {
+            if (util::dist<float>(anchor.point, otherAnchor.point) < repeatDistance) {
                 return true;
             }
         }
@@ -412,8 +411,8 @@ void SymbolBucket::placeFeatures(CollisionTile& collisionTile) {
         const float cos = std::cos(collisionTile.config.angle);
 
         std::sort(symbolInstances.begin(), symbolInstances.end(), [sin, cos](SymbolInstance &a, SymbolInstance &b) {
-            const int32_t aRotated = sin * a.x + cos * a.y;
-            const int32_t bRotated = sin * b.x + cos * b.y;
+            const int32_t aRotated = sin * a.point.x + cos * a.point.y;
+            const int32_t bRotated = sin * b.point.x + cos * b.point.y;
             return aRotated != bRotated ?
                 aRotated < bRotated :
                 a.index > b.index;
@@ -557,14 +556,14 @@ void SymbolBucket::addToDebugBuffers(CollisionTile &collisionTile) {
             for (const CollisionBox &box : feature.boxes) {
                 auto& anchor = box.anchor;
 
-                vec2<float> tl{box.x1, box.y1 * yStretch};
-                vec2<float> tr{box.x2, box.y1 * yStretch};
-                vec2<float> bl{box.x1, box.y2 * yStretch};
-                vec2<float> br{box.x2, box.y2 * yStretch};
-                tl = tl.matMul(matrix);
-                tr = tr.matMul(matrix);
-                bl = bl.matMul(matrix);
-                br = br.matMul(matrix);
+                Point<float> tl{box.x1, box.y1 * yStretch};
+                Point<float> tr{box.x2, box.y1 * yStretch};
+                Point<float> bl{box.x1, box.y2 * yStretch};
+                Point<float> br{box.x2, box.y2 * yStretch};
+                tl = util::matrixMultiply(matrix, tl);
+                tr = util::matrixMultiply(matrix, tr);
+                bl = util::matrixMultiply(matrix, bl);
+                br = util::matrixMultiply(matrix, br);
 
                 const float maxZoom = util::max(0.0f, util::min(25.0f, static_cast<float>(zoom + log(box.maxScale) / log(2))));
                 const float placementZoom= util::max(0.0f, util::min(25.0f, static_cast<float>(zoom + log(box.placementScale) / log(2))));
diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp
index 709f9fc65a..e212f56162 100644
--- a/src/mbgl/renderer/symbol_bucket.hpp
+++ b/src/mbgl/renderer/symbol_bucket.hpp
@@ -52,8 +52,7 @@ class SymbolInstance {
                 const float textBoxScale, const float textPadding, const float textAlongLine,
                 const float iconBoxScale, const float iconPadding, const float iconAlongLine,
                 const GlyphPositions& face, const IndexedSubfeature& indexedfeature);
-        float x;
-        float y;
+        Point<float> point;
         uint32_t index;
         bool hasText;
         bool hasIcon;
diff --git a/src/mbgl/source/source.cpp b/src/mbgl/source/source.cpp
index 4841767751..b2729593c6 100644
--- a/src/mbgl/source/source.cpp
+++ b/src/mbgl/source/source.cpp
@@ -479,7 +479,7 @@ void Source::updateTilePtrs() {
     }
 }
 
-vec2<int16_t> coordinateToTilePoint(const TileID& tileID, const TileCoordinate& coord) {
+static Point<int16_t> coordinateToTilePoint(const TileID& tileID, const TileCoordinate& coord) {
     auto zoomedCoord = coord.zoomTo(tileID.sourceZ);
     return {
         int16_t(util::clamp<int64_t>((zoomedCoord.x - (tileID.x + tileID.w * std::pow(2, tileID.sourceZ))) * util::EXTENT,
diff --git a/src/mbgl/text/check_max_angle.cpp b/src/mbgl/text/check_max_angle.cpp
index 4777f66a23..3ef13a0dd7 100644
--- a/src/mbgl/text/check_max_angle.cpp
+++ b/src/mbgl/text/check_max_angle.cpp
@@ -19,7 +19,7 @@ bool checkMaxAngle(const GeometryCoordinates &line, Anchor &anchor, const float
     // horizontal labels always pass
     if (anchor.segment < 0) return true;
 
-    GeometryCoordinate anchorPoint = { (int16_t)anchor.x, (int16_t)anchor.y };
+    GeometryCoordinate anchorPoint = convertPoint<int16_t>(anchor.point);
     GeometryCoordinate &p = anchorPoint;
     int index = anchor.segment + 1;
     float anchorDistance = 0;
diff --git a/src/mbgl/text/collision_feature.cpp b/src/mbgl/text/collision_feature.cpp
index 09c04ede78..8f0f099670 100644
--- a/src/mbgl/text/collision_feature.cpp
+++ b/src/mbgl/text/collision_feature.cpp
@@ -17,17 +17,17 @@ CollisionFeature::CollisionFeature(const GeometryCoordinates &line, const Anchor
 
     if (alongLine) {
         float height = y2 - y1;
-        const float length = x2 - x1;
+        const double length = x2 - x1;
 
         if (height <= 0.0f) return;
 
         height = std::max(10.0f * boxScale, height);
 
-        GeometryCoordinate anchorPoint(int16_t(anchor.x), int16_t(anchor.y));
+        GeometryCoordinate anchorPoint = convertPoint<int16_t>(anchor.point);
 
         if (straight) {
             // used for icon labels that are aligned with the line, but don't curve along it
-            const vec2<double> vector = util::unit(vec2<double>(line[anchor.segment + 1] - line[anchor.segment])) * length;
+            const GeometryCoordinate vector = convertPoint<int16_t>(util::unit(convertPoint<double>(line[anchor.segment + 1] - line[anchor.segment])) * length);
             const GeometryCoordinates newLine({ anchorPoint - vector, anchorPoint + vector });
             bboxifyLabel(newLine, anchorPoint, 0, length, height, indexedFeature);
         } else {
@@ -35,7 +35,7 @@ CollisionFeature::CollisionFeature(const GeometryCoordinates &line, const Anchor
             bboxifyLabel(line, anchorPoint, anchor.segment, length, height, indexedFeature);
         }
     } else {
-        boxes.emplace_back(anchor, x1, y1, x2, y2, std::numeric_limits<float>::infinity(), indexedFeature);
+        boxes.emplace_back(anchor.point, x1, y1, x2, y2, std::numeric_limits<float>::infinity(), indexedFeature);
     }
 }
 
@@ -89,7 +89,7 @@ void CollisionFeature::bboxifyLabel(const GeometryCoordinates &line,
         const auto& p0 = line[index];
         const auto& p1 = line[index + 1];
 
-        vec2<float> boxAnchor = {
+        Point<float> boxAnchor = {
             p0.x + segmentBoxDistance / segmentLength * (p1.x - p0.x),
             p0.y + segmentBoxDistance / segmentLength * (p1.y - p0.y)
         };
diff --git a/src/mbgl/text/collision_feature.hpp b/src/mbgl/text/collision_feature.hpp
index 0cd0b5554c..0fe248a3de 100644
--- a/src/mbgl/text/collision_feature.hpp
+++ b/src/mbgl/text/collision_feature.hpp
@@ -1,7 +1,6 @@
 #ifndef MBGL_TEXT_COLLISION_FEATURE
 #define MBGL_TEXT_COLLISION_FEATURE
 
-#include <mbgl/util/vec.hpp>
 #include <mbgl/geometry/anchor.hpp>
 #include <mbgl/text/shaping.hpp>
 #include <mbgl/tile/geometry_tile.hpp>
@@ -12,12 +11,12 @@
 namespace mbgl {
     class CollisionBox {
         public:
-            explicit CollisionBox(const vec2<float> &_anchor, float _x1, float _y1, float _x2, float _y2, float _maxScale,
+            explicit CollisionBox(const Point<float> &_anchor, float _x1, float _y1, float _x2, float _y2, float _maxScale,
                     const IndexedSubfeature& indexedFeature_ = { 0, "", "", 0 }) :
                 anchor(_anchor), x1(_x1), y1(_y1), x2(_x2), y2(_y2), maxScale(_maxScale), indexedFeature(indexedFeature_) {}
 
             // the box is centered around the anchor point
-            vec2<float> anchor;
+            Point<float> anchor;
 
             // distances to the edges from the anchor
             float x1;
diff --git a/src/mbgl/text/collision_tile.cpp b/src/mbgl/text/collision_tile.cpp
index 6b9240df1f..ef7e9ab850 100644
--- a/src/mbgl/text/collision_tile.cpp
+++ b/src/mbgl/text/collision_tile.cpp
@@ -1,6 +1,8 @@
 #include <mbgl/text/collision_tile.hpp>
 #include <mbgl/geometry/feature_index.hpp>
 #include <mbgl/util/constants.hpp>
+#include <mbgl/util/math.hpp>
+
 #include <cmath>
 
 namespace mbgl {
@@ -10,13 +12,13 @@ auto infinity = std::numeric_limits<float>::infinity();
 CollisionTile::CollisionTile(PlacementConfig config_) : config(config_),
     edges({{
         // left
-        CollisionBox(vec2<float>(0, 0), 0, -infinity, 0, infinity, infinity),
+        CollisionBox(Point<float>(0, 0), 0, -infinity, 0, infinity, infinity),
         // right
-        CollisionBox(vec2<float>(util::EXTENT, 0), 0, -infinity, 0, infinity, infinity),
+        CollisionBox(Point<float>(util::EXTENT, 0), 0, -infinity, 0, infinity, infinity),
         // top
-        CollisionBox(vec2<float>(0, 0), -infinity, 0, infinity, 0, infinity),
+        CollisionBox(Point<float>(0, 0), -infinity, 0, infinity, 0, infinity),
         // bottom
-        CollisionBox(vec2<float>(0, util::EXTENT), -infinity, 0, infinity, 0, infinity),
+        CollisionBox(Point<float>(0, util::EXTENT), -infinity, 0, infinity, 0, infinity),
     }}) {
     tree.clear();
 
@@ -35,8 +37,8 @@ CollisionTile::CollisionTile(PlacementConfig config_) : config(config_),
 }
 
 
-float CollisionTile::findPlacementScale(float minPlacementScale, const vec2<float>& anchor,
-        const CollisionBox& box, const vec2<float>& blockingAnchor, const CollisionBox& blocking) {
+float CollisionTile::findPlacementScale(float minPlacementScale, const Point<float>& anchor,
+        const CollisionBox& box, const Point<float>& blockingAnchor, const CollisionBox& blocking) {
 
 
     // Find the lowest scale at which the two boxes can fit side by side without overlapping.
@@ -80,7 +82,7 @@ float CollisionTile::placeFeature(const CollisionFeature &feature, const bool al
     float minPlacementScale = minScale;
 
     for (auto& box : feature.boxes) {
-        const auto anchor = box.anchor.matMul(rotationMatrix);
+        const auto anchor = util::matrixMultiply(rotationMatrix, box.anchor);
 
         if (!allowOverlap) {
             std::vector<CollisionTreeBox> blockingBoxes;
@@ -88,7 +90,7 @@ float CollisionTile::placeFeature(const CollisionFeature &feature, const bool al
 
             for (auto& blockingTreeBox : blockingBoxes) {
                 const auto& blocking = std::get<1>(blockingTreeBox);
-                auto blockingAnchor = blocking.anchor.matMul(rotationMatrix);
+                auto blockingAnchor = util::matrixMultiply(rotationMatrix, blocking.anchor);
 
                 minPlacementScale = findPlacementScale(minPlacementScale, anchor, box, blockingAnchor, blocking);
                 if (minPlacementScale >= maxScale) return minPlacementScale;
@@ -96,14 +98,14 @@ float CollisionTile::placeFeature(const CollisionFeature &feature, const bool al
         }
 
         if (avoidEdges) {
-            const vec2<float> tl = { box.x1, box.y1 };
-            const vec2<float> tr = { box.x2, box.y1 };
-            const vec2<float> bl = { box.x1, box.y2 };
-            const vec2<float> br = { box.x2, box.y2 };
-            const vec2<float> rtl = tl.matMul(reverseRotationMatrix);
-            const vec2<float> rtr = tr.matMul(reverseRotationMatrix);
-            const vec2<float> rbl = bl.matMul(reverseRotationMatrix);
-            const vec2<float> rbr = br.matMul(reverseRotationMatrix);
+            const Point<float> tl = { box.x1, box.y1 };
+            const Point<float> tr = { box.x2, box.y1 };
+            const Point<float> bl = { box.x1, box.y2 };
+            const Point<float> br = { box.x2, box.y2 };
+            const Point<float> rtl = util::matrixMultiply(reverseRotationMatrix, tl);
+            const Point<float> rtr = util::matrixMultiply(reverseRotationMatrix, tr);
+            const Point<float> rbl = util::matrixMultiply(reverseRotationMatrix, bl);
+            const Point<float> rbr = util::matrixMultiply(reverseRotationMatrix, br);
             CollisionBox rotatedBox(box.anchor,
                     ::fmin(::fmin(rtl.x, rtr.x), ::fmin(rbl.x, rbr.x)),
                     ::fmin(::fmin(rtl.y, rtr.y), ::fmin(rbl.y, rbr.y)),
@@ -130,7 +132,7 @@ void CollisionTile::insertFeature(CollisionFeature &feature, const float minPlac
     if (minPlacementScale < maxScale) {
         std::vector<CollisionTreeBox> treeBoxes;
         for (auto& box : feature.boxes) {
-            treeBoxes.emplace_back(getTreeBox(box.anchor.matMul(rotationMatrix), box), box);
+            treeBoxes.emplace_back(getTreeBox(util::matrixMultiply(rotationMatrix, box.anchor), box), box);
         }
         if (ignorePlacement) {
             ignoredTree.insert(treeBoxes.begin(), treeBoxes.end());
@@ -141,7 +143,7 @@ void CollisionTile::insertFeature(CollisionFeature &feature, const float minPlac
 
 }
 
-Box CollisionTile::getTreeBox(const vec2<float> &anchor, const CollisionBox &box, const float scale) {
+Box CollisionTile::getTreeBox(const Point<float> &anchor, const CollisionBox &box, const float scale) {
     return Box{
         CollisionPoint{
             anchor.x + box.x1 / scale,
@@ -158,7 +160,7 @@ std::vector<IndexedSubfeature> CollisionTile::queryRenderedSymbols(const float m
 
     std::vector<IndexedSubfeature> result;
 
-    auto anchor = vec2<float>(minX, minY).matMul(rotationMatrix);
+    auto anchor = util::matrixMultiply(rotationMatrix, Point<float>(minX, minY));
     CollisionBox queryBox(anchor, 0, 0, maxX - minX, maxY - minY, scale);
 
     std::vector<CollisionTreeBox> blockingBoxes;
@@ -174,7 +176,7 @@ std::vector<IndexedSubfeature> CollisionTile::queryRenderedSymbols(const float m
 
         auto& seenFeatures = sourceLayerFeatures[indexedFeature.sourceLayerName];
         if (seenFeatures.find(indexedFeature.index) == seenFeatures.end()) {
-            auto blockingAnchor = blocking.anchor.matMul(rotationMatrix);
+            auto blockingAnchor = util::matrixMultiply(rotationMatrix, blocking.anchor);
             float minPlacementScale = findPlacementScale(minScale, anchor, queryBox, blockingAnchor, blocking);
             if (minPlacementScale >= scale) {
                 seenFeatures.insert(indexedFeature.index);
diff --git a/src/mbgl/text/collision_tile.hpp b/src/mbgl/text/collision_tile.hpp
index 4bc25ddcb7..df769ac203 100644
--- a/src/mbgl/text/collision_tile.hpp
+++ b/src/mbgl/text/collision_tile.hpp
@@ -52,9 +52,9 @@ public:
 
 private:
     float findPlacementScale(float minPlacementScale,
-            const vec2<float>& anchor, const CollisionBox& box,
-            const vec2<float>& blockingAnchor, const CollisionBox& blocking);
-    Box getTreeBox(const vec2<float>& anchor, const CollisionBox& box, const float scale = 1.0);
+            const Point<float>& anchor, const CollisionBox& box,
+            const Point<float>& blockingAnchor, const CollisionBox& blocking);
+    Box getTreeBox(const Point<float>& anchor, const CollisionBox& box, const float scale = 1.0);
 
     Tree tree;
     Tree ignoredTree;
diff --git a/src/mbgl/text/glyph_set.cpp b/src/mbgl/text/glyph_set.cpp
index f63c1eae7f..8bd7e4ae03 100644
--- a/src/mbgl/text/glyph_set.cpp
+++ b/src/mbgl/text/glyph_set.cpp
@@ -33,7 +33,7 @@ const std::map<uint32_t, SDFGlyph> &GlyphSet::getSDFs() const {
 const Shaping GlyphSet::getShaping(const std::u32string &string, const float maxWidth,
                                     const float lineHeight, const float horizontalAlign,
                                     const float verticalAlign, const float justify,
-                                    const float spacing, const vec2<float> &translate) const {
+                                    const float spacing, const Point<float> &translate) const {
     Shaping shaping(translate.x * 24, translate.y * 24, string);
 
     // the y offset *should* be part of the font metadata
@@ -61,7 +61,7 @@ const Shaping GlyphSet::getShaping(const std::u32string &string, const float max
 
 void align(Shaping &shaping, const float justify, const float horizontalAlign,
            const float verticalAlign, const uint32_t maxLineLength, const float lineHeight,
-           const uint32_t line, const vec2<float> &translate) {
+           const uint32_t line, const Point<float> &translate) {
     const float shiftX = (justify - horizontalAlign) * maxLineLength + ::round(translate.x * 24/* one em */);
     const float shiftY = (-verticalAlign * (line + 1) + 0.5) * lineHeight + ::round(translate.y * 24/* one em */);
 
@@ -87,7 +87,7 @@ void justifyLine(std::vector<PositionedGlyph> &positionedGlyphs, const std::map<
 
 void GlyphSet::lineWrap(Shaping &shaping, const float lineHeight, const float maxWidth,
                          const float horizontalAlign, const float verticalAlign,
-                         const float justify, const vec2<float> &translate) const {
+                         const float justify, const Point<float> &translate) const {
     uint32_t lastSafeBreak = 0;
 
     uint32_t lengthBeforeCurrentLine = 0;
diff --git a/src/mbgl/text/glyph_set.hpp b/src/mbgl/text/glyph_set.hpp
index 5714071650..40f87835fd 100644
--- a/src/mbgl/text/glyph_set.hpp
+++ b/src/mbgl/text/glyph_set.hpp
@@ -2,7 +2,7 @@
 #define MBGL_TEXT_GLYPH_SET
 
 #include <mbgl/text/glyph.hpp>
-#include <mbgl/util/vec.hpp>
+#include <mbgl/util/geometry.hpp>
 
 namespace mbgl {
 
@@ -12,9 +12,9 @@ public:
     const std::map<uint32_t, SDFGlyph> &getSDFs() const;
     const Shaping getShaping(const std::u32string &string, float maxWidth, float lineHeight,
                              float horizontalAlign, float verticalAlign, float justify,
-                             float spacing, const vec2<float> &translate) const;
+                             float spacing, const Point<float> &translate) const;
     void lineWrap(Shaping &shaping, float lineHeight, float maxWidth, float horizontalAlign,
-                  float verticalAlign, float justify, const vec2<float> &translate) const;
+                  float verticalAlign, float justify, const Point<float> &translate) const;
 
 private:
     std::map<uint32_t, SDFGlyph> sdfs;
diff --git a/src/mbgl/text/quads.cpp b/src/mbgl/text/quads.cpp
index 2b5db023c0..f78d913e74 100644
--- a/src/mbgl/text/quads.cpp
+++ b/src/mbgl/text/quads.cpp
@@ -22,22 +22,22 @@ SymbolQuads getIconQuads(Anchor& anchor, const PositionedIcon& shapedIcon,
     auto right = left + image.pos.w / image.relativePixelRatio;
     auto top = shapedIcon.top - border;
     auto bottom = top + image.pos.h / image.relativePixelRatio;
-    vec2<float> tl{left, top};
-    vec2<float> tr{right, top};
-    vec2<float> br{right, bottom};
-    vec2<float> bl{left, bottom};
+    Point<float> tl{left, top};
+    Point<float> tr{right, top};
+    Point<float> br{right, bottom};
+    Point<float> bl{left, bottom};
 
 
     float angle = layout.iconRotate * util::DEG2RAD;
     if (alongLine) {
         assert(static_cast<unsigned int>(anchor.segment) < line.size());
         const GeometryCoordinate &prev= line[anchor.segment];
-        if (anchor.y == prev.y && anchor.x == prev.x &&
+        if (anchor.point.y == prev.y && anchor.point.x == prev.x &&
             static_cast<unsigned int>(anchor.segment + 1) < line.size()) {
             const GeometryCoordinate &next= line[anchor.segment + 1];
-            angle += std::atan2(anchor.y - next.y, anchor.x - next.x) + M_PI;
+            angle += std::atan2(anchor.point.y - next.y, anchor.point.x - next.x) + M_PI;
         } else {
-            angle += std::atan2(anchor.y - prev.y, anchor.x - prev.x);
+            angle += std::atan2(anchor.point.y - prev.y, anchor.point.x - prev.x);
         }
     }
 
@@ -48,24 +48,24 @@ SymbolQuads getIconQuads(Anchor& anchor, const PositionedIcon& shapedIcon,
         float angle_cos = std::cos(angle);
         std::array<float, 4> matrix = {{angle_cos, -angle_sin, angle_sin, angle_cos}};
 
-        tl = tl.matMul(matrix);
-        tr = tr.matMul(matrix);
-        bl = bl.matMul(matrix);
-        br = br.matMul(matrix);
+        tl = util::matrixMultiply(matrix, tl);
+        tr = util::matrixMultiply(matrix, tr);
+        bl = util::matrixMultiply(matrix, bl);
+        br = util::matrixMultiply(matrix, br);
     }
 
     SymbolQuads quads;
-    quads.emplace_back(tl, tr, bl, br, image.pos, 0, anchor, globalMinScale, std::numeric_limits<float>::infinity());
+    quads.emplace_back(tl, tr, bl, br, image.pos, 0, anchor.point, globalMinScale, std::numeric_limits<float>::infinity());
     return quads;
 }
 
 struct GlyphInstance {
-    explicit GlyphInstance(const vec2<float> &anchorPoint_) : anchorPoint(anchorPoint_) {}
-    explicit GlyphInstance(const vec2<float> &anchorPoint_, float offset_, float minScale_, float maxScale_,
+    explicit GlyphInstance(const Point<float> &anchorPoint_) : anchorPoint(anchorPoint_) {}
+    explicit GlyphInstance(const Point<float> &anchorPoint_, float offset_, float minScale_, float maxScale_,
             float angle_)
         : anchorPoint(anchorPoint_), offset(offset_), minScale(minScale_), maxScale(maxScale_), angle(angle_) {}
 
-    const vec2<float> anchorPoint;
+    const Point<float> anchorPoint;
     const float offset = 0.0f;
     const float minScale = globalMinScale;
     const float maxScale = std::numeric_limits<float>::infinity();
@@ -86,8 +86,8 @@ void getSegmentGlyphs(std::back_insert_iterator<GlyphInstances> glyphs, Anchor &
         segment++;
 
     assert((int)line.size() > segment);
-    vec2<float> end = line[segment];
-    vec2<float> newAnchorPoint = anchor;
+    Point<float> end = convertPoint<float>(line[segment]);
+    Point<float> newAnchorPoint = anchor.point;
     float prevscale = std::numeric_limits<float>::infinity();
 
     offset = std::fabs(offset);
@@ -122,10 +122,10 @@ void getSegmentGlyphs(std::back_insert_iterator<GlyphInstances> glyphs, Anchor &
                 anchor.scale = scale;
                 return;
             }
-            end = line[segment];
+            end = convertPoint<float>(line[segment]);
         }
 
-        vec2<float> normal = util::normal<float>(newAnchorPoint, end) * dist;
+        Point<float> normal = util::normal<float>(newAnchorPoint, end) * dist;
         newAnchorPoint = newAnchorPoint - normal;
 
         prevscale = scale;
@@ -163,7 +163,7 @@ SymbolQuads getGlyphQuads(Anchor& anchor, const Shaping& shapedText,
                 getSegmentGlyphs(std::back_inserter(glyphInstances), anchor, centerX, line, anchor.segment, false);
 
         } else {
-            glyphInstances.emplace_back(GlyphInstance{anchor});
+            glyphInstances.emplace_back(GlyphInstance{anchor.point});
         }
 
         // The rects have an addditional buffer that is not included in their size;
@@ -175,17 +175,17 @@ SymbolQuads getGlyphQuads(Anchor& anchor, const Shaping& shapedText,
         const float x2 = x1 + rect.w;
         const float y2 = y1 + rect.h;
 
-        const vec2<float> otl{x1, y1};
-        const vec2<float> otr{x2, y1};
-        const vec2<float> obl{x1, y2};
-        const vec2<float> obr{x2, y2};
+        const Point<float> otl{x1, y1};
+        const Point<float> otr{x2, y1};
+        const Point<float> obl{x1, y2};
+        const Point<float> obr{x2, y2};
 
         for (const GlyphInstance &instance : glyphInstances) {
 
-            vec2<float> tl = otl;
-            vec2<float> tr = otr;
-            vec2<float> bl = obl;
-            vec2<float> br = obr;
+            Point<float> tl = otl;
+            Point<float> tr = otr;
+            Point<float> bl = obl;
+            Point<float> br = obr;
             const float angle = instance.angle + textRotate;
 
             if (angle) {
@@ -194,10 +194,10 @@ SymbolQuads getGlyphQuads(Anchor& anchor, const Shaping& shapedText,
                 float angle_cos = std::cos(angle);
                 std::array<float, 4> matrix = {{angle_cos, -angle_sin, angle_sin, angle_cos}};
 
-                tl = tl.matMul(matrix);
-                tr = tr.matMul(matrix);
-                bl = bl.matMul(matrix);
-                br = br.matMul(matrix);
+                tl = util::matrixMultiply(matrix, tl);
+                tr = util::matrixMultiply(matrix, tr);
+                bl = util::matrixMultiply(matrix, bl);
+                br = util::matrixMultiply(matrix, br);
             }
 
             // Prevent label from extending past the end of the line
diff --git a/src/mbgl/text/quads.hpp b/src/mbgl/text/quads.hpp
index 12b8893503..03f86e1df9 100644
--- a/src/mbgl/text/quads.hpp
+++ b/src/mbgl/text/quads.hpp
@@ -3,16 +3,15 @@
 
 #include <mbgl/text/glyph.hpp>
 #include <mbgl/tile/geometry_tile.hpp>
-#include <mbgl/util/vec.hpp>
 
 #include <vector>
 
 namespace mbgl {
 
     struct SymbolQuad {
-        explicit SymbolQuad(const vec2<float> &tl_, const vec2<float> &tr_,
-                const vec2<float> &bl_, const vec2<float> &br_,
-                const Rect<uint16_t> &tex_, float angle_, const vec2<float> &anchorPoint_,
+        explicit SymbolQuad(const Point<float> &tl_, const Point<float> &tr_,
+                const Point<float> &bl_, const Point<float> &br_,
+                const Rect<uint16_t> &tex_, float angle_, const Point<float> &anchorPoint_,
                 float minScale_, float maxScale_)
             : tl(tl_),
             tr(tr_),
@@ -24,10 +23,10 @@ namespace mbgl {
             minScale(minScale_),
             maxScale(maxScale_) {}
 
-        vec2<float> tl, tr, bl, br;
+        Point<float> tl, tr, bl, br;
         Rect<uint16_t> tex;
         float angle;
-        vec2<float> anchorPoint;
+        Point<float> anchorPoint;
         float minScale, maxScale;
     };
 
diff --git a/src/mbgl/text/shaping.hpp b/src/mbgl/text/shaping.hpp
index 5fbb433035..89249ee605 100644
--- a/src/mbgl/text/shaping.hpp
+++ b/src/mbgl/text/shaping.hpp
@@ -4,8 +4,6 @@
 #include <mbgl/text/glyph.hpp>
 #include <mbgl/sprite/sprite_atlas.hpp>
 #include <mbgl/sprite/sprite_image.hpp>
-
-#include <mbgl/util/vec.hpp>
 #include <mbgl/util/optional.hpp>
 
 namespace mbgl {
diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp
index 0b01a230c5..923585028c 100644
--- a/src/mbgl/tile/geometry_tile.hpp
+++ b/src/mbgl/tile/geometry_tile.hpp
@@ -1,10 +1,10 @@
 #ifndef MBGL_MAP_GEOMETRY_TILE
 #define MBGL_MAP_GEOMETRY_TILE
 
+#include <mbgl/util/geometry.hpp>
 #include <mbgl/util/feature.hpp>
 #include <mbgl/util/chrono.hpp>
 #include <mbgl/util/ptr.hpp>
-#include <mbgl/util/vec.hpp>
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/optional.hpp>
 #include <mbgl/util/variant.hpp>
@@ -28,7 +28,7 @@ enum class FeatureType : uint8_t {
 // Normalized vector tile coordinates.
 // Each geometry coordinate represents a point in a bidimensional space,
 // varying from -V...0...+V, where V is the maximum extent applicable.
-using GeometryCoordinate  = vec2<int16_t>;
+using GeometryCoordinate  = Point<int16_t>;
 using GeometryCoordinates = std::vector<GeometryCoordinate>;
 using GeometryCollection  = std::vector<GeometryCoordinates>;
 
diff --git a/src/mbgl/util/geometry.hpp b/src/mbgl/util/geometry.hpp
new file mode 100644
index 0000000000..bf44d5ce93
--- /dev/null
+++ b/src/mbgl/util/geometry.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <mapbox/geometry/geometry.hpp>
+#include <mapbox/geometry/point_arithmetic.hpp>
+
+namespace mbgl {
+
+template <class T>
+using Point = mapbox::geometry::point<T>;
+
+template <class T>
+using LineString = mapbox::geometry::line_string<T>;
+
+template <class T>
+using Polygon = mapbox::geometry::polygon<T>;
+
+template <class T>
+using MultiPoint = mapbox::geometry::multi_point<T>;
+
+template <class T>
+using MultiLineString = mapbox::geometry::multi_line_string<T>;
+
+template <class T>
+using MultiPolygon = mapbox::geometry::multi_polygon<T>;
+
+template <class S, class T>
+Point<S> convertPoint(const Point<T>& p) {
+    return Point<S>(p.x, p.y);
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/util/intersection_tests.cpp b/src/mbgl/util/intersection_tests.cpp
index 44ec24db12..3e4ae27cd8 100644
--- a/src/mbgl/util/intersection_tests.cpp
+++ b/src/mbgl/util/intersection_tests.cpp
@@ -31,7 +31,7 @@ float distToSegmentSquared(const GeometryCoordinate& p, const GeometryCoordinate
     const float t = float((p.x - v.x) * (w.x - v.x) + (p.y - v.y) * (w.y - v.y)) / l2;
     if (t < 0) return util::distSqr<float>(p, v);
     if (t > 1) return util::distSqr<float>(p, w);
-    return util::distSqr<float>(p, vec2<float>(w - v) * t + v);
+    return util::distSqr<float>(p, convertPoint<float>(w - v) * t + convertPoint<float>(v));
 }
 
 bool pointIntersectsBufferedLine(const GeometryCoordinate& p, const GeometryCoordinates& line, const float radius) {
diff --git a/src/mbgl/util/mat4.cpp b/src/mbgl/util/mat4.cpp
index bf8252595d..d3d3617b7b 100644
--- a/src/mbgl/util/mat4.cpp
+++ b/src/mbgl/util/mat4.cpp
@@ -21,7 +21,6 @@
 // 3. This notice may not be removed or altered from any source distribution.
 
 #include <mbgl/util/mat4.hpp>
-#include <mbgl/util/vec.hpp>
 
 #include <cmath>
 
@@ -336,11 +335,11 @@ void multiply(mat4& out, const mat4& a, const mat4& b) {
     out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
 }
 
-void transformMat4(vec4<double>& out, vec4<double>& a, mat4& m) {
-    out.x = m[0] * a.x + m[4] * a.y + m[8] * a.z + m[12] * a.w;
-    out.y = m[1] * a.x + m[5] * a.y + m[9] * a.z + m[13] * a.w;
-    out.z = m[2] * a.x + m[6] * a.y + m[10] * a.z + m[14] * a.w;
-    out.w = m[3] * a.x + m[7] * a.y + m[11] * a.z + m[15] * a.w;
+void transformMat4(vec4& out, const vec4& a, const mat4& m) {
+    out[0] = m[0] * a[0] + m[4] * a[1] + m[8] * a[2] + m[12] * a[3];
+    out[1] = m[1] * a[0] + m[5] * a[1] + m[9] * a[2] + m[13] * a[3];
+    out[2] = m[2] * a[0] + m[6] * a[1] + m[10] * a[2] + m[14] * a[3];
+    out[3] = m[3] * a[0] + m[7] * a[1] + m[11] * a[2] + m[15] * a[3];
 }
 
 } // namespace matrix
diff --git a/src/mbgl/util/mat4.hpp b/src/mbgl/util/mat4.hpp
index ff8e65224c..80bd912554 100644
--- a/src/mbgl/util/mat4.hpp
+++ b/src/mbgl/util/mat4.hpp
@@ -23,12 +23,11 @@
 #ifndef MBGL_UTIL_MAT4
 #define MBGL_UTIL_MAT4
 
-#include <mbgl/util/vec.hpp>
-
 #include <array>
 
 namespace mbgl {
 
+using vec4 = std::array<double, 4>;
 using mat4 = std::array<double, 16>;
 
 namespace matrix {
@@ -45,7 +44,7 @@ void rotate_z(mat4& out, const mat4& a, double rad);
 void scale(mat4& out, const mat4& a, double x, double y, double z);
 void multiply(mat4& out, const mat4& a, const mat4& b);
 
-void transformMat4(vec4<double>& out, vec4<double>& a, mat4& m);
+void transformMat4(vec4& out, const vec4& a, const mat4& m);
 
 } // namespace matrix
 } // namespace mbgl
diff --git a/src/mbgl/util/math.hpp b/src/mbgl/util/math.hpp
index 6c6b02d126..f93743f211 100644
--- a/src/mbgl/util/math.hpp
+++ b/src/mbgl/util/math.hpp
@@ -5,7 +5,7 @@
 #include <array>
 #include <limits>
 
-#include <mbgl/util/vec.hpp>
+#include <mbgl/util/geometry.hpp>
 
 namespace mbgl {
 namespace util {
@@ -15,17 +15,12 @@ namespace util {
 // Find the angle of the two vectors, solving the formula for the cross product
 // a x b = |a||b|sin(θ) for θ.
 template <typename T = double, typename S>
-inline T angle_between(S ax, S ay, S bx, S by) {
-    return std::atan2((ax * by - ay * bx), ax * bx + ay * by);
+inline T angle_between(const Point<S>& a, const Point<S>& b) {
+    return std::atan2((a.x * b.y - a.y * b.x), a.x * b.x + a.y * b.y);
 }
 
 template <typename T = double, typename S>
-inline T angle_between(const vec2<S>& a, const vec2<S>& b) {
-    return angle_between(a.x, a.y, b.x, b.y);
-}
-
-template <typename T = double, typename S>
-inline T angle_to(const vec2<S>& a, const vec2<S>& b) {
+inline T angle_to(const Point<S>& a, const Point<S>& b) {
     return std::atan2(a.y - b.y, a.x - b.x);
 }
 
@@ -39,7 +34,7 @@ inline std::array<T, 2> flip(const std::array<T, 2>& c) {
 }
 
 template <typename T, typename S1, typename S2>
-inline vec2<T> normal(const S1& a, const S2& b) {
+inline Point<T> normal(const S1& a, const S2& b) {
     T dx = b.x - a.x;
     T dy = b.y - a.y;
     T c = std::sqrt(dx * dx + dy * dy);
@@ -102,6 +97,11 @@ inline T rotate(const T& a, S angle) {
 }
 
 template <typename T>
+inline Point<T> matrixMultiply(const std::array<T, 4>& m, const Point<T>& p) {
+    return Point<T>(m[0] * p.x + m[1] * p.y, m[2] * p.x + m[3] * p.y);
+}
+
+template <typename T>
 T smoothstep(T edge0, T edge1, T x) {
     T t = clamp((x - edge0) / (edge1 - edge0), T(0), T(1));
     return t * t * (T(3) - T(2) * t);
diff --git a/src/mbgl/util/tile_cover.cpp b/src/mbgl/util/tile_cover.cpp
index f2bda3f45b..6cd5d4b4ab 100644
--- a/src/mbgl/util/tile_cover.cpp
+++ b/src/mbgl/util/tile_cover.cpp
@@ -1,5 +1,4 @@
 #include <mbgl/util/tile_cover.hpp>
-#include <mbgl/util/vec.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/interpolate.hpp>
 #include <mbgl/map/transform_state.hpp>
diff --git a/src/mbgl/util/vec.hpp b/src/mbgl/util/vec.hpp
deleted file mode 100644
index 40d540fca4..0000000000
--- a/src/mbgl/util/vec.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-#ifndef MBGL_UTIL_VEC
-#define MBGL_UTIL_VEC
-
-#include <limits>
-#include <type_traits>
-#include <cmath>
-#include <cstdint>
-#include <array>
-
-namespace mbgl {
-
-template <typename T = double>
-struct vec2 {
-    struct null {};
-    typedef T Type;
-
-    T x, y;
-
-    inline vec2() = default;
-
-    template<typename U = T, typename std::enable_if<std::numeric_limits<U>::has_quiet_NaN, int>::type = 0>
-    inline vec2(null) : x(std::numeric_limits<T>::quiet_NaN()), y(std::numeric_limits<T>::quiet_NaN()) {}
-
-    template<typename U = T, typename std::enable_if<!std::numeric_limits<U>::has_quiet_NaN, int>::type = 0>
-    inline vec2(null) : x(std::numeric_limits<T>::min()), y(std::numeric_limits<T>::min()) {}
-
-    inline vec2(const vec2& o) = default;
-
-    template<typename U>
-    inline vec2(const U& u) : x(u.x), y(u.y) {}
-
-    inline vec2(T x_, T y_) : x(x_), y(y_) {}
-
-    inline bool operator==(const vec2& rhs) const {
-        return x == rhs.x && y == rhs.y;
-    }
-
-    template <typename O>
-    inline typename std::enable_if<std::is_arithmetic<O>::value, vec2>::type
-    operator*(O o) const {
-        return {x * o, y * o};
-    }
-
-    inline void operator*=(T o) {
-        x *= o;
-        y *= o;
-    }
-
-    template <typename O>
-    inline typename std::enable_if<std::is_arithmetic<O>::value, vec2>::type
-    operator/(O o) const {
-        return {x / o, y / o};
-    }
-
-    inline void operator/=(T o) {
-        x /= o;
-        y /= o;
-    }
-
-    inline vec2<T> operator *(const std::array<float, 16>& matrix) {
-        return { x * matrix[0] + y * matrix[4] + matrix[12], x * matrix[1] + y * matrix[5] + matrix[13] };
-    }
-
-    template <typename O>
-    inline typename std::enable_if<std::is_arithmetic<O>::value, vec2>::type
-    operator-(O o) const {
-        return {x - o, y - o};
-    }
-
-    template <typename O>
-    inline typename std::enable_if<!std::is_arithmetic<O>::value, vec2>::type
-    operator-(const O &o) const {
-        return vec2<T>(x - o.x, y - o.y);
-    }
-
-    template <typename O>
-    inline typename std::enable_if<!std::is_arithmetic<O>::value, vec2>::type
-    operator+(const O &o) const {
-        return vec2<T>(x + o.x, y + o.y);
-    }
-
-    template <typename M>
-    inline vec2 matMul(const M &m) const {
-        return {m[0] * x + m[1] * y, m[2] * x + m[3] * y};
-    }
-
-    template<typename U = T, typename std::enable_if<std::numeric_limits<U>::has_quiet_NaN, int>::type = 0>
-    explicit operator bool() const {
-        return !std::isnan(x) && !std::isnan(y);
-    }
-
-    template<typename U = T, typename std::enable_if<!std::numeric_limits<U>::has_quiet_NaN, int>::type = 0>
-    explicit operator bool() const {
-        return x != std::numeric_limits<T>::min() && y != std::numeric_limits<T>::min();
-    }
-};
-
-template <typename T = double>
-struct vec4 {
-    T x, y, z, w;
-
-    inline vec4() = default;
-    inline vec4(const vec4& o) : x(o.x), y(o.y), z(o.z), w(o.w) {}
-    inline vec4(T x_, T y_, T z_, T w_) : x(x_), y(y_), z(z_), w(w_) {}
-    inline bool operator==(const vec4& rhs) const {
-        return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w;
-    }
-
-    template<typename U = T, typename std::enable_if<std::numeric_limits<U>::has_quiet_NaN, int>::type = 0>
-    explicit operator bool() const {
-        return !std::isnan(x) && !std::isnan(y) && !std::isnan(z) && !std::isnan(w);
-    }
-
-    template<typename U = T, typename std::enable_if<!std::numeric_limits<U>::has_quiet_NaN, int>::type = 0>
-    explicit operator bool() const {
-        return x != std::numeric_limits<T>::min()
-            && y != std::numeric_limits<T>::min()
-            && z != std::numeric_limits<T>::min()
-            && w != std::numeric_limits<T>::min();
-    }
-};
-
-
-} // namespace mbgl
-
-#endif // MBGL_UTIL_VEC
diff --git a/test/map/transform.cpp b/test/map/transform.cpp
index 104ad7085f..a3a62e7ad8 100644
--- a/test/map/transform.cpp
+++ b/test/map/transform.cpp
@@ -79,9 +79,6 @@ TEST(Transform, InvalidLatLng) {
     ASSERT_DOUBLE_EQ(10, transform.getLatLng().latitude);
     ASSERT_DOUBLE_EQ(8, transform.getLatLng().longitude);
     ASSERT_DOUBLE_EQ(4, transform.getScale());
-
-    ASSERT_FALSE(transform.latLngToScreenCoordinate(LatLng::null()));
-    ASSERT_FALSE(transform.screenCoordinateToLatLng(ScreenCoordinate::null()));
 }
 
 
@@ -225,7 +222,7 @@ TEST(Transform, Anchor) {
     ASSERT_DOUBLE_EQ(10, transform.getZoom());
     ASSERT_DOUBLE_EQ(0, transform.getAngle());
 
-    const ScreenCoordinate invalidAnchorPoint = ScreenCoordinate::null();
+    const optional<ScreenCoordinate> invalidAnchorPoint {};
     const ScreenCoordinate anchorPoint = { 150, 150 };
 
     const LatLng anchorLatLng = transform.getState().screenCoordinateToLatLng(anchorPoint);