diff options
Diffstat (limited to 'platform')
27 files changed, 372 insertions, 181 deletions
diff --git a/platform/android/src/android_renderer_backend.cpp b/platform/android/src/android_renderer_backend.cpp index 52a9a93170..09c9e85ad5 100755 --- a/platform/android/src/android_renderer_backend.cpp +++ b/platform/android/src/android_renderer_backend.cpp @@ -1,6 +1,8 @@ #include "android_renderer_backend.hpp" +#include <mbgl/gfx/backend_scope.hpp> #include <mbgl/gl/context.hpp> +#include <mbgl/gl/renderable_resource.hpp> #include <EGL/egl.h> @@ -9,18 +11,27 @@ namespace mbgl { namespace android { -/** - * From mbgl::View - */ -void AndroidRendererBackend::bind() { - assert(gfx::BackendScope::exists()); - setFramebufferBinding(0); - setViewport(0, 0, getFramebufferSize()); +class AndroidGLRenderableResource final : public mbgl::gl::RenderableResource { +public: + AndroidGLRenderableResource(AndroidRendererBackend& backend_) : backend(backend_) { + } + + void bind() override { + assert(gfx::BackendScope::exists()); + backend.setFramebufferBinding(0); + backend.setViewport(0, 0, backend.getSize()); + } + +private: + AndroidRendererBackend& backend; +}; + +AndroidRendererBackend::AndroidRendererBackend() + : mbgl::gfx::Renderable({ 64, 64 }, std::make_unique<AndroidGLRenderableResource>(*this)) { } -/** - * From mbgl::RendererBackend. - */ +AndroidRendererBackend::~AndroidRendererBackend() = default; + gl::ProcAddress AndroidRendererBackend::getExtensionFunctionPointer(const char* name) { assert(gfx::BackendScope::exists()); return eglGetProcAddress(name); @@ -28,34 +39,26 @@ gl::ProcAddress AndroidRendererBackend::getExtensionFunctionPointer(const char* void AndroidRendererBackend::updateViewPort() { assert(gfx::BackendScope::exists()); - setViewport(0, 0, getFramebufferSize()); + setViewport(0, 0, size); } void AndroidRendererBackend::resizeFramebuffer(int width, int height) { - fbWidth = width; - fbHeight = height; + size = { static_cast<uint32_t>(width), static_cast<uint32_t>(height) }; } -PremultipliedImage AndroidRendererBackend::readFramebuffer() const { +PremultipliedImage AndroidRendererBackend::readFramebuffer() { assert(gfx::BackendScope::exists()); - return RendererBackend::readFramebuffer(getFramebufferSize()); -} - -mbgl::Size AndroidRendererBackend::getFramebufferSize() const { - return { static_cast<uint32_t>(fbWidth), static_cast<uint32_t>(fbHeight) }; + return gl::RendererBackend::readFramebuffer(size); } -/** - * From mbgl::RendererBackend. - */ void AndroidRendererBackend::updateAssumedState() { assumeFramebufferBinding(0); - assumeViewport(0, 0, getFramebufferSize()); + assumeViewport(0, 0, size); } void AndroidRendererBackend::markContextLost() { if (context) { - context->setCleanupOnDestruction(false); + getGLContext().setCleanupOnDestruction(false); } } diff --git a/platform/android/src/android_renderer_backend.hpp b/platform/android/src/android_renderer_backend.hpp index d2c100dcc1..f06f38e688 100755 --- a/platform/android/src/android_renderer_backend.hpp +++ b/platform/android/src/android_renderer_backend.hpp @@ -1,40 +1,42 @@ #pragma once -#include <mbgl/renderer/renderer_backend.hpp> +#include <mbgl/gfx/renderable.hpp> +#include <mbgl/gl/renderer_backend.hpp> namespace mbgl { namespace android { -class AndroidRendererBackend : public RendererBackend { +class AndroidRendererBackend : public gl::RendererBackend, public mbgl::gfx::Renderable { public: + AndroidRendererBackend(); + ~AndroidRendererBackend() override; - // mbgl::RendererBackend // - void bind() override; - void updateAssumedState() override; - mbgl::Size getFramebufferSize() const override; + void updateViewPort(); - // Ensures the current context is not - // cleaned up when destroyed + // Ensures the current context is not cleaned up when destroyed void markContextLost(); - void updateViewPort(); - void resizeFramebuffer(int width, int height); - PremultipliedImage readFramebuffer() const; - -protected: - // mbgl::RendererBackend // - gl::ProcAddress getExtensionFunctionPointer(const char*) override; - void activate() override {}; - void deactivate() override {}; + PremultipliedImage readFramebuffer(); + // mbgl::gfx::RendererBackend implementation +public: + mbgl::gfx::Renderable& getDefaultRenderable() override { + return *this; + } -private: - - // Minimum texture size according to OpenGL ES 2.0 specification. - int fbWidth = 64; - int fbHeight = 64; - +protected: + void activate() override { + // no-op + } + void deactivate() override { + // no-op + } + + // mbgl::gl::RendererBackend implementation +protected: + mbgl::gl::ProcAddress getExtensionFunctionPointer(const char*) override; + void updateAssumedState() override; }; } // namespace android diff --git a/platform/android/src/map_renderer.cpp b/platform/android/src/map_renderer.cpp index f0273cee50..7fefa457b1 100644 --- a/platform/android/src/map_renderer.cpp +++ b/platform/android/src/map_renderer.cpp @@ -1,6 +1,7 @@ #include "map_renderer.hpp" #include <mbgl/renderer/renderer.hpp> +#include <mbgl/gfx/backend_scope.hpp> #include <mbgl/util/shared_thread_pool.hpp> #include <mbgl/util/run_loop.hpp> @@ -159,6 +160,9 @@ void MapRenderer::onSurfaceCreated(JNIEnv&) { // Lock as the initialization can come from the main thread or the GL thread first std::lock_guard<std::mutex> lock(initialisationMutex); + // The GL context is already active if get a new surface. + gfx::BackendScope backendGuard { *backend, gfx::BackendScope::ScopeType::Implicit }; + // The android system will have already destroyed the underlying // GL resources if this is not the first initialization and an // attempt to clean them up will fail diff --git a/platform/darwin/src/MGLRendererFrontend.h b/platform/darwin/src/MGLRendererFrontend.h index 5e6a051bbb..ead6ad2660 100644 --- a/platform/darwin/src/MGLRendererFrontend.h +++ b/platform/darwin/src/MGLRendererFrontend.h @@ -1,7 +1,7 @@ #include <mbgl/gfx/backend_scope.hpp> #include <mbgl/renderer/renderer.hpp> -#include <mbgl/renderer/renderer_backend.hpp> #include <mbgl/renderer/renderer_frontend.hpp> +#include <mbgl/gl/renderer_backend.hpp> #include <mbgl/util/async_task.hpp> #include <mbgl/util/optional.hpp> @@ -13,7 +13,7 @@ class MGLRenderFrontend : public mbgl::RendererFrontend { public: - MGLRenderFrontend(std::unique_ptr<mbgl::Renderer> renderer_, MGLMapView* nativeView_, mbgl::RendererBackend& mbglBackend_, bool async = false) + MGLRenderFrontend(std::unique_ptr<mbgl::Renderer> renderer_, MGLMapView* nativeView_, mbgl::gl::RendererBackend& mbglBackend_, bool async = false) : renderer(std::move(renderer_)) , nativeView(nativeView_) , mbglBackend(mbglBackend_) { @@ -69,7 +69,7 @@ public: private: std::unique_ptr<mbgl::Renderer> renderer; __weak MGLMapView *nativeView = nullptr; - mbgl::RendererBackend& mbglBackend; + mbgl::gl::RendererBackend& mbglBackend; std::shared_ptr<mbgl::UpdateParameters> updateParameters; mbgl::optional<mbgl::util::AsyncTask> asyncInvalidate; }; diff --git a/platform/darwin/src/headless_backend_cgl.cpp b/platform/darwin/src/headless_backend_cgl.cpp index 46a5beb870..a21bcad9d0 100644 --- a/platform/darwin/src/headless_backend_cgl.cpp +++ b/platform/darwin/src/headless_backend_cgl.cpp @@ -8,6 +8,7 @@ #include <stdexcept> namespace mbgl { +namespace gl { // This class provides a singleton that contains information about the pixel format used for // instantiating new headless rendering contexts. @@ -125,4 +126,5 @@ void HeadlessBackend::createImpl() { impl = std::make_unique<CGLBackendImpl>(); } +} // namespace gl } // namespace mbgl diff --git a/platform/darwin/src/headless_backend_eagl.mm b/platform/darwin/src/headless_backend_eagl.mm index 050fa62c78..4ccc485313 100644 --- a/platform/darwin/src/headless_backend_eagl.mm +++ b/platform/darwin/src/headless_backend_eagl.mm @@ -5,6 +5,7 @@ #include <stdexcept> namespace mbgl { +namespace gl { class EAGLBackendImpl : public HeadlessBackend::Impl { public: @@ -50,4 +51,5 @@ void HeadlessBackend::createImpl() { impl = std::make_unique<EAGLBackendImpl>(); } +} // namespace gl } // namespace mbgl diff --git a/platform/default/include/mbgl/gl/headless_backend.hpp b/platform/default/include/mbgl/gl/headless_backend.hpp index 7757037533..9135c269be 100644 --- a/platform/default/include/mbgl/gl/headless_backend.hpp +++ b/platform/default/include/mbgl/gl/headless_backend.hpp @@ -1,19 +1,22 @@ #pragma once -#include <mbgl/renderer/renderer_backend.hpp> +#include <mbgl/gfx/renderable.hpp> +#include <mbgl/gl/renderer_backend.hpp> #include <memory> #include <functional> namespace mbgl { +namespace gl { -class HeadlessBackend : public RendererBackend { +class HeadlessBackend final : public gl::RendererBackend, public gfx::Renderable { public: HeadlessBackend(Size = { 256, 256 }); ~HeadlessBackend() override; - void bind() override; - Size getFramebufferSize() const override; + gfx::Renderable& getDefaultRenderable() override; + + Size getFramebufferSize() const; void updateAssumedState() override; void setSize(Size); @@ -39,12 +42,9 @@ private: private: std::unique_ptr<Impl> impl; - Size size; float pixelRatio; bool active = false; - - class View; - std::unique_ptr<View> view; }; +} // namespace gl } // namespace mbgl diff --git a/platform/default/include/mbgl/gl/headless_frontend.hpp b/platform/default/include/mbgl/gl/headless_frontend.hpp index ca3230a809..2e9378bf8f 100644 --- a/platform/default/include/mbgl/gl/headless_frontend.hpp +++ b/platform/default/include/mbgl/gl/headless_frontend.hpp @@ -13,10 +13,13 @@ namespace mbgl { class Scheduler; class Renderer; -class RendererBackend; class Map; class TransformState; +namespace gfx { +class RendererBackend; +} // namespace gfx + class HeadlessFrontend : public RendererFrontend { public: HeadlessFrontend(float pixelRatio_, Scheduler&, const optional<std::string> programCacheDir = {}, GLContextMode mode = GLContextMode::Unique, const optional<std::string> localFontFamily = {}); @@ -31,7 +34,7 @@ public: void setSize(Size); Renderer* getRenderer(); - RendererBackend* getBackend(); + gfx::RendererBackend* getBackend(); CameraOptions getCameraOptions(); bool hasImage(const std::string&); @@ -50,7 +53,7 @@ private: Size size; float pixelRatio; - HeadlessBackend backend; + gl::HeadlessBackend backend; util::AsyncTask asyncInvalidate; std::unique_ptr<Renderer> renderer; diff --git a/platform/default/src/mbgl/gl/headless_backend.cpp b/platform/default/src/mbgl/gl/headless_backend.cpp index 4d05be1675..cbf451d80b 100644 --- a/platform/default/src/mbgl/gl/headless_backend.cpp +++ b/platform/default/src/mbgl/gl/headless_backend.cpp @@ -1,4 +1,5 @@ #include <mbgl/gl/headless_backend.hpp> +#include <mbgl/gl/renderable_resource.hpp> #include <mbgl/gl/context.hpp> #include <mbgl/gfx/backend_scope.hpp> @@ -7,27 +8,38 @@ #include <type_traits> namespace mbgl { +namespace gl { -class HeadlessBackend::View { +class HeadlessRenderableResource final : public gl::RenderableResource { public: - View(gl::Context& context, Size size_) - : color(context.createRenderbuffer<gfx::RenderbufferPixelType::RGBA>(size_)), + HeadlessRenderableResource(gl::Context& context_, Size size_) + : context(context_), + color(context.createRenderbuffer<gfx::RenderbufferPixelType::RGBA>(size_)), depthStencil(context.createRenderbuffer<gfx::RenderbufferPixelType::DepthStencil>(size_)), framebuffer(context.createFramebuffer(color, depthStencil)) { } + void bind() override { + context.bindFramebuffer = framebuffer.framebuffer; + context.scissorTest = false; + context.viewport = { 0, 0, framebuffer.size }; + } + + gl::Context& context; gfx::Renderbuffer<gfx::RenderbufferPixelType::RGBA> color; gfx::Renderbuffer<gfx::RenderbufferPixelType::DepthStencil> depthStencil; gl::Framebuffer framebuffer; }; HeadlessBackend::HeadlessBackend(Size size_) - : size(size_) { + : mbgl::gfx::Renderable(size_, nullptr) { } HeadlessBackend::~HeadlessBackend() { gfx::BackendScope guard { *this }; - view.reset(); + resource.reset(); + // Explicitly reset the context so that it is destructed and cleaned up before we destruct + // the impl object. context.reset(); } @@ -53,16 +65,11 @@ void HeadlessBackend::deactivate() { active = false; } -void HeadlessBackend::bind() { - gl::Context& context_ = getContext(); - - if (!view) { - view = std::make_unique<View>(context_, size); +gfx::Renderable& HeadlessBackend::getDefaultRenderable() { + if (!resource) { + resource = std::make_unique<HeadlessRenderableResource>(static_cast<gl::Context&>(getContext()), size); } - - context_.bindFramebuffer = view->framebuffer.framebuffer; - context_.scissorTest = false; - context_.viewport = { 0, 0, size }; + return *this; } Size HeadlessBackend::getFramebufferSize() const { @@ -75,11 +82,12 @@ void HeadlessBackend::updateAssumedState() { void HeadlessBackend::setSize(Size size_) { size = size_; - view.reset(); + resource.reset(); } PremultipliedImage HeadlessBackend::readStillImage() { - return getContext().readFramebuffer<PremultipliedImage>(size); + return static_cast<gl::Context&>(getContext()).readFramebuffer<PremultipliedImage>(size); } +} // namespace gl } // namespace mbgl diff --git a/platform/default/src/mbgl/gl/headless_frontend.cpp b/platform/default/src/mbgl/gl/headless_frontend.cpp index 3c8188c8a3..406c197904 100644 --- a/platform/default/src/mbgl/gl/headless_frontend.cpp +++ b/platform/default/src/mbgl/gl/headless_frontend.cpp @@ -1,4 +1,5 @@ #include <mbgl/gl/headless_frontend.hpp> +#include <mbgl/gfx/backend_scope.hpp> #include <mbgl/renderer/renderer.hpp> #include <mbgl/renderer/renderer_state.hpp> #include <mbgl/renderer/update_parameters.hpp> @@ -58,7 +59,7 @@ Renderer* HeadlessFrontend::getRenderer() { return renderer.get(); } -RendererBackend* HeadlessFrontend::getBackend() { +gfx::RendererBackend* HeadlessFrontend::getBackend() { return &backend; } diff --git a/platform/glfw/glfw_backend.hpp b/platform/glfw/glfw_backend.hpp new file mode 100644 index 0000000000..1a2c89ac7a --- /dev/null +++ b/platform/glfw/glfw_backend.hpp @@ -0,0 +1,21 @@ +#pragma once + +#include <mbgl/util/size.hpp> + +namespace mbgl { +namespace gfx { +class RendererBackend; +} // namespace gfx +} // namespace mbgl + +class GLFWBackend { +public: + explicit GLFWBackend() = default; + GLFWBackend(const GLFWBackend&) = delete; + GLFWBackend& operator=(const GLFWBackend&) = delete; + virtual ~GLFWBackend() = default; + + virtual mbgl::gfx::RendererBackend& getRendererBackend() = 0; + virtual mbgl::Size getSize() const = 0; + virtual void setSize(mbgl::Size) = 0; +}; diff --git a/platform/glfw/glfw_gl_backend.cpp b/platform/glfw/glfw_gl_backend.cpp new file mode 100644 index 0000000000..b61e2775d5 --- /dev/null +++ b/platform/glfw/glfw_gl_backend.cpp @@ -0,0 +1,58 @@ +#include "glfw_gl_backend.hpp" + +#include <mbgl/gfx/backend_scope.hpp> +#include <mbgl/gl/renderable_resource.hpp> + +#include <GLFW/glfw3.h> + +class GLFWGLRenderableResource final : public mbgl::gl::RenderableResource { +public: + GLFWGLRenderableResource(GLFWGLBackend& backend_) : backend(backend_) { + } + + void bind() override { + backend.setFramebufferBinding(0); + backend.setViewport(0, 0, backend.getSize()); + } + +private: + GLFWGLBackend& backend; +}; + +GLFWGLBackend::GLFWGLBackend(GLFWwindow* window_) + : mbgl::gfx::Renderable( + [window_] { + int fbWidth, fbHeight; + glfwGetFramebufferSize(window_, &fbWidth, &fbHeight); + return mbgl::Size{ static_cast<uint32_t>(fbWidth), static_cast<uint32_t>(fbHeight) }; + }(), + std::make_unique<GLFWGLRenderableResource>(*this)), + window(window_) { +} + +GLFWGLBackend::~GLFWGLBackend() = default; + +void GLFWGLBackend::activate() { + glfwMakeContextCurrent(window); +} + +void GLFWGLBackend::deactivate() { + glfwMakeContextCurrent(nullptr); +} + +mbgl::gl::ProcAddress GLFWGLBackend::getExtensionFunctionPointer(const char* name) { + return glfwGetProcAddress(name); +} + +void GLFWGLBackend::updateAssumedState() { + assumeFramebufferBinding(0); + assumeViewport(0, 0, size); +} + +mbgl::Size GLFWGLBackend::getSize() const { + return size; +} + +void GLFWGLBackend::setSize(const mbgl::Size newSize) { + size = newSize; +} diff --git a/platform/glfw/glfw_gl_backend.hpp b/platform/glfw/glfw_gl_backend.hpp new file mode 100644 index 0000000000..ba4f6fa788 --- /dev/null +++ b/platform/glfw/glfw_gl_backend.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include "glfw_backend.hpp" + +#include <mbgl/gfx/renderable.hpp> +#include <mbgl/gl/renderer_backend.hpp> + +struct GLFWwindow; + +class GLFWGLBackend final : public GLFWBackend, + public mbgl::gl::RendererBackend, + public mbgl::gfx::Renderable { +public: + GLFWGLBackend(GLFWwindow*); + ~GLFWGLBackend() override; + + // GLFWRendererBackend implementation +public: + mbgl::gfx::RendererBackend& getRendererBackend() override { + return *this; + } + mbgl::Size getSize() const override; + void setSize(mbgl::Size) override; + + // mbgl::gfx::RendererBackend implementation +public: + mbgl::gfx::Renderable& getDefaultRenderable() override { + return *this; + } + +protected: + void activate() override; + void deactivate() override; + + // mbgl::gl::RendererBackend implementation +protected: + mbgl::gl::ProcAddress getExtensionFunctionPointer(const char*) override; + void updateAssumedState() override; + +private: + GLFWwindow* window; +}; diff --git a/platform/glfw/glfw_renderer_frontend.cpp b/platform/glfw/glfw_renderer_frontend.cpp index 82efbcdfb1..b8478a49f8 100644 --- a/platform/glfw/glfw_renderer_frontend.cpp +++ b/platform/glfw/glfw_renderer_frontend.cpp @@ -31,7 +31,7 @@ void GLFWRendererFrontend::render() { if (!updateParameters) return; - mbgl::gfx::BackendScope guard { glfwView, mbgl::gfx::BackendScope::ScopeType::Implicit }; + mbgl::gfx::BackendScope guard { glfwView.getRendererBackend(), mbgl::gfx::BackendScope::ScopeType::Implicit }; // onStyleImageMissing might be called during a render. The user implemented method // could trigger a call to MGLRenderFrontend#update which overwrites `updateParameters`. diff --git a/platform/glfw/glfw_view.cpp b/platform/glfw/glfw_view.cpp index 483ca14559..2772ed0773 100644 --- a/platform/glfw/glfw_view.cpp +++ b/platform/glfw/glfw_view.cpp @@ -1,4 +1,5 @@ #include "glfw_view.hpp" +#include "glfw_gl_backend.hpp" #include "glfw_renderer_frontend.hpp" #include "ny_route.hpp" @@ -105,8 +106,10 @@ GLFWView::GLFWView(bool fullscreen_, bool benchmark_) glfwSetKeyCallback(window, onKey); glfwGetWindowSize(window, &width, &height); - glfwGetFramebufferSize(window, &fbWidth, &fbHeight); - pixelRatio = static_cast<float>(fbWidth) / width; + + backend = std::make_unique<GLFWGLBackend>(window); + + pixelRatio = static_cast<float>(backend->getSize().width) / width; glfwMakeContextCurrent(nullptr); @@ -158,14 +161,8 @@ void GLFWView::setRenderFrontend(GLFWRendererFrontend* rendererFrontend_) { rendererFrontend = rendererFrontend_; } -void GLFWView::updateAssumedState() { - assumeFramebufferBinding(0); - assumeViewport(0, 0, getFramebufferSize()); -} - -void GLFWView::bind() { - setFramebufferBinding(0); - setViewport(0, 0, getFramebufferSize()); +mbgl::gfx::RendererBackend& GLFWView::getRendererBackend() { + return backend->getRendererBackend(); } void GLFWView::onKey(GLFWwindow *window, int key, int /*scancode*/, int action, int mods) { @@ -499,11 +496,7 @@ void GLFWView::onWindowResize(GLFWwindow *window, int width, int height) { void GLFWView::onFramebufferResize(GLFWwindow *window, int width, int height) { auto *view = reinterpret_cast<GLFWView *>(glfwGetWindowUserPointer(window)); - view->fbWidth = width; - view->fbHeight = height; - - mbgl::gfx::BackendScope scope { *view, mbgl::gfx::BackendScope::ScopeType::Implicit }; - view->bind(); + view->backend->setSize({ static_cast<uint32_t>(width), static_cast<uint32_t>(height) }); // This is only triggered when the framebuffer is resized, but not the window. It can // happen when you move the window between screens with a different pixel ratio. @@ -578,7 +571,7 @@ void GLFWView::run() { updateAnimatedAnnotations(); - activate(); + mbgl::gfx::BackendScope scope { backend->getRendererBackend() }; rendererFrontend->render(); @@ -608,22 +601,6 @@ mbgl::Size GLFWView::getSize() const { return { static_cast<uint32_t>(width), static_cast<uint32_t>(height) }; } -mbgl::Size GLFWView::getFramebufferSize() const { - return { static_cast<uint32_t>(fbWidth), static_cast<uint32_t>(fbHeight) }; -} - -mbgl::gl::ProcAddress GLFWView::getExtensionFunctionPointer(const char* name) { - return glfwGetProcAddress(name); -} - -void GLFWView::activate() { - glfwMakeContextCurrent(window); -} - -void GLFWView::deactivate() { - glfwMakeContextCurrent(nullptr); -} - void GLFWView::invalidate() { dirty = true; glfwPostEmptyEvent(); diff --git a/platform/glfw/glfw_view.hpp b/platform/glfw/glfw_view.hpp index d5acf697f7..9b580f80cc 100644 --- a/platform/glfw/glfw_view.hpp +++ b/platform/glfw/glfw_view.hpp @@ -1,15 +1,21 @@ #pragma once #include <mbgl/map/map.hpp> -#include <mbgl/renderer/renderer_backend.hpp> #include <mbgl/util/run_loop.hpp> #include <mbgl/util/timer.hpp> #include <mbgl/util/geometry.hpp> struct GLFWwindow; +class GLFWBackend; class GLFWRendererFrontend; -class GLFWView : public mbgl::RendererBackend, public mbgl::MapObserver { +namespace mbgl { +namespace gfx { +class RendererBackend; +} // namespace gfx +} // namespace mbgl + +class GLFWView : public mbgl::MapObserver { public: GLFWView(bool fullscreen = false, bool benchmark = false); ~GLFWView() override; @@ -20,6 +26,8 @@ public: void setRenderFrontend(GLFWRendererFrontend*); + mbgl::gfx::RendererBackend& getRendererBackend(); + // Callback called when the user presses the key mapped to style change. // The expected action is to set a new style, different to the current one. void setChangeStyleCallback(std::function<void()> callback); @@ -41,20 +49,12 @@ public: void invalidate(); mbgl::Size getSize() const; - mbgl::Size getFramebufferSize() const override; - - // mbgl::RendererBackend implementation - void bind() override; - void updateAssumedState() override; // mbgl::MapObserver implementation void onDidFinishLoadingStyle() override; protected: // mbgl::Backend implementation - mbgl::gl::ProcAddress getExtensionFunctionPointer(const char*) override; - void activate() override; - void deactivate() override; private: // Window callbacks @@ -95,6 +95,7 @@ private: mbgl::Map* map = nullptr; GLFWRendererFrontend* rendererFrontend = nullptr; + std::unique_ptr<GLFWBackend> backend; bool fullscreen = false; const bool benchmark = false; @@ -110,8 +111,6 @@ private: int width = 1024; int height = 768; - int fbWidth; - int fbHeight; float pixelRatio; double lastX = 0, lastY = 0; diff --git a/platform/glfw/main.cpp b/platform/glfw/main.cpp index fb7c2b4ffb..0a4ace6a19 100644 --- a/platform/glfw/main.cpp +++ b/platform/glfw/main.cpp @@ -109,9 +109,9 @@ int main(int argc, char *argv[]) { } mbgl::ThreadPool threadPool(4); - GLFWRendererFrontend rendererFrontend { std::make_unique<mbgl::Renderer>(backend, view->getPixelRatio(), threadPool), backend }; + GLFWRendererFrontend rendererFrontend { std::make_unique<mbgl::Renderer>(view->getRendererBackend(), view->getPixelRatio(), threadPool), *view }; - mbgl::Map map(rendererFrontend, backend, threadPool, + mbgl::Map map(rendererFrontend, *view, threadPool, mbgl::MapOptions().withSize(view->getSize()).withPixelRatio(view->getPixelRatio()), resourceOptions); backend.setMap(&map); diff --git a/platform/ios/src/MGLMapView.mm b/platform/ios/src/MGLMapView.mm index f78b2d150c..4cbe839179 100644 --- a/platform/ios/src/MGLMapView.mm +++ b/platform/ios/src/MGLMapView.mm @@ -19,7 +19,8 @@ #include <mbgl/style/layers/custom_layer.hpp> #include <mbgl/renderer/mode.hpp> #include <mbgl/renderer/renderer.hpp> -#include <mbgl/renderer/renderer_backend.hpp> +#import <mbgl/gl/renderer_backend.hpp> +#import <mbgl/gl/renderable_resource.hpp> #include <mbgl/math/wrap.hpp> #include <mbgl/util/exception.hpp> #include <mbgl/util/geo.hpp> @@ -6719,10 +6720,26 @@ public: return _annotationViewReuseQueueByIdentifier[identifier]; } -class MBGLView : public mbgl::RendererBackend, public mbgl::MapObserver -{ +class MBGLView; + +class MBGLMapViewRenderable final : public mbgl::gl::RenderableResource { +public: + MBGLMapViewRenderable(MBGLView& backend_) : backend(backend_) { + } + + void bind() override; + +private: + MBGLView& backend; +}; + +class MBGLView : public mbgl::gl::RendererBackend, + public mbgl::gfx::Renderable, + public mbgl::MapObserver { public: - MBGLView(MGLMapView* nativeView_) : nativeView(nativeView_) { + MBGLView(MGLMapView* nativeView_) : mbgl::gfx::Renderable( + nativeView_.framebufferSize, + std::make_unique<MBGLMapViewRenderable>(*this)), nativeView(nativeView_) { } /// This function is called before we start rendering, when iOS invokes our rendering method. @@ -6733,7 +6750,7 @@ public: assumeViewport(0, 0, nativeView.framebufferSize); } - void bind() override { + void restoreFramebufferBinding() { if (!implicitFramebufferBound()) { // Something modified our state, and we need to bind the original drawable again. // Doing this also sets the viewport to the full framebuffer. @@ -6747,10 +6764,6 @@ public: } } - mbgl::Size getFramebufferSize() const override { - return nativeView.framebufferSize; - } - void onCameraWillChange(mbgl::MapObserver::CameraChangeMode mode) override { bool animated = mode == mbgl::MapObserver::CameraChangeMode::Animated; [nativeView cameraWillChangeAnimated:animated]; @@ -6855,6 +6868,10 @@ public: return reinterpret_cast<mbgl::gl::ProcAddress>(symbol); } + mbgl::gfx::Renderable& getDefaultRenderable() override { + return *this; + } + void activate() override { if (activationCount++) @@ -6876,11 +6893,15 @@ public: } private: - __weak MGLMapView *nativeView = nullptr; + __weak MGLMapView* nativeView = nullptr; NSUInteger activationCount = 0; }; +void MBGLMapViewRenderable::bind() { + backend.restoreFramebufferBinding(); +} + @end #pragma mark - IBAdditions methods diff --git a/platform/linux/src/headless_backend_egl.cpp b/platform/linux/src/headless_backend_egl.cpp index d72fbbfdea..21db012510 100644 --- a/platform/linux/src/headless_backend_egl.cpp +++ b/platform/linux/src/headless_backend_egl.cpp @@ -8,6 +8,7 @@ #include <cassert> namespace mbgl { +namespace gl { // This class provides a singleton that contains information about the configuration used for // instantiating new headless rendering contexts. @@ -142,4 +143,5 @@ void HeadlessBackend::createImpl() { impl = std::make_unique<EGLBackendImpl>(); } +} // namespace gl } // namespace mbgl diff --git a/platform/linux/src/headless_backend_glx.cpp b/platform/linux/src/headless_backend_glx.cpp index 27af98e70a..4045d6635e 100644 --- a/platform/linux/src/headless_backend_glx.cpp +++ b/platform/linux/src/headless_backend_glx.cpp @@ -7,6 +7,7 @@ #include <GL/glx.h> namespace mbgl { +namespace gl { // This class provides a singleton that contains information about the configuration used for // instantiating new headless rendering contexts. @@ -127,4 +128,5 @@ void HeadlessBackend::createImpl() { impl = std::make_unique<GLXBackendImpl>(); } +} // namespace gl } // namespace mbgl diff --git a/platform/macos/src/MGLMapView.mm b/platform/macos/src/MGLMapView.mm index cb0cd7fa00..589d866782 100644 --- a/platform/macos/src/MGLMapView.mm +++ b/platform/macos/src/MGLMapView.mm @@ -34,7 +34,8 @@ #import <mbgl/util/default_thread_pool.hpp> #import <mbgl/style/image.hpp> #import <mbgl/renderer/renderer.hpp> -#import <mbgl/renderer/renderer_backend.hpp> +#import <mbgl/gl/renderer_backend.hpp> +#import <mbgl/gl/renderable_resource.hpp> #import <mbgl/storage/network_status.hpp> #import <mbgl/storage/resource_options.hpp> #import <mbgl/math/wrap.hpp> @@ -3041,10 +3042,27 @@ public: _mbglMap->setDebug(options); } +class MGLMapViewImpl; + +class MGLMapViewRenderable final : public mbgl::gl::RenderableResource { +public: + MGLMapViewRenderable(MGLMapViewImpl& backend_) : backend(backend_) { + } + + void bind() override; + +private: + MGLMapViewImpl& backend; +}; + /// Adapter responsible for bridging calls from mbgl to MGLMapView and Cocoa. -class MGLMapViewImpl : public mbgl::RendererBackend, public mbgl::MapObserver { +class MGLMapViewImpl : public mbgl::gl::RendererBackend, + public mbgl::gfx::Renderable, + public mbgl::MapObserver { public: - MGLMapViewImpl(MGLMapView *nativeView_) : nativeView(nativeView_) {} + MGLMapViewImpl(MGLMapView *nativeView_) : mbgl::gfx::Renderable( + nativeView_.framebufferSize, + std::make_unique<MGLMapViewRenderable>(*this)), nativeView(nativeView_) {} void onCameraWillChange(mbgl::MapObserver::CameraChangeMode mode) override { bool animated = mode == mbgl::MapObserver::CameraChangeMode::Animated; @@ -3141,6 +3159,10 @@ public: return reinterpret_cast<mbgl::gl::ProcAddress>(symbol); } + mbgl::gfx::Renderable& getDefaultRenderable() override { + return *this; + } + void activate() override { if (activationCount++) { return; @@ -3164,15 +3186,11 @@ public: assumeViewport(0, 0, nativeView.framebufferSize); } - void bind() override { + void restoreFramebufferBinding() { setFramebufferBinding(fbo); setViewport(0, 0, nativeView.framebufferSize); } - mbgl::Size getFramebufferSize() const override { - return nativeView.framebufferSize; - } - mbgl::PremultipliedImage readStillImage() { return readFramebuffer(nativeView.framebufferSize); } @@ -3188,4 +3206,8 @@ private: NSUInteger activationCount = 0; }; +void MGLMapViewRenderable::bind() { + backend.restoreFramebufferBinding(); +} + @end diff --git a/platform/qt/src/headless_backend_qt.cpp b/platform/qt/src/headless_backend_qt.cpp index 3702fdf14a..1d62afabff 100644 --- a/platform/qt/src/headless_backend_qt.cpp +++ b/platform/qt/src/headless_backend_qt.cpp @@ -6,21 +6,22 @@ #include <cassert> namespace mbgl { +namespace gl { -class QtBackendImpl : public HeadlessBackend::Impl { +class QtBackendImpl final : public HeadlessBackend::Impl { public: - ~QtBackendImpl() final = default; + ~QtBackendImpl() = default; - gl::ProcAddress getExtensionFunctionPointer(const char* name) final { + gl::ProcAddress getExtensionFunctionPointer(const char* name) { QOpenGLContext* thisContext = QOpenGLContext::currentContext(); return thisContext->getProcAddress(name); } - void activateContext() final { + void activateContext() { widget.makeCurrent(); } - void deactivateContext() final { + void deactivateContext() { widget.doneCurrent(); } @@ -33,4 +34,5 @@ void HeadlessBackend::createImpl() { impl = std::make_unique<QtBackendImpl>(); } +} // namespace gl } // namespace mbgl diff --git a/platform/qt/src/qmapboxgl_map_renderer.cpp b/platform/qt/src/qmapboxgl_map_renderer.cpp index 6b4103eabf..d10df50149 100644 --- a/platform/qt/src/qmapboxgl_map_renderer.cpp +++ b/platform/qt/src/qmapboxgl_map_renderer.cpp @@ -1,6 +1,8 @@ #include "qmapboxgl_map_renderer.hpp" #include "qmapboxgl_scheduler.hpp" +#include <mbgl/gfx/backend_scope.hpp> + #include <QThreadStorage> #include <QtGlobal> diff --git a/platform/qt/src/qmapboxgl_map_renderer.hpp b/platform/qt/src/qmapboxgl_map_renderer.hpp index d771a416da..7db0da99fa 100644 --- a/platform/qt/src/qmapboxgl_map_renderer.hpp +++ b/platform/qt/src/qmapboxgl_map_renderer.hpp @@ -4,7 +4,6 @@ #include "qmapboxgl_renderer_backend.hpp" #include <mbgl/renderer/renderer.hpp> -#include <mbgl/renderer/renderer_backend.hpp> #include <mbgl/renderer/renderer_observer.hpp> #include <mbgl/util/shared_thread_pool.hpp> #include <mbgl/util/util.hpp> diff --git a/platform/qt/src/qmapboxgl_renderer_backend.cpp b/platform/qt/src/qmapboxgl_renderer_backend.cpp index ac12981279..2a9706eb48 100644 --- a/platform/qt/src/qmapboxgl_renderer_backend.cpp +++ b/platform/qt/src/qmapboxgl_renderer_backend.cpp @@ -1,39 +1,51 @@ #include "qmapboxgl_renderer_backend.hpp" +#include <mbgl/gfx/backend_scope.hpp> +#include <mbgl/gl/renderable_resource.hpp> + #include <QOpenGLContext> #include <QtGlobal> -void QMapboxGLRendererBackend::updateAssumedState() -{ - assumeFramebufferBinding(ImplicitFramebufferBinding); - assumeViewport(0, 0, m_size); +class QMapboxGLRenderableResource final : public mbgl::gl::RenderableResource { +public: + QMapboxGLRenderableResource(QMapboxGLRendererBackend& backend_) : backend(backend_) { + } + + void bind() override { + assert(mbgl::gfx::BackendScope::exists()); + backend.restoreFramebufferBinding(); + backend.setViewport(0, 0, backend.getSize()); + } + +private: + QMapboxGLRendererBackend& backend; +}; + +QMapboxGLRendererBackend::QMapboxGLRendererBackend() + : mbgl::gfx::Renderable({ 0, 0 }, std::make_unique<QMapboxGLRenderableResource>(*this)) { } -void QMapboxGLRendererBackend::bind() -{ - assert(mbgl::gfx::BackendScope::exists()); +QMapboxGLRendererBackend::~QMapboxGLRendererBackend() = default; - setFramebufferBinding(m_fbo); - setViewport(0, 0, m_size); +void QMapboxGLRendererBackend::updateAssumedState() { + assumeFramebufferBinding(ImplicitFramebufferBinding); + assumeViewport(0, 0, size); } -mbgl::Size QMapboxGLRendererBackend::getFramebufferSize() const -{ - return m_size; +void QMapboxGLRendererBackend::restoreFramebufferBinding() { + setFramebufferBinding(m_fbo); } -void QMapboxGLRendererBackend::updateFramebuffer(quint32 fbo, const mbgl::Size &size) -{ +void QMapboxGLRendererBackend::updateFramebuffer(quint32 fbo, const mbgl::Size& newSize) { m_fbo = fbo; - m_size = size; + size = newSize; } /*! Initializes an OpenGL extension function such as Vertex Array Objects (VAOs), required by Mapbox GL Native engine. */ -mbgl::gl::ProcAddress QMapboxGLRendererBackend::getExtensionFunctionPointer(const char* name) -{ +mbgl::gl::ProcAddress QMapboxGLRendererBackend::getExtensionFunctionPointer(const char* name) { QOpenGLContext* thisContext = QOpenGLContext::currentContext(); return thisContext->getProcAddress(name); } diff --git a/platform/qt/src/qmapboxgl_renderer_backend.hpp b/platform/qt/src/qmapboxgl_renderer_backend.hpp index 476b3502c1..8d015f500d 100644 --- a/platform/qt/src/qmapboxgl_renderer_backend.hpp +++ b/platform/qt/src/qmapboxgl_renderer_backend.hpp @@ -2,32 +2,37 @@ #include "qmapboxgl.hpp" -#include <mbgl/renderer/renderer_backend.hpp> +#include <mbgl/gfx/renderable.hpp> +#include <mbgl/gl/renderer_backend.hpp> #include <mbgl/util/shared_thread_pool.hpp> -class QMapboxGLRendererBackend : public mbgl::RendererBackend -{ +class QMapboxGLRendererBackend final : public mbgl::gl::RendererBackend, + public mbgl::gfx::Renderable { public: - QMapboxGLRendererBackend() = default; - virtual ~QMapboxGLRendererBackend() = default; + QMapboxGLRendererBackend(); + ~QMapboxGLRendererBackend() override; - // mbgl::RendererBackend implementation - void updateAssumedState() final; - void bind() final; - mbgl::Size getFramebufferSize() const final; + void updateFramebuffer(quint32 fbo, const mbgl::Size&); + void restoreFramebufferBinding(); - void updateFramebuffer(quint32 fbo, const mbgl::Size &); + // mbgl::gfx::RendererBackend implementation +public: + mbgl::gfx::Renderable& getDefaultRenderable() override { + return *this; + } protected: - mbgl::gl::ProcAddress getExtensionFunctionPointer(const char*) final; - // No-op, implicit mode. - void activate() final {} - void deactivate() final {} + void activate() override {} + void deactivate() override {} + + // mbgl::gl::RendererBackend implementation +protected: + mbgl::gl::ProcAddress getExtensionFunctionPointer(const char*) override; + void updateAssumedState() override; private: quint32 m_fbo = 0; - mbgl::Size m_size = { 0, 0 }; Q_DISABLE_COPY(QMapboxGLRendererBackend) }; diff --git a/platform/qt/src/qt_geojson.cpp b/platform/qt/src/qt_geojson.cpp index cd808f016c..48d78abfe0 100644 --- a/platform/qt/src/qt_geojson.cpp +++ b/platform/qt/src/qt_geojson.cpp @@ -3,6 +3,8 @@ #include <mbgl/util/geometry.hpp> #include <mbgl/util/feature.hpp> +#pragma clang diagnostic ignored "-Wenum-compare-switch" + namespace QMapbox { mbgl::Point<double> asMapboxGLPoint(const QMapbox::Coordinate &coordinate) { |