*Tile ↔ *TileData

benchmark/parse/filter.cpp

@@ -3,7 +3,7 @@
 #include <mbgl/style/filter.hpp>
 #include <mbgl/style/filter_evaluator.hpp>
 #include <mbgl/style/parser.hpp>
-#include <mbgl/tile/geometry_tile.hpp>
+#include <mbgl/tile/geometry_tile_data.hpp>
 
 #include <rapidjson/document.h>
 

src/mbgl/algorithm/generate_clip_ids.cpp

@@ -2,7 +2,6 @@
 #include <mbgl/algorithm/covered_by_children.hpp>
 
 #include <mbgl/util/std.hpp>
-#include <mbgl/tile/tile.hpp>
 
 #include <list>
 #include <vector>

src/mbgl/algorithm/update_renderables.hpp

@@ -7,15 +7,15 @@
 namespace mbgl {
 namespace algorithm {
 
-template <typename GetTileDataFn,
- typename CreateTileDataFn,
- typename RetainTileDataFn,
+template <typename GetTileFn,
+ typename CreateTileFn,
+ typename RetainTileFn,
  typename RenderTileFn,
  typename IdealTileIDs,
  typename SourceInfo>
-void updateRenderables(GetTileDataFn getTileData,
- CreateTileDataFn createTileData,
- RetainTileDataFn retainTileData,
+void updateRenderables(GetTileFn getTile,
+ CreateTileFn createTile,
+ RetainTileFn retainTile,
  RenderTileFn renderTile,
  const IdealTileIDs& idealTileIDs,
  const SourceInfo& info,
@@ -31,29 +31,29 @@ void updateRenderables(GetTileDataFn getTileData,
  assert(dataTileZoom >= idealRenderTileID.canonical.z);
 
  const OverscaledTileID idealDataTileID(dataTileZoom, idealRenderTileID.canonical);
- auto data = getTileData(idealDataTileID);
+ auto data = getTile(idealDataTileID);
  if (!data) {
- data = createTileData(idealDataTileID);
+ data = createTile(idealDataTileID);
  assert(data);
  }
 
  // if (source has the tile and bucket is loaded) {
  if (data->isRenderable()) {
- retainTileData(*data, true);
+ retainTile(*data, true);
  renderTile(idealRenderTileID, *data);
  } else {
  bool triedPrevious = data->hasTriedOptional();
 
  // The tile isn't loaded yet, but retain it anyway because it's an ideal tile.
- retainTileData(*data, true);
+ retainTile(*data, true);
  covered = true;
  overscaledZ = dataTileZoom + 1;
  if (overscaledZ > info.maxZoom) {
  // We're looking for an overzoomed child tile.
  const auto childDataTileID = idealDataTileID.scaledTo(overscaledZ);
- data = getTileData(childDataTileID);
+ data = getTile(childDataTileID);
  if (data && data->isRenderable()) {
- retainTileData(*data, false);
+ retainTile(*data, false);
  renderTile(idealRenderTileID, *data);
  } else {
  covered = false;
@@ -62,9 +62,9 @@ void updateRenderables(GetTileDataFn getTileData,
  // Check all four actual child tiles.
  for (const auto& childTileID : idealDataTileID.canonical.children()) {
  const OverscaledTileID childDataTileID(overscaledZ, childTileID);
- data = getTileData(childDataTileID);
+ data = getTile(childDataTileID);
  if (data && data->isRenderable()) {
- retainTileData(*data, false);
+ retainTile(*data, false);
  renderTile(childDataTileID.unwrapTo(idealRenderTileID.wrap), *data);
  } else {
  // At least one child tile doesn't exist, so we are going to look for
@@ -89,14 +89,14 @@ void updateRenderables(GetTileDataFn getTileData,
  checked.emplace(parentRenderTileID);
  }
 
- data = getTileData(parentDataTileID);
+ data = getTile(parentDataTileID);
  if (!data && triedPrevious) {
- data = createTileData(parentDataTileID);
+ data = createTile(parentDataTileID);
  }
 
  if (data) {
  triedPrevious = data->hasTriedOptional();
- retainTileData(*data, false);
+ retainTile(*data, false);
 
  if (data->isRenderable()) {
  renderTile(parentRenderTileID, *data);

src/mbgl/annotation/annotation_manager.cpp

@@ -5,7 +5,6 @@
 #include <mbgl/annotation/fill_annotation_impl.hpp>
 #include <mbgl/annotation/style_sourced_annotation_impl.hpp>
 #include <mbgl/style/source.hpp>
-#include <mbgl/tile/annotation_tile_data.hpp>
 #include <mbgl/style/style.hpp>
 #include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/layers/symbol_layer_impl.hpp>
@@ -81,13 +80,13 @@ AnnotationIDs AnnotationManager::getPointAnnotationsInBounds(const LatLngBounds&
  return result;
 }
 
-std::unique_ptr<AnnotationTile> AnnotationManager::getTile(const CanonicalTileID& tileID) {
+std::unique_ptr<AnnotationTileData> AnnotationManager::getTileData(const CanonicalTileID& tileID) {
  if (symbolAnnotations.empty() && shapeAnnotations.empty())
  return nullptr;
 
- auto tile = std::make_unique<AnnotationTile>();
+ auto tileData = std::make_unique<AnnotationTileData>();
 
- AnnotationTileLayer& pointLayer = *tile->layers.emplace(
+ AnnotationTileLayer& pointLayer = *tileData->layers.emplace(
  PointLayerID,
  std::make_unique<AnnotationTileLayer>(PointLayerID)).first->second;
 
@@ -99,10 +98,10 @@ std::unique_ptr<AnnotationTile> AnnotationManager::getTile(const CanonicalTileID
  }));
 
  for (const auto& shape : shapeAnnotations) {
- shape.second->updateTile(tileID, *tile);
+ shape.second->updateTileData(tileID, *tileData);
  }
 
- return tile;
+ return tileData;
 }
 
 void AnnotationManager::updateStyle(Style& style) {
@@ -135,18 +134,18 @@ void AnnotationManager::updateStyle(Style& style) {
 
  obsoleteShapeAnnotationLayers.clear();
 
- for (auto& data : monitors) {
- data->setData(getTile(data->id.canonical), {}, {});
+ for (auto& tile : tiles) {
+ tile->setData(getTileData(tile->id.canonical));
  }
 }
 
-void AnnotationManager::addTileData(AnnotationTileData& data) {
- monitors.insert(&data);
- data.setData(getTile(data.id.canonical), {}, {});
+void AnnotationManager::addTile(AnnotationTile& tile) {
+ tiles.insert(&tile);
+ tile.setData(getTileData(tile.id.canonical));
 }
 
-void AnnotationManager::removeTileData(AnnotationTileData& data) {
- monitors.erase(&data);
+void AnnotationManager::removeTile(AnnotationTile& tile) {
+ tiles.erase(&tile);
 }
 
 void AnnotationManager::addIcon(const std::string& name, std::shared_ptr<const SpriteImage> sprite) {

src/mbgl/annotation/annotation_manager.hpp

@@ -41,8 +41,8 @@ class AnnotationManager : private util::noncopyable {
 
  void updateStyle(style::Style&);
 
- void addTileData(AnnotationTileData&);
- void removeTileData(AnnotationTileData&);
+ void addTile(AnnotationTile&);
+ void removeTile(AnnotationTile&);
 
  static const std::string SourceID;
  static const std::string PointLayerID;
@@ -53,7 +53,7 @@ class AnnotationManager : private util::noncopyable {
  void add(const AnnotationID&, const FillAnnotation&, const uint8_t);
  void add(const AnnotationID&, const StyleSourcedAnnotation&, const uint8_t);
 
- std::unique_ptr<AnnotationTile> getTile(const CanonicalTileID&);
+ std::unique_ptr<AnnotationTileData> getTileData(const CanonicalTileID&);
 
  AnnotationID nextID = 0;
 
@@ -65,7 +65,7 @@ class AnnotationManager : private util::noncopyable {
  SymbolAnnotationMap symbolAnnotations;
  ShapeAnnotationMap shapeAnnotations;
  std::vector<std::string> obsoleteShapeAnnotationLayers;
- std::set<AnnotationTileData*> monitors;
+ std::set<AnnotationTile*> tiles;
 
  SpriteStore spriteStore;
  SpriteAtlas spriteAtlas;

src/mbgl/annotation/annotation_tile.cpp

@@ -2,11 +2,26 @@
 #include <mbgl/annotation/annotation_manager.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/storage/file_source.hpp>
+#include <mbgl/style/update_parameters.hpp>
 
 #include <utility>
 
 namespace mbgl {
 
+AnnotationTile::AnnotationTile(const OverscaledTileID& overscaledTileID,
+ std::string sourceID,
+ const style::UpdateParameters& parameters)
+ : GeometryTile(overscaledTileID, sourceID, parameters.style, parameters.mode),
+ annotationManager(parameters.annotationManager) {
+ annotationManager.addTile(*this);
+}
+
+AnnotationTile::~AnnotationTile() {
+ annotationManager.removeTile(*this);
+}
+
+void AnnotationTile::setNecessity(Necessity) {}
+
 AnnotationTileFeature::AnnotationTileFeature(FeatureType type_, GeometryCollection geometries_,
  std::unordered_map<std::string, std::string> properties_)
  : type(type_),
@@ -24,7 +39,7 @@ optional<Value> AnnotationTileFeature::getValue(const std::string& key) const {
 AnnotationTileLayer::AnnotationTileLayer(const std::string &name_)
  : name(name_) {}
 
-util::ptr<GeometryTileLayer> AnnotationTile::getLayer(const std::string& name) const {
+util::ptr<GeometryTileLayer> AnnotationTileData::getLayer(const std::string& name) const {
  auto it = layers.find(name);
  if (it != layers.end()) {
  return it->second;

src/mbgl/annotation/annotation_tile.hpp

@@ -1,9 +1,29 @@
 #pragma once
 
 #include <mbgl/tile/geometry_tile.hpp>
+#include <mbgl/tile/geometry_tile_data.hpp>
 
 namespace mbgl {
 
+class AnnotationManager;
+
+namespace style {
+class UpdateParameters;
+}
+
+class AnnotationTile : public GeometryTile {
+public:
+ AnnotationTile(const OverscaledTileID&,
+ std::string sourceID,
+ const style::UpdateParameters&);
+ ~AnnotationTile();
+
+ void setNecessity(Necessity) final;
+
+private:
+ AnnotationManager& annotationManager;
+};
+
 class AnnotationTileFeature : public GeometryTileFeature {
 public:
  AnnotationTileFeature(FeatureType, GeometryCollection,
@@ -32,7 +52,7 @@ class AnnotationTileLayer : public GeometryTileLayer {
  std::string name;
 };
 
-class AnnotationTile : public GeometryTile {
+class AnnotationTileData : public GeometryTileData {
 public:
  util::ptr<GeometryTileLayer> getLayer(const std::string&) const override;
 

src/mbgl/annotation/shape_annotation_impl.cpp

@@ -85,7 +85,7 @@ struct ToGeoJSONVT {
  }
 };
 
-void ShapeAnnotationImpl::updateTile(const CanonicalTileID& tileID, AnnotationTile& tile) {
+void ShapeAnnotationImpl::updateTileData(const CanonicalTileID& tileID, AnnotationTileData& data) {
  static const double baseTolerance = 4;
 
  if (!shapeTiler) {
@@ -108,7 +108,7 @@ void ShapeAnnotationImpl::updateTile(const CanonicalTileID& tileID, AnnotationTi
  if (!shapeTile)
  return;
 
- AnnotationTileLayer& layer = *tile.layers.emplace(layerID,
+ AnnotationTileLayer& layer = *data.layers.emplace(layerID,
  std::make_unique<AnnotationTileLayer>(layerID)).first->second;
 
  for (auto& shapeFeature : shapeTile.features) {

src/mbgl/annotation/shape_annotation_impl.hpp

@@ -9,7 +9,7 @@
 
 namespace mbgl {
 
-class AnnotationTile;
+class AnnotationTileData;
 class CanonicalTileID;
 
 namespace style {
@@ -24,7 +24,7 @@ class ShapeAnnotationImpl {
  virtual void updateStyle(style::Style&) const = 0;
  virtual const ShapeAnnotationGeometry& geometry() const = 0;
 
- void updateTile(const CanonicalTileID&, AnnotationTile&);
+ void updateTileData(const CanonicalTileID&, AnnotationTileData&);
 
  const AnnotationID id;
  const uint8_t maxZoom;

src/mbgl/geometry/feature_index.cpp

@@ -57,7 +57,7 @@ void FeatureIndex::query(
  const double tileSize,
  const double scale,
  const optional<std::vector<std::string>>& filterLayerIDs,
- const GeometryTile& geometryTile,
+ const GeometryTileData& geometryTileData,
  const CanonicalTileID& tileID,
  const style::Style& style) const {
 
@@ -75,15 +75,15 @@ void FeatureIndex::query(
  if (indexedFeature.sortIndex == previousSortIndex) continue;
  previousSortIndex = indexedFeature.sortIndex;
 
- addFeature(result, indexedFeature, queryGeometry, filterLayerIDs, geometryTile, tileID, style, bearing, pixelsToTileUnits);
+ addFeature(result, indexedFeature, queryGeometry, filterLayerIDs, geometryTileData, tileID, style, bearing, pixelsToTileUnits);
  }
 
  // query symbol features
  assert(collisionTile);
  std::vector<IndexedSubfeature> symbolFeatures = collisionTile->queryRenderedSymbols(box, scale);
  std::sort(symbolFeatures.begin(), symbolFeatures.end(), topDownSymbols);
  for (const auto& symbolFeature : symbolFeatures) {
- addFeature(result, symbolFeature, queryGeometry, filterLayerIDs, geometryTile, tileID, style, bearing, pixelsToTileUnits);
+ addFeature(result, symbolFeature, queryGeometry, filterLayerIDs, geometryTileData, tileID, style, bearing, pixelsToTileUnits);
  }
 }
 
@@ -92,7 +92,7 @@ void FeatureIndex::addFeature(
  const IndexedSubfeature& indexedFeature,
  const GeometryCollection& queryGeometry,
  const optional<std::vector<std::string>>& filterLayerIDs,
- const GeometryTile& geometryTile,
+ const GeometryTileData& geometryTileData,
  const CanonicalTileID& tileID,
  const style::Style& style,
  const float bearing,
@@ -103,7 +103,7 @@ void FeatureIndex::addFeature(
  return;
  }
 
- auto sourceLayer = geometryTile.getLayer(indexedFeature.sourceLayerName);
+ auto sourceLayer = geometryTileData.getLayer(indexedFeature.sourceLayerName);
  assert(sourceLayer);
 
  auto geometryTileFeature = sourceLayer->getFeature(indexedFeature.index);

src/mbgl/geometry/feature_index.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <mbgl/style/types.hpp>
-#include <mbgl/tile/geometry_tile.hpp>
+#include <mbgl/tile/geometry_tile_data.hpp>
 #include <mbgl/util/grid_index.hpp>
 #include <mbgl/util/feature.hpp>
 
@@ -40,7 +40,7 @@ class FeatureIndex {
  const double tileSize,
  const double scale,
  const optional<std::vector<std::string>>& layerIDs,
- const GeometryTile&,
+ const GeometryTileData&,
  const CanonicalTileID&,
  const style::Style&) const;
 
@@ -61,7 +61,7 @@ class FeatureIndex {
  const IndexedSubfeature&,
  const GeometryCollection& queryGeometry,
  const optional<std::vector<std::string>>& filterLayerIDs,
- const GeometryTile&,
+ const GeometryTileData&,
  const CanonicalTileID&,
  const style::Style&,
  const float bearing,

src/mbgl/renderer/circle_bucket.hpp

@@ -2,7 +2,7 @@
 
 #include <mbgl/renderer/bucket.hpp>
 #include <mbgl/map/mode.hpp>
-#include <mbgl/tile/geometry_tile.hpp>
+#include <mbgl/tile/geometry_tile_data.hpp>
 #include <mbgl/geometry/elements_buffer.hpp>
 #include <mbgl/geometry/circle_buffer.hpp>