diff options
author | Ivo van Dongen <info@ivovandongen.nl> | 2017-07-05 20:08:51 +0300 |
---|---|---|
committer | Ivo van Dongen <ivovandongen@users.noreply.github.com> | 2017-07-18 10:45:12 +0200 |
commit | 46c43510d7ac5fe078010d5f0f5d39c4d5df3305 (patch) | |
tree | 5dc78959e174dc0e83198a4d92e86f65f33bb168 /include/mbgl/renderer | |
parent | ee205ca9ca3f808fa2cc16295ebde0a7c3867381 (diff) | |
download | qtlocation-mapboxgl-46c43510d7ac5fe078010d5f0f5d39c4d5df3305.tar.gz |
[core] rename backend to renderer backend
Diffstat (limited to 'include/mbgl/renderer')
-rw-r--r-- | include/mbgl/renderer/backend_scope.hpp | 31 | ||||
-rw-r--r-- | include/mbgl/renderer/renderer.hpp | 4 | ||||
-rw-r--r-- | include/mbgl/renderer/renderer_backend.hpp | 84 |
3 files changed, 117 insertions, 2 deletions
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<std::string> programCacheDir = optional<std::string>()); ~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 <mbgl/map/view.hpp> +#include <mbgl/renderer/backend_scope.hpp> +#include <mbgl/util/image.hpp> +#include <mbgl/util/size.hpp> + +#include <memory> +#include <mutex> + +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<gl::FramebufferID>::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<gl::Context> context; + +private: + std::once_flag initialized; + + friend class BackendScope; +}; + +} // namespace mbgl |