[core] rename backend to renderer backend

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