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

[core] renderer interface

Browse Source
This commit is contained in:
Ivo van Dongen
2017-06-13 10:50:16 +03:00
committed by Ivo van Dongen
parent 39a732d7ae
commit 3832f8d0d8
44 changed files with 1016 additions and 541 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
bin/render.cpp
View File

@@ -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);

8
cmake/core-files.cmake
View File

@@ -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

2
cmake/render.cmake
View File

@@ -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
)

2
cmake/test-files.cmake
View File

@@ -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

9
include/mbgl/map/backend.hpp
View File

@@ -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

25
include/mbgl/map/map.hpp
View File

@@ -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();

0
include/mbgl/map/query.hpp → include/mbgl/renderer/query.hpp
View File

54
include/mbgl/renderer/renderer.hpp Normal file
View File

@@ -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

31
include/mbgl/renderer/renderer_frontend.hpp Normal file
View File

@@ -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

2
platform/android/config.cmake
View File

@@ -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

6
platform/default/mbgl/gl/headless_backend.cpp
View File

@@ -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

2
platform/default/mbgl/gl/headless_backend.hpp
View File

@@ -17,8 +17,6 @@ public:
void updateAssumedState() override;
void invalidate() override;
struct Impl {
virtual ~Impl() = default;
virtual void activateContext() = 0;

38
platform/default/mbgl/renderer/async_renderer_frontend.cpp Normal file
View File

@@ -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

35
platform/default/mbgl/renderer/async_renderer_frontend.hpp Normal file
View File

@@ -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

1
platform/node/src/node_map.cpp
View File

@@ -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>

1
src/mbgl/annotation/annotation_manager.cpp
View File

@@ -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));
}

2
src/mbgl/geometry/feature_index.cpp
View File

@@ -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>

355
src/mbgl/map/map.cpp
View File

@@ -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,130 +164,54 @@ void Map::renderStill(View& view, StillImageCallback callback) {
return;
}
impl->stillImageRequest = std::make_unique<StillImageRequest>(view, std::move(callback));
impl->stillImageRequest = std::make_unique<StillImageRequest>(std::move(callback));
impl->onUpdate(Update::Repaint);
}
void Map::Impl::renderStill() {
if (!stillImageRequest) {
return;
}
// TODO: determine whether we need activate/deactivate
BackendScope guard(backend);
render(stillImageRequest->view);
}
void Map::triggerRepaint() {
impl->backend.invalidate();
impl->onUpdate(Update::Repaint);
}
void Map::render(View& view) {
impl->render(view);
#pragma mark - Map::Impl RendererObserver
void Map::Impl::onWillStartRenderingMap() {
if (mode == MapMode::Continuous) {
observer.onWillStartRenderingMap();
}
}
void Map::Impl::render(View& view) {
TimePoint timePoint = mode == MapMode::Continuous
? Clock::now()
: Clock::time_point::max();
transform.updateTransitions(timePoint);
if (updateFlags & Update::AnnotationData) {
annotationManager.updateData();
void Map::Impl::onWillStartRenderingFrame() {
if (mode == MapMode::Continuous) {
observer.onWillStartRenderingFrame();
}
}
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);
}
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.onDidFinishRenderingFrame(MapObserver::RenderMode(renderMode));
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();
}
}
// 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);
auto request = std::move(stillImageRequest);
request->callback(nullptr);
painter->cleanup();
}
}
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);
}
};
#pragma mark - Style
style::Style& Map::getStyle() {
@@ -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, "--------------------------------------------------------------------------------");
}

2
src/mbgl/renderer/painter.cpp
View File

@@ -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())),

6
src/mbgl/renderer/painter.hpp
View File

@@ -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;

2
src/mbgl/renderer/render_style.cpp
View File

@@ -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>

78
src/mbgl/renderer/renderer.cpp Normal file
View File

@@ -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

151
src/mbgl/renderer/renderer_impl.cpp Normal file
View File

@@ -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();
};
}

65
src/mbgl/renderer/renderer_impl.hpp Normal file
View File

@@ -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

35
src/mbgl/renderer/renderer_observer.hpp Normal file
View File

@@ -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

2
src/mbgl/renderer/tile_pyramid.cpp
View File

@@ -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>

21
src/mbgl/renderer/update_parameters.hpp
View File

@@ -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

2
src/mbgl/tile/geojson_tile.cpp
View File

@@ -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>

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

@@ -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>

2
src/mbgl/tile/tile.cpp
View File

@@ -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 {

17
test/api/annotations.test.cpp
View File

@@ -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());

11
test/api/api_misuse.test.cpp
View File

@@ -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();

9
test/api/custom_layer.test.cpp
View File

@@ -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);
}

40
test/api/query.test.cpp
View File

@@ -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);
}

10
test/api/render_missing.test.cpp
View File

@@ -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);

21
test/api/repeated_render.test.cpp
View File

@@ -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();
});

344
test/map/map.test.cpp
View File

@@ -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;
backend.callback = [&] {
render.send();
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);
isLoaded = [&] {
return map.isFullyLoaded();
};
map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json"));

6
test/map/prefetch.test.cpp
View File

@@ -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;

52
test/src/mbgl/test/stub_renderer_frontend.cpp Normal file
View File

@@ -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

44
test/src/mbgl/test/stub_renderer_frontend.hpp Normal file
View File

@@ -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

2
test/src/mbgl/test/util.cpp
View File

@@ -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();
});

3
test/tile/annotation_tile.test.cpp
View File

@@ -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>

2
test/tile/vector_tile.test.cpp
View File

@@ -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>

48
test/util/memory.test.cpp
View File

@@ -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);