[node] rendering interface changes

cmake/node.cmake

@@ -19,6 +19,8 @@ target_sources(mbgl-node
     PRIVATE platform/node/src/node_request.cpp
     PRIVATE platform/node/src/node_feature.hpp
     PRIVATE platform/node/src/node_feature.cpp
+    PRIVATE platform/node/src/node_renderer_frontend.hpp
+    PRIVATE platform/node/src/node_renderer_frontend.cpp
     PRIVATE platform/node/src/node_thread_pool.hpp
     PRIVATE platform/node/src/node_thread_pool.cpp
     PRIVATE platform/node/src/util/async_queue.hpp

platform/node/src/node_map.cpp

@@ -3,15 +3,18 @@
 #include "node_feature.hpp"
 #include "node_conversion.hpp"
 #include "node_geojson.hpp"
+#include "node_renderer_frontend.hpp"
 
 #include <mbgl/gl/headless_display.hpp>
 #include <mbgl/util/exception.hpp>
+#include <mbgl/renderer/renderer.hpp>
 #include <mbgl/style/conversion/source.hpp>
 #include <mbgl/style/conversion/layer.hpp>
 #include <mbgl/style/conversion/filter.hpp>
 #include <mbgl/style/style.hpp>
 #include <mbgl/style/image.hpp>
 #include <mbgl/map/backend_scope.hpp>
+#include <mbgl/map/map_observer.hpp>
 #include <mbgl/util/premultiply.hpp>
 
 #include <unistd.h>
@@ -396,7 +399,7 @@ void NodeMap::startRender(NodeMap::RenderOptions options) {
         map->setDebug(options.debugOptions);
     }
 
-    map->renderStill(*view, [this](const std::exception_ptr eptr) {
+    map->renderStill([this](const std::exception_ptr eptr) {
         if (eptr) {
             error = std::move(eptr);
             uv_async_send(async);
@@ -501,7 +504,7 @@ void NodeMap::release() {
     uv_close(reinterpret_cast<uv_handle_t *>(async), [] (uv_handle_t *h) {
         delete reinterpret_cast<uv_async_t *>(h);
     });
-
+    
     map.reset();
 }
 
@@ -528,9 +531,14 @@ void NodeMap::Cancel(const Nan::FunctionCallbackInfo<v8::Value>& info) {
 
 void NodeMap::cancel() {
     auto style = map->getStyle().getJSON();
+    
+    // Reset map explicitly as it resets the renderer frontend
+    map.reset();
 
-    map = std::make_unique<mbgl::Map>(backend, mapObserver, mbgl::Size{ 256, 256 },
-            pixelRatio, *this, threadpool, mbgl::MapMode::Still);
+    auto renderer = std::make_unique<mbgl::Renderer>(backend, pixelRatio, *this, threadpool);
+    rendererFrontend = std::make_unique<NodeRendererFrontend>(std::move(renderer), [this] { return view.get(); });
+    map = std::make_unique<mbgl::Map>(*rendererFrontend, mapObserver, mbgl::Size{ 256, 256 }, pixelRatio,
+                                      *this, threadpool, mbgl::MapMode::Still);
 
     // FIXME: Reload the style after recreating the map. We need to find
     // a better way of canceling an ongoing rendering on the core level
@@ -884,6 +892,11 @@ void NodeMap::DumpDebugLogs(const Nan::FunctionCallbackInfo<v8::Value>& info) {
     if (!nodeMap->map) return Nan::ThrowError(releasedMessage());
 
     nodeMap->map->dumpDebugLogs();
+    
+    if (nodeMap->rendererFrontend) {
+        nodeMap->rendererFrontend->dumpDebugLogs();
+    }
+    
     info.GetReturnValue().SetUndefined();
 }
 
@@ -945,7 +958,7 @@ void NodeMap::QueryRenderedFeatures(const Nan::FunctionCallbackInfo<v8::Value>&
             auto pos0 = Nan::Get(posOrBox, 0).ToLocalChecked().As<v8::Array>();
             auto pos1 = Nan::Get(posOrBox, 1).ToLocalChecked().As<v8::Array>();
 
-            optional = nodeMap->map->queryRenderedFeatures(mbgl::ScreenBox {
+            optional = nodeMap->rendererFrontend->queryRenderedFeatures(mbgl::ScreenBox {
                 {
                     Nan::Get(pos0, 0).ToLocalChecked()->NumberValue(),
                     Nan::Get(pos0, 1).ToLocalChecked()->NumberValue()
@@ -956,7 +969,7 @@ void NodeMap::QueryRenderedFeatures(const Nan::FunctionCallbackInfo<v8::Value>&
             },  queryOptions);
 
         } else {
-            optional = nodeMap->map->queryRenderedFeatures(mbgl::ScreenCoordinate {
+            optional = nodeMap->rendererFrontend->queryRenderedFeatures(mbgl::ScreenCoordinate {
                 Nan::Get(posOrBox, 0).ToLocalChecked()->NumberValue(),
                 Nan::Get(posOrBox, 1).ToLocalChecked()->NumberValue()
             }, queryOptions);
@@ -980,11 +993,12 @@ NodeMap::NodeMap(v8::Local<v8::Object> options)
                            .ToLocalChecked()
                            ->NumberValue()
                      : 1.0;
-      }()),
-      mapObserver(NodeMapObserver()),
-      map(std::make_unique<mbgl::Map>(backend,
+      }())
+    , mapObserver(NodeMapObserver())
+    , rendererFrontend(std::make_unique<NodeRendererFrontend>(std::make_unique<mbgl::Renderer>(backend, pixelRatio, *this, threadpool), [this] { return view.get(); }))
+    , map(std::make_unique<mbgl::Map>(*rendererFrontend,
                                       mapObserver,
-                                      mbgl::Size{ 256, 256 },
+                                      mbgl::Size { 256, 256 },
                                       pixelRatio,
                                       *this,
                                       threadpool,

platform/node/src/node_map.hpp

@@ -16,6 +16,8 @@
 #pragma GCC diagnostic pop
 
 namespace node_mbgl {
+    
+class NodeRendererFrontend;
 
 class NodeBackend : public mbgl::HeadlessBackend {
 public:
@@ -75,6 +77,7 @@ public:
     std::unique_ptr<mbgl::OffscreenView> view;
     NodeThreadPool threadpool;
     NodeMapObserver mapObserver;
+    std::unique_ptr<NodeRendererFrontend> rendererFrontend;
     std::unique_ptr<mbgl::Map> map;
 
     std::exception_ptr error;

platform/node/src/node_renderer_frontend.cpp

@@ -0,0 +1,50 @@
+#include "node_renderer_frontend.hpp"
+#include <mbgl/renderer/renderer.hpp>
+#include <mbgl/map/backend_scope.hpp>
+
+namespace node_mbgl {
+
+NodeRendererFrontend::NodeRendererFrontend(std::unique_ptr<mbgl::Renderer> renderer_, ViewAccessorFunction getView)
+    : renderer(std::move(renderer_))
+    , asyncInvalidate([&, this, getView] {
+        if (renderer && updateParameters) {
+            renderer->render(*getView(), *updateParameters);
+        }
+    }) {
+}
+
+NodeRendererFrontend::~NodeRendererFrontend() = default;
+    
+void NodeRendererFrontend::reset() {
+    assert(renderer);
+    renderer.reset();
+}
+    
+void NodeRendererFrontend::setObserver(mbgl::RendererObserver& observer_) {
+    assert(renderer);
+    renderer->setObserver(&observer_);
+}
+
+void NodeRendererFrontend::update(std::shared_ptr<mbgl::UpdateParameters> updateParameters_) {
+    updateParameters = updateParameters_;
+    asyncInvalidate.send();
+}
+    
+std::vector<mbgl::Feature> NodeRendererFrontend::queryRenderedFeatures(const mbgl::ScreenBox& box,
+                                                                       const mbgl::RenderedQueryOptions& options) const {
+    assert(renderer);
+    return renderer->queryRenderedFeatures(box, options);
+}
+
+std::vector<mbgl::Feature> NodeRendererFrontend::queryRenderedFeatures(const mbgl::ScreenCoordinate& point,
+                                                                       const mbgl::RenderedQueryOptions& options) const {
+    assert(renderer);
+    return renderer->queryRenderedFeatures(point, options);
+}
+
+void NodeRendererFrontend::dumpDebugLogs() {
+    assert(renderer);
+    return renderer->dumpDebugLogs();
+}
+
+} // namespace node_mbgl

platform/node/src/node_renderer_frontend.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <mbgl/map/backend.hpp>
+#include <mbgl/renderer/renderer_frontend.hpp>
+#include <mbgl/renderer/query.hpp>
+#include <mbgl/util/async_task.hpp>
+#include <mbgl/util/feature.hpp>
+#include <mbgl/util/geo.hpp>
+
+#include <functional>
+#include <memory>
+
+namespace mbgl {
+    class Renderer;
+} //  namespace mbgl
+
+namespace node_mbgl {
+
+class NodeRendererFrontend : public mbgl::RendererFrontend {
+public:
+    using ViewAccessorFunction = std::function<mbgl::View* ()>;
+    NodeRendererFrontend(std::unique_ptr<mbgl::Renderer>, ViewAccessorFunction);
+
+    ~NodeRendererFrontend();
+    
+    void reset() override;
+    
+    void setObserver(mbgl::RendererObserver&) override;
+
+    void update(std::shared_ptr<mbgl::UpdateParameters>) override;
+    
+    // Feature querying
+    std::vector<mbgl::Feature> queryRenderedFeatures(const mbgl::ScreenCoordinate&,
+                                                     const mbgl::RenderedQueryOptions& options = {}) const;
+    std::vector<mbgl::Feature> queryRenderedFeatures(const mbgl::ScreenBox&,
+                                                     const mbgl::RenderedQueryOptions& = {}) const;
+
+    void dumpDebugLogs();
+
+private:
+    std::unique_ptr<mbgl::Renderer> renderer;
+    std::shared_ptr<mbgl::UpdateParameters> updateParameters;
+    mbgl::util::AsyncTask asyncInvalidate;
+};
+
+} // namespace node_mbgl