From 46c43510d7ac5fe078010d5f0f5d39c4d5df3305 Mon Sep 17 00:00:00 2001 From: Ivo van Dongen Date: Wed, 5 Jul 2017 20:08:51 +0300 Subject: [core] rename backend to renderer backend --- include/mbgl/map/backend.hpp | 84 ------------------------------ include/mbgl/map/backend_scope.hpp | 31 ----------- include/mbgl/renderer/backend_scope.hpp | 31 +++++++++++ include/mbgl/renderer/renderer.hpp | 4 +- include/mbgl/renderer/renderer_backend.hpp | 84 ++++++++++++++++++++++++++++++ 5 files changed, 117 insertions(+), 117 deletions(-) delete mode 100644 include/mbgl/map/backend.hpp delete mode 100644 include/mbgl/map/backend_scope.hpp create mode 100644 include/mbgl/renderer/backend_scope.hpp create mode 100644 include/mbgl/renderer/renderer_backend.hpp (limited to 'include') diff --git a/include/mbgl/map/backend.hpp b/include/mbgl/map/backend.hpp deleted file mode 100644 index 3347086571..0000000000 --- a/include/mbgl/map/backend.hpp +++ /dev/null @@ -1,84 +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 - -class Backend { -public: - Backend(); - virtual ~Backend(); - - // 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; - - 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 - // must call the API-specific version that obtains the function pointer for this function, - // or a null pointer if unsupported/unavailable. - virtual gl::ProcAddress initializeExtension(const char*) = 0; - - // Called when the backend's GL context needs to be made active or inactive. These are called, - // as a matched pair, in four situations: - // - // 1. When releasing GL resources during Map destruction - // 2. When calling a CustomLayerInitializeFunction, during Map::addLayer - // 3. When calling a CustomLayerDeinitializeFunction, during Map::removeLayer - // 4. When rendering for Map::renderStill - // - // They are *not* called for Map::render; it is assumed that the correct context is already - // activated prior to calling Map::render. - 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 BackendScope; -}; - -} // namespace mbgl diff --git a/include/mbgl/map/backend_scope.hpp b/include/mbgl/map/backend_scope.hpp deleted file mode 100644 index 4985cd197f..0000000000 --- a/include/mbgl/map/backend_scope.hpp +++ /dev/null @@ -1,31 +0,0 @@ -#pragma once - -namespace mbgl { - -class Backend; - -class BackendScope { -public: - // There are two types of scopes: Creating an "Implicit" scope tells Mapbox GL that the - // supporting windowing system has already activated the GL Backend and that no further actions - // are required. Creating an "Explicit" scope actually enables the GL Backend, and disables it - // when the BackendScope is destroyed. - enum class ScopeType : bool { - Implicit, - Explicit, - }; - - BackendScope(Backend&, ScopeType = ScopeType::Explicit); - ~BackendScope(); - - // Returns true when there is currently a BackendScope active in this thread. - static bool exists(); - -private: - BackendScope* priorScope; - BackendScope* nextScope; - Backend& backend; - const ScopeType scopeType; -}; - -} // namespace mbgl diff --git a/include/mbgl/renderer/backend_scope.hpp b/include/mbgl/renderer/backend_scope.hpp new file mode 100644 index 0000000000..f8a258f3df --- /dev/null +++ b/include/mbgl/renderer/backend_scope.hpp @@ -0,0 +1,31 @@ +#pragma once + +namespace mbgl { + +class RendererBackend; + +class BackendScope { +public: + // There are two types of scopes: Creating an "Implicit" scope tells Mapbox GL that the + // supporting windowing system has already activated the GL Backend and that no further actions + // are required. Creating an "Explicit" scope actually enables the GL Backend, and disables it + // when the BackendScope is destroyed. + enum class ScopeType : bool { + Implicit, + Explicit, + }; + + BackendScope(RendererBackend&, ScopeType = ScopeType::Explicit); + ~BackendScope(); + + // Returns true when there is currently a BackendScope active in this thread. + static bool exists(); + +private: + BackendScope* priorScope; + BackendScope* nextScope; + RendererBackend& backend; + const ScopeType scopeType; +}; + +} // namespace mbgl diff --git a/include/mbgl/renderer/renderer.hpp b/include/mbgl/renderer/renderer.hpp index 6626f74d3d..c209e03045 100644 --- a/include/mbgl/renderer/renderer.hpp +++ b/include/mbgl/renderer/renderer.hpp @@ -13,8 +13,8 @@ namespace mbgl { -class Backend; class FileSource; +class RendererBackend; class RendererObserver; class RenderedQueryOptions; class Scheduler; @@ -24,7 +24,7 @@ class View; class Renderer { public: - Renderer(Backend&, float pixelRatio_, FileSource&, Scheduler&, + Renderer(RendererBackend&, float pixelRatio_, FileSource&, Scheduler&, GLContextMode = GLContextMode::Unique, const optional programCacheDir = optional()); ~Renderer(); diff --git a/include/mbgl/renderer/renderer_backend.hpp b/include/mbgl/renderer/renderer_backend.hpp new file mode 100644 index 0000000000..9d967fd51b --- /dev/null +++ b/include/mbgl/renderer/renderer_backend.hpp @@ -0,0 +1,84 @@ +#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; + + virtual BackendScope::ScopeType getScopeType() const { + return BackendScope::ScopeType::Explicit; + } + +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 initializeExtension(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 CustomLayerDeinitializeFunction during RenderCustomLayer destruction) + // 2. When renderering through Renderer::render() + // (Including calling CustomLayerDeinitializeFunction for newly added custom layers and + // CustomLayerDeinitializeFunction 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 BackendScope; +}; + +} // namespace mbgl -- cgit v1.2.1