From 66c020034e8260e5e071481e68ab61cd264723ba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Konstantin=20K=C3=A4fer?= Date: Mon, 1 Apr 2019 16:56:24 +0200 Subject: [core] refactor RendererBackend --- include/mbgl/gfx/backend_scope.hpp | 3 +- include/mbgl/gfx/renderer_backend.hpp | 57 ++++++++++++++++++ include/mbgl/gl/renderer_backend.hpp | 59 +++++++++++++++++++ include/mbgl/renderer/renderer.hpp | 7 ++- include/mbgl/renderer/renderer_backend.hpp | 92 ------------------------------ 5 files changed, 122 insertions(+), 96 deletions(-) create mode 100644 include/mbgl/gfx/renderer_backend.hpp create mode 100644 include/mbgl/gl/renderer_backend.hpp delete mode 100644 include/mbgl/renderer/renderer_backend.hpp (limited to 'include') diff --git a/include/mbgl/gfx/backend_scope.hpp b/include/mbgl/gfx/backend_scope.hpp index b92334ae0f..ae42123e97 100644 --- a/include/mbgl/gfx/backend_scope.hpp +++ b/include/mbgl/gfx/backend_scope.hpp @@ -1,11 +1,10 @@ #pragma once namespace mbgl { +namespace gfx { class RendererBackend; -namespace gfx { - class BackendScope { public: // There are two types of scopes: Creating an "Implicit" scope tells Mapbox GL that the diff --git a/include/mbgl/gfx/renderer_backend.hpp b/include/mbgl/gfx/renderer_backend.hpp new file mode 100644 index 0000000000..032c7021da --- /dev/null +++ b/include/mbgl/gfx/renderer_backend.hpp @@ -0,0 +1,57 @@ +#pragma once + +#include + +#include +#include + +namespace mbgl { +namespace gfx { + +class Context; +class Renderable; +class BackendScope; + +// TODO: Rename to "Device" +class RendererBackend { +protected: + explicit RendererBackend(); + +public: + virtual ~RendererBackend(); + RendererBackend(const RendererBackend&) = delete; + RendererBackend& operator=(const RendererBackend&) = delete; + + // Returns the device's context. + Context& getContext(); + + // Returns a reference to the default surface that should be rendered on. + virtual Renderable& getDefaultRenderable() = 0; + +protected: + virtual std::unique_ptr createContext() = 0; + + // Called when the backend's GL context needs to be made active or inactive. These are called, + // as a matched pair, exclusively through BackendScope, in two situations: + // + // 1. When releasing GL resources during Renderer destruction + // (Including calling CustomLayerHost::deinitialize during RenderCustomLayer destruction) + // 2. When renderering through Renderer::render() + // (Including calling CustomLayerHost::initialize for newly added custom layers and + // CustomLayerHost::deinitialize on layer removal) + virtual void activate() = 0; + virtual void deactivate() = 0; + +protected: + std::unique_ptr context; + std::once_flag initialized; + + friend class BackendScope; +}; + +MBGL_CONSTEXPR bool operator==(const RendererBackend& a, const RendererBackend& b) { + return &a == &b; +} + +} // namespace gfx +} // namespace mbgl diff --git a/include/mbgl/gl/renderer_backend.hpp b/include/mbgl/gl/renderer_backend.hpp new file mode 100644 index 0000000000..7ef8759477 --- /dev/null +++ b/include/mbgl/gl/renderer_backend.hpp @@ -0,0 +1,59 @@ +#pragma once + +#include +#include +#include +#include + +namespace mbgl { +namespace gl { + +class Context; +using ProcAddress = void (*)(); +using FramebufferID = uint32_t; + +class RendererBackend : public gfx::RendererBackend { +public: + RendererBackend(); + ~RendererBackend() override; + + // Returns the backend's context which manages OpenGL state. + Context& getGLContext(); + + // Called prior to rendering to update the internally assumed OpenGL state. + virtual void updateAssumedState() = 0; + +protected: + std::unique_ptr createContext() override; + + // Called with the name of an OpenGL extension that should be loaded. RendererBackend implementations + // must call the API-specific version that obtains the function pointer for this function, + // or a null pointer if unsupported/unavailable. + virtual ProcAddress getExtensionFunctionPointer(const char*) = 0; + + // Reads the color pixel data from the currently bound framebuffer. + PremultipliedImage readFramebuffer(const Size&); + + // A constant to signal that a framebuffer is bound, but with an unknown ID. + static constexpr const FramebufferID ImplicitFramebufferBinding = + std::numeric_limits::max(); + + // Tells the renderer that OpenGL state has already been set by the windowing toolkit. + // It sets the internal assumed state to the supplied values. + void assumeFramebufferBinding(FramebufferID fbo); + void assumeViewport(int32_t x, int32_t y, const Size&); + void assumeScissorTest(bool); + + // Returns true when assumed framebuffer binding hasn't changed from the implicit binding. + bool implicitFramebufferBound(); + +public: + // Triggers an OpenGL state update if the internal assumed state doesn't match the + // supplied values. + void setFramebufferBinding(FramebufferID fbo); + void setViewport(int32_t x, int32_t y, const Size&); + void setScissorTest(bool); +}; + +} // namespace gl +} // namespace mbgl diff --git a/include/mbgl/renderer/renderer.hpp b/include/mbgl/renderer/renderer.hpp index 0bed4cdaa8..aa06210804 100644 --- a/include/mbgl/renderer/renderer.hpp +++ b/include/mbgl/renderer/renderer.hpp @@ -13,16 +13,19 @@ namespace mbgl { -class RendererBackend; class RendererObserver; class RenderedQueryOptions; class Scheduler; class SourceQueryOptions; class UpdateParameters; +namespace gfx { +class RendererBackend; +} // namespace gfx + class Renderer { public: - Renderer(RendererBackend&, float pixelRatio_, Scheduler&, + Renderer(gfx::RendererBackend&, float pixelRatio_, Scheduler&, GLContextMode = GLContextMode::Unique, const optional programCacheDir = {}, const optional localFontFamily = {}); diff --git a/include/mbgl/renderer/renderer_backend.hpp b/include/mbgl/renderer/renderer_backend.hpp deleted file mode 100644 index f75d00ebb3..0000000000 --- a/include/mbgl/renderer/renderer_backend.hpp +++ /dev/null @@ -1,92 +0,0 @@ -#pragma once - -#include -#include -#include -#include - -#include -#include - -namespace mbgl { - -namespace gl { -class Context; -using ProcAddress = void (*)(); -using FramebufferID = uint32_t; -} // namespace gl - -// The RendererBackend is used by the Renderer to facilitate -// the actual rendering. -class RendererBackend { -public: - RendererBackend(); - virtual ~RendererBackend(); - - // Returns the backend's context which manages OpenGL state. - gl::Context& getContext(); - - // Called prior to rendering to update the internally assumed OpenGL state. - virtual void updateAssumedState() = 0; - - // Called when this backend is used for rendering. Implementations should ensure that a renderable - // object is bound and glClear/glDraw* calls can be done. They should also make sure that - // calling .bind() repeatedly is a no-op and that the appropriate gl::Context values are - // set to the current state. - virtual void bind() = 0; - - virtual Size getFramebufferSize() const = 0; - -protected: - // Called with the name of an OpenGL extension that should be loaded. RendererBackend implementations - // must call the API-specific version that obtains the function pointer for this function, - // or a null pointer if unsupported/unavailable. - virtual gl::ProcAddress getExtensionFunctionPointer(const char*) = 0; - - // Called when the backend's GL context needs to be made active or inactive. These are called, - // as a matched pair, exclusively through BackendScope, in two situations: - // - // 1. When releasing GL resources during Renderer destruction - // (Including calling CustomLayerHost::deinitialize during RenderCustomLayer destruction) - // 2. When renderering through Renderer::render() - // (Including calling CustomLayerHost::initialize for newly added custom layers and - // CustomLayerHost::deinitialize on layer removal) - virtual void activate() = 0; - virtual void deactivate() = 0; - - // Reads the color pixel data from the currently bound framebuffer. - PremultipliedImage readFramebuffer(const Size&) const; - - // A constant to signal that a framebuffer is bound, but with an unknown ID. - static constexpr const gl::FramebufferID ImplicitFramebufferBinding = - std::numeric_limits::max(); - - // Tells the renderer that OpenGL state has already been set by the windowing toolkit. - // It sets the internal assumed state to the supplied values. - void assumeFramebufferBinding(gl::FramebufferID fbo); - void assumeViewport(int32_t x, int32_t y, const Size&); - void assumeScissorTest(bool); - - // Returns true when assumed framebuffer binding hasn't changed from the implicit binding. - bool implicitFramebufferBound(); - - // Triggers an OpenGL state update if the internal assumed state doesn't match the - // supplied values. - void setFramebufferBinding(gl::FramebufferID fbo); - void setViewport(int32_t x, int32_t y, const Size&); - void setScissorTest(bool); - -protected: - std::unique_ptr context; - -private: - std::once_flag initialized; - - friend class gfx::BackendScope; -}; - -MBGL_CONSTEXPR bool operator==(const RendererBackend& a, const RendererBackend& b) { - return &a == &b; -} - -} // namespace mbgl -- cgit v1.2.1