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

CMakeLists.txt

@@ -142,6 +142,7 @@ if(MLN_DRAWABLE_RENDERER)
         ${PROJECT_SOURCE_DIR}/include/mbgl/gfx/drawable_builder.hpp
         ${PROJECT_SOURCE_DIR}/include/mbgl/gfx/drawable_tweaker.hpp
         ${PROJECT_SOURCE_DIR}/include/mbgl/gfx/drawable_atlases_tweaker.hpp
+        ${PROJECT_SOURCE_DIR}/include/mbgl/gfx/drawable_custom_layer_host_tweaker.hpp
         ${PROJECT_SOURCE_DIR}/include/mbgl/gfx/uniform_block.hpp
         ${PROJECT_SOURCE_DIR}/include/mbgl/gfx/uniform_buffer.hpp
         ${PROJECT_SOURCE_DIR}/include/mbgl/gfx/vertex_attribute.hpp
@@ -170,6 +171,7 @@ if(MLN_DRAWABLE_RENDERER)
         ${PROJECT_SOURCE_DIR}/src/mbgl/gfx/drawable_builder.cpp
         ${PROJECT_SOURCE_DIR}/src/mbgl/gfx/drawable_builder_impl.hpp
         ${PROJECT_SOURCE_DIR}/src/mbgl/gfx/drawable_atlases_tweaker.cpp
+        ${PROJECT_SOURCE_DIR}/src/mbgl/gfx/drawable_custom_layer_host_tweaker.cpp
         ${PROJECT_SOURCE_DIR}/src/mbgl/gfx/image_drawable_data.hpp
         ${PROJECT_SOURCE_DIR}/src/mbgl/gfx/line_drawable_data.hpp            
         ${PROJECT_SOURCE_DIR}/src/mbgl/gfx/symbol_drawable_data.hpp
