tei/MapLibreParticleLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[core] Rename data ⇢ tile; use Resource::Necessity

Browse Source
This commit is contained in:
John Firebaugh
2016-08-23 11:52:12 -07:00
parent 8ac03f3870
commit a79d2afe1b
3 changed files with 168 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
src/mbgl/algorithm/update_renderables.hpp
View File

@@ -2,6 +2,7 @@
#include <mbgl/tile/tile_id.hpp>
#include <mbgl/util/range.hpp>
#include <mbgl/storage/resource.hpp>
#include <set>
@@ -31,30 +32,30 @@ void updateRenderables(GetTileFn getTile,
assert(dataTileZoom >= idealRenderTileID.canonical.z);
const OverscaledTileID idealDataTileID(dataTileZoom, idealRenderTileID.canonical);
auto data = getTile(idealDataTileID);
if (!data) {
data = createTile(idealDataTileID);
assert(data);
auto tile = getTile(idealDataTileID);
if (!tile) {
tile = createTile(idealDataTileID);
assert(tile);
}
// if (source has the tile and bucket is loaded) {
if (data->isRenderable()) {
retainTile(*data, true);
renderTile(idealRenderTileID, *data);
if (tile->isRenderable()) {
retainTile(*tile, Resource::Necessity::Required);
renderTile(idealRenderTileID, *tile);
} else {
bool triedPrevious = data->hasTriedOptional();
bool triedPrevious = tile->hasTriedOptional();
// The tile isn't loaded yet, but retain it anyway because it's an ideal tile.
retainTile(*data, true);
retainTile(*tile, Resource::Necessity::Required);
covered = true;
overscaledZ = dataTileZoom + 1;
if (overscaledZ > zoomRange.max) {
// We're looking for an overzoomed child tile.
const auto childDataTileID = idealDataTileID.scaledTo(overscaledZ);
data = getTile(childDataTileID);
if (data && data->isRenderable()) {
retainTile(*data, false);
renderTile(idealRenderTileID, *data);
tile = getTile(childDataTileID);
if (tile && tile->isRenderable()) {
retainTile(*tile, Resource::Necessity::Optional);
renderTile(idealRenderTileID, *tile);
} else {
covered = false;
}
@@ -62,10 +63,10 @@ void updateRenderables(GetTileFn getTile,
// Check all four actual child tiles.
for (const auto& childTileID : idealDataTileID.canonical.children()) {
const OverscaledTileID childDataTileID(overscaledZ, childTileID);
data = getTile(childDataTileID);
if (data && data->isRenderable()) {
retainTile(*data, false);
renderTile(childDataTileID.unwrapTo(idealRenderTileID.wrap), *data);
tile = getTile(childDataTileID);
if (tile && tile->isRenderable()) {
retainTile(*tile, Resource::Necessity::Optional);
renderTile(childDataTileID.unwrapTo(idealRenderTileID.wrap), *tile);
} else {
// At least one child tile doesn't exist, so we are going to look for
// parents as well.
@@ -89,17 +90,17 @@ void updateRenderables(GetTileFn getTile,
checked.emplace(parentRenderTileID);
}
data = getTile(parentDataTileID);
if (!data && triedPrevious) {
data = createTile(parentDataTileID);
tile = getTile(parentDataTileID);
if (!tile && triedPrevious) {
tile = createTile(parentDataTileID);
}
if (data) {
triedPrevious = data->hasTriedOptional();
retainTile(*data, false);
if (tile) {
triedPrevious = tile->hasTriedOptional();
retainTile(*tile, Resource::Necessity::Optional);
if (data->isRenderable()) {
renderTile(parentRenderTileID, *data);
if (tile->isRenderable()) {
renderTile(parentRenderTileID, *tile);
// Break parent tile ascent, since we found one.
break;
}

55
src/mbgl/style/source_impl.cpp
View File

@@ -89,7 +89,7 @@ bool Source::Impl::update(const UpdateParameters& parameters) {
// Determine the overzooming/underzooming amounts and required tiles.
int32_t overscaledZoom = util::coveringZoomLevel(parameters.transformState.getZoom(), type, tileSize);
int32_t dataTileZoom = overscaledZoom;
int32_t tileZoom = overscaledZoom;
std::vector<UnwrappedTileID> idealTiles;
if (overscaledZoom >= zoomRange.min) {
@@ -97,48 +97,46 @@ bool Source::Impl::update(const UpdateParameters& parameters) {
// Make sure we're not reparsing overzoomed raster tiles.
if (type == SourceType::Raster) {
dataTileZoom = idealZoom;
tileZoom = idealZoom;
}
idealTiles = util::tileCover(parameters.transformState, idealZoom);
}
// Stores a list of all the data tiles that we're definitely going to retain. There are two
// Stores a list of all the tiles that we're definitely going to retain. There are two
// kinds of tiles we need: the ideal tiles determined by the tile cover. They may not yet be in
// use because they're still loading. In addition to that, we also need to retain all tiles that
// we're actively using, e.g. as a replacement for tile that aren't loaded yet.
std::set<OverscaledTileID> retain;
auto retainTileFn = [&retain](Tile& tile, bool required) -> void {
auto retainTileFn = [&retain](Tile& tile, Resource::Necessity necessity) -> void {
retain.emplace(tile.id);
tile.setNecessity(required ? Tile::Necessity::Required
: Tile::Necessity::Optional);
tile.setNecessity(necessity);
};
auto getTileFn = [this](const OverscaledTileID& tileID) -> Tile* {
auto it = tiles.find(tileID);
return it == tiles.end() ? nullptr : it->second.get();
};
auto createTileFn = [this, &parameters](const OverscaledTileID& dataTileID) -> Tile* {
std::unique_ptr<Tile> data = cache.get(dataTileID);
if (!data) {
data = createTile(dataTileID, parameters);
if (data) {
data->setObserver(this);
auto createTileFn = [this, &parameters](const OverscaledTileID& tileID) -> Tile* {
std::unique_ptr<Tile> tile = cache.get(tileID);
if (!tile) {
tile = createTile(tileID, parameters);
if (tile) {
tile->setObserver(this);
}
}
if (data) {
return tiles.emplace(dataTileID, std::move(data)).first->second.get();
} else {
if (!tile) {
return nullptr;
}
return tiles.emplace(tileID, std::move(tile)).first->second.get();
};
auto renderTileFn = [this](const UnwrappedTileID& renderTileID, Tile& tile) {
renderTiles.emplace(renderTileID, RenderTile{ renderTileID, tile });
auto renderTileFn = [this](const UnwrappedTileID& tileID, Tile& tile) {
renderTiles.emplace(tileID, RenderTile{ tileID, tile });
};
renderTiles.clear();
algorithm::updateRenderables(getTileFn, createTileFn, retainTileFn, renderTileFn,
idealTiles, zoomRange, dataTileZoom);
idealTiles, zoomRange, tileZoom);
if (type != SourceType::Raster && type != SourceType::Annotations && cache.getSize() == 0) {
size_t conservativeCacheSize =
@@ -149,19 +147,18 @@ bool Source::Impl::update(const UpdateParameters& parameters) {
cache.setSize(conservativeCacheSize);
}
// Remove stale data tiles from the active set of tiles.
// This goes through the (sorted!) tiles and retain set in lockstep and removes items from
// tiles that don't have the corresponding key in the retain set.
auto dataIt = tiles.begin();
// Remove stale tiles. This goes through the (sorted!) tiles map and retain set in lockstep
// and removes items from tiles that don't have the corresponding key in the retain set.
auto tilesIt = tiles.begin();
auto retainIt = retain.begin();
while (dataIt != tiles.end()) {
if (retainIt == retain.end() || dataIt->first < *retainIt) {
dataIt->second->setNecessity(Tile::Necessity::Optional);
cache.add(dataIt->first, std::move(dataIt->second));
tiles.erase(dataIt++);
while (tilesIt != tiles.end()) {
if (retainIt == retain.end() || tilesIt->first < *retainIt) {
tilesIt->second->setNecessity(Tile::Necessity::Optional);
cache.add(tilesIt->first, std::move(tilesIt->second));
tiles.erase(tilesIt++);
} else {
if (!(*retainIt < dataIt->first)) {
++dataIt;
if (!(*retainIt < tilesIt->first)) {
++tilesIt;
}
++retainIt;
}