[general] moving ios and android project under ./platform folder
This commit is contained in:
138
src/mbgl/algorithm/update_renderables.hpp
Normal file
138
src/mbgl/algorithm/update_renderables.hpp
Normal file
@@ -0,0 +1,138 @@
|
||||
#pragma once
|
||||
|
||||
#include <mbgl/tile/tile_id.hpp>
|
||||
#include <mbgl/tile/tile_necessity.hpp>
|
||||
#include <mbgl/util/optional.hpp>
|
||||
#include <mbgl/util/range.hpp>
|
||||
|
||||
#include <unordered_set>
|
||||
|
||||
namespace mbgl {
|
||||
namespace algorithm {
|
||||
|
||||
template <typename GetTileFn,
|
||||
typename CreateTileFn,
|
||||
typename RetainTileFn,
|
||||
typename RenderTileFn,
|
||||
typename IdealTileIDs>
|
||||
void updateRenderables(GetTileFn getTile,
|
||||
CreateTileFn createTile,
|
||||
RetainTileFn retainTile,
|
||||
RenderTileFn renderTile,
|
||||
const IdealTileIDs& idealTileIDs,
|
||||
const Range<uint8_t>& zoomRange,
|
||||
const optional<uint8_t>& maxParentOverscaleFactor = nullopt) {
|
||||
std::unordered_set<OverscaledTileID> checked;
|
||||
bool covered;
|
||||
int32_t overscaledZ;
|
||||
|
||||
// for (all in the set of ideal tiles of the source) {
|
||||
for (const auto& idealDataTileID : idealTileIDs) {
|
||||
assert(idealDataTileID.canonical.z >= zoomRange.min);
|
||||
assert(idealDataTileID.canonical.z <= zoomRange.max);
|
||||
assert(idealDataTileID.overscaledZ >= idealDataTileID.canonical.z);
|
||||
|
||||
const UnwrappedTileID idealRenderTileID = idealDataTileID.toUnwrapped();
|
||||
auto tile = getTile(idealDataTileID);
|
||||
if (!tile) {
|
||||
tile = createTile(idealDataTileID);
|
||||
// For source types where TileJSON.bounds is set, tiles outside the
|
||||
// bounds are not created
|
||||
if(tile == nullptr) {
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
// if (source has the tile and bucket is loaded) {
|
||||
if (tile->isRenderable()) {
|
||||
retainTile(*tile, TileNecessity::Required);
|
||||
renderTile(idealRenderTileID, *tile);
|
||||
} else {
|
||||
// We are now attempting to load child and parent tiles.
|
||||
bool parentHasTriedOptional = tile->hasTriedCache();
|
||||
bool parentIsLoaded = tile->isLoaded();
|
||||
|
||||
// The tile isn't loaded yet, but retain it anyway because it's an ideal tile.
|
||||
retainTile(*tile, TileNecessity::Required);
|
||||
covered = true;
|
||||
overscaledZ = idealDataTileID.overscaledZ + 1;
|
||||
if (overscaledZ > zoomRange.max) {
|
||||
// We're looking for an overzoomed child tile.
|
||||
const auto childDataTileID = idealDataTileID.scaledTo(overscaledZ);
|
||||
tile = getTile(childDataTileID);
|
||||
if (tile && tile->isRenderable()) {
|
||||
retainTile(*tile, TileNecessity::Optional);
|
||||
renderTile(idealRenderTileID, *tile);
|
||||
} else {
|
||||
covered = false;
|
||||
}
|
||||
} else {
|
||||
// Check all four actual child tiles.
|
||||
for (const auto& childTileID : idealDataTileID.canonical.children()) {
|
||||
const OverscaledTileID childDataTileID(overscaledZ, idealRenderTileID.wrap, childTileID);
|
||||
tile = getTile(childDataTileID);
|
||||
if (tile && tile->isRenderable()) {
|
||||
retainTile(*tile, TileNecessity::Optional);
|
||||
renderTile(childDataTileID.toUnwrapped(), *tile);
|
||||
} else {
|
||||
// At least one child tile doesn't exist, so we are going to look for
|
||||
// parents as well.
|
||||
covered = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!covered) {
|
||||
// We couldn't find child tiles that entirely cover the ideal tile.
|
||||
for (overscaledZ = idealDataTileID.overscaledZ - 1; overscaledZ >= zoomRange.min; --overscaledZ) {
|
||||
const auto parentDataTileID = idealDataTileID.scaledTo(overscaledZ);
|
||||
|
||||
// Request / render parent tile only if it's overscale factor is less than defined maximum.
|
||||
if (maxParentOverscaleFactor &&
|
||||
(idealDataTileID.overscaledZ - overscaledZ) > *maxParentOverscaleFactor) {
|
||||
break;
|
||||
}
|
||||
|
||||
if (checked.find(parentDataTileID) != checked.end()) {
|
||||
// Break parent tile ascent, this route has been checked by another child
|
||||
// tile before.
|
||||
break;
|
||||
} else {
|
||||
checked.emplace(parentDataTileID);
|
||||
}
|
||||
|
||||
tile = getTile(parentDataTileID);
|
||||
if (!tile && (parentHasTriedOptional || parentIsLoaded)) {
|
||||
tile = createTile(parentDataTileID);
|
||||
}
|
||||
|
||||
if (tile) {
|
||||
if (!parentIsLoaded) {
|
||||
// We haven't completed loading the child, so we only do an optional
|
||||
// (cache) request in an attempt to quickly load data that we can show.
|
||||
retainTile(*tile, TileNecessity::Optional);
|
||||
} else {
|
||||
// Now that we've checked the child and know for sure that we can't load
|
||||
// it, we attempt to load the parent from the network.
|
||||
retainTile(*tile, TileNecessity::Required);
|
||||
}
|
||||
|
||||
// Save the current values, since they're the parent of the next iteration
|
||||
// of the parent tile ascent loop.
|
||||
parentHasTriedOptional = tile->hasTriedCache();
|
||||
parentIsLoaded = tile->isLoaded();
|
||||
|
||||
if (tile->isRenderable()) {
|
||||
renderTile(parentDataTileID.toUnwrapped(), *tile);
|
||||
// Break parent tile ascent, since we found one.
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace algorithm
|
||||
} // namespace mbgl
|
||||
132
src/mbgl/algorithm/update_tile_masks.hpp
Normal file
132
src/mbgl/algorithm/update_tile_masks.hpp
Normal file
@@ -0,0 +1,132 @@
|
||||
#pragma once
|
||||
|
||||
#include <mbgl/renderer/tile_mask.hpp>
|
||||
|
||||
#include <vector>
|
||||
#include <functional>
|
||||
#include <algorithm>
|
||||
|
||||
namespace mbgl {
|
||||
namespace algorithm {
|
||||
|
||||
template <typename T>
|
||||
bool tileNeedsMask(const std::reference_wrapper<T>& tile) { return tile.get().usedByRenderedLayers; }
|
||||
template <typename T>
|
||||
void setTileMask(const std::reference_wrapper<T>& tile, TileMask&& mask ) { return tile.get().setMask(std::move(mask)); }
|
||||
|
||||
// Overloads for tests
|
||||
template <typename T> bool tileNeedsMask(const T& tile) { return tile.usedByRenderedLayers; }
|
||||
template <typename T> void setTileMask(T& tile, TileMask&& mask ) { return tile.setMask(std::move(mask)); }
|
||||
|
||||
template <typename Iterator>
|
||||
void computeTileMasks(
|
||||
const CanonicalTileID& root,
|
||||
const UnwrappedTileID& ref,
|
||||
const Iterator begin,
|
||||
const Iterator end,
|
||||
TileMask& mask) {
|
||||
// If the reference or any of its children is found in the list, we need to recurse.
|
||||
for (auto it = begin; it != end; ++it) {
|
||||
const UnwrappedTileID& id = it->first;
|
||||
if (!tileNeedsMask(it->second)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (ref == id) {
|
||||
// The current tile is masked out, so we don't need to add them to the mask set.
|
||||
return;
|
||||
}
|
||||
|
||||
if (id.isChildOf(ref)) {
|
||||
// There's at least one child tile that is masked out, so recursively descend.
|
||||
for (const auto& child : ref.children()) {
|
||||
computeTileMasks(root, child, it, end, mask);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// We couldn't find a child, so it's definitely a masked part.
|
||||
// Compute the difference between the root tile ID and the reference tile ID, since TileMask
|
||||
// elements are always relative (see below for explanation).
|
||||
const uint8_t diffZ = ref.canonical.z - root.z;
|
||||
mask.emplace(diffZ, ref.canonical.x - (root.x << diffZ), ref.canonical.y - (root.y << diffZ));
|
||||
}
|
||||
|
||||
// Updates the TileMasks for all renderable tiles. Each renderable tile has a corresponding UnwrappedTileID
|
||||
// indicating where it should be rendered on the screen. A TileMask describes all regions
|
||||
// within a renderable tile that are *not* covered by other renderable tiles.
|
||||
// Example: Renderable tiles in our list are 2/1/3, 3/3/6, and 4/5/13. The schematic for creating the
|
||||
// TileMask for 2/1/3 looks like this:
|
||||
//
|
||||
// ┌────────┬────────┬─────────────────┐
|
||||
// │ │ │#################│
|
||||
// │ 4/4/12 │ 4/5/12 │#################│
|
||||
// │ │ │#################│
|
||||
// ├──────3/2/6──────┤#####3/3/6#######│
|
||||
// │ │########│#################│
|
||||
// │ 4/4/13 │#4/5/13#│#################│
|
||||
// │ │########│#################│
|
||||
// ├────────┴──────2/1/3───────────────┤
|
||||
// │ │ │
|
||||
// │ │ │
|
||||
// │ │ │
|
||||
// │ 3/2/7 │ 3/3/7 │
|
||||
// │ │ │
|
||||
// │ │ │
|
||||
// │ │ │
|
||||
// └─────────────────┴─────────────────┘
|
||||
//
|
||||
// The TileMask for 2/1/3 thus consists of the tiles 4/4/12, 4/5/12, 4/4/13, 3/2/7, and 3/3/7,
|
||||
// but it does *not* include 4/5/13, and 3/3/6, since these are other renderable tiles.
|
||||
// A TileMask always contains TileIDs *relative* to the tile it is generated for, so 2/1/3 is
|
||||
// "subtracted" from these TileIDs. The final TileMask for 2/1/3 will thus be:
|
||||
//
|
||||
// ┌────────┬────────┬─────────────────┐
|
||||
// │ │ │#################│
|
||||
// │ 2/0/0 │ 2/1/0 │#################│
|
||||
// │ │ │#################│
|
||||
// ├────────┼────────┤#################│
|
||||
// │ │########│#################│
|
||||
// │ 2/0/1 │########│#################│
|
||||
// │ │########│#################│
|
||||
// ├────────┴────────┼─────────────────┤
|
||||
// │ │ │
|
||||
// │ │ │
|
||||
// │ │ │
|
||||
// │ 1/0/1 │ 1/1/1 │
|
||||
// │ │ │
|
||||
// │ │ │
|
||||
// │ │ │
|
||||
// └─────────────────┴─────────────────┘
|
||||
//
|
||||
// Only other renderable tiles that are *children* of the renderable tile we are generating the mask for will
|
||||
// will be considered. For example, adding a renderable tile with TileID 4/8/13 won't affect the TileMask for
|
||||
// 2/1/3, since it is not a descendant of it.
|
||||
template <typename RenderableTilesMap>
|
||||
void updateTileMasks(RenderableTilesMap& renderables) {
|
||||
TileMask mask;
|
||||
const auto end = renderables.end();
|
||||
for (auto it = renderables.begin(); it != end; ++it) {
|
||||
const UnwrappedTileID& id = it->first;
|
||||
if (!tileNeedsMask(it->second)) {
|
||||
continue;
|
||||
}
|
||||
// Try to add all remaining ids as children. We sorted the tile list
|
||||
// by z earlier, so all preceding items cannot be children of the current
|
||||
// tile. We also compute the lower bound of the next wrap, because items of the next wrap
|
||||
// can never be children of the current wrap.
|
||||
auto child_it = std::next(it);
|
||||
const auto children_end = std::lower_bound(
|
||||
child_it, end,
|
||||
UnwrappedTileID{ static_cast<int16_t>(id.wrap + 1), { 0, 0, 0 } },
|
||||
[](auto& a, auto& b) { return a.first < b; });
|
||||
|
||||
mask.clear();
|
||||
computeTileMasks(id.canonical, id, child_it, children_end, mask);
|
||||
setTileMask(it->second, std::move(mask));
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace algorithm
|
||||
} // namespace mbgl
|
||||
Reference in New Issue
Block a user