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

[core] Introduce TileRenderData

Browse Source 
Remove rendering functionality from Tile implementations.
This commit is contained in:
Mikhail Pozdnyakov
2019-07-01 21:44:15 +03:00
parent b1cbc2f245
commit 63dd17e2bb
15 changed files with 268 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/core-files.json
View File

@@ -143,6 +143,7 @@
"src/mbgl/renderer/sources/render_vector_source.cpp",
"src/mbgl/renderer/style_diff.cpp",
"src/mbgl/renderer/tile_pyramid.cpp",
"src/mbgl/renderer/tile_render_data.cpp",
"src/mbgl/sprite/sprite_loader.cpp",
"src/mbgl/sprite/sprite_loader_worker.cpp",
"src/mbgl/sprite/sprite_parser.cpp",
@@ -665,6 +666,7 @@
"mbgl/renderer/tile_mask.hpp": "src/mbgl/renderer/tile_mask.hpp",
"mbgl/renderer/tile_parameters.hpp": "src/mbgl/renderer/tile_parameters.hpp",
"mbgl/renderer/tile_pyramid.hpp": "src/mbgl/renderer/tile_pyramid.hpp",
"mbgl/renderer/tile_render_data.hpp": "src/mbgl/renderer/tile_render_data.hpp",
"mbgl/renderer/transition_parameters.hpp": "src/mbgl/renderer/transition_parameters.hpp",
"mbgl/renderer/update_parameters.hpp": "src/mbgl/renderer/update_parameters.hpp",
"mbgl/renderer/upload_parameters.hpp": "src/mbgl/renderer/upload_parameters.hpp",

33
src/mbgl/renderer/render_tile.cpp
View File

