diff options
44 files changed, 1013 insertions, 538 deletions
diff --git a/bin/render.cpp b/bin/render.cpp index 74fd6fdcc4..fedd8bbda6 100644 --- a/bin/render.cpp +++ b/bin/render.cpp @@ -8,6 +8,8 @@ #include <mbgl/util/default_thread_pool.hpp> #include <mbgl/storage/default_file_source.hpp> #include <mbgl/style/style.hpp> +#include <mbgl/renderer/renderer.hpp> +#include <mbgl/renderer/async_renderer_frontend.hpp> #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunknown-pragmas" @@ -88,7 +90,8 @@ int main(int argc, char *argv[]) { OffscreenView view(backend.getContext(), { static_cast<uint32_t>(width * pixelRatio), static_cast<uint32_t>(height * pixelRatio) }); ThreadPool threadPool(4); - Map map(backend, MapObserver::nullObserver(), mbgl::Size { width, height }, pixelRatio, fileSource, threadPool, MapMode::Still); + AsyncRendererFrontend rendererFrontend(std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view); + Map map(rendererFrontend, MapObserver::nullObserver(), mbgl::Size { width, height }, pixelRatio, fileSource, threadPool, MapMode::Still); if (style_path.find("://") == std::string::npos) { style_path = std::string("file://") + style_path; @@ -103,7 +106,7 @@ int main(int argc, char *argv[]) { map.setDebug(debug ? mbgl::MapDebugOptions::TileBorders | mbgl::MapDebugOptions::ParseStatus : mbgl::MapDebugOptions::NoDebug); } - map.renderStill(view, [&](std::exception_ptr error) { + map.renderStill([&](std::exception_ptr error) { try { if (error) { std::rethrow_exception(error); diff --git a/cmake/core-files.cmake b/cmake/core-files.cmake index 28dd25376b..d22aa58fef 100644 --- a/cmake/core-files.cmake +++ b/cmake/core-files.cmake @@ -108,7 +108,6 @@ set(MBGL_CORE_FILES include/mbgl/map/map.hpp include/mbgl/map/map_observer.hpp include/mbgl/map/mode.hpp - include/mbgl/map/query.hpp include/mbgl/map/view.hpp src/mbgl/map/backend.cpp src/mbgl/map/backend_scope.cpp @@ -160,6 +159,9 @@ set(MBGL_CORE_FILES src/mbgl/programs/uniforms.hpp # renderer + include/mbgl/renderer/query.hpp + include/mbgl/renderer/renderer.hpp + include/mbgl/renderer/renderer_frontend.hpp src/mbgl/renderer/bucket.hpp src/mbgl/renderer/bucket_parameters.cpp src/mbgl/renderer/bucket_parameters.hpp @@ -196,6 +198,10 @@ set(MBGL_CORE_FILES src/mbgl/renderer/render_style_observer.hpp src/mbgl/renderer/render_tile.cpp src/mbgl/renderer/render_tile.hpp + src/mbgl/renderer/renderer.cpp + src/mbgl/renderer/renderer_impl.cpp + src/mbgl/renderer/renderer_impl.hpp + src/mbgl/renderer/renderer_observer.hpp src/mbgl/renderer/style_diff.cpp src/mbgl/renderer/style_diff.hpp src/mbgl/renderer/tile_parameters.hpp diff --git a/cmake/render.cmake b/cmake/render.cmake index 407e1ca8ef..350350dc76 100644 --- a/cmake/render.cmake +++ b/cmake/render.cmake @@ -1,4 +1,6 @@ add_executable(mbgl-render + platform/default/mbgl/renderer/async_renderer_frontend.cpp + platform/default/mbgl/renderer/async_renderer_frontend.hpp bin/render.cpp ) diff --git a/cmake/test-files.cmake b/cmake/test-files.cmake index cdca1db280..ca7182581b 100644 --- a/cmake/test-files.cmake +++ b/cmake/test-files.cmake @@ -60,6 +60,8 @@ set(MBGL_TEST_FILES test/src/mbgl/test/stub_geometry_tile_feature.hpp test/src/mbgl/test/stub_layer_observer.hpp test/src/mbgl/test/stub_render_source_observer.hpp + test/src/mbgl/test/stub_renderer_frontend.cpp + test/src/mbgl/test/stub_renderer_frontend.hpp test/src/mbgl/test/stub_style_observer.hpp test/src/mbgl/test/stub_tile_observer.hpp test/src/mbgl/test/test.cpp diff --git a/include/mbgl/map/backend.hpp b/include/mbgl/map/backend.hpp index 434f68779c..3347086571 100644 --- a/include/mbgl/map/backend.hpp +++ b/include/mbgl/map/backend.hpp @@ -1,6 +1,7 @@ #pragma once #include <mbgl/map/view.hpp> +#include <mbgl/map/backend_scope.hpp> #include <mbgl/util/image.hpp> #include <mbgl/util/size.hpp> @@ -15,8 +16,6 @@ using ProcAddress = void (*)(); using FramebufferID = uint32_t; } // namespace gl -class BackendScope; - class Backend { public: Backend(); @@ -28,9 +27,9 @@ public: // Called prior to rendering to update the internally assumed OpenGL state. virtual void updateAssumedState() = 0; - // Called when the map needs to be rendered; the backend should call Map::render() at some point - // in the near future. (Not called for Map::renderStill() mode.) - virtual void invalidate() = 0; + inline virtual BackendScope::ScopeType getScopeType() const { + return BackendScope::ScopeType::Explicit; + }; protected: // Called with the name of an OpenGL extension that should be loaded. Backend implementations diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp index 22ac100c40..14f42d7fd5 100644 --- a/include/mbgl/map/map.hpp +++ b/include/mbgl/map/map.hpp @@ -4,13 +4,10 @@ #include <mbgl/util/chrono.hpp> #include <mbgl/map/map_observer.hpp> #include <mbgl/map/mode.hpp> -#include <mbgl/util/geo.hpp> -#include <mbgl/util/feature.hpp> #include <mbgl/util/noncopyable.hpp> #include <mbgl/util/size.hpp> #include <mbgl/annotation/annotation.hpp> #include <mbgl/map/camera.hpp> -#include <mbgl/map/query.hpp> #include <cstdint> #include <string> @@ -24,6 +21,7 @@ class Backend; class View; class FileSource; class Scheduler; +class RendererFrontend; namespace style { class Image; @@ -32,30 +30,25 @@ class Style; class Map : private util::noncopyable { public: - explicit Map(Backend&, + explicit Map(RendererFrontend&, MapObserver&, Size size, float pixelRatio, FileSource&, Scheduler&, MapMode mapMode = MapMode::Continuous, - GLContextMode contextMode = GLContextMode::Unique, ConstrainMode constrainMode = ConstrainMode::HeightOnly, - ViewportMode viewportMode = ViewportMode::Default, - optional<std::string> programCacheDir = optional<std::string>()); + ViewportMode viewportMode = ViewportMode::Default); ~Map(); // Register a callback that will get called (on the render thread) when all resources have // been loaded and a complete render occurs. using StillImageCallback = std::function<void (std::exception_ptr)>; - void renderStill(View&, StillImageCallback callback); + void renderStill(StillImageCallback callback); // Triggers a repaint. void triggerRepaint(); - // Main render function. - void render(View&); - style::Style& getStyle(); const style::Style& getStyle() const; @@ -150,13 +143,6 @@ public: void updateAnnotation(AnnotationID, const Annotation&); void removeAnnotation(AnnotationID); - // Feature queries - std::vector<Feature> queryRenderedFeatures(const ScreenCoordinate&, const RenderedQueryOptions& options = {}); - std::vector<Feature> queryRenderedFeatures(const ScreenBox&, const RenderedQueryOptions& options = {}); - std::vector<Feature> querySourceFeatures(const std::string& sourceID, const SourceQueryOptions& options = {}); - - AnnotationIDs queryPointAnnotations(const ScreenBox&); - // Tile prefetching // // When loading a map, if `PrefetchZoomDelta` is set to any number greater than 0, the map will @@ -166,9 +152,6 @@ public: void setPrefetchZoomDelta(uint8_t delta); uint8_t getPrefetchZoomDelta() const; - // Memory - void onLowMemory(); - // Debug void setDebug(MapDebugOptions); void cycleDebugOptions(); diff --git a/include/mbgl/map/query.hpp b/include/mbgl/renderer/query.hpp index b9d5f21a44..b9d5f21a44 100644 --- a/include/mbgl/map/query.hpp +++ b/include/mbgl/renderer/query.hpp diff --git a/include/mbgl/renderer/renderer.hpp b/include/mbgl/renderer/renderer.hpp new file mode 100644 index 0000000000..6626f74d3d --- /dev/null +++ b/include/mbgl/renderer/renderer.hpp @@ -0,0 +1,54 @@ +#pragma once + +#include <mbgl/map/mode.hpp> +#include <mbgl/renderer/query.hpp> +#include <mbgl/annotation/annotation.hpp> +#include <mbgl/util/geo.hpp> +#include <mbgl/util/geo.hpp> + +#include <functional> +#include <memory> +#include <string> +#include <vector> + +namespace mbgl { + +class Backend; +class FileSource; +class RendererObserver; +class RenderedQueryOptions; +class Scheduler; +class SourceQueryOptions; +class UpdateParameters; +class View; + +class Renderer { +public: + Renderer(Backend&, float pixelRatio_, FileSource&, Scheduler&, + GLContextMode = GLContextMode::Unique, + const optional<std::string> programCacheDir = optional<std::string>()); + ~Renderer(); + + void setObserver(RendererObserver*); + + void render(View& view, const UpdateParameters&); + + // Feature queries + std::vector<Feature> queryRenderedFeatures(const ScreenLineString&, const RenderedQueryOptions& options = {}) const; + std::vector<Feature> queryRenderedFeatures(const ScreenCoordinate& point, const RenderedQueryOptions& options = {}) const; + std::vector<Feature> queryRenderedFeatures(const ScreenBox& box, const RenderedQueryOptions& options = {}) const; + std::vector<Feature> querySourceFeatures(const std::string& sourceID, const SourceQueryOptions& options = {}) const; + AnnotationIDs queryPointAnnotations(const ScreenBox& box) const; + + // Debug + void dumpDebugLogs(); + + // Memory + void onLowMemory(); + +private: + class Impl; + std::unique_ptr<Impl> impl; +}; + +} // namespace mbgl diff --git a/include/mbgl/renderer/renderer_frontend.hpp b/include/mbgl/renderer/renderer_frontend.hpp new file mode 100644 index 0000000000..f72b0ccdde --- /dev/null +++ b/include/mbgl/renderer/renderer_frontend.hpp @@ -0,0 +1,31 @@ +#pragma once + +#include <memory> + +namespace mbgl { + +class RendererObserver; +class UpdateParameters; + +// The RenderFrontend is the bridge between the Map and +// platform used to update and observer the Renderer +// +// It hides any threading specifics and always replies on +// the original thread. +class RendererFrontend { +public: + + virtual ~RendererFrontend() = default; + + // Must synchronously clean up the Renderer if set + virtual void reset() = 0; + + // Implementer must bind the renderer observer to the renderer in a + // appropriate manner so that the callbacks occur on the main thread + virtual void setObserver(RendererObserver&) = 0; + + // Coalescing updates is up to the implementer + virtual void update(std::shared_ptr<UpdateParameters>) = 0; +}; + +} // namespace mbgl diff --git a/platform/android/config.cmake b/platform/android/config.cmake index 5a6950a23f..9fdbfa1b45 100644 --- a/platform/android/config.cmake +++ b/platform/android/config.cmake @@ -57,6 +57,8 @@ macro(mbgl_platform_core) PRIVATE platform/default/bidi.cpp PRIVATE platform/default/thread_local.cpp PRIVATE platform/default/utf.cpp + PRIVATE platform/default/mbgl/renderer/default_render_bridge.cpp + PRIVATE platform/default/mbgl/renderer/default_render_bridge.hpp # Image handling PRIVATE platform/default/png_writer.cpp diff --git a/platform/default/mbgl/gl/headless_backend.cpp b/platform/default/mbgl/gl/headless_backend.cpp index df3a517823..82cf7b38fd 100644 --- a/platform/default/mbgl/gl/headless_backend.cpp +++ b/platform/default/mbgl/gl/headless_backend.cpp @@ -16,7 +16,7 @@ HeadlessBackend::HeadlessBackend(std::shared_ptr<HeadlessDisplay> display_) } HeadlessBackend::~HeadlessBackend() { - BackendScope scope(*this); + BackendScope guard { *this, getScopeType() }; context.reset(); } @@ -44,8 +44,4 @@ void HeadlessBackend::updateAssumedState() { // no-op } -void HeadlessBackend::invalidate() { - assert(false); -} - } // namespace mbgl diff --git a/platform/default/mbgl/gl/headless_backend.hpp b/platform/default/mbgl/gl/headless_backend.hpp index 26033acf82..7b9f7f5ad3 100644 --- a/platform/default/mbgl/gl/headless_backend.hpp +++ b/platform/default/mbgl/gl/headless_backend.hpp @@ -17,8 +17,6 @@ public: void updateAssumedState() override; - void invalidate() override; - struct Impl { virtual ~Impl() = default; virtual void activateContext() = 0; diff --git a/platform/default/mbgl/renderer/async_renderer_frontend.cpp b/platform/default/mbgl/renderer/async_renderer_frontend.cpp new file mode 100644 index 0000000000..37b4e60cf6 --- /dev/null +++ b/platform/default/mbgl/renderer/async_renderer_frontend.cpp @@ -0,0 +1,38 @@ +#include "async_renderer_frontend.hpp" +#include <mbgl/renderer/renderer.hpp> + +namespace mbgl { + +AsyncRendererFrontend::AsyncRendererFrontend(std::unique_ptr<Renderer> renderer_, View& view_) + : renderer(std::move(renderer_)) + , view(view_) + , asyncInvalidate([this] { + if (renderer && updateParameters) { + renderer->render(view, *updateParameters); + } + }) { +} + +AsyncRendererFrontend::~AsyncRendererFrontend() = default; + +void AsyncRendererFrontend::reset() { + assert(renderer); + renderer.reset(); +} + +void AsyncRendererFrontend::update(std::shared_ptr<UpdateParameters> updateParameters_) { + updateParameters = updateParameters_; + asyncInvalidate.send(); +} + +void AsyncRendererFrontend::setObserver(RendererObserver& observer_) { + assert(renderer); + renderer->setObserver(&observer_); +} + +Renderer* AsyncRendererFrontend::getRenderer() { + assert(renderer); + return renderer.get(); +} + +} // namespace mbgl diff --git a/platform/default/mbgl/renderer/async_renderer_frontend.hpp b/platform/default/mbgl/renderer/async_renderer_frontend.hpp new file mode 100644 index 0000000000..00cf3a480c --- /dev/null +++ b/platform/default/mbgl/renderer/async_renderer_frontend.hpp @@ -0,0 +1,35 @@ +#pragma once + +#include <mbgl/map/view.hpp> +#include <mbgl/renderer/renderer_frontend.hpp> +#include <mbgl/util/async_task.hpp> + +#include <memory> +#include <vector> + +namespace mbgl { + +class Renderer; + +// Default implementation for RendererFrontend +class AsyncRendererFrontend : public mbgl::RendererFrontend { +public: + AsyncRendererFrontend(std::unique_ptr<Renderer>, View&); + ~AsyncRendererFrontend() override; + + void reset() override; + + void update(std::shared_ptr<UpdateParameters> updateParameters_) override; + + void setObserver(RendererObserver& observer_) override; + + Renderer* getRenderer(); + +private: + std::unique_ptr<Renderer> renderer; + View& view; + std::shared_ptr<UpdateParameters> updateParameters; + util::AsyncTask asyncInvalidate; +}; + +} // namespace mbgl diff --git a/platform/node/src/node_map.cpp b/platform/node/src/node_map.cpp index 78e98e2a28..2599996f7c 100644 --- a/platform/node/src/node_map.cpp +++ b/platform/node/src/node_map.cpp @@ -12,7 +12,6 @@ #include <mbgl/style/style.hpp> #include <mbgl/style/image.hpp> #include <mbgl/map/backend_scope.hpp> -#include <mbgl/map/query.hpp> #include <mbgl/util/premultiply.hpp> #include <unistd.h> 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 { diff --git a/test/api/annotations.test.cpp b/test/api/annotations.test.cpp index 42fbcc0a8b..76e66c2fa3 100644 --- a/test/api/annotations.test.cpp +++ b/test/api/annotations.test.cpp @@ -12,6 +12,8 @@ #include <mbgl/util/io.hpp> #include <mbgl/util/run_loop.hpp> #include <mbgl/util/color.hpp> +#include <mbgl/renderer/renderer.hpp> +#include <mbgl/test/stub_renderer_frontend.hpp> using namespace mbgl; @@ -33,7 +35,10 @@ public: OffscreenView view { backend.getContext() }; StubFileSource fileSource; ThreadPool threadPool { 4 }; - Map map { backend, MapObserver::nullObserver(), view.getSize(), 1, fileSource, threadPool, MapMode::Still }; + float pixelRatio { 1 }; + StubRendererFrontend rendererFrontend { std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view }; + Map map { rendererFrontend, MapObserver::nullObserver(), view.getSize(), pixelRatio, fileSource, + threadPool, MapMode::Still }; void checkRendering(const char * name) { test::checkImage(std::string("test/fixtures/annotations/") + name, @@ -346,12 +351,12 @@ TEST(Annotations, QueryRenderedFeatures) { test::render(test.map, test.view); - auto features = test.map.queryRenderedFeatures(test.map.pixelForLatLng({ 0, 0 })); + auto features = test.rendererFrontend.getRenderer()->queryRenderedFeatures(test.map.pixelForLatLng({ 0, 0 })); EXPECT_EQ(features.size(), 1u); EXPECT_TRUE(!!features[0].id); EXPECT_EQ(*features[0].id, uint64_t(0)); - auto features2 = test.map.queryRenderedFeatures(test.map.pixelForLatLng({ 50, 0 })); + auto features2 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(test.map.pixelForLatLng({ 50, 0 })); EXPECT_EQ(features2.size(), 1u); EXPECT_TRUE(!!features2[0].id); EXPECT_EQ(*features2[0].id, uint64_t(1)); @@ -377,7 +382,7 @@ TEST(Annotations, QueryFractionalZoomLevels) { for (uint16_t zoomSteps = 10; zoomSteps <= 20; ++zoomSteps) { test.map.setZoom(zoomSteps / 10.0); test::render(test.map, test.view); - auto features = test.map.queryRenderedFeatures(box); + auto features = test.rendererFrontend.getRenderer()->queryRenderedFeatures(box); // Filter out repeated features. // See 'edge-cases/null-island' query-test for reference. @@ -410,7 +415,7 @@ TEST(Annotations, VisibleFeatures) { test.map.setBearing(45); test::render(test.map, test.view); - auto features = test.map.queryRenderedFeatures(box, {}); + auto features = test.rendererFrontend.getRenderer()->queryRenderedFeatures(box, {}); auto sortID = [](const Feature& lhs, const Feature& rhs) { return lhs.id < rhs.id; }; auto sameID = [](const Feature& lhs, const Feature& rhs) { return lhs.id == rhs.id; }; std::sort(features.begin(), features.end(), sortID); @@ -420,7 +425,7 @@ TEST(Annotations, VisibleFeatures) { test.map.setBearing(0); test.map.setZoom(4); test::render(test.map, test.view); - features = test.map.queryRenderedFeatures(box); + features = test.rendererFrontend.getRenderer()->queryRenderedFeatures(box); std::sort(features.begin(), features.end(), sortID); features.erase(std::unique(features.begin(), features.end(), sameID), features.end()); EXPECT_EQ(features.size(), ids.size()); diff --git a/test/api/api_misuse.test.cpp b/test/api/api_misuse.test.cpp index e5498576a8..742137d73d 100644 --- a/test/api/api_misuse.test.cpp +++ b/test/api/api_misuse.test.cpp @@ -6,7 +6,9 @@ #include <mbgl/map/backend_scope.hpp> #include <mbgl/gl/headless_backend.hpp> #include <mbgl/gl/offscreen_view.hpp> +#include <mbgl/test/stub_renderer_frontend.hpp> #include <mbgl/storage/online_file_source.hpp> +#include <mbgl/renderer/renderer.hpp> #include <mbgl/util/default_thread_pool.hpp> #include <mbgl/util/exception.hpp> #include <mbgl/util/run_loop.hpp> @@ -27,10 +29,13 @@ TEST(API, RenderWithoutCallback) { OffscreenView view { backend.getContext(), { 128, 512 } }; StubFileSource fileSource; ThreadPool threadPool(4); + float pixelRatio { 1 }; + StubRendererFrontend rendererFrontend { + std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view }; - std::unique_ptr<Map> map = - std::make_unique<Map>(backend, MapObserver::nullObserver(), view.getSize(), 1, fileSource, threadPool, MapMode::Still); - map->renderStill(view, nullptr); + auto map = std::make_unique<Map>(rendererFrontend, MapObserver::nullObserver(), view.getSize(), + pixelRatio, fileSource, threadPool, MapMode::Still); + map->renderStill(nullptr); // Force Map thread to join. map.reset(); diff --git a/test/api/custom_layer.test.cpp b/test/api/custom_layer.test.cpp index b5d94f2786..b3ef0719ce 100644 --- a/test/api/custom_layer.test.cpp +++ b/test/api/custom_layer.test.cpp @@ -7,9 +7,11 @@ #include <mbgl/gl/offscreen_view.hpp> #include <mbgl/util/default_thread_pool.hpp> #include <mbgl/storage/default_file_source.hpp> +#include <mbgl/renderer/renderer.hpp> #include <mbgl/style/style.hpp> #include <mbgl/style/layers/custom_layer.hpp> #include <mbgl/style/layers/fill_layer.hpp> +#include <mbgl/test/stub_renderer_frontend.hpp> #include <mbgl/util/io.hpp> #include <mbgl/util/mat4.hpp> #include <mbgl/util/run_loop.hpp> @@ -92,8 +94,10 @@ TEST(CustomLayer, Basic) { OffscreenView view { backend.getContext() }; DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets"); ThreadPool threadPool(4); - - Map map(backend, MapObserver::nullObserver(), view.getSize(), 1, fileSource, threadPool, MapMode::Still); + float pixelRatio { 1 }; + StubRendererFrontend rendererFrontend { std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view }; + Map map(rendererFrontend, MapObserver::nullObserver(), view.getSize(), pixelRatio, fileSource, + threadPool, MapMode::Still); map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json")); map.setLatLngZoom({ 37.8, -122.5 }, 10); map.getStyle().addLayer(std::make_unique<CustomLayer>( @@ -114,4 +118,5 @@ TEST(CustomLayer, Basic) { map.getStyle().addLayer(std::move(layer)); test::checkImage("test/fixtures/custom_layer/basic", test::render(map, view), 0.0006, 0.1); + } diff --git a/test/api/query.test.cpp b/test/api/query.test.cpp index 0b02e47219..efb31f89c6 100644 --- a/test/api/query.test.cpp +++ b/test/api/query.test.cpp @@ -11,6 +11,8 @@ #include <mbgl/style/style.hpp> #include <mbgl/style/image.hpp> #include <mbgl/style/source.hpp> +#include <mbgl/renderer/renderer.hpp> +#include <mbgl/test/stub_renderer_frontend.hpp> using namespace mbgl; using namespace mbgl::style; @@ -33,7 +35,11 @@ public: OffscreenView view { backend.getContext() }; StubFileSource fileSource; ThreadPool threadPool { 4 }; - Map map { backend, MapObserver::nullObserver(), view.getSize(), 1, fileSource, threadPool, MapMode::Still }; + float pixelRatio { 1 }; + StubRendererFrontend rendererFrontend { + std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view }; + Map map { rendererFrontend, MapObserver::nullObserver(), view.getSize(), pixelRatio, fileSource, + threadPool, MapMode::Still }; }; } // end namespace @@ -41,10 +47,10 @@ public: TEST(Query, QueryRenderedFeatures) { QueryTest test; - auto features1 = test.map.queryRenderedFeatures(test.map.pixelForLatLng({ 0, 0 })); + auto features1 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(test.map.pixelForLatLng({ 0, 0 })); EXPECT_EQ(features1.size(), 4u); - auto features2 = test.map.queryRenderedFeatures(test.map.pixelForLatLng({ 9, 9 })); + auto features2 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(test.map.pixelForLatLng({ 9, 9 })); EXPECT_EQ(features2.size(), 0u); } @@ -53,16 +59,16 @@ TEST(Query, QueryRenderedFeaturesFilterLayer) { auto zz = test.map.pixelForLatLng({ 0, 0 }); - auto features1 = test.map.queryRenderedFeatures(zz, {{{ "layer1"}}, {}}); + auto features1 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{{ "layer1"}}, {}}); EXPECT_EQ(features1.size(), 1u); - auto features2 = test.map.queryRenderedFeatures(zz, {{{ "layer1", "layer2" }}, {}}); + auto features2 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{{ "layer1", "layer2" }}, {}}); EXPECT_EQ(features2.size(), 2u); - auto features3 = test.map.queryRenderedFeatures(zz, {{{ "foobar" }}, {}}); + auto features3 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{{ "foobar" }}, {}}); EXPECT_EQ(features3.size(), 0u); - auto features4 = test.map.queryRenderedFeatures(zz, {{{ "foobar", "layer3" }}, {}}); + auto features4 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{{ "foobar", "layer3" }}, {}}); EXPECT_EQ(features4.size(), 1u); } @@ -72,22 +78,22 @@ TEST(Query, QueryRenderedFeaturesFilter) { auto zz = test.map.pixelForLatLng({ 0, 0 }); const EqualsFilter eqFilter = { "key1", std::string("value1") }; - auto features1 = test.map.queryRenderedFeatures(zz, {{}, { eqFilter }}); + auto features1 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{}, { eqFilter }}); EXPECT_EQ(features1.size(), 1u); const IdentifierNotEqualsFilter idNotEqFilter = { std::string("feature1") }; - auto features2 = test.map.queryRenderedFeatures(zz, {{{ "layer4" }}, { idNotEqFilter }}); + auto features2 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{{ "layer4" }}, { idNotEqFilter }}); EXPECT_EQ(features2.size(), 0u); const GreaterThanFilter gtFilter = { "key2", 1.0 }; - auto features3 = test.map.queryRenderedFeatures(zz, {{ }, { gtFilter }}); + auto features3 = test.rendererFrontend.getRenderer()->queryRenderedFeatures(zz, {{ }, { gtFilter }}); EXPECT_EQ(features3.size(), 1u); } TEST(Query, QuerySourceFeatures) { QueryTest test; - auto features1 = test.map.querySourceFeatures("source3"); + auto features1 = test.rendererFrontend.getRenderer()->querySourceFeatures("source3"); EXPECT_EQ(features1.size(), 1u); } @@ -95,15 +101,15 @@ TEST(Query, QuerySourceFeaturesOptionValidation) { QueryTest test; // GeoJSONSource, doesn't require a layer id - auto features = test.map.querySourceFeatures("source3"); + auto features = test.rendererFrontend.getRenderer()->querySourceFeatures("source3"); ASSERT_EQ(features.size(), 1u); // VectorSource, requires a layer id - features = test.map.querySourceFeatures("source5"); + features = test.rendererFrontend.getRenderer()->querySourceFeatures("source5"); ASSERT_EQ(features.size(), 0u); // RasterSource, not supported - features = test.map.querySourceFeatures("source6"); + features = test.rendererFrontend.getRenderer()->querySourceFeatures("source6"); ASSERT_EQ(features.size(), 0u); } @@ -111,15 +117,15 @@ TEST(Query, QuerySourceFeaturesFilter) { QueryTest test; const EqualsFilter eqFilter = { "key1", std::string("value1") }; - auto features1 = test.map.querySourceFeatures("source4", {{}, { eqFilter }}); + auto features1 = test.rendererFrontend.getRenderer()->querySourceFeatures("source4", {{}, { eqFilter }}); EXPECT_EQ(features1.size(), 1u); const IdentifierNotEqualsFilter idNotEqFilter = { std::string("feature1") }; - auto features2 = test.map.querySourceFeatures("source4", {{}, { idNotEqFilter }}); + auto features2 = test.rendererFrontend.getRenderer()->querySourceFeatures("source4", {{}, { idNotEqFilter }}); EXPECT_EQ(features2.size(), 0u); const GreaterThanFilter gtFilter = { "key2", 1.0 }; - auto features3 = test.map.querySourceFeatures("source4", {{}, { gtFilter }}); + auto features3 = test.rendererFrontend.getRenderer()->querySourceFeatures("source4", {{}, { gtFilter }}); EXPECT_EQ(features3.size(), 1u); } diff --git a/test/api/render_missing.test.cpp b/test/api/render_missing.test.cpp index 9cba1dcac7..bce6df6305 100644 --- a/test/api/render_missing.test.cpp +++ b/test/api/render_missing.test.cpp @@ -7,12 +7,15 @@ #include <mbgl/gl/offscreen_view.hpp> #include <mbgl/util/default_thread_pool.hpp> #include <mbgl/storage/default_file_source.hpp> +#include <mbgl/renderer/renderer.hpp> #include <mbgl/util/image.hpp> #include <mbgl/util/io.hpp> #include <mbgl/util/run_loop.hpp> #include <mbgl/style/style.hpp> +#include <mbgl/test/stub_renderer_frontend.hpp> #include <future> +#include <memory> #if TEST_HAS_SERVER #define TEST_REQUIRES_SERVER(name) name @@ -30,19 +33,22 @@ TEST(API, TEST_REQUIRES_SERVER(RenderMissingTile)) { HeadlessBackend backend { test::sharedDisplay() }; BackendScope scope { backend }; OffscreenView view { backend.getContext(), { 256, 512 } }; + float pixelRatio { 1 }; DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets"); ThreadPool threadPool(4); + StubRendererFrontend rendererFrontend { std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view }; Log::setObserver(std::make_unique<FixtureLogObserver>()); - Map map(backend, MapObserver::nullObserver(), view.getSize(), 1, fileSource, threadPool, MapMode::Still); + Map map { rendererFrontend, MapObserver::nullObserver(), view.getSize(), pixelRatio, fileSource, + threadPool, MapMode::Still }; std::string message; // This host does not respond (== connection error). // Are you seeing this test fail? Make sure you don't have a server running on port 3001! map.getStyle().loadJSON(style); - map.renderStill(view, [&](std::exception_ptr err) { + map.renderStill([&](std::exception_ptr err) { ASSERT_TRUE(err.operator bool()); try { std::rethrow_exception(err); diff --git a/test/api/repeated_render.test.cpp b/test/api/repeated_render.test.cpp index 033b741ab6..d52765e2a5 100644 --- a/test/api/repeated_render.test.cpp +++ b/test/api/repeated_render.test.cpp @@ -7,10 +7,12 @@ #include <mbgl/gl/offscreen_view.hpp> #include <mbgl/util/default_thread_pool.hpp> #include <mbgl/storage/default_file_source.hpp> +#include <mbgl/renderer/renderer.hpp> #include <mbgl/util/image.hpp> #include <mbgl/util/io.hpp> #include <mbgl/util/run_loop.hpp> #include <mbgl/style/style.hpp> +#include <mbgl/test/stub_renderer_frontend.hpp> #include <mbgl/style/layers/line_layer.hpp> #include <mbgl/style/sources/geojson_source.hpp> @@ -28,17 +30,21 @@ TEST(API, RepeatedRender) { HeadlessBackend backend { test::sharedDisplay() }; BackendScope scope { backend }; OffscreenView view { backend.getContext(), { 512, 512 } }; + float pixelRatio { 1 }; DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets"); ThreadPool threadPool(4); + StubRendererFrontend rendererFrontend { + std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view }; Log::setObserver(std::make_unique<FixtureLogObserver>()); - Map map(backend, MapObserver::nullObserver(), view.getSize(), 1, fileSource, threadPool, MapMode::Still); + Map map(rendererFrontend, MapObserver::nullObserver(), view.getSize(), pixelRatio, fileSource, + threadPool, MapMode::Still); { map.getStyle().loadJSON(style); PremultipliedImage result; - map.renderStill(view, [&](std::exception_ptr) { + map.renderStill([&](std::exception_ptr) { result = view.readStillImage(); }); @@ -54,7 +60,7 @@ TEST(API, RepeatedRender) { { map.getStyle().loadJSON(style); PremultipliedImage result; - map.renderStill(view, [&](std::exception_ptr) { + map.renderStill([&](std::exception_ptr) { result = view.readStillImage(); }); @@ -86,7 +92,10 @@ TEST(API, ZoomHistory) { Log::setObserver(std::make_unique<FixtureLogObserver>()); - Map map(backend, MapObserver::nullObserver(), view.getSize(), 1, fileSource, threadPool, MapMode::Still); + float pixelRatio { 1 }; + StubRendererFrontend rendererFrontend { + std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view }; + Map map(rendererFrontend, MapObserver::nullObserver(), view.getSize(), pixelRatio, fileSource, threadPool, MapMode::Still); map.getStyle().loadJSON(style); auto geojson = mapbox::geojson::parse(R"t({ "type": "FeatureCollection", "features": [{ "type": "Feature", "properties": {}, "geometry": { "type": "LineString", "coordinates": [ [ -150, -75 ], [ 150, 75 ] ] } } ] })t"); @@ -101,7 +110,7 @@ TEST(API, ZoomHistory) { { PremultipliedImage result; - map.renderStill(view, [&](std::exception_ptr) { + map.renderStill([&](std::exception_ptr) { result = view.readStillImage(); }); @@ -116,7 +125,7 @@ TEST(API, ZoomHistory) { map.setZoom(1.0); PremultipliedImage result; - map.renderStill(view, [&](std::exception_ptr) { + map.renderStill([&](std::exception_ptr) { result = view.readStillImage(); }); diff --git a/test/map/map.test.cpp b/test/map/map.test.cpp index 206371613d..ef1d7c3d6f 100644 --- a/test/map/map.test.cpp +++ b/test/map/map.test.cpp @@ -12,6 +12,7 @@ #include <mbgl/storage/network_status.hpp> #include <mbgl/storage/default_file_source.hpp> #include <mbgl/storage/online_file_source.hpp> +#include <mbgl/renderer/renderer.hpp> #include <mbgl/util/image.hpp> #include <mbgl/util/io.hpp> #include <mbgl/util/run_loop.hpp> @@ -19,26 +20,13 @@ #include <mbgl/style/style.hpp> #include <mbgl/style/image.hpp> #include <mbgl/style/layers/background_layer.hpp> +#include <mbgl/test/stub_renderer_frontend.hpp> #include <mbgl/util/color.hpp> using namespace mbgl; using namespace mbgl::style; using namespace std::literals::string_literals; -class MockBackend : public HeadlessBackend { -public: - MockBackend() - : HeadlessBackend(test::sharedDisplay() ) { - } - - std::function<void()> callback; - void invalidate() override { - if (callback) { - callback(); - } - } -}; - class StubMapObserver : public MapObserver { public: void onWillStartLoadingMap() final { @@ -71,66 +59,83 @@ public: std::function<void()> didFinishLoadingStyleCallback; }; -struct MapTest { +template <class FileSource = StubFileSource> +class MapTest { +public: util::RunLoop runLoop; - MockBackend backend; - StubMapObserver observer; + HeadlessBackend backend; BackendScope scope { backend }; OffscreenView view { backend.getContext() }; - StubFileSource fileSource; + FileSource fileSource; ThreadPool threadPool { 4 }; + StubMapObserver observer; + StubRendererFrontend rendererFrontend; + Map map; + + MapTest(float pixelRatio = 1, MapMode mode = MapMode::Still) + : rendererFrontend( + std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), view) + , map(rendererFrontend, observer, view.getSize(), pixelRatio, fileSource, threadPool, mode) { + } + + template <typename T = FileSource> + MapTest(const std::string& cachePath, const std::string& assetRoot, + float pixelRatio = 1, MapMode mode = MapMode::Still, + typename std::enable_if<std::is_same<T, DefaultFileSource>::value>::type* = 0) + : fileSource { cachePath, assetRoot } + , rendererFrontend( + std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), + view) + , map(rendererFrontend, observer, view.getSize(), pixelRatio, fileSource, threadPool, mode) { + } }; TEST(Map, LatLngBehavior) { - MapTest test; - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); + MapTest<> test; - map.setLatLngZoom({ 1, 1 }, 0); - auto latLng1 = map.getLatLng(); + test.map.setLatLngZoom({ 1, 1 }, 0); + auto latLng1 = test.map.getLatLng(); - map.setLatLng({ 1, 1 }); - auto latLng2 = map.getLatLng(); + test.map.setLatLng({ 1, 1 }); + auto latLng2 = test.map.getLatLng(); ASSERT_DOUBLE_EQ(latLng1.latitude(), latLng2.latitude()); ASSERT_DOUBLE_EQ(latLng1.longitude(), latLng2.longitude()); } TEST(Map, LatLngBoundsToCamera) { - MapTest test; - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); + MapTest<> test; - map.setLatLngZoom({ 40.712730, -74.005953 }, 16.0); + test.map.setLatLngZoom({ 40.712730, -74.005953 }, 16.0); LatLngBounds bounds = LatLngBounds::hull({15.68169,73.499857}, {53.560711, 134.77281}); - CameraOptions virtualCamera = map.cameraForLatLngBounds(bounds, {}); + CameraOptions virtualCamera = test.map.cameraForLatLngBounds(bounds, {}); ASSERT_TRUE(bounds.contains(*virtualCamera.center)); } TEST(Map, CameraToLatLngBounds) { - MapTest test; - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); + MapTest<> test; - map.setLatLngZoom({ 45, 90 }, 16); + test.map.setLatLngZoom({ 45, 90 }, 16); LatLngBounds bounds = LatLngBounds::hull( - map.latLngForPixel({}), - map.latLngForPixel({ double(map.getSize().width), double(map.getSize().height) })); + test.map.latLngForPixel({}), + test.map.latLngForPixel({ double(test.map.getSize().width), double(test.map.getSize().height) })); - CameraOptions camera = map.getCameraOptions({}); + CameraOptions camera = test.map.getCameraOptions({}); - ASSERT_EQ(bounds, map.latLngBoundsForCamera(camera)); + ASSERT_EQ(bounds, test.map.latLngBoundsForCamera(camera)); // Map::cameraForLatLngBounds only sets zoom and center. - CameraOptions virtualCamera = map.cameraForLatLngBounds(bounds, {}); + CameraOptions virtualCamera = test.map.cameraForLatLngBounds(bounds, {}); ASSERT_NEAR(*camera.zoom, *virtualCamera.zoom, 1e-7); ASSERT_NEAR(camera.center->latitude(), virtualCamera.center->latitude(), 1e-7); ASSERT_NEAR(camera.center->longitude(), virtualCamera.center->longitude(), 1e-7); } TEST(Map, Offline) { - MapTest test; - DefaultFileSource fileSource(":memory:", "."); + MapTest<DefaultFileSource> test {":memory:", "."}; auto expiredItem = [] (const std::string& path) { Response response; @@ -140,19 +145,18 @@ TEST(Map, Offline) { }; const std::string prefix = "http://127.0.0.1:3000/"; - fileSource.put(Resource::style(prefix + "style.json"), expiredItem("style.json")); - fileSource.put(Resource::source(prefix + "streets.json"), expiredItem("streets.json")); - fileSource.put(Resource::spriteJSON(prefix + "sprite", 1.0), expiredItem("sprite.json")); - fileSource.put(Resource::spriteImage(prefix + "sprite", 1.0), expiredItem("sprite.png")); - fileSource.put(Resource::tile(prefix + "{z}-{x}-{y}.vector.pbf", 1.0, 0, 0, 0, Tileset::Scheme::XYZ), expiredItem("0-0-0.vector.pbf")); - fileSource.put(Resource::glyphs(prefix + "{fontstack}/{range}.pbf", {{"Helvetica"}}, {0, 255}), expiredItem("glyph.pbf")); + test.fileSource.put(Resource::style(prefix + "style.json"), expiredItem("style.json")); + test.fileSource.put(Resource::source(prefix + "streets.json"), expiredItem("streets.json")); + test.fileSource.put(Resource::spriteJSON(prefix + "sprite", 1.0), expiredItem("sprite.json")); + test.fileSource.put(Resource::spriteImage(prefix + "sprite", 1.0), expiredItem("sprite.png")); + test.fileSource.put(Resource::tile(prefix + "{z}-{x}-{y}.vector.pbf", 1.0, 0, 0, 0, Tileset::Scheme::XYZ), expiredItem("0-0-0.vector.pbf")); + test.fileSource.put(Resource::glyphs(prefix + "{fontstack}/{range}.pbf", {{"Helvetica"}}, {0, 255}), expiredItem("glyph.pbf")); NetworkStatus::Set(NetworkStatus::Status::Offline); - Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadURL(prefix + "style.json"); + test.map.getStyle().loadURL(prefix + "style.json"); test::checkImage("test/fixtures/map/offline", - test::render(map, test.view), + test::render(test.map, test.view), 0.0015, 0.1); @@ -160,19 +164,16 @@ TEST(Map, Offline) { } TEST(Map, SetStyleInvalidJSON) { - MapTest test; - Log::setObserver(std::make_unique<FixtureLogObserver>()); bool fail = false; - test.observer.didFailLoadingMapCallback = [&]() { - fail = true; - }; { - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, - MapMode::Still); - map.getStyle().loadJSON("invalid"); + MapTest<> test; + test.observer.didFailLoadingMapCallback = [&]() { + fail = true; + }; + test.map.getStyle().loadJSON("invalid"); } EXPECT_TRUE(fail); @@ -186,7 +187,7 @@ TEST(Map, SetStyleInvalidJSON) { } TEST(Map, SetStyleInvalidURL) { - MapTest test; + MapTest<> test; test.fileSource.styleResponse = [] (const Resource&) { Response response; @@ -200,36 +201,32 @@ TEST(Map, SetStyleInvalidURL) { test.runLoop.stop(); }; - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadURL("mapbox://bar"); + test.map.getStyle().loadURL("mapbox://bar"); test.runLoop.run(); } TEST(Map, DoubleStyleLoad) { - MapTest test; + MapTest<> test; - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadJSON(""); - map.getStyle().loadJSON(""); + test.map.getStyle().loadJSON(""); + test.map.getStyle().loadJSON(""); } TEST(Map, StyleFresh) { // The map should not revalidate fresh styles. - MapTest test; - FakeFileSource fileSource; + MapTest<FakeFileSource> test; - Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadURL("mapbox://styles/test"); - EXPECT_EQ(1u, fileSource.requests.size()); + test.map.getStyle().loadURL("mapbox://styles/test"); + EXPECT_EQ(1u, test.fileSource.requests.size()); Response response; response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/empty.json")); response.expires = Timestamp::max(); - fileSource.respond(Resource::Style, response); - EXPECT_EQ(0u, fileSource.requests.size()); + test.fileSource.respond(Resource::Style, response); + EXPECT_EQ(0u, test.fileSource.requests.size()); } TEST(Map, StyleExpired) { @@ -237,26 +234,24 @@ TEST(Map, StyleExpired) { using namespace std::chrono_literals; - MapTest test; - FakeFileSource fileSource; + MapTest<FakeFileSource> test; - Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadURL("mapbox://styles/test"); - EXPECT_EQ(1u, fileSource.requests.size()); + test.map.getStyle().loadURL("mapbox://styles/test"); + EXPECT_EQ(1u, test.fileSource.requests.size()); Response response; response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/empty.json")); response.expires = util::now() - 1h; - fileSource.respond(Resource::Style, response); - EXPECT_EQ(1u, fileSource.requests.size()); + test.fileSource.respond(Resource::Style, response); + EXPECT_EQ(1u, test.fileSource.requests.size()); - map.getStyle().addLayer(std::make_unique<style::BackgroundLayer>("bg")); - EXPECT_EQ(1u, fileSource.requests.size()); + test.map.getStyle().addLayer(std::make_unique<style::BackgroundLayer>("bg")); + EXPECT_EQ(1u, test.fileSource.requests.size()); - fileSource.respond(Resource::Style, response); - EXPECT_EQ(0u, fileSource.requests.size()); - EXPECT_NE(nullptr, map.getStyle().getLayer("bg")); + test.fileSource.respond(Resource::Style, response); + EXPECT_EQ(0u, test.fileSource.requests.size()); + EXPECT_NE(nullptr, test.map.getStyle().getLayer("bg")); } TEST(Map, StyleExpiredWithAnnotations) { @@ -264,25 +259,23 @@ TEST(Map, StyleExpiredWithAnnotations) { using namespace std::chrono_literals; - MapTest test; - FakeFileSource fileSource; + MapTest<FakeFileSource> test; - Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadURL("mapbox://styles/test"); - EXPECT_EQ(1u, fileSource.requests.size()); + test.map.getStyle().loadURL("mapbox://styles/test"); + EXPECT_EQ(1u, test.fileSource.requests.size()); Response response; response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/empty.json")); response.expires = util::now() - 1h; - fileSource.respond(Resource::Style, response); - EXPECT_EQ(1u, fileSource.requests.size()); + test.fileSource.respond(Resource::Style, response); + EXPECT_EQ(1u, test.fileSource.requests.size()); - map.addAnnotation(LineAnnotation { LineString<double> {{ { 0, 0 }, { 10, 10 } }} }); - EXPECT_EQ(1u, fileSource.requests.size()); + test.map.addAnnotation(LineAnnotation { LineString<double> {{ { 0, 0 }, { 10, 10 } }} }); + EXPECT_EQ(1u, test.fileSource.requests.size()); - fileSource.respond(Resource::Style, response); - EXPECT_EQ(1u, fileSource.requests.size()); + test.fileSource.respond(Resource::Style, response); + EXPECT_EQ(1u, test.fileSource.requests.size()); } TEST(Map, StyleExpiredWithRender) { @@ -290,98 +283,85 @@ TEST(Map, StyleExpiredWithRender) { using namespace std::chrono_literals; - MapTest test; - FakeFileSource fileSource; + MapTest<FakeFileSource> test; - Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadURL("mapbox://styles/test"); - EXPECT_EQ(1u, fileSource.requests.size()); + test.map.getStyle().loadURL("mapbox://styles/test"); + EXPECT_EQ(1u, test.fileSource.requests.size()); Response response; response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/empty.json")); response.expires = util::now() - 1h; - fileSource.respond(Resource::Style, response); - EXPECT_EQ(1u, fileSource.requests.size()); + test.fileSource.respond(Resource::Style, response); + EXPECT_EQ(1u, test.fileSource.requests.size()); - map.render(test.view); - EXPECT_EQ(1u, fileSource.requests.size()); + test::render(test.map, test.view); + EXPECT_EQ(1u, test.fileSource.requests.size()); - fileSource.respond(Resource::Style, response); - EXPECT_EQ(1u, fileSource.requests.size()); + test.fileSource.respond(Resource::Style, response); + EXPECT_EQ(1u, test.fileSource.requests.size()); } TEST(Map, StyleEarlyMutation) { // An early mutation should not prevent the initial style load. - MapTest test; - FakeFileSource fileSource; + MapTest<FakeFileSource> test; - Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadURL("mapbox://styles/test"); - map.getStyle().addLayer(std::make_unique<style::BackgroundLayer>("bg")); + test.map.getStyle().loadURL("mapbox://styles/test"); + test.map.getStyle().addLayer(std::make_unique<style::BackgroundLayer>("bg")); Response response; response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/water.json")); - fileSource.respond(Resource::Style, response); + test.fileSource.respond(Resource::Style, response); - EXPECT_EQ(0u, fileSource.requests.size()); - EXPECT_NE(nullptr, map.getStyle().getLayer("water")); + EXPECT_EQ(0u, test.fileSource.requests.size()); + EXPECT_NE(nullptr, test.map.getStyle().getLayer("water")); } TEST(Map, MapLoadingSignal) { - MapTest test; - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); + MapTest<> test; bool emitted = false; test.observer.onWillStartLoadingMapCallback = [&]() { emitted = true; }; - map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json")); + test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json")); EXPECT_TRUE(emitted); } TEST(Map, MapLoadedSignal) { - MapTest test; - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Continuous); + MapTest<> test { 1, MapMode::Continuous }; test.observer.onDidFinishLoadingMapCallback = [&]() { test.runLoop.stop(); }; - test.backend.callback = [&]() { - map.render(test.view); - }; - - map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json")); + test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json")); test.runLoop.run(); } TEST(Map, StyleLoadedSignal) { - MapTest test; - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); + MapTest<> test; // The map should emit a signal on style loaded bool emitted = false; test.observer.didFinishLoadingStyleCallback = [&]() { emitted = true; }; - map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json")); + test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json")); EXPECT_TRUE(emitted); // But not when the style couldn't be parsed emitted = false; - map.getStyle().loadJSON("invalid"); + test.map.getStyle().loadJSON("invalid"); EXPECT_FALSE(emitted); } // Test for https://github.com/mapbox/mapbox-gl-native/issues/7902 TEST(Map, TEST_REQUIRES_SERVER(StyleNetworkErrorRetry)) { - MapTest test; - OnlineFileSource fileSource; + MapTest<OnlineFileSource> test; - Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadURL("http://127.0.0.1:3000/style-fail-once-500"); + test.map.getStyle().loadURL("http://127.0.0.1:3000/style-fail-once-500"); test.observer.didFinishLoadingStyleCallback = [&]() { test.runLoop.stop(); @@ -391,11 +371,9 @@ TEST(Map, TEST_REQUIRES_SERVER(StyleNetworkErrorRetry)) { } TEST(Map, TEST_REQUIRES_SERVER(StyleNotFound)) { - MapTest test; - OnlineFileSource fileSource; + MapTest<OnlineFileSource> test; - Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadURL("http://127.0.0.1:3000/style-fail-once-404"); + test.map.getStyle().loadURL("http://127.0.0.1:3000/style-fail-once-404"); using namespace std::chrono_literals; util::Timer timer; @@ -414,52 +392,46 @@ TEST(Map, TEST_REQUIRES_SERVER(StyleNotFound)) { test.runLoop.run(); // Should also not retry if the response has cache headers. - map.getStyle().loadURL("http://127.0.0.1:3000/style-fail-once-404-cache"); + test.map.getStyle().loadURL("http://127.0.0.1:3000/style-fail-once-404-cache"); test.runLoop.run(); } TEST(Map, AddLayer) { - MapTest test; + MapTest<> test; - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json")); + test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json")); auto layer = std::make_unique<BackgroundLayer>("background"); layer->setBackgroundColor({ { 1, 0, 0, 1 } }); - map.getStyle().addLayer(std::move(layer)); + test.map.getStyle().addLayer(std::move(layer)); - test::checkImage("test/fixtures/map/add_layer", test::render(map, test.view)); + test::checkImage("test/fixtures/map/add_layer", test::render(test.map, test.view)); } TEST(Map, WithoutVAOExtension) { - MapTest test; - + MapTest<DefaultFileSource> test { ":memory:", "test/fixtures/api/assets" }; test.backend.getContext().disableVAOExtension = true; - DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets"); + test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json")); - Map map(test.backend, test.observer, test.view.getSize(), 1, fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json")); - - test::checkImage("test/fixtures/map/no_vao", test::render(map, test.view), 0.002); + test::checkImage("test/fixtures/map/no_vao", test::render(test.map, test.view), 0.002); } TEST(Map, RemoveLayer) { - MapTest test; + MapTest<> test; - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json")); + test.map.getStyle().loadJSON(util::read_file("test/fixtures/api/empty.json")); auto layer = std::make_unique<BackgroundLayer>("background"); layer->setBackgroundColor({{ 1, 0, 0, 1 }}); - map.getStyle().addLayer(std::move(layer)); - map.getStyle().removeLayer("background"); + test.map.getStyle().addLayer(std::move(layer)); + test.map.getStyle().removeLayer("background"); - test::checkImage("test/fixtures/map/remove_layer", test::render(map, test.view)); + test::checkImage("test/fixtures/map/remove_layer", test::render(test.map, test.view)); } TEST(Map, DisabledSources) { - MapTest test; + MapTest<> test; // Always load the same image tile for raster layers. test.fileSource.response = [] (const Resource& res) -> optional<Response> { @@ -472,15 +444,14 @@ TEST(Map, DisabledSources) { return {}; }; - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); - map.setZoom(1); + test.map.setZoom(1); // This stylesheet has two raster layers, one that starts at zoom 1, the other at zoom 0. // We first render a map at zoom level 1, which should show both layers (both are "visible" due // to an opacity of 0.5). Then, we are zooming back out to a zoom level of 0.5 and rerender. // The "raster1" layer should not be visible anymore since it has minzoom 1, while "raster2" // should still be there. Both layers have a distinct color through "raster-hue-rotate". - map.getStyle().loadJSON(R"STYLE( + test.map.getStyle().loadJSON(R"STYLE( { "version": 8, "name": "Test", @@ -514,16 +485,15 @@ TEST(Map, DisabledSources) { } )STYLE"); - test::checkImage("test/fixtures/map/disabled_layers/first", test::render(map, test.view)); - map.setZoom(0.5); - test::checkImage("test/fixtures/map/disabled_layers/second", test::render(map, test.view)); + test::checkImage("test/fixtures/map/disabled_layers/first", test::render(test.map, test.view)); + test.map.setZoom(0.5); + test::checkImage("test/fixtures/map/disabled_layers/second", test::render(test.map, test.view)); } TEST(Map, DontLoadUnneededTiles) { - MapTest test; + MapTest<> test; - Map map(test.backend, test.observer, test.view.getSize(), 1, test.fileSource, test.threadPool, MapMode::Still); - map.getStyle().loadJSON(R"STYLE({ + test.map.getStyle().loadJSON(R"STYLE({ "sources": { "a": { "type": "vector", "tiles": [ "a/{z}/{x}/{y}" ] } }, @@ -561,20 +531,20 @@ TEST(Map, DontLoadUnneededTiles) { // Note: using z += 0.1 in the loop doesn't produce accurate floating point numbers. const double z = double(zoom) / 10; tiles.clear(); - map.setZoom(z); - test::render(map, test.view); + test.map.setZoom(z); + test::render(test.map, test.view); EXPECT_EQ(referenceTiles[z], tiles) << "zoom level " << z; } } TEST(Map, TEST_DISABLED_ON_CI(ContinuousRendering)) { util::RunLoop runLoop; - MockBackend backend; - BackendScope scope { backend }; + HeadlessBackend backend { test::sharedDisplay() }; + BackendScope scope(backend); OffscreenView view { backend.getContext() }; ThreadPool threadPool { 4 }; DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets"); - Map map(backend, MapObserver::nullObserver(), view.getSize(), 1, fileSource, threadPool, MapMode::Continuous); + float pixelRatio { 1 }; using namespace std::chrono_literals; @@ -585,24 +555,32 @@ TEST(Map, TEST_DISABLED_ON_CI(ContinuousRendering)) { }); util::Timer timer; - util::AsyncTask render{[&] { - if (map.isFullyLoaded()) { - // Abort the test after 1 second after the map loading fully. Note that a "fully loaded - // map" doesn't mean that we won't render anymore: we could still render fade in/fade - // out or other animations. - // If we are continuing to render indefinitely, the emergency shutoff above will trigger - // and the test will fail since the regular time will be constantly reset. - timer.start(1s, 0s, [&] { - util::RunLoop::Get()->stop(); - }); - } - BackendScope scope2(backend); - map.render(view); - }}; + std::function<bool()> isLoaded; + + StubRendererFrontend rendererFrontend { + std::make_unique<Renderer>(backend, pixelRatio, fileSource, threadPool), + [&](StubRendererFrontend& bridge) { + if (isLoaded()) { + // Abort the test after 1 second after the map loading fully. Note that a "fully loaded + // map" doesn't mean that we won't render anymore: we could still render fade in/fade + // out or other animations. + // If we are continuing to render indefinitely, the emergency shutoff above will trigger + // and the test will fail since the regular time will be constantly reset. + timer.start(1s, 0s, [&] { + util::RunLoop::Get()->stop(); + }); + } + + bridge.render(view); + } + }; + + Map map(rendererFrontend, MapObserver::nullObserver(), view.getSize(), pixelRatio, fileSource, + threadPool, MapMode::Continuous); - backend.callback = [&] { - render.send(); + isLoaded = [&] { + return map.isFullyLoaded(); }; map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json")); diff --git a/test/map/prefetch.test.cpp b/test/map/prefetch.test.cpp index 47b39f7b88..d14f5db492 100644 --- a/test/map/prefetch.test.cpp +++ b/test/map/prefetch.test.cpp @@ -5,12 +5,14 @@ #include <mbgl/gl/offscreen_view.hpp> #include <mbgl/map/backend_scope.hpp> #include <mbgl/map/map.hpp> +#include <mbgl/renderer/renderer.hpp> #include <mbgl/storage/default_file_source.hpp> #include <mbgl/style/style.hpp> #include <mbgl/util/default_thread_pool.hpp> #include <mbgl/util/image.hpp> #include <mbgl/util/io.hpp> #include <mbgl/util/run_loop.hpp> +#include <mbgl/test/stub_renderer_frontend.hpp> #include <algorithm> #include <string> @@ -27,7 +29,9 @@ TEST(Map, PrefetchTiles) { OffscreenView view(backend.getContext(), { 512, 512 }); ThreadPool threadPool(4); StubFileSource fileSource; - Map map(backend, MapObserver::nullObserver(), view.getSize(), 1, fileSource, threadPool, MapMode::Still); + StubRendererFrontend rendererFrontend { + std::make_unique<Renderer>(backend, 1, fileSource, threadPool), view }; + Map map(rendererFrontend, MapObserver::nullObserver(), view.getSize(), 1, fileSource, threadPool, MapMode::Still); std::vector<int> tiles; diff --git a/test/src/mbgl/test/stub_renderer_frontend.cpp b/test/src/mbgl/test/stub_renderer_frontend.cpp new file mode 100644 index 0000000000..7edcfd397e --- /dev/null +++ b/test/src/mbgl/test/stub_renderer_frontend.cpp @@ -0,0 +1,52 @@ +#include <mbgl/test/stub_renderer_frontend.hpp> + +#include <mbgl/map/view.hpp> +#include <mbgl/renderer/renderer.hpp> + +namespace mbgl { + +StubRendererFrontend::StubRendererFrontend(std::unique_ptr<Renderer> renderer_, InvalidateCallback invalidate) + : renderer(std::move(renderer_)) + , asyncInvalidate([this, invalidate=std::move(invalidate)]() { + invalidate(*this); + }) { +} + +StubRendererFrontend::StubRendererFrontend(std::unique_ptr<Renderer> renderer_, View& view) + : renderer(std::move(renderer_)) + , asyncInvalidate([&]() { + this->render(view); + }) { +} + +StubRendererFrontend::~StubRendererFrontend() { + reset(); +} + +void StubRendererFrontend::reset() { + if (renderer) { + renderer.reset(); + } +} + +void StubRendererFrontend::setObserver(RendererObserver& observer) { + if (!renderer) return; + renderer->setObserver(&observer); +} + +void StubRendererFrontend::update(std::shared_ptr<UpdateParameters> params) { + updateParameters = std::move(params); + asyncInvalidate.send(); +} + +void StubRendererFrontend::render(View& view) { + if (!updateParameters || !renderer) return; + renderer->render(view, *updateParameters); +} + +Renderer* StubRendererFrontend::getRenderer() { + return renderer.get(); +} + +} // namespace mbgl + diff --git a/test/src/mbgl/test/stub_renderer_frontend.hpp b/test/src/mbgl/test/stub_renderer_frontend.hpp new file mode 100644 index 0000000000..f6dd1d0472 --- /dev/null +++ b/test/src/mbgl/test/stub_renderer_frontend.hpp @@ -0,0 +1,44 @@ + +#pragma once + +#include <mbgl/renderer/renderer_frontend.hpp> +#include <mbgl/util/async_task.hpp> +#include <mbgl/util/geo.hpp> +#include <mbgl/util/feature.hpp> +#include <mbgl/renderer/query.hpp> + +#include <functional> +#include <memory> + +namespace mbgl { + +class Renderer; +class View; + +class StubRendererFrontend : public RendererFrontend { +public: + // Calls the provided callback when it's time to render + using InvalidateCallback = std::function<void (StubRendererFrontend&)>; + StubRendererFrontend(std::unique_ptr<Renderer>, InvalidateCallback); + + // Will render async + StubRendererFrontend(std::unique_ptr<Renderer>, View&); + + ~StubRendererFrontend() override; + + void reset() override; + + void setObserver(RendererObserver&) override; + + void update(std::shared_ptr<UpdateParameters>) override; + void render(View& view); + + Renderer* getRenderer(); + +private: + std::unique_ptr<Renderer> renderer; + std::shared_ptr<UpdateParameters> updateParameters; + util::AsyncTask asyncInvalidate; +}; + +} // namespace mbgl diff --git a/test/src/mbgl/test/util.cpp b/test/src/mbgl/test/util.cpp index 7ca2d72504..f3b0bbc96f 100644 --- a/test/src/mbgl/test/util.cpp +++ b/test/src/mbgl/test/util.cpp @@ -106,7 +106,7 @@ std::shared_ptr<HeadlessDisplay> sharedDisplay() { PremultipliedImage render(Map& map, OffscreenView& view) { PremultipliedImage result; - map.renderStill(view, [&](std::exception_ptr) { + map.renderStill([&](std::exception_ptr) { result = view.readStillImage(); }); diff --git a/test/tile/annotation_tile.test.cpp b/test/tile/annotation_tile.test.cpp index 739307b78a..bed0bb160e 100644 --- a/test/tile/annotation_tile.test.cpp +++ b/test/tile/annotation_tile.test.cpp @@ -4,10 +4,9 @@ #include <mbgl/util/default_thread_pool.hpp> #include <mbgl/util/run_loop.hpp> #include <mbgl/map/transform.hpp> -#include <mbgl/map/query.hpp> #include <mbgl/renderer/render_style.hpp> #include <mbgl/renderer/tile_parameters.hpp> -#include <mbgl/map/query.hpp> +#include <mbgl/renderer/query.hpp> #include <mbgl/text/collision_tile.hpp> #include <mbgl/geometry/feature_index.hpp> #include <mbgl/annotation/annotation_manager.hpp> diff --git a/test/tile/vector_tile.test.cpp b/test/tile/vector_tile.test.cpp index b0fee28edf..45eab21576 100644 --- a/test/tile/vector_tile.test.cpp +++ b/test/tile/vector_tile.test.cpp @@ -6,11 +6,11 @@ #include <mbgl/util/default_thread_pool.hpp> #include <mbgl/util/run_loop.hpp> #include <mbgl/map/transform.hpp> -#include <mbgl/map/query.hpp> #include <mbgl/style/style.hpp> #include <mbgl/style/layers/symbol_layer.hpp> #include <mbgl/renderer/tile_parameters.hpp> #include <mbgl/renderer/buckets/symbol_bucket.hpp> +#include <mbgl/renderer/query.hpp> #include <mbgl/text/collision_tile.hpp> #include <mbgl/geometry/feature_index.hpp> #include <mbgl/annotation/annotation_manager.hpp> diff --git a/test/util/memory.test.cpp b/test/util/memory.test.cpp index 8fd27f2462..fb93699d7f 100644 --- a/test/util/memory.test.cpp +++ b/test/util/memory.test.cpp @@ -10,6 +10,8 @@ #include <mbgl/util/io.hpp> #include <mbgl/util/run_loop.hpp> #include <mbgl/style/style.hpp> +#include <mbgl/renderer/renderer.hpp> +#include <mbgl/test/stub_renderer_frontend.hpp> #include <algorithm> #include <iostream> @@ -38,7 +40,7 @@ public: util::RunLoop runLoop; HeadlessBackend backend { test::sharedDisplay() }; BackendScope scope { backend }; - OffscreenView view{ backend.getContext(), { 512, 512 } }; + OffscreenView view { backend.getContext(), { 512, 512 } }; StubFileSource fileSource; ThreadPool threadPool { 4 }; @@ -73,8 +75,13 @@ private: TEST(Memory, Vector) { MemoryTest test; + float ratio { 2 }; - Map map(test.backend, MapObserver::nullObserver(), { 256, 256 }, 2, test.fileSource, test.threadPool, MapMode::Still); + StubRendererFrontend rendererFrontend { + std::make_unique<Renderer>(test.backend, ratio, test.fileSource, test.threadPool), + test.view }; + Map map(rendererFrontend, MapObserver::nullObserver(), { 256, 256 }, ratio, test.fileSource, + test.threadPool, MapMode::Still); map.setZoom(16); // more map features map.getStyle().loadURL("mapbox://streets"); @@ -83,8 +90,14 @@ TEST(Memory, Vector) { TEST(Memory, Raster) { MemoryTest test; + float ratio { 2 }; - Map map(test.backend, MapObserver::nullObserver(), { 256, 256 }, 2, test.fileSource, test.threadPool, MapMode::Still); + StubRendererFrontend rendererFrontend { + std::make_unique<Renderer>(test.backend, ratio, test.fileSource, test.threadPool), + test.view }; + + Map map(rendererFrontend, MapObserver::nullObserver(), { 256, 256 }, ratio, test.fileSource, + test.threadPool, MapMode::Still); map.getStyle().loadURL("mapbox://satellite"); test::render(map, test.view); @@ -116,6 +129,7 @@ TEST(Memory, Footprint) { } MemoryTest test; + float ratio { 2 }; auto renderMap = [&](Map& map, const char* style){ map.setZoom(16); @@ -125,7 +139,11 @@ TEST(Memory, Footprint) { // Warm up buffers and cache. for (unsigned i = 0; i < 10; ++i) { - Map map(test.backend, MapObserver::nullObserver(), { 256, 256 }, 2, test.fileSource, test.threadPool, MapMode::Still); + StubRendererFrontend rendererFrontend { + std::make_unique<Renderer>(test.backend, ratio, test.fileSource, test.threadPool), + test.view }; + Map map(rendererFrontend, MapObserver::nullObserver(), { 256, 256 }, ratio, test.fileSource, + test.threadPool, MapMode::Still); renderMap(map, "mapbox://streets"); renderMap(map, "mapbox://satellite"); }; @@ -134,27 +152,31 @@ TEST(Memory, Footprint) { // libuv runloop. test.runLoop.runOnce(); - std::vector<std::unique_ptr<Map>> maps; + std::vector<std::pair<std::unique_ptr<Map>, std::unique_ptr<RendererFrontend>>> maps; unsigned runs = 15; long vectorInitialRSS = mbgl::test::getCurrentRSS(); for (unsigned i = 0; i < runs; ++i) { - auto vector = std::make_unique<Map>(test.backend, MapObserver::nullObserver(), - Size{ 256, 256 }, 2, test.fileSource, test.threadPool, - MapMode::Still); + auto frontend = std::make_unique<StubRendererFrontend>( + std::make_unique<Renderer>(test.backend, ratio, test.fileSource, test.threadPool), test.view); + auto vector = std::make_unique<Map>(*frontend, MapObserver::nullObserver(), + Size{ 256, 256 }, ratio, test.fileSource, + test.threadPool, MapMode::Still); renderMap(*vector, "mapbox://streets"); - maps.push_back(std::move(vector)); + maps.push_back({std::move(vector), std::move(frontend)}); }; double vectorFootprint = (mbgl::test::getCurrentRSS() - vectorInitialRSS) / double(runs); long rasterInitialRSS = mbgl::test::getCurrentRSS(); for (unsigned i = 0; i < runs; ++i) { - auto raster = std::make_unique<Map>(test.backend, MapObserver::nullObserver(), - Size{ 256, 256 }, 2, test.fileSource, test.threadPool, - MapMode::Still); + auto frontend = std::make_unique<StubRendererFrontend>( + std::make_unique<Renderer>(test.backend, ratio, test.fileSource, test.threadPool), test.view); + auto raster = std::make_unique<Map>(*frontend, MapObserver::nullObserver(), + Size{ 256, 256 }, ratio, test.fileSource, + test.threadPool, MapMode::Still); renderMap(*raster, "mapbox://satellite"); - maps.push_back(std::move(raster)); + maps.push_back({std::move(raster), std::move(frontend)}); }; double rasterFootprint = (mbgl::test::getCurrentRSS() - rasterInitialRSS) / double(runs); |