summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorIvo van Dongen <info@ivovandongen.nl>2017-06-13 10:50:16 +0300
committerIvo van Dongen <ivovandongen@users.noreply.github.com>2017-07-18 10:45:12 +0200
commit3832f8d0d8194b81ea34a045e19b0d5bc7a89e25 (patch)
treebbb4b277e1e74bde457271b9b9a5b6a9ec3ad5fb /src
parent39a732d7ae3cb1b927d94c4b1154b42d9565356a (diff)
downloadqtlocation-mapboxgl-3832f8d0d8194b81ea34a045e19b0d5bc7a89e25.tar.gz
[core] renderer interface
Diffstat (limited to 'src')
-rw-r--r--src/mbgl/annotation/annotation_manager.cpp1
-rw-r--r--src/mbgl/geometry/feature_index.cpp2
-rw-r--r--src/mbgl/map/map.cpp349
-rw-r--r--src/mbgl/renderer/painter.cpp2
-rw-r--r--src/mbgl/renderer/painter.hpp6
-rw-r--r--src/mbgl/renderer/render_style.cpp2
-rw-r--r--src/mbgl/renderer/renderer.cpp78
-rw-r--r--src/mbgl/renderer/renderer_impl.cpp151
-rw-r--r--src/mbgl/renderer/renderer_impl.hpp65
-rw-r--r--src/mbgl/renderer/renderer_observer.hpp35
-rw-r--r--src/mbgl/renderer/tile_pyramid.cpp2
-rw-r--r--src/mbgl/renderer/update_parameters.hpp21
-rw-r--r--src/mbgl/tile/geojson_tile.cpp2
-rw-r--r--src/mbgl/tile/geometry_tile.cpp2
-rw-r--r--src/mbgl/tile/tile.cpp2
15 files changed, 456 insertions, 264 deletions
diff --git a/src/mbgl/annotation/annotation_manager.cpp b/src/mbgl/annotation/annotation_manager.cpp
index ec5a360a90..dbf8387ae0 100644
--- a/src/mbgl/annotation/annotation_manager.cpp
+++ b/src/mbgl/annotation/annotation_manager.cpp
@@ -215,7 +215,6 @@ void AnnotationManager::addImage(std::unique_ptr<style::Image> image) {
images.erase(id);
auto inserted = images.emplace(id, style::Image(id, image->getImage().clone(),
image->getPixelRatio(), image->isSdf()));
-
style.get().impl->addImage(std::make_unique<style::Image>(inserted.first->second));
}
diff --git a/src/mbgl/geometry/feature_index.cpp b/src/mbgl/geometry/feature_index.cpp
index b1594388c4..4c4e985369 100644
--- a/src/mbgl/geometry/feature_index.cpp
+++ b/src/mbgl/geometry/feature_index.cpp
@@ -1,12 +1,12 @@
#include <mbgl/geometry/feature_index.hpp>
#include <mbgl/renderer/render_style.hpp>
#include <mbgl/renderer/render_layer.hpp>
+#include <mbgl/renderer/query.hpp>
#include <mbgl/renderer/layers/render_symbol_layer.hpp>
#include <mbgl/text/collision_tile.hpp>
#include <mbgl/util/constants.hpp>
#include <mbgl/util/math.hpp>
#include <mbgl/math/minmax.hpp>
-#include <mbgl/map/query.hpp>
#include <mbgl/style/filter.hpp>
#include <mbgl/style/filter_evaluator.hpp>
#include <mbgl/tile/geometry_tile.hpp>
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index 172b2bf851..7d57f6863e 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -1,23 +1,19 @@
#include <mbgl/map/map.hpp>
#include <mbgl/map/camera.hpp>
-#include <mbgl/map/view.hpp>
-#include <mbgl/map/backend.hpp>
-#include <mbgl/map/backend_scope.hpp>
#include <mbgl/map/transform.hpp>
#include <mbgl/map/transform_state.hpp>
#include <mbgl/annotation/annotation_manager.hpp>
#include <mbgl/style/style_impl.hpp>
#include <mbgl/style/observer.hpp>
#include <mbgl/renderer/update_parameters.hpp>
-#include <mbgl/renderer/painter.hpp>
-#include <mbgl/renderer/render_source.hpp>
-#include <mbgl/renderer/render_style.hpp>
-#include <mbgl/renderer/render_style_observer.hpp>
+#include <mbgl/renderer/renderer_frontend.hpp>
+#include <mbgl/renderer/renderer_observer.hpp>
+#include <mbgl/storage/file_source.hpp>
+#include <mbgl/storage/resource.hpp>
+#include <mbgl/storage/response.hpp>
#include <mbgl/util/constants.hpp>
-#include <mbgl/util/exception.hpp>
#include <mbgl/util/math.hpp>
#include <mbgl/util/exception.hpp>
-#include <mbgl/util/async_task.hpp>
#include <mbgl/util/mapbox.hpp>
#include <mbgl/util/tile_coordinate.hpp>
#include <mbgl/actor/scheduler.hpp>
@@ -29,69 +25,58 @@ namespace mbgl {
using namespace style;
-enum class RenderState : uint8_t {
- Never,
- Partial,
- Fully,
-};
-
struct StillImageRequest {
- StillImageRequest(View& view_, Map::StillImageCallback&& callback_)
- : view(view_), callback(std::move(callback_)) {
+ StillImageRequest(Map::StillImageCallback&& callback_)
+ : callback(std::move(callback_)) {
}
- View& view;
Map::StillImageCallback callback;
};
class Map::Impl : public style::Observer,
- public RenderStyleObserver {
+ public RendererObserver {
public:
Impl(Map&,
- Backend&,
+ RendererFrontend&,
MapObserver&,
float pixelRatio,
FileSource&,
Scheduler&,
MapMode,
- GLContextMode,
ConstrainMode,
- ViewportMode,
- optional<std::string> programCacheDir);
+ ViewportMode);
+
+ ~Impl();
+ // StyleObserver
void onSourceChanged(style::Source&) override;
void onUpdate(Update) override;
- void onInvalidate() override;
void onStyleLoading() override;
void onStyleLoaded() override;
void onStyleError(std::exception_ptr) override;
- void onResourceError(std::exception_ptr) override;
- void render(View&);
- void renderStill();
+ // RendererObserver
+ void onInvalidate() override;
+ void onResourceError(std::exception_ptr) override;
+ void onWillStartRenderingFrame() override;
+ void onDidFinishRenderingFrame(RenderMode, bool) override;
+ void onWillStartRenderingMap() override;
+ void onDidFinishRenderingMap() override;
Map& map;
MapObserver& observer;
- Backend& backend;
+ RendererFrontend& rendererFrontend;
FileSource& fileSource;
Scheduler& scheduler;
- RenderState renderState = RenderState::Never;
Transform transform;
const MapMode mode;
- const GLContextMode contextMode;
const float pixelRatio;
- const optional<std::string> programCacheDir;
MapDebugOptions debugOptions { MapDebugOptions::NoDebug };
- Update updateFlags = Update::Nothing;
-
- std::unique_ptr<Painter> painter;
std::unique_ptr<Style> style;
- std::unique_ptr<RenderStyle> renderStyle;
-
AnnotationManager annotationManager;
bool cameraMutated = false;
@@ -99,81 +84,66 @@ public:
uint8_t prefetchZoomDelta = util::DEFAULT_PREFETCH_ZOOM_DELTA;
bool loading = false;
-
- util::AsyncTask asyncInvalidate;
+ bool rendererFullyLoaded;
std::unique_ptr<StillImageRequest> stillImageRequest;
};
-Map::Map(Backend& backend,
+Map::Map(RendererFrontend& rendererFrontend,
MapObserver& mapObserver,
const Size size,
const float pixelRatio,
FileSource& fileSource,
Scheduler& scheduler,
MapMode mapMode,
- GLContextMode contextMode,
ConstrainMode constrainMode,
- ViewportMode viewportMode,
- optional<std::string> programCacheDir)
+ ViewportMode viewportMode)
: impl(std::make_unique<Impl>(*this,
- backend,
+ rendererFrontend,
mapObserver,
pixelRatio,
fileSource,
scheduler,
mapMode,
- contextMode,
constrainMode,
- viewportMode,
- programCacheDir)) {
+ viewportMode)) {
impl->transform.resize(size);
}
Map::Impl::Impl(Map& map_,
- Backend& backend_,
+ RendererFrontend& frontend,
MapObserver& mapObserver,
float pixelRatio_,
FileSource& fileSource_,
Scheduler& scheduler_,
MapMode mode_,
- GLContextMode contextMode_,
ConstrainMode constrainMode_,
- ViewportMode viewportMode_,
- optional<std::string> programCacheDir_)
+ ViewportMode viewportMode_)
: map(map_),
observer(mapObserver),
- backend(backend_),
+ rendererFrontend(frontend),
fileSource(fileSource_),
scheduler(scheduler_),
transform(observer,
constrainMode_,
viewportMode_),
mode(mode_),
- contextMode(contextMode_),
pixelRatio(pixelRatio_),
- programCacheDir(std::move(programCacheDir_)),
style(std::make_unique<Style>(scheduler, fileSource, pixelRatio)),
- annotationManager(*style),
- asyncInvalidate([this] {
- if (mode == MapMode::Continuous) {
- backend.invalidate();
- } else {
- renderStill();
- }
- }) {
+ annotationManager(*style) {
+
style->impl->setObserver(this);
+ rendererFrontend.setObserver(*this);
}
-Map::~Map() {
- BackendScope guard(impl->backend);
+Map::Impl::~Impl() {
+ // Explicitly reset the RendererFrontend first to ensure it releases
+ // All shared resources (AnnotationManager)
+ rendererFrontend.reset();
+};
- // Explicit resets currently necessary because these abandon resources that need to be
- // cleaned up by context.reset();
- impl->renderStyle.reset();
- impl->painter.reset();
-}
+Map::~Map() = default;
-void Map::renderStill(View& view, StillImageCallback callback) {
+void Map::renderStill(StillImageCallback callback) {
if (!callback) {
Log::Error(Event::General, "StillImageCallback not set");
return;
@@ -194,129 +164,53 @@ void Map::renderStill(View& view, StillImageCallback callback) {
return;
}
- impl->stillImageRequest = std::make_unique<StillImageRequest>(view, std::move(callback));
- impl->onUpdate(Update::Repaint);
-}
-
-void Map::Impl::renderStill() {
- if (!stillImageRequest) {
- return;
- }
+ impl->stillImageRequest = std::make_unique<StillImageRequest>(std::move(callback));
- // TODO: determine whether we need activate/deactivate
- BackendScope guard(backend);
- render(stillImageRequest->view);
+ impl->onUpdate(Update::Repaint);
}
void Map::triggerRepaint() {
- impl->backend.invalidate();
-}
-
-void Map::render(View& view) {
- impl->render(view);
+ impl->onUpdate(Update::Repaint);
}
-void Map::Impl::render(View& view) {
- TimePoint timePoint = mode == MapMode::Continuous
- ? Clock::now()
- : Clock::time_point::max();
-
- transform.updateTransitions(timePoint);
+#pragma mark - Map::Impl RendererObserver
- if (updateFlags & Update::AnnotationData) {
- annotationManager.updateData();
+void Map::Impl::onWillStartRenderingMap() {
+ if (mode == MapMode::Continuous) {
+ observer.onWillStartRenderingMap();
}
+}
- updateFlags = Update::Nothing;
-
- gl::Context& context = backend.getContext();
- if (!painter) {
- renderStyle = std::make_unique<RenderStyle>(scheduler, fileSource);
- renderStyle->setObserver(this);
- painter = std::make_unique<Painter>(context, transform.getState(), pixelRatio, programCacheDir);
+void Map::Impl::onWillStartRenderingFrame() {
+ if (mode == MapMode::Continuous) {
+ observer.onWillStartRenderingFrame();
}
+}
- renderStyle->update({
- mode,
- pixelRatio,
- debugOptions,
- timePoint,
- transform.getState(),
- style->impl->getGlyphURL(),
- style->impl->spriteLoaded,
- style->impl->getTransitionOptions(),
- style->impl->getLight()->impl,
- style->impl->getImageImpls(),
- style->impl->getSourceImpls(),
- style->impl->getLayerImpls(),
- scheduler,
- fileSource,
- annotationManager,
- prefetchZoomDelta
- });
-
- bool loaded = style->impl->isLoaded() && renderStyle->isLoaded();
+void Map::Impl::onDidFinishRenderingFrame(RenderMode renderMode, bool needsRepaint) {
+ rendererFullyLoaded = renderMode == RenderMode::Full;
if (mode == MapMode::Continuous) {
- if (renderState == RenderState::Never) {
- observer.onWillStartRenderingMap();
- }
-
- observer.onWillStartRenderingFrame();
-
- FrameData frameData { timePoint,
- pixelRatio,
- mode,
- contextMode,
- debugOptions };
-
- backend.updateAssumedState();
-
- painter->render(*renderStyle,
- frameData,
- view);
-
- painter->cleanup();
-
- observer.onDidFinishRenderingFrame(loaded
- ? MapObserver::RenderMode::Full
- : MapObserver::RenderMode::Partial);
-
- if (!loaded) {
- renderState = RenderState::Partial;
- } else if (renderState != RenderState::Fully) {
- renderState = RenderState::Fully;
- observer.onDidFinishRenderingMap(MapObserver::RenderMode::Full);
- if (loading) {
- loading = false;
- observer.onDidFinishLoadingMap();
- }
- }
+ observer.onDidFinishRenderingFrame(MapObserver::RenderMode(renderMode));
- // Schedule an update if we need to paint another frame due to transitions or
- // animations that are still in progress
- if (renderStyle->hasTransitions() || painter->needsAnimation() || transform.inTransition()) {
+ if (needsRepaint || transform.inTransition()) {
onUpdate(Update::Repaint);
}
- } else if (stillImageRequest && loaded) {
- FrameData frameData { timePoint,
- pixelRatio,
- mode,
- contextMode,
- debugOptions };
-
- backend.updateAssumedState();
-
- painter->render(*renderStyle,
- frameData,
- view);
+ }
+}
+void Map::Impl::onDidFinishRenderingMap() {
+ if (mode == MapMode::Continuous && loading) {
+ observer.onDidFinishRenderingMap(MapObserver::RenderMode::Full);
+ if (loading) {
+ loading = false;
+ observer.onDidFinishLoadingMap();
+ }
+ } else if (stillImageRequest) {
auto request = std::move(stillImageRequest);
request->callback(nullptr);
-
- painter->cleanup();
}
-}
+};
#pragma mark - Style
@@ -737,60 +631,6 @@ void Map::removeAnnotation(AnnotationID annotation) {
impl->onUpdate(Update::AnnotationData);
}
-#pragma mark - Feature query api
-
-std::vector<Feature> Map::queryRenderedFeatures(const ScreenCoordinate& point, const RenderedQueryOptions& options) {
- if (!impl->renderStyle) return {};
-
- return impl->renderStyle->queryRenderedFeatures(
- { point },
- impl->transform.getState(),
- options
- );
-}
-
-std::vector<Feature> Map::queryRenderedFeatures(const ScreenBox& box, const RenderedQueryOptions& options) {
- if (!impl->renderStyle) return {};
-
- return impl->renderStyle->queryRenderedFeatures(
- {
- box.min,
- { box.max.x, box.min.y },
- box.max,
- { box.min.x, box.max.y },
- box.min
- },
- impl->transform.getState(),
- options
- );
-}
-
-std::vector<Feature> Map::querySourceFeatures(const std::string& sourceID, const SourceQueryOptions& options) {
- if (!impl->renderStyle) return {};
-
- const RenderSource* source = impl->renderStyle->getRenderSource(sourceID);
- if (!source) return {};
-
- return source->querySourceFeatures(options);
-}
-
-AnnotationIDs Map::queryPointAnnotations(const ScreenBox& box) {
- RenderedQueryOptions options;
- options.layerIDs = {{ AnnotationManager::PointLayerID }};
- auto features = queryRenderedFeatures(box, options);
- std::set<AnnotationID> set;
- for (auto &feature : features) {
- assert(feature.id);
- assert(feature.id->is<uint64_t>());
- assert(feature.id->get<uint64_t>() <= std::numeric_limits<AnnotationID>::max());
- set.insert(static_cast<AnnotationID>(feature.id->get<uint64_t>()));
- }
- AnnotationIDs ids;
- ids.reserve(set.size());
- std::move(set.begin(), set.end(), std::back_inserter(ids));
- return ids;
-}
-
#pragma mark - Toggles
void Map::setDebug(MapDebugOptions debugOptions) {
@@ -826,10 +666,6 @@ MapDebugOptions Map::getDebug() const {
return impl->debugOptions;
}
-bool Map::isFullyLoaded() const {
- return impl->style->impl->isLoaded() && impl->renderStyle && impl->renderStyle->isLoaded();
-}
-
void Map::setPrefetchZoomDelta(uint8_t delta) {
impl->prefetchZoomDelta = delta;
}
@@ -838,32 +674,54 @@ uint8_t Map::getPrefetchZoomDelta() const {
return impl->prefetchZoomDelta;
}
-void Map::onLowMemory() {
- if (impl->painter) {
- BackendScope guard(impl->backend);
- impl->painter->cleanup();
- }
- if (impl->renderStyle) {
- impl->renderStyle->onLowMemory();
- impl->backend.invalidate();
- }
+bool Map::isFullyLoaded() const {
+ return impl->style->impl->isLoaded() && impl->rendererFullyLoaded;
}
void Map::Impl::onSourceChanged(style::Source& source) {
observer.onSourceChanged(source);
}
-void Map::Impl::onUpdate(Update flags) {
- updateFlags |= flags;
- asyncInvalidate.send();
-}
-
void Map::Impl::onInvalidate() {
onUpdate(Update::Repaint);
}
+void Map::Impl::onUpdate(Update flags) {
+ TimePoint timePoint = mode == MapMode::Continuous ? Clock::now() : Clock::time_point::max();
+
+ transform.updateTransitions(timePoint);
+
+ if (flags & Update::AnnotationData) {
+ annotationManager.updateData();
+ }
+
+ UpdateParameters params = {
+ style->impl->isLoaded(),
+ mode,
+ pixelRatio,
+ debugOptions,
+ timePoint,
+ transform.getState(),
+ style->impl->getGlyphURL(),
+ style->impl->spriteLoaded,
+ style->impl->getTransitionOptions(),
+ style->impl->getLight()->impl,
+ style->impl->getImageImpls(),
+ style->impl->getSourceImpls(),
+ style->impl->getLayerImpls(),
+ scheduler,
+ fileSource,
+ annotationManager,
+ prefetchZoomDelta,
+ bool(stillImageRequest)
+ };
+
+ rendererFrontend.update(std::make_shared<UpdateParameters>(std::move(params)));
+}
+
void Map::Impl::onStyleLoading() {
loading = true;
+ rendererFullyLoaded = false;
observer.onWillStartLoadingMap();
}
@@ -894,9 +752,6 @@ void Map::Impl::onResourceError(std::exception_ptr error) {
void Map::dumpDebugLogs() const {
Log::Info(Event::General, "--------------------------------------------------------------------------------");
impl->style->impl->dumpDebugLogs();
- if (impl->renderStyle) {
- impl->renderStyle->dumpDebugLogs();
- }
Log::Info(Event::General, "--------------------------------------------------------------------------------");
}
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index 9ab50e83b0..8e76d6bfc4 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -88,11 +88,9 @@ static gl::VertexVector<ExtrusionTextureLayoutVertex> extrusionTextureVertices()
Painter::Painter(gl::Context& context_,
- const TransformState& state_,
float pixelRatio,
const optional<std::string>& programCacheDir)
: context(context_),
- state(state_),
tileVertexBuffer(context.createVertexBuffer(tileVertices())),
rasterVertexBuffer(context.createVertexBuffer(rasterVertices())),
extrusionTextureVertexBuffer(context.createVertexBuffer(extrusionTextureVertices())),
diff --git a/src/mbgl/renderer/painter.hpp b/src/mbgl/renderer/painter.hpp
index 0b6ee3497e..08ca76bf16 100644
--- a/src/mbgl/renderer/painter.hpp
+++ b/src/mbgl/renderer/painter.hpp
@@ -70,7 +70,7 @@ struct FrameData {
class Painter : private util::noncopyable {
public:
- Painter(gl::Context&, const TransformState&, float pixelRatio, const optional<std::string>& programCacheDir);
+ Painter(gl::Context&, float pixelRatio, const optional<std::string>& programCacheDir);
~Painter();
void render(RenderStyle&,
@@ -125,6 +125,8 @@ public:
gl::Context& context;
+ TransformState state;
+
algorithm::ClipIDGenerator clipIDGenerator;
mat4 projMatrix;
@@ -138,8 +140,6 @@ public:
return identity;
}();
- const TransformState& state;
-
FrameData frame;
int indent = 0;
diff --git a/src/mbgl/renderer/render_style.cpp b/src/mbgl/renderer/render_style.cpp
index 47639a57e7..a0f1fd4049 100644
--- a/src/mbgl/renderer/render_style.cpp
+++ b/src/mbgl/renderer/render_style.cpp
@@ -17,6 +17,7 @@
#include <mbgl/renderer/layers/render_symbol_layer.hpp>
#include <mbgl/renderer/style_diff.hpp>
#include <mbgl/renderer/image_manager.hpp>
+#include <mbgl/renderer/query.hpp>
#include <mbgl/style/style.hpp>
#include <mbgl/style/source_impl.hpp>
#include <mbgl/style/transition_options.hpp>
@@ -24,7 +25,6 @@
#include <mbgl/text/glyph_manager.hpp>
#include <mbgl/geometry/line_atlas.hpp>
#include <mbgl/map/backend_scope.hpp>
-#include <mbgl/map/query.hpp>
#include <mbgl/tile/tile.hpp>
#include <mbgl/util/math.hpp>
#include <mbgl/util/string.hpp>
diff --git a/src/mbgl/renderer/renderer.cpp b/src/mbgl/renderer/renderer.cpp
new file mode 100644
index 0000000000..11d7726c79
--- /dev/null
+++ b/src/mbgl/renderer/renderer.cpp
@@ -0,0 +1,78 @@
+#include <mbgl/renderer/renderer.hpp>
+#include <mbgl/renderer/renderer_impl.hpp>
+#include <mbgl/renderer/update_parameters.hpp>
+#include <mbgl/annotation/annotation_manager.hpp>
+
+namespace mbgl {
+
+Renderer::Renderer(Backend& backend,
+ float pixelRatio_,
+ FileSource& fileSource_,
+ Scheduler& scheduler_,
+ GLContextMode contextMode_,
+ const optional<std::string> programCacheDir_)
+ : impl(std::make_unique<Impl>(backend, pixelRatio_, fileSource_, scheduler_,
+ contextMode_, std::move(programCacheDir_))) {
+}
+
+Renderer::~Renderer() = default;
+
+void Renderer::setObserver(RendererObserver* observer) {
+ impl->setObserver(observer);
+}
+
+void Renderer::render(View& view, const UpdateParameters& updateParameters) {
+ impl->render(view, updateParameters);
+}
+
+std::vector<Feature> Renderer::queryRenderedFeatures(const ScreenLineString& geometry, const RenderedQueryOptions& options) const {
+ return impl->queryRenderedFeatures(geometry, options);
+}
+
+std::vector<Feature> Renderer::queryRenderedFeatures(const ScreenCoordinate& point, const RenderedQueryOptions& options) const {
+ return impl->queryRenderedFeatures({ point }, options);
+}
+
+std::vector<Feature> Renderer::queryRenderedFeatures(const ScreenBox& box, const RenderedQueryOptions& options) const {
+ return impl->queryRenderedFeatures(
+ {
+ box.min,
+ {box.max.x, box.min.y},
+ box.max,
+ {box.min.x, box.max.y},
+ box.min
+ },
+ options
+ );
+}
+
+AnnotationIDs Renderer::queryPointAnnotations(const ScreenBox& box) const {
+ RenderedQueryOptions options;
+ options.layerIDs = {{ AnnotationManager::PointLayerID }};
+ auto features = queryRenderedFeatures(box, options);
+ std::set<AnnotationID> set;
+ for (auto &feature : features) {
+ assert(feature.id);
+ assert(feature.id->is<uint64_t>());
+ assert(feature.id->get<uint64_t>() <= std::numeric_limits<AnnotationID>::max());
+ set.insert(static_cast<AnnotationID>(feature.id->get<uint64_t>()));
+ }
+ AnnotationIDs ids;
+ ids.reserve(set.size());
+ std::move(set.begin(), set.end(), std::back_inserter(ids));
+ return ids;
+}
+
+std::vector<Feature> Renderer::querySourceFeatures(const std::string& sourceID, const SourceQueryOptions& options) const {
+ return impl->querySourceFeatures(sourceID, options);
+}
+
+void Renderer::dumpDebugLogs() {
+ impl->dumDebugLogs();
+}
+
+void Renderer::onLowMemory() {
+ impl->onLowMemory();
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
new file mode 100644
index 0000000000..accdbc1332
--- /dev/null
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -0,0 +1,151 @@
+#include <mbgl/renderer/renderer_impl.hpp>
+#include <mbgl/actor/scheduler.hpp>
+#include <mbgl/storage/file_source.hpp>
+#include <mbgl/renderer/render_style.hpp>
+#include <mbgl/renderer/painter.hpp>
+#include <mbgl/renderer/update_parameters.hpp>
+#include <mbgl/map/transform_state.hpp>
+#include <mbgl/map/backend_scope.hpp>
+
+namespace mbgl {
+
+static RendererObserver& nullObserver() {
+ static RendererObserver observer;
+ return observer;
+}
+
+Renderer::Impl::Impl(Backend& backend_,
+ float pixelRatio_,
+ FileSource& fileSource_,
+ Scheduler& scheduler_,
+ GLContextMode contextMode_,
+ const optional<std::string> programCacheDir_)
+ : backend(backend_)
+ , observer(&nullObserver())
+ , contextMode(contextMode_)
+ , pixelRatio(pixelRatio_),
+ programCacheDir(programCacheDir_)
+ , renderStyle(std::make_unique<RenderStyle>(scheduler_, fileSource_)) {
+
+ renderStyle->setObserver(this);
+}
+
+Renderer::Impl::~Impl() {
+ BackendScope guard { backend, backend.getScopeType()};
+ renderStyle.reset();
+};
+
+void Renderer::Impl::setObserver(RendererObserver* observer_) {
+ observer = observer_ ? observer_ : &nullObserver();
+}
+
+void Renderer::Impl::render(View& view, const UpdateParameters& updateParameters) {
+ // Don't load/render anyting in still mode until explicitly requested.
+ if (updateParameters.mode == MapMode::Still && !updateParameters.stillImageRequest) return;
+
+ BackendScope guard { backend, backend.getScopeType() };
+
+ // Update render style
+ renderStyle->update(updateParameters);
+
+ // Initialize painter
+ if (!painter) {
+ gl::Context& context = backend.getContext();
+ painter = std::make_unique<Painter>(context,
+ pixelRatio,
+ programCacheDir);
+ }
+
+ // Update transform state on painter.
+ painter->state = updateParameters.transformState;
+
+ bool loaded = updateParameters.styleLoaded && renderStyle->isLoaded();
+
+ if (updateParameters.mode == MapMode::Continuous) {
+ if (renderState == RenderState::Never) {
+ observer->onWillStartRenderingMap();
+ }
+
+ observer->onWillStartRenderingFrame();
+
+ FrameData frameData { updateParameters.timePoint,
+ pixelRatio,
+ updateParameters.mode,
+ contextMode,
+ updateParameters.debugOptions };
+
+ backend.updateAssumedState();
+
+ painter->render(*renderStyle, frameData, view);
+ painter->cleanup();
+
+ observer->onDidFinishRenderingFrame(
+ loaded ? RendererObserver::RenderMode::Full : RendererObserver::RenderMode::Partial,
+ renderStyle->hasTransitions() || painter->needsAnimation()
+ );
+
+ if (!loaded) {
+ renderState = RenderState::Partial;
+ } else if (renderState != RenderState::Fully) {
+ renderState = RenderState::Fully;
+ observer->onDidFinishRenderingMap();
+ }
+ } else if (loaded) {
+ // We can render the map in still mode
+ observer->onWillStartRenderingMap();
+ observer->onWillStartRenderingFrame();
+
+ FrameData frameData { updateParameters.timePoint,
+ pixelRatio,
+ updateParameters.mode,
+ contextMode,
+ updateParameters.debugOptions };
+
+ backend.updateAssumedState();
+
+ painter->render(*renderStyle, frameData, view);
+
+ observer->onDidFinishRenderingFrame(RendererObserver::RenderMode::Full, false);
+ observer->onDidFinishRenderingMap();
+
+ // Cleanup only after signaling completion
+ painter->cleanup();
+ }
+}
+
+std::vector<Feature> Renderer::Impl::queryRenderedFeatures(const ScreenLineString& geometry, const RenderedQueryOptions& options) const {
+ if (!painter) return {};
+
+ return renderStyle->queryRenderedFeatures(geometry, painter->state, options);
+}
+
+std::vector<Feature> Renderer::Impl::querySourceFeatures(const std::string& sourceID, const SourceQueryOptions& options) const {
+ const RenderSource* source = renderStyle->getRenderSource(sourceID);
+ if (!source) return {};
+
+ return source->querySourceFeatures(options);
+}
+
+void Renderer::Impl::onInvalidate() {
+ observer->onInvalidate();
+};
+
+void Renderer::Impl::onResourceError(std::exception_ptr ptr) {
+ observer->onResourceError(ptr);
+}
+
+void Renderer::Impl::onLowMemory() {
+ if (painter) {
+ BackendScope { backend, backend.getScopeType() };
+ painter->cleanup();
+ }
+ renderStyle->onLowMemory();
+ observer->onInvalidate();
+}
+
+void Renderer::Impl::dumDebugLogs() {
+ renderStyle->dumpDebugLogs();
+};
+
+
+}
diff --git a/src/mbgl/renderer/renderer_impl.hpp b/src/mbgl/renderer/renderer_impl.hpp
new file mode 100644
index 0000000000..645b33b354
--- /dev/null
+++ b/src/mbgl/renderer/renderer_impl.hpp
@@ -0,0 +1,65 @@
+#pragma once
+#include <mbgl/renderer/renderer.hpp>
+#include <mbgl/renderer/renderer_observer.hpp>
+#include <mbgl/renderer/render_style_observer.hpp>
+#include <mbgl/style/style.hpp>
+
+#include <mbgl/map/backend.hpp>
+
+#include <memory>
+#include <string>
+
+namespace mbgl {
+
+enum class RenderState : uint8_t {
+ Never,
+ Partial,
+ Fully,
+};
+
+class Painter;
+class RenderStyle;
+class TransformState;
+class View;
+
+
+class Renderer::Impl : public RenderStyleObserver {
+public:
+ Impl(Backend&, float pixelRatio_, FileSource&, Scheduler&, GLContextMode,
+ const optional<std::string> programCacheDir);
+ ~Impl() final;
+
+ void setObserver(RendererObserver*);
+
+ void render(View&, const UpdateParameters&);
+
+ std::vector<Feature> queryRenderedFeatures(const ScreenLineString&, const RenderedQueryOptions&) const;
+ std::vector<Feature> querySourceFeatures(const std::string& sourceID, const SourceQueryOptions&) const;
+
+ void onLowMemory();
+
+ void dumDebugLogs() ;
+
+ // RenderStyleObserver implementation
+ void onInvalidate()override;
+ void onResourceError(std::exception_ptr) override;
+
+private:
+ friend class Renderer;
+
+ Backend& backend;
+
+ RendererObserver* observer;
+
+ const GLContextMode contextMode;
+ const float pixelRatio;
+ const optional<std::string> programCacheDir;
+
+ RenderState renderState = RenderState::Never;
+
+ std::unique_ptr<RenderStyle> renderStyle;
+ std::unique_ptr<Painter> painter;
+
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/renderer/renderer_observer.hpp b/src/mbgl/renderer/renderer_observer.hpp
new file mode 100644
index 0000000000..551b5c803e
--- /dev/null
+++ b/src/mbgl/renderer/renderer_observer.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include <exception>
+
+namespace mbgl {
+
+class RendererObserver {
+public:
+ virtual ~RendererObserver() = default;
+
+ enum class RenderMode : uint32_t {
+ Partial,
+ Full
+ };
+
+ // Signals that a repaint is required
+ virtual void onInvalidate() {}
+
+ // Resource failed to download / parse
+ virtual void onResourceError(std::exception_ptr) {}
+
+ // First frame
+ virtual void onWillStartRenderingMap() {}
+
+ // Start of frame, initial is the first frame for this map
+ virtual void onWillStartRenderingFrame() {}
+
+ // End of frame, boolean flags that a repaint is required
+ virtual void onDidFinishRenderingFrame(RenderMode, bool) {}
+
+ // Final frame
+ virtual void onDidFinishRenderingMap() {}
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/renderer/tile_pyramid.cpp b/src/mbgl/renderer/tile_pyramid.cpp
index 5b1e621743..4abe189826 100644
--- a/src/mbgl/renderer/tile_pyramid.cpp
+++ b/src/mbgl/renderer/tile_pyramid.cpp
@@ -3,8 +3,8 @@
#include <mbgl/renderer/painter.hpp>
#include <mbgl/renderer/render_source.hpp>
#include <mbgl/renderer/tile_parameters.hpp>
+#include <mbgl/renderer/query.hpp>
#include <mbgl/map/transform.hpp>
-#include <mbgl/map/query.hpp>
#include <mbgl/text/placement_config.hpp>
#include <mbgl/math/clamp.hpp>
#include <mbgl/util/tile_cover.hpp>
diff --git a/src/mbgl/renderer/update_parameters.hpp b/src/mbgl/renderer/update_parameters.hpp
index 04b59699b3..9fe8afcd89 100644
--- a/src/mbgl/renderer/update_parameters.hpp
+++ b/src/mbgl/renderer/update_parameters.hpp
@@ -2,11 +2,14 @@
#include <mbgl/map/mode.hpp>
#include <mbgl/map/transform_state.hpp>
-#include <mbgl/util/chrono.hpp>
#include <mbgl/style/light.hpp>
#include <mbgl/style/image.hpp>
#include <mbgl/style/source.hpp>
#include <mbgl/style/layer.hpp>
+#include <mbgl/util/chrono.hpp>
+#include <mbgl/util/immutable.hpp>
+
+#include <vector>
namespace mbgl {
@@ -16,7 +19,8 @@ class AnnotationManager;
class UpdateParameters {
public:
- UpdateParameters(const MapMode mode_,
+ UpdateParameters(const bool styleLoaded_,
+ const MapMode mode_,
const float pixelRatio_,
const MapDebugOptions debugOptions_,
const TimePoint timePoint_,
@@ -31,8 +35,10 @@ public:
Scheduler& scheduler_,
FileSource& fileSource_,
AnnotationManager& annotationManager_,
- const uint8_t prefetchZoomDelta_)
- : mode(mode_),
+ const uint8_t prefetchZoomDelta_,
+ const bool stillImageRequest_)
+ : styleLoaded(styleLoaded_),
+ mode(mode_),
pixelRatio(pixelRatio_),
debugOptions(debugOptions_),
timePoint(std::move(timePoint_)),
@@ -47,8 +53,10 @@ public:
scheduler(scheduler_),
fileSource(fileSource_),
annotationManager(annotationManager_),
- prefetchZoomDelta(prefetchZoomDelta_) {}
+ prefetchZoomDelta(prefetchZoomDelta_),
+ stillImageRequest(stillImageRequest_) {}
+ const bool styleLoaded;
const MapMode mode;
const float pixelRatio;
const MapDebugOptions debugOptions;
@@ -68,6 +76,9 @@ public:
AnnotationManager& annotationManager;
const uint8_t prefetchZoomDelta;
+
+ // For still image requests, render requested
+ const bool stillImageRequest;
};
} // namespace mbgl
diff --git a/src/mbgl/tile/geojson_tile.cpp b/src/mbgl/tile/geojson_tile.cpp
index e9865e8272..d5e2e14e54 100644
--- a/src/mbgl/tile/geojson_tile.cpp
+++ b/src/mbgl/tile/geojson_tile.cpp
@@ -1,6 +1,6 @@
#include <mbgl/tile/geojson_tile.hpp>
#include <mbgl/tile/geometry_tile_data.hpp>
-#include <mbgl/map/query.hpp>
+#include <mbgl/renderer/query.hpp>
#include <mbgl/renderer/tile_parameters.hpp>
#include <mapbox/geojsonvt.hpp>
diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp
index 4f1bc9e759..33911df9ed 100644
--- a/src/mbgl/tile/geometry_tile.cpp
+++ b/src/mbgl/tile/geometry_tile.cpp
@@ -10,13 +10,13 @@
#include <mbgl/renderer/layers/render_custom_layer.hpp>
#include <mbgl/renderer/layers/render_symbol_layer.hpp>
#include <mbgl/renderer/buckets/symbol_bucket.hpp>
+#include <mbgl/renderer/query.hpp>
#include <mbgl/text/glyph_atlas.hpp>
#include <mbgl/renderer/image_atlas.hpp>
#include <mbgl/storage/file_source.hpp>
#include <mbgl/geometry/feature_index.hpp>
#include <mbgl/text/collision_tile.hpp>
#include <mbgl/map/transform_state.hpp>
-#include <mbgl/map/query.hpp>
#include <mbgl/util/run_loop.hpp>
#include <mbgl/style/filter_evaluator.hpp>
#include <mbgl/util/chrono.hpp>
diff --git a/src/mbgl/tile/tile.cpp b/src/mbgl/tile/tile.cpp
index 5080d42933..35fc31dae1 100644
--- a/src/mbgl/tile/tile.cpp
+++ b/src/mbgl/tile/tile.cpp
@@ -1,9 +1,9 @@
#include <mbgl/tile/tile.hpp>
#include <mbgl/tile/tile_observer.hpp>
#include <mbgl/renderer/buckets/debug_bucket.hpp>
+#include <mbgl/renderer/query.hpp>
#include <mbgl/util/string.hpp>
#include <mbgl/util/logging.hpp>
-#include <mbgl/map/query.hpp>
namespace mbgl {