@@ -4,6 +4,7 @@
#include <mbgl/renderer/buckets/debug_bucket.hpp>
#include <mbgl/renderer/render_source.hpp>
#include <mbgl/renderer/render_static_data.hpp>
#include <mbgl/renderer/tile_render_data.hpp>
#include <mbgl/programs/programs.hpp>
#include <mbgl/map/transform_state.hpp>
#include <mbgl/gfx/cull_face_mode.hpp>
@@ -15,7 +16,8 @@ namespace mbgl {
using namespace style;
RenderTile::RenderTile(UnwrappedTileID id_, Tile& tile_) : id(std::move(id_)), tile(tile_) {
RenderTile::RenderTile(UnwrappedTileID id_, Tile& tile_)
: id(std::move(id_)), tile(tile_) {
}
RenderTile::~RenderTile() = default;
@@ -65,32 +67,33 @@ const OverscaledTileID& RenderTile::getOverscaledTileID() const { return tile.id
bool RenderTile::holdForFade() const { return tile.holdForFade(); }
Bucket* RenderTile::getBucket(const style::Layer::Impl& impl) const {
return tile.getBucket(impl);
assert(renderData);
return renderData->getBucket(impl);
}
const LayerRenderData* RenderTile::getLayerRenderData(const style::Layer::Impl& impl) const {
return tile.getLayerRenderData(impl);
assert(renderData);
return renderData->getLayerRenderData(impl);
}
optional<ImagePosition> RenderTile::getPattern(const std::string& pattern) const {
assert(tile.kind == Tile::Kind::Geometry);
return static_cast<const GeometryTile&>(tile).getPattern(pattern);
assert(renderData);
return renderData->getPattern(pattern);
}
const gfx::Texture& RenderTile::getGlyphAtlasTexture() const {
assert(tile.kind == Tile::Kind::Geometry);
assert(static_cast<const GeometryTile&>(tile).glyphAtlasTexture);
return *(static_cast<const GeometryTile&>(tile).glyphAtlasTexture);
assert(renderData);
return renderData->getGlyphAtlasTexture();
}
const gfx::Texture& RenderTile::getIconAtlasTexture() const {
assert(tile.kind == Tile::Kind::Geometry);
assert(static_cast<const GeometryTile&>(tile).iconAtlasTexture);
return *(static_cast<const GeometryTile&>(tile).iconAtlasTexture);
assert(renderData);
return renderData->getIconAtlasTexture();
}
void RenderTile::upload(gfx::UploadPass& uploadPass) {
tile.upload(uploadPass);
assert(renderData);
renderData->upload(uploadPass);
if (debugBucket) {
debugBucket->upload(uploadPass);
@@ -98,6 +101,10 @@ void RenderTile::upload(gfx::UploadPass& uploadPass) {
}
void RenderTile::prepare(const SourcePrepareParameters& parameters) {
renderData = tile.createRenderData();
assert(renderData);
needsRendering = tile.usedByRenderedLayers;
if (parameters.debugOptions != MapDebugOptions::NoDebug &&
(!debugBucket || debugBucket->renderable != tile.isRenderable() ||
debugBucket->complete != tile.isComplete() ||
@@ -121,7 +128,7 @@ void RenderTile::prepare(const SourcePrepareParameters& parameters) {
}
void RenderTile::finishRender(PaintParameters& parameters) {
if (!tile.usedByRenderedLayers || parameters.debugOptions == MapDebugOptions::NoDebug)
if (!needsRendering || parameters.debugOptions == MapDebugOptions::NoDebug)
return;
static const style::Properties<>::PossiblyEvaluated properties {};

7
src/mbgl/renderer/render_tile.hpp
View File

@@ -4,10 +4,9 @@
#include <mbgl/gfx/texture.hpp>
#include <mbgl/tile/tile_id.hpp>
#include <mbgl/util/mat4.hpp>
#include <mbgl/renderer/image_atlas.hpp>
#include <mbgl/style/layer_impl.hpp>
#include <mbgl/style/types.hpp>
#include <mbgl/renderer/image_atlas.hpp>
#include <mbgl/renderer/tile_mask.hpp>
#include <array>
#include <memory>
@@ -26,6 +25,7 @@ class PaintParameters;
class DebugBucket;
class SourcePrepareParameters;
class FeatureIndex;
class TileRenderData;
class RenderTile final {
public:
@@ -70,6 +70,9 @@ public:
const bool inViewportPixelUnits) const;
private:
Tile& tile;
// The following members are reset at placement stage.
std::unique_ptr<TileRenderData> renderData;
bool needsRendering = false;
};
} // namespace mbgl

1
src/mbgl/renderer/sources/render_tile_source.cpp
View File

@@ -3,6 +3,7 @@
#include <mbgl/renderer/buckets/debug_bucket.hpp>
#include <mbgl/renderer/render_tile.hpp>
#include <mbgl/renderer/paint_parameters.hpp>
#include <mbgl/renderer/tile_render_data.hpp>
#include <mbgl/tile/vector_tile.hpp>
namespace mbgl {

40
src/mbgl/renderer/tile_render_data.cpp Normal file
View File

@@ -0,0 +1,40 @@
#include <mbgl/renderer/tile_render_data.hpp>
namespace mbgl {
TileRenderData::TileRenderData() = default;
TileRenderData::TileRenderData(std::shared_ptr<TileAtlasTextures> atlasTextures_)
: atlasTextures(std::move(atlasTextures_)) {
}
TileRenderData::~TileRenderData() = default;
const gfx::Texture& TileRenderData::getGlyphAtlasTexture() const {
assert(atlasTextures);
assert(atlasTextures->glyph);
return *atlasTextures->glyph;
}
const gfx::Texture& TileRenderData::getIconAtlasTexture() const {
assert(atlasTextures);
assert(atlasTextures->icon);
return *atlasTextures->icon;
}
optional<ImagePosition> TileRenderData::getPattern(const std::string&) const {
assert(false);
return nullopt;
}
const LayerRenderData* TileRenderData::getLayerRenderData(const style::Layer::Impl&) const {
assert(false);
return nullptr;
}
Bucket* TileRenderData::getBucket(const style::Layer::Impl&) const {
assert(false);
return nullptr;
}
} // namespace mbgl

61
src/mbgl/renderer/tile_render_data.hpp Normal file
View File

@@ -0,0 +1,61 @@
#pragma once
#include <mbgl/gfx/texture.hpp>
#include <mbgl/renderer/image_atlas.hpp>
#include <mbgl/style/layer_impl.hpp>
#include <memory>
namespace mbgl {
namespace gfx {
class UploadPass;
} // namespace gfx
class Bucket;
class LayerRenderData;
class SourcePrepareParameters;
class TileAtlasTextures {
public:
optional<gfx::Texture> glyph;
optional<gfx::Texture> icon;
};
class TileRenderData {
public:
virtual ~TileRenderData();
const gfx::Texture& getGlyphAtlasTexture() const;
const gfx::Texture& getIconAtlasTexture() const;
// To be implemented for concrete tile types.
virtual optional<ImagePosition> getPattern(const std::string&) const;
virtual const LayerRenderData* getLayerRenderData(const style::Layer::Impl&) const;
virtual Bucket* getBucket(const style::Layer::Impl&) const;
virtual void upload(gfx::UploadPass&) {}
virtual void prepare(const SourcePrepareParameters&) {}
protected:
TileRenderData();
TileRenderData(std::shared_ptr<TileAtlasTextures>);
std::shared_ptr<TileAtlasTextures> atlasTextures;
};
template <typename BucketType>
class SharedBucketTileRenderData final : public TileRenderData {
public:
SharedBucketTileRenderData(std::shared_ptr<BucketType> bucket_)
: bucket(std::move(bucket_)) {}
private:
// TileRenderData overrides.
Bucket* getBucket(const style::Layer::Impl&) const override {
return bucket ? bucket.get() : nullptr;
}
void upload(gfx::UploadPass& uploadPass) override {
if (bucket) bucket->upload(uploadPass);
}
std::shared_ptr<BucketType> bucket;
};
} // namespace mbgl

165
src/mbgl/tile/geometry_tile.cpp
View File

@@ -18,11 +18,98 @@
#include <mbgl/map/transform_state.hpp>
#include <mbgl/util/logging.hpp>
#include <mbgl/actor/scheduler.hpp>
#include <mbgl/renderer/tile_render_data.hpp>
namespace mbgl {
LayerRenderData* GeometryTile::LayoutResult::getLayerRenderData(const style::Layer::Impl& layerImpl) {
auto it = layerRenderData.find(layerImpl.id);
if (it == layerRenderData.end()) {
return nullptr;
}
LayerRenderData& result = it->second;
if (result.layerProperties->baseImpl->getTypeInfo() != layerImpl.getTypeInfo()) {
// Layer data might be outdated, see issue #12432.
return nullptr;
}
return &result;
}
class GeometryTileRenderData final : public TileRenderData {
public:
GeometryTileRenderData(
std::shared_ptr<GeometryTile::LayoutResult> layoutResult_,
std::shared_ptr<TileAtlasTextures> atlasTextures_,
ImageManager& imageManager_)
: TileRenderData(std::move(atlasTextures_))
, layoutResult(std::move(layoutResult_))
, imageManager(imageManager_) {
}
private:
// TileRenderData overrides.
optional<ImagePosition> getPattern(const std::string&) const override;
const LayerRenderData* getLayerRenderData(const style::Layer::Impl&) const override;
Bucket* getBucket(const style::Layer::Impl&) const override;
void upload(gfx::UploadPass&) override;
std::shared_ptr<GeometryTile::LayoutResult> layoutResult;
ImageManager& imageManager;
};
using namespace style;
optional<ImagePosition> GeometryTileRenderData::getPattern(const std::string& pattern) const {
if (layoutResult) {
const auto& iconAtlas = layoutResult->iconAtlas;
auto it = iconAtlas.patternPositions.find(pattern);
if (it != iconAtlas.patternPositions.end()) {
return it->second;
}
}
return nullopt;
}
void GeometryTileRenderData::upload(gfx::UploadPass& uploadPass) {
if (!layoutResult) return;
auto uploadFn = [&] (Bucket& bucket) {
if (bucket.needsUpload()) {
bucket.upload(uploadPass);
}
};
for (auto& entry : layoutResult->layerRenderData) {
uploadFn(*entry.second.bucket);
}
assert(atlasTextures);
if (layoutResult->glyphAtlasImage) {
atlasTextures->glyph = uploadPass.createTexture(*layoutResult->glyphAtlasImage);
layoutResult->glyphAtlasImage = {};
}
if (layoutResult->iconAtlas.image.valid()) {
atlasTextures->icon = uploadPass.createTexture(layoutResult->iconAtlas.image);
layoutResult->iconAtlas.image = {};
}
if (atlasTextures->icon) {
layoutResult->iconAtlas.patchUpdatedImages(uploadPass, *atlasTextures->icon, imageManager);
}
}
Bucket* GeometryTileRenderData::getBucket(const Layer::Impl& layer) const {
const LayerRenderData* data = getLayerRenderData(layer);
return data ? data->bucket.get() : nullptr;
}
const LayerRenderData* GeometryTileRenderData::getLayerRenderData(const style::Layer::Impl& layerImpl) const {
return layoutResult ? layoutResult->getLayerRenderData(layerImpl) : nullptr;
}
/*
Correlation between GeometryTile and GeometryTileWorker is safeguarded by two
correlation schemes:
@@ -88,6 +175,9 @@ void GeometryTile::setData(std::unique_ptr<const GeometryTileData> data_) {
worker.self().invoke(&GeometryTileWorker::setData, std::move(data_), correlationID);
}
std::unique_ptr<TileRenderData> GeometryTile::createRenderData() {
return std::make_unique<GeometryTileRenderData>(layoutResult, atlasTextures, imageManager);
}
void GeometryTile::setLayers(const std::vector<Immutable<LayerProperties>>& layers) {
// Mark the tile as pending again if it was complete before to prevent signaling a complete
@@ -131,6 +221,9 @@ void GeometryTile::onLayout(std::shared_ptr<LayoutResult> result, const uint64_t
}
layoutResult = std::move(result);
if (!atlasTextures) {
atlasTextures = std::make_shared<TileAtlasTextures>();
}
observer->onTileChanged(*this);
}
@@ -159,61 +252,12 @@ void GeometryTile::getImages(ImageRequestPair pair) {
imageManager.getImages(*this, std::move(pair));
}
const optional<ImagePosition> GeometryTile::getPattern(const std::string& pattern) const {
if (layoutResult) {
const auto& iconAtlas = layoutResult->iconAtlas;
auto it = iconAtlas.patternPositions.find(pattern);
if (it != iconAtlas.patternPositions.end()) {
return it->second;
}
}
return nullopt;
}
const std::shared_ptr<FeatureIndex> GeometryTile::getFeatureIndex() const {
return layoutResult ? layoutResult->featureIndex : nullptr;
}
void GeometryTile::upload(gfx::UploadPass& uploadPass) {
if (!layoutResult) return;
auto uploadFn = [&] (Bucket& bucket) {
if (bucket.needsUpload()) {
bucket.upload(uploadPass);
}
};
for (auto& entry : layoutResult->layerRenderData) {
uploadFn(*entry.second.bucket);
}
if (layoutResult->glyphAtlasImage) {
glyphAtlasTexture = uploadPass.createTexture(*layoutResult->glyphAtlasImage);
layoutResult->glyphAtlasImage = {};
}
if (layoutResult->iconAtlas.image.valid()) {
iconAtlasTexture = uploadPass.createTexture(layoutResult->iconAtlas.image);
layoutResult->iconAtlas.image = {};
}
if (iconAtlasTexture) {
layoutResult->iconAtlas.patchUpdatedImages(uploadPass, *iconAtlasTexture, imageManager);
}
}
Bucket* GeometryTile::getBucket(const Layer::Impl& layer) const {
const LayerRenderData* data = getLayerRenderData(layer);
return data ? data->bucket.get() : nullptr;
}
const LayerRenderData* GeometryTile::getLayerRenderData(const style::Layer::Impl& layerImpl) const {
auto* that = const_cast<GeometryTile*>(this);
return that->getMutableLayerRenderData(layerImpl);
}
bool GeometryTile::layerPropertiesUpdated(const Immutable<style::LayerProperties>& layerProperties) {
LayerRenderData* renderData = getMutableLayerRenderData(*layerProperties->baseImpl);
LayerRenderData* renderData = getLayerRenderData(*layerProperties->baseImpl);
if (!renderData) {
return false;
}
@@ -233,27 +277,16 @@ const GeometryTileData* GeometryTile::getData() const {
return layoutResult->featureIndex->getData();
}
LayerRenderData* GeometryTile::getMutableLayerRenderData(const style::Layer::Impl& layerImpl) {
if (!layoutResult) return nullptr;
auto& layerIdToLayerRenderData = layoutResult->layerRenderData;
auto it = layerIdToLayerRenderData.find(layerImpl.id);
if (it == layerIdToLayerRenderData.end()) {
return nullptr;
}
LayerRenderData& result = it->second;
if (result.layerProperties->baseImpl->getTypeInfo() != layerImpl.getTypeInfo()) {
// Layer data might be outdated, see issue #12432.
return nullptr;
}
return &result;
LayerRenderData* GeometryTile::getLayerRenderData(const style::Layer::Impl& layerImpl) {
return layoutResult ? layoutResult->getLayerRenderData(layerImpl) : nullptr;
}
float GeometryTile::getQueryPadding(const std::vector<const RenderLayer*>& layers) {
float queryPadding = 0;
for (const RenderLayer* layer : layers) {
auto bucket = getBucket(*layer->baseImpl);
if (bucket && bucket->hasData()) {
queryPadding = std::max(queryPadding, bucket->getQueryRadius(*layer));
const LayerRenderData* data = getLayerRenderData(*layer->baseImpl);
if (data && data->bucket && data->bucket->hasData()) {
queryPadding = std::max(queryPadding, data->bucket->getQueryRadius(*layer));
}
}
return queryPadding;

14
src/mbgl/tile/geometry_tile.hpp
View File

@@ -23,6 +23,7 @@ class SourceQueryOptions;
class TileParameters;
class GlyphAtlas;
class ImageAtlas;
class TileAtlasTextures;
class GeometryTile : public Tile, public GlyphRequestor, public ImageRequestor {
public:
@@ -35,6 +36,7 @@ public:
void setError(std::exception_ptr);
void setData(std::unique_ptr<const GeometryTileData>);
std::unique_ptr<TileRenderData> createRenderData() override;
void setLayers(const std::vector<Immutable<style::LayerProperties>>&) override;
void setShowCollisionBoxes(const bool showCollisionBoxes) override;
@@ -44,9 +46,6 @@ public:
void getGlyphs(GlyphDependencies);
void getImages(ImageRequestPair);
void upload(gfx::UploadPass&) override;
Bucket* getBucket(const style::Layer::Impl&) const override;
const LayerRenderData* getLayerRenderData(const style::Layer::Impl&) const override;
bool layerPropertiesUpdated(const Immutable<style::LayerProperties>&) override;
void queryRenderedFeatures(
@@ -72,6 +71,8 @@ public:
optional<AlphaImage> glyphAtlasImage;
ImageAtlas iconAtlas;
LayerRenderData* getLayerRenderData(const style::Layer::Impl&);
LayoutResult(std::unordered_map<std::string, LayerRenderData> renderData_,
std::unique_ptr<FeatureIndex> featureIndex_,
optional<AlphaImage> glyphAtlasImage_,
@@ -89,14 +90,13 @@ public:
void markRenderedIdeal() override;
void markRenderedPreviously() override;
void performedFadePlacement() override;
const optional<ImagePosition> getPattern(const std::string& pattern) const;
const std::shared_ptr<FeatureIndex> getFeatureIndex() const;
const std::string sourceID;
protected:
const GeometryTileData* getData() const;
LayerRenderData* getMutableLayerRenderData(const style::Layer::Impl&);
LayerRenderData* getLayerRenderData(const style::Layer::Impl&);
private:
void markObsolete();
@@ -114,6 +114,7 @@ private:
uint64_t correlationID = 0;
std::shared_ptr<LayoutResult> layoutResult;
std::shared_ptr<TileAtlasTextures> atlasTextures;
const MapMode mode;
@@ -127,9 +128,6 @@ private:
};
FadeState fadeState = FadeState::Loaded;
public:
optional<gfx::Texture> glyphAtlasTexture;
optional<gfx::Texture> iconAtlasTexture;
};
} // namespace mbgl

16
src/mbgl/tile/raster_dem_tile.cpp
View File

@@ -7,6 +7,7 @@
#include <mbgl/storage/resource.hpp>
#include <mbgl/storage/response.hpp>
#include <mbgl/renderer/tile_parameters.hpp>
#include <mbgl/renderer/tile_render_data.hpp>
#include <mbgl/renderer/buckets/hillshade_bucket.hpp>
#include <mbgl/actor/scheduler.hpp>
@@ -35,6 +36,10 @@ RasterDEMTile::RasterDEMTile(const OverscaledTileID& id_,
RasterDEMTile::~RasterDEMTile() = default;
std::unique_ptr<TileRenderData> RasterDEMTile::createRenderData() {
return std::make_unique<SharedBucketTileRenderData<HillshadeBucket>>(bucket);
}
void RasterDEMTile::setError(std::exception_ptr err) {
loaded = true;
observer->onTileError(*this, err);
@@ -69,15 +74,8 @@ void RasterDEMTile::onError(std::exception_ptr err, const uint64_t resultCorrela
observer->onTileError(*this, err);
}
void RasterDEMTile::upload(gfx::UploadPass& uploadPass) {
if (bucket) {
bucket->upload(uploadPass);
}
}
Bucket* RasterDEMTile::getBucket(const style::Layer::Impl&) const {
return bucket.get();
bool RasterDEMTile::layerPropertiesUpdated(const Immutable<style::LayerProperties>&) {
return bool(bucket);
}
HillshadeBucket* RasterDEMTile::getBucket() const {

8
src/mbgl/tile/raster_dem_tile.hpp
View File

@@ -59,21 +59,21 @@ namespace style {
class Layer;
} // namespace style
class RasterDEMTile : public Tile {
class RasterDEMTile final : public Tile {
public:
RasterDEMTile(const OverscaledTileID&,
const TileParameters&,
const Tileset&);
~RasterDEMTile() override;
std::unique_ptr<TileRenderData> createRenderData() override;
void setNecessity(TileNecessity) final;
void setError(std::exception_ptr);
void setMetadata(optional<Timestamp> modified, optional<Timestamp> expires);
void setData(std::shared_ptr<const std::string> data);
void upload(gfx::UploadPass&) override;
Bucket* getBucket(const style::Layer::Impl&) const override;
bool layerPropertiesUpdated(const Immutable<style::LayerProperties>& layerProperties) override;
HillshadeBucket* getBucket() const;
void backfillBorder(const RasterDEMTile& borderTile, const DEMTileNeighbors mask);
@@ -98,7 +98,7 @@ private:
// Contains the Bucket object for the tile. Buckets are render
// objects and they get added by tile parsing operations.
std::unique_ptr<HillshadeBucket> bucket;
std::shared_ptr<HillshadeBucket> bucket;
};

15
src/mbgl/tile/raster_tile.cpp
View File

@@ -7,6 +7,7 @@
#include <mbgl/storage/resource.hpp>
#include <mbgl/storage/response.hpp>
#include <mbgl/renderer/tile_parameters.hpp>
#include <mbgl/renderer/tile_render_data.hpp>
#include <mbgl/renderer/buckets/raster_bucket.hpp>
#include <mbgl/actor/scheduler.hpp>
@@ -24,6 +25,10 @@ RasterTile::RasterTile(const OverscaledTileID& id_,
RasterTile::~RasterTile() = default;
std::unique_ptr<TileRenderData> RasterTile::createRenderData() {
return std::make_unique<SharedBucketTileRenderData<RasterBucket>>(bucket);
}
void RasterTile::setError(std::exception_ptr err) {
loaded = true;
observer->onTileError(*this, err);
@@ -58,14 +63,8 @@ void RasterTile::onError(std::exception_ptr err, const uint64_t resultCorrelatio
observer->onTileError(*this, err);
}
void RasterTile::upload(gfx::UploadPass& uploadPass) {
if (bucket) {
bucket->upload(uploadPass);
}
}
Bucket* RasterTile::getBucket(const style::Layer::Impl&) const {
return bucket.get();
bool RasterTile::layerPropertiesUpdated(const Immutable<style::LayerProperties>&) {
return bool(bucket);
}
void RasterTile::setMask(TileMask&& mask) {

8
src/mbgl/tile/raster_tile.hpp
View File

@@ -15,21 +15,21 @@ namespace style {
class Layer;
} // namespace style
class RasterTile : public Tile {
class RasterTile final : public Tile {
public:
RasterTile(const OverscaledTileID&,
const TileParameters&,
const Tileset&);
~RasterTile() override;
std::unique_ptr<TileRenderData> createRenderData() override;
void setNecessity(TileNecessity) final;
void setError(std::exception_ptr);
void setMetadata(optional<Timestamp> modified, optional<Timestamp> expires);
void setData(std::shared_ptr<const std::string> data);
void upload(gfx::UploadPass&) override;
Bucket* getBucket(const style::Layer::Impl&) const override;
bool layerPropertiesUpdated(const Immutable<style::LayerProperties>& layerProperties) override;
void setMask(TileMask&&) override;
@@ -46,7 +46,7 @@ private:
// Contains the Bucket object for the tile. Buckets are render
// objects and they get added by tile parsing operations.
std::unique_ptr<RasterBucket> bucket;
std::shared_ptr<RasterBucket> bucket;
};
} // namespace mbgl

13
src/mbgl/tile/tile.hpp
View File

@@ -24,6 +24,7 @@ class LayerRenderData;
class TransformState;
class TileObserver;
class RenderLayer;
class TileRenderData;
class RenderedQueryOptions;
class SourceQueryOptions;
class CollisionIndex;
@@ -45,6 +46,8 @@ public:
Tile(Kind, OverscaledTileID);
virtual ~Tile();
virtual std::unique_ptr<TileRenderData> createRenderData() = 0;
void setObserver(TileObserver* observer);
virtual void setNecessity(TileNecessity) {}
@@ -52,12 +55,6 @@ public:
// Mark this tile as no longer needed and cancel any pending work.
virtual void cancel();
virtual void upload(gfx::UploadPass&) = 0;
virtual Bucket* getBucket(const style::Layer::Impl&) const = 0;
virtual const LayerRenderData* getLayerRenderData(const style::Layer::Impl&) const {
assert(false);
return nullptr;
}
// Notifies this tile of the updated layer properties.
//
// Tile implementation should update the contained layer
@@ -65,9 +62,7 @@ public:
//
// Returns `true` if the corresponding render layer data is present in this tile (and i.e. it
// was succesfully updated); returns `false` otherwise.
virtual bool layerPropertiesUpdated(const Immutable<style::LayerProperties>& layerProperties) {
return bool(getBucket(*layerProperties->baseImpl));
}
virtual bool layerPropertiesUpdated(const Immutable<style::LayerProperties>& layerProperties) = 0;
virtual void setShowCollisionBoxes(const bool) {}
virtual void setLayers(const std::vector<Immutable<style::LayerProperties>>&) {}
virtual void setMask(TileMask&&) {}

4
test/tile/custom_geometry_tile.test.cpp
View File

@@ -111,14 +111,14 @@ TEST(CustomGeometryTile, InvokeTileChanged) {
CustomGeometryTile tile(OverscaledTileID(0, 0, 0), "source", test.tileParameters, CustomGeometrySource::TileOptions(),
loaderActor);
Immutable<LayerProperties> layerProperties = makeMutable<CircleLayerProperties>(staticImmutableCast<CircleLayer::Impl>(layer.baseImpl));
StubTileObserver observer;
observer.tileChanged = [&] (const Tile&) {
// Once present, the bucket should never "disappear", which would cause
// flickering.
ASSERT_NE(nullptr, tile.getBucket(*layer.baseImpl));
ASSERT_TRUE(tile.layerPropertiesUpdated(layerProperties));
};
Immutable<LayerProperties> layerProperties = makeMutable<CircleLayerProperties>(staticImmutableCast<CircleLayer::Impl>(layer.baseImpl));
std::vector<Immutable<LayerProperties>> layers { layerProperties };
tile.setLayers(layers);
tile.setObserver(&observer);

12
test/tile/geojson_tile.test.cpp
View File

@@ -52,14 +52,14 @@ TEST(GeoJSONTile, Issue7648) {
features.push_back(mapbox::feature::feature<int16_t> { mapbox::geometry::point<int16_t>(0, 0) });
GeoJSONTile tile(OverscaledTileID(0, 0, 0), "source", test.tileParameters, features);
Immutable<LayerProperties> layerProperties = makeMutable<CircleLayerProperties>(staticImmutableCast<CircleLayer::Impl>(layer.baseImpl));
StubTileObserver observer;
observer.tileChanged = [&] (const Tile&) {
// Once present, the bucket should never "disappear", which would cause
// flickering.
ASSERT_NE(nullptr, tile.getBucket(*layer.baseImpl));
ASSERT_TRUE(tile.layerPropertiesUpdated(layerProperties));
};
Immutable<LayerProperties> layerProperties = makeMutable<CircleLayerProperties>(staticImmutableCast<CircleLayer::Impl>(layer.baseImpl));
std::vector<Immutable<LayerProperties>> layers { layerProperties };
tile.setLayers(layers);
tile.setObserver(&observer);
@@ -95,18 +95,18 @@ TEST(GeoJSONTile, Issue9927) {
}
ASSERT_TRUE(tile.isRenderable());
ASSERT_NE(nullptr, tile.getBucket(*layer.baseImpl));
ASSERT_TRUE(tile.layerPropertiesUpdated(layerProperties));
// Make sure that once we've had a renderable tile and then receive erroneous data, we retain
// the previously rendered data and keep the tile renderable.
tile.setError(std::make_exception_ptr(std::runtime_error("Connection offline")));
ASSERT_TRUE(tile.isRenderable());
ASSERT_NE(nullptr, tile.getBucket(*layer.baseImpl));
ASSERT_TRUE(tile.layerPropertiesUpdated(layerProperties));
// Then simulate a parsing failure and make sure that we keep it renderable in this situation
// as well. We're using 3 as a correlationID since we've done two three calls that increment
// this counter (as part of the GeoJSONTile constructor, setLayers, and setPlacementConfig).
tile.onError(std::make_exception_ptr(std::runtime_error("Parse error")), 3);
ASSERT_TRUE(tile.isRenderable());
ASSERT_NE(nullptr, tile.getBucket(*layer.baseImpl));
ASSERT_TRUE(tile.layerPropertiesUpdated(layerProperties));
}