@@ -980,8 +982,8 @@ if(MLN_WITH_OPENGL)
     list(APPEND 
         INCLUDE_FILES
             ${PROJECT_SOURCE_DIR}/include/mbgl/gfx/backend.hpp
-            ${PROJECT_SOURCE_DIR}/include/mbgl/gl/custom_layer.hpp
+            ${PROJECT_SOURCE_DIR}/include/mbgl/style/layers/custom_layer.hpp
-            ${PROJECT_SOURCE_DIR}/include/mbgl/gl/custom_layer_factory.hpp
+            ${PROJECT_SOURCE_DIR}/include/mbgl/layermanager/custom_layer_factory.hpp
             ${PROJECT_SOURCE_DIR}/include/mbgl/gl/renderable_resource.hpp
             ${PROJECT_SOURCE_DIR}/include/mbgl/gl/renderer_backend.hpp
             ${PROJECT_SOURCE_DIR}/include/mbgl/layermanager/location_indicator_layer_factory.hpp
@@ -1046,10 +1048,10 @@ if(MLN_WITH_OPENGL)
             ${PROJECT_SOURCE_DIR}/src/mbgl/gl/command_encoder.hpp
             ${PROJECT_SOURCE_DIR}/src/mbgl/gl/context.cpp
             ${PROJECT_SOURCE_DIR}/src/mbgl/gl/context.hpp
-            ${PROJECT_SOURCE_DIR}/src/mbgl/gl/custom_layer.cpp
+            ${PROJECT_SOURCE_DIR}/src/mbgl/style/layers/custom_layer.cpp
-            ${PROJECT_SOURCE_DIR}/src/mbgl/gl/custom_layer_factory.cpp
+            ${PROJECT_SOURCE_DIR}/src/mbgl/layermanager/custom_layer_factory.cpp
-            ${PROJECT_SOURCE_DIR}/src/mbgl/gl/custom_layer_impl.cpp
+            ${PROJECT_SOURCE_DIR}/src/mbgl/style/layers/custom_layer_impl.cpp
-            ${PROJECT_SOURCE_DIR}/src/mbgl/gl/custom_layer_impl.hpp
+            ${PROJECT_SOURCE_DIR}/src/mbgl/style/layers/custom_layer_impl.hpp
             ${PROJECT_SOURCE_DIR}/src/mbgl/gl/debugging_extension.cpp
             ${PROJECT_SOURCE_DIR}/src/mbgl/gl/debugging_extension.hpp
             ${PROJECT_SOURCE_DIR}/src/mbgl/gl/defines.hpp
@@ -1065,8 +1067,8 @@ if(MLN_WITH_OPENGL)
             ${PROJECT_SOURCE_DIR}/src/mbgl/gl/offscreen_texture.cpp
             ${PROJECT_SOURCE_DIR}/src/mbgl/gl/offscreen_texture.hpp
             ${PROJECT_SOURCE_DIR}/src/mbgl/gl/program.hpp
-            ${PROJECT_SOURCE_DIR}/src/mbgl/gl/render_custom_layer.cpp
+            ${PROJECT_SOURCE_DIR}/src/mbgl/renderer/layers/render_custom_layer.cpp
-            ${PROJECT_SOURCE_DIR}/src/mbgl/gl/render_custom_layer.hpp
+            ${PROJECT_SOURCE_DIR}/src/mbgl/renderer/layers/render_custom_layer.hpp
             ${PROJECT_SOURCE_DIR}/src/mbgl/gl/render_pass.cpp
             ${PROJECT_SOURCE_DIR}/src/mbgl/gl/render_pass.hpp
             ${PROJECT_SOURCE_DIR}/src/mbgl/gl/renderbuffer_resource.hpp

bazel/core.bzl

@@ -825,10 +825,10 @@ MLN_OPENGL_SOURCE = [
     "src/mbgl/gl/command_encoder.hpp",
     "src/mbgl/gl/context.cpp",
     "src/mbgl/gl/context.hpp",
-    "src/mbgl/gl/custom_layer.cpp",
+    "src/mbgl/style/layers/custom_layer.cpp",
-    "src/mbgl/gl/custom_layer_factory.cpp",
+    "src/mbgl/layermanager/custom_layer_factory.cpp",
-    "src/mbgl/gl/custom_layer_impl.cpp",
+    "src/mbgl/style/layers/custom_layer_impl.cpp",
-    "src/mbgl/gl/custom_layer_impl.hpp",
+    "src/mbgl/style/layers/custom_layer_impl.hpp",
     "src/mbgl/gl/debugging_extension.cpp",
     "src/mbgl/gl/debugging_extension.hpp",
     "src/mbgl/gl/defines.hpp",
@@ -844,8 +844,8 @@ MLN_OPENGL_SOURCE = [
     "src/mbgl/gl/offscreen_texture.cpp",
     "src/mbgl/gl/offscreen_texture.hpp",
     "src/mbgl/gl/program.hpp",
-    "src/mbgl/gl/render_custom_layer.cpp",
+    "src/mbgl/renderer/layers/render_custom_layer.cpp",
-    "src/mbgl/gl/render_custom_layer.hpp",
+    "src/mbgl/renderer/layers/render_custom_layer.hpp",
     "src/mbgl/gl/render_pass.cpp",
     "src/mbgl/gl/render_pass.hpp",
     "src/mbgl/gl/renderbuffer_resource.hpp",
@@ -876,8 +876,8 @@ MLN_OPENGL_SOURCE = [
 
 MLN_OPENGL_HEADERS = [
     "include/mbgl/gfx/backend.hpp",
-    "include/mbgl/gl/custom_layer.hpp",
+    "include/mbgl/style/layers/custom_layer.hpp",
-    "include/mbgl/gl/custom_layer_factory.hpp",
+    "include/mbgl/layermanager/custom_layer_factory.hpp",
     "include/mbgl/gl/renderable_resource.hpp",
     "include/mbgl/gl/renderer_backend.hpp",
     "include/mbgl/layermanager/location_indicator_layer_factory.hpp",
@@ -889,6 +889,7 @@ MLN_DRAWABLES_SOURCE = [
     "src/mbgl/gfx/drawable_builder.cpp",
     "src/mbgl/gfx/drawable_builder_impl.hpp",
     "src/mbgl/gfx/drawable_atlases_tweaker.cpp",
+    "src/mbgl/gfx/drawable_custom_layer_host_tweaker.cpp",
     "src/mbgl/gfx/image_drawable_data.hpp",
     "src/mbgl/gfx/line_drawable_data.hpp",
     "src/mbgl/gfx/symbol_drawable_data.hpp",
@@ -940,6 +941,7 @@ MLN_DRAWABLES_HEADERS = [
     "include/mbgl/gfx/drawable_builder.hpp",
     "include/mbgl/gfx/drawable_tweaker.hpp",
     "include/mbgl/gfx/drawable_atlases_tweaker.hpp",
+    "include/mbgl/gfx/drawable_custom_layer_host_tweaker.hpp",
     "include/mbgl/gfx/uniform_block.hpp",
     "include/mbgl/gfx/uniform_buffer.hpp",
     "include/mbgl/gfx/vertex_attribute.hpp",

include/mbgl/gfx/drawable.hpp

@@ -129,6 +129,10 @@ public:
     bool getIs3D() const { return is3D; }
     void setIs3D(bool value) { is3D = value; }
 
+    /// Is custom
+    bool getIsCustom() const { return isCustom; }
+    void setIsCustom(bool value) { isCustom = value; }
+
     /// The ID of the tile that this drawable represents, if any
     const std::optional<OverscaledTileID>& getTileID() const { return tileID; }
     void setTileID(const OverscaledTileID& value) { tileID = value; }
@@ -175,6 +179,7 @@ protected:
     bool enableColor = true;
     bool enableStencil = false;
     bool is3D = false;
+    bool isCustom = false;
     std::string name;
     util::SimpleIdentity uniqueID;
     gfx::ShaderProgramBasePtr shader;

include/mbgl/gfx/drawable_builder.hpp

@@ -32,7 +32,7 @@ public:
     virtual ~DrawableBuilder();
 
     /// Get the drawable we're currently working on, if any
-    const UniqueDrawable& getCurrentDrawable(bool createIfNone);
+    UniqueDrawable& getCurrentDrawable(bool createIfNone);
 
     /// Close the current drawable, using a new one for any further work
     void flush();

include/mbgl/gfx/drawable_custom_layer_host_tweaker.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <mbgl/gfx/drawable_tweaker.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
+
+#include <memory>
+#include <string>
+
+namespace mbgl {
+
+namespace gfx {
+
+class Drawable;
+
+/**
+ Tweaker that enables drawing a CustomLayer via their CustomLayerHost
+ */
+class DrawableCustomLayerHostTweaker : public gfx::DrawableTweaker {
+public:
+    DrawableCustomLayerHostTweaker(std::shared_ptr<style::CustomLayerHost> host_)
+        : host(host_) {}
+    ~DrawableCustomLayerHostTweaker() override = default;
+
+    void execute(Drawable&, const PaintParameters&) override;
+
+protected:
+    std::shared_ptr<style::CustomLayerHost> host;
+};
+
+} // namespace gfx
+} // namespace mbgl

include/mbgl/gfx/renderable.hpp

@@ -16,6 +16,8 @@ public:
     virtual ~RenderableResource() = default;
     RenderableResource(const RenderableResource&) = delete;
     RenderableResource& operator=(const RenderableResource&) = delete;
+
+    virtual void bind() = 0;
 };
 
 class Renderable {

platform/android/MapboxGLAndroidSDK/src/cpp/style/layers/custom_layer.hpp

@@ -1,8 +1,8 @@
 #pragma once
 
 #include <jni/jni.hpp>
-#include <mbgl/gl/custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
-#include <mbgl/gl/custom_layer_factory.hpp>
+#include <mbgl/layermanager/custom_layer_factory.hpp>
 #include "layer.hpp"
 
 namespace mbgl {

platform/android/src/example_custom_layer.cpp

@@ -1,7 +1,7 @@
 #include <GLES3/gl3.h>
 #include <android/log.h>
 #include <jni.h>
-#include <mbgl/gl/custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
 #include <sstream>
 
 // DEBUGGING

platform/darwin/src/MLNOpenGLStyleLayer.mm

@@ -6,7 +6,7 @@
 #import "MLNStyleLayer_Private.h"
 #import "MLNGeometry_Private.h"
 
-#include <mbgl/gl/custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
 #include <mbgl/math/wrap.hpp>
 
 class MLNOpenGLLayerHost;

platform/darwin/src/MLNOpenGLStyleLayer_Private.h

@@ -2,7 +2,7 @@
 
 #include "MLNStyleLayer_Private.h"
 
-#include <mbgl/gl/custom_layer_factory.hpp>
+#include <mbgl/layermanager/custom_layer_factory.hpp>
 
 namespace mbgl {
     

platform/default/src/mbgl/layermanager/layer_manager.cpp

@@ -2,9 +2,7 @@
 
 #include <mbgl/layermanager/background_layer_factory.hpp>
 #include <mbgl/layermanager/circle_layer_factory.hpp>
-#ifdef MBGL_RENDER_BACKEND_OPENGL
+#include <mbgl/layermanager/custom_layer_factory.hpp>
-#include <mbgl/gl/custom_layer_factory.hpp>
-#endif
 #include <mbgl/layermanager/fill_extrusion_layer_factory.hpp>
 #include <mbgl/layermanager/fill_layer_factory.hpp>
 #include <mbgl/layermanager/heatmap_layer_factory.hpp>

platform/ios/src/MLNMapView.mm

@@ -12,7 +12,7 @@
 #include <mbgl/style/style.hpp>
 #include <mbgl/style/image.hpp>
 #include <mbgl/style/transition_options.hpp>
-#include <mbgl/gl/custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
 #include <mbgl/renderer/renderer.hpp>
 #include <mbgl/math/wrap.hpp>
 #include <mbgl/util/client_options.hpp>

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;
+        const auto debugGroup = uploadPass.createDebugGroup(drawable.getName().c_str());
-        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);
 #endif
 
         drawableGL.upload(uploadPass);

src/mbgl/layermanager/custom_layer_factory.cpp

@@ -1,7 +1,7 @@
-#include <mbgl/gl/custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
-#include <mbgl/gl/custom_layer_factory.hpp>
+#include <mbgl/layermanager/custom_layer_factory.hpp>
-#include <mbgl/gl/custom_layer_impl.hpp>
+#include <mbgl/style/layers/custom_layer_impl.hpp>
-#include <mbgl/gl/render_custom_layer.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/style/layers/custom_layer_impl.hpp>
-#include <mbgl/gl/custom_layer_impl.hpp>
+#include <mbgl/renderer/layers/render_custom_layer.hpp>
-#include <mbgl/gl/render_custom_layer.hpp>
-#include <mbgl/gl/renderable_resource.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();
-
+        impl->preRender(*renderTree, updateParameters);
-#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->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) {
+void Renderer::Impl::preRender(const RenderTree& renderTree,
-    if (renderState == RenderState::Never) {
+                               [[maybe_unused]] const std::shared_ptr<UpdateParameters>& updateParameters) {
-        observer->onWillStartRenderingMap();
-    }
-
-    observer->onWillStartRenderingFrame();
-    const auto& renderTreeParameters = renderTree.getParameters();
-
     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/style/layers/custom_layer.hpp>
-#include <mbgl/gl/custom_layer_impl.hpp>
+#include <mbgl/style/layers/custom_layer_impl.hpp>
-#include <mbgl/gl/render_custom_layer.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/style/layers/custom_layer.hpp>
-#include <mbgl/gl/render_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>

test/api/custom_layer.test.cpp

@@ -1,7 +1,7 @@
 #include <mbgl/test/util.hpp>
 
 #include <mbgl/gfx/headless_frontend.hpp>
-#include <mbgl/gl/custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
 #include <mbgl/gl/defines.hpp>
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>

test/gl/context.test.cpp

@@ -3,7 +3,7 @@
 #include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/gfx/headless_frontend.hpp>
 #include <mbgl/gl/context.hpp>
-#include <mbgl/gl/custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
 #include <mbgl/gl/defines.hpp>
 #include <mbgl/gl/renderable_resource.hpp>
 #include <mbgl/map/map.hpp>

test/style/style_layer.test.cpp

@@ -1,5 +1,5 @@
-#include <mbgl/gl/custom_layer.hpp>
+#include <mbgl/style/layers/custom_layer.hpp>
-#include <mbgl/gl/custom_layer_impl.hpp>
+#include <mbgl/style/layers/custom_layer_impl.hpp>
 #include <mbgl/style/conversion/filter.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/expression/dsl.hpp>