Tile::ID ⇢ TileID

This allows making both Tile and TileID private.

44 files changed, 371 insertions, 348 deletions

diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index f8e082f693..129d463b25 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -192,7 +192,7 @@ private:
 
     void processTasks();
 
-    void updateAnnotationTiles(const std::vector<Tile::ID>&);
+    void updateAnnotationTiles(const std::vector<TileID>&);
 
     enum class Mode : uint8_t {
         None, // we're not doing any processing
diff --git a/include/mbgl/map/tile.hpp b/include/mbgl/map/tile.hpp
deleted file mode 100644
index 146ebe6ad7..0000000000
--- a/include/mbgl/map/tile.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-#ifndef MBGL_MAP_TILE
-#define MBGL_MAP_TILE
-
-#include <mbgl/util/mat4.hpp>
-#include <mbgl/util/noncopyable.hpp>
-#include <mbgl/util/ptr.hpp>
-
-#include <cstdint>
-#include <bitset>
-#include <cmath>
-#include <cstdint>
-#include <forward_list>
-#include <iosfwd>
-#include <string>
-#include <functional>
-
-namespace mbgl {
-
-class TileData;
-struct box;
-
-struct ClipID {
-    inline ClipID() {}
-    inline ClipID(const std::string &mask_, const std::string &reference_) : mask(mask_), reference(reference_) {}
-
-    std::bitset<8> mask;
-    std::bitset<8> reference;
-
-    inline bool operator==(const ClipID &other) const {
-        return mask == other.mask && reference == other.reference;
-    }
-};
-
-class Tile : private util::noncopyable {
-public:
-    struct ID {
-        const int16_t w = 0;
-        const int8_t z = 0;
-        const int32_t x = 0, y = 0;
-
-        inline explicit ID(int8_t z_, int32_t x_, int32_t y_)
-            : w((x_ < 0 ? x_ - (1 << z_) + 1 : x_) / (1 << z_)), z(z_), x(x_), y(y_) {}
-
-        inline uint64_t to_uint64() const {
-            return ((std::pow(2, z) * y + x) * 32) + z;
-        }
-
-        struct Hash {
-            std::size_t operator()(ID const& i) const {
-                return std::hash<uint64_t>()(i.to_uint64());
-            }
-        };
-
-        inline bool operator==(const ID& rhs) const {
-            return w == rhs.w && z == rhs.z && x == rhs.x && y == rhs.y;
-        }
-
-        inline bool operator!=(const ID& rhs) const {
-            return !operator==(rhs);
-        }
-
-        inline bool operator<(const ID &rhs) const {
-            if (w != rhs.w) return w < rhs.w;
-            if (z != rhs.z) return z < rhs.z;
-            if (x != rhs.x) return x < rhs.x;
-            return y < rhs.y;
-        }
-
-        ID parent(int8_t z) const;
-        ID normalized() const;
-        std::forward_list<ID> children(int32_t z) const;
-        bool isChildOf(const Tile::ID &id) const;
-        operator std::string() const;
-    };
-
-    static std::forward_list<Tile::ID> cover(int8_t z, const box& bounds);
-
-public:
-    explicit Tile(const ID& id);
-
-public:
-    const Tile::ID id;
-    ClipID clip;
-    mat4 matrix;
-    util::ptr<TileData> data;
-};
-
-}
-
-#endif
diff --git a/include/mbgl/map/transform_state.hpp b/include/mbgl/map/transform_state.hpp
index c1a324a899..f6a00a4a3d 100644
--- a/include/mbgl/map/transform_state.hpp
+++ b/include/mbgl/map/transform_state.hpp
@@ -1,8 +1,6 @@
 #ifndef MBGL_MAP_TRANSFORM_STATE
 #define MBGL_MAP_TRANSFORM_STATE
 
-#include <mbgl/map/tile.hpp>
-
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/geo.hpp>
 #include <mbgl/util/vec.hpp>
@@ -13,12 +11,15 @@
 
 namespace mbgl {
 
+class TileID;
+struct box;
+
 class TransformState {
     friend class Transform;
 
 public:
     // Matrix
-    void matrixFor(mat4& matrix, const Tile::ID& id) const;
+    void matrixFor(mat4& matrix, const TileID& id) const;
     box cornersToBox(uint32_t z) const;
 
     // Dimensions
diff --git a/src/mbgl/map/annotation.cpp b/src/mbgl/map/annotation.cpp
index fa26af785f..b921c08f74 100644
--- a/src/mbgl/map/annotation.cpp
+++ b/src/mbgl/map/annotation.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/map/annotation.hpp>
 #include <mbgl/map/map.hpp>
+#include <mbgl/map/tile_id.hpp>
 #include <mbgl/map/live_tile.hpp>
 #include <mbgl/util/ptr.hpp>
 #include <mbgl/util/std.hpp>
@@ -29,7 +30,7 @@ private:
 private:
     const AnnotationType type = AnnotationType::Point;
     const AnnotationSegments geometry;
-    std::unordered_map<Tile::ID, std::weak_ptr<const LiveTileFeature>, Tile::ID::Hash> tileFeatures;
+    std::unordered_map<TileID, std::weak_ptr<const LiveTileFeature>, TileID::Hash> tileFeatures;
     const LatLngBounds bounds;
 };
 
@@ -82,7 +83,7 @@ vec2<double> AnnotationManager::projectPoint(const LatLng& point) {
     return { x, y };
 }
 
-std::pair<std::vector<Tile::ID>, AnnotationIDs> AnnotationManager::addPointAnnotations(
+std::pair<std::vector<TileID>, AnnotationIDs> AnnotationManager::addPointAnnotations(
     const std::vector<LatLng>& points, const std::vector<std::string>& symbols, const Map& map) {
     std::lock_guard<std::mutex> lock(mtx);
 
@@ -97,7 +98,7 @@ std::pair<std::vector<Tile::ID>, AnnotationIDs> AnnotationManager::addPointAnnot
     std::vector<uint32_t> annotationIDs;
     annotationIDs.reserve(points.size());
 
-    std::vector<Tile::ID> affectedTiles;
+    std::vector<TileID> affectedTiles;
 
     for (size_t i = 0; i < points.size(); ++i) {
         const uint32_t annotationID = nextID();
@@ -121,7 +122,7 @@ std::pair<std::vector<Tile::ID>, AnnotationIDs> AnnotationManager::addPointAnnot
 
         for (int8_t z = maxZoom; z >= 0; z--) {
             affectedTiles.emplace_back(z, x, y);
-            Tile::ID tileID = affectedTiles.back();
+            TileID tileID = affectedTiles.back();
 
             // calculate tile coordinate
             const Coordinate coordinate(extent * (p.x * z2 - x), extent * (p.y * z2 - y));
@@ -180,10 +181,10 @@ std::pair<std::vector<Tile::ID>, AnnotationIDs> AnnotationManager::addPointAnnot
     return std::make_pair(affectedTiles, annotationIDs);
 }
 
-std::vector<Tile::ID> AnnotationManager::removeAnnotations(const AnnotationIDs& ids, const Map& map) {
+std::vector<TileID> AnnotationManager::removeAnnotations(const AnnotationIDs& ids, const Map& map) {
     std::lock_guard<std::mutex> lock(mtx);
 
-    std::vector<Tile::ID> affectedTiles;
+    std::vector<TileID> affectedTiles;
 
     std::vector<uint32_t> z2s;
     uint8_t zoomCount = map.getMaxZoom() + 1;
@@ -208,7 +209,7 @@ std::vector<Tile::ID> AnnotationManager::removeAnnotations(const AnnotationIDs&
                 p = projectPoint(latLng);
                 x = z2s[z] * p.x;
                 y = z2s[z] * p.y;
-                Tile::ID tid(z, x, y);
+                TileID tid(z, x, y);
                 // erase annotation from tile's list
                 auto& tileAnnotations = tiles[tid].first;
                 tileAnnotations.erase(annotationID);
@@ -225,7 +226,7 @@ std::vector<Tile::ID> AnnotationManager::removeAnnotations(const AnnotationIDs&
         }
     }
 
-    // Tile::IDs for tiles that need refreshed.
+    // TileIDs for tiles that need refreshed.
     return affectedTiles;
 }
 
@@ -239,13 +240,13 @@ std::vector<uint32_t> AnnotationManager::getAnnotationsInBounds(const LatLngBoun
     const vec2<double> nePoint = projectPoint(queryBounds.ne);
 
     // tiles number y from top down
-    const Tile::ID nwTile(z, swPoint.x * z2, nePoint.y * z2);
-    const Tile::ID seTile(z, nePoint.x * z2, swPoint.y * z2);
+    const TileID nwTile(z, swPoint.x * z2, nePoint.y * z2);
+    const TileID seTile(z, nePoint.x * z2, swPoint.y * z2);
 
     std::vector<uint32_t> matchingAnnotations;
 
     for (auto& tile : tiles) {
-        Tile::ID id = tile.first;
+        TileID id = tile.first;
         if (id.z == z) {
             if (id.x >= nwTile.x && id.x <= seTile.x && id.y >= nwTile.y && id.y <= seTile.y) {
                 if (id.x > nwTile.x && id.x < seTile.x && id.y > nwTile.y && id.y < seTile.y) {
@@ -292,7 +293,7 @@ LatLngBounds AnnotationManager::getBoundsForAnnotations(const AnnotationIDs& ids
     return bounds;
 }
 
-const LiveTile* AnnotationManager::getTile(Tile::ID const& id) {
+const LiveTile* AnnotationManager::getTile(const TileID& id) {
     std::lock_guard<std::mutex> lock(mtx);
 
     const auto tile_it = tiles.find(id);
diff --git a/include/mbgl/map/annotation.hpp b/src/mbgl/map/annotation.hpp
index efd91d9087..f1596dbdff 100644
--- a/include/mbgl/map/annotation.hpp
+++ b/src/mbgl/map/annotation.hpp
@@ -1,7 +1,7 @@
 #ifndef MBGL_MAP_ANNOTATIONS
 #define MBGL_MAP_ANNOTATIONS
 
-#include <mbgl/map/tile.hpp>
+#include <mbgl/map/tile_id.hpp>
 #include <mbgl/util/geo.hpp>
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/std.hpp>
@@ -28,13 +28,13 @@ public:
     ~AnnotationManager();
 
     void setDefaultPointAnnotationSymbol(const std::string& symbol);
-    std::pair<std::vector<Tile::ID>, AnnotationIDs> addPointAnnotations(
+    std::pair<std::vector<TileID>, AnnotationIDs> addPointAnnotations(
         const std::vector<LatLng>&, const std::vector<std::string>& symbols, const Map&);
-    std::vector<Tile::ID> removeAnnotations(const AnnotationIDs&, const Map&);
+    std::vector<TileID> removeAnnotations(const AnnotationIDs&, const Map&);
     AnnotationIDs getAnnotationsInBounds(const LatLngBounds&, const Map&) const;
     LatLngBounds getBoundsForAnnotations(const AnnotationIDs&) const;
 
-    const LiveTile* getTile(Tile::ID const& id);
+    const LiveTile* getTile(const TileID& id);
 
     static const std::string layerID;
 
@@ -46,7 +46,7 @@ private:
     mutable std::mutex mtx;
     std::string defaultPointAnnotationSymbol;
     std::unordered_map<uint32_t, std::unique_ptr<Annotation>> annotations;
-    std::unordered_map<Tile::ID, std::pair<std::unordered_set<uint32_t>, std::unique_ptr<LiveTile>>, Tile::ID::Hash> tiles;
+    std::unordered_map<TileID, std::pair<std::unordered_set<uint32_t>, std::unique_ptr<LiveTile>>, TileID::Hash> tiles;
     uint32_t nextID_ = 0;
 };
 
diff --git a/src/mbgl/map/live_tile_data.cpp b/src/mbgl/map/live_tile_data.cpp
index 71b5a2e1b3..6456e51538 100644
--- a/src/mbgl/map/live_tile_data.cpp
+++ b/src/mbgl/map/live_tile_data.cpp
@@ -8,7 +8,7 @@
 
 using namespace mbgl;
 
-LiveTileData::LiveTileData(Tile::ID const& id_,
+LiveTileData::LiveTileData(const TileID& id_,
                            AnnotationManager& annotationManager_,
                            float mapMaxZoom,
                            util::ptr<Style> style_,
diff --git a/src/mbgl/map/live_tile_data.hpp b/src/mbgl/map/live_tile_data.hpp
index 7874d6ff55..d40cfdfd69 100644
--- a/src/mbgl/map/live_tile_data.hpp
+++ b/src/mbgl/map/live_tile_data.hpp
@@ -9,7 +9,7 @@ class AnnotationManager;
 
 class LiveTileData : public VectorTileData {
 public:
-    LiveTileData(Tile::ID const&,
+    LiveTileData(const TileID&,
                  AnnotationManager&,
                  float mapMaxZoom,
                  util::ptr<Style>,
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index 333be1e030..8697523ac1 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -616,7 +616,7 @@ LatLngBounds Map::getBoundsForAnnotations(const std::vector<uint32_t>& annotatio
     });
 }
 
-void Map::updateAnnotationTiles(const std::vector<Tile::ID>& ids) {
+void Map::updateAnnotationTiles(const std::vector<TileID>& ids) {
     assert(Environment::currentlyOn(ThreadType::Map));
     if (!style) return;
     for (const auto &source : style->sources) {
diff --git a/src/mbgl/map/raster_tile_data.cpp b/src/mbgl/map/raster_tile_data.cpp
index b8862e6dd8..2531f5130b 100644
--- a/src/mbgl/map/raster_tile_data.cpp
+++ b/src/mbgl/map/raster_tile_data.cpp
@@ -4,7 +4,7 @@
 
 using namespace mbgl;
 
-RasterTileData::RasterTileData(Tile::ID const &id_, TexturePool &texturePool,
+RasterTileData::RasterTileData(const TileID& id_, TexturePool &texturePool,
                                const SourceInfo &source_)
     : TileData(id_, source_), bucket(texturePool, layout) {
 }
diff --git a/src/mbgl/map/raster_tile_data.hpp b/src/mbgl/map/raster_tile_data.hpp
index 76bc1bb5aa..dab2b7b842 100644
--- a/src/mbgl/map/raster_tile_data.hpp
+++ b/src/mbgl/map/raster_tile_data.hpp
@@ -1,7 +1,6 @@
 #ifndef MBGL_MAP_RASTER_TILE_DATA
 #define MBGL_MAP_RASTER_TILE_DATA
 
-#include <mbgl/map/tile.hpp>
 #include <mbgl/map/tile_data.hpp>
 #include <mbgl/style/style_layout.hpp>
 #include <mbgl/renderer/raster_bucket.hpp>
@@ -17,7 +16,7 @@ class RasterTileData : public TileData {
     friend class TileParser;
 
 public:
-    RasterTileData(Tile::ID const &id, TexturePool &, const SourceInfo &);
+    RasterTileData(const TileID&, TexturePool&, const SourceInfo&);
     ~RasterTileData();
 
     void parse() override;
diff --git a/src/mbgl/map/source.cpp b/src/mbgl/map/source.cpp
index 282fd30938..fac42d9e47 100644
--- a/src/mbgl/map/source.cpp
+++ b/src/mbgl/map/source.cpp
@@ -2,6 +2,7 @@
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/environment.hpp>
 #include <mbgl/map/transform.hpp>
+#include <mbgl/map/tile.hpp>
 #include <mbgl/renderer/painter.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/raster.hpp>
@@ -96,7 +97,7 @@ void SourceInfo::parseTileJSONProperties(const rapidjson::Value& value) {
     parse(value, bounds, "bounds");
 }
 
-std::string SourceInfo::tileURL(const Tile::ID& id, float pixelRatio) const {
+std::string SourceInfo::tileURL(const TileID& id, float pixelRatio) const {
     std::string result = tiles.at((id.x + id.y) % tiles.size());
     result = util::mapbox::normalizeTileURL(result, url, type);
     result = util::replaceTokens(result, [&](const std::string &token) -> std::string {
@@ -119,6 +120,8 @@ Source::Source()
 {
 }
 
+Source::~Source() {}
+
 // Note: This is a separate function that must be called exactly once after creation
 // The reason this isn't part of the constructor is that calling shared_from_this() in
 // the constructor fails.
@@ -154,8 +157,8 @@ void Source::load(const std::string& accessToken,
     });
 }
 
-void Source::updateClipIDs(const std::map<Tile::ID, ClipID> &mapping) {
-    std::for_each(tiles.begin(), tiles.end(), [&mapping](std::pair<const Tile::ID, std::unique_ptr<Tile>> &pair) {
+void Source::updateClipIDs(const std::map<TileID, ClipID> &mapping) {
+    std::for_each(tiles.begin(), tiles.end(), [&mapping](std::pair<const TileID, std::unique_ptr<Tile>> &pair) {
         Tile &tile = *pair.second;
         auto it = mapping.find(tile.id);
         if (it != mapping.end()) {
@@ -203,10 +206,10 @@ void Source::finishRender(Painter &painter) {
     }
 }
 
-std::forward_list<Tile::ID> Source::getIDs() const {
-    std::forward_list<Tile::ID> ptrs;
+std::forward_list<TileID> Source::getIDs() const {
+    std::forward_list<TileID> ptrs;
 
-    std::transform(tiles.begin(), tiles.end(), std::front_inserter(ptrs), [](const std::pair<const Tile::ID, std::unique_ptr<Tile>> &pair) {
+    std::transform(tiles.begin(), tiles.end(), std::front_inserter(ptrs), [](const std::pair<const TileID, std::unique_ptr<Tile>> &pair) {
         Tile &tile = *pair.second;
         return tile.id;
     });
@@ -225,7 +228,7 @@ std::forward_list<Tile *> Source::getLoadedTiles() const {
 }
 
 
-TileData::State Source::hasTile(const Tile::ID& id) {
+TileData::State Source::hasTile(const TileID& id) {
     auto it = tiles.find(id);
     if (it != tiles.end()) {
         Tile &tile = *it->second;
@@ -241,7 +244,7 @@ TileData::State Source::addTile(Map &map, uv::worker &worker,
                                 util::ptr<Style> style, GlyphAtlas &glyphAtlas,
                                 GlyphStore &glyphStore, SpriteAtlas &spriteAtlas,
                                 util::ptr<Sprite> sprite, TexturePool &texturePool,
-                                const Tile::ID &id, std::function<void()> callback) {
+                                const TileID &id, std::function<void()> callback) {
     const TileData::State state = hasTile(id);
 
     if (state != TileData::State::invalid) {
@@ -253,7 +256,7 @@ TileData::State Source::addTile(Map &map, uv::worker &worker,
 
     // We couldn't find the tile in the list. Create a new one.
     // Try to find the associated TileData object.
-    const Tile::ID normalized_id = id.normalized();
+    const TileID normalized_id = id.normalized();
 
     auto it = tile_data.find(normalized_id);
     if (it != tile_data.end()) {
@@ -300,7 +303,7 @@ int32_t Source::coveringZoomLevel(const TransformState& state) const {
     return std::floor(getZoom(state));
 }
 
-std::forward_list<Tile::ID> Source::coveringTiles(const TransformState& state) const {
+std::forward_list<TileID> Source::coveringTiles(const TransformState& state) const {
     int32_t z = coveringZoomLevel(state);
 
     if (z < info.min_zoom) return {{}};
@@ -310,9 +313,9 @@ std::forward_list<Tile::ID> Source::coveringTiles(const TransformState& state) c
     box points = state.cornersToBox(z);
     const vec2<double>& center = points.center;
 
-    std::forward_list<Tile::ID> covering_tiles = Tile::cover(z, points);
+    std::forward_list<TileID> covering_tiles = Tile::cover(z, points);
 
-    covering_tiles.sort([&center](const Tile::ID& a, const Tile::ID& b) {
+    covering_tiles.sort([&center](const TileID& a, const TileID& b) {
         // Sorts by distance from the box center
         return std::fabs(a.x - center.x) + std::fabs(a.y - center.y) <
                std::fabs(b.x - center.x) + std::fabs(b.y - center.y);
@@ -330,7 +333,7 @@ std::forward_list<Tile::ID> Source::coveringTiles(const TransformState& state) c
  *
  * @return boolean Whether the children found completely cover the tile.
  */
-bool Source::findLoadedChildren(const Tile::ID& id, int32_t maxCoveringZoom, std::forward_list<Tile::ID>& retain) {
+bool Source::findLoadedChildren(const TileID& id, int32_t maxCoveringZoom, std::forward_list<TileID>& retain) {
     bool complete = true;
     int32_t z = id.z;
     auto ids = id.children(z + 1);
@@ -358,9 +361,9 @@ bool Source::findLoadedChildren(const Tile::ID& id, int32_t maxCoveringZoom, std
  *
  * @return boolean Whether a parent was found.
  */
-bool Source::findLoadedParent(const Tile::ID& id, int32_t minCoveringZoom, std::forward_list<Tile::ID>& retain) {
+bool Source::findLoadedParent(const TileID& id, int32_t minCoveringZoom, std::forward_list<TileID>& retain) {
     for (int32_t z = id.z - 1; z >= minCoveringZoom; --z) {
-        const Tile::ID parent_id = id.parent(z);
+        const TileID parent_id = id.parent(z);
         const TileData::State state = hasTile(parent_id);
         if (state == TileData::State::parsed) {
             retain.emplace_front(parent_id);
@@ -384,7 +387,7 @@ void Source::update(Map &map,
     }
 
     int32_t zoom = std::floor(getZoom(map.getState()));
-    std::forward_list<Tile::ID> required = coveringTiles(map.getState());
+    std::forward_list<TileID> required = coveringTiles(map.getState());
 
     // Determine the overzooming/underzooming amounts.
     int32_t minCoveringZoom = util::clamp<int32_t>(zoom - 10, info.min_zoom, info.max_zoom);
@@ -393,7 +396,7 @@ void Source::update(Map &map,
     // Retain is a list of tiles that we shouldn't delete, even if they are not
     // the most ideal tile for the current viewport. This may include tiles like
     // parent or child tiles that are *already* loaded.
-    std::forward_list<Tile::ID> retain(required);
+    std::forward_list<TileID> retain(required);
 
     // Add existing child/parent tiles if the actual tile is not yet loaded
     for (const auto& id : required) {
@@ -418,8 +421,8 @@ void Source::update(Map &map,
 
     // Remove tiles that we definitely don't need, i.e. tiles that are not on
     // the required list.
-    std::set<Tile::ID> retain_data;
-    util::erase_if(tiles, [&retain, &retain_data](std::pair<const Tile::ID, std::unique_ptr<Tile>> &pair) {
+    std::set<TileID> retain_data;
+    util::erase_if(tiles, [&retain, &retain_data](std::pair<const TileID, std::unique_ptr<Tile>> &pair) {
         Tile &tile = *pair.second;
         bool obsolete = std::find(retain.begin(), retain.end(), tile.id) == retain.end();
         if (!obsolete) {
@@ -429,7 +432,7 @@ void Source::update(Map &map,
     });
 
     // Remove all the expired pointers from the set.
-    util::erase_if(tile_data, [&retain_data](std::pair<const Tile::ID, std::weak_ptr<TileData>> &pair) {
+    util::erase_if(tile_data, [&retain_data](std::pair<const TileID, std::weak_ptr<TileData>> &pair) {
         const util::ptr<TileData> tile = pair.second.lock();
         if (!tile) {
             return true;
@@ -447,7 +450,7 @@ void Source::update(Map &map,
     updated = map.getTime();
 }
 
-void Source::invalidateTiles(const std::vector<Tile::ID>& ids) {
+void Source::invalidateTiles(const std::vector<TileID>& ids) {
     for (auto& id : ids) {
         tiles.erase(id);
         tile_data.erase(id);
diff --git a/src/mbgl/map/source.hpp b/src/mbgl/map/source.hpp
index c853ac295f..7b6e401217 100644
--- a/src/mbgl/map/source.hpp
+++ b/src/mbgl/map/source.hpp
@@ -1,7 +1,7 @@
 #ifndef MBGL_MAP_SOURCE
 #define MBGL_MAP_SOURCE
 
-#include <mbgl/map/tile.hpp>
+#include <mbgl/map/tile_id.hpp>
 #include <mbgl/map/tile_data.hpp>
 #include <mbgl/style/types.hpp>
 
@@ -30,6 +30,8 @@ class Style;
 class Painter;
 class StyleLayer;
 class TransformState;
+class Tile;
+struct ClipID;
 struct box;
 
 class SourceInfo : private util::noncopyable {
@@ -45,12 +47,13 @@ public:
     std::array<float, 4> bounds = {{-180, -90, 180, 90}};
 
     void parseTileJSONProperties(const rapidjson::Value&);
-    std::string tileURL(const Tile::ID& id, float pixelRatio) const;
+    std::string tileURL(const TileID& id, float pixelRatio) const;
 };
 
 class Source : public std::enable_shared_from_this<Source>, private util::noncopyable {
 public:
     Source();
+    ~Source();
 
     void load(const std::string& accessToken,
               Environment&,
@@ -59,7 +62,7 @@ public:
     void update(Map &, uv::worker &, util::ptr<Style>, GlyphAtlas &, GlyphStore &,
                 SpriteAtlas &, util::ptr<Sprite>, TexturePool &, std::function<void()> callback);
 
-    void invalidateTiles(const std::vector<Tile::ID>&);
+    void invalidateTiles(const std::vector<TileID>&);
 
     void updateMatrices(const mat4 &projMatrix, const TransformState &transform);
     void drawClippingMasks(Painter &painter);
@@ -67,24 +70,24 @@ public:
     void render(Painter &painter, const StyleLayer &layer_desc);
     void finishRender(Painter &painter);
 
-    std::forward_list<Tile::ID> getIDs() const;
+    std::forward_list<TileID> getIDs() const;
     std::forward_list<Tile *> getLoadedTiles() const;
-    void updateClipIDs(const std::map<Tile::ID, ClipID> &mapping);
+    void updateClipIDs(const std::map<TileID, ClipID> &mapping);
 
     SourceInfo info;
     bool enabled;
 
 private:
-    bool findLoadedChildren(const Tile::ID& id, int32_t maxCoveringZoom, std::forward_list<Tile::ID>& retain);
-    bool findLoadedParent(const Tile::ID& id, int32_t minCoveringZoom, std::forward_list<Tile::ID>& retain);
+    bool findLoadedChildren(const TileID& id, int32_t maxCoveringZoom, std::forward_list<TileID>& retain);
+    bool findLoadedParent(const TileID& id, int32_t minCoveringZoom, std::forward_list<TileID>& retain);
     int32_t coveringZoomLevel(const TransformState&) const;
-    std::forward_list<Tile::ID> coveringTiles(const TransformState&) const;
+    std::forward_list<TileID> coveringTiles(const TransformState&) const;
 
     TileData::State addTile(Map &, uv::worker &, util::ptr<Style>, GlyphAtlas &,
                             GlyphStore &, SpriteAtlas &, util::ptr<Sprite>, TexturePool &,
-                            const Tile::ID &, std::function<void()> callback);
+                            const TileID &, std::function<void()> callback);
 
-    TileData::State hasTile(const Tile::ID& id);
+    TileData::State hasTile(const TileID& id);
 
     double getZoom(const TransformState &state) const;
 
@@ -93,8 +96,8 @@ private:
     // Stores the time when this source was most recently updated.
     TimePoint updated = TimePoint::min();
 
-    std::map<Tile::ID, std::unique_ptr<Tile>> tiles;
-    std::map<Tile::ID, std::weak_ptr<TileData>> tile_data;
+    std::map<TileID, std::unique_ptr<Tile>> tiles;
+    std::map<TileID, std::weak_ptr<TileData>> tile_data;
 };
 
 }
diff --git a/src/mbgl/map/tile.cpp b/src/mbgl/map/tile.cpp
index 9f31048857..3cc210f2a3 100644
--- a/src/mbgl/map/tile.cpp
+++ b/src/mbgl/map/tile.cpp
@@ -1,65 +1,15 @@
 #include <mbgl/map/tile.hpp>
 #include <mbgl/util/vec.hpp>
-#include <mbgl/util/string.hpp>
 #include <mbgl/util/box.hpp>
 
-
-#include <cassert>
-
 using namespace mbgl;
 
 #include <iostream>
 
-Tile::Tile(const ID& id_)
+Tile::Tile(const TileID& id_)
     : id(id_) {
 }
 
-Tile::ID Tile::ID::parent(int8_t parent_z) const {
-    assert(parent_z < z);
-    int32_t dim = std::pow(2, z - parent_z);
-    return Tile::ID{
-        parent_z,
-        (x >= 0 ? x : x - dim + 1) / dim,
-        y / dim
-    };
-}
-
-std::forward_list<Tile::ID> Tile::ID::children(int32_t child_z) const {
-    assert(child_z > z);
-    int32_t factor = std::pow(2, child_z - z);
-
-    std::forward_list<ID> child_ids;
-    for (int32_t ty = y * factor, y_max = (y + 1) * factor; ty < y_max; ++ty) {
-        for (int32_t tx = x * factor, x_max = (x + 1) * factor; tx < x_max; ++tx) {
-            child_ids.emplace_front(child_z, tx, ty);
-        }
-    }
-    return child_ids;
-}
-
-Tile::ID Tile::ID::normalized() const {
-    int32_t dim = std::pow(2, z);
-    int32_t nx = x, ny = y;
-    while (nx < 0) nx += dim;
-    while (nx >= dim) nx -= dim;
-    return ID { z, nx, ny };
-}
-
-bool Tile::ID::isChildOf(const Tile::ID &parent_id) const {
-    if (parent_id.z >= z || parent_id.w != w) {
-        return false;
-    }
-    int32_t scale = std::pow(2, z - parent_id.z);
-    return parent_id.x == ((x < 0 ? x - scale + 1 : x) / scale) &&
-           parent_id.y == y / scale;
-}
-
-
-Tile::ID::operator std::string() const {
-    return util::toString(z) + "/" + util::toString(x) + "/" + util::toString(y);
-}
-
-
 // Taken from polymaps src/Layer.js
 // https://github.com/simplegeo/polymaps/blob/master/src/Layer.js#L333-L383
 
@@ -121,9 +71,9 @@ static void scanTriangle(const mbgl::vec2<double> a, const mbgl::vec2<double> b,
     if (bc.dy) scanSpans(ca, bc, ymin, ymax, scanLine);
 }
 
-std::forward_list<Tile::ID> Tile::cover(int8_t z, const mbgl::box &bounds) {
+std::forward_list<TileID> Tile::cover(int8_t z, const mbgl::box &bounds) {
     int32_t tiles = 1 << z;
-    std::forward_list<mbgl::Tile::ID> t;
+    std::forward_list<mbgl::TileID> t;
 
     auto scanLine = [&](int32_t x0, int32_t x1, int32_t y) {
         int32_t x;
diff --git a/src/mbgl/map/tile.hpp b/src/mbgl/map/tile.hpp
new file mode 100644
index 0000000000..57ca8feb03
--- /dev/null
+++ b/src/mbgl/map/tile.hpp
@@ -0,0 +1,43 @@
+#ifndef MBGL_MAP_TILE
+#define MBGL_MAP_TILE
+
+#include <mbgl/util/mat4.hpp>
+#include <mbgl/util/noncopyable.hpp>
+#include <mbgl/util/ptr.hpp>
+#include <mbgl/map/tile_id.hpp>
+
+#include <bitset>
+#include <string>
+
+namespace mbgl {
+
+class TileData;
+struct box;
+
+struct ClipID {
+    inline ClipID() {}
+    inline ClipID(const std::string &mask_, const std::string &reference_) : mask(mask_), reference(reference_) {}
+
+    std::bitset<8> mask;
+    std::bitset<8> reference;
+
+    inline bool operator==(const ClipID &other) const {
+        return mask == other.mask && reference == other.reference;
+    }
+};
+
+class Tile : private util::noncopyable {
+public:
+    static std::forward_list<TileID> cover(int8_t z, const box& bounds);
+
+    explicit Tile(const TileID&);
+
+    const TileID id;
+    ClipID clip;
+    mat4 matrix;
+    util::ptr<TileData> data;
+};
+
+}
+
+#endif
diff --git a/src/mbgl/map/tile_data.cpp b/src/mbgl/map/tile_data.cpp
index a2e485a24a..fdec759938 100644
--- a/src/mbgl/map/tile_data.cpp
+++ b/src/mbgl/map/tile_data.cpp
@@ -8,7 +8,7 @@
 
 using namespace mbgl;
 
-TileData::TileData(Tile::ID const& id_, const SourceInfo& source_)
+TileData::TileData(const TileID& id_, const SourceInfo& source_)
     : id(id_),
       name(id),
       state(State::initial),
diff --git a/src/mbgl/map/tile_data.hpp b/src/mbgl/map/tile_data.hpp
index a5598fee3b..6fbc9ec3fb 100644
--- a/src/mbgl/map/tile_data.hpp
+++ b/src/mbgl/map/tile_data.hpp
@@ -1,7 +1,7 @@
 #ifndef MBGL_MAP_TILE_DATA
 #define MBGL_MAP_TILE_DATA
 
-#include <mbgl/map/tile.hpp>
+#include <mbgl/map/tile_id.hpp>
 #include <mbgl/renderer/debug_bucket.hpp>
 #include <mbgl/geometry/debug_font_buffer.hpp>
 
@@ -38,7 +38,7 @@ public:
         obsolete
     };
 
-    TileData(Tile::ID const &id, const SourceInfo &);
+    TileData(const TileID&, const SourceInfo&);
     ~TileData();
 
     void request(uv::worker&, float pixelRatio, std::function<void ()> callback);
@@ -55,7 +55,7 @@ public:
     virtual void render(Painter &painter, const StyleLayer &layer_desc, const mat4 &matrix) = 0;
     virtual bool hasData(StyleLayer const &layer_desc) const = 0;
 
-    const Tile::ID id;
+    const TileID id;
     const std::string name;
     std::atomic<State> state;
 
diff --git a/src/mbgl/map/tile_id.cpp b/src/mbgl/map/tile_id.cpp
new file mode 100644
index 0000000000..518ee14c42
--- /dev/null
+++ b/src/mbgl/map/tile_id.cpp
@@ -0,0 +1,52 @@
+#include <mbgl/map/tile_id.hpp>
+#include <mbgl/util/string.hpp>
+
+#include <cassert>
+
+namespace mbgl {
+
+TileID TileID::parent(int8_t parent_z) const {
+    assert(parent_z < z);
+    int32_t dim = std::pow(2, z - parent_z);
+    return TileID{
+        parent_z,
+        (x >= 0 ? x : x - dim + 1) / dim,
+        y / dim
+    };
+}
+
+std::forward_list<TileID> TileID::children(int32_t child_z) const {
+    assert(child_z > z);
+    int32_t factor = std::pow(2, child_z - z);
+
+    std::forward_list<TileID> child_ids;
+    for (int32_t ty = y * factor, y_max = (y + 1) * factor; ty < y_max; ++ty) {
+        for (int32_t tx = x * factor, x_max = (x + 1) * factor; tx < x_max; ++tx) {
+            child_ids.emplace_front(child_z, tx, ty);
+        }
+    }
+    return child_ids;
+}
+
+TileID TileID::normalized() const {
+    int32_t dim = std::pow(2, z);
+    int32_t nx = x, ny = y;
+    while (nx < 0) nx += dim;
+    while (nx >= dim) nx -= dim;
+    return TileID { z, nx, ny };
+}
+
+bool TileID::isChildOf(const TileID &parent_id) const {
+    if (parent_id.z >= z || parent_id.w != w) {
+        return false;
+    }
+    int32_t scale = std::pow(2, z - parent_id.z);
+    return parent_id.x == ((x < 0 ? x - scale + 1 : x) / scale) &&
+           parent_id.y == y / scale;
+}
+
+TileID::operator std::string() const {
+    return util::toString(z) + "/" + util::toString(x) + "/" + util::toString(y);
+}
+
+}
diff --git a/src/mbgl/map/tile_id.hpp b/src/mbgl/map/tile_id.hpp
new file mode 100644
index 0000000000..056fcdbfa5
--- /dev/null
+++ b/src/mbgl/map/tile_id.hpp
@@ -0,0 +1,55 @@
+#ifndef MBGL_MAP_TILE_ID
+#define MBGL_MAP_TILE_ID
+
+#include <cstdint>
+#include <cmath>
+#include <string>
+#include <functional>
+#include <forward_list>
+
+namespace mbgl {
+
+class TileID {
+public:
+    const int16_t w = 0;
+    const int8_t z = 0;
+    const int32_t x = 0, y = 0;
+
+    inline explicit TileID(int8_t z_, int32_t x_, int32_t y_)
+        : w((x_ < 0 ? x_ - (1 << z_) + 1 : x_) / (1 << z_)), z(z_), x(x_), y(y_) {}
+
+    inline uint64_t to_uint64() const {
+        return ((std::pow(2, z) * y + x) * 32) + z;
+    }
+
+    struct Hash {
+        std::size_t operator()(const TileID& id) const {
+            return std::hash<uint64_t>()(id.to_uint64());
+        }
+    };
+
+    inline bool operator==(const TileID& rhs) const {
+        return w == rhs.w && z == rhs.z && x == rhs.x && y == rhs.y;
+    }
+
+    inline bool operator!=(const TileID& rhs) const {
+        return !operator==(rhs);
+    }
+
+    inline bool operator<(const TileID& rhs) const {
+        if (w != rhs.w) return w < rhs.w;
+        if (z != rhs.z) return z < rhs.z;
+        if (x != rhs.x) return x < rhs.x;
+        return y < rhs.y;
+    }
+
+    TileID parent(int8_t z) const;
+    TileID normalized() const;
+    std::forward_list<TileID> children(int32_t z) const;
+    bool isChildOf(const TileID&) const;
+    operator std::string() const;
+};
+
+}
+
+#endif
diff --git a/src/mbgl/map/transform_state.cpp b/src/mbgl/map/transform_state.cpp
index 32ce184fa9..507e63f67e 100644
--- a/src/mbgl/map/transform_state.cpp
+++ b/src/mbgl/map/transform_state.cpp
@@ -1,4 +1,5 @@
 #include <mbgl/map/transform_state.hpp>
+#include <mbgl/map/tile_id.hpp>
 #include <mbgl/util/projection.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/box.hpp>
@@ -7,7 +8,7 @@ using namespace mbgl;
 
 #pragma mark - Matrix
 
-void TransformState::matrixFor(mat4& matrix, const Tile::ID& id) const {
+void TransformState::matrixFor(mat4& matrix, const TileID& id) const {
     const double tile_scale = std::pow(2, id.z);
     const double tile_size = scale * util::tileSize / tile_scale;
 
diff --git a/src/mbgl/map/vector_tile_data.cpp b/src/mbgl/map/vector_tile_data.cpp
index 0f04efd284..39c2d9fce3 100644
--- a/src/mbgl/map/vector_tile_data.cpp
+++ b/src/mbgl/map/vector_tile_data.cpp
@@ -10,7 +10,7 @@
 
 using namespace mbgl;
 
-VectorTileData::VectorTileData(Tile::ID const& id_,
+VectorTileData::VectorTileData(const TileID& id_,
                                float mapMaxZoom,
                                util::ptr<Style> style_,
                                GlyphAtlas& glyphAtlas_,
diff --git a/src/mbgl/map/vector_tile_data.hpp b/src/mbgl/map/vector_tile_data.hpp
index 7ecad4ccec..4e2f252f85 100644
--- a/src/mbgl/map/vector_tile_data.hpp
+++ b/src/mbgl/map/vector_tile_data.hpp
@@ -1,7 +1,6 @@
 #ifndef MBGL_MAP_VECTOR_TILE_DATA
 #define MBGL_MAP_VECTOR_TILE_DATA
 
-#include <mbgl/map/tile.hpp>
 #include <mbgl/map/tile_data.hpp>
 #include <mbgl/geometry/elements_buffer.hpp>
 #include <mbgl/geometry/fill_buffer.hpp>
@@ -30,7 +29,7 @@ class VectorTileData : public TileData {
     friend class TileParser;
 
 public:
-    VectorTileData(Tile::ID const&,
+    VectorTileData(const TileID&,
                    float mapMaxZoom,
                    util::ptr<Style>,
                    GlyphAtlas&,
diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp
index f59ae65be0..a7b0f61a3b 100644
--- a/src/mbgl/renderer/bucket.hpp
+++ b/src/mbgl/renderer/bucket.hpp
@@ -1,20 +1,18 @@
 #ifndef MBGL_RENDERER_BUCKET
 #define MBGL_RENDERER_BUCKET
 
-#include <mbgl/map/tile.hpp>
 #include <mbgl/util/noncopyable.hpp>
-
-#include <string>
+#include <mbgl/util/mat4.hpp>
 
 namespace mbgl {
 
 class Painter;
 class StyleLayer;
+class TileID;
 
 class Bucket : private util::noncopyable {
 public:
-    virtual void render(Painter &painter, const StyleLayer &layer_desc, const Tile::ID &id,
-                        const mat4 &matrix) = 0;
+    virtual void render(Painter&, const StyleLayer&, const TileID&, const mat4&) = 0;
     virtual bool hasData() const = 0;
     virtual ~Bucket() {}
 
diff --git a/src/mbgl/renderer/debug_bucket.cpp b/src/mbgl/renderer/debug_bucket.cpp
index 6104e2456b..ed03458dad 100644
--- a/src/mbgl/renderer/debug_bucket.cpp
+++ b/src/mbgl/renderer/debug_bucket.cpp
@@ -12,7 +12,7 @@ DebugBucket::DebugBucket(DebugFontBuffer& fontBuffer_)
 }
 
 void DebugBucket::render(Painter &painter, const StyleLayer & /*layer_desc*/,
-                         const Tile::ID & /*id*/, const mat4 &matrix) {
+                         const TileID & /*id*/, const mat4 &matrix) {
     painter.renderDebugText(*this, matrix);
 }
 
diff --git a/src/mbgl/renderer/debug_bucket.hpp b/src/mbgl/renderer/debug_bucket.hpp
index d23248841b..074d1d3991 100644
--- a/src/mbgl/renderer/debug_bucket.hpp
+++ b/src/mbgl/renderer/debug_bucket.hpp
@@ -19,7 +19,7 @@ class DebugBucket : public Bucket {
 public:
     DebugBucket(DebugFontBuffer& fontBuffer);
 
-    void render(Painter &painter, const StyleLayer &layer_desc, const Tile::ID &id,
+    void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id,
                 const mat4 &matrix) override;
     bool hasData() const override;
 
diff --git a/src/mbgl/renderer/fill_bucket.cpp b/src/mbgl/renderer/fill_bucket.cpp
index c3e04db067..f5726690b1 100644
--- a/src/mbgl/renderer/fill_bucket.cpp
+++ b/src/mbgl/renderer/fill_bucket.cpp
@@ -195,7 +195,7 @@ void FillBucket::tessellate() {
     lineGroup.vertex_length += total_vertex_count;
 }
 
-void FillBucket::render(Painter &painter, const StyleLayer &layer_desc, const Tile::ID &id,
+void FillBucket::render(Painter &painter, const StyleLayer &layer_desc, const TileID &id,
                         const mat4 &matrix) {
     painter.renderFill(*this, layer_desc, id, matrix);
 }
diff --git a/src/mbgl/renderer/fill_bucket.hpp b/src/mbgl/renderer/fill_bucket.hpp
index 5a51f17c4e..d28f849a2c 100644
--- a/src/mbgl/renderer/fill_bucket.hpp
+++ b/src/mbgl/renderer/fill_bucket.hpp
@@ -37,7 +37,7 @@ public:
                LineElementsBuffer &lineElementsBuffer);
     ~FillBucket() override;
 
-    void render(Painter &painter, const StyleLayer &layer_desc, const Tile::ID &id,
+    void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id,
                 const mat4 &matrix) override;
     bool hasData() const override;
 
diff --git a/src/mbgl/renderer/line_bucket.cpp b/src/mbgl/renderer/line_bucket.cpp
index 5404398ca0..4e09b74640 100644
--- a/src/mbgl/renderer/line_bucket.cpp
+++ b/src/mbgl/renderer/line_bucket.cpp
@@ -326,7 +326,7 @@ void LineBucket::addGeometry(const std::vector<Coordinate>& vertices) {
     }
 }
 
-void LineBucket::render(Painter &painter, const StyleLayer &layer_desc, const Tile::ID &id,
+void LineBucket::render(Painter &painter, const StyleLayer &layer_desc, const TileID &id,
                         const mat4 &matrix) {
     painter.renderLine(*this, layer_desc, id, matrix);
 }
diff --git a/src/mbgl/renderer/line_bucket.hpp b/src/mbgl/renderer/line_bucket.hpp
index e6e5f66d57..d70801e0bf 100644
--- a/src/mbgl/renderer/line_bucket.hpp
+++ b/src/mbgl/renderer/line_bucket.hpp
@@ -32,7 +32,7 @@ public:
                PointElementsBuffer &pointElementsBuffer);
     ~LineBucket() override;
 
-    void render(Painter &painter, const StyleLayer &layer_desc, const Tile::ID &id,
+    void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id,
                 const mat4 &matrix) override;
     bool hasData() const override;
 
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index 90b20ff0c4..c05aab0ae5 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -10,6 +10,7 @@
 #include <mbgl/util/mat3.hpp>
 #include <mbgl/geometry/sprite_atlas.hpp>
 #include <mbgl/map/source.hpp>
+#include <mbgl/map/tile.hpp>
 
 #if defined(DEBUG)
 #include <mbgl/util/stopwatch.hpp>
@@ -442,7 +443,7 @@ void Painter::renderBackground(const StyleLayer &layer_desc) {
     MBGL_CHECK_ERROR(glEnable(GL_STENCIL_TEST));
 }
 
-mat4 Painter::translatedMatrix(const mat4& matrix, const std::array<float, 2> &translation, const Tile::ID &id, TranslateAnchorType anchor) {
+mat4 Painter::translatedMatrix(const mat4& matrix, const std::array<float, 2> &translation, const TileID &id, TranslateAnchorType anchor) {
     if (translation[0] == 0 && translation[1] == 0) {
         return matrix;
     } else {
diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp
index 50cb1e338e..cf01c03918 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -54,6 +54,7 @@ struct RasterProperties;
 
 class LayerDescription;
 class RasterTileData;
+struct ClipID;
 
 class Painter : private util::noncopyable {
 public:
@@ -91,10 +92,10 @@ public:
 
     void renderDebugText(DebugBucket& bucket, const mat4 &matrix);
     void renderDebugText(const std::vector<std::string> &strings);
-    void renderFill(FillBucket& bucket, const StyleLayer &layer_desc, const Tile::ID& id, const mat4 &matrix);
-    void renderLine(LineBucket& bucket, const StyleLayer &layer_desc, const Tile::ID& id, const mat4 &matrix);
-    void renderSymbol(SymbolBucket& bucket, const StyleLayer &layer_desc, const Tile::ID& id, const mat4 &matrix);
-    void renderRaster(RasterBucket& bucket, const StyleLayer &layer_desc, const Tile::ID& id, const mat4 &matrix);
+    void renderFill(FillBucket& bucket, const StyleLayer &layer_desc, const TileID& id, const mat4 &matrix);
+    void renderLine(LineBucket& bucket, const StyleLayer &layer_desc, const TileID& id, const mat4 &matrix);
+    void renderSymbol(SymbolBucket& bucket, const StyleLayer &layer_desc, const TileID& id, const mat4 &matrix);
+    void renderRaster(RasterBucket& bucket, const StyleLayer &layer_desc, const TileID& id, const mat4 &matrix);
     void renderBackground(const StyleLayer &layer_desc);
 
     float saturationFactor(float saturation);
@@ -105,7 +106,7 @@ public:
 
     void renderPrerenderedTexture(RasterBucket &bucket, const mat4 &matrix, const RasterProperties& properties);
 
-    void createPrerendered(RasterBucket& bucket, const StyleLayer &layer_desc, const Tile::ID& id);
+    void createPrerendered(RasterBucket& bucket, const StyleLayer &layer_desc, const TileID& id);
 
     void resize();
 
@@ -133,13 +134,13 @@ public:
 private:
     void setupShaders();
     void deleteShaders();
-    mat4 translatedMatrix(const mat4& matrix, const std::array<float, 2> &translation, const Tile::ID &id, TranslateAnchorType anchor);
+    mat4 translatedMatrix(const mat4& matrix, const std::array<float, 2> &translation, const TileID &id, TranslateAnchorType anchor);
 
     void prepareTile(const Tile& tile);
 
     template <typename BucketProperties, typename StyleProperties>
     void renderSDF(SymbolBucket &bucket,
-                   const Tile::ID &id,
+                   const TileID &id,
                    const mat4 &matrixSymbol,
                    const BucketProperties& bucketProperties,
                    const StyleProperties& styleProperties,
diff --git a/src/mbgl/renderer/painter_clipping.cpp b/src/mbgl/renderer/painter_clipping.cpp
index ab16de49aa..8b97bb5b69 100644
--- a/src/mbgl/renderer/painter_clipping.cpp
+++ b/src/mbgl/renderer/painter_clipping.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/renderer/painter.hpp>
 #include <mbgl/renderer/fill_bucket.hpp>
 #include <mbgl/map/map.hpp>
+#include <mbgl/map/tile.hpp>
 #include <mbgl/map/source.hpp>
 #include <mbgl/util/clip_ids.hpp>
 
diff --git a/src/mbgl/renderer/painter_debug.cpp b/src/mbgl/renderer/painter_debug.cpp
index 7f9c990776..2931473283 100644
--- a/src/mbgl/renderer/painter_debug.cpp
+++ b/src/mbgl/renderer/painter_debug.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/renderer/painter.hpp>
 #include <mbgl/renderer/debug_bucket.hpp>
 #include <mbgl/map/map.hpp>
+#include <mbgl/map/tile.hpp>
 #include <mbgl/util/string.hpp>
 
 using namespace mbgl;
diff --git a/src/mbgl/renderer/painter_fill.cpp b/src/mbgl/renderer/painter_fill.cpp
index cadc9ab148..8025cf3469 100644
--- a/src/mbgl/renderer/painter_fill.cpp
+++ b/src/mbgl/renderer/painter_fill.cpp
@@ -11,7 +11,7 @@
 
 using namespace mbgl;
 
-void Painter::renderFill(FillBucket& bucket, const StyleLayer &layer_desc, const Tile::ID& id, const mat4 &matrix) {
+void Painter::renderFill(FillBucket& bucket, const StyleLayer &layer_desc, const TileID& id, const mat4 &matrix) {
     // Abort early.
     if (!bucket.hasData()) return;
 
diff --git a/src/mbgl/renderer/painter_line.cpp b/src/mbgl/renderer/painter_line.cpp
index a19d9873af..2f8c3face3 100644
--- a/src/mbgl/renderer/painter_line.cpp
+++ b/src/mbgl/renderer/painter_line.cpp
@@ -10,7 +10,7 @@
 
 using namespace mbgl;
 
-void Painter::renderLine(LineBucket& bucket, const StyleLayer &layer_desc, const Tile::ID& id, const mat4 &matrix) {
+void Painter::renderLine(LineBucket& bucket, const StyleLayer &layer_desc, const TileID& id, const mat4 &matrix) {
     // Abort early.
     if (pass == RenderPass::Opaque) return;
     if (!bucket.hasData()) return;
diff --git a/src/mbgl/renderer/painter_raster.cpp b/src/mbgl/renderer/painter_raster.cpp
index 72d15aabd0..5fac248ee6 100644
--- a/src/mbgl/renderer/painter_raster.cpp
+++ b/src/mbgl/renderer/painter_raster.cpp
@@ -7,7 +7,7 @@
 
 using namespace mbgl;
 
-void Painter::renderRaster(RasterBucket& bucket, const StyleLayer &layer_desc, const Tile::ID&, const mat4 &matrix) {
+void Painter::renderRaster(RasterBucket& bucket, const StyleLayer &layer_desc, const TileID&, const mat4 &matrix) {
     if (pass != RenderPass::Translucent) return;
 
     const RasterProperties &properties = layer_desc.getProperties<RasterProperties>();
diff --git a/src/mbgl/renderer/painter_symbol.cpp b/src/mbgl/renderer/painter_symbol.cpp
index e1b4d88193..2785e8bae3 100644
--- a/src/mbgl/renderer/painter_symbol.cpp
+++ b/src/mbgl/renderer/painter_symbol.cpp
@@ -13,7 +13,7 @@ using namespace mbgl;
 
 template <typename BucketProperties, typename StyleProperties>
 void Painter::renderSDF(SymbolBucket &bucket,
-                        const Tile::ID &id,
+                        const TileID &id,
                         const mat4 &matrix,
                         const BucketProperties& bucketProperties,
                         const StyleProperties& styleProperties,
@@ -112,7 +112,7 @@ void Painter::renderSDF(SymbolBucket &bucket,
     }
 }
 
-void Painter::renderSymbol(SymbolBucket &bucket, const StyleLayer &layer_desc, const Tile::ID &id, const mat4 &matrix) {
+void Painter::renderSymbol(SymbolBucket &bucket, const StyleLayer &layer_desc, const TileID &id, const mat4 &matrix) {
     // Abort early.
     if (pass == RenderPass::Opaque) {
         return;
diff --git a/src/mbgl/renderer/raster_bucket.cpp b/src/mbgl/renderer/raster_bucket.cpp
index b16303c84f..b00933d24b 100644
--- a/src/mbgl/renderer/raster_bucket.cpp
+++ b/src/mbgl/renderer/raster_bucket.cpp
@@ -8,7 +8,7 @@ RasterBucket::RasterBucket(TexturePool& texturePool, const StyleLayoutRaster& la
   raster(texturePool) {
 }
 
-void RasterBucket::render(Painter &painter, const StyleLayer &layer_desc, const Tile::ID &id,
+void RasterBucket::render(Painter &painter, const StyleLayer &layer_desc, const TileID &id,
                           const mat4 &matrix) {
     painter.renderRaster(*this, layer_desc, id, matrix);
 }
diff --git a/src/mbgl/renderer/raster_bucket.hpp b/src/mbgl/renderer/raster_bucket.hpp
index 168685b163..22a151cf7d 100644
--- a/src/mbgl/renderer/raster_bucket.hpp
+++ b/src/mbgl/renderer/raster_bucket.hpp
@@ -18,7 +18,7 @@ class RasterBucket : public Bucket {
 public:
     RasterBucket(TexturePool&, const StyleLayoutRaster&);
 
-    void render(Painter &painter, const StyleLayer &layer_desc, const Tile::ID &id,
+    void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id,
                 const mat4 &matrix) override;
     bool hasData() const override;
 
diff --git a/src/mbgl/renderer/symbol_bucket.cpp b/src/mbgl/renderer/symbol_bucket.cpp
index d5940eccf1..c0c732084e 100644
--- a/src/mbgl/renderer/symbol_bucket.cpp
+++ b/src/mbgl/renderer/symbol_bucket.cpp
@@ -30,7 +30,7 @@ SymbolBucket::~SymbolBucket() {
     // Do not remove. header file only contains forward definitions to unique pointers.
 }
 
-void SymbolBucket::render(Painter &painter, const StyleLayer &layer_desc, const Tile::ID &id,
+void SymbolBucket::render(Painter &painter, const StyleLayer &layer_desc, const TileID &id,
                           const mat4 &matrix) {
     painter.renderSymbol(*this, layer_desc, id, matrix);
 }
diff --git a/src/mbgl/renderer/symbol_bucket.hpp b/src/mbgl/renderer/symbol_bucket.hpp
index 94d8ce45c7..9ddd653c5d 100644
--- a/src/mbgl/renderer/symbol_bucket.hpp
+++ b/src/mbgl/renderer/symbol_bucket.hpp
@@ -55,7 +55,7 @@ public:
     SymbolBucket(Collision &collision);
     ~SymbolBucket() override;
 
-    void render(Painter &painter, const StyleLayer &layer_desc, const Tile::ID &id,
+    void render(Painter &painter, const StyleLayer &layer_desc, const TileID &id,
                 const mat4 &matrix) override;
     bool hasData() const override;
     bool hasTextData() const;
diff --git a/src/mbgl/util/clip_ids.cpp b/src/mbgl/util/clip_ids.cpp
index e7833b679f..42a1627b6e 100644
--- a/src/mbgl/util/clip_ids.cpp
+++ b/src/mbgl/util/clip_ids.cpp
@@ -1,8 +1,8 @@
 #include <mbgl/util/clip_ids.hpp>
-#include <mbgl/map/tile.hpp>
 
 #include <mbgl/platform/log.hpp>
 #include <mbgl/util/math.hpp>
+#include <mbgl/map/tile.hpp>
 
 #include <list>
 #include <vector>
@@ -15,7 +15,7 @@ namespace mbgl {
 
 ClipIDGenerator::Leaf::Leaf(Tile &tile_) : tile(tile_) {}
 
-void ClipIDGenerator::Leaf::add(const Tile::ID &p) {
+void ClipIDGenerator::Leaf::add(const TileID &p) {
     if (p.isChildOf(tile.id)) {
         // Ensure that no already present child is a parent of the new p.
         for (const auto& child : children) {
diff --git a/src/mbgl/util/clip_ids.hpp b/src/mbgl/util/clip_ids.hpp
index 5855b16af7..154003f280 100644
--- a/src/mbgl/util/clip_ids.hpp
+++ b/src/mbgl/util/clip_ids.hpp
@@ -1,7 +1,8 @@
 #ifndef MBGL_UTIL_CLIP_IDS
 #define MBGL_UTIL_CLIP_IDS
 
-#include <mbgl/map/tile.hpp>
+#include <mbgl/map/tile_id.hpp>
+
 #include <list>
 #include <set>
 #include <vector>
@@ -10,15 +11,17 @@
 
 namespace mbgl {
 
+class Tile;
+
 class ClipIDGenerator {
 private:
     struct Leaf {
         Leaf(Tile &tile);
-        void add(const Tile::ID &p);
+        void add(const TileID &p);
         bool operator==(const Leaf &other) const;
 
         Tile &tile;
-        std::forward_list<Tile::ID> children;
+        std::forward_list<TileID> children;
     };
 
     typedef std::vector<Leaf> Pool;
diff --git a/test/miscellaneous/clip_ids.cpp b/test/miscellaneous/clip_ids.cpp
index 845b094520..cf7ebb398b 100644
--- a/test/miscellaneous/clip_ids.cpp
+++ b/test/miscellaneous/clip_ids.cpp
@@ -4,6 +4,7 @@
 #include <algorithm>
 
 #include <mbgl/util/clip_ids.hpp>
+#include <mbgl/map/tile.hpp>
 #include <mbgl/util/std.hpp>
 
 using namespace mbgl;
@@ -29,11 +30,11 @@ template <typename T> void print(const T &sources) {
 TEST(ClipIDs, ParentAndFourChildren) {
     const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
         {
-            std::make_shared<Tile>(Tile::ID { 1, 0, 0 }),
-            std::make_shared<Tile>(Tile::ID { 1, 0, 1 }),
-            std::make_shared<Tile>(Tile::ID { 1, 1, 0 }),
-            std::make_shared<Tile>(Tile::ID { 1, 1, 1 }),
-            std::make_shared<Tile>(Tile::ID { 0, 0, 0 }),
+            std::make_shared<Tile>(TileID { 1, 0, 0 }),
+            std::make_shared<Tile>(TileID { 1, 0, 1 }),
+            std::make_shared<Tile>(TileID { 1, 1, 0 }),
+            std::make_shared<Tile>(TileID { 1, 1, 1 }),
+            std::make_shared<Tile>(TileID { 0, 0, 0 }),
         },
     };
 
@@ -50,11 +51,11 @@ TEST(ClipIDs, ParentAndFourChildren) {
 TEST(ClipIDs, ParentAndFourChildrenNegative) {
     const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
         {
-            std::make_shared<Tile>(Tile::ID { 1, -2, 0 }),
-            std::make_shared<Tile>(Tile::ID { 1, -2, 1 }),
-            std::make_shared<Tile>(Tile::ID { 1, -1, 0 }),
-            std::make_shared<Tile>(Tile::ID { 1, -1, 1 }),
-            std::make_shared<Tile>(Tile::ID { 0, -1, 0 }),
+            std::make_shared<Tile>(TileID { 1, -2, 0 }),
+            std::make_shared<Tile>(TileID { 1, -2, 1 }),
+            std::make_shared<Tile>(TileID { 1, -1, 0 }),
+            std::make_shared<Tile>(TileID { 1, -1, 1 }),
+            std::make_shared<Tile>(TileID { 0, -1, 0 }),
         },
     };
 
@@ -71,11 +72,11 @@ TEST(ClipIDs, ParentAndFourChildrenNegative) {
 TEST(ClipIDs, NegativeParentAndMissingLevel) {
     const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
         {
-            std::make_shared<Tile>(Tile::ID { 1, -1, 0 }),
-            std::make_shared<Tile>(Tile::ID { 2, -1, 0 }),
-            std::make_shared<Tile>(Tile::ID { 2, -2, 1 }),
-            std::make_shared<Tile>(Tile::ID { 2, -1, 1 }),
-            std::make_shared<Tile>(Tile::ID { 2, -2, 0 }),
+            std::make_shared<Tile>(TileID { 1, -1, 0 }),
+            std::make_shared<Tile>(TileID { 2, -1, 0 }),
+            std::make_shared<Tile>(TileID { 2, -2, 1 }),
+            std::make_shared<Tile>(TileID { 2, -1, 1 }),
+            std::make_shared<Tile>(TileID { 2, -2, 0 }),
         },
     };
 
@@ -93,13 +94,13 @@ TEST(ClipIDs, NegativeParentAndMissingLevel) {
 TEST(ClipIDs, SevenOnSameLevel) {
     const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
         {
-            std::make_shared<Tile>(Tile::ID { 2, 0, 0 }),
-            std::make_shared<Tile>(Tile::ID { 2, 0, 1 }),
-            std::make_shared<Tile>(Tile::ID { 2, 0, 2 }),
-            std::make_shared<Tile>(Tile::ID { 2, 1, 0 }),
-            std::make_shared<Tile>(Tile::ID { 2, 1, 1 }),
-            std::make_shared<Tile>(Tile::ID { 2, 1, 2 }),
-            std::make_shared<Tile>(Tile::ID { 2, 2, 0 }),
+            std::make_shared<Tile>(TileID { 2, 0, 0 }),
+            std::make_shared<Tile>(TileID { 2, 0, 1 }),
+            std::make_shared<Tile>(TileID { 2, 0, 2 }),
+            std::make_shared<Tile>(TileID { 2, 1, 0 }),
+            std::make_shared<Tile>(TileID { 2, 1, 1 }),
+            std::make_shared<Tile>(TileID { 2, 1, 2 }),
+            std::make_shared<Tile>(TileID { 2, 2, 0 }),
         },
     };
 
@@ -118,18 +119,18 @@ TEST(ClipIDs, SevenOnSameLevel) {
 TEST(ClipIDs, MultipleLevels) {
     const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
         {
-            std::make_shared<Tile>(Tile::ID { 2, 0, 0 }),
-                std::make_shared<Tile>(Tile::ID { 3, 0, 0 }),
-                std::make_shared<Tile>(Tile::ID { 3, 0, 1 }),
-                    std::make_shared<Tile>(Tile::ID { 4, 0, 2 }),
-                    std::make_shared<Tile>(Tile::ID { 4, 1, 2 }),
-                    std::make_shared<Tile>(Tile::ID { 4, 0, 3 }),
-                    std::make_shared<Tile>(Tile::ID { 4, 1, 3 }),
-                std::make_shared<Tile>(Tile::ID { 3, 1, 0 }),
-                std::make_shared<Tile>(Tile::ID { 3, 1, 1 }),
-            std::make_shared<Tile>(Tile::ID { 2, 1, 0 }),
-                std::make_shared<Tile>(Tile::ID { 3, 2, 0 }),
-                std::make_shared<Tile>(Tile::ID { 3, 2, 1 }),
+            std::make_shared<Tile>(TileID { 2, 0, 0 }),
+                std::make_shared<Tile>(TileID { 3, 0, 0 }),
+                std::make_shared<Tile>(TileID { 3, 0, 1 }),
+                    std::make_shared<Tile>(TileID { 4, 0, 2 }),
+                    std::make_shared<Tile>(TileID { 4, 1, 2 }),
+                    std::make_shared<Tile>(TileID { 4, 0, 3 }),
+                    std::make_shared<Tile>(TileID { 4, 1, 3 }),
+                std::make_shared<Tile>(TileID { 3, 1, 0 }),
+                std::make_shared<Tile>(TileID { 3, 1, 1 }),
+            std::make_shared<Tile>(TileID { 2, 1, 0 }),
+                std::make_shared<Tile>(TileID { 3, 2, 0 }),
+                std::make_shared<Tile>(TileID { 3, 2, 1 }),
         },
     };
 
@@ -154,17 +155,17 @@ TEST(ClipIDs, MultipleLevels) {
 TEST(ClipIDs, Bug206) {
     const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
         {
-            std::make_shared<Tile>(Tile::ID { 10, 162, 395 }),
-            std::make_shared<Tile>(Tile::ID { 10, 162, 396 }),
-            std::make_shared<Tile>(Tile::ID { 10, 163, 395 }),
-                std::make_shared<Tile>(Tile::ID { 11, 326, 791 }),
-                std::make_shared<Tile>(Tile::ID { 12, 654, 1582 }),
-                std::make_shared<Tile>(Tile::ID { 12, 654, 1583 }),
-                std::make_shared<Tile>(Tile::ID { 12, 655, 1582 }),
-                std::make_shared<Tile>(Tile::ID { 12, 655, 1583 }),
-            std::make_shared<Tile>(Tile::ID { 10, 163, 396 }),
-            std::make_shared<Tile>(Tile::ID { 10, 164, 395 }),
-            std::make_shared<Tile>(Tile::ID { 10, 164, 396 }),
+            std::make_shared<Tile>(TileID { 10, 162, 395 }),
+            std::make_shared<Tile>(TileID { 10, 162, 396 }),
+            std::make_shared<Tile>(TileID { 10, 163, 395 }),
+                std::make_shared<Tile>(TileID { 11, 326, 791 }),
+                std::make_shared<Tile>(TileID { 12, 654, 1582 }),
+                std::make_shared<Tile>(TileID { 12, 654, 1583 }),
+                std::make_shared<Tile>(TileID { 12, 655, 1582 }),
+                std::make_shared<Tile>(TileID { 12, 655, 1583 }),
+            std::make_shared<Tile>(TileID { 10, 163, 396 }),
+            std::make_shared<Tile>(TileID { 10, 164, 395 }),
+            std::make_shared<Tile>(TileID { 10, 164, 396 }),
         },
     };
 
@@ -188,23 +189,23 @@ TEST(ClipIDs, Bug206) {
 TEST(ClipIDs, MultipleSources) {
     const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
         {
-            std::make_shared<Tile>(Tile::ID { 0, 0, 0 }),
-            std::make_shared<Tile>(Tile::ID { 1, 1, 1 }),
-            std::make_shared<Tile>(Tile::ID { 2, 2, 1 }),
-            std::make_shared<Tile>(Tile::ID { 2, 2, 2 }),
+            std::make_shared<Tile>(TileID { 0, 0, 0 }),
+            std::make_shared<Tile>(TileID { 1, 1, 1 }),
+            std::make_shared<Tile>(TileID { 2, 2, 1 }),
+            std::make_shared<Tile>(TileID { 2, 2, 2 }),
         },
         {
-            std::make_shared<Tile>(Tile::ID { 0, 0, 0 }),
-            std::make_shared<Tile>(Tile::ID { 1, 1, 1 }),
-            std::make_shared<Tile>(Tile::ID { 2, 1, 1 }),
-            std::make_shared<Tile>(Tile::ID { 2, 2, 2 }),
+            std::make_shared<Tile>(TileID { 0, 0, 0 }),
+            std::make_shared<Tile>(TileID { 1, 1, 1 }),
+            std::make_shared<Tile>(TileID { 2, 1, 1 }),
+            std::make_shared<Tile>(TileID { 2, 2, 2 }),
         },
         {
-            std::make_shared<Tile>(Tile::ID { 1, 0, 0 }),
-            std::make_shared<Tile>(Tile::ID { 1, 0, 1 }),
-            std::make_shared<Tile>(Tile::ID { 1, 1, 0 }),
-            std::make_shared<Tile>(Tile::ID { 1, 1, 1 }),
-            std::make_shared<Tile>(Tile::ID { 2, 1, 1 }),
+            std::make_shared<Tile>(TileID { 1, 0, 0 }),
+            std::make_shared<Tile>(TileID { 1, 0, 1 }),
+            std::make_shared<Tile>(TileID { 1, 1, 0 }),
+            std::make_shared<Tile>(TileID { 1, 1, 1 }),
+            std::make_shared<Tile>(TileID { 2, 1, 1 }),
         },
     };
 
@@ -230,13 +231,13 @@ TEST(ClipIDs, MultipleSources) {
 TEST(ClipIDs, DuplicateIDs) {
         const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
         {
-            std::make_shared<Tile>(Tile::ID { 2, 0, 0 }),
-            std::make_shared<Tile>(Tile::ID { 2, 0, 1 }),
+            std::make_shared<Tile>(TileID { 2, 0, 0 }),
+            std::make_shared<Tile>(TileID { 2, 0, 1 }),
         },
         {
-            std::make_shared<Tile>(Tile::ID { 2, 0, 0 }),
-            std::make_shared<Tile>(Tile::ID { 2, 0, 1 }),
-            std::make_shared<Tile>(Tile::ID { 2, 0, 1 }),
+            std::make_shared<Tile>(TileID { 2, 0, 0 }),
+            std::make_shared<Tile>(TileID { 2, 0, 1 }),
+            std::make_shared<Tile>(TileID { 2, 0, 1 }),
         }
     };
 
diff --git a/test/miscellaneous/tile.cpp b/test/miscellaneous/tile.cpp
index 01da68f10d..6c5c89ac43 100644
--- a/test/miscellaneous/tile.cpp
+++ b/test/miscellaneous/tile.cpp
@@ -1,50 +1,50 @@
 #include <iostream>
 #include "../fixtures/util.hpp"
 
-#include <mbgl/map/tile.hpp>
+#include <mbgl/map/tile_id.hpp>
 
 using namespace mbgl;
 
 
 TEST(Variant, isChild) {
-    ASSERT_TRUE(Tile::ID(1, 0, 0).isChildOf(Tile::ID(0, 0, 0)));
-    ASSERT_TRUE(Tile::ID(1, 1, 0).isChildOf(Tile::ID(0, 0, 0)));
-    ASSERT_TRUE(Tile::ID(1, 2, 0).isChildOf(Tile::ID(0, 1, 0)));
-    ASSERT_TRUE(Tile::ID(1, 3, 0).isChildOf(Tile::ID(0, 1, 0)));
-    ASSERT_TRUE(Tile::ID(1, 4, 0).isChildOf(Tile::ID(0, 2, 0)));
-    ASSERT_TRUE(Tile::ID(1, 5, 0).isChildOf(Tile::ID(0, 2, 0)));
-    ASSERT_TRUE(Tile::ID(2, 0, 0).isChildOf(Tile::ID(0, 0, 0)));
-
-    ASSERT_TRUE(Tile::ID(2, 8, 0).isChildOf(Tile::ID(0, 2, 0)));
-    ASSERT_TRUE(Tile::ID(2, 9, 0).isChildOf(Tile::ID(0, 2, 0)));
-    ASSERT_TRUE(Tile::ID(2, 10, 0).isChildOf(Tile::ID(0, 2, 0)));
-    ASSERT_TRUE(Tile::ID(2, 11, 0).isChildOf(Tile::ID(0, 2, 0)));
-    ASSERT_TRUE(Tile::ID(2, 12, 0).isChildOf(Tile::ID(0, 3, 0)));
-    ASSERT_TRUE(Tile::ID(2, 13, 0).isChildOf(Tile::ID(0, 3, 0)));
-
-    ASSERT_TRUE(Tile::ID(1, -1, 0).isChildOf(Tile::ID(0, -1, 0)));
-    ASSERT_TRUE(Tile::ID(1, -2, 0).isChildOf(Tile::ID(0, -1, 0)));
-    ASSERT_TRUE(Tile::ID(1, -3, 0).isChildOf(Tile::ID(0, -2, 0)));
-    ASSERT_TRUE(Tile::ID(1, -4, 0).isChildOf(Tile::ID(0, -2, 0)));
-    ASSERT_TRUE(Tile::ID(2, -1, 0).isChildOf(Tile::ID(0, -1, 0)));
-    ASSERT_TRUE(Tile::ID(2, -2, 0).isChildOf(Tile::ID(0, -1, 0)));
-    ASSERT_TRUE(Tile::ID(2, -3, 0).isChildOf(Tile::ID(0, -1, 0)));
-    ASSERT_TRUE(Tile::ID(2, -4, 0).isChildOf(Tile::ID(0, -1, 0)));
-    ASSERT_TRUE(Tile::ID(2, -5, 0).isChildOf(Tile::ID(0, -2, 0)));
-    ASSERT_TRUE(Tile::ID(2, -6, 0).isChildOf(Tile::ID(0, -2, 0)));
-    ASSERT_TRUE(Tile::ID(2, -7, 0).isChildOf(Tile::ID(0, -2, 0)));
-    ASSERT_TRUE(Tile::ID(2, -8, 0).isChildOf(Tile::ID(0, -2, 0)));
-
-    ASSERT_FALSE(Tile::ID(4, -16, 0).isChildOf(Tile::ID(0, -2, 0)));
-    ASSERT_TRUE(Tile::ID(4, -17, 0).isChildOf(Tile::ID(0, -2, 0)));
-
-    ASSERT_TRUE(Tile::ID(2, -1, 0).isChildOf(Tile::ID(1, -1, 0)));
-    ASSERT_TRUE(Tile::ID(2, -2, 0).isChildOf(Tile::ID(1, -1, 0)));
-    ASSERT_TRUE(Tile::ID(2, -3, 0).isChildOf(Tile::ID(1, -2, 0)));
-    ASSERT_TRUE(Tile::ID(2, -4, 0).isChildOf(Tile::ID(1, -2, 0)));
-    ASSERT_TRUE(Tile::ID(3, -1, 0).isChildOf(Tile::ID(1, -1, 0)));
-    ASSERT_TRUE(Tile::ID(3, -2, 0).isChildOf(Tile::ID(1, -1, 0)));
-    ASSERT_TRUE(Tile::ID(3, -3, 0).isChildOf(Tile::ID(1, -1, 0)));
-    ASSERT_TRUE(Tile::ID(3, -4, 0).isChildOf(Tile::ID(1, -1, 0)));
-    ASSERT_TRUE(Tile::ID(3, -5, 0).isChildOf(Tile::ID(1, -2, 0)));
+    ASSERT_TRUE(TileID(1, 0, 0).isChildOf(TileID(0, 0, 0)));
+    ASSERT_TRUE(TileID(1, 1, 0).isChildOf(TileID(0, 0, 0)));
+    ASSERT_TRUE(TileID(1, 2, 0).isChildOf(TileID(0, 1, 0)));
+    ASSERT_TRUE(TileID(1, 3, 0).isChildOf(TileID(0, 1, 0)));
+    ASSERT_TRUE(TileID(1, 4, 0).isChildOf(TileID(0, 2, 0)));
+    ASSERT_TRUE(TileID(1, 5, 0).isChildOf(TileID(0, 2, 0)));
+    ASSERT_TRUE(TileID(2, 0, 0).isChildOf(TileID(0, 0, 0)));
+
+    ASSERT_TRUE(TileID(2, 8, 0).isChildOf(TileID(0, 2, 0)));
+    ASSERT_TRUE(TileID(2, 9, 0).isChildOf(TileID(0, 2, 0)));
+    ASSERT_TRUE(TileID(2, 10, 0).isChildOf(TileID(0, 2, 0)));
+    ASSERT_TRUE(TileID(2, 11, 0).isChildOf(TileID(0, 2, 0)));
+    ASSERT_TRUE(TileID(2, 12, 0).isChildOf(TileID(0, 3, 0)));
+    ASSERT_TRUE(TileID(2, 13, 0).isChildOf(TileID(0, 3, 0)));
+
+    ASSERT_TRUE(TileID(1, -1, 0).isChildOf(TileID(0, -1, 0)));
+    ASSERT_TRUE(TileID(1, -2, 0).isChildOf(TileID(0, -1, 0)));
+    ASSERT_TRUE(TileID(1, -3, 0).isChildOf(TileID(0, -2, 0)));
+    ASSERT_TRUE(TileID(1, -4, 0).isChildOf(TileID(0, -2, 0)));
+    ASSERT_TRUE(TileID(2, -1, 0).isChildOf(TileID(0, -1, 0)));
+    ASSERT_TRUE(TileID(2, -2, 0).isChildOf(TileID(0, -1, 0)));
+    ASSERT_TRUE(TileID(2, -3, 0).isChildOf(TileID(0, -1, 0)));
+    ASSERT_TRUE(TileID(2, -4, 0).isChildOf(TileID(0, -1, 0)));
+    ASSERT_TRUE(TileID(2, -5, 0).isChildOf(TileID(0, -2, 0)));
+    ASSERT_TRUE(TileID(2, -6, 0).isChildOf(TileID(0, -2, 0)));
+    ASSERT_TRUE(TileID(2, -7, 0).isChildOf(TileID(0, -2, 0)));
+    ASSERT_TRUE(TileID(2, -8, 0).isChildOf(TileID(0, -2, 0)));
+
+    ASSERT_FALSE(TileID(4, -16, 0).isChildOf(TileID(0, -2, 0)));
+    ASSERT_TRUE(TileID(4, -17, 0).isChildOf(TileID(0, -2, 0)));
+
+    ASSERT_TRUE(TileID(2, -1, 0).isChildOf(TileID(1, -1, 0)));
+    ASSERT_TRUE(TileID(2, -2, 0).isChildOf(TileID(1, -1, 0)));
+    ASSERT_TRUE(TileID(2, -3, 0).isChildOf(TileID(1, -2, 0)));
+    ASSERT_TRUE(TileID(2, -4, 0).isChildOf(TileID(1, -2, 0)));
+    ASSERT_TRUE(TileID(3, -1, 0).isChildOf(TileID(1, -1, 0)));
+    ASSERT_TRUE(TileID(3, -2, 0).isChildOf(TileID(1, -1, 0)));
+    ASSERT_TRUE(TileID(3, -3, 0).isChildOf(TileID(1, -1, 0)));
+    ASSERT_TRUE(TileID(3, -4, 0).isChildOf(TileID(1, -1, 0)));
+    ASSERT_TRUE(TileID(3, -5, 0).isChildOf(TileID(1, -2, 0)));
 }