Drawable Renderer (#1570), Custom layer (issue #1272)

src/mbgl/gfx/context.hpp

@@ -113,6 +113,9 @@ public:
 
     virtual void clearStencilBuffer(int32_t) = 0;
 
+    /// Sets dirty state
+    virtual void setDirtyState() = 0;
+
 #if MLN_DRAWABLE_RENDERER
 public:
     /// Create a new drawable builder
@@ -137,6 +140,9 @@ public:
 
     /// Create a render target
     virtual RenderTargetPtr createRenderTarget(const Size size, const TextureChannelDataType type) = 0;
+
+    /// Resets the context state to defaults
+    virtual void resetState(gfx::DepthMode depthMode, gfx::ColorMode colorMode) = 0;
 #endif
 };
 

src/mbgl/gfx/drawable_builder.cpp

@@ -30,7 +30,7 @@ void DrawableBuilder::setCullFaceMode(const gfx::CullFaceMode& value) {
     impl->cullFaceMode = value;
 }
 
-const UniqueDrawable& DrawableBuilder::getCurrentDrawable(bool createIfNone) {
+UniqueDrawable& DrawableBuilder::getCurrentDrawable(bool createIfNone) {
     if (!currentDrawable && createIfNone) {
         currentDrawable = createDrawable();
     }

src/mbgl/gfx/drawable_custom_layer_host_tweaker.cpp

@@ -0,0 +1,46 @@
+#include <mbgl/gfx/drawable_custom_layer_host_tweaker.hpp>
+#include <mbgl/renderer/paint_parameters.hpp>
+#include <mbgl/gfx/renderer_backend.hpp>
+#include <mbgl/gfx/renderable.hpp>
+
+#include <mbgl/gfx/drawable.hpp>
+#include <mbgl/gfx/context.hpp>
+
+#include <mbgl/gfx/renderable.hpp>
+
+namespace mbgl {
+namespace gfx {
+
+void DrawableCustomLayerHostTweaker::execute([[maybe_unused]] gfx::Drawable& drawable,
+                                             const PaintParameters& paintParameters) {
+    // custom drawing
+    auto& context = paintParameters.context;
+    const TransformState& state = paintParameters.state;
+    context.resetState(paintParameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
+                       paintParameters.colorModeForRenderPass());
+
+    style::CustomLayerRenderParameters parameters;
+
+    parameters.width = state.getSize().width;
+    parameters.height = state.getSize().height;
+    parameters.latitude = state.getLatLng().latitude();
+    parameters.longitude = state.getLatLng().longitude();
+    parameters.zoom = state.getZoom();
+    parameters.bearing = util::rad2deg(-state.getBearing());
+    parameters.pitch = state.getPitch();
+    parameters.fieldOfView = state.getFieldOfView();
+    mat4 projMatrix;
+    state.getProjMatrix(projMatrix);
+    parameters.projectionMatrix = projMatrix;
+
+    host->render(parameters);
+
+    // Reset the view back to our original one, just in case the CustomLayer
+    // changed the viewport or Framebuffer.
+    paintParameters.backend.getDefaultRenderable().getResource<gfx::RenderableResource>().bind();
+
+    context.setDirtyState();
+}
+
+} // namespace gfx
+} // namespace mbgl

src/mbgl/gl/context.cpp

@@ -423,6 +423,17 @@ void Context::reset() {
     performCleanup();
 }
 
+#if MLN_DRAWABLE_RENDERER
+void Context::resetState(gfx::DepthMode depthMode, gfx::ColorMode colorMode) {
+    // Reset GL state to a known state so the CustomLayer always has a clean slate.
+    bindVertexArray = value::BindVertexArray::Default;
+    setDepthMode(depthMode);
+    setStencilMode(gfx::StencilMode::disabled());
+    setColorMode(colorMode);
+    setCullFaceMode(gfx::CullFaceMode::disabled());
+}
+#endif
+
 void Context::setDirtyState() {
     // Note: does not set viewport/scissorTest/bindFramebuffer to dirty
     // since they are handled separately in the view object.

src/mbgl/gl/context.hpp

@@ -100,8 +100,6 @@ public:
                abandonedFramebuffers.empty();
     }
 
-    void setDirtyState();
-
     extension::Debugging* getDebuggingExtension() const { return debugging.get(); }
 
     void setCleanupOnDestruction(bool cleanup) { cleanupOnDestruction = cleanup; }
@@ -121,8 +119,12 @@ public:
     RenderTargetPtr createRenderTarget(const Size size, const gfx::TextureChannelDataType type) override;
 
     UniqueFramebuffer createFramebuffer(const gfx::Texture2D& color);
+
+    void resetState(gfx::DepthMode depthMode, gfx::ColorMode colorMode) override;
 #endif
 
+    void setDirtyState() override;
+
 private:
     RendererBackend& backend;
     bool cleanupOnDestruction = true;

src/mbgl/gl/drawable_gl.cpp

@@ -22,6 +22,10 @@ DrawableGL::~DrawableGL() {
 }
 
 void DrawableGL::draw(PaintParameters& parameters) const {
+    if (isCustom) {
+        return;
+    }
+
     auto& context = static_cast<gl::Context&>(parameters.context);
 
     if (shader) {

src/mbgl/gl/layer_group_gl.cpp

@@ -106,12 +106,7 @@ void LayerGroupGL::upload(gfx::UploadPass& uploadPass) {
         auto& drawableGL = static_cast<gl::DrawableGL&>(drawable);
 
 #if !defined(NDEBUG)
-        std::string label;
-        if (const auto& tileID = drawable.getTileID()) {
-            label = drawable.getName() + "/" + util::toString(*tileID);
-        }
-        const auto labelPtr = (label.empty() ? drawable.getName() : label).c_str();
-        const auto debugGroup = uploadPass.createDebugGroup(labelPtr);
+        const auto debugGroup = uploadPass.createDebugGroup(drawable.getName().c_str());
 #endif
 
         drawableGL.upload(uploadPass);

src/mbgl/layermanager/custom_layer_factory.cpp

@@ -1,7 +1,7 @@
-#include <mbgl/gl/custom_layer.hpp>
-#include <mbgl/gl/custom_layer_factory.hpp>
-#include <mbgl/gl/custom_layer_impl.hpp>
-#include <mbgl/gl/render_custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
+#include <mbgl/layermanager/custom_layer_factory.hpp>
+#include <mbgl/style/layers/custom_layer_impl.hpp>
+#include <mbgl/renderer/layers/render_custom_layer.hpp>
 
 namespace mbgl {
 

src/mbgl/renderer/layers/render_custom_layer.cpp

@@ -1,16 +1,31 @@
 #include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/gfx/renderer_backend.hpp>
-#include <mbgl/gl/context.hpp>
-#include <mbgl/gl/custom_layer_impl.hpp>
-#include <mbgl/gl/render_custom_layer.hpp>
-#include <mbgl/gl/renderable_resource.hpp>
+#include <mbgl/style/layers/custom_layer_impl.hpp>
+#include <mbgl/renderer/layers/render_custom_layer.hpp>
 #include <mbgl/map/transform_state.hpp>
 #include <mbgl/math/angles.hpp>
-#include <mbgl/platform/gl_functions.hpp>
 #include <mbgl/renderer/bucket.hpp>
 #include <mbgl/renderer/paint_parameters.hpp>
 #include <mbgl/util/mat4.hpp>
 
+#if MLN_LEGACY_RENDERER
+#include <mbgl/platform/gl_functions.hpp>
+#include <mbgl/gl/context.hpp>
+#include <mbgl/gl/renderable_resource.hpp>
+#endif
+
+#if MLN_DRAWABLE_RENDERER
+#include <mbgl/gfx/context.hpp>
+#include <mbgl/renderer/layer_group.hpp>
+#include <mbgl/gfx/drawable_custom_layer_host_tweaker.hpp>
+#include <mbgl/gfx/drawable_builder.hpp>
+
+#if !MLN_LEGACY_RENDERER
+// TODO: platform agnostic error checks
+#define MBGL_CHECK_ERROR(cmd) (cmd)
+#endif
+#endif
+
 namespace mbgl {
 
 using namespace style;
@@ -58,6 +73,7 @@ void RenderCustomLayer::markContextDestroyed() {
 
 void RenderCustomLayer::prepare(const LayerPrepareParameters&) {}
 
+#if MLN_LEGACY_RENDERER
 void RenderCustomLayer::render(PaintParameters& paintParameters) {
     if (host != impl(baseImpl).host) {
         // If the context changed, deinitialize the previous one before initializing the new one.
@@ -100,5 +116,57 @@ void RenderCustomLayer::render(PaintParameters& paintParameters) {
     paintParameters.backend.getDefaultRenderable().getResource<gl::RenderableResource>().bind();
     glContext.setDirtyState();
 }
+#endif
+
+#if MLN_DRAWABLE_RENDERER
+void RenderCustomLayer::update([[maybe_unused]] gfx::ShaderRegistry& shaders,
+                               gfx::Context& context,
+                               [[maybe_unused]] const TransformState& state,
+                               [[maybe_unused]] const RenderTree& renderTree,
+                               [[maybe_unused]] UniqueChangeRequestVec& changes) {
+    std::unique_lock<std::mutex> guard(mutex);
+
+    // create layer group
+    if (!layerGroup) {
+        if (auto layerGroup_ = context.createLayerGroup(layerIndex, /*initialCapacity=*/1, getID())) {
+            setLayerGroup(std::move(layerGroup_), changes);
+        }
+    }
+
+    auto* localLayerGroup = static_cast<LayerGroup*>(layerGroup.get());
+
+    // check if host changed and update
+    bool hostChanged = (host != impl(baseImpl).host);
+    if (hostChanged) {
+        // If the context changed, deinitialize the previous one before initializing the new one.
+        if (host && !contextDestroyed) {
+            MBGL_CHECK_ERROR(host->deinitialize());
+        }
+        host = impl(baseImpl).host;
+        MBGL_CHECK_ERROR(host->initialize());
+    }
+
+    // create drawable
+    if (localLayerGroup->getDrawableCount() == 0 || hostChanged) {
+        localLayerGroup->clearDrawables();
+
+        // create tweaker
+        auto tweaker = std::make_shared<gfx::DrawableCustomLayerHostTweaker>(host);
+
+        // create empty drawable using a builder
+        std::unique_ptr<gfx::DrawableBuilder> builder = context.createDrawableBuilder(getID());
+        auto& drawable = builder->getCurrentDrawable(true);
+        drawable->setIsCustom(true);
+        drawable->setRenderPass(RenderPass::Translucent);
+
+        // assign tweaker to drawable
+        drawable->addTweaker(tweaker);
+
+        // add drawable to layer group
+        localLayerGroup->addDrawable(std::move(drawable));
+        ++stats.drawablesAdded;
+    }
+}
+#endif
 
 } // namespace mbgl

src/mbgl/renderer/layers/render_custom_layer.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <mbgl/gl/custom_layer_impl.hpp>
+#include <mbgl/style/layers/custom_layer_impl.hpp>
 #include <mbgl/renderer/render_layer.hpp>
 
 namespace mbgl {
@@ -10,6 +10,15 @@ public:
     explicit RenderCustomLayer(Immutable<style::CustomLayer::Impl>);
     ~RenderCustomLayer() override;
 
+#if MLN_DRAWABLE_RENDERER
+    /// Generate any changes needed by the layer
+    void update(gfx::ShaderRegistry&,
+                gfx::Context&,
+                const TransformState&,
+                const RenderTree&,
+                UniqueChangeRequestVec&) override;
+#endif
+
 private:
     void transition(const TransitionParameters&) override {}
     void evaluate(const PropertyEvaluationParameters&) override;
@@ -18,7 +27,9 @@ private:
     void markContextDestroyed() override;
     void prepare(const LayerPrepareParameters&) override;
 
+#if MLN_LEGACY_RENDERER
     void render(PaintParameters&) override;
+#endif
 
     bool contextDestroyed = false;
     std::shared_ptr<style::CustomLayerHost> host;

src/mbgl/renderer/renderer.cpp

@@ -32,18 +32,7 @@ void Renderer::render(const std::shared_ptr<UpdateParameters>& updateParameters)
     assert(updateParameters);
     if (auto renderTree = impl->orchestrator.createRenderTree(updateParameters)) {
         renderTree->prepare();
-
-#if MLN_DRAWABLE_RENDERER
-        const auto& renderTreeParameters = renderTree->getParameters();
-        const auto& state = renderTreeParameters.transformParams.state;
-
-        if (impl->staticData && impl->staticData->shaders) {
-            auto& context = impl->backend.getContext();
-            auto& shaders = *impl->staticData->shaders;
-            impl->orchestrator.updateLayers(shaders, context, state, updateParameters, *renderTree);
-        }
-#endif
-
+        impl->preRender(*renderTree, updateParameters);
         impl->render(*renderTree);
     }
 }

src/mbgl/renderer/renderer_impl.cpp

@@ -62,14 +62,8 @@ void Renderer::Impl::setObserver(RendererObserver* observer_) {
     observer = observer_ ? observer_ : &nullObserver();
 }
 
-void Renderer::Impl::render(const RenderTree& renderTree) {
-    if (renderState == RenderState::Never) {
-        observer->onWillStartRenderingMap();
-    }
-
-    observer->onWillStartRenderingFrame();
-    const auto& renderTreeParameters = renderTree.getParameters();
-
+void Renderer::Impl::preRender(const RenderTree& renderTree,
+                               [[maybe_unused]] const std::shared_ptr<UpdateParameters>& updateParameters) {
     auto& context = backend.getContext();
     // Blocks execution until the renderable is available.
     backend.getDefaultRenderable().wait();
@@ -89,7 +83,26 @@ void Renderer::Impl::render(const RenderTree& renderTree) {
         // Notify post-shader registration
         observer->onRegisterShaders(*staticData->shaders);
     }
+
+#if MLN_DRAWABLE_RENDERER
+    // update layers
+    const auto& renderTreeParameters = renderTree.getParameters();
     staticData->has3D = renderTreeParameters.has3D;
+    if (staticData && staticData->shaders) {
+        orchestrator.updateLayers(
+            *staticData->shaders, context, renderTreeParameters.transformParams.state, updateParameters, renderTree);
+    }
+#endif
+}
+
+void Renderer::Impl::render(const RenderTree& renderTree) {
+    if (renderState == RenderState::Never) {
+        observer->onWillStartRenderingMap();
+    }
+
+    observer->onWillStartRenderingFrame();
+    auto& context = backend.getContext();
+    const auto& renderTreeParameters = renderTree.getParameters();
 
     PaintParameters parameters{context,
                                pixelRatio,

src/mbgl/renderer/renderer_impl.hpp

@@ -26,6 +26,8 @@ private:
 
     void setObserver(RendererObserver*);
 
+    void preRender(const RenderTree&, const std::shared_ptr<UpdateParameters>&);
+
     void render(const RenderTree&);
 
     void reduceMemoryUse();

src/mbgl/style/layers/custom_layer.cpp

@@ -1,6 +1,6 @@
-#include <mbgl/gl/custom_layer.hpp>
-#include <mbgl/gl/custom_layer_impl.hpp>
-#include <mbgl/gl/render_custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer_impl.hpp>
+#include <mbgl/renderer/layers/render_custom_layer.hpp>
 #include <mbgl/style/layer_observer.hpp>
 
 namespace mbgl {

src/mbgl/style/layers/custom_layer_impl.cpp

@@ -1,4 +1,4 @@
-#include <mbgl/gl/custom_layer_impl.hpp>
+#include <mbgl/style/layers/custom_layer_impl.hpp>
 
 namespace mbgl {
 namespace style {

src/mbgl/style/layers/custom_layer_impl.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <mbgl/gl/custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
 #include <mbgl/style/layer_impl.hpp>
 #include <mbgl/style/layer_properties.hpp>
 

src/mbgl/style/style_impl.cpp

@@ -1,4 +1,4 @@
-#include <mbgl/gl/custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
 #include <mbgl/sprite/sprite_loader.hpp>
 #include <mbgl/storage/file_source.hpp>
 #include <mbgl/storage/resource.hpp>

src/mbgl/tile/geometry_tile.cpp

@@ -2,8 +2,8 @@
 
 #include <mbgl/actor/scheduler.hpp>
 #include <mbgl/geometry/feature_index.hpp>
-#include <mbgl/gl/custom_layer.hpp>
-#include <mbgl/gl/render_custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
+#include <mbgl/renderer/layers/render_custom_layer.hpp>
 #include <mbgl/map/transform_state.hpp>
 #include <mbgl/renderer/buckets/symbol_bucket.hpp>
 #include <mbgl/renderer/image_atlas.hpp>